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;
}
/**
* gdaui_bar_add_button_from_stock:
* @bar: a #GdauiBar
* @stock_id: the stock name of the button to add
*
* Returns: (transfer none): the created #GtkButton
*/
GtkWidget *
gdaui_bar_add_button_from_stock (GdauiBar *bar, const gchar *stock_id)
{
g_return_val_if_fail (GDAUI_IS_BAR (bar), NULL);
g_return_val_if_fail (stock_id && *stock_id, NULL);
GtkWidget *vb, *button, *img;
vb = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vb), GTK_BUTTONBOX_CENTER);
gtk_box_pack_start (GTK_BOX (bar->priv->action_area), vb, FALSE, FALSE, 0);
button = gtk_button_new ();
img = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (button), img);
gtk_box_pack_start (GTK_BOX (vb), button, FALSE, FALSE, 0);
g_object_set (G_OBJECT (button), "label", NULL, NULL);
/* CSS theming */
GtkStyleContext *context;
context = gtk_widget_get_style_context (vb);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_button");
context = gtk_widget_get_style_context (button);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_button");
context = gtk_widget_get_style_context (img);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_button");
gtk_widget_show_all (vb);
return button;
}
/**
* gdaui_bar_add_search_entry:
* @bar: a #GdauiBar
*
* Returns: (transfer none): the created #GtkEntry
*/
GtkWidget *
gdaui_bar_add_search_entry (GdauiBar *bar)
{
g_return_val_if_fail (GDAUI_IS_BAR (bar), NULL);
GtkWidget *vb, *entry;
vb = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vb), GTK_BUTTONBOX_CENTER);
gtk_box_pack_start (GTK_BOX (bar->priv->action_area), vb, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vb), entry, FALSE, FALSE, 0);
/* CSS theming */
GtkStyleContext *context;
context = gtk_widget_get_style_context (vb);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_entry");
context = gtk_widget_get_style_context (entry);
gtk_style_context_add_provider (context, css_provider, G_MAXUINT);
gtk_style_context_add_class (context, "gdauibar_entry");
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_CLEAR);
g_signal_connect (entry, "icon-press",
G_CALLBACK (find_icon_pressed_cb), NULL);
gtk_widget_show_all (vb);
return entry;
}
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");
}
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);
}
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;
}
/** \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;
}
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
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 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;
}
static void
apply_css (GtkWidget *widget, GtkStyleProvider *provider)
{
gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
if (GTK_IS_CONTAINER (widget))
gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
}
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 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
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);
}
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;
}
/**
* 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);
}
int
main(int argc, char **argv)
{
GtkWidget *window, *revealer, *grid, *widget;
GtkCssProvider *cssprovider;
GError *error = NULL;
guint x, y;
GOptionContext *context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
frame_stats_add_options (g_option_context_get_main_group (context));
g_option_context_add_group (context,
gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
frame_stats_ensure (GTK_WINDOW (window));
revealer = gtk_revealer_new ();
gtk_widget_set_valign (revealer, GTK_ALIGN_START);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN);
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), reveal_time * 1000);
gtk_revealer_set_reveal_child (GTK_REVEALER (revealer), TRUE);
g_signal_connect_after (revealer, "map", G_CALLBACK (toggle_reveal), NULL);
g_signal_connect_after (revealer, "notify::child-revealed", G_CALLBACK (toggle_reveal), NULL);
gtk_container_add (GTK_CONTAINER (window), revealer);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (revealer), grid);
cssprovider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (cssprovider, "* { padding: 2px; text-shadow: 5px 5px 2px grey; }", -1, NULL);
for (x = 0; x < 10; x++)
{
for (y = 0; y < 20; y++)
{
widget = gtk_label_new ("Hello World");
gtk_style_context_add_provider (gtk_widget_get_style_context (widget),
GTK_STYLE_PROVIDER (cssprovider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
gtk_grid_attach (GTK_GRID (grid), widget, x, y, 1, 1);
}
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
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);
}
void theme_apply(GtkWidget *widget){
if (!provider) return;
gtk_style_context_add_provider(
gtk_widget_get_style_context(widget), provider, _G_MAXUINT);
if(GTK_IS_CONTAINER(widget))
gtk_container_forall(GTK_CONTAINER(widget),
(GtkCallback)theme_apply, NULL);
}
static void set_button_text_color(GtkWidget *widget,char *color) {
GtkStyleContext *style_context;
GtkCssProvider *provider = gtk_css_provider_new ();
gchar tmp[64];
style_context = gtk_widget_get_style_context(widget);
gtk_style_context_add_provider(style_context, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_snprintf(tmp, sizeof tmp, "GtkButton, GtkLabel { color: %s; }", color);
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider), tmp, -1, 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 GObject * flat_button_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
GObject * obj;
GObjectClass * parent_class;
FlatButton * self;
GError * _inner_error_ = NULL;
parent_class = G_OBJECT_CLASS (flat_button_parent_class);
obj = parent_class->constructor (type, n_construct_properties, construct_properties);
self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FLAT_BUTTON, FlatButton);
unity_greeter_add_style_class ((GtkWidget*) self);
{
GtkCssProvider* _tmp0_;
GtkCssProvider* style;
GtkCssProvider* _tmp1_;
GtkStyleContext* _tmp2_ = NULL;
GtkCssProvider* _tmp3_;
_tmp0_ = gtk_css_provider_new ();
style = _tmp0_;
_tmp1_ = style;
gtk_css_provider_load_from_data (_tmp1_, "* {-GtkButton-child-displacement-x: 0px;\n" \
" -GtkButton-child-displacement-y:" \
" 0px;\n" \
" -GtkWidget-focus-line-width: 1px" \
";\n" \
" }", (gssize) (-1), &_inner_error_);
if (_inner_error_ != NULL) {
_g_object_unref0 (style);
goto __catch8_g_error;
}
_tmp2_ = gtk_widget_get_style_context ((GtkWidget*) self);
_tmp3_ = style;
gtk_style_context_add_provider (_tmp2_, (GtkStyleProvider*) _tmp3_, (guint) GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
_g_object_unref0 (style);
}
goto __finally8;
__catch8_g_error:
{
GError* e = NULL;
GError* _tmp4_;
const gchar* _tmp5_;
e = _inner_error_;
_inner_error_ = NULL;
_tmp4_ = e;
_tmp5_ = _tmp4_->message;
g_debug ("flat-button.vala:38: Internal error loading session chooser style: %s", _tmp5_);
_g_error_free0 (e);
}
__finally8:
if (_inner_error_ != NULL) {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
}
return obj;
}
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
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;
}
}
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);
}
void gtk_widget_modify_bkg(GtkWidget *widget, GtkStateType state, GdkRGBA* color)
{
GtkStyleContext *context = gtk_widget_get_style_context(widget);
GtkCssProvider *cssprv = gtk_css_provider_new();
char css[2048], strstate[256];
strstate[0] = '\0';
if (state == 0)
{
//GTK_STATE_FLAG_NORMAL
strcat(strstate, "");
}
if ((state << 0) == 1)
{
//GTK_STATE_FLAG_ACTIVE
strcat(strstate, ":active");
}
if ((state << 1) == 1)
{
//GTK_STATE_FLAG_PRELIGHT
strcat(strstate, ":hoover");
}
if ((state << 2) == 1)
{
//GTK_STATE_FLAG_SELECTED
strcat(strstate, ":focus");
}
if ((state << 3) == 1)
{
//GTK_STATE_FLAG_INSENSITIVE
strcat(strstate, ":insensitive");
}
if ((state << 4) == 1)
{
//GTK_STATE_FLAG_INCONSISTENT
strcat(strstate, "");
}
if ((state << 5) == 1)
{
//GTK_STATE_FLAG_FOCUSED
strcat(strstate, "focus");
}
//sprintf(css, "%s%s {\n background-color: %s;\n background-image: none;\n }\n", G_OBJECT_TYPE_NAME(widget), strstate, gdk_rgba_to_string(color));
sprintf(css, "%s%s {\n background-image: -gtk-gradient (linear, left top, left bottom, from (shade (%s, 1.1)), color-stop (0.5, shade (%s, 0.85)), to (shade (%s, 1.1)));\n }\n", G_OBJECT_TYPE_NAME(widget), strstate, gdk_rgba_to_string(color), gdk_rgba_to_string(color), gdk_rgba_to_string(color));
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);
}
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);
}
/**
* 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);
}
static void setColor(GtkWidget *widget, gboolean isOk){
GtkCssProvider *cssProvider;
cssProvider = gtk_css_provider_new ();
gtk_css_provider_load_from_path(cssProvider,"src/style.css",NULL);
char* cssClass = "enter_button_ok";
if(isOk == FALSE)
cssClass = "enter_button_fail";
gtk_style_context_add_provider(gtk_widget_get_style_context(widget),cssProvider,GTK_STYLE_PROVIDER_PRIORITY_USER);
GtkStyleContext *context;
context = gtk_widget_get_style_context(widget);
gtk_style_context_add_class(context,cssClass);
}
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);
}
