Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-12-01 17:23:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
28f65f2044
gecko-dev/widget/gtk/gtk3drawing.cpp
lochang e889dbe685 Bug 1417751 - Implement a new value inner-spin-button to -moz-appearance on all platforms except Android. r=mats 
MozReview-Commit-ID: 7jpLCOWZA2x

--HG--
extra : rebase_source : d2a4d160d26e6f6996ed1cb3a673576236b8ef23
2017-11-29 10:43:13 +08:00

3059 lines
111 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* This file contains painting functions for each of the gtk2 widgets.
* Adapted from the gtkdrawing.c, and gtk+2.0 source.
*/
#include <gtk/gtk.h>
#include <gdk/gdkprivate.h>
#include <string.h>
#include "gtkdrawing.h"
#include "mozilla/Assertions.h"
#include "prinrval.h"
#include "WidgetStyleCache.h"
#include "nsDebug.h"
#include <math.h>
static gboolean checkbox_check_state;
static gboolean notebook_has_tab_gap;
static ScrollbarGTKMetrics sScrollbarMetrics[2];
static ToggleGTKMetrics sCheckboxMetrics;
static ToggleGTKMetrics sRadioMetrics;
#define ARROW_UP 0
#define ARROW_DOWN G_PI
#define ARROW_RIGHT G_PI_2
#define ARROW_LEFT (G_PI+G_PI_2)
#if !GTK_CHECK_VERSION(3,14,0)
#define GTK_STATE_FLAG_CHECKED (1 << 11)
#endif
static gint
moz_gtk_get_tab_thickness(GtkStyleContext *style);
static gint
moz_gtk_menu_item_paint(WidgetNodeType widget, cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state, GtkTextDirection direction);
static GtkBorder
GetMarginBorderPadding(GtkStyleContext* aStyle);
static void
InsetByMargin(GdkRectangle* rect, GtkStyleContext* style);
static void
moz_gtk_add_style_margin(GtkStyleContext* style,
gint* left, gint* top, gint* right, gint* bottom)
{
GtkBorder margin;
gtk_style_context_get_margin(style, GTK_STATE_FLAG_NORMAL, &margin);
*left += margin.left;
*right += margin.right;
*top += margin.top;
*bottom += margin.bottom;
}
static void
moz_gtk_add_style_border(GtkStyleContext* style,
gint* left, gint* top, gint* right, gint* bottom)
{
GtkBorder border;
gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL, &border);
*left += border.left;
*right += border.right;
*top += border.top;
*bottom += border.bottom;
}
static void
moz_gtk_add_style_padding(GtkStyleContext* style,
gint* left, gint* top, gint* right, gint* bottom)
{
GtkBorder padding;
gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
*left += padding.left;
*right += padding.right;
*top += padding.top;
*bottom += padding.bottom;
}
static void
moz_gtk_add_margin_border_padding(GtkStyleContext *style,
gint* left, gint* top,
gint* right, gint* bottom)
{
moz_gtk_add_style_margin(style, left, top, right, bottom);
moz_gtk_add_style_border(style, left, top, right, bottom);
moz_gtk_add_style_padding(style, left, top, right, bottom);
}
static void
moz_gtk_add_border_padding(GtkStyleContext *style,
gint* left, gint* top,
gint* right, gint* bottom)
{
moz_gtk_add_style_border(style, left, top, right, bottom);
moz_gtk_add_style_padding(style, left, top, right, bottom);
}
// GetStateFlagsFromGtkWidgetState() can be safely used for the specific
// GtkWidgets that set both prelight and active flags. For other widgets,
// either the GtkStateFlags or Gecko's GtkWidgetState need to be carefully
// adjusted to match GTK behavior. Although GTK sets insensitive and focus
// flags in the generic GtkWidget base class, GTK adds prelight and active
// flags only to widgets that are expected to demonstrate prelight or active
// states. This contrasts with HTML where any element may have :active and
// :hover states, and so Gecko's GtkStateFlags do not necessarily map to GTK
// flags. Failure to restrict the flags in the same way as GTK can cause
// generic CSS selectors from some themes to unintentionally match elements
// that are not expected to change appearance on hover or mouse-down.
static GtkStateFlags
GetStateFlagsFromGtkWidgetState(GtkWidgetState* state)
{
GtkStateFlags stateFlags = GTK_STATE_FLAG_NORMAL;
if (state->disabled)
stateFlags = GTK_STATE_FLAG_INSENSITIVE;
else {
if (state->depressed || state->active)
stateFlags = static_cast<GtkStateFlags>(stateFlags|GTK_STATE_FLAG_ACTIVE);
if (state->inHover)
stateFlags = static_cast<GtkStateFlags>(stateFlags|GTK_STATE_FLAG_PRELIGHT);
if (state->focused)
stateFlags = static_cast<GtkStateFlags>(stateFlags|GTK_STATE_FLAG_FOCUSED);
}
return stateFlags;
}
static GtkStateFlags
GetStateFlagsFromGtkTabFlags(GtkTabFlags flags)
{
return ((flags & MOZ_GTK_TAB_SELECTED) == 0) ?
GTK_STATE_FLAG_NORMAL : GTK_STATE_FLAG_ACTIVE;
}
gint
moz_gtk_init()
{
if (gtk_major_version > 3 ||
(gtk_major_version == 3 && gtk_minor_version >= 14))
checkbox_check_state = GTK_STATE_FLAG_CHECKED;
else
checkbox_check_state = GTK_STATE_FLAG_ACTIVE;
moz_gtk_refresh();
return MOZ_GTK_SUCCESS;
}
void
moz_gtk_refresh()
{
if (gtk_check_version(3, 12, 0) == nullptr &&
gtk_check_version(3, 20, 0) != nullptr)
{
// Deprecated for Gtk >= 3.20+
GtkStyleContext *style = GetStyleContext(MOZ_GTK_TAB_TOP);
gtk_style_context_get_style(style,
"has-tab-gap", &notebook_has_tab_gap, NULL);
}
else {
notebook_has_tab_gap = true;
}
sScrollbarMetrics[GTK_ORIENTATION_HORIZONTAL].initialized = false;
sScrollbarMetrics[GTK_ORIENTATION_VERTICAL].initialized = false;
sCheckboxMetrics.initialized = false;
sRadioMetrics.initialized = false;
}
gint
moz_gtk_checkbox_get_metrics(gint* indicator_size, gint* indicator_spacing)
{
gtk_widget_style_get(GetWidget(MOZ_GTK_CHECKBUTTON_CONTAINER),
"indicator_size", indicator_size,
"indicator_spacing", indicator_spacing,
NULL);
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_radio_get_metrics(gint* indicator_size, gint* indicator_spacing)
{
gtk_widget_style_get(GetWidget(MOZ_GTK_RADIOBUTTON_CONTAINER),
"indicator_size", indicator_size,
"indicator_spacing", indicator_spacing,
NULL);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_get_focus_outline_size(GtkStyleContext* style,
gint* focus_h_width, gint* focus_v_width)
{
GtkBorder border;
GtkBorder padding;
gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL, &border);
gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
*focus_h_width = border.left + padding.left;
*focus_v_width = border.top + padding.top;
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_get_focus_outline_size(gint* focus_h_width, gint* focus_v_width)
{
GtkStyleContext *style = GetStyleContext(MOZ_GTK_ENTRY);
moz_gtk_get_focus_outline_size(style, focus_h_width, focus_v_width);
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_menuitem_get_horizontal_padding(gint* horizontal_padding)
{
GtkStyleContext *style = GetStyleContext(MOZ_GTK_MENUITEM);
gtk_style_context_get_style(style,
"horizontal-padding", horizontal_padding,
nullptr);
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_checkmenuitem_get_horizontal_padding(gint* horizontal_padding)
{
GtkStyleContext *style = GetStyleContext(MOZ_GTK_CHECKMENUITEM);
gtk_style_context_get_style(style,
"horizontal-padding", horizontal_padding,
nullptr);
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_button_get_default_overflow(gint* border_top, gint* border_left,
gint* border_bottom, gint* border_right)
{
GtkBorder* default_outside_border;
GtkStyleContext *style = GetStyleContext(MOZ_GTK_BUTTON);
gtk_style_context_get_style(style,
"default-outside-border", &default_outside_border,
NULL);
if (default_outside_border) {
*border_top = default_outside_border->top;
*border_left = default_outside_border->left;
*border_bottom = default_outside_border->bottom;
*border_right = default_outside_border->right;
gtk_border_free(default_outside_border);
} else {
*border_top = *border_left = *border_bottom = *border_right = 0;
}
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_button_get_default_border(gint* border_top, gint* border_left,
gint* border_bottom, gint* border_right)
{
GtkBorder* default_border;
GtkStyleContext *style = GetStyleContext(MOZ_GTK_BUTTON);
gtk_style_context_get_style(style,
"default-border", &default_border,
NULL);
if (default_border) {
*border_top = default_border->top;
*border_left = default_border->left;
*border_bottom = default_border->bottom;
*border_right = default_border->right;
gtk_border_free(default_border);
} else {
/* see gtkbutton.c */
*border_top = *border_left = *border_bottom = *border_right = 1;
}
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_splitter_get_metrics(gint orientation, gint* size)
{
GtkStyleContext *style;
if (orientation == GTK_ORIENTATION_HORIZONTAL) {
style = GetStyleContext(MOZ_GTK_SPLITTER_HORIZONTAL);
} else {
style = GetStyleContext(MOZ_GTK_SPLITTER_VERTICAL);
}
gtk_style_context_get_style(style, "handle_size", size, NULL);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_window_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_WINDOW, direction);
gtk_style_context_save(style);
gtk_style_context_add_class(style, GTK_STYLE_CLASS_BACKGROUND);
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_style_context_restore(style);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_button_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkReliefStyle relief, GtkWidget* widget,
GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GtkStyleContext* style = gtk_widget_get_style_context(widget);
gint x = rect->x, y=rect->y, width=rect->width, height=rect->height;
gtk_widget_set_direction(widget, direction);
gtk_style_context_save(style);
gtk_style_context_set_state(style, state_flags);
if (state->isDefault && relief == GTK_RELIEF_NORMAL) {
/* handle default borders both outside and inside the button */
gint default_top, default_left, default_bottom, default_right;
moz_gtk_button_get_default_overflow(&default_top, &default_left,
&default_bottom, &default_right);
x -= default_left;
y -= default_top;
width += default_left + default_right;
height += default_top + default_bottom;
gtk_render_background(style, cr, x, y, width, height);
gtk_render_frame(style, cr, x, y, width, height);
moz_gtk_button_get_default_border(&default_top, &default_left,
&default_bottom, &default_right);
x += default_left;
y += default_top;
width -= (default_left + default_right);
height -= (default_top + default_bottom);
} else if (relief != GTK_RELIEF_NONE || state->depressed ||
(state_flags & GTK_STATE_FLAG_PRELIGHT)) {
/* the following line can trigger an assertion (Crux theme)
file ../../gdk/gdkwindow.c: line 1846 (gdk_window_clear_area):
assertion `GDK_IS_WINDOW (window)' failed */
gtk_render_background(style, cr, x, y, width, height);
gtk_render_frame(style, cr, x, y, width, height);
}
if (state->focused) {
GtkBorder border;
gtk_style_context_get_border(style, state_flags, &border);
x += border.left;
y += border.top;
width -= (border.left + border.right);
height -= (border.top + border.bottom);
gtk_render_focus(style, cr, x, y, width, height);
}
gtk_style_context_restore(style);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_header_bar_button_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkReliefStyle relief, GtkWidget* widget,
GtkTextDirection direction)
{
InsetByMargin(rect, gtk_widget_get_style_context(widget));
return moz_gtk_button_paint(cr, rect, state, relief, widget, direction);
}
static gint
moz_gtk_toggle_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
gboolean selected, gboolean inconsistent,
gboolean isradio, GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
gint x, y, width, height;
GtkStyleContext *style;
const ToggleGTKMetrics* metrics = GetToggleMetrics(isradio);
// Clamp the rect and paint it center aligned in the rect.
x = rect->x;
y = rect->y;
width = rect->width;
height = rect->height;
if (rect->width < rect->height) {
y = rect->y + (rect->height - rect->width) / 2;
height = rect->width;
}
if (rect->height < rect->width) {
x = rect->x + (rect->width - rect->height) / 2;
width = rect->height;
}
if (selected)
state_flags = static_cast<GtkStateFlags>(state_flags|checkbox_check_state);
if (inconsistent)
state_flags = static_cast<GtkStateFlags>(state_flags|GTK_STATE_FLAG_INCONSISTENT);
style = GetStyleContext(isradio ? MOZ_GTK_RADIOBUTTON : MOZ_GTK_CHECKBUTTON,
direction, state_flags);
if (gtk_check_version(3, 20, 0) == nullptr) {
gtk_render_background(style, cr, x, y, width, height);
gtk_render_frame(style, cr, x, y, width, height);
// Indicator is inset by the toggle's padding and border.
gint indicator_x = x + metrics->borderAndPadding.left;
gint indicator_y = y + metrics->borderAndPadding.top;
gint indicator_width = metrics->minSizeWithBorder.width -
metrics->borderAndPadding.left - metrics->borderAndPadding.right;
gint indicator_height = metrics->minSizeWithBorder.height -
metrics->borderAndPadding.top - metrics->borderAndPadding.bottom;
if (isradio) {
gtk_render_option(style, cr, indicator_x, indicator_y,
indicator_width, indicator_height);
} else {
gtk_render_check(style, cr, indicator_x, indicator_y,
indicator_width, indicator_height);
}
} else {
if (isradio) {
gtk_render_option(style, cr, x, y, width, height);
} else {
gtk_render_check(style, cr, x, y, width, height);
}
}
return MOZ_GTK_SUCCESS;
}
static gint
calculate_button_inner_rect(GtkWidget* button, GdkRectangle* rect,
GdkRectangle* inner_rect,
GtkTextDirection direction)
{
GtkStyleContext* style;
GtkBorder border;
GtkBorder padding = {0, 0, 0, 0};
style = gtk_widget_get_style_context(button);
/* This mirrors gtkbutton's child positioning */
gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL, &border);
gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
inner_rect->x = rect->x + border.left + padding.left;
inner_rect->y = rect->y + padding.top + border.top;
inner_rect->width = MAX(1, rect->width - padding.left -
padding.right - border.left * 2);
inner_rect->height = MAX(1, rect->height - padding.top -
padding.bottom - border.top * 2);
return MOZ_GTK_SUCCESS;
}
static gint
calculate_arrow_rect(GtkWidget* arrow, GdkRectangle* rect,
GdkRectangle* arrow_rect, GtkTextDirection direction)
{
/* defined in gtkarrow.c */
gfloat arrow_scaling = 0.7;
gfloat xalign, xpad;
gint extent;
gint mxpad, mypad;
gfloat mxalign, myalign;
GtkMisc* misc = GTK_MISC(arrow);
gtk_style_context_get_style(gtk_widget_get_style_context(arrow),
"arrow_scaling", &arrow_scaling, NULL);
gtk_misc_get_padding(misc, &mxpad, &mypad);
extent = MIN((rect->width - mxpad * 2),
(rect->height - mypad * 2)) * arrow_scaling;
gtk_misc_get_alignment(misc, &mxalign, &myalign);
xalign = direction == GTK_TEXT_DIR_LTR ? mxalign : 1.0 - mxalign;
xpad = mxpad + (rect->width - extent) * xalign;
arrow_rect->x = direction == GTK_TEXT_DIR_LTR ?
floor(rect->x + xpad) : ceil(rect->x + xpad);
arrow_rect->y = floor(rect->y + mypad +
((rect->height - extent) * myalign));
arrow_rect->width = arrow_rect->height = extent;
return MOZ_GTK_SUCCESS;
}
static MozGtkSize
GetMinContentBox(GtkStyleContext* style)
{
GtkStateFlags state_flags = gtk_style_context_get_state(style);
gint width, height;
gtk_style_context_get(style, state_flags,
"min-width", &width,
"min-height", &height,
nullptr);
return {width, height};
}
/**
* Get minimum widget size as sum of margin, padding, border and
* min-width/min-height.
*/
static void
moz_gtk_get_widget_min_size(WidgetNodeType aGtkWidgetType, int* width,
int* height)
{
GtkStyleContext* style = GetStyleContext(aGtkWidgetType);
GtkStateFlags state_flags = gtk_style_context_get_state(style);
gtk_style_context_get(style, state_flags,
"min-height", height,
"min-width", width,
nullptr);
GtkBorder border, padding, margin;
gtk_style_context_get_border(style, state_flags, &border);
gtk_style_context_get_padding(style, state_flags, &padding);
gtk_style_context_get_margin(style, state_flags, &margin);
*width += border.left + border.right + margin.left + margin.right +
padding.left + padding.right;
*height += border.top + border.bottom + margin.top + margin.bottom +
padding.top + padding.bottom;
}
static MozGtkSize
GetMinMarginBox(WidgetNodeType aNodeType)
{
gint width, height;
moz_gtk_get_widget_min_size(aNodeType, &width, &height);
return {width, height};
}
static void
Inset(GdkRectangle* rect, GtkBorder& aBorder)
{
MOZ_ASSERT(rect);
rect->x += aBorder.left;
rect->y += aBorder.top;
rect->width -= aBorder.left + aBorder.right;
rect->height -= aBorder.top + aBorder.bottom;
}
// Inset a rectangle by the margins specified in a style context.
static void
InsetByMargin(GdkRectangle* rect, GtkStyleContext* style)
{
MOZ_ASSERT(rect);
GtkBorder margin;
gtk_style_context_get_margin(style, gtk_style_context_get_state(style),
&margin);
Inset(rect, margin);
}
// Inset a rectangle by the border and padding specified in a style context.
static void
InsetByBorderPadding(GdkRectangle* rect, GtkStyleContext* style)
{
GtkStateFlags state = gtk_style_context_get_state(style);
GtkBorder padding, border;
gtk_style_context_get_padding(style, state, &padding);
Inset(rect, padding);
gtk_style_context_get_border(style, state, &border);
Inset(rect, border);
}
static gint
moz_gtk_scrollbar_button_paint(cairo_t *cr, const GdkRectangle* aRect,
GtkWidgetState* state,
GtkScrollbarButtonFlags flags,
GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GdkRectangle arrow_rect;
gdouble arrow_angle;
GtkStyleContext* style;
gint arrow_displacement_x, arrow_displacement_y;
GtkWidget *scrollbar =
GetWidget(flags & MOZ_GTK_STEPPER_VERTICAL ?
MOZ_GTK_SCROLLBAR_VERTICAL : MOZ_GTK_SCROLLBAR_HORIZONTAL);
gtk_widget_set_direction(scrollbar, direction);
if (flags & MOZ_GTK_STEPPER_VERTICAL) {
arrow_angle = (flags & MOZ_GTK_STEPPER_DOWN) ? ARROW_DOWN : ARROW_UP;
} else {
arrow_angle = (flags & MOZ_GTK_STEPPER_DOWN) ? ARROW_RIGHT : ARROW_LEFT;
}
style = gtk_widget_get_style_context(scrollbar);
gtk_style_context_save(style);
gtk_style_context_add_class(style, GTK_STYLE_CLASS_BUTTON);
gtk_style_context_set_state(style, state_flags);
if (arrow_angle == ARROW_RIGHT) {
gtk_style_context_add_class(style, GTK_STYLE_CLASS_RIGHT);
} else if (arrow_angle == ARROW_DOWN) {
gtk_style_context_add_class(style, GTK_STYLE_CLASS_BOTTOM);
} else if (arrow_angle == ARROW_LEFT) {
gtk_style_context_add_class(style, GTK_STYLE_CLASS_LEFT);
} else {
gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOP);
}
GdkRectangle rect = *aRect;
if (gtk_check_version(3,20,0) == nullptr) {
// The "trough-border" is not used since GTK 3.20. The stepper margin
// box occupies the full width of the "contents" gadget content box.
InsetByMargin(&rect, style);
} else {
// Scrollbar button has to be inset by trough_border because its DOM
// element is filling width of vertical scrollbar's track (or height
// in case of horizontal scrollbars).
GtkOrientation orientation = flags & MOZ_GTK_STEPPER_VERTICAL ?
GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL;
const auto& metrics = sScrollbarMetrics[orientation];
if (!metrics.initialized) {
NS_WARNING("Didn't measure before drawing?");
}
if (flags & MOZ_GTK_STEPPER_VERTICAL) {
rect.x += metrics.border.track.left;
rect.width = metrics.size.thumb.width;
} else {
rect.y += metrics.border.track.top;
rect.height = metrics.size.thumb.height;
}
}
gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height);
arrow_rect.width = rect.width / 2;
arrow_rect.height = rect.height / 2;
gfloat arrow_scaling;
gtk_style_context_get_style(style, "arrow-scaling", &arrow_scaling, NULL);
gdouble arrow_size = MIN(rect.width, rect.height) * arrow_scaling;
arrow_rect.x = rect.x + (rect.width - arrow_size) / 2;
arrow_rect.y = rect.y + (rect.height - arrow_size) / 2;
if (state_flags & GTK_STATE_FLAG_ACTIVE) {
gtk_style_context_get_style(style,
"arrow-displacement-x", &arrow_displacement_x,
"arrow-displacement-y", &arrow_displacement_y,
NULL);
arrow_rect.x += arrow_displacement_x;
arrow_rect.y += arrow_displacement_y;
}
gtk_render_arrow(style, cr, arrow_angle,
arrow_rect.x,
arrow_rect.y,
arrow_size);
gtk_style_context_restore(style);
return MOZ_GTK_SUCCESS;
}
static void
moz_gtk_update_scrollbar_style(GtkStyleContext* style,
WidgetNodeType widget,
GtkTextDirection direction)
{
if (widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) {
gtk_style_context_add_class(style, GTK_STYLE_CLASS_BOTTOM);
} else {
if (direction == GTK_TEXT_DIR_LTR) {
gtk_style_context_add_class(style, GTK_STYLE_CLASS_RIGHT);
gtk_style_context_remove_class(style, GTK_STYLE_CLASS_LEFT);
} else {
gtk_style_context_add_class(style, GTK_STYLE_CLASS_LEFT);
gtk_style_context_remove_class(style, GTK_STYLE_CLASS_RIGHT);
}
}
}
static void
moz_gtk_draw_styled_frame(GtkStyleContext* style, cairo_t *cr,
const GdkRectangle* aRect, bool drawFocus)
{
GdkRectangle rect = *aRect;
if (gtk_check_version(3, 6, 0) == nullptr) {
InsetByMargin(&rect, style);
}
gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height);
if (drawFocus) {
gtk_render_focus(style, cr,
rect.x, rect.y, rect.width, rect.height);
}
}
static gint
moz_gtk_scrollbar_trough_paint(WidgetNodeType widget,
cairo_t *cr, const GdkRectangle* aRect,
GtkWidgetState* state,
GtkTextDirection direction)
{
GdkRectangle rect = *aRect;
GtkStyleContext* style;
if (gtk_get_minor_version() >= 20) {
WidgetNodeType thumb = widget == MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL ?
MOZ_GTK_SCROLLBAR_THUMB_VERTICAL :
MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL;
MozGtkSize thumbSize = GetMinMarginBox(thumb);
style = GetStyleContext(widget, direction);
MozGtkSize trackSize = GetMinContentBox(style);
trackSize.Include(thumbSize);
trackSize += GetMarginBorderPadding(style);
// Gecko's trough |aRect| fills available breadth, but GTK's trough is
// centered in the contents_gadget. The centering here round left
// and up, like gtk_box_gadget_allocate_child().
if (widget == MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL) {
rect.x += (rect.width - trackSize.width)/2;
rect.width = trackSize.width;
} else {
rect.y += (rect.height - trackSize.height)/2;
rect.height = trackSize.height;
}
} else {
style = GetStyleContext(widget, direction);
}
moz_gtk_draw_styled_frame(style, cr, &rect, state->focused);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_scrollbar_paint(WidgetNodeType widget,
cairo_t *cr, const GdkRectangle* rect,
GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(widget, direction);
moz_gtk_update_scrollbar_style(style, widget, direction);
moz_gtk_draw_styled_frame(style, cr, rect, state->focused);
style = GetStyleContext((widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) ?
MOZ_GTK_SCROLLBAR_CONTENTS_HORIZONTAL :
MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL,
direction);
moz_gtk_draw_styled_frame(style, cr, rect, state->focused);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_scrollbar_thumb_paint(WidgetNodeType widget,
cairo_t *cr, const GdkRectangle* aRect,
GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GdkRectangle rect = *aRect;
GtkStyleContext* style = GetStyleContext(widget, direction, state_flags);
InsetByMargin(&rect, style);
gtk_render_slider(style, cr,
rect.x,
rect.y,
rect.width,
rect.height,
(widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) ?
GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_inner_spin_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPINBUTTON, direction,
GetStateFlagsFromGtkWidgetState(state));
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
/* hard code these values */
GdkRectangle arrow_rect;
arrow_rect.width = 6;
arrow_rect.height = 6;
// align spin to the left
arrow_rect.x = rect->x;
// up button
arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2 - 3;
gtk_render_arrow(style, cr, ARROW_UP,
arrow_rect.x, arrow_rect.y,
arrow_rect.width);
// down button
arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2 + 3;
gtk_render_arrow(style, cr, ARROW_DOWN,
arrow_rect.x, arrow_rect.y,
arrow_rect.width);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_spin_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPINBUTTON, direction);
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_spin_updown_paint(cairo_t *cr, GdkRectangle* rect,
gboolean isDown, GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPINBUTTON, direction,
GetStateFlagsFromGtkWidgetState(state));
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
/* hard code these values */
GdkRectangle arrow_rect;
arrow_rect.width = 6;
arrow_rect.height = 6;
arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
arrow_rect.y += isDown ? -1 : 1;
gtk_render_arrow(style, cr,
isDown ? ARROW_DOWN : ARROW_UP,
arrow_rect.x, arrow_rect.y,
arrow_rect.width);
return MOZ_GTK_SUCCESS;
}
/* See gtk_range_draw() for reference.
*/
static gint
moz_gtk_scale_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkOrientation flags, GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
gint x, y, width, height, min_width, min_height;
GtkStyleContext* style;
GtkBorder margin;
moz_gtk_get_scale_metrics(flags, &min_width, &min_height);
WidgetNodeType widget = (flags == GTK_ORIENTATION_HORIZONTAL) ?
MOZ_GTK_SCALE_TROUGH_HORIZONTAL :
MOZ_GTK_SCALE_TROUGH_VERTICAL;
style = GetStyleContext(widget, direction, state_flags);
gtk_style_context_get_margin(style, state_flags, &margin);
// Clamp the dimension perpendicular to the direction that the slider crosses
// to the minimum size.
if (flags == GTK_ORIENTATION_HORIZONTAL) {
width = rect->width - (margin.left + margin.right);
height = min_height - (margin.top + margin.bottom);
x = rect->x + margin.left;
y = rect->y + (rect->height - height)/2;
} else {
width = min_width - (margin.left + margin.right);
height = rect->height - (margin.top + margin.bottom);
x = rect->x + (rect->width - width)/2;
y = rect->y + margin.top;
}
gtk_render_background(style, cr, x, y, width, height);
gtk_render_frame(style, cr, x, y, width, height);
if (state->focused)
gtk_render_focus(style, cr,
rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_scale_thumb_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkOrientation flags, GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GtkStyleContext* style;
gint thumb_width, thumb_height, x, y;
/* determine the thumb size, and position the thumb in the center in the opposite axis
*/
if (flags == GTK_ORIENTATION_HORIZONTAL) {
moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_HORIZONTAL, &thumb_width, &thumb_height);
x = rect->x;
y = rect->y + (rect->height - thumb_height) / 2;
}
else {
moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_VERTICAL, &thumb_height, &thumb_width);
x = rect->x + (rect->width - thumb_width) / 2;
y = rect->y;
}
WidgetNodeType widget = (flags == GTK_ORIENTATION_HORIZONTAL) ?
MOZ_GTK_SCALE_THUMB_HORIZONTAL :
MOZ_GTK_SCALE_THUMB_VERTICAL;
style = GetStyleContext(widget, direction, state_flags);
gtk_render_slider(style, cr, x, y, thumb_width, thumb_height, flags);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_gripper_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_GRIPPER, direction,
GetStateFlagsFromGtkWidgetState(state));
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_hpaned_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state)
{
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_SPLITTER_SEPARATOR_HORIZONTAL,
GTK_TEXT_DIR_LTR,
GetStateFlagsFromGtkWidgetState(state));
gtk_render_handle(style, cr,
rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_vpaned_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state)
{
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_SPLITTER_SEPARATOR_VERTICAL,
GTK_TEXT_DIR_LTR,
GetStateFlagsFromGtkWidgetState(state));
gtk_render_handle(style, cr,
rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
// See gtk_entry_draw() for reference.
static gint
moz_gtk_entry_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkStyleContext* style)
{
gint x = rect->x, y = rect->y, width = rect->width, height = rect->height;
int draw_focus_outline_only = state->depressed; // NS_THEME_FOCUS_OUTLINE
if (draw_focus_outline_only) {
// Inflate the given 'rect' with the focus outline size.
gint h, v;
moz_gtk_get_focus_outline_size(style, &h, &v);
rect->x -= h;
rect->width += 2 * h;
rect->y -= v;
rect->height += 2 * v;
width = rect->width;
height = rect->height;
} else {
gtk_render_background(style, cr, x, y, width, height);
}
gtk_render_frame(style, cr, x, y, width, height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_text_view_paint(cairo_t *cr, GdkRectangle* aRect,
GtkWidgetState* state,
GtkTextDirection direction)
{
// GtkTextView and GtkScrolledWindow do not set active and prelight flags.
// The use of focus with MOZ_GTK_SCROLLED_WINDOW here is questionable
// because a parent widget will not have focus when its child GtkTextView
// has focus, but perhaps this may help identify a focused textarea with
// some themes as GtkTextView backgrounds do not typically render
// differently with focus.
GtkStateFlags state_flags =
state->disabled ? GTK_STATE_FLAG_INSENSITIVE :
state->focused ? GTK_STATE_FLAG_FOCUSED :
GTK_STATE_FLAG_NORMAL;
GtkStyleContext* style_frame =
GetStyleContext(MOZ_GTK_SCROLLED_WINDOW, direction, state_flags);
gtk_render_frame(style_frame, cr,
aRect->x, aRect->y, aRect->width, aRect->height);
GdkRectangle rect = *aRect;
InsetByBorderPadding(&rect, style_frame);
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_TEXT_VIEW, direction, state_flags);
gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
// There is a separate "text" window, which usually provides the
// background behind the text. However, this is transparent in Ambiance
// for GTK 3.20, in which case the MOZ_GTK_TEXT_VIEW background is
// visible.
style = GetStyleContext(MOZ_GTK_TEXT_VIEW_TEXT, direction, state_flags);
gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_treeview_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkTextDirection direction)
{
gint xthickness, ythickness;
GtkStyleContext *style;
GtkStyleContext *style_tree;
GtkStateFlags state_flags;
GtkBorder border;
/* only handle disabled and normal states, otherwise the whole background
* area will be painted differently with other states */
state_flags = state->disabled ? GTK_STATE_FLAG_INSENSITIVE : GTK_STATE_FLAG_NORMAL;
style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW, direction);
gtk_style_context_get_border(style, state_flags, &border);
xthickness = border.left;
ythickness = border.top;
style_tree = GetStyleContext(MOZ_GTK_TREEVIEW_VIEW, direction);
gtk_render_background(style_tree, cr,
rect->x + xthickness, rect->y + ythickness,
rect->width - 2 * xthickness,
rect->height - 2 * ythickness);
style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW, direction);
gtk_render_frame(style, cr,
rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_tree_header_cell_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
gboolean isSorted, GtkTextDirection direction)
{
moz_gtk_button_paint(cr, rect, state, GTK_RELIEF_NORMAL,
GetWidget(MOZ_GTK_TREE_HEADER_CELL), direction);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_tree_header_sort_arrow_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state, GtkArrowType arrow_type,
GtkTextDirection direction)
{
GdkRectangle arrow_rect;
gdouble arrow_angle;
GtkStyleContext* style;
/* hard code these values */
arrow_rect.width = 11;
arrow_rect.height = 11;
arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
style = GetStyleContext(MOZ_GTK_TREE_HEADER_SORTARROW, direction,
GetStateFlagsFromGtkWidgetState(state));
switch (arrow_type) {
case GTK_ARROW_LEFT:
arrow_angle = ARROW_LEFT;
break;
case GTK_ARROW_RIGHT:
arrow_angle = ARROW_RIGHT;
break;
case GTK_ARROW_DOWN:
arrow_angle = ARROW_DOWN;
break;
default:
arrow_angle = ARROW_UP;
break;
}
if (arrow_type != GTK_ARROW_NONE)
gtk_render_arrow(style, cr, arrow_angle,
arrow_rect.x, arrow_rect.y,
arrow_rect.width);
return MOZ_GTK_SUCCESS;
}
/* See gtk_expander_paint() for reference.
*/
static gint
moz_gtk_treeview_expander_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkExpanderStyle expander_state,
GtkTextDirection direction)
{
/* Because the frame we get is of the entire treeview, we can't get the precise
* event state of one expander, thus rendering hover and active feedback useless. */
GtkStateFlags state_flags = state->disabled ? GTK_STATE_FLAG_INSENSITIVE :
GTK_STATE_FLAG_NORMAL;
/* GTK_STATE_FLAG_ACTIVE controls expanded/colapsed state rendering
* in gtk_render_expander()
*/
if (expander_state == GTK_EXPANDER_EXPANDED)
state_flags = static_cast<GtkStateFlags>(state_flags|checkbox_check_state);
else
state_flags = static_cast<GtkStateFlags>(state_flags&~(checkbox_check_state));
GtkStyleContext *style = GetStyleContext(MOZ_GTK_TREEVIEW_EXPANDER,
direction, state_flags);
gtk_render_expander(style, cr,
rect->x,
rect->y,
rect->width,
rect->height);
return MOZ_GTK_SUCCESS;
}
/* See gtk_separator_draw() for reference.
*/
static gint
moz_gtk_combo_box_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkTextDirection direction)
{
GdkRectangle arrow_rect, real_arrow_rect;
gint separator_width;
gboolean wide_separators;
GtkStyleContext* style;
GtkRequisition arrow_req;
GtkWidget* comboBoxButton = GetWidget(MOZ_GTK_COMBOBOX_BUTTON);
GtkWidget* comboBoxArrow = GetWidget(MOZ_GTK_COMBOBOX_ARROW);
/* Also sets the direction on gComboBoxButtonWidget, which is then
* inherited by the separator and arrow */
moz_gtk_button_paint(cr, rect, state, GTK_RELIEF_NORMAL,
comboBoxButton, direction);
calculate_button_inner_rect(comboBoxButton, rect, &arrow_rect, direction);
/* Now arrow_rect contains the inner rect ; we want to correct the width
* to what the arrow needs (see gtk_combo_box_size_allocate) */
gtk_widget_get_preferred_size(comboBoxArrow, NULL, &arrow_req);
if (direction == GTK_TEXT_DIR_LTR)
arrow_rect.x += arrow_rect.width - arrow_req.width;
arrow_rect.width = arrow_req.width;
calculate_arrow_rect(comboBoxArrow,
&arrow_rect, &real_arrow_rect, direction);
style = GetStyleContext(MOZ_GTK_COMBOBOX_ARROW);
gtk_render_arrow(style, cr, ARROW_DOWN,
real_arrow_rect.x, real_arrow_rect.y,
real_arrow_rect.width);
/* If there is no separator in the theme, there's nothing left to do. */
GtkWidget* widget = GetWidget(MOZ_GTK_COMBOBOX_SEPARATOR);
if (!widget)
return MOZ_GTK_SUCCESS;
style = gtk_widget_get_style_context(widget);
gtk_style_context_get_style(style,
"wide-separators", &wide_separators,
"separator-width", &separator_width,
NULL);
if (wide_separators) {
if (direction == GTK_TEXT_DIR_LTR)
arrow_rect.x -= separator_width;
else
arrow_rect.x += arrow_rect.width;
gtk_render_frame(style, cr, arrow_rect.x, arrow_rect.y, separator_width, arrow_rect.height);
} else {
if (direction == GTK_TEXT_DIR_LTR) {
GtkBorder padding;
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
gtk_style_context_get_padding(style, state_flags, &padding);
arrow_rect.x -= padding.left;
}
else
arrow_rect.x += arrow_rect.width;
gtk_render_line(style, cr,
arrow_rect.x, arrow_rect.y,
arrow_rect.x, arrow_rect.y + arrow_rect.height);
}
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_arrow_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkArrowType arrow_type, GtkTextDirection direction)
{
GdkRectangle arrow_rect;
gdouble arrow_angle;
if (direction == GTK_TEXT_DIR_RTL) {
if (arrow_type == GTK_ARROW_LEFT) {
arrow_type = GTK_ARROW_RIGHT;
} else if (arrow_type == GTK_ARROW_RIGHT) {
arrow_type = GTK_ARROW_LEFT;
}
}
switch (arrow_type) {
case GTK_ARROW_LEFT:
arrow_angle = ARROW_LEFT;
break;
case GTK_ARROW_RIGHT:
arrow_angle = ARROW_RIGHT;
break;
case GTK_ARROW_DOWN:
arrow_angle = ARROW_DOWN;
break;
default:
arrow_angle = ARROW_UP;
break;
}
if (arrow_type == GTK_ARROW_NONE)
return MOZ_GTK_SUCCESS;
calculate_arrow_rect(GetWidget(MOZ_GTK_BUTTON_ARROW), rect, &arrow_rect,
direction);
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GtkStyleContext* style = GetStyleContext(MOZ_GTK_BUTTON_ARROW,
direction, state_flags);
gtk_render_arrow(style, cr, arrow_angle,
arrow_rect.x, arrow_rect.y, arrow_rect.width);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_combo_box_entry_button_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
gboolean input_focus,
GtkTextDirection direction)
{
gint x_displacement, y_displacement;
GdkRectangle arrow_rect, real_arrow_rect;
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GtkStyleContext* style;
GtkWidget* comboBoxEntry = GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON);
moz_gtk_button_paint(cr, rect, state, GTK_RELIEF_NORMAL,
comboBoxEntry, direction);
calculate_button_inner_rect(comboBoxEntry, rect, &arrow_rect, direction);
if (state_flags & GTK_STATE_FLAG_ACTIVE) {
style = gtk_widget_get_style_context(comboBoxEntry);
gtk_style_context_get_style(style,
"child-displacement-x", &x_displacement,
"child-displacement-y", &y_displacement,
NULL);
arrow_rect.x += x_displacement;
arrow_rect.y += y_displacement;
}
calculate_arrow_rect(GetWidget(MOZ_GTK_COMBOBOX_ENTRY_ARROW),
&arrow_rect, &real_arrow_rect, direction);
style = GetStyleContext(MOZ_GTK_COMBOBOX_ENTRY_ARROW);
gtk_render_arrow(style, cr, ARROW_DOWN,
real_arrow_rect.x, real_arrow_rect.y,
real_arrow_rect.width);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_container_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
WidgetNodeType widget_type,
GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GtkStyleContext* style = GetStyleContext(widget_type, direction,
state_flags);
/* this is for drawing a prelight box */
if (state_flags & GTK_STATE_FLAG_PRELIGHT) {
gtk_render_background(style, cr,
rect->x, rect->y, rect->width, rect->height);
}
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_toggle_label_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
gboolean isradio, GtkTextDirection direction)
{
if (!state->focused)
return MOZ_GTK_SUCCESS;
GtkStyleContext *style =
GetStyleContext(isradio ? MOZ_GTK_RADIOBUTTON_CONTAINER :
MOZ_GTK_CHECKBUTTON_CONTAINER,
direction,
GetStateFlagsFromGtkWidgetState(state));
gtk_render_focus(style, cr,
rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_toolbar_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLBAR, direction);
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
/* See _gtk_toolbar_paint_space_line() for reference.
*/
static gint
moz_gtk_toolbar_separator_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
gint separator_width;
gint paint_width;
gboolean wide_separators;
/* Defined as constants in GTK+ 2.10.14 */
const double start_fraction = 0.2;
const double end_fraction = 0.8;
GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLBAR);
gtk_style_context_get_style(style,
"wide-separators", &wide_separators,
"separator-width", &separator_width,
NULL);
style = GetStyleContext(MOZ_GTK_TOOLBAR_SEPARATOR, direction);
if (wide_separators) {
if (separator_width > rect->width)
separator_width = rect->width;
gtk_render_frame(style, cr,
rect->x + (rect->width - separator_width) / 2,
rect->y + rect->height * start_fraction,
separator_width,
rect->height * (end_fraction - start_fraction));
} else {
GtkBorder padding;
gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
paint_width = padding.left;
if (paint_width > rect->width)
paint_width = rect->width;
gtk_render_line(style, cr,
rect->x + (rect->width - paint_width) / 2,
rect->y + rect->height * start_fraction,
rect->x + (rect->width - paint_width) / 2,
rect->y + rect->height * end_fraction);
}
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_tooltip_paint(cairo_t *cr, const GdkRectangle* aRect,
GtkTextDirection direction)
{
// Tooltip widget is made in GTK3 as following tree:
// Tooltip window
// Horizontal Box
// Icon (not supported by Firefox)
// Label
// Each element can be fully styled by CSS of GTK theme.
// We have to draw all elements with appropriate offset and right dimensions.
// Tooltip drawing
GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLTIP, direction);
GdkRectangle rect = *aRect;
gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height);
gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height);
// Horizontal Box drawing
//
// The box element has hard-coded 6px margin-* GtkWidget properties, which
// are added between the window dimensions and the CSS margin box of the
// horizontal box. The frame of the tooltip window is drawn in the
// 6px margin.
// For drawing Horizontal Box we have to inset drawing area by that 6px
// plus its CSS margin.
GtkStyleContext* boxStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX, direction);
rect.x += 6;
rect.y += 6;
rect.width -= 12;
rect.height -= 12;
InsetByMargin(&rect, boxStyle);
gtk_render_background(boxStyle, cr, rect.x, rect.y, rect.width, rect.height);
gtk_render_frame(boxStyle, cr, rect.x, rect.y, rect.width, rect.height);
// Label drawing
InsetByBorderPadding(&rect, boxStyle);
GtkStyleContext* labelStyle =
GetStyleContext(MOZ_GTK_TOOLTIP_BOX_LABEL, direction);
moz_gtk_draw_styled_frame(labelStyle, cr, &rect, false);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_resizer_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_RESIZER, GTK_TEXT_DIR_LTR,
GetStateFlagsFromGtkWidgetState(state));
// Workaround unico not respecting the text direction for resizers.
// See bug 1174248.
cairo_save(cr);
if (direction == GTK_TEXT_DIR_RTL) {
cairo_matrix_t mat;
cairo_matrix_init_translate(&mat, 2 * rect->x + rect->width, 0);
cairo_matrix_scale(&mat, -1, 1);
cairo_transform(cr, &mat);
}
gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height);
cairo_restore(cr);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_frame_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_FRAME, direction);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_progressbar_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_PROGRESS_TROUGH,
direction);
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_progress_chunk_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction,
WidgetNodeType widget)
{
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_PROGRESS_CHUNK, direction);
if (widget == MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE ||
widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE) {
/**
* The bar's size and the bar speed are set depending of the progress'
* size. These could also be constant for all progress bars easily.
*/
gboolean vertical = (widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE);
/* The size of the dimension we are going to use for the animation. */
const gint progressSize = vertical ? rect->height : rect->width;
/* The bar is using a fifth of the element size, based on GtkProgressBar
* activity-blocks property. */
const gint barSize = MAX(1, progressSize / 5);
/* Represents the travel that has to be done for a complete cycle. */
const gint travel = 2 * (progressSize - barSize);
/* period equals to travel / pixelsPerMillisecond
* where pixelsPerMillisecond equals progressSize / 1000.0.
* This is equivalent to 1600. */
static const guint period = 1600;
const gint t = PR_IntervalToMilliseconds(PR_IntervalNow()) % period;
const gint dx = travel * t / period;
if (vertical) {
rect->y += (dx < travel / 2) ? dx : travel - dx;
rect->height = barSize;
} else {
rect->x += (dx < travel / 2) ? dx : travel - dx;
rect->width = barSize;
}
}
// gtk_render_activity was used to render progress chunks on GTK versions
// before 3.13.7, see bug 1173907.
if (!gtk_check_version(3, 13, 7)) {
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
} else {
gtk_render_activity(style, cr, rect->x, rect->y, rect->width, rect->height);
}
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_get_tab_thickness(GtkStyleContext *style)
{
if (!notebook_has_tab_gap)
return 0; /* tabs do not overdraw the tabpanel border with "no gap" style */
GtkBorder border;
gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL, &border);
if (border.top < 2)
return 2; /* some themes don't set ythickness correctly */
return border.top;
}
gint
moz_gtk_get_tab_thickness(WidgetNodeType aNodeType)
{
GtkStyleContext *style = GetStyleContext(aNodeType);
int thickness = moz_gtk_get_tab_thickness(style);
return thickness;
}
/* actual small tabs */
static gint
moz_gtk_tab_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkTabFlags flags, GtkTextDirection direction,
WidgetNodeType widget)
{
/* When the tab isn't selected, we just draw a notebook extension.
* When it is selected, we overwrite the adjacent border of the tabpanel
* touching the tab with a pierced border (called "the gap") to make the
* tab appear physically attached to the tabpanel; see details below. */
GtkStyleContext* style;
GdkRectangle tabRect;
GdkRectangle focusRect;
GdkRectangle backRect;
int initial_gap = 0;
bool isBottomTab = (widget == MOZ_GTK_TAB_BOTTOM);
style = GetStyleContext(widget, direction,
GetStateFlagsFromGtkTabFlags(flags));
tabRect = *rect;
if (flags & MOZ_GTK_TAB_FIRST) {
gtk_style_context_get_style(style, "initial-gap", &initial_gap, NULL);
tabRect.width -= initial_gap;
if (direction != GTK_TEXT_DIR_RTL) {
tabRect.x += initial_gap;
}
}
focusRect = backRect = tabRect;
if (notebook_has_tab_gap) {
if ((flags & MOZ_GTK_TAB_SELECTED) == 0) {
/* Only draw the tab */
gtk_render_extension(style, cr,
tabRect.x, tabRect.y, tabRect.width, tabRect.height,
isBottomTab ? GTK_POS_TOP : GTK_POS_BOTTOM );
} else {
/* Draw the tab and the gap
* We want the gap to be positioned exactly on the tabpanel top
* border; since tabbox.css may set a negative margin so that the tab
* frame rect already overlaps the tabpanel frame rect, we need to take
* that into account when drawing. To that effect, nsNativeThemeGTK
* passes us this negative margin (bmargin in the graphic below) in the
* lowest bits of |flags|. We use it to set gap_voffset, the distance
* between the top of the gap and the bottom of the tab (resp. the
* bottom of the gap and the top of the tab when we draw a bottom tab),
* while ensuring that the gap always touches the border of the tab,
* i.e. 0 <= gap_voffset <= gap_height, to avoid surprinsing results
* with big negative or positive margins.
* Here is a graphical explanation in the case of top tabs:
* ___________________________
* / \
* | T A B |
* ----------|. . . . . . . . . . . . . . .|----- top of tabpanel
* : ^ bmargin : ^
* : | (-negative margin, : |
* bottom : v passed in flags) : | gap_height
* of -> :.............................: | (the size of the
* the tab . part of the gap . | tabpanel top border)
* . outside of the tab . v
* ----------------------------------------------
*
* To draw the gap, we use gtk_render_frame_gap(), see comment in
* moz_gtk_tabpanels_paint(). This gap is made 3 * gap_height tall,
* which should suffice to ensure that the only visible border is the
* pierced one. If the tab is in the middle, we make the box_gap begin
* a bit to the left of the tab and end a bit to the right, adjusting
* the gap position so it still is under the tab, because we want the
* rendering of a gap in the middle of a tabpanel. This is the role of
* the gints gap_{l,r}_offset. On the contrary, if the tab is the
* first, we align the start border of the box_gap with the start
* border of the tab (left if LTR, right if RTL), by setting the
* appropriate offset to 0.*/
gint gap_loffset, gap_roffset, gap_voffset, gap_height;
/* Get height needed by the gap */
gap_height = moz_gtk_get_tab_thickness(style);
/* Extract gap_voffset from the first bits of flags */
gap_voffset = flags & MOZ_GTK_TAB_MARGIN_MASK;
if (gap_voffset > gap_height)
gap_voffset = gap_height;
/* Set gap_{l,r}_offset to appropriate values */
gap_loffset = gap_roffset = 20; /* should be enough */
if (flags & MOZ_GTK_TAB_FIRST) {
if (direction == GTK_TEXT_DIR_RTL)
gap_roffset = initial_gap;
else
gap_loffset = initial_gap;
}
GtkStyleContext* panelStyle =
GetStyleContext(MOZ_GTK_TABPANELS, direction);
if (isBottomTab) {
/* Draw the tab on bottom */
focusRect.y += gap_voffset;
focusRect.height -= gap_voffset;
gtk_render_extension(style, cr,
tabRect.x, tabRect.y + gap_voffset, tabRect.width,
tabRect.height - gap_voffset, GTK_POS_TOP);
backRect.y += (gap_voffset - gap_height);
backRect.height = gap_height;
/* Draw the gap; erase with background color before painting in
* case theme does not */
gtk_render_background(panelStyle, cr, backRect.x, backRect.y,
backRect.width, backRect.height);
cairo_save(cr);
cairo_rectangle(cr, backRect.x, backRect.y, backRect.width, backRect.height);
cairo_clip(cr);
gtk_render_frame_gap(panelStyle, cr,
tabRect.x - gap_loffset,
tabRect.y + gap_voffset - 3 * gap_height,
tabRect.width + gap_loffset + gap_roffset,
3 * gap_height, GTK_POS_BOTTOM,
gap_loffset, gap_loffset + tabRect.width);
cairo_restore(cr);
} else {
/* Draw the tab on top */
focusRect.height -= gap_voffset;
gtk_render_extension(style, cr,
tabRect.x, tabRect.y, tabRect.width,
tabRect.height - gap_voffset, GTK_POS_BOTTOM);
backRect.y += (tabRect.height - gap_voffset);
backRect.height = gap_height;
/* Draw the gap; erase with background color before painting in
* case theme does not */
gtk_render_background(panelStyle, cr, backRect.x, backRect.y,
backRect.width, backRect.height);
cairo_save(cr);
cairo_rectangle(cr, backRect.x, backRect.y, backRect.width, backRect.height);
cairo_clip(cr);
gtk_render_frame_gap(panelStyle, cr,
tabRect.x - gap_loffset,
tabRect.y + tabRect.height - gap_voffset,
tabRect.width + gap_loffset + gap_roffset,
3 * gap_height, GTK_POS_TOP,
gap_loffset, gap_loffset + tabRect.width);
cairo_restore(cr);
}
}
} else {
gtk_render_background(style, cr, tabRect.x, tabRect.y, tabRect.width, tabRect.height);
gtk_render_frame(style, cr, tabRect.x, tabRect.y, tabRect.width, tabRect.height);
}
if (state->focused) {
/* Paint the focus ring */
GtkBorder padding;
gtk_style_context_get_padding(style, GetStateFlagsFromGtkWidgetState(state), &padding);
focusRect.x += padding.left;
focusRect.width -= (padding.left + padding.right);
focusRect.y += padding.top;
focusRect.height -= (padding.top + padding.bottom);
gtk_render_focus(style, cr,
focusRect.x, focusRect.y, focusRect.width, focusRect.height);
}
return MOZ_GTK_SUCCESS;
}
/* tab area*/
static gint
moz_gtk_tabpanels_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_TABPANELS, direction);
gtk_render_background(style, cr, rect->x, rect->y,
rect->width, rect->height);
/*
* The gap size is not needed in moz_gtk_tabpanels_paint because
* the gap will be painted with the foreground tab in moz_gtk_tab_paint.
*
* However, if moz_gtk_tabpanels_paint just uses gtk_render_frame(),
* the theme will think that there are no tabs and may draw something
* different.Hence the trick of using two clip regions, and drawing the
* gap outside each clip region, to get the correct frame for
* a tabpanel with tabs.
*/
/* left side */
cairo_save(cr);
cairo_rectangle(cr, rect->x, rect->y,
rect->x + rect->width / 2,
rect->y + rect->height);
cairo_clip(cr);
gtk_render_frame_gap(style, cr,
rect->x, rect->y,
rect->width, rect->height,
GTK_POS_TOP, rect->width - 1, rect->width);
cairo_restore(cr);
/* right side */
cairo_save(cr);
cairo_rectangle(cr, rect->x + rect->width / 2, rect->y,
rect->x + rect->width,
rect->y + rect->height);
cairo_clip(cr);
gtk_render_frame_gap(style, cr,
rect->x, rect->y,
rect->width, rect->height,
GTK_POS_TOP, 0, 1);
cairo_restore(cr);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_tab_scroll_arrow_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkArrowType arrow_type,
GtkTextDirection direction)
{
GtkStyleContext* style;
gdouble arrow_angle;
gint arrow_size = MIN(rect->width, rect->height);
gint x = rect->x + (rect->width - arrow_size) / 2;
gint y = rect->y + (rect->height - arrow_size) / 2;
if (direction == GTK_TEXT_DIR_RTL) {
arrow_type = (arrow_type == GTK_ARROW_LEFT) ?
GTK_ARROW_RIGHT : GTK_ARROW_LEFT;
}
switch (arrow_type) {
case GTK_ARROW_LEFT:
arrow_angle = ARROW_LEFT;
break;
case GTK_ARROW_RIGHT:
arrow_angle = ARROW_RIGHT;
break;
case GTK_ARROW_DOWN:
arrow_angle = ARROW_DOWN;
break;
default:
arrow_angle = ARROW_UP;
break;
}
if (arrow_type != GTK_ARROW_NONE) {
style = GetStyleContext(MOZ_GTK_TAB_SCROLLARROW, direction,
GetStateFlagsFromGtkWidgetState(state));
gtk_render_arrow(style, cr, arrow_angle,
x, y, arrow_size);
}
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_menu_bar_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkStyleContext* style;
GtkWidget* widget = GetWidget(MOZ_GTK_MENUBAR);
gtk_widget_set_direction(widget, direction);
style = gtk_widget_get_style_context(widget);
gtk_style_context_save(style);
gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_style_context_restore(style);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_menu_popup_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkStyleContext* style;
GtkWidget* widget = GetWidget(MOZ_GTK_MENUPOPUP);
gtk_widget_set_direction(widget, direction);
// Draw a backing toplevel. This fixes themes that don't provide a menu
// background, and depend on the GtkMenu's implementation window to provide it.
moz_gtk_window_paint(cr, rect, direction);
style = gtk_widget_get_style_context(widget);
gtk_style_context_save(style);
gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENU);
gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
gtk_style_context_restore(style);
return MOZ_GTK_SUCCESS;
}
// See gtk_menu_item_draw() for reference.
static gint
moz_gtk_menu_separator_paint(cairo_t *cr, GdkRectangle* rect,
GtkTextDirection direction)
{
GtkWidgetState defaultState = { 0 };
moz_gtk_menu_item_paint(MOZ_GTK_MENUSEPARATOR, cr, rect,
&defaultState, direction);
if (gtk_get_minor_version() >= 20)
return MOZ_GTK_SUCCESS;
GtkStyleContext* style;
gboolean wide_separators;
gint separator_height;
gint x, y, w;
GtkBorder padding;
style = GetStyleContext(MOZ_GTK_MENUSEPARATOR, direction);
gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
x = rect->x;
y = rect->y;
w = rect->width;
gtk_style_context_save(style);
gtk_style_context_add_class(style, GTK_STYLE_CLASS_SEPARATOR);
gtk_style_context_get_style(style,
"wide-separators", &wide_separators,
"separator-height", &separator_height,
NULL);
if (wide_separators) {
gtk_render_frame(style, cr,
x + padding.left,
y + padding.top,
w - padding.left - padding.right,
separator_height);
} else {
gtk_render_line(style, cr,
x + padding.left,
y + padding.top,
x + w - padding.right - 1,
y + padding.top);
}
gtk_style_context_restore(style);
return MOZ_GTK_SUCCESS;
}
// See gtk_menu_item_draw() for reference.
static gint
moz_gtk_menu_item_paint(WidgetNodeType widget, cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state, GtkTextDirection direction)
{
gint x, y, w, h;
guint minorVersion = gtk_get_minor_version();
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
// GTK versions prior to 3.8 render the background and frame only when not
// a separator and in hover prelight.
if (minorVersion < 8 && (widget == MOZ_GTK_MENUSEPARATOR ||
!(state_flags & GTK_STATE_FLAG_PRELIGHT)))
return MOZ_GTK_SUCCESS;
GtkStyleContext* style = GetStyleContext(widget, direction, state_flags);
if (minorVersion < 6) {
// GTK+ 3.4 saves the style context and adds the menubar class to
// menubar children, but does each of these only when drawing, not
// during layout.
gtk_style_context_save(style);
if (widget == MOZ_GTK_MENUBARITEM) {
gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
}
}
x = rect->x;
y = rect->y;
w = rect->width;
h = rect->height;
gtk_render_background(style, cr, x, y, w, h);
gtk_render_frame(style, cr, x, y, w, h);
if (minorVersion < 6) {
gtk_style_context_restore(style);
}
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_menu_arrow_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GtkStyleContext* style = GetStyleContext(MOZ_GTK_MENUITEM,
direction, state_flags);
gtk_render_arrow(style, cr,
(direction == GTK_TEXT_DIR_LTR) ? ARROW_RIGHT : ARROW_LEFT,
rect->x, rect->y, rect->width);
return MOZ_GTK_SUCCESS;
}
// For reference, see gtk_check_menu_item_size_allocate() in GTK versions after
// 3.20 and gtk_real_check_menu_item_draw_indicator() in earlier versions.
static gint
moz_gtk_check_menu_item_paint(WidgetNodeType widgetType,
cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state,
gboolean checked, GtkTextDirection direction)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GtkStyleContext* style;
gint indicator_size, horizontal_padding;
gint x, y;
moz_gtk_menu_item_paint(MOZ_GTK_MENUITEM, cr, rect, state, direction);
if (checked) {
state_flags = static_cast<GtkStateFlags>(state_flags|checkbox_check_state);
}
bool pre_3_20 = gtk_get_minor_version() < 20;
gint offset;
style = GetStyleContext(widgetType, direction);
gtk_style_context_get_style(style,
"indicator-size", &indicator_size,
"horizontal-padding", &horizontal_padding,
NULL);
if (pre_3_20) {
GtkBorder padding;
gtk_style_context_get_padding(style, state_flags, &padding);
offset = horizontal_padding + padding.left + 2;
} else {
GdkRectangle r = { 0 };
InsetByMargin(&r, style);
InsetByBorderPadding(&r, style);
offset = r.x;
}
bool isRadio = (widgetType == MOZ_GTK_RADIOMENUITEM);
WidgetNodeType indicatorType = isRadio ? MOZ_GTK_RADIOMENUITEM_INDICATOR
: MOZ_GTK_CHECKMENUITEM_INDICATOR;
style = GetStyleContext(indicatorType, direction, state_flags);
if (direction == GTK_TEXT_DIR_RTL) {
x = rect->width - indicator_size - offset;
}
else {
x = rect->x + offset;
}
y = rect->y + (rect->height - indicator_size) / 2;
if (!pre_3_20) {
gtk_render_background(style, cr, x, y, indicator_size, indicator_size);
gtk_render_frame(style, cr, x, y, indicator_size, indicator_size);
}
if (isRadio) {
gtk_render_option(style, cr, x, y, indicator_size, indicator_size);
} else {
gtk_render_check(style, cr, x, y, indicator_size, indicator_size);
}
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_info_bar_paint(cairo_t *cr, GdkRectangle* rect,
GtkWidgetState* state)
{
GtkStyleContext *style =
GetStyleContext(MOZ_GTK_INFO_BAR, GTK_TEXT_DIR_LTR,
GetStateFlagsFromGtkWidgetState(state));
gtk_render_background(style, cr, rect->x, rect->y, rect->width,
rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static gint
moz_gtk_header_bar_paint(WidgetNodeType widgetType,
cairo_t *cr, GdkRectangle* rect, GtkWidgetState* state)
{
GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
GtkStyleContext *style = GetStyleContext(widgetType, GTK_TEXT_DIR_LTR,
state_flags);
InsetByMargin(rect, style);
gtk_render_background(style, cr, rect->x, rect->y, rect->width,
rect->height);
gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static GtkBorder
GetMarginBorderPadding(GtkStyleContext* aStyle)
{
gint left = 0, top = 0, right = 0, bottom = 0;
moz_gtk_add_margin_border_padding(aStyle, &left, &top, &right, &bottom);
// narrowing conversions to gint16:
GtkBorder result;
result.left = left;
result.right = right;
result.top = top;
result.bottom = bottom;
return result;
}
gint
moz_gtk_get_widget_border(WidgetNodeType widget, gint* left, gint* top,
gint* right, gint* bottom,
// NOTE: callers depend on direction being used
// only for MOZ_GTK_DROPDOWN widgets.
GtkTextDirection direction)
{
GtkWidget* w;
GtkStyleContext* style;
*left = *top = *right = *bottom = 0;
switch (widget) {
case MOZ_GTK_BUTTON:
case MOZ_GTK_TOOLBAR_BUTTON:
{
style = GetStyleContext(MOZ_GTK_BUTTON);
*left = *top = *right = *bottom =
gtk_container_get_border_width(GTK_CONTAINER(GetWidget(MOZ_GTK_BUTTON)));
if (widget == MOZ_GTK_TOOLBAR_BUTTON) {
gtk_style_context_save(style);
gtk_style_context_add_class(style, "image-button");
}
moz_gtk_add_style_padding(style, left, top, right, bottom);
if (widget == MOZ_GTK_TOOLBAR_BUTTON)
gtk_style_context_restore(style);
moz_gtk_add_style_border(style, left, top, right, bottom);
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_ENTRY:
{
style = GetStyleContext(MOZ_GTK_ENTRY);
// XXX: Subtract 1 pixel from the padding to account for the default
// padding in forms.css. See bug 1187385.
*left = *top = *right = *bottom = -1;
moz_gtk_add_border_padding(style, left, top, right, bottom);
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_TEXT_VIEW:
case MOZ_GTK_TREEVIEW:
{
style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW);
moz_gtk_add_style_border(style, left, top, right, bottom);
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_TREE_HEADER_CELL:
{
/* A Tree Header in GTK is just a different styled button
* It must be placed in a TreeView for getting the correct style
* assigned.
* That is why the following code is the same as for MOZ_GTK_BUTTON.
* */
*left = *top = *right = *bottom =
gtk_container_get_border_width(GTK_CONTAINER(
GetWidget(MOZ_GTK_TREE_HEADER_CELL)));
style = GetStyleContext(MOZ_GTK_TREE_HEADER_CELL);
moz_gtk_add_border_padding(style, left, top, right, bottom);
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_TREE_HEADER_SORTARROW:
w = GetWidget(MOZ_GTK_TREE_HEADER_SORTARROW);
break;
case MOZ_GTK_DROPDOWN_ENTRY:
w = GetWidget(MOZ_GTK_COMBOBOX_ENTRY_TEXTAREA);
break;
case MOZ_GTK_DROPDOWN_ARROW:
w = GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON);
break;
case MOZ_GTK_DROPDOWN:
{
/* We need to account for the arrow on the dropdown, so text
* doesn't come too close to the arrow, or in some cases spill
* into the arrow. */
gboolean wide_separators;
gint separator_width;
GtkRequisition arrow_req;
GtkBorder border;
*left = *top = *right = *bottom =
gtk_container_get_border_width(GTK_CONTAINER(
GetWidget(MOZ_GTK_COMBOBOX_BUTTON)));
style = GetStyleContext(MOZ_GTK_COMBOBOX_BUTTON);
moz_gtk_add_border_padding(style, left, top, right, bottom);
/* If there is no separator, don't try to count its width. */
separator_width = 0;
GtkWidget* comboBoxSeparator = GetWidget(MOZ_GTK_COMBOBOX_SEPARATOR);
if (comboBoxSeparator) {
style = gtk_widget_get_style_context(comboBoxSeparator);
gtk_style_context_get_style(style,
"wide-separators", &wide_separators,
"separator-width", &separator_width,
NULL);
if (!wide_separators) {
gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL,
&border);
separator_width = border.left;
}
}
gtk_widget_get_preferred_size(GetWidget(MOZ_GTK_COMBOBOX_ARROW),
NULL, &arrow_req);
if (direction == GTK_TEXT_DIR_RTL)
*left += separator_width + arrow_req.width;
else
*right += separator_width + arrow_req.width;
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_TABPANELS:
w = GetWidget(MOZ_GTK_TABPANELS);
break;
case MOZ_GTK_PROGRESSBAR:
w = GetWidget(MOZ_GTK_PROGRESSBAR);
break;
case MOZ_GTK_SPINBUTTON_ENTRY:
case MOZ_GTK_SPINBUTTON_UP:
case MOZ_GTK_SPINBUTTON_DOWN:
w = GetWidget(MOZ_GTK_SPINBUTTON);
break;
case MOZ_GTK_SCALE_HORIZONTAL:
case MOZ_GTK_SCALE_VERTICAL:
w = GetWidget(widget);
break;
case MOZ_GTK_FRAME:
w = GetWidget(MOZ_GTK_FRAME);
break;
case MOZ_GTK_CHECKBUTTON_CONTAINER:
case MOZ_GTK_RADIOBUTTON_CONTAINER:
{
w = GetWidget(widget);
style = gtk_widget_get_style_context(w);
*left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(w));
moz_gtk_add_border_padding(style,
left, top, right, bottom);
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_MENUPOPUP:
w = GetWidget(MOZ_GTK_MENUPOPUP);
break;
case MOZ_GTK_MENUBARITEM:
case MOZ_GTK_MENUITEM:
case MOZ_GTK_CHECKMENUITEM:
case MOZ_GTK_RADIOMENUITEM:
{
// Bug 1274143 for MOZ_GTK_MENUBARITEM
WidgetNodeType type =
widget == MOZ_GTK_MENUBARITEM ? MOZ_GTK_MENUITEM : widget;
style = GetStyleContext(type);
if (gtk_get_minor_version() < 20) {
moz_gtk_add_style_padding(style, left, top, right, bottom);
} else {
moz_gtk_add_margin_border_padding(style,
left, top, right, bottom);
}
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_INFO_BAR:
w = GetWidget(MOZ_GTK_INFO_BAR);
break;
case MOZ_GTK_TOOLTIP:
{
// In GTK 3 there are 6 pixels of additional margin around the box.
// See details there:
// https://github.com/GNOME/gtk/blob/5ea69a136bd7e4970b3a800390e20314665aaed2/gtk/ui/gtktooltipwindow.ui#L11
*left = *right = *top = *bottom = 6;
// We also need to add margin/padding/borders from Tooltip content.
// Tooltip contains horizontal box, where icon and label is put.
// We ignore icon as long as we don't have support for it.
GtkStyleContext* boxStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX);
moz_gtk_add_margin_border_padding(boxStyle,
left, top, right, bottom);
GtkStyleContext* labelStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX_LABEL);
moz_gtk_add_margin_border_padding(labelStyle,
left, top, right, bottom);
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_HEADER_BAR:
case MOZ_GTK_HEADER_BAR_MAXIMIZED:
{
style = GetStyleContext(widget);
moz_gtk_add_border_padding(style, left, top, right, bottom);
return MOZ_GTK_SUCCESS;
}
case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE:
case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE:
case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE:
{
style = GetStyleContext(widget);
moz_gtk_add_margin_border_padding(style, left, top, right, bottom);
return MOZ_GTK_SUCCESS;
}
/* These widgets have no borders, since they are not containers. */
case MOZ_GTK_CHECKBUTTON_LABEL:
case MOZ_GTK_RADIOBUTTON_LABEL:
case MOZ_GTK_SPLITTER_HORIZONTAL:
case MOZ_GTK_SPLITTER_VERTICAL:
case MOZ_GTK_CHECKBUTTON:
case MOZ_GTK_RADIOBUTTON:
case MOZ_GTK_SCROLLBAR_BUTTON:
case MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL:
case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL:
case MOZ_GTK_SCALE_THUMB_HORIZONTAL:
case MOZ_GTK_SCALE_THUMB_VERTICAL:
case MOZ_GTK_GRIPPER:
case MOZ_GTK_PROGRESS_CHUNK:
case MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE:
case MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE:
case MOZ_GTK_TREEVIEW_EXPANDER:
case MOZ_GTK_TOOLBAR_SEPARATOR:
case MOZ_GTK_MENUSEPARATOR:
/* These widgets have no borders.*/
case MOZ_GTK_INNER_SPIN_BUTTON:
case MOZ_GTK_SPINBUTTON:
case MOZ_GTK_WINDOW:
case MOZ_GTK_RESIZER:
case MOZ_GTK_MENUARROW:
case MOZ_GTK_TOOLBARBUTTON_ARROW:
case MOZ_GTK_TOOLBAR:
case MOZ_GTK_MENUBAR:
case MOZ_GTK_TAB_SCROLLARROW:
return MOZ_GTK_SUCCESS;
default:
g_warning("Unsupported widget type: %d", widget);
return MOZ_GTK_UNKNOWN_WIDGET;
}
/* TODO - we're still missing some widget implementations */
if (w) {
moz_gtk_add_style_border(gtk_widget_get_style_context(w),
left, top, right, bottom);
}
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_get_tab_border(gint* left, gint* top, gint* right, gint* bottom,
GtkTextDirection direction, GtkTabFlags flags,
WidgetNodeType widget)
{
GtkStyleContext* style = GetStyleContext(widget, direction,
GetStateFlagsFromGtkTabFlags(flags));
*left = *top = *right = *bottom = 0;
moz_gtk_add_style_padding(style, left, top, right, bottom);
// Gtk >= 3.20 does not use those styles
if (gtk_check_version(3, 20, 0) != nullptr) {
int tab_curvature;
gtk_style_context_get_style(style, "tab-curvature", &tab_curvature, NULL);
*left += tab_curvature;
*right += tab_curvature;
if (flags & MOZ_GTK_TAB_FIRST) {
int initial_gap = 0;
gtk_style_context_get_style(style, "initial-gap", &initial_gap, NULL);
if (direction == GTK_TEXT_DIR_RTL)
*right += initial_gap;
else
*left += initial_gap;
}
} else {
GtkBorder margin;
gtk_style_context_get_margin(style, GTK_STATE_FLAG_NORMAL, &margin);
*left += margin.left;
*right += margin.right;
if (flags & MOZ_GTK_TAB_FIRST) {
style = GetStyleContext(MOZ_GTK_NOTEBOOK_HEADER, direction);
gtk_style_context_get_margin(style, GTK_STATE_FLAG_NORMAL, &margin);
*left += margin.left;
*right += margin.right;
}
}
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_get_combo_box_entry_button_size(gint* width, gint* height)
{
/*
* We get the requisition of the drop down button, which includes
* all padding, border and focus line widths the button uses,
* as well as the minimum arrow size and its padding
* */
GtkRequisition requisition;
gtk_widget_get_preferred_size(GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON),
NULL, &requisition);
*width = requisition.width;
*height = requisition.height;
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_get_tab_scroll_arrow_size(gint* width, gint* height)
{
gint arrow_size;
GtkStyleContext *style = GetStyleContext(MOZ_GTK_TABPANELS);
gtk_style_context_get_style(style,
"scroll-arrow-hlength", &arrow_size,
NULL);
*height = *width = arrow_size;
return MOZ_GTK_SUCCESS;
}
void
moz_gtk_get_arrow_size(WidgetNodeType widgetType, gint* width, gint* height)
{
GtkWidget* widget;
switch (widgetType) {
case MOZ_GTK_DROPDOWN:
widget = GetWidget(MOZ_GTK_COMBOBOX_ARROW);
break;
default:
widget = GetWidget(MOZ_GTK_BUTTON_ARROW);
break;
}
GtkRequisition requisition;
gtk_widget_get_preferred_size(widget, NULL, &requisition);
*width = requisition.width;
*height = requisition.height;
}
gint
moz_gtk_get_toolbar_separator_width(gint* size)
{
gboolean wide_separators;
gint separator_width;
GtkBorder border;
GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLBAR);
gtk_style_context_get_style(style,
"space-size", size,
"wide-separators", &wide_separators,
"separator-width", &separator_width,
NULL);
/* Just in case... */
gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL, &border);
*size = MAX(*size, (wide_separators ? separator_width : border.left));
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_get_expander_size(gint* size)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_EXPANDER);
gtk_style_context_get_style(style,
"expander-size", size,
NULL);
return MOZ_GTK_SUCCESS;
}
gint
moz_gtk_get_treeview_expander_size(gint* size)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_TREEVIEW);
gtk_style_context_get_style(style, "expander-size", size, NULL);
return MOZ_GTK_SUCCESS;
}
// See gtk_menu_item_draw() for reference.
gint
moz_gtk_get_menu_separator_height(gint *size)
{
gboolean wide_separators;
gint separator_height;
GtkBorder padding;
GtkStyleContext* style = GetStyleContext(MOZ_GTK_MENUSEPARATOR);
gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
gtk_style_context_save(style);
gtk_style_context_add_class(style, GTK_STYLE_CLASS_SEPARATOR);
gtk_style_context_get_style(style,
"wide-separators", &wide_separators,
"separator-height", &separator_height,
NULL);
gtk_style_context_restore(style);
*size = padding.top + padding.bottom;
*size += (wide_separators) ? separator_height : 1;
return MOZ_GTK_SUCCESS;
}
void
moz_gtk_get_entry_min_height(gint* height)
{
GtkStyleContext* style = GetStyleContext(MOZ_GTK_ENTRY);
if (!gtk_check_version(3, 20, 0)) {
gtk_style_context_get(style, gtk_style_context_get_state(style),
"min-height", height,
nullptr);
} else {
*height = 0;
}
GtkBorder border;
GtkBorder padding;
gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL, &border);
gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
*height += (border.top + border.bottom + padding.top + padding.bottom);
}
void
moz_gtk_get_scale_metrics(GtkOrientation orient, gint* scale_width,
gint* scale_height)
{
if (gtk_check_version(3, 20, 0) != nullptr) {
WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL) ?
MOZ_GTK_SCALE_HORIZONTAL :
MOZ_GTK_SCALE_VERTICAL;
gint thumb_length, thumb_height, trough_border;
moz_gtk_get_scalethumb_metrics(orient, &thumb_length, &thumb_height);
GtkStyleContext* style = GetStyleContext(widget);
gtk_style_context_get_style(style, "trough-border", &trough_border, NULL);
if (orient == GTK_ORIENTATION_HORIZONTAL) {
*scale_width = thumb_length + trough_border * 2;
*scale_height = thumb_height + trough_border * 2;
} else {
*scale_width = thumb_height + trough_border * 2;
*scale_height = thumb_length + trough_border * 2;
}
} else {
WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL) ?
MOZ_GTK_SCALE_TROUGH_HORIZONTAL :
MOZ_GTK_SCALE_TROUGH_VERTICAL;
moz_gtk_get_widget_min_size(widget, scale_width, scale_height);
}
}
gint
moz_gtk_get_scalethumb_metrics(GtkOrientation orient, gint* thumb_length, gint* thumb_height)
{
if (gtk_check_version(3, 20, 0) != nullptr) {
WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL) ?
MOZ_GTK_SCALE_HORIZONTAL:
MOZ_GTK_SCALE_VERTICAL;
GtkStyleContext* style = GetStyleContext(widget);
gtk_style_context_get_style(style,
"slider_length", thumb_length,
"slider_width", thumb_height,
NULL);
} else {
WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL) ?
MOZ_GTK_SCALE_THUMB_HORIZONTAL:
MOZ_GTK_SCALE_THUMB_VERTICAL;
GtkStyleContext* style = GetStyleContext(widget);
gint min_width, min_height;
GtkStateFlags state = gtk_style_context_get_state(style);
gtk_style_context_get(style, state,
"min-width", &min_width,
"min-height", &min_height,
nullptr);
GtkBorder margin;
gtk_style_context_get_margin(style, state, &margin);
gint margin_width = margin.left + margin.right;
gint margin_height = margin.top + margin.bottom;
// Negative margin of slider element also determines its minimal size
// so use bigger of those two values.
if (min_width < -margin_width)
min_width = -margin_width;
if (min_height < -margin_height)
min_height = -margin_height;
*thumb_length = min_width;
*thumb_height = min_height;
}
return MOZ_GTK_SUCCESS;
}
static MozGtkSize
SizeFromLengthAndBreadth(GtkOrientation aOrientation,
gint aLength, gint aBreadth)
{
return aOrientation == GTK_ORIENTATION_HORIZONTAL ?
MozGtkSize({aLength, aBreadth}) : MozGtkSize({aBreadth, aLength});
}
const ToggleGTKMetrics*
GetToggleMetrics(bool isRadio)
{
ToggleGTKMetrics* metrics;
if (isRadio) {
metrics = &sRadioMetrics;
} else {
metrics = &sCheckboxMetrics;
}
if (metrics->initialized)
return metrics;
metrics->initialized = true;
if (gtk_check_version(3,20,0) == nullptr) {
GtkStyleContext* style;
if (isRadio) {
style = GetStyleContext(MOZ_GTK_RADIOBUTTON);
} else {
style = GetStyleContext(MOZ_GTK_CHECKBUTTON);
}
GtkStateFlags state_flags = gtk_style_context_get_state(style);
gtk_style_context_get(style, state_flags,
"min-height",&(metrics->minSizeWithBorder.height),
"min-width", &(metrics->minSizeWithBorder.width),
nullptr);
// Fallback to indicator size if min dimensions are zero
if (metrics->minSizeWithBorder.height == 0 ||
metrics->minSizeWithBorder.width == 0) {
gint indicator_size;
gtk_widget_style_get(GetWidget(MOZ_GTK_CHECKBUTTON_CONTAINER),
"indicator_size", &indicator_size, nullptr);
if (metrics->minSizeWithBorder.height == 0) {
metrics->minSizeWithBorder.height = indicator_size;
}
if (metrics->minSizeWithBorder.width == 0) {
metrics->minSizeWithBorder.width = indicator_size;
}
}
GtkBorder border, padding;
gtk_style_context_get_border(style, state_flags, &border);
gtk_style_context_get_padding(style, state_flags, &padding);
metrics->borderAndPadding.left = border.left + padding.left;
metrics->borderAndPadding.right = border.right + padding.right;
metrics->borderAndPadding.top = border.top + padding.top;
metrics->borderAndPadding.bottom = border.bottom + padding.bottom;
metrics->minSizeWithBorder.width += metrics->borderAndPadding.left +
metrics->borderAndPadding.right;
metrics->minSizeWithBorder.height += metrics->borderAndPadding.top +
metrics->borderAndPadding.bottom;
} else {
gint indicator_size, indicator_spacing;
gtk_widget_style_get(GetWidget(MOZ_GTK_CHECKBUTTON_CONTAINER),
"indicator_size", &indicator_size,
"indicator_spacing", &indicator_spacing,
nullptr);
metrics->minSizeWithBorder.width =
metrics->minSizeWithBorder.height = indicator_size;
}
return metrics;
}
const ScrollbarGTKMetrics*
GetScrollbarMetrics(GtkOrientation aOrientation)
{
auto metrics = &sScrollbarMetrics[aOrientation];
if (metrics->initialized)
return metrics;
metrics->initialized = true;
WidgetNodeType scrollbar = aOrientation == GTK_ORIENTATION_HORIZONTAL ?
MOZ_GTK_SCROLLBAR_HORIZONTAL : MOZ_GTK_SCROLLBAR_VERTICAL;
gboolean backward, forward, secondary_backward, secondary_forward;
GtkStyleContext* style = GetStyleContext(scrollbar);
gtk_style_context_get_style(style,
"has-backward-stepper", &backward,
"has-forward-stepper", &forward,
"has-secondary-backward-stepper",
&secondary_backward,
"has-secondary-forward-stepper",
&secondary_forward, nullptr);
bool hasButtons =
backward || forward || secondary_backward || secondary_forward;
if (gtk_get_minor_version() < 20) {
gint slider_width, trough_border, stepper_size, min_slider_size;
gtk_style_context_get_style(style,
"slider-width", &slider_width,
"trough-border", &trough_border,
"stepper-size", &stepper_size,
"min-slider-length", &min_slider_size,
nullptr);
metrics->size.thumb =
SizeFromLengthAndBreadth(aOrientation, min_slider_size, slider_width);
metrics->size.button =
SizeFromLengthAndBreadth(aOrientation, stepper_size, slider_width);
// overall scrollbar
gint breadth = slider_width + 2 * trough_border;
// Require room for the slider in the track if we don't have buttons.
gint length = hasButtons ? 0 : min_slider_size + 2 * trough_border;
metrics->size.scrollbar =
SizeFromLengthAndBreadth(aOrientation, length, breadth);
// Borders on the major axis are set on the outermost scrollbar
// element to correctly position the buttons when
// trough-under-steppers is true.
// Borders on the minor axis are set on the track element so that it
// receives mouse events, as in GTK.
// Other borders have been zero-initialized.
if (aOrientation == GTK_ORIENTATION_HORIZONTAL) {
metrics->border.scrollbar.left =
metrics->border.scrollbar.right =
metrics->border.track.top =
metrics->border.track.bottom = trough_border;
} else {
metrics->border.scrollbar.top =
metrics->border.scrollbar.bottom =
metrics->border.track.left =
metrics->border.track.right = trough_border;
}
return metrics;
}
// GTK version > 3.20
// scrollbar
metrics->border.scrollbar = GetMarginBorderPadding(style);
WidgetNodeType contents, track, thumb;
if (aOrientation == GTK_ORIENTATION_HORIZONTAL) {
contents = MOZ_GTK_SCROLLBAR_CONTENTS_HORIZONTAL;
track = MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL;
thumb = MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL;
} else {
contents = MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL;
track = MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL;
thumb = MOZ_GTK_SCROLLBAR_THUMB_VERTICAL;
}
// thumb
metrics->size.thumb = GetMinMarginBox(thumb);
// track
style = GetStyleContext(track);
metrics->border.track = GetMarginBorderPadding(style);
MozGtkSize trackMinSize = GetMinContentBox(style) + metrics->border.track;
MozGtkSize trackSizeForThumb = metrics->size.thumb + metrics->border.track;
// button
if (hasButtons) {
metrics->size.button = GetMinMarginBox(MOZ_GTK_SCROLLBAR_BUTTON);
} else {
metrics->size.button = {0, 0};
}
if (aOrientation == GTK_ORIENTATION_HORIZONTAL) {
metrics->size.button.Rotate();
// If the track is wider than necessary for the thumb, including when
// the buttons will cause Gecko to expand the track to fill
// available breadth, then add to the track border to prevent Gecko
// from expanding the thumb to fill available breadth.
gint extra =
std::max(trackMinSize.height,
metrics->size.button.height) - trackSizeForThumb.height;
if (extra > 0) {
// If extra is odd, then the thumb is 0.5 pixels above
// center as in gtk_range_compute_slider_position().
metrics->border.track.top += extra / 2;
metrics->border.track.bottom += extra - extra / 2;
// Update size for change in border.
trackSizeForThumb.height += extra;
}
} else {
gint extra =
std::max(trackMinSize.width,
metrics->size.button.width) - trackSizeForThumb.width;
if (extra > 0) {
// If extra is odd, then the thumb is 0.5 pixels to the left
// of center as in gtk_range_compute_slider_position().
metrics->border.track.left += extra / 2;
metrics->border.track.right += extra - extra / 2;
trackSizeForThumb.width += extra;
}
}
style = GetStyleContext(contents);
GtkBorder contentsBorder = GetMarginBorderPadding(style);
metrics->size.scrollbar =
trackSizeForThumb + contentsBorder + metrics->border.scrollbar;
return metrics;
}
/* cairo_t *cr argument has to be a system-cairo. */
gint
moz_gtk_widget_paint(WidgetNodeType widget, cairo_t *cr,
GdkRectangle* rect,
GtkWidgetState* state, gint flags,
GtkTextDirection direction)
{
/* A workaround for https://bugzilla.gnome.org/show_bug.cgi?id=694086
*/
cairo_new_path(cr);
switch (widget) {
case MOZ_GTK_BUTTON:
case MOZ_GTK_TOOLBAR_BUTTON:
if (state->depressed) {
return moz_gtk_button_paint(cr, rect, state,
(GtkReliefStyle) flags,
GetWidget(MOZ_GTK_TOGGLE_BUTTON),
direction);
}
return moz_gtk_button_paint(cr, rect, state,
(GtkReliefStyle) flags,
GetWidget(MOZ_GTK_BUTTON),
direction);
break;
case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE:
case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE:
case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE:
return moz_gtk_header_bar_button_paint(cr, rect, state,
(GtkReliefStyle) flags,
GetWidget(widget),
direction);
break;
case MOZ_GTK_CHECKBUTTON:
case MOZ_GTK_RADIOBUTTON:
return moz_gtk_toggle_paint(cr, rect, state,
!!(flags & MOZ_GTK_WIDGET_CHECKED),
!!(flags & MOZ_GTK_WIDGET_INCONSISTENT),
(widget == MOZ_GTK_RADIOBUTTON),
direction);
break;
case MOZ_GTK_SCROLLBAR_BUTTON:
return moz_gtk_scrollbar_button_paint(cr, rect, state,
(GtkScrollbarButtonFlags) flags,
direction);
break;
case MOZ_GTK_SCROLLBAR_HORIZONTAL:
case MOZ_GTK_SCROLLBAR_VERTICAL:
if (flags & MOZ_GTK_TRACK_OPAQUE) {
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_WINDOW, direction);
gtk_render_background(style, cr,
rect->x, rect->y, rect->width, rect->height);
}
if (gtk_check_version(3,20,0) == nullptr) {
return moz_gtk_scrollbar_paint(widget, cr, rect, state, direction);
} else {
WidgetNodeType trough_widget = (widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) ?
MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL : MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL;
return moz_gtk_scrollbar_trough_paint(trough_widget, cr, rect,
state, direction);
}
break;
case MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL:
case MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL:
if (gtk_check_version(3,20,0) == nullptr) {
return moz_gtk_scrollbar_trough_paint(widget, cr, rect,
state, direction);
}
break;
case MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL:
case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL:
return moz_gtk_scrollbar_thumb_paint(widget, cr, rect,
state, direction);
break;
case MOZ_GTK_SCALE_HORIZONTAL:
case MOZ_GTK_SCALE_VERTICAL:
return moz_gtk_scale_paint(cr, rect, state,
(GtkOrientation) flags, direction);
break;
case MOZ_GTK_SCALE_THUMB_HORIZONTAL:
case MOZ_GTK_SCALE_THUMB_VERTICAL:
return moz_gtk_scale_thumb_paint(cr, rect, state,
(GtkOrientation) flags, direction);
break;
case MOZ_GTK_INNER_SPIN_BUTTON:
return moz_gtk_inner_spin_paint(cr, rect, state, direction);
break;
case MOZ_GTK_SPINBUTTON:
return moz_gtk_spin_paint(cr, rect, direction);
break;
case MOZ_GTK_SPINBUTTON_UP:
case MOZ_GTK_SPINBUTTON_DOWN:
return moz_gtk_spin_updown_paint(cr, rect,
(widget == MOZ_GTK_SPINBUTTON_DOWN),
state, direction);
break;
case MOZ_GTK_SPINBUTTON_ENTRY:
{
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_SPINBUTTON_ENTRY, direction,
GetStateFlagsFromGtkWidgetState(state));
gint ret = moz_gtk_entry_paint(cr, rect, state, style);
return ret;
}
break;
case MOZ_GTK_GRIPPER:
return moz_gtk_gripper_paint(cr, rect, state,
direction);
break;
case MOZ_GTK_TREEVIEW:
return moz_gtk_treeview_paint(cr, rect, state,
direction);
break;
case MOZ_GTK_TREE_HEADER_CELL:
return moz_gtk_tree_header_cell_paint(cr, rect, state,
flags, direction);
break;
case MOZ_GTK_TREE_HEADER_SORTARROW:
return moz_gtk_tree_header_sort_arrow_paint(cr, rect,
state,
(GtkArrowType) flags,
direction);
break;
case MOZ_GTK_TREEVIEW_EXPANDER:
return moz_gtk_treeview_expander_paint(cr, rect, state,
(GtkExpanderStyle) flags, direction);
break;
case MOZ_GTK_ENTRY:
{
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_ENTRY, direction,
GetStateFlagsFromGtkWidgetState(state));
gint ret = moz_gtk_entry_paint(cr, rect, state, style);
return ret;
}
case MOZ_GTK_TEXT_VIEW:
return moz_gtk_text_view_paint(cr, rect, state, direction);
break;
case MOZ_GTK_DROPDOWN:
return moz_gtk_combo_box_paint(cr, rect, state, direction);
break;
case MOZ_GTK_DROPDOWN_ARROW:
return moz_gtk_combo_box_entry_button_paint(cr, rect,
state, flags, direction);
break;
case MOZ_GTK_DROPDOWN_ENTRY:
{
GtkStyleContext* style =
GetStyleContext(MOZ_GTK_COMBOBOX_ENTRY_TEXTAREA, direction,
GetStateFlagsFromGtkWidgetState(state));
gint ret = moz_gtk_entry_paint(cr, rect, state, style);
return ret;
}
break;
case MOZ_GTK_CHECKBUTTON_CONTAINER:
case MOZ_GTK_RADIOBUTTON_CONTAINER:
return moz_gtk_container_paint(cr, rect, state, widget, direction);
break;
case MOZ_GTK_CHECKBUTTON_LABEL:
case MOZ_GTK_RADIOBUTTON_LABEL:
return moz_gtk_toggle_label_paint(cr, rect, state,
(widget == MOZ_GTK_RADIOBUTTON_LABEL),
direction);
break;
case MOZ_GTK_TOOLBAR:
return moz_gtk_toolbar_paint(cr, rect, direction);
break;
case MOZ_GTK_TOOLBAR_SEPARATOR:
return moz_gtk_toolbar_separator_paint(cr, rect,
direction);
break;
case MOZ_GTK_TOOLTIP:
return moz_gtk_tooltip_paint(cr, rect, direction);
break;
case MOZ_GTK_FRAME:
return moz_gtk_frame_paint(cr, rect, direction);
break;
case MOZ_GTK_RESIZER:
return moz_gtk_resizer_paint(cr, rect, state,
direction);
break;
case MOZ_GTK_PROGRESSBAR:
return moz_gtk_progressbar_paint(cr, rect, direction);
break;
case MOZ_GTK_PROGRESS_CHUNK:
case MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE:
case MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE:
return moz_gtk_progress_chunk_paint(cr, rect,
direction, widget);
break;
case MOZ_GTK_TAB_TOP:
case MOZ_GTK_TAB_BOTTOM:
return moz_gtk_tab_paint(cr, rect, state,
(GtkTabFlags) flags, direction, widget);
break;
case MOZ_GTK_TABPANELS:
return moz_gtk_tabpanels_paint(cr, rect, direction);
break;
case MOZ_GTK_TAB_SCROLLARROW:
return moz_gtk_tab_scroll_arrow_paint(cr, rect, state,
(GtkArrowType) flags, direction);
break;
case MOZ_GTK_MENUBAR:
return moz_gtk_menu_bar_paint(cr, rect, direction);
break;
case MOZ_GTK_MENUPOPUP:
return moz_gtk_menu_popup_paint(cr, rect, direction);
break;
case MOZ_GTK_MENUSEPARATOR:
return moz_gtk_menu_separator_paint(cr, rect,
direction);
break;
case MOZ_GTK_MENUBARITEM:
case MOZ_GTK_MENUITEM:
return moz_gtk_menu_item_paint(widget, cr, rect, state, direction);
break;
case MOZ_GTK_MENUARROW:
return moz_gtk_menu_arrow_paint(cr, rect, state,
direction);
break;
case MOZ_GTK_TOOLBARBUTTON_ARROW:
return moz_gtk_arrow_paint(cr, rect, state,
(GtkArrowType) flags, direction);
break;
case MOZ_GTK_CHECKMENUITEM:
case MOZ_GTK_RADIOMENUITEM:
return moz_gtk_check_menu_item_paint(widget, cr, rect, state,
(gboolean) flags, direction);
break;
case MOZ_GTK_SPLITTER_HORIZONTAL:
return moz_gtk_vpaned_paint(cr, rect, state);
break;
case MOZ_GTK_SPLITTER_VERTICAL:
return moz_gtk_hpaned_paint(cr, rect, state);
break;
case MOZ_GTK_WINDOW:
return moz_gtk_window_paint(cr, rect, direction);
break;
case MOZ_GTK_INFO_BAR:
return moz_gtk_info_bar_paint(cr, rect, state);
break;
case MOZ_GTK_HEADER_BAR:
case MOZ_GTK_HEADER_BAR_MAXIMIZED:
return moz_gtk_header_bar_paint(widget, cr, rect, state);
break;
default:
g_warning("Unknown widget type: %d", widget);
}
return MOZ_GTK_UNKNOWN_WIDGET;
}
gint
moz_gtk_shutdown()
{
/* This will destroy all of our widgets */
ResetWidgetCache();
return MOZ_GTK_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink