void change_win1_font()
{
int i;
if (!frame)
return;
GdkColor fg;
gdk_color_parse(gcin_win_color_fg, &fg);
#if GTK_CHECK_VERSION(2,91,6)
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&fg));
#endif
for(i=0; i < wselkeyN; i++) {
set_label_font_size(labels_sele[i], gcin_font_size_tsin_presel);
set_label_font_size(labels_seleR[i], gcin_font_size_tsin_presel);
#if !GTK_CHECK_VERSION(2,91,6)
if (labels_sele[i])
gtk_widget_modify_fg(labels_sele[i], GTK_STATE_NORMAL, gcin_win_color_use?&fg:NULL);
if (labels_seleR[i])
gtk_widget_modify_fg(labels_seleR[i], GTK_STATE_NORMAL, gcin_win_color_use?&fg:NULL);
#else
if (labels_sele[i])
gtk_widget_override_color(labels_sele[i], GTK_STATE_FLAG_NORMAL, gcin_win_color_use?&rgbfg:NULL);
if (labels_seleR[i])
gtk_widget_override_color(labels_seleR[i], GTK_STATE_FLAG_NORMAL, gcin_win_color_use?&rgbfg:NULL);
#endif
change_win_bg(eve_sele[i]);
if (eve_seleR[i])
change_win_bg(eve_seleR[i]);
}
change_win_bg(gwin1);
}
void
girara_tab_update(girara_session_t* session)
{
if (session == NULL || session->gtk.tabs == NULL) {
return;
}
int number_of_tabs = girara_get_number_of_tabs(session);
int current_tab = girara_tab_position_get(session, girara_tab_current_get(session));
for (int i = 0; i < number_of_tabs; i++) {
GtkWidget* widget = gtk_notebook_get_nth_page(session->gtk.tabs, i);
girara_tab_t* tab = (girara_tab_t*) g_object_get_data(G_OBJECT(widget), "tab");
if (tab == NULL) {
continue;
}
GtkWidget* tab_event = GTK_WIDGET(g_object_get_data(G_OBJECT(tab->widget), "event"));
GtkWidget* tab_label = GTK_WIDGET(g_object_get_data(G_OBJECT(tab->widget), "label"));
if (i == current_tab) {
gtk_widget_override_background_color(tab_event, GTK_STATE_NORMAL, &(session->style.tabbar_focus_background));
gtk_widget_override_color(tab_label, GTK_STATE_NORMAL, &(session->style.tabbar_focus_foreground));
} else {
gtk_widget_override_background_color(tab_event, GTK_STATE_NORMAL, &(session->style.tabbar_background));
gtk_widget_override_color(tab_label, GTK_STATE_NORMAL, &(session->style.tabbar_foreground));
}
}
}
static void
gnm_notebook_button_set_property (GObject *obj,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GnmNotebookButton *nbb = GNM_NOTEBOOK_BUTTON (obj);
switch (prop_id) {
case NBB_PROP_BACKGROUND_COLOR:
gdk_rgba_free (nbb->bg);
nbb->bg = g_value_dup_boxed (value);
gtk_widget_queue_draw (GTK_WIDGET (obj));
g_clear_object (&nbb->layout);
g_clear_object (&nbb->layout_active);
break;
case NBB_PROP_TEXT_COLOR:
gdk_rgba_free (nbb->fg);
nbb->fg = g_value_dup_boxed (value);
gtk_widget_queue_draw (GTK_WIDGET (obj));
gtk_widget_override_color (GTK_WIDGET (obj),
GTK_STATE_FLAG_NORMAL,
nbb->fg);
gtk_widget_override_color (GTK_WIDGET (obj),
GTK_STATE_FLAG_ACTIVE,
nbb->fg);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
/* function to highlight label */
void highlight(GtkWidget *eventbox)
{
GtkWidget *label, *lighted_eventbox, *lighted_label;
GList *child;
GtkStyleContext *context;
GdkRGBA selected_fg, selected_bg;
/* get label from eventbox */
child = gtk_container_get_children(GTK_CONTAINER(eventbox));
label = child->data;
/* prepare highlight colors */
context = gtk_widget_get_style_context(label);
gtk_style_context_get_color(context, GTK_STATE_FLAG_SELECTED, &selected_fg);
gtk_style_context_get_background_color(context, GTK_STATE_FLAG_SELECTED,
&selected_bg);
/* clearcolor previous highlighted label */
lighted_eventbox = g_object_get_data(G_OBJECT(builder), "lighted_eventbox");
if(lighted_eventbox)
{
child = gtk_container_get_children(GTK_CONTAINER(lighted_eventbox));
lighted_label = child->data;
clearcolor(lighted_label, lighted_eventbox);
}
/* apply color */
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &selected_fg);
gtk_widget_override_background_color(eventbox,
GTK_STATE_FLAG_NORMAL, &selected_bg);
/* set current eventbox as lighted */
g_object_set_data(G_OBJECT(builder), "lighted_eventbox", eventbox);
}
void
module_change_font_size (void)
{
GdkColor colorFG;
GtkWidget *pLabel;
int n;
gdk_color_parse (*g_himeModMainFuncs.mf_hime_win_color_fg, &colorFG);
g_himeModMainFuncs.mf_change_win_bg (g_pWinChewing);
g_himeModMainFuncs.mf_change_win_bg (g_pEvBoxChewing);
for (n = 0; n < MAX_SEG_NUM; n++)
{
pLabel = g_pSeg[n].label;
g_himeModMainFuncs.mf_set_label_font_size (pLabel,
*g_himeModMainFuncs.mf_hime_font_size);
if (*g_himeModMainFuncs.mf_hime_win_color_use) {
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg (pLabel, GTK_STATE_NORMAL, &colorFG);
#else
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&colorFG));
gtk_widget_override_color(pLabel, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
}
}
}
void module_change_font_size()
{
dbg("change_anthy_font_size\n");
GdkColor fg;
gdk_color_parse(*gmf.mf_hime_win_color_fg, &fg);
#if GTK_CHECK_VERSION(2,91,6)
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&fg));
#endif
gmf.mf_change_win_bg(win_anthy);
gmf.mf_change_win_bg(event_box_anthy);
int i;
for(i=0; i < MAX_SEG_N; i++) {
GtkWidget *label = seg[i].label;
gmf.mf_set_label_font_size(label, *gmf.mf_hime_font_size);
if (*gmf.mf_hime_win_color_use) {
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &fg);
#else
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
}
}
}
/**************************************************************************
Alert the user to an important event.
**************************************************************************/
void gui_dialog_alert(struct gui_dialog *dlg)
{
fc_assert_ret(NULL != dlg);
switch (dlg->type) {
case GUI_DIALOG_WINDOW:
break;
case GUI_DIALOG_TAB:
{
GtkNotebook *notebook = GTK_NOTEBOOK(dlg->v.tab.notebook);
gint current, n;
current = gtk_notebook_get_current_page(notebook);
n = gtk_notebook_page_num(notebook, dlg->vbox);
if (current != n) {
GtkWidget *label = dlg->v.tab.label;
GdkRGBA color = {.red = 0, .green = 0, .blue =1.0, .alpha = 1.0};
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &color);
}
}
break;
}
}
static void
lyric_show_viewport_update_current_widget(LyricShowViewport *lsv)
{
if((!lsv->priv->is_pressed) && lsv->priv->current_widget)
{
GtkAllocation alc0,alc1;
const gchar *color_string = "blue";
#if GTK_CHECK_VERSION(3,2,0)
GdkRGBA color = {0};
gdk_rgba_parse(&color,color_string);
#else
GdkColor color = {0};
gdk_color_parse(color_string,&color);
#endif
if(lsv->priv->pre_widget &&
GTK_IS_WIDGET(lsv->priv->pre_widget) &&
lsv->priv->current_widget !=lsv->priv->pre_widget)
{
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_override_color(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,NULL);
gtk_widget_set_state_flags(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,FALSE);
#else
gtk_widget_modify_fg(lsv->priv->pre_widget,GTK_STATE_ACTIVE,NULL);
gtk_widget_set_state(lsv->priv->pre_widget,GTK_STATE_NORMAL);
#endif
}
#if GTK_CHECK_VERSION(3,2,0)
gtk_widget_override_color(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,&color);
gtk_widget_set_state_flags(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,FALSE);
#else
gtk_widget_modify_fg(lsv->priv->current_widget,GTK_STATE_ACTIVE,&color);
gtk_widget_set_state(lsv->priv->current_widget,GTK_STATE_ACTIVE);
#endif
gtk_widget_get_allocation(lsv->priv->current_widget,&alc0);
gtk_widget_get_allocation(lsv->priv->lyricbox,&alc1);
lsv->priv->pos = (alc0.y - alc1.y)+alc0.height/2.0;
gtk_widget_queue_resize(GTK_WIDGET(lsv));
}
}
void mod_fg_all(GtkWidget *lab, GdkColor *col)
{
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(lab, GTK_STATE_NORMAL, col);
gtk_widget_modify_fg(lab, GTK_STATE_ACTIVE, col);
gtk_widget_modify_fg(lab, GTK_STATE_SELECTED, col);
gtk_widget_modify_fg(lab, GTK_STATE_PRELIGHT, col);
#else
GdkRGBA rgb, *prgb = NULL;
if (col) {
gdk_rgba_parse(&rgb, gdk_color_to_string(col));
prgb = &rgb;
}
gtk_widget_override_color(lab, GTK_STATE_FLAG_NORMAL, prgb);
gtk_widget_override_color(lab, GTK_STATE_FLAG_ACTIVE, prgb);
gtk_widget_override_color(lab, GTK_STATE_FLAG_SELECTED, prgb);
gtk_widget_override_color(lab, GTK_STATE_FLAG_PRELIGHT, prgb);
#endif
}
static void
change_text_color (const char *key, gpointer user_data)
{
GtkWidget *text_view;
GdkRGBA *color;
text_view = user_data;
color = preferences_get_color (key);
gtk_widget_override_color (text_view, GTK_STATE_NORMAL, color);
}
static void
cheese_widget_spinner_invert (GtkWidget *spinner, GtkWidget *parent)
{
GtkStyleContext *context;
guint i;
for (i = GTK_STATE_NORMAL; i <= GTK_STATE_INSENSITIVE; i++)
{
GdkRGBA fg, bg;
context = gtk_widget_get_style_context (spinner);
gtk_style_context_get_color (context, gtk_style_context_get_state (context), &fg);
gtk_style_context_get_background_color (context, gtk_style_context_get_state (context), &bg);
gtk_widget_override_color (spinner, i, &bg);
gtk_widget_override_background_color (spinner, i, &fg);
gtk_widget_override_color (parent, i, &bg);
gtk_widget_override_background_color (parent, i, &fg);
}
}
void gwrgtk_modify_fg_color (GtkWidget* _w, GtkStateType _st, guint16 _r, guint16 _g, guint16 _b)
{
// GTK >= 3.0
#if GWR_GTK_VERSION_GE(3,0)
{
GtkStateFlags sf;
GdkRGBA color;
sf = (GtkStateFlags)
(
- ( _st == GTK_STATE_NORMAL ) * GTK_STATE_FLAG_NORMAL
);
/*
- ( GTK_STATE_ACTIVE,
- ( GTK_STATE_PRELIGHT,
- ( GTK_STATE_SELECTED,
- ( GTK_STATE_INSENSITIVE,
- ( GTK_STATE_INCONSISTENT,
- ( GTK_STATE_FOCUSED
GTK_STATE_FLAG_NORMAL = 0,
GTK_STATE_FLAG_ACTIVE = 1 << 0,
GTK_STATE_FLAG_PRELIGHT = 1 << 1,
GTK_STATE_FLAG_SELECTED = 1 << 2,
GTK_STATE_FLAG_INSENSITIVE = 1 << 3,
GTK_STATE_FLAG_INCONSISTENT = 1 << 4,
GTK_STATE_FLAG_FOCUSED = 1 << 5,
GTK_STATE_FLAG_BACKDROP = 1 << 6
*/
sf = (GtkStateFlags)0xff;
color.red = ( (gdouble)_r / (gdouble)65535. );
color.green = ( (gdouble)_g / (gdouble)65535. );
color.blue = ( (gdouble)_b / (gdouble)65535. );
color.alpha = (gdouble)1.;
gtk_widget_override_color(_w, sf, &color);
}
#else
// GTK < 3.0
{
GdkColor color;
color.pixel = 0;
color.red = _r;
color.green = _g;
color.blue = _b;
gtk_widget_modify_fg( _w, _st, &color );
}
#endif
}
void set_key_codes_label(char *s, int better)
{
// dbg("set_key_codes_label %s %x\n", s, label_key_codes);
if (!label_key_codes)
return;
if (s && strlen(s)) {
if (hbox_row2 && (!gtab_hide_row2 || ggg.wild_mode || (str_key_codes[0]))) {
gtk_widget_show(hbox_row2);
}
} else {
if (gtab_hide_row2 && hbox_row2) {
gtk_widget_hide(hbox_row2);
}
}
if (better) {
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(label_key_codes, GTK_STATE_NORMAL, &better_color);
#else
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&better_color));
gtk_widget_override_color(label_key_codes, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
} else
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(label_key_codes, GTK_STATE_NORMAL, NULL);
#else
gtk_widget_override_color(label_key_codes, GTK_STATE_FLAG_NORMAL, NULL);
#endif
gtk_label_set_text(GTK_LABEL(label_key_codes), s);
if (s && s[0])
gtk_widget_show(label_key_codes);
better_key_codes = better;
if (s && s != str_key_codes)
strcpy(str_key_codes, s);
else
str_key_codes[0]=0;
}
gint ygtk_steps_append (YGtkSteps *steps, const gchar *text)
{
GtkWidget *label = gtk_label_new (text);
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
gtk_widget_override_color (label, GTK_STATE_NORMAL, &black);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
int mark_width = 10;
pango_layout_get_pixel_size (steps->check_mark_layout, &mark_width, NULL);
gtk_misc_set_padding (GTK_MISC (label), mark_width+12, 0);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (steps), label, FALSE, TRUE, 0);
return ygtk_steps_total (steps)-1;
}
/**************************************************************************
Resets tab colour on tab activation.
**************************************************************************/
static void gui_dialog_switch_page_handler(GtkNotebook *notebook,
GtkWidget *page,
guint num,
struct gui_dialog *dlg)
{
gint n;
n = gtk_notebook_page_num(GTK_NOTEBOOK(dlg->v.tab.notebook), dlg->vbox);
if (n == num) {
gtk_widget_override_color(dlg->v.tab.label, GTK_STATE_FLAG_NORMAL, NULL);
}
}
static void create_char(int index)
{
int i;
// dbg("create_char %d\n", index);
if (!hbox_edit) {
dbg("create_char: !hbox_edit\n");
return;
}
GdkColor fg;
gdk_color_parse(gcin_win_color_fg, &fg);
GdkColor color_bg;
gdk_color_parse(tsin_phrase_line_color, &color_bg);
i = index;
{
if (chars[i].vbox)
return;
GtkWidget *event_box = gtk_event_box_new();
gtk_event_box_set_visible_window (GTK_EVENT_BOX(event_box), FALSE);
chars[i].vbox = event_box;
g_signal_connect (G_OBJECT (event_box), "button-press-event", G_CALLBACK (mouse_char_callback), GINT_TO_POINTER(index));
gtk_box_pack_start (GTK_BOX (hbox_edit), event_box, FALSE, FALSE, 0);
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add(GTK_CONTAINER(event_box), vbox);
GtkWidget *label = gtk_label_new(NULL);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
set_label_font_size(label, gcin_font_size);
chars[i].label = label;
if (gcin_win_color_use) {
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &fg);
#else
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&fg));
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
}
gtk_widget_show_all(event_box);
}
}
void ygtk_steps_append_heading (YGtkSteps *steps, const gchar *heading)
{
GtkWidget *label = gtk_label_new (heading);
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
gtk_widget_override_color (label, GTK_STATE_NORMAL, &black);
g_object_set_data (G_OBJECT (label), "is-header", GINT_TO_POINTER (1));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
PangoAttrList *attrbs = pango_attr_list_new();
pango_attr_list_insert (attrbs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
pango_attr_list_insert (attrbs, pango_attr_scale_new (PANGO_SCALE_LARGE));
gtk_label_set_attributes (GTK_LABEL (label), attrbs);
pango_attr_list_unref (attrbs);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (steps), label, FALSE, TRUE, 6);
}
static void
plugin_action (GAction *action,
GVariant *parameter,
gpointer data)
{
GApplication *app;
GList *list;
GtkWindow *window;
GtkWidget *text;
GdkRGBA color;
app = g_application_get_default ();
list = gtk_application_get_windows (GTK_APPLICATION (app));
window = GTK_WINDOW (list->data);
text = g_object_get_data ((GObject*)window, "plugman-text");
gdk_rgba_parse (&color, g_action_get_name (action));
gtk_widget_override_color (text, 0, &color);
}
void ug_banner_init (struct UgBanner* banner)
{
GtkStyleContext* style_context;
GdkRGBA rgba;
hand_cursor = gdk_cursor_new (GDK_HAND2);
regular_cursor = gdk_cursor_new (GDK_XTERM);
banner->self = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
banner->buffer = gtk_text_buffer_new (NULL);
banner->tag_link = gtk_text_buffer_create_tag (banner->buffer, NULL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
banner->text_view = (GtkTextView*) gtk_text_view_new_with_buffer (banner->buffer);
gtk_text_view_set_cursor_visible (banner->text_view, FALSE);
gtk_text_view_set_editable (banner->text_view, FALSE);
gtk_box_pack_start (GTK_BOX (banner->self),
GTK_WIDGET (banner->text_view), TRUE, TRUE, 0);
g_signal_connect (banner->text_view, "event-after",
G_CALLBACK (event_after), banner);
g_signal_connect (banner->text_view, "motion-notify-event",
G_CALLBACK (motion_notify_event), banner);
// style: color
style_context = gtk_widget_get_style_context (GTK_WIDGET (banner->text_view));
gtk_style_context_get_background_color (style_context,
GTK_STATE_FLAG_SELECTED, &rgba);
gtk_widget_override_background_color (
GTK_WIDGET (banner->text_view), GTK_STATE_FLAG_NORMAL, &rgba);
gtk_style_context_get_color (style_context,
GTK_STATE_FLAG_SELECTED, &rgba);
gtk_widget_override_color (
GTK_WIDGET (banner->text_view), GTK_STATE_FLAG_NORMAL, &rgba);
// close button
gtk_box_pack_end (GTK_BOX (banner->self),
create_x_button (banner), FALSE, FALSE, 0);
ug_banner_show_donation (banner);
}
void change_win_fg_bg(GtkWidget *win, GtkWidget *label)
{
if (win)
change_win_bg(win);
// TODO: Simplify repeating codes below.
if (!hime_win_color_use) {
#if !GTK_CHECK_VERSION(2,91,6)
if (label)
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, NULL);
if (label_edit)
gtk_widget_modify_fg(label_edit, GTK_STATE_NORMAL, NULL);
if (label_gtab_pre_sel)
gtk_widget_modify_fg(label_gtab_pre_sel, GTK_STATE_NORMAL, NULL);
#else
if (label)
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, NULL);
if (label_edit)
gtk_widget_override_color(label_edit, GTK_STATE_FLAG_NORMAL, NULL);
if (label_gtab_pre_sel)
gtk_widget_override_color(label_gtab_pre_sel, GTK_STATE_FLAG_NORMAL, NULL);
#endif
return;
}
GdkColor col;
gdk_color_parse(hime_win_color_fg, &col);
#if !GTK_CHECK_VERSION(2,91,6)
if (label)
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &col);
if (label_edit)
gtk_widget_modify_fg(label_edit, GTK_STATE_NORMAL, &col);
if (label_gtab_pre_sel)
gtk_widget_modify_fg(label_gtab_pre_sel, GTK_STATE_NORMAL, &col);
#else
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&col));
if (label)
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &rgbfg);
if (label_edit)
gtk_widget_override_color(label_edit, GTK_STATE_FLAG_NORMAL, &rgbfg);
if (label_gtab_pre_sel)
gtk_widget_override_color(label_gtab_pre_sel, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
}
void change_tsin_font_size()
{
if (!top_bin)
return;
GdkColor fg;
gdk_color_parse(gcin_win_color_fg, &fg);
set_label_font_size(label_pho, gcin_font_size_tsin_pho_in);
int i;
for(i=0; i < MAX_PH_BF_EXT; i++) {
GtkWidget *label = chars[i].label;
if (!label)
continue;
set_label_font_size(label, gcin_font_size);
if (gcin_win_color_use) {
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &fg);
#else
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&fg));
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
}
}
compact_win0();
// change_win1_font();
set_win0_bg();
// change_tsin_line_color();
}
int
main (int argc,
char *argv[])
{
ScreenSaver *screen_saver;
GtkWidget *window;
GtkWidget *drawing_area;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkRGBA bg;
GdkRGBA fg;
#else
GtkStyle *style;
GtkStateType state;
#endif
GError *error;
error = NULL;
bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_init_with_args (&argc, &argv,
/* translators: the word "image" here
* represents a command line argument
*/
_("image - floats images around the screen"),
options, GETTEXT_PACKAGE, &error);
if (error != NULL)
{
g_printerr (_("%s. See --help for usage information.\n"),
_(error->message));
g_error_free (error);
return EX_SOFTWARE;
}
if ((filenames == NULL) || (filenames[0] == NULL) ||
(filenames[1] != NULL))
{
g_printerr (_("You must specify one image. See --help for usage "
"information.\n"));
return EX_USAGE;
}
window = gs_theme_window_new ();
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
drawing_area = gtk_drawing_area_new ();
#if GTK_CHECK_VERSION (3, 0, 0)
bg.red = 0;
bg.green = 0;
bg.blue = 0;
bg.alpha = 1.0;
fg.red = 0.8;
fg.green = 0.8;
fg.blue = 0.8;
fg.alpha = 1.0;
gtk_widget_override_background_color (drawing_area, 0, &bg);
gtk_widget_override_color (drawing_area, 0, &fg);
#else
style = drawing_area->style;
state = (GtkStateType) 0;
while (state < (GtkStateType) G_N_ELEMENTS (style->bg))
{
gtk_widget_modify_bg (drawing_area, state, &style->mid[state]);
state++;
}
#endif
gtk_widget_show (drawing_area);
gtk_container_add (GTK_CONTAINER (window), drawing_area);
screen_saver = screen_saver_new (GTK_DRAWING_AREA (drawing_area),
filenames[0], max_floater_count,
should_do_rotations, should_show_paths);
g_strfreev (filenames);
if (should_print_stats)
g_timeout_add (STAT_PRINT_FREQUENCY,
(GSourceFunc) do_print_screen_saver_stats,
screen_saver);
if ((geometry == NULL)
|| !gtk_window_parse_geometry (GTK_WINDOW (window), geometry))
gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
gtk_widget_show (window);
gtk_main ();
screen_saver_free (screen_saver);
return EX_OK;
}
static void
warlock_view_create_text_view (WarlockView *warlock_view)
{
PangoFontDescription *font;
GdkRGBA *color;
GtkTextIter iter;
GtkWidget *text_view;
text_view = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view),
GTK_WRAP_WORD_CHAR);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
warlock_view->text_buffer = gtk_text_buffer_new (highlight_tag_table);
warlock_view->text_view = text_view;
gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view),
warlock_view->text_buffer);
gtk_text_buffer_get_end_iter (warlock_view->text_buffer, &iter);
warlock_view->mark = gtk_text_buffer_create_mark
(warlock_view->text_buffer, NULL, &iter, TRUE);
/* set the text color */
color = preferences_get_color (preferences_get_key
(PREF_DEFAULT_TEXT_COLOR));
if (color == NULL) {
color = g_new (GdkRGBA, 1);
gdk_rgba_parse (color, "white");
}
gtk_widget_override_color (text_view, GTK_STATE_NORMAL, color);
g_free (color);
/* set the background color*/
color = preferences_get_color (preferences_get_key
(PREF_DEFAULT_BASE_COLOR));
if (color == NULL) {
color = g_new (GdkRGBA, 1);
gdk_rgba_parse (color, "black");
}
gtk_widget_override_background_color (text_view, GTK_STATE_NORMAL,
color);
g_free (color);
/* set the font */
font = preferences_get_font (preferences_get_key (PREF_DEFAULT_FONT));
if (font == NULL) {
font = pango_font_description_from_string ("sans");
}
gtk_widget_override_font (text_view, font);
/* listen to gconf and change the text color when the gconf
* value changes */
preferences_notify_add (preferences_get_key (PREF_DEFAULT_TEXT_COLOR),
change_text_color, text_view);
/* listen for background change */
preferences_notify_add (preferences_get_key (PREF_DEFAULT_BASE_COLOR),
change_base_color, text_view);
/* listen for font change */
preferences_notify_add (preferences_get_key (PREF_DEFAULT_FONT),
change_font, text_view);
}
GtkWidget * create_videobox(entry * argEntry)
{
GtkWidget * top;
GtkWidget * box;
GtkWidget * title;
GtkWidget * author;
GtkWidget * duration;
GtkWidget * thumboverlay; /*GTKoverlay to overlay author and duration over the image thumb.*/
GtkWidget * thumb;
GdkRGBA * bgcolor = NULL;
uint8_t colorret =0;
if(argEntry == (entry *) NULL)
return (GtkWidget *) NULL;
//construction
top = gtk_event_box_new();
box = gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
get_thumb_filename(argEntry);
thumb = gtk_image_new_from_file(argEntry->fields[THUMBLOC]);
title = gtk_label_new(argEntry->fields[TITLE]);
author = gtk_label_new(argEntry->fields[AUTHOR]);
duration = gtk_label_new(argEntry->fields[DURATION]);
thumboverlay = gtk_overlay_new();
gtk_label_set_ellipsize(GTK_LABEL(title),PANGO_ELLIPSIZE_END);
gtk_label_set_ellipsize(GTK_LABEL(author),PANGO_ELLIPSIZE_END);
gtk_label_set_line_wrap(GTK_LABEL(title),gtk_true());
gtk_widget_set_tooltip_text(title,argEntry->fields[TITLE]);
gtk_widget_set_size_request(thumboverlay,120,20);
gtk_widget_set_size_request(top,ENTRYWIDTH,ENTRYHEIGHT);
gtk_widget_set_valign(author,GTK_ALIGN_START);
gtk_widget_set_halign(author,GTK_ALIGN_START);
gtk_widget_set_valign(duration,GTK_ALIGN_END);
gtk_widget_set_halign(duration,GTK_ALIGN_END);
//Adding widgets
gtk_container_add(GTK_CONTAINER(thumboverlay), thumb);
gtk_container_add(GTK_CONTAINER(top), box);
gtk_overlay_add_overlay(GTK_OVERLAY(thumboverlay),author);
gtk_overlay_add_overlay(GTK_OVERLAY(thumboverlay),duration);
gtk_box_set_homogeneous(GTK_BOX(box),FALSE);
gtk_box_pack_start(GTK_BOX(box),title,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(box),thumboverlay,FALSE,FALSE,0);
//Color
bgcolor = get_bgcolor(argEntry->fields[AUTHOR]);
colorret = adjust_titlecolor(bgcolor);
gtk_widget_override_color(title,GTK_STATE_FLAG_NORMAL,RGBARRAY[colorret]);
gtk_widget_override_background_color(top,GTK_STATE_FLAG_NORMAL,bgcolor);
free(bgcolor);
// gtk_widget_add_events(thumb, GDK_BUTTON_MOTION_MASK);
g_signal_connect(top,"button-press-event",G_CALLBACK(get_ytstream),argEntry->fields[ID]);
gtk_widget_override_background_color(thumboverlay,GTK_STATE_FLAG_NORMAL,&BLACK);
gtk_widget_override_color(author,GTK_STATE_FLAG_NORMAL,&WHITE);
gtk_widget_override_color(duration,GTK_STATE_FLAG_NORMAL,&WHITE);
gtk_widget_show_all(top);
return top;
}
static GtkWidget *
secure_button_get_widget_for_validity (CamelCipherValidity *validity)
{
GtkWidget *box, *button, *layout, *widget;
const gchar *icon_name;
gchar *description;
GString *buffer;
g_return_val_if_fail (validity != NULL, NULL);
buffer = g_string_new ("");
if (validity->sign.status != CAMEL_CIPHER_VALIDITY_SIGN_NONE) {
const gchar *desc;
gint status;
status = validity->sign.status;
desc = smime_sign_table[status].shortdesc;
g_string_append (buffer, gettext (desc));
format_cert_infos (&validity->sign.signers, buffer);
}
if (validity->encrypt.status != CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE) {
const gchar *desc;
gint status;
if (validity->sign.status != CAMEL_CIPHER_VALIDITY_SIGN_NONE)
g_string_append (buffer, "\n");
status = validity->encrypt.status;
desc = smime_encrypt_table[status].shortdesc;
g_string_append (buffer, gettext (desc));
}
description = g_string_free (buffer, FALSE);
/* FIXME: need to have it based on encryption and signing too */
if (validity->sign.status != 0)
icon_name = smime_sign_table[validity->sign.status].icon;
else
icon_name = smime_encrypt_table[validity->encrypt.status].icon;
box = gtk_event_box_new ();
if (validity->sign.status != 0)
gtk_widget_override_background_color (
box, GTK_STATE_FLAG_NORMAL,
&smime_sign_colour[validity->sign.status]);
layout = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add (GTK_CONTAINER (box), layout);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (layout), button, FALSE, FALSE, 0);
g_signal_connect (
button, "clicked",
G_CALLBACK (secure_button_clicked_cb), validity);
widget = gtk_image_new_from_icon_name (
icon_name, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image (GTK_BUTTON (button), widget);
widget = gtk_label_new (description);
/* make sure the text color doesn't change with theme */
gtk_widget_override_color (widget, GTK_STATE_FLAG_NORMAL, &smime_sign_colour[5]);
gtk_box_pack_start (GTK_BOX (layout), widget, FALSE, FALSE, 0);
g_free (description);
return box;
}
/* function to clear label color */
void clearcolor(GtkWidget *label,
GtkWidget *eventbox)
{
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, NULL);
gtk_widget_override_background_color(eventbox, GTK_STATE_FLAG_NORMAL, NULL);
}
static GtkWidget *
create_label_window (CcRRLabeler *labeler, GnomeRROutputInfo *output, GdkRGBA *rgba)
{
GtkWidget *window;
GtkWidget *widget;
char *str;
const char *display_name;
GdkRGBA black = { 0, 0, 0, 1.0 };
int x, y;
GdkScreen *screen;
GdkVisual *visual;
window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_TOOLTIP);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_widget_set_app_paintable (window, TRUE);
screen = gtk_widget_get_screen (window);
visual = gdk_screen_get_rgba_visual (screen);
if (visual != NULL)
gtk_widget_set_visual (window, visual);
gtk_container_set_border_width (GTK_CONTAINER (window), LABEL_WINDOW_PADDING + LABEL_WINDOW_EDGE_THICKNESS);
/* This is semi-dangerous. The color is part of the labeler->palette
* array. Note that in cc_rr_labeler_finalize(), we are careful to
* free the palette only after we free the windows.
*/
g_object_set_data (G_OBJECT (window), "rgba", rgba);
g_signal_connect (window, "draw",
G_CALLBACK (label_window_draw_event_cb), labeler);
g_signal_connect (window, "realize",
G_CALLBACK (label_window_realize_cb), labeler);
g_signal_connect (window, "composited-changed",
G_CALLBACK (label_window_composited_changed_cb), labeler);
if (gnome_rr_config_get_clone (labeler->priv->config)) {
/* Keep this string in sync with gnome-control-center/capplets/display/xrandr-capplet.c:get_display_name() */
/* Translators: this is the feature where what you see on your
* laptop's screen is the same as your external projector.
* Here, "Mirrored" is being used as an adjective. For example,
* the Spanish translation could be "Pantallas en Espejo".
*/
display_name = _("Mirrored Displays");
} else
display_name = gnome_rr_output_info_get_display_name (output);
str = g_strdup_printf ("<b>%s</b>", display_name);
widget = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (widget), str);
g_free (str);
/* Make the label explicitly black. We don't want it to follow the
* theme's colors, since the label is always shown against a light
* pastel background. See bgo#556050
*/
gtk_widget_override_color (widget,
gtk_widget_get_state_flags (widget),
&black);
gtk_container_add (GTK_CONTAINER (window), widget);
/* Should we center this at the top edge of the monitor, instead of using the upper-left corner? */
gnome_rr_output_info_get_geometry (output, &x, &y, NULL, NULL);
position_window (labeler, window, x, y);
gtk_widget_show_all (window);
return window;
}
gint
main (gint argc, gchar *argv[])
{
gtk_init (&argc, &argv);
g_object_set (gtk_settings_get_default (), "gtk-application-prefer-dark-theme", TRUE, NULL);
gsize size = DEFAULT_SIZE;
guint32 target = DEFAULT_TARGET;
const gchar *theme = DEFAULT_THEME;
GOptionEntry options[] = {
{ "size", 's', 0, G_OPTION_ARG_INT, &size, "The size of the grid", "4" },
{ "target", '\0', 0, G_OPTION_ARG_INT, &target, "The tile to reach", "2048" },
{ "theme", 't', 0, G_OPTION_ARG_STRING, &theme, "The theme to use", DEFAULT_THEME },
{ NULL, '\0', 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
G_2048_CLEANUP_OPTIONS_FREE GOptionContext *ctx = g_option_context_new ("foobar");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gtk_get_option_group (TRUE));
g_option_context_parse (ctx, &argc, &argv, NULL);
GtkApplication *app = gtk_application_new ("org.gnome.g2048", G_APPLICATION_FLAGS_NONE);
GApplication *gapp = G_APPLICATION (app);
G_2048_CLEANUP_ERROR_FREE GError *error = NULL;
G_APPLICATION_GET_CLASS (gapp)->activate = show_win;
g_application_register (gapp, NULL, &error);
if (error)
{
fprintf (stderr, "Failed to register the gtk application: %s\n", error->message);
return EXIT_FAILURE;
}
if (g_application_get_is_remote (gapp))
{
g_application_activate (gapp);
return EXIT_SUCCESS;
}
G_2048_CLEANUP_FREE gchar *theme_path = get_theme_path (theme);
if (!theme_path)
theme_path = get_theme_path (DEFAULT_THEME);
if (!theme_path)
{
g_critical ("No theme found");
exit (EXIT_FAILURE);
}
GtkWidget *score_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
GtkBox *hbox = GTK_BOX (score_box);
gtk_box_pack_start (hbox, gtk_label_new ("Score:"), TRUE, TRUE, 0);
GtkWidget *score_label = gtk_label_new ("0");
GtkLabel *label = GTK_LABEL (score_label);
GdkRGBA color;
gdk_rgba_parse (&color, "white");
gtk_widget_override_background_color (score_label, GTK_STATE_FLAG_NORMAL, &color);
gdk_rgba_parse (&color, "black");
gtk_widget_override_color (score_label, GTK_STATE_FLAG_NORMAL, &color);
gtk_label_set_width_chars (GTK_LABEL (score_label), 8);
gtk_box_pack_end (hbox, score_label, TRUE, FALSE, 0);
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
GtkBox *vbox = GTK_BOX (box);
gtk_box_pack_start (vbox, g_2048_grid_new (size, target, theme_path, label), TRUE, TRUE, 0);
gtk_box_pack_end (vbox, score_box, TRUE, TRUE, 20);
GtkWidget *win = gtk_widget_new (GTK_TYPE_APPLICATION_WINDOW,
"application", app,
"type", GTK_WINDOW_TOPLEVEL,
"window-position", GTK_WIN_POS_CENTER,
"resizable", FALSE,
NULL);
gtk_container_add (GTK_CONTAINER (win), box);
gtk_widget_show_all (win);
gtk_widget_override_font (win, pango_font_description_from_string("Monospace 18"));
GTK_WIDGET_GET_CLASS (win)->key_press_event = on_key;
return g_application_run (gapp, argc, argv);
}
static GtkWidget *
create_label_window (MateRRLabeler *labeler, MateRROutputInfo *output, GdkColor *color)
#endif
{
GtkWidget *window;
GtkWidget *widget;
char *str;
const char *display_name;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkRGBA black = { 0., 0., 0., 1. };
#else
GdkColor black = { 0, 0, 0, 0 };
#endif
int x,y;
window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_app_paintable (window, TRUE);
gtk_container_set_border_width (GTK_CONTAINER (window), LABEL_WINDOW_PADDING + LABEL_WINDOW_EDGE_THICKNESS);
/* This is semi-dangerous. The color is part of the labeler->palette
* array. Note that in mate_rr_labeler_finalize(), we are careful to
* free the palette only after we free the windows.
*/
g_object_set_data (G_OBJECT (window), "color", color);
#if GTK_CHECK_VERSION (3, 0, 0)
g_signal_connect (window, "draw",
G_CALLBACK (label_window_draw_event_cb), labeler);
#else
g_signal_connect (window, "expose-event",
G_CALLBACK (label_window_expose_event_cb), labeler);
#endif
if (mate_rr_config_get_clone (labeler->priv->config)) {
/* Keep this string in sync with mate-control-center/capplets/display/xrandr-capplet.c:get_display_name() */
/* Translators: this is the feature where what you see on your laptop's
* screen is the same as your external monitor. Here, "Mirror" is being
* used as an adjective, not as a verb. For example, the Spanish
* translation could be "Pantallas en Espejo", *not* "Espejar Pantallas".
*/
display_name = g_strdup_printf (_("Mirror Screens"));
str = g_strdup_printf ("<b>%s</b>", display_name);
} else {
display_name = g_strdup_printf ("<b>%s</b>\n<small>%s</small>", mate_rr_output_info_get_display_name (output), mate_rr_output_info_get_name (output));
str = g_strdup_printf ("%s", display_name);
}
g_free (display_name);
widget = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (widget), str);
g_free (str);
/* Make the label explicitly black. We don't want it to follow the
* theme's colors, since the label is always shown against a light
* pastel background. See bgo#556050
*/
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_override_color(widget, gtk_widget_get_state_flags (widget), &black);
#else
gtk_widget_modify_fg (widget, gtk_widget_get_state (widget), &black);
#endif
gtk_container_add (GTK_CONTAINER (window), widget);
/* Should we center this at the top edge of the monitor, instead of using the upper-left corner? */
mate_rr_output_info_get_geometry (output, &x, &y, NULL, NULL);
position_window (labeler, window, x, y);
gtk_widget_show_all (window);
return window;
}
void set_gtab_input_color(GdkRGBA *rgbfg)
{
if (label_gtab)
gtk_widget_override_color(label_gtab, GTK_STATE_FLAG_NORMAL, rgbfg);
}
