static void panel_frame_get_preferred_height (GtkWidget *widget, gint *minimal_height, gint *natural_height) { PanelFrame *frame = (PanelFrame *) widget; GtkBin *bin = (GtkBin *) widget; GtkStyleContext *context; GtkWidget *child; GtkBorder padding; int border_width; context = gtk_widget_get_style_context (widget); gtk_style_context_get_padding (context, gtk_widget_get_state_flags (widget), &padding); border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); *minimal_height = 1; *natural_height = 1; child = gtk_bin_get_child (bin); if (child && gtk_widget_get_visible (child)) gtk_widget_get_preferred_height (child, minimal_height, natural_height); *minimal_height += border_width; *natural_height += border_width; if (frame->edges & PANEL_EDGE_TOP) { *minimal_height += padding.top; *natural_height += padding.top; } if (frame->edges & PANEL_EDGE_BOTTOM) { *minimal_height += padding.bottom; *natural_height += padding.bottom; } }
static gboolean gnm_notebook_button_draw (GtkWidget *widget, cairo_t *cr) { GnmNotebookButton *nbb = GNM_NOTEBOOK_BUTTON (widget); GnmNotebook *nb = GNM_NOTEBOOK (gtk_widget_get_parent (widget)); GtkStyleContext *context = gtk_widget_get_style_context (widget); gboolean is_active = (widget == gnm_notebook_get_current_label (nb)); GtkStateFlags state = is_active ? GTK_STATE_FLAG_ACTIVE : GTK_STATE_FLAG_NORMAL; GtkBorder padding; gtk_style_context_save (context); gtk_style_context_set_state (context, state); gtk_style_context_get_padding (context, state, &padding); gnm_notebook_button_ensure_layout (nbb); gtk_render_layout (context, cr, padding.left + (is_active ? nbb->x_offset_active : nbb->x_offset), 0, is_active ? nbb->layout_active : nbb->layout); gtk_style_context_restore (context); return FALSE; }
static void _gtk_theming_background_init_context (GtkThemingBackground *bg) { bg->flags = gtk_style_context_get_state (bg->context); gtk_style_context_get_border (bg->context, bg->flags, &bg->border); gtk_style_context_get_padding (bg->context, bg->flags, &bg->padding); gtk_style_context_get_background_color (bg->context, bg->flags, &bg->bg_color); /* In the CSS box model, by default the background positioning area is * the padding-box, i.e. all the border-box minus the borders themselves, * which determines also its default size, see * http://dev.w3.org/csswg/css3-background/#background-origin * * In the future we might want to support different origins or clips, but * right now we just shrink to the default. */ _gtk_rounded_box_init_rect (&bg->border_box, 0, 0, bg->paint_area.width, bg->paint_area.height); _gtk_rounded_box_apply_border_radius_for_context (&bg->border_box, bg->context, bg->junction); bg->padding_box = bg->border_box; _gtk_rounded_box_shrink (&bg->padding_box, bg->border.top, bg->border.right, bg->border.bottom, bg->border.left); }
static void anjuta_tabber_get_preferred_width (GtkWidget* widget, gint* minimum, gint* preferred) { g_return_if_fail (ANJUTA_IS_TABBER (widget)); AnjutaTabber* tabber = ANJUTA_TABBER (widget); GtkStyleContext* context; GList* child; gint focus_width; gint focus_pad; gint tab_curvature; gint tab_overlap; *minimum = 0; *preferred = 0; gtk_widget_style_get (GTK_WIDGET (tabber->priv->notebook), "focus-line-width", &focus_width, "focus-padding", &focus_pad, "tab-curvature", &tab_curvature, "tab-overlap", &tab_overlap, NULL); context = gtk_widget_get_style_context (widget); for (child = tabber->priv->children; child != NULL; child = g_list_next (child)) { GtkStateFlags state; GtkBorder tab_padding; gint xpadding; gint child_min; gint child_preferred; gint extra_space = 2 * (tab_curvature - tab_overlap); /* Get the padding of the tab */ gtk_style_context_save (context); anjuta_tabber_setup_style_context (tabber, context, child, &state, NULL); gtk_style_context_get_padding (context, state, &tab_padding); gtk_style_context_restore (context); xpadding = 2 * (focus_width + focus_pad) + tab_padding.left + tab_padding.right; if (child->prev == NULL) extra_space += tab_overlap; if (child->next == NULL) extra_space += tab_overlap; gtk_widget_get_preferred_width (GTK_WIDGET (child->data), &child_min, &child_preferred); if (minimum) { *minimum += child_min + xpadding + extra_space; } if (preferred) { *preferred += child_preferred + xpadding + extra_space; } } }
static void gtk_tearoff_menu_item_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural) { GtkStyleContext *context; GtkBorder padding; GtkStateFlags state; GtkWidget *parent; guint border_width; context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); gtk_style_context_get_padding (context, state, &padding); border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); *minimum = *natural = (border_width * 2) + padding.top + padding.bottom; parent = gtk_widget_get_parent (widget); if (GTK_IS_MENU (parent) && gtk_menu_get_tearoff_state (GTK_MENU (parent))) { *minimum += ARROW_SIZE; *natural += ARROW_SIZE; } else { *minimum += padding.top + 4; *natural += padding.top + 4; } }
static void resize_window(GtkWidget *widget, guint width, guint height, gpointer data) { VteTerminal *terminal; if ((GTK_IS_WINDOW(data)) && (width >= 2) && (height >= 2)) { gint owidth, oheight, char_width, char_height, column_count, row_count; GtkBorder padding; terminal = VTE_TERMINAL(widget); gtk_window_get_size(GTK_WINDOW(data), &owidth, &oheight); /* Take into account border overhead. */ char_width = vte_terminal_get_char_width (terminal); char_height = vte_terminal_get_char_height (terminal); column_count = vte_terminal_get_column_count (terminal); row_count = vte_terminal_get_row_count (terminal); gtk_style_context_get_padding(gtk_widget_get_style_context(widget), gtk_widget_get_state_flags(widget), &padding); owidth -= char_width * column_count + padding.left + padding.right; oheight -= char_height * row_count + padding.top + padding.bottom; gtk_window_resize(GTK_WINDOW(data), width + owidth, height + oheight); } }
static void _gtk_theming_background_init_context (GtkThemingBackground *bg, double width, double height, GtkJunctionSides junction) { GtkStateFlags flags = gtk_style_context_get_state (bg->context); GtkBorder border, padding; gtk_style_context_get_border (bg->context, flags, &border); gtk_style_context_get_padding (bg->context, flags, &padding); /* In the CSS box model, by default the background positioning area is * the padding-box, i.e. all the border-box minus the borders themselves, * which determines also its default size, see * http://dev.w3.org/csswg/css3-background/#background-origin * * In the future we might want to support different origins or clips, but * right now we just shrink to the default. */ _gtk_rounded_box_init_rect (&bg->boxes[GTK_CSS_AREA_BORDER_BOX], 0, 0, width, height); _gtk_rounded_box_apply_border_radius_for_context (&bg->boxes[GTK_CSS_AREA_BORDER_BOX], bg->context, junction); bg->boxes[GTK_CSS_AREA_PADDING_BOX] = bg->boxes[GTK_CSS_AREA_BORDER_BOX]; _gtk_rounded_box_shrink (&bg->boxes[GTK_CSS_AREA_PADDING_BOX], border.top, border.right, border.bottom, border.left); bg->boxes[GTK_CSS_AREA_CONTENT_BOX] = bg->boxes[GTK_CSS_AREA_PADDING_BOX]; _gtk_rounded_box_shrink (&bg->boxes[GTK_CSS_AREA_CONTENT_BOX], padding.top, padding.right, padding.bottom, padding.left); }
static void term_char_size_changed (VteTerminal *vtterm, guint width, guint height, gpointer userdata) { GdkGeometry geometry; geometry.height_inc = height; geometry.width_inc = width; GtkBorder padding; gtk_style_context_get_padding (gtk_widget_get_style_context (GTK_WIDGET (vtterm)), gtk_widget_get_state_flags (GTK_WIDGET (vtterm)), &padding); geometry.base_height = padding.top + padding.bottom; geometry.base_width = padding.left + padding.right; geometry.min_height = geometry.base_height + 3 * geometry.height_inc; geometry.min_width = geometry.base_width + 10 * geometry.width_inc; gtk_window_set_geometry_hints (GTK_WINDOW (userdata), GTK_WIDGET (vtterm), &geometry, GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE | GDK_HINT_RESIZE_INC); gtk_widget_queue_resize (GTK_WIDGET (vtterm)); }
static void image_menuitem_set_size_request (GtkWidget *menuitem, GtkIconSize icon_size) { GtkStyleContext *context; GtkStateFlags state; GtkBorder padding, border; int border_width; int icon_height; int req_height; if (!gtk_icon_size_lookup (icon_size, NULL, &icon_height)) return; /* If we don't have a pixmap for this menuitem * at least make sure its the same height as * the rest. * This is a bit ugly, since we should keep this in sync with what's in * gtk_menu_item_size_request() */ context = gtk_widget_get_style_context (menuitem); state = gtk_widget_get_state_flags (menuitem); gtk_style_context_get_padding (context, state, &padding); gtk_style_context_get_border (context, state, &border); border_width = gtk_container_get_border_width (GTK_CONTAINER (menuitem)); req_height = icon_height; req_height += (border_width * 2) + padding.top + padding.bottom + border.top + border.bottom; gtk_widget_set_size_request (menuitem, -1, req_height); }
static void query_size (GtkStyleContext *context, gint *width, gint *height) { GtkBorder margin, border, padding; int min_width, min_height; gtk_style_context_get_margin (context, &margin); gtk_style_context_get_border (context, &border); gtk_style_context_get_padding (context, &padding); gtk_style_context_get (context, "min-width", &min_width, "min-height", &min_height, NULL); min_width += margin.left + margin.right + border.left + border.right + padding.left + padding.right; min_height += margin.top + margin.bottom + border.top + border.bottom + padding.top + padding.bottom; if (width) *width = MAX (*width, min_width); if (height) *height = MAX (*height, min_height); }
static void gtk_switch_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural) { GtkStyleContext *context; GtkStateFlags state; GtkBorder padding; gint width, slider_width, focus_width, focus_pad; PangoLayout *layout; PangoRectangle logical_rect; context = gtk_widget_get_style_context (widget); state = gtk_style_context_get_state (context); gtk_style_context_save (context); gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER); gtk_style_context_get_padding (context, state, &padding); width = padding.left + padding.right; gtk_style_context_restore (context); gtk_widget_style_get (widget, "slider-width", &slider_width, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); slider_width = MAX (slider_width, 3 * (focus_width + focus_pad)); /* Translators: if the "on" state label requires more than three * glyphs then use MEDIUM VERTICAL BAR (U+2759) as the text for * the state */ layout = gtk_widget_create_pango_layout (widget, C_("switch", "ON")); pango_layout_get_extents (layout, NULL, &logical_rect); pango_extents_to_pixels (&logical_rect, NULL); width += MAX (logical_rect.width, slider_width); /* Translators: if the "off" state label requires more than three * glyphs then use WHITE CIRCLE (U+25CB) as the text for the state */ pango_layout_set_text (layout, C_("switch", "OFF"), -1); pango_layout_get_extents (layout, NULL, &logical_rect); pango_extents_to_pixels (&logical_rect, NULL); width += MAX (logical_rect.width, slider_width); g_object_unref (layout); if (minimum) *minimum = width; if (natural) *natural = width; }
static gboolean gtk_switch_motion (GtkWidget *widget, GdkEventMotion *event) { GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv; /* if this is a direct toggle we don't handle motion */ if (priv->in_press) return GDK_EVENT_PROPAGATE; if (ABS (event->x - priv->drag_start) < priv->drag_threshold) return GDK_EVENT_STOP; if (event->state & GDK_BUTTON1_MASK) { gint position = event->x - priv->offset; GtkAllocation allocation; GtkStyleContext *context; GtkStateFlags state; GtkBorder padding; gint width, focus_width, focus_pad; gtk_widget_style_get (widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); gtk_style_context_save (context); gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER); gtk_style_context_get_padding (context, state, &padding); gtk_style_context_restore (context); gtk_widget_get_allocation (widget, &allocation); width = allocation.width - 2 * (focus_width + focus_pad); /* constrain the handle within the trough width */ if (position > (width / 2) - padding.right) priv->handle_x = width / 2 - padding.right; else if (position < padding.left) priv->handle_x = 0; else priv->handle_x = position; priv->is_dragging = TRUE; /* we need to redraw the handle */ gtk_widget_queue_draw (widget); return GDK_EVENT_STOP; } return GDK_EVENT_PROPAGATE; }
static void gtk_switch_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural) { GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv; GtkStyleContext *context; GtkStateFlags state; GtkBorder padding; gint height, focus_width, focus_pad; PangoLayout *layout; PangoRectangle logical_rect; gchar *str; context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); if (priv->is_active) state |= GTK_STATE_FLAG_ACTIVE; gtk_style_context_save (context); gtk_style_context_set_state (context, state); gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER); gtk_style_context_get_padding (context, state, &padding); height = padding.top + padding.bottom; gtk_style_context_restore (context); gtk_widget_style_get (widget, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); height += 2 * (focus_width + focus_pad); str = g_strdup_printf ("%s%s", C_("switch", "ON"), C_("switch", "OFF")); layout = gtk_widget_create_pango_layout (widget, str); pango_layout_get_extents (layout, NULL, &logical_rect); pango_extents_to_pixels (&logical_rect, NULL); height += MAX (DEFAULT_SLIDER_HEIGHT, logical_rect.height); g_object_unref (layout); g_free (str); if (minimum) *minimum = height; if (natural) *natural = height; }
static void panel_frame_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { PanelFrame *frame = (PanelFrame *) widget; GtkBin *bin = (GtkBin *) widget; GtkStyleContext *context; GtkBorder padding; GtkAllocation child_allocation; GtkAllocation child_allocation_current; GtkWidget *child; int border_width; gtk_widget_set_allocation (widget, allocation); context = gtk_widget_get_style_context (widget); gtk_style_context_get_padding (context, gtk_widget_get_state_flags (widget), &padding); border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); child_allocation.x = allocation->x + border_width; child_allocation.y = allocation->y + border_width; child_allocation.width = allocation->width - 2 * border_width; child_allocation.height = allocation->height - 2 * border_width; if (frame->edges & PANEL_EDGE_LEFT) { child_allocation.x += padding.left; child_allocation.width -= padding.left; } if (frame->edges & PANEL_EDGE_TOP) { child_allocation.y += padding.top; child_allocation.height -= padding.top; } if (frame->edges & PANEL_EDGE_RIGHT) child_allocation.width -= padding.left; if (frame->edges & PANEL_EDGE_BOTTOM) child_allocation.height -= padding.top; child = gtk_bin_get_child (bin); gtk_widget_get_allocation (child, &child_allocation_current); if (gtk_widget_get_mapped (widget) && (child_allocation.x != child_allocation_current.x || child_allocation.y != child_allocation_current.y || child_allocation.width != child_allocation_current.width || child_allocation.height != child_allocation_current.height)) gdk_window_invalidate_rect (gtk_widget_get_window (widget), allocation, FALSE); if (child && gtk_widget_get_visible (child)) gtk_widget_size_allocate (child, &child_allocation); }
static void update_hours_sidebar_size (GcalWeekView *self) { GtkStyleContext *context; GtkStateFlags state; GtkSizeGroup *sidebar_sizegroup; GtkWidget *widget; GtkBorder padding; PangoLayout *layout; PangoFontDescription *font_desc; gint hours_12_width, hours_24_width, sidebar_width; gint hours_12_height, hours_24_height, cell_height; widget = GTK_WIDGET (self); context = gtk_widget_get_style_context (widget); state = gtk_style_context_get_state (context); gtk_style_context_save (context); gtk_style_context_add_class (context, "hours"); gtk_style_context_get (context, state, "font", &font_desc, NULL); gtk_style_context_get_padding (context, state, &padding); layout = pango_layout_new (gtk_widget_get_pango_context (widget)); pango_layout_set_font_description (layout, font_desc); pango_layout_set_text (layout, _("00 AM"), -1); pango_layout_get_pixel_size (layout, &hours_12_width, &hours_12_height); pango_layout_set_text (layout, _("00:00"), -1); pango_layout_get_pixel_size (layout, &hours_24_width, &hours_24_height); sidebar_width = MAX (hours_12_width, hours_24_width) + padding.left + padding.right; cell_height = MAX (hours_12_height, hours_24_height) + padding.top + padding.bottom + 1; gtk_style_context_restore (context); /* Update the size requests */ gtk_widget_set_size_request (self->hours_bar, sidebar_width, 48 * cell_height); /* Sync with the week header sidebar */ sidebar_sizegroup = gcal_week_header_get_sidebar_size_group (GCAL_WEEK_HEADER (self->header)); gtk_size_group_add_widget (sidebar_sizegroup, self->hours_bar); pango_font_description_free (font_desc); g_object_unref (layout); }
static void gtk_revealer_get_padding (GtkRevealer *revealer, GtkBorder *padding) { GtkWidget *widget = GTK_WIDGET (revealer); GtkStyleContext *context; GtkStateFlags state; context = gtk_widget_get_style_context (widget); state = gtk_style_context_get_state (context); gtk_style_context_get_padding (context, state, padding); }
static void gtk_switch_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural) { GtkStyleContext *context; GtkStateFlags state; GtkBorder padding; gint height, focus_width, focus_pad, slider_width, min_height; PangoLayout *layout; PangoRectangle logical_rect; gchar *str; context = gtk_widget_get_style_context (widget); state = gtk_style_context_get_state (context); gtk_style_context_save (context); gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER); gtk_style_context_get_padding (context, state, &padding); height = padding.top + padding.bottom; gtk_style_context_restore (context); gtk_widget_style_get (widget, "slider-width", &slider_width, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); min_height = MAX (slider_width * 0.6, 3 * (focus_width + focus_pad)); str = g_strdup_printf ("%s%s", C_("switch", "ON"), C_("switch", "OFF")); layout = gtk_widget_create_pango_layout (widget, str); pango_layout_get_extents (layout, NULL, &logical_rect); pango_extents_to_pixels (&logical_rect, NULL); height += MAX (min_height, logical_rect.height); g_object_unref (layout); g_free (str); if (minimum) *minimum = height; if (natural) *natural = height; }
static void gctt_combott_menu_position (GtkMenu *menu, gint *x, gint *y, gint *push_in, gpointer user_data) { GncCombott *combott = GNC_COMBOTT (user_data); GncCombottPrivate *priv = GNC_COMBOTT_GET_PRIVATE (combott); gint sx, sy; GtkWidget *child; GtkRequisition req; GtkAllocation alloc; GtkBorder padding; GtkStyleContext *sc = gtk_widget_get_style_context (GTK_WIDGET (priv->button)); GtkStateFlags state_flags = gtk_style_context_get_state (sc); child = gtk_bin_get_child (GTK_BIN (priv->button)); sx = sy = 0; if (!gtk_widget_get_has_window (child)) { gtk_widget_get_allocation (child, &alloc); sx += alloc.x; sy += alloc.y; } gdk_window_get_root_coords (gtk_widget_get_window (child), sx, sy, &sx, &sy); gtk_style_context_get_padding (sc, state_flags, &padding); sx -= padding.left; gtk_widget_get_preferred_size (GTK_WIDGET (menu), &req, NULL); if (gtk_widget_get_direction (GTK_WIDGET (priv->button)) == GTK_TEXT_DIR_LTR) *x = sx; else { gtk_widget_get_allocation (child, &alloc); *x = sx + alloc.width - req.width; } if(priv->active == -1 || priv->active == 0) *y = sy; else *y = sy - ((req.height / priv->num_items) * (priv->active - 1)); *push_in = FALSE; }
static void _style_get_borders (GtkStyleContext *context, GtkBorder *border_out) { GtkBorder padding, border; GtkStateFlags state; state = gtk_style_context_get_state (context); gtk_style_context_get_padding (context, state, &padding); gtk_style_context_get_border (context, state, &border); border_out->top = padding.top + border.top; border_out->bottom = padding.bottom + border.bottom; border_out->left = padding.left + border.left; border_out->right = padding.right + border.right; }
static void anjuta_tabber_get_preferred_height (GtkWidget* widget, gint* minimum, gint* preferred) { g_return_if_fail (ANJUTA_IS_TABBER (widget)); AnjutaTabber* tabber = ANJUTA_TABBER (widget); GtkStyleContext* context; GList* child; gint focus_width; gint focus_pad; gtk_widget_style_get (GTK_WIDGET (tabber), "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); context = gtk_widget_get_style_context (widget); for (child = tabber->priv->children; child != NULL; child = g_list_next (child)) { GtkStateFlags state; GtkBorder tab_padding; gint ypadding; gint child_min; gint child_preferred; /* Get the padding of the tab */ gtk_style_context_save (context); anjuta_tabber_setup_style_context (tabber, context, child, &state, NULL); gtk_style_context_get_padding (context, state, &tab_padding); gtk_style_context_restore (context); ypadding = 2 * (focus_width + focus_pad) + tab_padding.top + tab_padding.bottom; gtk_widget_get_preferred_height (GTK_WIDGET (child->data), &child_min, &child_preferred); if (minimum) { *minimum = MAX(*minimum, child_min + ypadding); } if (preferred) { *preferred = MAX(*preferred, child_preferred + ypadding); } } }
static void msd_osd_window_style_updated (GtkWidget *widget) { GtkStyleContext *context; GtkBorder padding; GTK_WIDGET_CLASS (msd_osd_window_parent_class)->style_updated (widget); /* We set our border width to 12 (per the MATE standard), plus the * padding of the frame that we draw in our expose handler. This will * make our child be 12 pixels away from the frame. */ context = gtk_widget_get_style_context (widget); gtk_style_context_get_padding (context, GTK_STATE_FLAG_NORMAL, &padding); gtk_container_set_border_width (GTK_CONTAINER (widget), 12 + MAX (padding.left, padding.top)); }
static void get_padding_and_border (GtkWidget *widget, GtkBorder *border) { GtkStyleContext *context; GtkStateFlags state; GtkBorder tmp; context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); gtk_style_context_get_padding (context, state, border); gtk_style_context_get_border (context, state, &tmp); border->top += tmp.top; border->right += tmp.right; border->bottom += tmp.bottom; border->left += tmp.left; }
static void msd_osd_window_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural) { GtkStyleContext *context; GtkBorder padding; GTK_WIDGET_CLASS (msd_osd_window_parent_class)->get_preferred_height (widget, minimum, natural); /* See the comment in msd_osd_window_style_updated() for why we add the padding here */ context = gtk_widget_get_style_context (widget); gtk_style_context_get_padding (context, GTK_STATE_FLAG_NORMAL, &padding); *minimum += padding.top; *natural += padding.top; }
static void xfce_arrow_button_get_thickness (GtkStyleContext *context, xfce_arrow_button_thickness *thickness) { GtkBorder border; GtkBorder margin; GtkBorder padding; gint xthickness; gint ythickness; gtk_style_context_get_border (context, GTK_STATE_FLAG_NORMAL, &border); gtk_style_context_get_margin (context, GTK_STATE_FLAG_NORMAL, &margin); gtk_style_context_get_padding (context, GTK_STATE_FLAG_NORMAL, &padding); thickness->x = MAX (border.left + margin.left + padding.left, border.right + margin.right + padding.right); thickness->y = MAX (border.top + margin.top + padding.top, border.bottom + margin.bottom + padding.bottom); }
static void gtk_tearoff_menu_item_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural) { GtkStyleContext *context; guint border_width; GtkBorder padding; GtkStateFlags state; context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); gtk_style_context_get_padding (context, state, &padding); border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); *minimum = *natural = (border_width + BORDER_SPACING) * 2 + padding.left + padding.right; }
static gboolean gtk_switch_motion (GtkWidget *widget, GdkEventMotion *event) { GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv; /* if this is a direct toggle we don't handle motion */ if (priv->in_press) return FALSE; if (ABS (event->x - priv->drag_start) < priv->drag_threshold) return TRUE; if (event->state & GDK_BUTTON1_MASK) { gint position = event->x - priv->offset; GtkAllocation allocation; GtkStyleContext *context; GtkStateFlags state; GtkBorder padding; context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); gtk_style_context_get_padding (context, state, &padding); gtk_widget_get_allocation (widget, &allocation); /* constrain the handle within the trough width */ if (position > (allocation.width / 2 - padding.right)) priv->handle_x = allocation.width / 2 - padding.right; else if (position < padding.left) priv->handle_x = padding.left; else priv->handle_x = position; priv->is_dragging = TRUE; /* we need to redraw the handle */ gtk_widget_queue_draw (widget); return TRUE; } return FALSE; }
static void gtk_switch_pan_gesture_pan (GtkGesturePan *gesture, GtkPanDirection direction, gdouble offset, GtkSwitch *sw) { GtkWidget *widget = GTK_WIDGET (sw); GtkSwitchPrivate *priv = sw->priv; GtkAllocation allocation; GtkStyleContext *context; GtkStateFlags state; GtkBorder padding; gint width, position; if (direction == GTK_PAN_DIRECTION_LEFT) offset = -offset; gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED); position = priv->offset + offset; context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); gtk_style_context_save (context); gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER); gtk_style_context_get_padding (context, state, &padding); gtk_style_context_restore (context); gtk_widget_get_allocation (widget, &allocation); width = allocation.width; /* constrain the handle within the trough width */ if (position > (width / 2) - padding.right) priv->handle_x = width / 2 - padding.right; else if (position < padding.left) priv->handle_x = 0; else priv->handle_x = position; /* we need to redraw the handle */ gtk_widget_queue_draw (widget); }
static void draw_style_common (GtkStyleContext *context, cairo_t *cr, gint x, gint y, gint width, gint height, gint *contents_x, gint *contents_y, gint *contents_width, gint *contents_height) { GtkBorder margin, border, padding; int min_width, min_height; gtk_style_context_get_margin (context, &margin); gtk_style_context_get_border (context, &border); gtk_style_context_get_padding (context, &padding); gtk_style_context_get (context, "min-width", &min_width, "min-height", &min_height, NULL); x += margin.left; y += margin.top; width -= margin.left + margin.right; height -= margin.top + margin.bottom; width = MAX (width, min_width); height = MAX (height, min_height); gtk_render_background (context, cr, x, y, width, height); gtk_render_frame (context, cr, x, y, width, height); if (contents_x) *contents_x = x + border.left + padding.left; if (contents_y) *contents_y = y + border.top + padding.top; if (contents_width) *contents_width = width - border.left - border.right - padding.left - padding.right; if (contents_height) *contents_height = height - border.top - border.bottom - padding.top - padding.bottom; }
wxSize wxSpinButton::DoGetBestSize() const { wxSize best = base_type::DoGetBestSize(); #ifdef __WXGTK3__ GtkStyleContext* sc = gtk_widget_get_style_context(m_widget); GtkBorder pad = { 0, 0, 0, 0 }; gtk_style_context_get_padding(sc, GtkStateFlags(0), &pad); best.x -= pad.left + pad.right; #else gtk_widget_ensure_style(m_widget); int w = PANGO_PIXELS(pango_font_description_get_size(m_widget->style->font_desc)); w &= ~1; if (w < 6) w = 6; best.x = w + 2 * m_widget->style->xthickness; #endif CacheBestSize(best); return best; }
static void get_padding_and_border (GdNotification *notification, GtkBorder *border) { GtkStyleContext *context; GtkStateFlags state; GtkBorder tmp; context = gtk_widget_get_style_context (GTK_WIDGET (notification)); state = gtk_widget_get_state_flags (GTK_WIDGET (notification)); gtk_style_context_get_padding (context, state, border); gtk_style_context_get_border (context, state, &tmp); border->top += tmp.top; border->right += tmp.right; border->bottom += tmp.bottom; border->left += tmp.left; }