static void init_styles(BudgiePanel *self)
{
GtkCssProvider *css_provider;
GFile *file = NULL;
GdkScreen *screen;
screen = gdk_screen_get_default();
/* Fallback */
css_provider = gtk_css_provider_new();
file = g_file_new_for_uri("resource://com/evolve-os/budgie/panel/style.css");
if (gtk_css_provider_load_from_file(css_provider, file, NULL)) {
gtk_style_context_add_provider_for_screen(screen,
GTK_STYLE_PROVIDER(css_provider),
GTK_STYLE_PROVIDER_PRIORITY_FALLBACK);
}
g_object_unref(css_provider);
g_object_unref(file);
/* Forced */
css_provider = gtk_css_provider_new();
file = g_file_new_for_uri("resource://com/evolve-os/budgie/panel/app.css");
if (gtk_css_provider_load_from_file(css_provider, file, NULL)) {
gtk_style_context_add_provider_for_screen(screen,
GTK_STYLE_PROVIDER(css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
g_object_unref(css_provider);
g_object_unref(file);
}
static void
plugin_action (GAction *action,
GVariant *parameter,
gpointer data)
{
const char *action_name;
const char *css_to_load;
GtkCssProvider *css_provider;
action_name = g_action_get_name (action);
if (strcmp (action_name, "red") == 0)
css_to_load = red_css;
else if (strcmp (action_name, "black") == 0)
css_to_load = black_css;
else
{
g_critical ("Unknown action name: %s", action_name);
return;
}
g_message ("Color: %s", g_action_get_name (action));
css_provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (css_provider, css_to_load, -1);
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
GTK_STYLE_PROVIDER (css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
int main(int argc, char ** argv)
{
/* Init GTK+ */
gtk_init( &argc, &argv );
builder = gtk_builder_new();
MainWindow* window = new MainWindow(GTK_BUILDER(builder));
gtk_builder_connect_signals( GTK_BUILDER(builder), window );
/* ============== CSS ============== */
GtkCssProvider *provider;
GdkDisplay *display;
GdkScreen *screen;
provider = 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),
GTK_STYLE_PROVIDER_PRIORITY_USER);
gtk_css_provider_load_from_path(GTK_CSS_PROVIDER(provider), "style.css", NULL);
g_object_unref (provider);
/* ============== /// ============== */
/* Start main loop */
gtk_main();
return 0;
}
static void
gcal_application_startup (GApplication *app)
{
GcalApplicationPrivate *priv;
GError *error;
priv = GCAL_APPLICATION (app)->priv;
G_APPLICATION_CLASS (gcal_application_parent_class)->startup (app);
if (gtk_clutter_init (NULL, NULL) < 0)
{
g_error (_("Unable to initialize GtkClutter"));
g_application_quit (app);
}
if (priv->provider == NULL)
{
priv->provider = gtk_css_provider_new ();
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
GTK_STYLE_PROVIDER (priv->provider),
G_MAXUINT);
error = NULL;
gtk_css_provider_load_from_path (priv->provider, CSS_FILE, &error);
if (error != NULL)
g_warning ("Error loading stylesheet from file %s. %s", CSS_FILE, error->message);
}
priv->manager = gcal_manager_new ();
gcal_application_set_app_menu (app);
}
void
empathy_set_css_provider (GtkWidget *widget)
{
GtkCssProvider *provider;
gchar *filename;
GError *error = NULL;
GdkScreen *screen;
filename = empathy_file_lookup ("empathy.css", "data");
provider = gtk_css_provider_new ();
if (!gtk_css_provider_load_from_path (provider, filename, &error))
{
g_warning ("Failed to load css file '%s': %s", filename, error->message);
g_error_free (error);
goto out;
}
if (widget != NULL)
screen = gtk_widget_get_screen (widget);
else
screen = gdk_screen_get_default ();
gtk_style_context_add_provider_for_screen (screen,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
out:
g_free (filename);
g_object_unref (provider);
}
int
main (int argc, char* argv[])
{
gtk_init(&argc, &argv);
/* register signal handler */
signal(SIGHUP, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
GtkCssProvider *provider = gtk_css_provider_new();
gtk_css_provider_load_from_data(provider, TINYTERM_STYLE, strlen(TINYTERM_STYLE), NULL);
gtk_style_context_add_provider_for_screen(
gdk_screen_get_default(), provider,
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
GtkApplication *app;
int status;
app = gtk_application_new("org.nhoad.tinyterm", G_APPLICATION_HANDLES_COMMAND_LINE);
_application = G_APPLICATION(app);
g_signal_connect(app, "activate", G_CALLBACK(activate), NULL);
g_signal_connect(app, "command-line", G_CALLBACK(command_line), NULL);
status = g_application_run(G_APPLICATION(app), argc, argv);
g_object_unref(app);
return status;
}
GtkWidget *
do_css_blendmodes (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkStyleProvider *provider;
GtkBuilder *builder;
builder = gtk_builder_new_from_resource ("/css_blendmodes/blendmodes.ui");
window = WID ("window");
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
/* Setup the CSS provider for window */
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
provider,
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
setup_listbox (builder, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
static void
ide_keybindings_load_plugin (IdeKeybindings *self,
PeasPluginInfo *plugin_info,
PeasEngine *engine)
{
g_autofree gchar *path = NULL;
const gchar *module_name;
g_autoptr(GBytes) bytes = NULL;
g_autoptr(GtkCssProvider) provider = NULL;
g_assert (IDE_IS_KEYBINDINGS (self));
g_assert (plugin_info != NULL);
g_assert (PEAS_IS_ENGINE (engine));
if (!self->mode || !self->plugin_providers)
return;
module_name = peas_plugin_info_get_module_name (plugin_info);
path = g_strdup_printf ("/org/gnome/builder/plugins/%s/keybindings/%s.css",
module_name, self->mode);
bytes = g_resources_lookup_data (path, 0, NULL);
if (bytes == NULL)
return;
IDE_TRACE_MSG ("Loading %s keybindings for \"%s\" plugin", self->mode, module_name);
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_resource (provider, path);
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);
g_hash_table_insert (self->plugin_providers,
g_strdup (module_name),
g_steal_pointer (&provider));
}
static void
ide_keybindings_constructed (GObject *object)
{
IdeKeybindings *self = (IdeKeybindings *)object;
PeasEngine *engine;
GdkScreen *screen;
IDE_ENTRY;
self->constructed = TRUE;
G_OBJECT_CLASS (ide_keybindings_parent_class)->constructed (object);
screen = gdk_screen_get_default ();
engine = peas_engine_get_default ();
g_signal_connect_object (engine,
"load-plugin",
G_CALLBACK (ide_keybindings_load_plugin),
self,
G_CONNECT_AFTER | G_CONNECT_SWAPPED);
g_signal_connect_object (engine,
"unload-plugin",
G_CALLBACK (ide_keybindings_unload_plugin),
self,
G_CONNECT_SWAPPED);
gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (self->css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
ide_keybindings_reload (self);
IDE_EXIT;
}
static void
_gth_window_add_css_provider (GtkWidget *widget,
const char *path)
{
GBytes *bytes;
gconstpointer css_data;
gsize css_data_size;
GtkCssProvider *css_provider;
GError *error = NULL;
bytes = g_resources_lookup_data (path, 0, &error);
if (bytes == NULL) {
g_warning ("%s", error->message);
g_error_free (error);
return;
}
css_data = g_bytes_get_data (bytes, &css_data_size);
css_provider = gtk_css_provider_new ();
if (! gtk_css_provider_load_from_data (css_provider, css_data, css_data_size, &error)) {
g_warning ("%s", error->message);
g_error_free (error);
}
gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (widget),
GTK_STYLE_PROVIDER (css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (css_provider);
g_bytes_unref (bytes);
}
void side_set_application_mode(int type)
{
GSettings *theme = g_settings_new("org.jetspace.desktop.session");
GdkDisplay *display;
GdkScreen *screen;
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
mode = type;
if(g_variant_get_boolean(g_settings_get_value(theme, "use-custom-theme")))
{
GtkCssProvider *provider;
provider = gtk_css_provider_new ();
gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
gsize bytes, read;
const gchar* t = g_strdup_printf( "%s%s",g_variant_get_string(g_settings_get_value(theme, "custom-theme-path"), NULL), "/side-session/gtk.css");
if(access(t, F_OK) != 0)
{
system("side-notifier --theme-not-found &");
return;
}
gtk_css_provider_load_from_path (provider,g_filename_to_utf8(t, strlen(t), &read, &bytes, NULL),NULL);
g_object_unref (provider);
}
}
static void
nemo_application_add_app_css_provider (void)
{
GtkCssProvider *provider;
GError *error = NULL;
GdkScreen *screen;
provider = gtk_css_provider_new ();
if (!css_provider_load_from_resource (provider, "/org/nemo/nemo-style-fallback.css", &error))
{
g_warning ("Failed to load fallback css file: %s", error->message);
if (error->message != NULL)
g_error_free (error);
goto out_a;
}
screen = gdk_screen_get_default ();
gtk_style_context_add_provider_for_screen (screen,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_FALLBACK);
out_a:
g_object_unref (provider);
provider = gtk_css_provider_new ();
if (!css_provider_load_from_resource (provider, "/org/nemo/nemo-style-application.css", &error))
{
g_warning ("Failed to load application css file: %s", error->message);
if (error->message != NULL)
g_error_free (error);
goto out_b;
}
screen = gdk_screen_get_default ();
gtk_style_context_add_provider_for_screen (screen,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
out_b:
g_object_unref (provider);
}
static VALUE
rg_add_provider(VALUE self, VALUE provider, VALUE priority)
{
gtk_style_context_add_provider_for_screen(_SELF(self),
RVAL2GTKSTYLEPROVIDER(provider),
NUM2UINT(priority));
return self;
}
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, NULL);
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_header_bar_new ();
button = gtk_button_new_with_label ("Title");
g_signal_connect (button, "clicked", G_CALLBACK (change_title), footer);
gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button);
gtk_header_bar_set_custom_title (GTK_HEADER_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_header_bar_pack_start (GTK_HEADER_BAR (footer), button);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle"));
button = gtk_button_new_with_label ("Subtitle");
g_signal_connect (button, "clicked", G_CALLBACK (change_subtitle), NULL);
gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button);
button = gtk_button_new_with_label ("Fullscreen");
gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button);
g_signal_connect (button, "clicked", G_CALLBACK (toggle_fullscreen), window);
gtk_box_pack_end (GTK_BOX (box), footer, FALSE, FALSE, 0);
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, 0);
gtk_widget_show_all (window);
gtk_main ();
gtk_widget_destroy (window);
return 0;
}
GtkWidget *factory_build_main_window()
{
GtkCssProvider *provider;
GdkScreen *screen;
GtkWidget *tabbar;
GtkWidget *window;
GtkWidget *scroll;
GtkWidget *vbox;
GtkWidget *ebox;
/* load css and apply style */
provider = gtk_css_provider_new();
screen = gdk_screen_get_default();
gtk_css_provider_load_from_file(provider, g_file_new_for_path("style.css"), NULL);
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER);
/* setup elements */
tabbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous(GTK_BOX(tabbar), true);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "awb");
gtk_window_set_resizable(GTK_WINDOW(window), false);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
ebox = gtk_event_box_new();
/* link to gui struct */
awb.gui.tabbar = tabbar;
awb.gui.window = window;
awb.gui.scrollarea = scroll;
awb.gui.inbox = ebox;
GtkWidget *scrollarea = factory_build_history();
/* packing */
gtk_box_pack_start(GTK_BOX(vbox), tabbar, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), scroll, 1, 1, 0);
gtk_box_pack_end(GTK_BOX(vbox), ebox, 0, 0, 0);
gtk_box_pack_end(GTK_BOX(vbox), factory_build_inputbar(), 0, 0, 0);
gtk_box_pack_end(GTK_BOX(vbox), scrollarea /*factory_build_history()*/, 0, 0, 0);
gtk_box_pack_end(GTK_BOX(vbox), factory_build_statusbar(), 0, 0, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
awb_new_tab("about:blank");
gtk_widget_show_all(awb.gui.window);
gtk_widget_set_visible(awb.gui.statusbar.ssl, false);
gtk_widget_set_visible(awb.gui.inputbar.widget, false);
gtk_widget_set_visible(awb.gui.tabbar, false);
gtk_widget_set_visible(awb.gui.history, false);
gtk_widget_set_visible(GTK_WIDGET(gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(scrollarea))), false);
return window;
}
static void
gt_win_init(GtWin* self)
{
GtWinPrivate* priv = gt_win_get_instance_private(self);
GPropertyAction* action;
GT_TYPE_PLAYER; // Hack to load GtPlayer into the symbols table
GT_TYPE_PLAYER_HEADER_BAR;
GT_TYPE_BROWSE_HEADER_BAR;
GT_TYPE_CHANNELS_VIEW;
GT_TYPE_GAMES_VIEW;
GT_TYPE_FOLLOWS_VIEW;
GT_TYPE_CHAT;
gtk_window_set_application(GTK_WINDOW(self), GTK_APPLICATION(main_app));
gtk_widget_init_template(GTK_WIDGET(self));
gtk_widget_realize(priv->player_header_bar);
priv->cur_info_data = NULL;
priv->info_queue = g_queue_new();
gtk_window_set_default_size(GTK_WINDOW(self),
g_settings_get_int(main_app->settings, "window-width"),
g_settings_get_int(main_app->settings, "window-height"));
gtk_window_set_default_icon_name("gnome-twitch");
g_object_bind_property(priv->browse_stack, "visible-child",
self, "visible-view",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
GdkScreen* screen = gdk_screen_get_default();
GtkCssProvider* css = gtk_css_provider_new();
gtk_css_provider_load_from_resource(css, "/com/vinszent/GnomeTwitch/com.vinszent.GnomeTwitch.style.css");
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_signal_connect_after(self, "key-press-event", G_CALLBACK(key_press_cb), self);
g_signal_connect(self, "delete-event", G_CALLBACK(delete_cb), self);
g_signal_connect_after(priv->info_bar, "response", G_CALLBACK(close_info_bar_cb), self);
g_action_map_add_action_entries(G_ACTION_MAP(self),
win_actions,
G_N_ELEMENTS(win_actions),
self);
action = g_property_action_new("toggle_fullscreen", self, "fullscreen");
g_action_map_add_action(G_ACTION_MAP(self),
G_ACTION(action));
g_object_unref(action);
GtkWindowGroup* window_group = gtk_window_group_new();
gtk_window_group_add_window(window_group, GTK_WINDOW(self));
g_object_unref(window_group);
}
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);
}
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);
}
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);
}
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);
}
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
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);
}
/**************************************************************************
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
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);
}
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));
}
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);
}
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;
}
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);
}
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;
}
