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);
}
