static void border(GtkWidget* widget, GtkStateFlags state, GdkRGBA& gdkRGBA) { GtkStyleContext* sc = gtk_widget_get_style_context(widget); gtk_style_context_set_state(sc, state); gtk_style_context_get_border_color(sc, state, &gdkRGBA); if (gdkRGBA.alpha <= 0) { widget = gtk_widget_get_parent(GTK_WIDGET(ContainerWidget())); sc = gtk_widget_get_style_context(widget); gtk_style_context_set_state(sc, state); gtk_style_context_get_border_color(sc, state, &gdkRGBA); } }
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; }
GtkStyleContext* ClaimStyleContext(WidgetNodeType aNodeType, GtkTextDirection aDirection, GtkStateFlags aStateFlags, StyleFlags aFlags) { MOZ_ASSERT(!sStyleContextNeedsRestore); GtkStyleContext* style = GetStyleInternal(aNodeType); #ifdef DEBUG MOZ_ASSERT(!sCurrentStyleContext); sCurrentStyleContext = style; #endif GtkStateFlags oldState = gtk_style_context_get_state(style); GtkTextDirection oldDirection = gtk_style_context_get_direction(style); if (oldState != aStateFlags || oldDirection != aDirection) { // From GTK 3.8, set_state() will overwrite the direction, so set // direction after state. gtk_style_context_set_state(style, aStateFlags); gtk_style_context_set_direction(style, aDirection); // This invalidate is necessary for unsaved style contexts from GtkWidgets // in pre-3.18 GTK, because automatic invalidation of such contexts // was delayed until a resize event runs. // // https://bugzilla.mozilla.org/show_bug.cgi?id=1272194#c7 // // Avoid calling invalidate on saved contexts to avoid performing // build_properties() (in 3.16 stylecontext.c) unnecessarily early. if (!sStyleContextNeedsRestore) { gtk_style_context_invalidate(style); } } return style; }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkStyleContext_gtk_1style_1context_1set_1state ( JNIEnv* env, jclass cls, jlong _self, jint _flags ) { GtkStyleContext* self; GtkStateFlags flags; // convert parameter self self = (GtkStyleContext*) _self; // convert parameter flags flags = (GtkStateFlags) _flags; // call function gtk_style_context_set_state(self, flags); // cleanup parameter self // cleanup parameter flags }
static void on_preview_draw (GtkWidget *drawing_area, cairo_t *cr, gpointer data) { ScreenshotDialog *dialog = data; GtkStyleContext *context; int width, height; width = gtk_widget_get_allocated_width (drawing_area); height = gtk_widget_get_allocated_height (drawing_area); if (!dialog->preview_image || gdk_pixbuf_get_width (dialog->preview_image) != width || gdk_pixbuf_get_height (dialog->preview_image) != height) { g_clear_object (&dialog->preview_image); dialog->preview_image = gdk_pixbuf_scale_simple (dialog->screenshot, width, height, GDK_INTERP_BILINEAR); } context = gtk_widget_get_style_context (drawing_area); gtk_style_context_save (context); gtk_style_context_set_state (context, gtk_widget_get_state_flags (drawing_area)); gtk_render_icon (context, cr, dialog->preview_image, 0, 0); gtk_style_context_restore (context); }
static void apply_subtitle_style_to_layout (GtkStyleContext *context, PangoLayout *layout, GtkStateFlags flags) { PangoFontDescription *desc; PangoAttrList *layout_attr; PangoAttribute *attr_alpha; gtk_style_context_save (context); gtk_style_context_set_state (context, flags); gtk_style_context_get (context, gtk_style_context_get_state (context), "font", &desc, NULL); gtk_style_context_restore (context); /* Set the font size */ pango_font_description_set_size (desc, pango_font_description_get_size (desc) * SUBTITLE_SIZE_PERCENTAGE); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); /* Set the font alpha */ layout_attr = pango_attr_list_new (); attr_alpha = pango_attr_foreground_alpha_new (SUBTITLE_DIM_PERCENTAGE * 65535); pango_attr_list_insert (layout_attr, attr_alpha); pango_layout_set_attributes (layout, layout_attr); pango_attr_list_unref (layout_attr); }
void styleContext_estimateBackColor(GtkStyleContext* a_StyleContext, GdkRGBA* a_BackColor) { GtkStateFlags state = GTK_STATE_FLAG_NORMAL; unsigned char imageBytes[4]; { gtk_style_context_save(a_StyleContext); gtk_style_context_set_state(a_StyleContext, state); cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1); cairo_t* cairo = cairo_create(surface); renderAllBackgrounds(a_StyleContext, cairo); cairo_surface_flush(surface); memcpy(imageBytes, cairo_image_surface_get_data(surface), sizeof(imageBytes)); cairo_surface_destroy(surface); cairo_destroy(cairo); gtk_style_context_restore(a_StyleContext); } const unsigned char a = imageBytes[3]; const unsigned char r = imageBytes[2]; const unsigned char g = imageBytes[1]; const unsigned char b = imageBytes[0]; a_BackColor->alpha = a / 255.0; a_BackColor->red = inversePremultipliedColor(r, a) / 255.0; a_BackColor->green = inversePremultipliedColor(g, a) / 255.0; a_BackColor->blue = inversePremultipliedColor(b, a) / 255.0; }
static gboolean draw_callback (GtkWidget *widget, cairo_t *cr, gpointer data) { RenderGradientFunc func = data; GtkAllocation allocation; GtkStyleContext *style; GdkRGBA color; style = gtk_widget_get_style_context (widget); gtk_style_context_save (style); gtk_style_context_set_state (style, gtk_widget_get_state_flags (widget)); gtk_style_context_lookup_color (style, "foreground-color", &color); gtk_style_context_restore (style); gtk_widget_get_allocation (widget, &allocation); cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha); (* func) ( cr, allocation.width, allocation.height); return FALSE; }
/* FIXME: this doesn't work */ static gboolean draw_cb_activity (GtkWidget *widget, cairo_t *cr) { GtkStyleContext *context; GtkWidgetPath *path; context = gtk_widget_get_style_context (widget); gtk_style_context_notify_state_change (context, gtk_widget_get_window (widget), NULL, GTK_STATE_FLAG_ACTIVE, TRUE); gtk_style_context_save (context); path = gtk_widget_path_new (); gtk_widget_path_append_type (path, GTK_TYPE_SPINNER); gtk_widget_path_iter_add_class (path, 0, "spinner"); gtk_style_context_set_path (context, path); gtk_widget_path_free (path); gtk_style_context_set_state (context, GTK_STATE_FLAG_ACTIVE); gtk_render_activity (context, cr, 12, 12, 12, 12); gtk_style_context_restore (context); return TRUE; }
static inline void gtk_switch_paint_handle (GtkWidget *widget, cairo_t *cr, GdkRectangle *box) { GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv; GtkStyleContext *context = gtk_widget_get_style_context (widget); GtkStateFlags state; 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_render_slider (context, cr, box->x, box->y, box->width, box->height, GTK_ORIENTATION_HORIZONTAL); gtk_style_context_restore (context); }
static void draw_radio (GtkWidget *widget, cairo_t *cr, gint x, gint y, GtkStateFlags state, gint *width, gint *height) { GtkStyleContext *button_context; GtkStyleContext *check_context; gint contents_x, contents_y, contents_width, contents_height; /* This information is taken from the GtkRadioButton docs, see "CSS nodes" */ button_context = get_style (NULL, "radiobutton"); check_context = get_style (button_context, "radio"); gtk_style_context_set_state (check_context, state); *width = *height = 0; query_size (button_context, width, height); query_size (check_context, width, height); draw_style_common (button_context, cr, x, y, *width, *height, NULL, NULL, NULL, NULL); draw_style_common (check_context, cr, x, y, *width, *height, &contents_x, &contents_y, &contents_width, &contents_height); gtk_render_check (check_context, cr, contents_x, contents_y, contents_width, contents_height); g_object_unref (check_context); g_object_unref (button_context); }
static void gdl_dock_tablabel_paint (GtkWidget *widget, cairo_t *cr) { GtkBin *bin; GtkAllocation widget_allocation; GdlDockTablabel *tablabel; gint border_width; cairo_rectangle_int_t rect; bin = GTK_BIN (widget); tablabel = GDL_DOCK_TABLABEL (widget); border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); gtk_widget_get_allocation (widget, &widget_allocation); rect.x = widget_allocation.x + border_width; rect.y = widget_allocation.y + border_width; rect.width = tablabel->drag_handle_size * HANDLE_RATIO; rect.height = widget_allocation.height - 2*border_width; if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget))) { GtkStyleContext* context = gtk_widget_get_style_context (widget); gtk_style_context_set_state (context, tablabel->active ? 0 : GTK_STATE_FLAG_ACTIVE); gtk_render_handle (gtk_widget_get_style_context (widget), cr, rect.x, rect.y, rect.width, rect.height); }; }
static gboolean gb_preferences_switch_draw (GtkWidget *widget, cairo_t *cr) { GbPreferencesSwitch *self = (GbPreferencesSwitch *)widget; GtkStyleContext *style_context; GtkStateFlags flags; gboolean ret = FALSE; g_assert (GB_IS_PREFERENCES_SWITCH (self)); style_context = gtk_widget_get_style_context (widget); gtk_style_context_save (style_context); if (self->in_widget) { flags = gtk_style_context_get_state (style_context); gtk_style_context_set_state (style_context, flags | GTK_STATE_FLAG_PRELIGHT); } ret = GTK_WIDGET_CLASS (gb_preferences_switch_parent_class)->draw (widget, cr); gtk_style_context_restore (style_context); return ret; }
static gboolean xfce_arrow_button_draw (GtkWidget *widget, cairo_t *cr) { gint x, y, w; GtkStyleContext *context; xfce_arrow_button_thickness thickness; GtkAllocation allocation; if (G_LIKELY (gtk_widget_is_drawable (widget))) { context = gtk_widget_get_style_context (widget); xfce_arrow_button_get_thickness (context, &thickness); gtk_widget_get_allocation (widget, &allocation); w = MIN (allocation.height - 2 * thickness.y, allocation.width - 2 * thickness.x); w = MIN (w, ARROW_WIDTH); x = (allocation.width - w) / 2; y = (allocation.height - w) / 2; GTK_WIDGET_CLASS (parent_class)->draw (widget, cr); gtk_style_context_save (context); gtk_style_context_set_state (context, gtk_widget_get_state_flags (widget)); gtk_render_arrow (context, cr, G_PI, x, y, w); gtk_style_context_restore (context); } return TRUE; }
static void draw_radio (GtkWidget *widget, cairo_t *cr, gint x, gint y, GtkStateFlags state) { GtkStyleContext *button_context; GtkStyleContext *check_context; /* This information is taken from the GtkRadioButton docs, see "CSS nodes" */ const char *path[2] = { "radiobutton", "radio" }; button_context = get_style (NULL, path[0]); check_context = get_style (button_context, path[1]); gtk_style_context_set_state (check_context, state); gtk_render_background (check_context, cr, x, y, 20, 20); gtk_render_frame (check_context, cr, x, y, 20, 20); gtk_render_option (check_context, cr, x, y, 20, 20); g_object_unref (check_context); g_object_unref (button_context); }
static void gossip_cell_renderer_expander_render (GtkCellRenderer *cell, cairo_t *cr, GtkWidget *widget, const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags) { GossipCellRendererExpander *expander; GossipCellRendererExpanderPriv *priv; GtkStyleContext *style_context; gint x_offset, y_offset; gint xpad, ypad; expander = (GossipCellRendererExpander*) cell; priv = GET_PRIV (expander); gossip_cell_renderer_expander_get_size (cell, widget, cell_area, &x_offset, &y_offset, NULL, NULL); gtk_cell_renderer_get_padding (cell, &xpad, &ypad); style_context = gtk_widget_get_style_context (widget); gtk_style_context_set_state (style_context, priv->style_flags); gtk_render_expander (gtk_widget_get_style_context (widget), cr, cell_area->x + x_offset + xpad, cell_area->y + y_offset + ypad, priv->expander_size, priv->expander_size); }
static gboolean window_menu_on_draw (GtkWidget *widget, cairo_t *cr, gpointer data) { GtkStyleContext *context; GtkStateFlags state; WindowMenu *window_menu = data; if (!gtk_widget_has_focus (window_menu->applet)) return FALSE; state = gtk_widget_get_state_flags (widget); context = gtk_widget_get_style_context (widget); gtk_style_context_save (context); gtk_style_context_set_state (context, state); cairo_save (cr); gtk_render_focus (context, cr, 0., 0., gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); cairo_restore (cr); gtk_style_context_restore (context); return FALSE; }
static gboolean panel_menu_bar_object_on_draw (GtkWidget *widget, cairo_t *cr, gpointer data) { PanelMenuBarObject *menubar = data; if (gtk_widget_has_focus (GTK_WIDGET (menubar))) { GtkStyleContext *context; context = gtk_widget_get_style_context (widget); gtk_style_context_save (context); gtk_style_context_set_state (context, gtk_widget_get_state_flags (widget)); cairo_save (cr); gtk_render_focus (context, cr, 0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); cairo_restore (cr); gtk_style_context_restore (context); } return FALSE; }
static gboolean drag_highlight_draw (GtkWidget *widget, cairo_t *cr, gpointer user_data) { gint width, height; GdkWindow *window; GtkStyleContext *style; window = gtk_widget_get_window (widget); width = gdk_window_get_width (window); height = gdk_window_get_height (window); style = gtk_widget_get_style_context (widget); gtk_style_context_save (style); gtk_style_context_add_class (style, GTK_STYLE_CLASS_DND); gtk_style_context_set_state (style, GTK_STATE_FLAG_FOCUSED); gtk_render_frame (style, cr, 0, 0, width, height); gtk_style_context_restore (style); return FALSE; }
static gboolean panel_toggle_button_draw (GtkWidget *widget, cairo_t *cr) { GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget)); GtkStateType state_type; GtkShadowType shadow_type; GtkAllocation allocation; GtkStyleContext *context = gtk_widget_get_style_context (widget); GtkStateFlags flags = 0; state_type = gtk_widget_get_state (widget); /* FIXME: someone make this layout work nicely for all themes * Currently I'm trying to imitate the volume applet's widget */ if (gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (widget))) { if (state_type == GTK_STATE_ACTIVE) state_type = GTK_STATE_NORMAL; shadow_type = GTK_SHADOW_ETCHED_IN; } else { shadow_type = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)) ? GTK_SHADOW_IN : GTK_SHADOW_OUT; } if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) state_type = GTK_STATE_SELECTED; /* FIXME: better detail? */ gtk_widget_get_allocation (widget, &allocation); gtk_style_context_add_class (context, "togglebutton"); switch (state_type) { case GTK_STATE_PRELIGHT: flags |= GTK_STATE_FLAG_PRELIGHT; break; case GTK_STATE_SELECTED: flags |= GTK_STATE_FLAG_SELECTED; break; case GTK_STATE_INSENSITIVE: flags |= GTK_STATE_FLAG_INSENSITIVE; break; case GTK_STATE_ACTIVE: flags |= GTK_STATE_FLAG_ACTIVE; break; case GTK_STATE_FOCUSED: flags |= GTK_STATE_FLAG_FOCUSED; break; case GTK_STATE_NORMAL: case GTK_STATE_INCONSISTENT: default: break; } gtk_style_context_set_state (context, flags); gtk_render_background (context, cr, (gdouble) allocation.x, (gdouble) allocation.y, (gdouble) allocation.width, (gdouble) allocation.height); (void) shadow_type; if (child) gtk_container_propagate_draw (GTK_CONTAINER (widget), child, cr); return FALSE; }
static void draw_horizontal_scrollbar (GtkWidget *widget, cairo_t *cr, gint x, gint y, gint width, gint position, GtkStateFlags state, gint *height) { GtkStyleContext *scrollbar_context; GtkStyleContext *contents_context; GtkStyleContext *trough_context; GtkStyleContext *slider_context; gint slider_width; /* This information is taken from the GtkScrollbar docs, see "CSS nodes" */ scrollbar_context = get_style (NULL, "scrollbar.horizontal.bottom"); contents_context = get_style (scrollbar_context, "contents"); trough_context = get_style (contents_context, "trough"); slider_context = get_style (trough_context, "slider"); gtk_style_context_set_state (scrollbar_context, state); gtk_style_context_set_state (contents_context, state); gtk_style_context_set_state (trough_context, state); gtk_style_context_set_state (slider_context, state); *height = 0; query_size (scrollbar_context, NULL, height); query_size (contents_context, NULL, height); query_size (trough_context, NULL, height); query_size (slider_context, NULL, height); gtk_style_context_get (slider_context, "min-width", &slider_width, NULL); draw_style_common (scrollbar_context, cr, x, y, width, *height, NULL, NULL, NULL, NULL); draw_style_common (contents_context, cr, x, y, width, *height, NULL, NULL, NULL, NULL); draw_style_common (trough_context, cr, x, y, width, *height, NULL, NULL, NULL, NULL); draw_style_common (slider_context, cr, x + position, y, slider_width, *height, NULL, NULL, NULL, NULL); g_object_unref (slider_context); g_object_unref (trough_context); g_object_unref (contents_context); g_object_unref (scrollbar_context); }
static void bg(GtkStyleContext* sc, wxColour& color, int state = GTK_STATE_FLAG_NORMAL) { GdkRGBA* rgba; cairo_pattern_t* pattern = NULL; gtk_style_context_set_state(sc, GtkStateFlags(state)); gtk_style_context_get(sc, GtkStateFlags(state), "background-color", &rgba, "background-image", &pattern, NULL); color = wxColour(*rgba); gdk_rgba_free(rgba); // "background-image" takes precedence over "background-color". // If there is an image, try to get a color out of it. if (pattern) { if (cairo_pattern_get_type(pattern) == CAIRO_PATTERN_TYPE_SURFACE) { cairo_surface_t* surf; cairo_pattern_get_surface(pattern, &surf); if (cairo_surface_get_type(surf) == CAIRO_SURFACE_TYPE_IMAGE) { const guchar* data = cairo_image_surface_get_data(surf); const int stride = cairo_image_surface_get_stride(surf); // choose a pixel in the middle vertically, // images often have a vertical gradient const int i = stride * (cairo_image_surface_get_height(surf) / 2); const unsigned* p = reinterpret_cast<const unsigned*>(data + i); const unsigned pixel = *p; guchar r, g, b, a = 0xff; switch (cairo_image_surface_get_format(surf)) { case CAIRO_FORMAT_ARGB32: a = guchar(pixel >> 24); // fallthrough case CAIRO_FORMAT_RGB24: r = guchar(pixel >> 16); g = guchar(pixel >> 8); b = guchar(pixel); break; default: a = 0; break; } if (a != 0) { if (a != 0xff) { // un-premultiply r = guchar((r * 0xff) / a); g = guchar((g * 0xff) / a); b = guchar((b * 0xff) / a); } color.Set(r, g, b, a); } } } cairo_pattern_destroy(pattern); }
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 set_color_from_style (GdkRGBA *color, GtkStyleContext *context, GtkStateFlags state, MetaGtkColorComponent component) { GdkRGBA other; gtk_style_context_set_state (context, state); switch (component) { case META_GTK_COLOR_BG: case META_GTK_COLOR_BASE: meta_color_get_background_color (context, state, color); break; case META_GTK_COLOR_FG: case META_GTK_COLOR_TEXT: gtk_style_context_get_color (context, state, color); break; case META_GTK_COLOR_TEXT_AA: gtk_style_context_get_color (context, state, color); set_color_from_style (&other, context, state, META_GTK_COLOR_BASE); color->red = (color->red + other.red) / 2; color->green = (color->green + other.green) / 2; color->blue = (color->blue + other.blue) / 2; break; case META_GTK_COLOR_MID: meta_color_get_light_color (context, state, color); meta_color_get_dark_color (context, state, &other); color->red = (color->red + other.red) / 2; color->green = (color->green + other.green) / 2; color->blue = (color->blue + other.blue) / 2; break; case META_GTK_COLOR_LIGHT: meta_color_get_light_color (context, state, color); break; case META_GTK_COLOR_DARK: meta_color_get_dark_color (context, state, color); break; case META_GTK_COLOR_LAST: default: g_assert_not_reached (); break; } }
wxFont wxSystemSettingsNative::GetFont( wxSystemFont index ) { wxFont font; switch (index) { case wxSYS_OEM_FIXED_FONT: case wxSYS_ANSI_FIXED_FONT: case wxSYS_SYSTEM_FIXED_FONT: font = *wxNORMAL_FONT; break; case wxSYS_ANSI_VAR_FONT: case wxSYS_SYSTEM_FONT: case wxSYS_DEVICE_DEFAULT_FONT: case wxSYS_DEFAULT_GUI_FONT: if (!gs_fontSystem.IsOk()) { wxNativeFontInfo info; #ifdef __WXGTK3__ GtkStyleContext* sc = gtk_widget_get_style_context(ButtonWidget()); gtk_style_context_set_state(sc, GTK_STATE_FLAG_NORMAL); gtk_style_context_get(sc, GTK_STATE_FLAG_NORMAL, GTK_STYLE_PROPERTY_FONT, &info.description, NULL); #else info.description = ButtonStyle()->font_desc; #endif gs_fontSystem = wxFont(info); #if wxUSE_FONTENUM // (try to) heal the default font (on some common systems e.g. Ubuntu // it's "Sans Serif" but the real font is called "Sans"): if (!wxFontEnumerator::IsValidFacename(gs_fontSystem.GetFaceName()) && gs_fontSystem.GetFaceName() == "Sans Serif") { gs_fontSystem.SetFaceName("Sans"); } #endif // wxUSE_FONTENUM #ifndef __WXGTK3__ info.description = NULL; #endif } font = gs_fontSystem; break; default: break; } wxASSERT( font.IsOk() ); return font; }
static void gm_cell_renderer_expander_render (GtkCellRenderer *cell, cairo_t *cr, GtkWidget *widget, G_GNUC_UNUSED const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags) { GmCellRendererExpander *expander; GmCellRendererExpanderPriv *priv; gint x_offset, y_offset; guint xpad, ypad; GtkStyleContext *style; GtkStateFlags state; expander = (GmCellRendererExpander *) cell; priv = expander->priv; gm_cell_renderer_expander_get_size (cell, widget, (GdkRectangle *) cell_area, &x_offset, &y_offset, NULL, NULL); g_object_get (cell, "xpad", &xpad, "ypad", &ypad, NULL); style = gtk_widget_get_style_context (widget); gtk_style_context_save (style); gtk_style_context_add_class (style, GTK_STYLE_CLASS_EXPANDER); state = gtk_cell_renderer_get_state (cell, widget, flags); if (priv->expander_style == GTK_EXPANDER_COLLAPSED) state |= GTK_STATE_FLAG_NORMAL; else state |= GTK_STATE_FLAG_ACTIVE; gtk_style_context_set_state (style, state); gtk_render_expander (style, cr, cell_area->x + x_offset + xpad, cell_area->y + y_offset + ypad, priv->expander_size, priv->expander_size); gtk_style_context_restore (style); }
static void ide_omni_bar_popover_closed (IdeOmniBar *self, GtkPopover *popover) { GtkStyleContext *style_context; GtkStateFlags state_flags; g_assert (IDE_IS_OMNI_BAR (self)); g_assert (GTK_IS_POPOVER (popover)); style_context = gtk_widget_get_style_context (GTK_WIDGET (self)); state_flags = gtk_style_context_get_state (style_context); gtk_style_context_set_state (style_context, state_flags & ~GTK_STATE_FLAG_ACTIVE); }
static gboolean draw_cb_checks (GtkWidget *widget, cairo_t *cr) { GtkStyleContext *context; context = gtk_widget_get_style_context (widget); gtk_style_context_save (context); gtk_style_context_add_class (context, "check"); gtk_style_context_set_state (context, 0); gtk_render_check (context, cr, 12, 12, 12, 12); gtk_style_context_set_state (context, GTK_STATE_FLAG_ACTIVE); gtk_render_check (context, cr, 36, 12, 12, 12); gtk_style_context_set_state (context, GTK_STATE_FLAG_INCONSISTENT); gtk_render_check (context, cr, 60, 12, 12, 12); gtk_style_context_set_state (context, GTK_STATE_FLAG_INSENSITIVE); gtk_render_check (context, cr, 84, 12, 12, 12); gtk_style_context_restore (context); return TRUE; }
static gboolean draw_cb_expanders (GtkWidget *widget, cairo_t *cr) { GtkStyleContext *context; context = gtk_widget_get_style_context (widget); gtk_style_context_save (context); gtk_style_context_add_class (context, "expander"); gtk_style_context_set_state (context, 0); gtk_render_expander (context, cr, 12, 12, 12, 12); gtk_style_context_set_state (context, GTK_STATE_FLAG_PRELIGHT); gtk_render_expander (context, cr, 36, 12, 12, 12); gtk_style_context_set_state (context, GTK_STATE_FLAG_ACTIVE); gtk_render_expander (context, cr, 60, 12, 12, 12); gtk_style_context_set_state (context, GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_ACTIVE); gtk_render_expander (context, cr, 84, 12, 12, 12); gtk_style_context_restore (context); return TRUE; }
static void draw_horizontal_scrollbar (GtkWidget *widget, cairo_t *cr, gint x, gint y, gint width, gint height, gint position, GtkStateFlags state) { GtkStyleContext *scrollbar_context; GtkStyleContext *trough_context; GtkStyleContext *slider_context; /* This information is taken from the GtkScrollbar docs, see "CSS nodes" */ const char *path[3] = { "scrollbar.horizontal", "trough", "slider" }; scrollbar_context = get_style (NULL, path[0]); trough_context = get_style (scrollbar_context, path[1]); slider_context = get_style (trough_context, path[2]); gtk_style_context_set_state (scrollbar_context, state); gtk_style_context_set_state (trough_context, state); gtk_style_context_set_state (slider_context, state); gtk_render_background (trough_context, cr, x, y, width, height); gtk_render_frame (trough_context, cr, x, y, width, height); gtk_render_slider (slider_context, cr, x + position, y + 1, 30, height - 2, GTK_ORIENTATION_HORIZONTAL); g_object_unref (slider_context); g_object_unref (trough_context); g_object_unref (scrollbar_context); }