GtkWidget *
hitori_create_interface (Hitori *hitori)
{
GtkBuilder *builder;
GtkStyleContext *style_context;
GtkCssProvider *css_provider;
const PangoFontDescription *font;
GAction *action;
builder = gtk_builder_new_from_resource ("/org/gnome/Hitori/ui/hitori.ui");
gtk_builder_set_translation_domain (builder, PACKAGE);
gtk_builder_connect_signals (builder, hitori);
/* Setup the main window */
hitori->window = GTK_WIDGET (gtk_builder_get_object (builder, "hitori_main_window"));
hitori->drawing_area = GTK_WIDGET (gtk_builder_get_object (builder, "hitori_drawing_area"));
hitori->timer_label = GTK_LABEL (gtk_builder_get_object (builder, "hitori_timer"));
g_object_unref (builder);
/* Set up actions */
g_action_map_add_action_entries (G_ACTION_MAP (hitori), app_entries, G_N_ELEMENTS (app_entries), hitori);
g_action_map_add_action_entries (G_ACTION_MAP (hitori->window), win_entries, G_N_ELEMENTS (win_entries), hitori);
action = g_settings_create_action (hitori->settings, "board-size");
g_action_map_add_action (G_ACTION_MAP (hitori), action);
g_signal_connect (G_OBJECT (action), "notify::state", (GCallback) board_size_change_cb, hitori);
g_object_unref (action);
hitori->undo_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "undo"));
hitori->redo_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "redo"));
hitori->hint_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "hint"));
/* Set up font descriptions for the drawing area */
style_context = gtk_widget_get_style_context (hitori->drawing_area);
gtk_style_context_get (style_context,
gtk_style_context_get_state (style_context),
GTK_STYLE_PROPERTY_FONT, &font, NULL);
hitori->normal_font_desc = pango_font_description_copy (font);
hitori->painted_font_desc = pango_font_description_copy (font);
/* Load CSS for the drawing area */
css_provider = gtk_css_provider_new ();
gtk_css_provider_load_from_resource (css_provider, "/org/gnome/Hitori/ui/hitori.css");
gtk_style_context_add_provider (style_context, GTK_STYLE_PROVIDER (css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (css_provider);
/* Reset the timer */
hitori_reset_timer (hitori);
/* Disable undo/redo until a cell has been clicked. */
g_simple_action_set_enabled (hitori->undo_action, FALSE);
g_simple_action_set_enabled (hitori->redo_action, FALSE);
return hitori->window;
}
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
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 gboolean
tweak_css (gpointer unused)
{
GtkAllocation allocation;
GtkCssProvider *provider;
GtkStyleContext *context;
gchar *css_data;
/* XXX Restore progress bar to the way it was intended to look. */
gtk_widget_get_allocation (GVA_WIDGET_MAIN_STATUSBAR, &allocation);
css_data = g_strdup_printf (
"GtkProgressBar { "
"-GtkProgressBar-min-horizontal-bar-height: %u;"
" }",
allocation.height);
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider, css_data, -1, NULL);
g_free (css_data);
context = gtk_widget_get_style_context (GVA_WIDGET_MAIN_PROGRESS_BAR);
gtk_style_context_add_provider (
context, GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
/* Do not reschedule this callback. */
return FALSE;
}
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);
}
}
void changeColor(GtkColorButton *cb, gpointer data)
{
GtkStyleContext *context;
GdkRGBA fg, bg;
char *css;
GError *err = NULL;
context = gtk_widget_get_style_context(button);
if (current != NULL) {
gtk_style_context_remove_provider(context, GTK_STYLE_PROVIDER(current));
g_object_unref(current);
}
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(foreground), &fg);
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(background), &bg);
css = g_strdup_printf(CSSFormat,
(int) (fg.red * 255),
(int) (fg.green * 255),
(int) (fg.blue * 255),
(int) (bg.red * 255),
(int) (bg.green * 255),
(int) (bg.blue * 255));
current = gtk_css_provider_new();
if (gtk_css_provider_load_from_data(current, css, -1, &err) == FALSE)
g_error("error parsing CSS: %s", err->message);
gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(current), GTK_STYLE_PROVIDER_PRIORITY_USER);
g_free(css);
}
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 inline void force_no_focus_padding (GtkWidget *widget)
{
static gboolean first_time = TRUE;
GtkCssProvider *provider;
if (first_time) {
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider,
"#charpick-applet-button {\n"
"-GtkWidget-focus-line-width: 0px;\n"
"-GtkWidget-focus-padding: 0px;\n"
"}",
-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);
first_time = FALSE;
}
gtk_widget_set_name (widget, "charpick-applet-button");
}
/** \brief Create a right-align label
*
* \param[in] text text for the label
* \param[in] minimal use CSS to reduce size of use as statusbar widget
*
* \return GtkLabel
*/
static GtkWidget *create_label(const char *text, gboolean minimal,
GtkAlign alignment)
{
GtkWidget *label;
GtkCssProvider *provider;
GtkStyleContext *context;
GError *err = NULL;
label = gtk_label_new(text);
gtk_widget_set_halign(label, alignment);
if (minimal) {
provider = gtk_css_provider_new();
gtk_css_provider_load_from_data(provider, LABEL_CSS, -1, &err);
if (err != NULL) {
fprintf(stderr, "CSS error: %s\n", err->message);
g_error_free(err);
}
context = gtk_widget_get_style_context(label);
if (context != NULL) {
gtk_style_context_add_provider(context,
GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
}
}
return label;
}
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;
}
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;
}
static GtkWidget *newTabLabel(OovStringRef const tabText, GtkWidget *viewTopParent)
{
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add(GTK_CONTAINER(box), gtk_label_new(tabText));
GtkButton *button = GTK_BUTTON(gtk_button_new());
gtk_button_set_relief(button, GTK_RELIEF_NORMAL);
gtk_button_set_focus_on_click(button, false);
gtk_button_set_image(button,
gtk_image_new_from_icon_name("window-close", GTK_ICON_SIZE_SMALL_TOOLBAR)); //GTK_ICON_SIZE_MENU));
char const * const data = "* {\n"
"-GtkButton-default-border : 0px;\n"
"-GtkButton-default-outside-border : 0px;\n"
"-GtkButton-inner-border: 0px;\n"
"-GtkWidget-focus-line-width : 0px;\n"
"-GtkWidget-focus-padding : 0px;\n"
"padding: 0px;\n"
"}";
GtkCssProvider *provider = gtk_css_provider_new();
gtk_css_provider_load_from_data(provider, data, -1, NULL);
GtkStyleContext *context = gtk_widget_get_style_context(GTK_WIDGET(button));
gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
// gtk_box_pack_start(box, button, False, False, 0);
gtk_container_add(GTK_CONTAINER(box), GTK_WIDGET(button));
g_signal_connect(button, "clicked", G_CALLBACK(onTabLabelCloseClicked), viewTopParent);
gtk_widget_show_all(box);
return box;
}
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);
}
static void
gt_twitch_chat_view_init(GtTwitchChatView* self)
{
GtTwitchChatViewPrivate* priv = gt_twitch_chat_view_get_instance_private(self);
gtk_widget_init_template(GTK_WIDGET(self));
priv->action_group = g_simple_action_group_new();
priv->dark_theme_action = g_property_action_new("dark-theme", self, "dark-theme");
g_action_map_add_action(G_ACTION_MAP(priv->action_group), G_ACTION(priv->dark_theme_action));
priv->chat_css_provider = gtk_css_provider_new();
gtk_style_context_add_provider(gtk_widget_get_style_context(GTK_WIDGET(self)),
GTK_STYLE_PROVIDER(priv->chat_css_provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
priv->chat_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->chat_view));
priv->tag_table = gtk_text_buffer_get_tag_table(priv->chat_buffer);
priv->twitch_emotes = g_hash_table_new(g_direct_hash, g_direct_equal);
gtk_text_buffer_get_end_iter(priv->chat_buffer, &priv->bottom_iter);
priv->bottom_mark = gtk_text_buffer_create_mark(priv->chat_buffer, "end", &priv->bottom_iter, TRUE);
priv->chat = gt_twitch_chat_client_new();
priv->cur_chan = NULL;
priv->joined_channel = FALSE;
g_signal_connect(priv->chat_entry, "key-press-event", G_CALLBACK(key_press_cb), self);
g_signal_connect(self, "hierarchy-changed", G_CALLBACK(anchored_cb), self);
g_source_set_callback((GSource*) priv->chat->source, (GSourceFunc) twitch_chat_source_cb, self, NULL);
ADD_STYLE_CLASS(self, "gt-twitch-chat-view");
}
static GtkWidget *
create_combo (const char *name,
gboolean is_list)
{
GtkCellRenderer *cell_renderer;
GtkWidget *combo;
GtkCssProvider *provider;
GtkStyleContext *context;
gchar *css_data;
combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
cell_renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell_renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell_renderer,
"text", 0, NULL);
gtk_widget_set_name (combo, name);
context = gtk_widget_get_style_context (combo);
provider = gtk_css_provider_new ();
css_data = g_strdup_printf ("#%s { -GtkComboBox-appears-as-list: %s }",
name, is_list ? "true" : "false");
gtk_css_provider_load_from_data (provider, css_data, -1, NULL);
g_free (css_data);
gtk_style_context_add_provider (context,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
return combo;
}
static void context_apply_config(GtkWidget *console)
{
#if !GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_modify_base(console, GTK_STATE_NORMAL, &pref_vte_colour_back);
gtk_widget_modify_cursor(console, &pref_vte_colour_fore, &pref_vte_colour_back);
#else
GString *css_string;
GtkStyleContext *context;
GtkCssProvider *provider;
gchar *css_code, *color, *background_color;
color = gdk_rgba_to_string (&pref_vte_colour_fore);
background_color = gdk_rgba_to_string (&pref_vte_colour_back);
gtk_widget_set_name(console, "scope-console");
context = gtk_widget_get_style_context(console);
provider = gtk_css_provider_new();
gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
css_string = g_string_new(NULL);
g_string_printf(css_string, "#scope-console { color: %s; background-color: %s; }",
color, background_color);
css_code = g_string_free(css_string, FALSE);
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider), css_code, -1, NULL);
g_free(css_code);
g_object_unref(provider);
#endif
ui_widget_modify_font_from_string(console, pref_vte_font);
}
static void
panel_menu_bar_object_init (PanelMenuBarObject *menubar)
{
GtkStyleContext *context;
GtkCssProvider *provider;
menubar->priv = PANEL_MENU_BAR_OBJECT_GET_PRIVATE (menubar);
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider,
"PanelMenuBarObject {\n"
" border-width: 0px;\n"
"}",
-1, NULL);
context = gtk_widget_get_style_context (GTK_WIDGET (menubar));
gtk_style_context_add_provider (context,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
gtk_style_context_add_class (context, "consort-panel-menu-bar");
if (menubar->priv->orientation & PANEL_HORIZONTAL_MASK)
gtk_style_context_add_class (context, GTK_STYLE_CLASS_HORIZONTAL);
else
gtk_style_context_add_class (context, GTK_STYLE_CLASS_VERTICAL);
menubar->priv->panel = NULL;
}
GtkWidget *
do_css_accordion (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *container, *child;
GtkStyleProvider *provider;
GBytes *bytes;
gsize data_size;
const guint8 *data;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 600, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_halign (container, GTK_ALIGN_CENTER);
gtk_widget_set_valign (container, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (window), container);
child = gtk_button_new_with_label ("This");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("Is");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("A");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("CSS");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("Accordion");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label (":-)");
gtk_container_add (GTK_CONTAINER (container), child);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
bytes = g_resources_lookup_data ("/css_accordion/css_accordion.css", 0, NULL);
data = g_bytes_get_data (bytes, &data_size);
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider), (gchar *)data, data_size, NULL);
g_bytes_unref (bytes);
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
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);
}
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 style_init()
{
static const char *stylesheet;
GError *error = NULL;
stylesheet = "" \
".cm-header-title {" \
" font-weight: bold;" \
"}" \
".cm-wireless-hidden {" \
" font-style: italic;" \
"}" \
".cm-log {" \
" background-color: white;" \
" padding: 5px;" \
"}" \
"";
css_provider = gtk_css_provider_new();
gtk_css_provider_load_from_data(css_provider, stylesheet, -1, &error);
if(error != NULL) {
g_warning("couldn't load stylesheet: %s", error->message);
g_error_free(error);
}
}
static void
gs_progress_button_init (GsProgressButton *button)
{
button->css_provider = gtk_css_provider_new ();
gtk_style_context_add_provider (gtk_widget_get_style_context (GTK_WIDGET (button)),
GTK_STYLE_PROVIDER (button->css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
GtkWidget *
do_css_basics (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *container, *child;
GtkStyleProvider *provider;
GtkTextBuffer *text;
GBytes *bytes;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "CSS Basics");
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
text = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text,
"warning",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_create_tag (text,
"error",
"underline", PANGO_UNDERLINE_ERROR,
NULL);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
container = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), container);
child = gtk_text_view_new_with_buffer (text);
gtk_container_add (GTK_CONTAINER (container), child);
g_signal_connect (text, "changed",
G_CALLBACK (css_text_changed), provider);
bytes = g_resources_lookup_data ("/css_basics/css_basics.css", 0, NULL);
gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
g_bytes_unref (bytes);
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (show_parsing_error),
gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
static GtkWidget *
create_top_bar (EmpathyAppPluginWidget *self)
{
GtkWidget *bar, *content, *action, *label;
GtkCssProvider *css;
AgProvider *provider;
gchar *str;
GError *error = NULL;
bar = gtk_info_bar_new_with_buttons (
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Done"), GTK_RESPONSE_OK,
NULL);
gtk_widget_set_hexpand (bar, TRUE);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_QUESTION);
action = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action),
GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_name (bar, "authorization-infobar");
css = gtk_css_provider_new ();
if (gtk_css_provider_load_from_data (css,
"@define-color question_bg_color rgb (222, 222, 222);"
"GtkInfoBar#authorization-infobar"
"{"
" color: @fg_color;"
"}",
-1, &error))
{
GtkStyleContext *context = gtk_widget_get_style_context (bar);
gtk_style_context_add_provider (context, (GtkStyleProvider *) css,
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
else
{
g_warning ("Error processing CSS theme override: %s", error->message);
g_clear_error (&error);
}
g_object_unref (css);
content = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
provider = ag_manager_get_provider (
ag_account_get_manager (self->priv->account),
ag_account_get_provider_name (self->priv->account));
str = g_strdup_printf (_("Edit %s account options"),
ag_provider_get_display_name (provider));
label = gtk_label_new (str);
gtk_container_add (GTK_CONTAINER (content), label);
gtk_widget_show (label);
ag_provider_unref (provider);
g_free (str);
g_signal_connect (bar, "response",
G_CALLBACK (response_cb), self);
return bar;
}
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);
}
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;
}
/**
* Callback to initialize SPSVGSPViewWidget object.
*/
static void sp_svg_view_widget_init(SPSVGSPViewWidget *vw)
{
SPCanvasItem *parent;
/* Settings */
vw->resize = FALSE;
vw->maxwidth = 400.0;
vw->maxheight = 400.0;
/* ScrolledWindow */
vw->sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(vw->sw), GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (vw->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (vw), vw->sw);
gtk_widget_show (vw->sw);
/* Canvas */
#if !GTK_CHECK_VERSION(3,0,0)
GdkColormap *cmap = gdk_colormap_get_system();
gtk_widget_push_colormap(cmap);
#endif
vw->canvas = SPCanvas::createAA();
#if GTK_CHECK_VERSION(3,0,0)
GtkCssProvider *css_provider = gtk_css_provider_new();
GtkStyleContext *style_context = gtk_widget_get_style_context(GTK_WIDGET(vw->canvas));
gtk_css_provider_load_from_data(css_provider,
"SPCanvas {\n"
" background-color: white;\n"
"}\n",
-1, NULL);
gtk_style_context_add_provider(style_context,
GTK_STYLE_PROVIDER(css_provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
#else
gtk_widget_pop_colormap ();
GtkStyle *style = gtk_style_copy (gtk_widget_get_style (vw->canvas));
style->bg[GTK_STATE_NORMAL] = style->white;
gtk_widget_set_style (vw->canvas, style);
#endif
#if GTK_CHECK_VERSION(3,0,0)
gtk_container_add (GTK_CONTAINER (vw->sw), vw->canvas);
#else
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (vw->sw), vw->canvas);
#endif
gtk_widget_show (vw->canvas);
/* View */
parent = sp_canvas_item_new(SP_CANVAS(vw->canvas)->getRoot(), SP_TYPE_CANVAS_GROUP, NULL);
Inkscape::UI::View::View *view = Inkscape::GC::release(new SPSVGView (SP_CANVAS_GROUP (parent)));
sp_view_widget_set_view (SP_VIEW_WIDGET (vw), view);
}
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);
}
