void cc_set_css(GtkWidget*w,gchar*file) { GFile *cssfile=g_file_new_for_path(file); GtkCssProvider*provider=gtk_css_provider_new(); GtkStyleContext*context=gtk_widget_get_style_context(w); gtk_style_context_add_provider(context,GTK_STYLE_PROVIDER(provider),GTK_STYLE_PROVIDER_PRIORITY_USER); gtk_css_provider_load_from_file(GTK_CSS_PROVIDER(provider),cssfile,NULL); g_object_unref(provider); }
static cairo_surface_t * tile_surface (cairo_surface_t *surface, int width, int height) { cairo_surface_t *copy; cairo_t *cr; if (surface == NULL) { copy = gdk_window_create_similar_surface (gdk_get_default_root_window (), CAIRO_CONTENT_COLOR, width, height); } else { copy = cairo_surface_create_similar (surface, cairo_surface_get_content (surface), width, height); } cr = cairo_create (copy); if (surface != NULL) { cairo_pattern_t *pattern; cairo_set_source_surface (cr, surface, 0.0, 0.0); pattern = cairo_get_source (cr); cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT); } else { GtkStyleContext *context; GdkRGBA bg; context = gtk_style_context_new (); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (gtk_css_provider_get_default ()), GTK_STYLE_PROVIDER_PRIORITY_THEME); gtk_style_context_get_background_color (context, GTK_STATE_FLAG_NORMAL, &bg); gdk_cairo_set_source_rgba(cr, &bg); g_object_unref (G_OBJECT (context)); } cairo_paint (cr); if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) { cairo_surface_destroy (copy); copy = NULL; } cairo_destroy(cr); return copy; }
static void gs_feature_tile_init (GsFeatureTile *tile) { gtk_widget_set_has_window (GTK_WIDGET (tile), FALSE); gtk_widget_init_template (GTK_WIDGET (tile)); tile->provider = gtk_css_provider_new (); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (tile->provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *box; GtkWidget *footer; GtkWidget *button; GtkWidget *content; GtkCssProvider *provider; gtk_init (NULL, NULL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_style_context_add_class (gtk_widget_get_style_context (window), "main"); provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, css, -1); gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (window), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_USER); change_header (NULL, window); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), box); footer = gtk_action_bar_new (); gtk_action_bar_set_center_widget (GTK_ACTION_BAR (footer), gtk_check_button_new_with_label ("Middle")); button = gtk_toggle_button_new_with_label ("Custom"); g_signal_connect (button, "clicked", G_CALLBACK (change_header), window); gtk_action_bar_pack_start (GTK_ACTION_BAR (footer), button); button = gtk_button_new_with_label ("Subtitle"); g_signal_connect (button, "clicked", G_CALLBACK (change_subtitle), NULL); gtk_action_bar_pack_end (GTK_ACTION_BAR (footer), button); button = gtk_button_new_with_label ("Fullscreen"); gtk_action_bar_pack_end (GTK_ACTION_BAR (footer), button); g_signal_connect (button, "clicked", G_CALLBACK (toggle_fullscreen), window); gtk_box_pack_end (GTK_BOX (box), footer, FALSE, FALSE); content = gtk_image_new_from_icon_name ("start-here-symbolic", GTK_ICON_SIZE_DIALOG); gtk_image_set_pixel_size (GTK_IMAGE (content), 512); gtk_box_pack_start (GTK_BOX (box), content, FALSE, TRUE); gtk_widget_show_all (window); gtk_main (); gtk_widget_destroy (window); return 0; }
void side_modify_css(char *str) { GdkDisplay *display; GdkScreen *screen; display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); GtkCssProvider *provider; provider = gtk_css_provider_new (); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gtk_css_provider_load_from_data(provider, str, -1, NULL); g_object_unref (provider); }
void gnc_add_css_file (void) { GtkCssProvider *provider_user, *provider_app, *provider_fallback; GdkDisplay *display; GdkScreen *screen; const gchar *var; GError *error = 0; provider_user = gtk_css_provider_new (); provider_app = gtk_css_provider_new (); provider_fallback = gtk_css_provider_new (); display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider_fallback), GTK_STYLE_PROVIDER_PRIORITY_FALLBACK); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider_app), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider_user), GTK_STYLE_PROVIDER_PRIORITY_USER); #if GTK_CHECK_VERSION(3,20,0) gtk_css_provider_load_from_resource (provider_app, "/org/gnucash/gnucash-320.css"); #else gtk_css_provider_load_from_resource (provider_app, "/org/gnucash/gnucash-310.css"); #endif gtk_css_provider_load_from_resource (provider_fallback, "/org/gnucash/gnucash-fallback-310.css"); var = g_get_home_dir (); if (var) { gchar *str; str = g_build_filename (var, ".gtk-3.0-gnucash.css", (char *)NULL); gtk_css_provider_load_from_path (provider_user, str, &error); g_free (str); } g_object_unref (provider_user); g_object_unref (provider_app); g_object_unref (provider_fallback); }
static void set_button_style(GtkWidget *button, gint type) { #if GTK_CHECK_VERSION(2, 90, 0) GtkStyleContext *context = gtk_widget_get_style_context(button); GtkCssProvider *provider = gtk_css_provider_new(); switch (type) { case TYPE_ICON: gtk_css_provider_load_from_data(provider, "#uim-systray-button {\n" " -GtkWidget-focus-line-width: 0;\n" " -GtkWidget-focus-padding: 0;\n" " padding-top: 0;\n" " padding-bottom: 0;\n" " padding-left: 2px;\n" " padding-right: 2px;\n" "}\n", -1, NULL); break; case TYPE_STANDALONE: gtk_css_provider_load_from_data(provider, "#uim-toolbar-button {\n" " padding-left: 5px;\n" " padding-right: 5px;\n" "}\n", -1, NULL); break; case TYPE_APPLET: gtk_css_provider_load_from_data(provider, "#uim-applet-button {\n" " padding-left: 2px;\n" " padding-right: 2px;\n" "}\n", -1, NULL); break; } gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref(provider); #endif switch (type) { case TYPE_ICON: gtk_widget_set_name(button, "uim-systray-button"); break; case TYPE_STANDALONE: gtk_widget_set_name(button, "uim-toolbar-button"); break; case TYPE_APPLET: gtk_widget_set_name(button, "uim-applet-button"); break; } }
void Editor::setStyle() { GtkCssProvider *provider = gtk_css_provider_get_default(); GdkDisplay *display = gdk_display_get_default(); GdkScreen *screen = gdk_display_get_default_screen(display); OovString path = Project::getBinDirectory(); path += "OovEdit.css"; GError *err = 0; gtk_css_provider_load_from_path(provider, path.getStr(), &err); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref(provider); }
GtkWidget *gtk_paned_new_with_handle(GtkOrientation orientation) { GtkWidget *pnd = gtk_paned_new(orientation); GtkStyleContext *context = gtk_widget_get_style_context(pnd); GtkCssProvider *cssprv = gtk_css_provider_new(); GdkRGBA clrSel = {0.,0.,0.,0.}; char css[2048]; gtk_style_context_lookup_color(context, "bg_color", &clrSel); if (orientation == GTK_ORIENTATION_HORIZONTAL) { sprintf(css, "* {\n -GtkPaned-handle-size: 3; \n } \n .pane-separator.horizontal {\n background-image: -gtk-gradient (linear, left top, left bottom, from (%s), color-stop (0.5, shade (%s, 0.95)), to (%s)); \n -unico-centroid-texture: url(\"%s\");\n }\n", gdk_rgba_to_string(&clrSel), gdk_rgba_to_string(&clrSel), gdk_rgba_to_string(&clrSel), imgOrzHnd); } else { sprintf(css, "* {\n -GtkPaned-handle-size: 3; \n } \n \n .pane-separator.vertical {\n background-image: -gtk-gradient (linear, left top, right top, from (%s), color-stop (0.5, shade (%s, 0.95)), to (%s)); \n -unico-centroid-texture: url(\"%s\");\n }\n", gdk_rgba_to_string(&clrSel), gdk_rgba_to_string(&clrSel), gdk_rgba_to_string(&clrSel), imgVrtHnd); } gtk_style_context_remove_provider(context, GTK_STYLE_PROVIDER (cssprv)); gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER (cssprv), GTK_STYLE_PROVIDER_PRIORITY_USER); gtk_css_provider_load_from_data(cssprv, css, -1, NULL); g_object_unref(cssprv); return pnd; }
static void add_css_provider (GApplication *application, gboolean theme) { gs_unref_object GtkCssProvider *provider; provider = gtk_css_provider_new (); if (!load_css_from_resource (application, provider, theme)) return; gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); }
void theme_init(){ char *theme_file; theme_file = get_theme_file("default.css"); if (!theme_file){ return; } provider = GTK_STYLE_PROVIDER(gtk_css_provider_new()); gtk_css_provider_load_from_path( GTK_CSS_PROVIDER(provider), theme_file, NULL); g_free(theme_file); }
static void button_clicked_cb (GtkButton *b, gpointer user_data) { PackData *d = user_data; GtkCssProvider *provider; GtkStyleContext *style; GError *error = NULL; gchar *data, *bg_str, *grad1, *grad2; const gchar data_format[] = "GtkNumerableIcon { background-color: %s; color: #000000;" "background-image: -gtk-gradient (linear, 0 0, 1 1, from(%s), to(%s));" "font: Monospace 12;" /* "background-image: url('apple-red.png');" */ "}"; bg_str = g_strdup_printf ("rgb(%d,%d,%d)", g_random_int_range (0, 255), g_random_int_range (0, 255), g_random_int_range (0, 255)); grad1 = g_strdup_printf ("rgb(%d,%d,%d)", g_random_int_range (0, 255), g_random_int_range (0, 255), g_random_int_range (0, 255)); grad2 = g_strdup_printf ("rgb(%d,%d,%d)", g_random_int_range (0, 255), g_random_int_range (0, 255), g_random_int_range (0, 255)); data = g_strdup_printf (data_format, bg_str, grad1, grad2); provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, data, -1, &error); g_assert (error == NULL); style = gtk_widget_get_style_context (d->image); gtk_style_context_add_provider (style, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_USER); if (d->odd) { gtk_numerable_icon_set_background_icon_name (GTK_NUMERABLE_ICON (d->numerable), NULL); gtk_numerable_icon_set_count (GTK_NUMERABLE_ICON (d->numerable), g_random_int_range (-99, 99)); } else { gtk_numerable_icon_set_background_icon_name (GTK_NUMERABLE_ICON (d->numerable), "emblem-favorite"); gtk_numerable_icon_set_label (GTK_NUMERABLE_ICON (d->numerable), "IVX"); } gtk_image_set_from_gicon (GTK_IMAGE (d->image), d->numerable, d->size); d->odd = !d->odd; g_free (data); g_free (bg_str); g_free (grad1); g_free (grad2); g_object_unref (provider); }
static void test_init_of_theme (void) { GtkStyleContext *context; GtkCssProvider *provider; GtkWidgetPath *path; GdkRGBA before, after; char *css; /* Test that a style context actually uses the theme loaded for the * screen it is using. If no screen is set, it's the default one. */ context = gtk_style_context_new (); path = gtk_widget_path_new (); /* Set a path that will have a color set. * (This could actually fail if style classes change, so if this test * fails, make sure to have this path represent something sane.) */ gtk_widget_path_append_type (path, GTK_TYPE_WINDOW); gtk_widget_path_iter_add_class (path, -1, GTK_STYLE_CLASS_BACKGROUND); gtk_style_context_set_path (context, path); gtk_widget_path_free (path); /* Get the color. This should be initialized by the theme and not be * the default. */ gtk_style_context_get_color (context, gtk_style_context_get_state (context), &before); /* Add a style that sets a different color for this widget. * This style has a higher priority than fallback, but a lower * priority than the theme. */ css = g_strdup_printf (".background { color: %s; }", before.alpha < 0.5 ? "black" : "transparent"); provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, css, -1, NULL); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_FALLBACK + 1); g_object_unref (provider); /* Get the color again. */ gtk_style_context_get_color (context, gtk_style_context_get_state (context), &after); /* Because the style we added does not influence the color, * the before and after colors should be identical. */ g_assert (gdk_rgba_equal (&before, &after)); g_object_unref (context); }
int main(int argc, char* argv[]) { GtkWidget *win; GtkCssProvider *cssprovider; GdkScreen *screen; GError *error; /* Disable global menus */ g_unsetenv ("UBUNTU_MENUPROXY"); gtk_init(&argc, &argv); ido_init (); screen = gdk_screen_get_default(); win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (win), -1, 28); g_signal_connect(win, "realize", G_CALLBACK(on_realize), NULL); g_signal_connect(screen, "monitors-changed", G_CALLBACK(on_screen_change), win); g_signal_connect(screen, "size-changed", G_CALLBACK(on_screen_change), win); cssprovider = gtk_css_provider_new (); gtk_css_provider_load_from_data(cssprovider, "GtkMenuBar {\n" " -GtkMenuBar-internal-padding: 0;\n" " -GtkMenuBar-shadow-type: none;\n" "}\n" "GtkWidget {\n" " -GtkWidget-focus-line-width: 0;\n" " -GtkWidget-focus-padding: 0;\n" "}\n", -1, NULL); gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER (cssprovider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); GtkWidget* menubar = gtk_menu_bar_new(); load_indicator_files (INDICATOR_DIR, menubar); IndicatorObject * io = indicator_object_new_from_file("/usr/lib/indicators3/7/libapplication.so"); load_indicator(io, menubar); GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); gtk_container_add(GTK_CONTAINER(win), hbox); gtk_box_pack_end(GTK_BOX(hbox), menubar, FALSE, FALSE, 0); g_signal_connect_after(menubar, "draw", G_CALLBACK(on_draw), NULL); g_signal_connect(win, "draw", G_CALLBACK(on_draw), NULL); gtk_widget_show_all(win); gdk_window_process_updates(gtk_widget_get_window(win), TRUE); gtk_widget_set_app_paintable(win, TRUE); gtk_main(); return 0; }
static void irc_application_activate (GApplication *self) { IrcApplicationPrivate *priv = irc_application_get_instance_private (IRC_APPLICATION(self)); if (priv->main_window == NULL) { priv->main_window = GTK_WINDOW(irc_window_new (self)); gtk_style_context_add_provider_for_screen (gtk_window_get_screen (priv->main_window), GTK_STYLE_PROVIDER(priv->css_provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); irc_application_load_plugins (IRC_APPLICATION(self)); // In-case plugins modify UI } gtk_window_present (priv->main_window); }
/************************************************************************** Updates a gui font style. **************************************************************************/ void gui_update_font(const char *font_name, const char *font_value) { char *str; GtkCssProvider *provider; str = g_strdup_printf("#Freeciv #%s { font: %s;}", font_name, font_value); provider = gtk_css_provider_new(); gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider), str, -1, NULL); gtk_style_context_add_provider_for_screen( gtk_widget_get_screen(toplevel), GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_free(str); }
static void add_custom_css (void) { GtkCssProvider *provider; const gchar data[] = "levelbar block.my-offset {" " background: magenta;" "}"; provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, data, -1); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); }
static void sc_button_set_style(GtkButton* button) { GtkCssProvider* provider; GtkStyleContext*context; provider=gtk_css_provider_new(); context=gtk_widget_get_style_context(GTK_WIDGET(button)); gtk_style_context_add_provider(context,GTK_STYLE_PROVIDER(provider),GTK_STYLE_PROVIDER_PRIORITY_USER); gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider),"GtkButton {border-radius:0px ;padding:0}",-1,NULL); g_object_unref(provider); }
static void gis_password_page_init (GisPasswordPage *page) { GtkCssProvider *provider; g_resources_register (password_get_resource ()); provider = gtk_css_provider_new (); gtk_css_provider_load_from_resource (provider, "/org/gnome/initial-setup/gis-password-page.css"); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref (provider); gtk_widget_init_template (GTK_WIDGET (page)); }
/** * anaconda_widget_apply_stylesheet: * @widget: The widget to apply the style data to. * @name: The name of the widget's stylesheet. * * Apply CSS data to a widget's #GtkStyleContext. The data will not affect any * other widgets, including children of this widget. * * The CSS data lives in the resource bundle, the advantage of which is that * the stylesheet is just a normal stylesheet in the source tree with normal * syntax highlighting and no weird C string stuff or anything. The * disadvantage is that the stylesheet can only be applied to one widget at a * time so there's a bunch of tiny little stylesheets in the resources * directory, but that's the world we live in. * * The stylesheet should live in the resources/ directory in the source tree * and will be fetched as /org/fedoraproject/anaconda/widgets/<name>.css. * * The stylesheet is added to the style context at one less than * #GTK_STYLE_PROVIDER_PRIORITY_APPLICATION so that the style will not * overridden by a sloppy wildcard in a theme somewhere, but it will be * overridden by the application-level stylesheet, which may include * product-specific customizations. * */ void anaconda_widget_apply_stylesheet(GtkWidget *widget, const gchar *name) { GtkCssProvider *style_provider; GtkStyleContext *style_context; gchar *resource_path; resource_path = g_strdup_printf("/org/fedoraproject/anaconda/widgets/%s.css", name); style_provider = gtk_css_provider_new(); gtk_css_provider_load_from_resource(style_provider, resource_path); g_free(resource_path); style_context = gtk_widget_get_style_context(widget); gtk_style_context_add_provider(style_context, GTK_STYLE_PROVIDER(style_provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION - 1); }
void cc_style_setup() { GtkCssProvider* provider=gtk_css_provider_new(); GdkScreen*screen=gdk_display_get_default_screen(gdk_display_get_default()); GFile* cssfile=g_file_new_for_path(STYLE_PATH "image.css"); gtk_css_provider_load_from_file(GTK_CSS_PROVIDER(provider),cssfile,NULL); gtk_style_context_add_provider_for_screen(screen,GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER); g_object_unref(provider); }
static void panel_menu_bar_init(PanelMenuBar* menubar) { #if GTK_CHECK_VERSION (3, 0, 0) GtkCssProvider *provider; #endif menubar->priv = PANEL_MENU_BAR_GET_PRIVATE(menubar); #if GTK_CHECK_VERSION (3, 0, 0) provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, "PanelMenuBar {\n" " border-width: 0px;\n" "}", -1, NULL); gtk_style_context_add_provider (gtk_widget_get_style_context (GTK_WIDGET (menubar)), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref (provider); #endif menubar->priv->info = NULL; menubar->priv->settings = g_settings_new (PANEL_MENU_BAR_SCHEMA); menubar->priv->applications_menu = create_applications_menu("mate-applications.menu", NULL, TRUE); menubar->priv->applications_item = panel_image_menu_item_new(); gtk_menu_item_set_label(GTK_MENU_ITEM(menubar->priv->applications_item), _("Applications")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menubar->priv->applications_item), menubar->priv->applications_menu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menubar->priv->applications_item); menubar->priv->places_item = panel_place_menu_item_new(FALSE); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menubar->priv->places_item); menubar->priv->desktop_item = panel_desktop_menu_item_new(FALSE, TRUE); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menubar->priv->desktop_item); panel_menu_bar_setup_tooltip(menubar); panel_menu_bar_update_visibility(menubar->priv->settings, NULL, menubar); g_signal_connect(menubar->priv->settings, "changed", G_CALLBACK (panel_menu_bar_update_visibility), menubar); panel_menu_bar_update_text_gravity(menubar); g_signal_connect(menubar, "screen-changed", G_CALLBACK(panel_menu_bar_update_text_gravity), NULL); }
int main(int argc, char* argv[]) { GtkWidget *win; GtkCssProvider *cssprovider; /* Disable global menus */ g_unsetenv ("UBUNTU_MENUPROXY"); gtk_init(&argc, &argv); win = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect(win, "realize", G_CALLBACK(on_realize), NULL); cssprovider = gtk_css_provider_new (); gtk_css_provider_load_from_data(cssprovider, "GtkMenuBar {\n" " -GtkMenuBar-internal-padding: 0;\n" " -GtkMenuBar-shadow-type: none;\n" "}\n" "GtkWidget {\n" " -GtkWidget-focus-line-width: 0;\n" " -GtkWidget-focus-padding: 0;\n" "}\n" ".menuitem {\n" " padding: 0px 0px 0px 0px;\n" "}\n", -1, NULL); gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER (cssprovider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); GtkWidget* menubar = gtk_menu_bar_new(); gtk_menu_bar_set_pack_direction(GTK_MENU_BAR(menubar), GTK_PACK_DIRECTION_RTL); int i; for(i = 0; indicators[i]; i++) { if (!load_module(indicators[i], menubar)) { g_error("Unable to load module"); } } GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); gtk_container_add(GTK_CONTAINER(win), hbox); gtk_box_pack_end(GTK_BOX(hbox), menubar, FALSE, FALSE, 0); g_signal_connect_after(menubar, "draw", G_CALLBACK(on_draw), NULL); g_signal_connect(win, "draw", G_CALLBACK(on_draw), NULL); gtk_widget_show_all(win); gdk_window_process_updates(gtk_widget_get_window(win), TRUE); gtk_widget_set_app_paintable(win, TRUE); gtk_main(); return 0; }
int main (int argc, char *argv[]) { GdkScreen *screen; GtkBuilder *builder; GtkWidget *window; GtkWidget *grid; GtkCssProvider *provider; GError *error = NULL; gtk_init (&argc, &argv); provider = gtk_css_provider_new (); if (!gtk_css_provider_load_from_path (provider, "style.css", &error)) { g_object_unref (provider); g_clear_error (&error); return 0; } screen = gdk_screen_get_default (); gtk_style_context_add_provider_for_screen ( screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref (provider); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Hello Theming"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); builder = gtk_builder_new (); gtk_builder_add_from_file (builder, "theming.ui", NULL); grid = (GtkWidget *)gtk_builder_get_object (builder, "grid"); gtk_container_add (GTK_CONTAINER (window), grid); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_widget_show_all (window); gtk_main (); g_object_unref (builder); return 0; }
static void panel_background_prepare_css () { GtkCssProvider *provider; provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, ".mate-custom-panel-background{\n" " background-color: rgba (0, 0, 0, 0);\n" " background-image: none;\n" "}", -1, NULL); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref (provider); }
gint main (gint argc, gchar *argv[]) { GtkBuilder *builder = NULL; GtkWindow *window = NULL; GActionGroup *group; GtkWidget *dockbin; GtkWidget *dockoverlay; GtkCssProvider *provider; GError *error = NULL; gtk_init (&argc, &argv); provider = gtk_css_provider_new (); gtk_css_provider_load_from_path (provider, "test-panel.css", &error); g_assert_no_error (error); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); builder = gtk_builder_new (); gtk_builder_add_callback_symbol (builder, "toggle_all", G_CALLBACK (toggle_all)); gtk_builder_add_from_file (builder, "test-panel.ui", &error); g_assert_no_error (error); window = GTK_WINDOW (gtk_builder_get_object (builder, "window")); g_signal_connect (window, "delete-event", gtk_main_quit, NULL); dockoverlay = GTK_WIDGET (gtk_builder_get_object (builder, "dockoverlay")); _pnl_dock_item_printf (PNL_DOCK_ITEM (dockoverlay)); dockbin = GTK_WIDGET (gtk_builder_get_object (builder, "dockbin")); group = gtk_widget_get_action_group (dockbin, "dockbin"); gtk_widget_insert_action_group (GTK_WIDGET (window), "dockbin", group); gtk_builder_connect_signals (builder, dockbin); gtk_window_present (window); gtk_main (); g_clear_object (&builder); return 0; }
static inline void force_no_focus_padding(GtkWidget* widget) { GtkCssProvider *provider; provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, "#PanelApplet-window-menu-applet-button {\n" " border-width: 0px;\n" " -GtkWidget-focus-line-width: 0px;\n" " -GtkWidget-focus-padding: 0px; }", -1, NULL); gtk_style_context_add_provider (gtk_widget_get_style_context (widget), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref (provider); gtk_widget_set_name(widget, "PanelApplet-window-menu-applet-button"); }
static void set_styles (void) { GtkCssProvider *provider; GdkScreen *screen; provider = gtk_css_provider_new (); if (!gtk_css_provider_load_from_data (provider, CSS, -1, NULL)) { g_assert_not_reached (); } screen = gdk_display_get_default_screen (gdk_display_get_default ()); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); }
/* * frame_update_titlebar_font * * Returns: void * Description: updates the titlebar font from the pango context, should * be called whenever the gtk style or font has changed */ void frame_update_titlebar_font (decor_frame_t *frame) { const PangoFontDescription *font_desc; PangoFontDescription *free_font_desc; PangoFontMetrics *metrics; PangoLanguage *lang; free_font_desc = NULL; frame = gwd_decor_frame_ref (frame); font_desc = get_titlebar_font (frame); if (!font_desc) { GtkCssProvider *provider = gtk_css_provider_get_default (); GtkStyleContext *context = gtk_style_context_new (); GtkWidgetPath *path = gtk_widget_path_new (); gtk_widget_path_prepend_type (path, GTK_TYPE_WIDGET); gtk_style_context_set_path (context, path); gtk_widget_path_free (path); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_FALLBACK); gtk_style_context_get (context, GTK_STATE_FLAG_NORMAL, "font", &free_font_desc, NULL); font_desc = (const PangoFontDescription *) free_font_desc; } pango_context_set_font_description (frame->pango_context, font_desc); lang = pango_context_get_language (frame->pango_context); metrics = pango_context_get_metrics (frame->pango_context, font_desc, lang); frame->text_height = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent (metrics)); gwd_decor_frame_unref (frame); pango_font_metrics_unref (metrics); if (free_font_desc) pango_font_description_free (free_font_desc); }
static void override_background_color (GtkWidget *widget, GdkRGBA *rgba) { gchar *css; GtkCssProvider *provider; provider = gtk_css_provider_new (); css = g_strdup_printf ("* { background-color: %s; }", gdk_rgba_to_string (rgba)); gtk_css_provider_load_from_data (provider, css, -1, NULL); g_free (css); gtk_style_context_add_provider (gtk_widget_get_style_context (widget), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref (provider); }