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;
}
}
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
_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);
}
static void
reset_theme_css(GtTwitchChatView* self)
{
GtTwitchChatViewPrivate* priv = gt_twitch_chat_view_get_instance_private(self);
gchar css[200];
g_sprintf(css, priv->dark_theme ? CHAT_DARK_THEME_CSS : CHAT_LIGHT_THEME_CSS,
priv->opacity);
if (priv->dark_theme)
{
REMOVE_STYLE_CLASS(priv->chat_view, CHAT_LIGHT_THEME_CSS_CLASS);
REMOVE_STYLE_CLASS(priv->chat_entry, CHAT_LIGHT_THEME_CSS_CLASS);
ADD_STYLE_CLASS(priv->chat_view, CHAT_DARK_THEME_CSS_CLASS);
ADD_STYLE_CLASS(priv->chat_entry, CHAT_DARK_THEME_CSS_CLASS);
}
else
{
REMOVE_STYLE_CLASS(priv->chat_view, CHAT_DARK_THEME_CSS_CLASS);
REMOVE_STYLE_CLASS(priv->chat_entry, CHAT_DARK_THEME_CSS_CLASS);
ADD_STYLE_CLASS(priv->chat_view, CHAT_LIGHT_THEME_CSS_CLASS);
ADD_STYLE_CLASS(priv->chat_entry, CHAT_LIGHT_THEME_CSS_CLASS);
}
gtk_css_provider_load_from_data(priv->chat_css_provider, css, -1, NULL); //TODO Error handling
gtk_widget_reset_style(GTK_WIDGET(self));
gtk_widget_reset_style(priv->chat_view);
}
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);
}
}
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 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 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;
}
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 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");
}
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;
}
/** \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
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;
}
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
gb_keybindings_reload (GbKeybindings *self)
{
const gchar *mode;
g_autofree gchar *path = NULL;
g_autoptr(GBytes) bytes = NULL;
g_autoptr(GError) error = NULL;
IDE_ENTRY;
g_assert (GB_IS_KEYBINDINGS (self));
mode = self->mode ? self->mode : "default";
IDE_TRACE_MSG ("Loading %s keybindings", mode);
path = g_strdup_printf ("/org/gnome/builder/keybindings/%s.css", mode);
bytes = g_resources_lookup_data (path, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (error == NULL)
gtk_css_provider_load_from_data (self->css_provider,
g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes),
&error);
if (error)
g_warning ("%s", error->message);
IDE_EXIT;
}
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;
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;
}
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;
}
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 void
font_changed (GObject *obj, GParamSpec *spec, gpointer data)
{
IrcApplication *self = IRC_APPLICATION(data);
IrcApplicationPrivate *priv = irc_application_get_instance_private (self);
g_autofree char *font = g_settings_get_string (priv->settings, "font");
g_autofree char *css = g_strdup_printf (".irc-textview { font: %s }", font);
if (!gtk_css_provider_load_from_data (priv->css_provider, css, -1, NULL))
g_warning ("Failed loading font css \"%s\"", css);
}
static void
gtk_css_provider_load_data_not_null_terminated (void)
{
GtkCssProvider *p;
const gchar data[3] = {'*', '{', '}'};
p = gtk_css_provider_new();
gtk_css_provider_load_from_data(p, data, sizeof (data));
g_object_unref (p);
}
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;
}
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
gs_progress_button_set_progress (GsProgressButton *button, guint percentage)
{
g_autofree gchar *css = NULL;
if (percentage == 0)
css = g_strdup (".install-progress { background-size: 0; }");
else if (percentage == 100)
css = g_strdup (".install-progress { background-size: 100%; }");
else
css = g_strdup_printf (".install-progress { background-size: %u%%; }", percentage);
gtk_css_provider_load_from_data (button->css_provider, css, -1, NULL);
}
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);
}
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
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);
}
