/* Common XML format for both Bijiben / Tomboy */
static void
processNode (BijiLazyDeserializer *self)
{
xmlTextReaderPtr r = self->priv->r;
BijiNoteObj * n = self->priv->note;
xmlChar *name;
GdkRGBA color;
gchar *tag, *color_str;
GString *norm;
name = xmlTextReaderName (r);
if ( g_strcmp0((gchar*)name,"title") == 0 )
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_title, n);
if ( g_strcmp0((gchar*)name,"text") == 0 )
{
if (self->priv->type == BIJIBEN_1)
{
process_bijiben_html_content (self, r);
}
else if (self->priv->type == TOMBOY_1 ||
self->priv->type == TOMBOY_2 ||
self->priv->type == TOMBOY_3 )
{
self->priv->content = (gchar*) xmlTextReaderReadInnerXml (r);
process_tomboy_xml_content (self);
}
}
if (g_strcmp0 ((gchar*) name, "last-change-date") == 0)
{
gchar *result = (gchar*) xmlTextReaderReadString (r);
biji_note_obj_set_mtime (n, iso8601_to_gint64 (result));
free (result);
}
if (g_strcmp0 ((gchar*) name, "last-metadata-change-date") == 0)
{
gchar *result = (gchar*) xmlTextReaderReadString (r);
biji_note_obj_set_last_metadata_change_date (n, iso8601_to_gint64 (result));
free (result);
}
if (g_strcmp0 ((gchar*) name, "create-date") == 0)
{
gchar *result = (gchar*) xmlTextReaderReadString (r);
biji_note_obj_set_create_date (n, iso8601_to_gint64 (result));
free (result);
}
if (g_strcmp0 ((gchar*) name, "color") == 0 )
{
color_str = (gchar*) xmlTextReaderReadString (r);
if (gdk_rgba_parse (&color, color_str))
biji_note_obj_set_rgba (n, &color);
else
g_warning ("color invalid:%s", color_str);
free (color_str);
}
if ( g_strcmp0((gchar*)name,"tag") == 0 )
{
tag = (gchar*) xmlTextReaderReadString(r);
if (g_str_has_prefix (tag,"system:template"))
{
note_obj_set_is_template(n,TRUE);
}
else if (g_str_has_prefix (tag,"system:notebook:"))
{
norm = g_string_new (tag);
g_string_erase (norm,0,16);
biji_item_add_notebook (BIJI_ITEM (n), NULL, norm->str);
g_string_free (norm, TRUE);
}
free (tag);
}
xmlFree(name);
}
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);
}
void create_kbm_window()
{
if (hime_kbm_window) {
gtk_window_present(GTK_WINDOW(hime_kbm_window));
return;
}
load_setttings();
hime_kbm_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(hime_kbm_window), GTK_WIN_POS_MOUSE);
gtk_window_set_has_resize_grip(GTK_WINDOW(hime_kbm_window), FALSE);
g_signal_connect (G_OBJECT (hime_kbm_window), "delete_event",
G_CALLBACK (close_kbm_window),
NULL);
gtk_window_set_title (GTK_WINDOW (hime_kbm_window), _("HIME 注音/詞音設定"));
gtk_container_set_border_width (GTK_CONTAINER (hime_kbm_window), 1);
GtkWidget *vbox_top = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (hime_kbm_window), vbox_top);
GtkWidget *hbox_lr = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_lr, TRUE, TRUE, 0);
GtkWidget *vbox_l = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_l), GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_l, TRUE, TRUE, 10);
GtkWidget *vbox_r = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_r), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_homogeneous(GTK_GRID(vbox_r), TRUE);
gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_r, TRUE, TRUE, 10);
GtkWidget *frame_kbm = gtk_frame_new(_("鍵盤排列方式/選擇鍵/選單每列字數"));
gtk_box_pack_start (GTK_BOX (vbox_l), frame_kbm, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_kbm), 1);
gtk_container_add (GTK_CONTAINER (frame_kbm), create_kbm_opts());
gtk_box_pack_start (GTK_BOX (vbox_l), create_en_pho_key_sel(_("(詞音) 切換[中/英]輸入")), TRUE, TRUE, 0);
GtkWidget *frame_tsin_space_opt = gtk_frame_new(_("(詞音) 鍵入空白鍵"));
gtk_box_pack_start (GTK_BOX (vbox_l), frame_tsin_space_opt, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_space_opt), 1);
GtkWidget *box_tsin_space_opt = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(box_tsin_space_opt), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (frame_tsin_space_opt), box_tsin_space_opt);
gtk_container_set_border_width (GTK_CONTAINER (box_tsin_space_opt), 1);
GSList *group_tsin_space_opt = NULL;
int current_idx = get_currnet_tsin_space_option_idx();
new_select_idx_tsin_space_opt = current_idx;
gsize i;
for(i=0; i< tsin_space_optionsN; i++) {
GtkWidget *button = gtk_radio_button_new_with_label (group_tsin_space_opt, _(tsin_space_options[i].name));
gtk_box_pack_start (GTK_BOX (box_tsin_space_opt), button, TRUE, TRUE, 0);
group_tsin_space_opt = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (callback_button_clicked_tsin_space_opt), (gpointer) i);
if (i==current_idx)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
}
GtkWidget *hbox_tsin_phrase_pre_select = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_tsin_phrase_pre_select , TRUE, TRUE, 1);
check_button_tsin_phrase_pre_select = gtk_check_button_new_with_label(_("詞音輸入預選詞視窗"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_phrase_pre_select), check_button_tsin_phrase_pre_select, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_phrase_pre_select), tsin_phrase_pre_select);
GtkWidget *hbox_phonetic_char_dynamic_sequence = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_phonetic_char_dynamic_sequence , TRUE, TRUE, 1);
check_button_phonetic_char_dynamic_sequence = gtk_check_button_new_with_label(_("依使用頻率調整字的順序"));
gtk_box_pack_start (GTK_BOX (hbox_phonetic_char_dynamic_sequence), check_button_phonetic_char_dynamic_sequence, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_phonetic_char_dynamic_sequence), phonetic_char_dynamic_sequence);
GtkWidget *hbox_pho_hide_row2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_pho_hide_row2 , TRUE, TRUE, 1);
check_button_pho_hide_row2 = gtk_check_button_new_with_label(_("注音隱藏第二列 (注音符號)"));
gtk_box_pack_start (GTK_BOX (hbox_pho_hide_row2), check_button_pho_hide_row2, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_pho_hide_row2), pho_hide_row2);
GtkWidget *hbox_pho_in_row1 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_pho_in_row1 , TRUE, TRUE, 1);
check_button_pho_in_row1 = gtk_check_button_new_with_label(_("注音符號移至第一列"));
gtk_box_pack_start (GTK_BOX (hbox_pho_in_row1), check_button_pho_in_row1, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_pho_in_row1), pho_in_row1);
GtkWidget *hbox_phonetic_huge_tab = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_phonetic_huge_tab , TRUE, TRUE, 1);
check_button_phonetic_huge_tab = gtk_check_button_new_with_label(_("使用巨大 UTF-8 字集"));
gtk_box_pack_start (GTK_BOX (hbox_phonetic_huge_tab), check_button_phonetic_huge_tab, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_phonetic_huge_tab), phonetic_huge_tab);
GtkWidget *hbox_tsin_tone_char_input = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tone_char_input , TRUE, TRUE, 1);
check_button_tsin_tone_char_input = gtk_check_button_new_with_label(_("(詞音) 輸入注音聲調符號"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tone_char_input), check_button_tsin_tone_char_input, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tone_char_input), tsin_tone_char_input);
GtkWidget *hbox_tsin_tab_phrase_end = gtk_hbox_new(FALSE, 1);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tab_phrase_end , TRUE, TRUE, 1);
check_button_tsin_tab_phrase_end = gtk_check_button_new_with_label(_("(詞音) 使用 Escape/Tab 斷詞"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tab_phrase_end), check_button_tsin_tab_phrase_end, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tab_phrase_end), tsin_tab_phrase_end);
GtkWidget *hbox_tsin_tail_select_key = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tail_select_key , TRUE, TRUE, 1);
check_button_tsin_tail_select_key = gtk_check_button_new_with_label(_("選擇鍵顯示於候選字(詞)後方"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tail_select_key), check_button_tsin_tail_select_key, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tail_select_key), tsin_tail_select_key);
GtkWidget *hbox_tsin_buffer_editing_mode = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_buffer_editing_mode , TRUE, TRUE, 1);
check_button_tsin_buffer_editing_mode = gtk_check_button_new_with_label(_("\\ 鍵可切換 jkx 鍵編輯模式"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_buffer_editing_mode), check_button_tsin_buffer_editing_mode, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_buffer_editing_mode), tsin_buffer_editing_mode);
GtkWidget *hbox_tsin_use_pho_near = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_use_pho_near , TRUE, TRUE, 1);
check_button_tsin_use_pho_near = gtk_check_button_new_with_label(_("按下 ↑ 鍵查詢近似音"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_use_pho_near), check_button_tsin_use_pho_near, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_use_pho_near), tsin_use_pho_near);
GtkWidget *frame_tsin_buffer_size = gtk_frame_new(_("(詞音) 的編輯緩衝區大小"));
gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_buffer_size, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_buffer_size), 1);
GtkAdjustment *adj_gtab_in =
(GtkAdjustment *) gtk_adjustment_new (tsin_buffer_size, 10.0, MAX_PH_BF, 1.0, 1.0, 0.0);
spinner_tsin_buffer_size = gtk_spin_button_new (adj_gtab_in, 0, 0);
gtk_container_add (GTK_CONTAINER (frame_tsin_buffer_size), spinner_tsin_buffer_size);
GtkWidget *frame_tsin_cursor_color = gtk_frame_new(_("詞音游標的顏色"));
gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_cursor_color, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_cursor_color), 1);
GtkWidget *button_tsin_cursor_color = gtk_button_new();
g_signal_connect (G_OBJECT (button_tsin_cursor_color), "clicked",
G_CALLBACK (cb_tsin_cursor_color), G_OBJECT (hime_kbm_window));
da_cursor = gtk_drawing_area_new();
gtk_container_add (GTK_CONTAINER (button_tsin_cursor_color), da_cursor);
gdk_color_parse(tsin_cursor_color, &tsin_cursor_gcolor);
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_bg(da_cursor, GTK_STATE_NORMAL, &tsin_cursor_gcolor);
#else
GdkRGBA rgbbg;
gdk_rgba_parse(&rgbbg, gdk_color_to_string(&tsin_cursor_gcolor));
gtk_widget_override_background_color(da_cursor, GTK_STATE_FLAG_NORMAL, &rgbbg);
#endif
gtk_widget_set_size_request(da_cursor, 16, 2);
gtk_container_add (GTK_CONTAINER (frame_tsin_cursor_color), button_tsin_cursor_color);
GtkWidget *hbox_cancel_ok = gtk_hbox_new (FALSE, 10);
gtk_grid_set_column_homogeneous(GTK_GRID(hbox_cancel_ok), TRUE);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_cancel_ok , FALSE, FALSE, 5);
GtkWidget *button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
if (button_order)
gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
else
gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
GtkWidget *button_ok = gtk_button_new_from_stock (GTK_STOCK_OK);
#if !GTK_CHECK_VERSION(2,91,2)
if (button_order)
gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5);
else
gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5);
#else
if (button_order)
gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_LEFT, 1, 1);
else
gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_RIGHT, 1, 1);
#endif
g_signal_connect (G_OBJECT (button_cancel), "clicked",
G_CALLBACK (close_kbm_window),
G_OBJECT (hime_kbm_window));
g_signal_connect_swapped (G_OBJECT (button_ok), "clicked",
G_CALLBACK (cb_ok),
G_OBJECT (hime_kbm_window));
GTK_WIDGET_SET_FLAGS (button_cancel, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button_cancel);
gtk_widget_show_all (hime_kbm_window);
return;
}
static void
gtk_cell_view_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GtkCellView *view = GTK_CELL_VIEW (object);
GtkCellViewPrivate *priv = view->priv;
GtkCellArea *area;
GtkCellAreaContext *context;
switch (param_id)
{
case PROP_ORIENTATION:
priv->orientation = g_value_get_enum (value);
if (priv->context)
gtk_cell_area_context_reset (priv->context);
_gtk_orientable_set_style_classes (GTK_ORIENTABLE (object));
break;
case PROP_BACKGROUND:
{
GdkRGBA color;
if (!g_value_get_string (value))
gtk_cell_view_set_background_rgba (view, NULL);
else if (gdk_rgba_parse (&color, g_value_get_string (value)))
gtk_cell_view_set_background_rgba (view, &color);
else
g_warning ("Don't know color `%s'", g_value_get_string (value));
g_object_notify (object, "background-rgba");
g_object_notify (object, "background-gdk");
}
break;
case PROP_BACKGROUND_GDK:
{
GdkColor *color;
GdkRGBA rgba;
color = g_value_get_boxed (value);
rgba.red = color->red / 65535.0;
rgba.green = color->green / 65535.0;
rgba.blue = color->blue / 65535.0;
rgba.alpha = 1.0;
gtk_cell_view_set_background_rgba (view, &rgba);
}
break;
case PROP_BACKGROUND_RGBA:
gtk_cell_view_set_background_rgba (view, g_value_get_boxed (value));
break;
case PROP_BACKGROUND_SET:
view->priv->background_set = g_value_get_boolean (value);
break;
case PROP_MODEL:
gtk_cell_view_set_model (view, g_value_get_object (value));
break;
case PROP_CELL_AREA:
/* Construct-only, can only be assigned once */
area = g_value_get_object (value);
if (area)
{
if (priv->area != NULL)
{
g_warning ("cell-area has already been set, ignoring construct property");
g_object_ref_sink (area);
g_object_unref (area);
}
else
priv->area = g_object_ref_sink (area);
}
break;
case PROP_CELL_AREA_CONTEXT:
/* Construct-only, can only be assigned once */
context = g_value_get_object (value);
if (context)
{
if (priv->context != NULL)
{
g_warning ("cell-area-context has already been set, ignoring construct property");
g_object_ref_sink (context);
g_object_unref (context);
}
else
priv->context = g_object_ref (context);
}
break;
case PROP_DRAW_SENSITIVE:
gtk_cell_view_set_draw_sensitive (view, g_value_get_boolean (value));
break;
case PROP_FIT_MODEL:
gtk_cell_view_set_fit_model (view, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
static void
populate_colors (GtkWidget *widget)
{
struct { const gchar *name; const gchar *color; const gchar *title; } colors[] = {
{ "2.5", "#C8828C", "Red" },
{ "5", "#C98286", NULL },
{ "7.5", "#C9827F", NULL },
{ "10", "#C98376", NULL },
{ "2.5", "#C8856D", "Red/Yellow" },
{ "5", "#C58764", NULL },
{ "7.5", "#C1895E", NULL },
{ "10", "#BB8C56", NULL },
{ "2.5", "#B58F4F", "Yellow" },
{ "5", "#AD924B", NULL },
{ "7.5", "#A79548", NULL },
{ "10", "#A09749", NULL },
{ "2.5", "#979A4E", "Yellow/Green" },
{ "5", "#8D9C55", NULL },
{ "7.5", "#7F9F62", NULL },
{ "10", "#73A06E", NULL },
{ "2.5", "#65A27C", "Green" },
{ "5", "#5CA386", NULL },
{ "7.5", "#57A38D", NULL },
{ "10", "#52A394", NULL },
{ "2.5", "#4EA39A", "Green/Blue" },
{ "5", "#49A3A2", NULL },
{ "7.5", "#46A2AA", NULL },
{ "10", "#46A1B1", NULL },
{ "2.5", "#49A0B8", "Blue" },
{ "5", "#529EBD", NULL },
{ "7.5", "#5D9CC1", NULL },
{ "10", "#689AC3", NULL },
{ "2.5", "#7597C5", "Blue/Purple" },
{ "5", "#8095C6", NULL },
{ "7.5", "#8D91C6", NULL },
{ "10", "#988EC4", NULL },
{ "2.5", "#A08CC1", "Purple" },
{ "5", "#A88ABD", NULL },
{ "7.5", "#B187B6", NULL },
{ "10", "#B786B0", NULL },
{ "2.5", "#BC84A9", "Purple/Red" },
{ "5", "#C183A0", NULL },
{ "7.5", "#C48299", NULL },
{ "10", "#C68292", NULL }
};
gint i;
GtkWidget *row, *box, *label, *swatch;
GdkRGBA rgba;
gtk_list_box_set_header_func (GTK_LIST_BOX (widget), update_title_header, NULL, NULL);
for (i = 0; i < G_N_ELEMENTS (colors); i++)
{
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20);
label = gtk_label_new (colors[i].name);
g_object_set (label,
"halign", GTK_ALIGN_START,
"valign", GTK_ALIGN_CENTER,
"margin", 6,
"xalign", 0.0,
NULL);
gtk_box_pack_start (GTK_BOX (row), label, TRUE, TRUE, 0);
gdk_rgba_parse (&rgba, colors[i].color);
swatch = g_object_new (g_type_from_name ("GtkColorSwatch"),
"rgba", &rgba,
"selectable", FALSE,
"halign", GTK_ALIGN_END,
"valign", GTK_ALIGN_CENTER,
"margin", 6,
"height-request", 24,
NULL);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (box), swatch);
gtk_box_pack_start (GTK_BOX (row), box, FALSE, FALSE, 0);
gtk_widget_show_all (row);
gtk_list_box_insert (GTK_LIST_BOX (widget), row, -1);
row = gtk_widget_get_parent (row);
gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE);
if (colors[i].title)
g_object_set_data (G_OBJECT (row), "title", (gpointer)colors[i].title);
}
gtk_list_box_invalidate_headers (GTK_LIST_BOX (widget));
}
static void
marlin_text_renderer_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
MarlinTextRenderer *text_renderer = MARLIN_TEXT_RENDERER (cell);
GtkStyleContext *context;
GtkStateFlags state;
gint x0, x1, y0, y1;
gint text_width;
gint text_height;
gint x_offset;
gint y_offset;
gint xpad, ypad;
gfloat xalign, yalign;
gboolean selected;
/* setup the new widget */
marlin_text_renderer_set_widget (text_renderer, widget);
state = gtk_widget_get_state_flags (widget);
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
state |= GTK_STATE_FLAG_SELECTED;
}
else if ((flags & GTK_CELL_RENDERER_PRELIT) == GTK_CELL_RENDERER_PRELIT
&& gtk_widget_get_state (widget) == GTK_STATE_PRELIGHT)
{
state = GTK_STATE_PRELIGHT;
}
else
{
state = gtk_widget_get_sensitive (widget) ? GTK_STATE_FLAG_NORMAL : GTK_STATE_INSENSITIVE;
}
/* render small/normal text depending on the zoom_level */
if (text_renderer->zoom_level < MARLIN_ZOOM_LEVEL_NORMAL)
{
if (text_renderer->follow_prelit && (flags & GTK_CELL_RENDERER_PRELIT) != 0)
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_small_underline_single ());
else
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_small ());
} else {
if (text_renderer->follow_prelit && (flags & GTK_CELL_RENDERER_PRELIT) != 0)
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_underline_single ());
else
pango_layout_set_attributes (text_renderer->layout, NULL);
}
/* setup the wrapping */
if (text_renderer->wrap_width < 0)
{
pango_layout_set_width (text_renderer->layout, -1);
pango_layout_set_wrap (text_renderer->layout, PANGO_WRAP_CHAR);
}
else
{
pango_layout_set_width (text_renderer->layout, text_renderer->wrap_width * PANGO_SCALE);
pango_layout_set_wrap (text_renderer->layout, text_renderer->wrap_mode);
}
/* ellipsize to max lines except for selected or prelit items */
pango_layout_set_ellipsize (text_renderer->layout, PANGO_ELLIPSIZE_END);
pango_layout_set_height (text_renderer->layout, -3);
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED ||
(flags & GTK_CELL_RENDERER_PRELIT) == GTK_CELL_RENDERER_PRELIT) {
pango_layout_set_ellipsize (text_renderer->layout, PANGO_ELLIPSIZE_NONE);
}
gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
if (xalign == 0.5f)
pango_layout_set_alignment (text_renderer->layout, PANGO_ALIGN_CENTER);
pango_layout_set_text (text_renderer->layout, text_renderer->text, -1);
/* calculate the real text dimension */
pango_layout_get_pixel_size (text_renderer->layout, &text_width, &text_height);
/* take into account the state indicator (required for calculation) */
if (text_renderer->follow_state)
{
text_width += 2 * text_renderer->focus_width;
text_height += 2 * text_renderer->focus_width;
}
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
/* calculate the real x-offset */
x_offset = ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ? (1.0 - xalign) : xalign)
* (cell_area->width - text_width - (2 * xpad));
x_offset = MAX (x_offset, 0);
/* calculate the real y-offset */
y_offset = yalign * (cell_area->height - text_height - (2 * ypad));
y_offset = MAX (y_offset, 0);
context = gtk_widget_get_style_context (gtk_widget_get_parent (widget));
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
selected = ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED && text_renderer->follow_state);
/* render the state indicator */
if (selected || text_renderer->background != NULL)
{
/* calculate the text bounding box (including the focus padding/width) */
x0 = cell_area->x + x_offset;
y0 = cell_area->y + y_offset;
x1 = x0 + text_width;
y1 = y0 + text_height;
cairo_move_to (cr, x0 + 5, y0);
cairo_line_to (cr, x1 - 5, y0);
cairo_curve_to (cr, x1 - 5, y0, x1, y0, x1, y0 + 5);
cairo_line_to (cr, x1, y1 - 5);
cairo_curve_to (cr, x1, y1 - 5, x1, y1, x1 - 5, y1);
cairo_line_to (cr, x0 + 5, y1);
cairo_curve_to (cr, x0 + 5, y1, x0, y1, x0, y1 - 5);
cairo_line_to (cr, x0, y0 + 5);
cairo_curve_to (cr, x0, y0 + 5, x0, y0, x0 + 5, y0);
GdkRGBA color;
if(text_renderer->background != NULL && !selected)
{
if(!gdk_rgba_parse(&color, text_renderer->background))
{
g_critical("Can't parse this color value: %s", text_renderer->background);
gtk_style_context_get_background_color (context, state, &color);
}
}
else
{
gtk_style_context_get_background_color (context, state, &color);
}
gdk_cairo_set_source_rgba (cr, &color);
cairo_fill (cr);
}
/* draw the focus indicator */
if (text_renderer->follow_state && (flags & GTK_CELL_RENDERER_FOCUSED) != 0)
{
gtk_render_focus (context, cr, cell_area->x + x_offset, cell_area->y + y_offset, text_width, text_height);
}
/* get proper sizing for the layout drawing */
if (text_renderer->follow_state)
{
text_width -= 2 * text_renderer->focus_width;
text_height -= 2 * text_renderer->focus_width;
x_offset += text_renderer->focus_width;
y_offset += text_renderer->focus_width;
}
/* draw the text */
if (xalign == 0.5f)
x_offset = (cell_area->width - text_renderer->wrap_width)/2;
gtk_render_layout (context, cr,
cell_area->x + x_offset + xpad,
cell_area->y + y_offset + ypad,
text_renderer->layout);
gtk_style_context_restore (context);
}
static gboolean
cell_changed_cb (GtkEditable *editable,
gpointer user_data)
{
char *cell_text;
guint column;
GdkRGBA rgba;
gboolean value_valid = FALSE;
const char *colorname = NULL;
cell_text = gtk_editable_get_chars (editable, 0, -1);
/* The Netmask column can also contain prefix */
column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (user_data), "column"));
if (column == COL_PREFIX) {
/* The COL_PREFIX can contain IP address or prefix */
guint32 tmp_prefix;
errno = 0;
/* Is it a prefix? */
if (!strchr (cell_text, '.')) {
tmp_prefix = strtol (cell_text, NULL, 10);
if (*cell_text && !errno && tmp_prefix > 0 && tmp_prefix <= 32)
value_valid = TRUE;
} else {
struct in_addr tmp_addr;
/* Is it a netmask? */
if (inet_pton (AF_INET, cell_text, &tmp_addr) > 0)
value_valid = TRUE;
}
} else if (column == COL_METRIC) {
long int tmp_int;
errno = 0;
tmp_int = strtol (cell_text, NULL, 10);
if (errno || tmp_int < 0 || tmp_int > G_MAXUINT32)
value_valid = FALSE;
else
value_valid = TRUE;
} else {
struct in_addr tmp_addr = { 0 };
if (inet_pton (AF_INET, cell_text, &tmp_addr) > 0)
value_valid = TRUE;
/* 0.0.0.0 is not accepted for address */
if (column == COL_ADDRESS && tmp_addr.s_addr == 0)
value_valid = FALSE;
/* Consider empty next_hop as valid */
if (!*cell_text && column == COL_NEXT_HOP)
value_valid = TRUE;
}
/* Change cell's background color while editing */
colorname = value_valid ? "lightgreen" : "red";
gdk_rgba_parse (&rgba, colorname);
utils_override_bg_color (GTK_WIDGET (editable), &rgba);
g_free (cell_text);
return FALSE;
}
static void
mc_preferences_setup_dialog (GtkBuilder *builder,
MCData *mc)
{
MCPrefsDialog *dialog;
GtkCellRenderer *renderer;
GdkRGBA color;
dialog = &mc->prefs_dialog;
g_signal_connect (dialog->dialog, "response",
G_CALLBACK (preferences_response), mc);
gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_CLOSE);
gtk_window_set_default_size (GTK_WINDOW (dialog->dialog), 400, -1);
dialog->auto_complete_history_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "auto_complete_history_toggle"));
dialog->size_spinner = GTK_WIDGET (gtk_builder_get_object (builder, "size_spinner"));
dialog->use_default_theme_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "default_theme_toggle"));
dialog->fg_color_picker = GTK_WIDGET (gtk_builder_get_object (builder, "fg_color_picker"));
dialog->bg_color_picker = GTK_WIDGET (gtk_builder_get_object (builder, "bg_color_picker"));
dialog->macros_tree = GTK_WIDGET (gtk_builder_get_object (builder, "macros_tree"));
dialog->delete_button = GTK_WIDGET (gtk_builder_get_object (builder, "delete_button"));
dialog->add_button = GTK_WIDGET (gtk_builder_get_object (builder, "add_button"));
/* History based autocompletion */
g_signal_connect (dialog->auto_complete_history_toggle, "toggled",
G_CALLBACK (auto_complete_history_toggled), mc);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->auto_complete_history_toggle),
mc->preferences.auto_complete_history);
if (!g_settings_is_writable (mc->settings, KEY_AUTOCOMPLETE_HISTORY))
hard_set_sensitive (dialog->auto_complete_history_toggle, FALSE);
/* Width */
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->size_spinner), mc->preferences.normal_size_x);
g_signal_connect (dialog->size_spinner, "value_changed",
G_CALLBACK (size_value_changed), mc);
if (!g_settings_is_writable (mc->settings, KEY_NORMAL_SIZE_X)) {
hard_set_sensitive (dialog->size_spinner, FALSE);
hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "size_label")), FALSE);
hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "size_post_label")), FALSE);
}
/* Use default theme */
g_signal_connect (dialog->use_default_theme_toggle, "toggled",
G_CALLBACK (use_default_theme_toggled), mc);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->use_default_theme_toggle),
mc->preferences.show_default_theme);
if (!g_settings_is_writable (mc->settings, KEY_SHOW_DEFAULT_THEME))
hard_set_sensitive (dialog->use_default_theme_toggle, FALSE);
/* Foreground color */
g_signal_connect (dialog->fg_color_picker, "color_set",
G_CALLBACK (foreground_color_set), mc);
gdk_rgba_parse (&color, mc->preferences.cmd_line_color_fg);
gtk_color_button_set_rgba (GTK_COLOR_BUTTON (dialog->fg_color_picker), &color);
soft_set_sensitive (dialog->fg_color_picker, !mc->preferences.show_default_theme);
if (!g_settings_is_writable (mc->settings, KEY_CMD_LINE_COLOR_FG)) {
hard_set_sensitive (dialog->fg_color_picker, FALSE);
hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "fg_color_label")), FALSE);
}
/* Background color */
g_signal_connect (dialog->bg_color_picker, "color_set",
G_CALLBACK (background_color_set), mc);
gdk_rgba_parse (&color, mc->preferences.cmd_line_color_bg);
gtk_color_button_set_rgba (GTK_COLOR_BUTTON (dialog->bg_color_picker), &color);
soft_set_sensitive (dialog->bg_color_picker, !mc->preferences.show_default_theme);
if (!g_settings_is_writable (mc->settings, KEY_CMD_LINE_COLOR_BG)) {
hard_set_sensitive (dialog->bg_color_picker, FALSE);
hard_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "bg_color_label")), FALSE);
}
/* Macros Delete and Add buttons */
g_signal_connect (dialog->delete_button, "clicked", G_CALLBACK (macro_delete), mc);
g_signal_connect (dialog->add_button, "clicked", G_CALLBACK (macro_add), mc);
if (!g_settings_is_writable (mc->global_settings, KEY_MACRO_PATTERNS) ||
!g_settings_is_writable (mc->global_settings, KEY_MACRO_COMMANDS)) {
hard_set_sensitive (dialog->add_button, FALSE);
hard_set_sensitive (dialog->delete_button, FALSE);
hard_set_sensitive (dialog->macros_tree, FALSE);
}
/* Macros tree view */
dialog->macros_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->macros_tree),
GTK_TREE_MODEL (dialog->macros_store));
renderer = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_PATTERN));
g_signal_connect (renderer, "edited", G_CALLBACK (macro_edited), mc);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->macros_tree), -1,
_("Pattern"), renderer,
"text", COLUMN_PATTERN,
NULL);
renderer = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_COMMAND));
g_signal_connect (renderer, "edited", G_CALLBACK (macro_edited), mc);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->macros_tree), -1,
_("Command"), renderer,
"text", COLUMN_COMMAND,
NULL);
show_macros_list (mc);
}
GtkSymbolicColor *
_gtk_css_parser_read_symbolic_color (GtkCssParser *parser)
{
GtkSymbolicColor *symbolic;
guint color;
const char *names[] = {"rgba", "rgb", "lighter", "darker", "shade", "alpha", "mix",
GTK_WIN32_THEME_SYMBOLIC_COLOR_NAME};
char *name;
g_return_val_if_fail (GTK_IS_CSS_PARSER (parser), NULL);
if (_gtk_css_parser_try (parser, "@", FALSE))
{
name = _gtk_css_parser_try_name (parser, TRUE);
if (name)
{
symbolic = gtk_symbolic_color_new_name (name);
}
else
{
_gtk_css_parser_error (parser, "'%s' is not a valid symbolic color name", name);
symbolic = NULL;
}
g_free (name);
return symbolic;
}
for (color = 0; color < G_N_ELEMENTS (names); color++)
{
if (_gtk_css_parser_try (parser, names[color], TRUE))
break;
}
if (color < G_N_ELEMENTS (names))
return gtk_css_parser_read_symbolic_color_function (parser, color);
symbolic = gtk_css_parser_try_hash_color (parser);
if (symbolic)
return symbolic;
name = _gtk_css_parser_try_name (parser, TRUE);
if (name)
{
GdkRGBA rgba;
if (gdk_rgba_parse (&rgba, name))
{
symbolic = gtk_symbolic_color_new_literal (&rgba);
}
else
{
_gtk_css_parser_error (parser, "'%s' is not a valid color name", name);
symbolic = NULL;
}
g_free (name);
return symbolic;
}
_gtk_css_parser_error (parser, "Not a color definition");
return NULL;
}
void parse_config (GromitData *data)
{
GromitPaintContext *context=NULL;
GromitPaintContext *context_template=NULL;
GScanner *scanner;
GTokenType token;
gchar *filename;
int file;
gchar *name, *copy;
GromitPaintType type;
GdkRGBA *fg_color=NULL;
guint width, arrowsize, minwidth;
filename = g_strjoin (G_DIR_SEPARATOR_S,
g_get_user_config_dir(), "gromit-mpx.cfg", NULL);
file = open (filename, O_RDONLY);
if (file < 0)
{
g_printerr ("Could not open %s: %s\n", filename, g_strerror (errno));
/* try global config file */
g_free (filename);
filename = g_strdup ("/etc/gromit-mpx/gromit-mpx.cfg");
file = open (filename, O_RDONLY);
if (file < 0)
{
g_printerr ("Could not open %s: %s\n", filename, g_strerror (errno));
g_free (filename);
return;
}
}
scanner = g_scanner_new (NULL);
scanner->input_name = filename;
scanner->config->case_sensitive = 0;
scanner->config->scan_octal = 0;
scanner->config->identifier_2_string = 0;
scanner->config->char_2_token = 1;
scanner->config->numbers_2_int = 1;
scanner->config->int_2_float = 1;
g_scanner_scope_add_symbol (scanner, 0, "PEN", (gpointer) GROMIT_PEN);
g_scanner_scope_add_symbol (scanner, 0, "ERASER", (gpointer) GROMIT_ERASER);
g_scanner_scope_add_symbol (scanner, 0, "RECOLOR",(gpointer) GROMIT_RECOLOR);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON1", (gpointer) 1);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON2", (gpointer) 2);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON3", (gpointer) 3);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON4", (gpointer) 4);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON5", (gpointer) 5);
g_scanner_scope_add_symbol (scanner, 1, "SHIFT", (gpointer) 11);
g_scanner_scope_add_symbol (scanner, 1, "CONTROL", (gpointer) 12);
g_scanner_scope_add_symbol (scanner, 1, "META", (gpointer) 13);
g_scanner_scope_add_symbol (scanner, 1, "ALT", (gpointer) 13);
g_scanner_scope_add_symbol (scanner, 2, "size", (gpointer) 1);
g_scanner_scope_add_symbol (scanner, 2, "color", (gpointer) 2);
g_scanner_scope_add_symbol (scanner, 2, "arrowsize", (gpointer) 3);
g_scanner_scope_add_symbol (scanner, 2, "minsize", (gpointer) 4);
g_scanner_set_scope (scanner, 0);
scanner->config->scope_0_fallback = 0;
g_scanner_input_file (scanner, file);
token = g_scanner_get_next_token (scanner);
while (token != G_TOKEN_EOF)
{
/*
* New tool definition
*/
if (token == G_TOKEN_STRING)
{
name = parse_name (scanner);
token = g_scanner_cur_token(scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN, NULL,
NULL, NULL, "aborting", TRUE);
exit (1);
}
token = g_scanner_get_next_token (scanner);
/* defaults */
type = GROMIT_PEN;
width = 7;
arrowsize = 0;
minwidth = 1;
fg_color = data->red;
if (token == G_TOKEN_SYMBOL)
{
type = (GromitPaintType) scanner->value.v_symbol;
token = g_scanner_get_next_token (scanner);
}
else if (token == G_TOKEN_STRING)
{
copy = parse_name (scanner);
token = g_scanner_cur_token(scanner);
context_template = g_hash_table_lookup (data->tool_config, copy);
if (context_template)
{
type = context_template->type;
width = context_template->width;
arrowsize = context_template->arrowsize;
minwidth = context_template->minwidth;
fg_color = context_template->paint_color;
}
else
{
g_printerr ("WARNING: Unable to copy \"%s\": "
"not yet defined!\n", copy);
}
}
else
{
g_printerr ("Expected Tool-definition "
"or name of template tool\n");
exit (1);
}
/* Are there any tool-options?
*/
if (token == G_TOKEN_LEFT_PAREN)
{
GdkRGBA *color = NULL;
g_scanner_set_scope (scanner, 2);
scanner->config->int_2_float = 1;
token = g_scanner_get_next_token (scanner);
while (token != G_TOKEN_RIGHT_PAREN)
{
if (token == G_TOKEN_SYMBOL)
{
if ((intptr_t) scanner->value.v_symbol == 1)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Size (float)... aborting\n");
exit (1);
}
width = (guint) (scanner->value.v_float + 0.5);
}
else if ((intptr_t) scanner->value.v_symbol == 2)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_STRING)
{
g_printerr ("Missing Color (string)... "
"aborting\n");
exit (1);
}
color = g_malloc (sizeof (GdkRGBA));
if (gdk_rgba_parse (color, scanner->value.v_string))
{
fg_color = color;
}
else
{
g_printerr ("Unable to parse color. "
"Keeping default.\n");
g_free (color);
}
color = NULL;
}
else if ((intptr_t) scanner->value.v_symbol == 3)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Arrowsize (float)... "
"aborting\n");
exit (1);
}
arrowsize = scanner->value.v_float;
}
else if ((intptr_t) scanner->value.v_symbol == 4)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Minsize (float)... "
"aborting\n");
exit (1);
}
minwidth = scanner->value.v_float;
}
else
{
g_printerr ("Unknown tool type?????\n");
}
}
else
{
g_printerr ("skipped token!!!\n");
}
token = g_scanner_get_next_token (scanner);
}
g_scanner_set_scope (scanner, 0);
token = g_scanner_get_next_token (scanner);
}
/*
* Finally we expect a semicolon
*/
if (token != ';')
{
g_printerr ("Expected \";\"\n");
exit (1);
}
context = paint_context_new (data, type, fg_color, width, arrowsize, minwidth);
g_hash_table_insert (data->tool_config, name, context);
}
else
{
g_printerr ("Expected name of Tool to define\n");
exit(1);
}
token = g_scanner_get_next_token (scanner);
}
g_scanner_destroy (scanner);
close (file);
g_free (filename);
}
static void
theme_parser_start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error)
{
const gchar *prop_value;
Theme *theme = THEME (user_data);
ThemePrivate *priv = theme->priv;
if (!g_strcmp0 (element_name, "theme")) {
prop_value = get_attribute_value ("name", attribute_names, attribute_values);
priv->name = g_strdup (prop_value);
} else if (!g_strcmp0 (element_name, "icon")) {
gchar *src;
GdkPixbuf *pixbuf;
gint alpha = 255;
src = g_build_filename (theme->priv->path,
get_attribute_value ("src", attribute_names, attribute_values),
NULL);
prop_value = get_attribute_value ("alpha", attribute_names, attribute_values);
if (prop_value != NULL)
alpha = CLAMP (atoi (prop_value), 0, 255);
if (theme->priv->tile_width == 0) {
pixbuf = gdk_pixbuf_new_from_file (src, NULL);
if (pixbuf != NULL) {
theme->priv->tile_width = gdk_pixbuf_get_width (pixbuf);
theme->priv->tile_height = gdk_pixbuf_get_height (pixbuf);
g_object_unref (pixbuf);
}
}
theme_add_image (theme, src, alpha);
g_free (src);
} else if (!g_strcmp0 (element_name, "animstep")) {
priv->animstep = atoi (get_attribute_value ("dist", attribute_names,
attribute_values));
} else if (!g_strcmp0 (element_name, "bgcolor")) {
/* handle background color */
prop_value = get_attribute_value ("color", attribute_names, attribute_values);
gdk_rgba_parse (&(priv->bg_color), prop_value);
} else if (!g_strcmp0 (element_name, "bgcolor_rgb")) {
/* handle rgb color node */
prop_value = get_attribute_value ("red", attribute_names, attribute_values);
priv->bg_color.red = (atof (prop_value) / 255.0) * 65536;
prop_value = get_attribute_value ("blue", attribute_names, attribute_values);
priv->bg_color.blue = (atof (prop_value) / 255.0) * 65536;
prop_value = get_attribute_value ("green", attribute_names, attribute_values);
priv->bg_color.green = (atof (prop_value) / 255.0) * 65536;
} else if (!g_strcmp0 (element_name, "decor")) {
gchar *src;
const gchar *base;
GQuark base_id;
GQuark decor_id;
gint alpha = 255;
src = g_build_filename (theme->priv->path,
get_attribute_value ("src", attribute_names, attribute_values),
NULL);
prop_value = get_attribute_value ("alpha", attribute_names, attribute_values);
if (prop_value != NULL) {
alpha = CLAMP (atoi (prop_value), 0, 255);
}
decor_id = theme_add_image (theme, src, alpha);
g_free (src);
base = get_attribute_value ("base", attribute_names, attribute_values);
if (base == NULL)
return;
base_id = g_quark_from_string (base);
theme_add_image_decoration (theme, base_id, decor_id);
}
}
/**
* Creates the windows and other objects required to do calibration
* under GTK. When the window is closed (timed out, calibration finished
* or user cancellation), callback will be called, where you should call
* calib_area_finish().
*/
CalibArea *
calib_area_new (GdkScreen *screen,
int monitor,
int device_id,
FinishCallback callback,
gpointer user_data,
XYinfo *old_axis,
int threshold_doubleclick,
int threshold_misclick)
{
CalibArea *calib_area;
GdkRectangle rect;
GdkWindow *window;
GdkRGBA black;
#ifndef FAKE_AREA
GdkCursor *cursor;
#endif /* FAKE_AREA */
g_return_val_if_fail (old_axis, NULL);
g_return_val_if_fail (callback, NULL);
g_debug ("Current calibration: %d, %d, %d, %d\n",
old_axis->x_min,
old_axis->y_min,
old_axis->x_max,
old_axis->y_max);
calib_area = g_new0 (CalibArea, 1);
calib_area->callback = callback;
calib_area->user_data = user_data;
calib_area->device_id = device_id;
calib_area->calibrator.old_axis.x_min = old_axis->x_min;
calib_area->calibrator.old_axis.x_max = old_axis->x_max;
calib_area->calibrator.old_axis.y_min = old_axis->y_min;
calib_area->calibrator.old_axis.y_max = old_axis->y_max;
calib_area->calibrator.threshold_doubleclick = threshold_doubleclick;
calib_area->calibrator.threshold_misclick = threshold_misclick;
/* Set up the window */
calib_area->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable (GTK_WIDGET (calib_area->window), TRUE);
/* Black background */
gdk_rgba_parse (&black, "rgb(0,0,0)");
gtk_widget_set_opacity (GTK_WIDGET (calib_area->window), WINDOW_OPACITY);
gtk_widget_realize (calib_area->window);
window = gtk_widget_get_window (calib_area->window);
gdk_window_set_background_rgba (window, &black);
#ifndef FAKE_AREA
/* No cursor (unless we're faking the area
which might be convenient) */
cursor = gdk_cursor_new (GDK_BLANK_CURSOR);
gdk_window_set_cursor (window, cursor);
g_object_unref (cursor);
#endif /* FAKE_AREA */
/* Listen for mouse events */
gtk_widget_add_events (calib_area->window, GDK_KEY_RELEASE_MASK | GDK_BUTTON_PRESS_MASK);
gtk_widget_set_can_focus (calib_area->window, TRUE);
gtk_window_fullscreen (GTK_WINDOW (calib_area->window));
gtk_window_set_keep_above (GTK_WINDOW (calib_area->window), TRUE);
/* Connect callbacks */
g_signal_connect (calib_area->window, "draw",
G_CALLBACK(draw), calib_area);
g_signal_connect (calib_area->window, "button-press-event",
G_CALLBACK(on_button_press_event), calib_area);
g_signal_connect (calib_area->window, "key-release-event",
G_CALLBACK(on_key_release_event), calib_area);
g_signal_connect (calib_area->window, "delete-event",
G_CALLBACK(on_delete_event), calib_area);
g_signal_connect (calib_area->window, "focus-out-event",
G_CALLBACK(on_focus_out_event), calib_area);
/* Setup timer for animation */
calib_area->anim_id = g_timeout_add(TIME_STEP, (GSourceFunc)on_timer_signal, calib_area);
/* Move to correct screen */
if (screen == NULL)
screen = gdk_screen_get_default ();
gdk_screen_get_monitor_geometry (screen, monitor, &rect);
gtk_window_move (GTK_WINDOW (calib_area->window), rect.x, rect.y);
gtk_window_set_default_size (GTK_WINDOW (calib_area->window), rect.width, rect.height);
calib_area->calibrator.geometry.x = rect.x;
calib_area->calibrator.geometry.y = rect.y;
calib_area->calibrator.geometry.width = rect.width;
calib_area->calibrator.geometry.height = rect.height;
gtk_widget_show_all (calib_area->window);
return calib_area;
}
static void
gtk_source_map_rebuild_css (GtkSourceMap *map)
{
GtkSourceMapPrivate *priv;
GtkSourceStyleScheme *style_scheme;
GtkSourceStyle *style = NULL;
GtkTextBuffer *buffer;
GString *gstr;
gboolean alter_alpha = TRUE;
gchar *background = NULL;
priv = gtk_source_map_get_instance_private (map);
if (priv->view == NULL)
{
return;
}
/*
* This is where we calculate the CSS that maps the font for the
* minimap as well as the styling for the scrubber.
*
* The font is calculated from #GtkSourceMap:font-desc. We convert this
* to CSS using _gtk_source_pango_font_description_to_css(). It gets
* applied to the minimap widget via the CSS style provider which we
* attach to the child widget in gtk_source_map_init().
*
* The rules for calculating the style for the scrubber are as follows.
*
* If the current style scheme provides a background color for the
* scrubber using the "map-overlay" style name, we use that without
* any transformations.
*
* If the style scheme contains a "selection" style scheme, used for
* selected text, we use that with a 0.75 alpha value.
*
* If none of these are met, we take the background from the
* #GtkStyleContext using the deprecated
* gtk_style_context_get_background_color(). This is non-ideal, but
* currently required since we cannot indicate that we want to
* alter the alpha for gtk_render_background().
*/
gstr = g_string_new (NULL);
/* Calculate the font if one has been set */
if (priv->font_desc != NULL)
{
gchar *css;
css = _gtk_source_pango_font_description_to_css (priv->font_desc);
g_string_append_printf (gstr, "GtkSourceView { %s }\n", css != NULL ? css : "");
g_free (css);
}
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->view));
style_scheme = gtk_source_buffer_get_style_scheme (GTK_SOURCE_BUFFER (buffer));
if (style_scheme != NULL)
{
style = gtk_source_style_scheme_get_style (style_scheme, "map-overlay");
if (style != NULL)
{
/* styling is taking as is only if we found a "map-overlay". */
alter_alpha = FALSE;
}
else
{
style = gtk_source_style_scheme_get_style (style_scheme, "selection");
}
}
if (style != NULL)
{
g_object_get (style,
"background", &background,
NULL);
}
if (background == NULL)
{
GtkStyleContext *context;
GdkRGBA color;
/*
* We failed to locate a style for both "map-overlay" and for
* "selection". That means we need to fallback to using the
* selected color for the gtk+ theme. This uses deprecated
* API because we have no way to tell gtk_render_background()
* to render with an alpha.
*/
context = gtk_widget_get_style_context (GTK_WIDGET (priv->view));
gtk_style_context_save (context);
gtk_style_context_add_class (context, "view");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_style_context_get_background_color (context, GTK_STATE_FLAG_SELECTED, &color);
G_GNUC_END_IGNORE_DEPRECATIONS;
gtk_style_context_restore (context);
background = gdk_rgba_to_string (&color);
/*
* Make sure we alter the alpha. It is possible this could be
* FALSE here if we found a style for map-overlay but it did
* not contain a background color.
*/
alter_alpha = TRUE;
}
if (alter_alpha)
{
GdkRGBA color;
gdk_rgba_parse (&color, background);
color.alpha = 0.75;
g_free (background);
background = gdk_rgba_to_string (&color);
}
if (background != NULL)
{
g_string_append_printf (gstr,
"GtkSourceMap.scrubber {\n"
"\tbackground-color: %s;\n"
"\tborder-top: 1px solid shade(%s,0.9);\n"
"\tborder-bottom: 1px solid shade(%s,0.9);\n"
"}\n",
background,
background,
background);
}
g_free (background);
if (gstr->len > 0)
{
gtk_css_provider_load_from_data (priv->css_provider, gstr->str, gstr->len, NULL);
}
g_string_free (gstr, TRUE);
}
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);
}
gboolean
setup_term(GtkWidget *win, GtkWidget *term, struct term_options *to)
{
static char *args_default[] = { NULL, NULL, NULL };
char **args_use;
size_t i;
GdkRGBA c_foreground_gdk;
GdkRGBA c_background_gdk;
GdkRGBA c_palette_gdk[16];
GdkRGBA c_gdk;
VteRegex *url_vregex = NULL;
GError *err = NULL;
GSpawnFlags spawn_flags;
if (to->argv != NULL)
{
args_use = to->argv;
spawn_flags = G_SPAWN_SEARCH_PATH;
}
else
{
if (args_default[0] == NULL)
{
args_default[0] = vte_get_user_shell();
if (args_default[0] == NULL)
args_default[0] = "/bin/sh";
if (login_shell)
args_default[1] = g_strdup_printf("-%s", args_default[0]);
else
args_default[1] = args_default[0];
}
args_use = args_default;
spawn_flags = G_SPAWN_SEARCH_PATH | G_SPAWN_FILE_AND_ARGV_ZERO;
}
/* Appearance. */
term_set_font(NULL, VTE_TERMINAL(term), 0);
gtk_widget_show_all(win);
vte_terminal_set_allow_bold(VTE_TERMINAL(term), enable_bold);
vte_terminal_set_cursor_blink_mode(VTE_TERMINAL(term), VTE_CURSOR_BLINK_OFF);
vte_terminal_set_geometry_hints_for_window(VTE_TERMINAL(term),
GTK_WINDOW(win));
vte_terminal_set_mouse_autohide(VTE_TERMINAL(term), TRUE);
vte_terminal_set_scrollback_lines(VTE_TERMINAL(term), scrollback_lines);
gdk_rgba_parse(&c_foreground_gdk, c_foreground);
gdk_rgba_parse(&c_background_gdk, c_background);
for (i = 0; i < 16; i++)
gdk_rgba_parse(&c_palette_gdk[i], c_palette[i]);
vte_terminal_set_colors(VTE_TERMINAL(term), &c_foreground_gdk,
&c_background_gdk, c_palette_gdk, 16);
if (c_bold != NULL)
{
gdk_rgba_parse(&c_gdk, c_bold);
vte_terminal_set_color_bold(VTE_TERMINAL(term), &c_gdk);
}
if (c_cursor != NULL)
{
gdk_rgba_parse(&c_gdk, c_cursor);
vte_terminal_set_color_cursor(VTE_TERMINAL(term), &c_gdk);
}
if (c_cursor_foreground != NULL)
{
gdk_rgba_parse(&c_gdk, c_cursor_foreground);
vte_terminal_set_color_cursor_foreground(VTE_TERMINAL(term), &c_gdk);
}
url_vregex = vte_regex_new_for_match(url_regex, strlen(url_regex),
PCRE2_MULTILINE | PCRE2_CASELESS, &err);
if (url_vregex == NULL)
fprintf(stderr, "url_regex: %s\n",
err == NULL ? "<err is NULL>" : err->message);
else
{
vte_terminal_match_add_regex(VTE_TERMINAL(term), url_vregex, 0);
vte_regex_unref(url_vregex);
}
/* Signals. */
g_signal_connect(G_OBJECT(term), "bell",
G_CALLBACK(sig_bell), win);
g_signal_connect(G_OBJECT(term), "button-press-event",
G_CALLBACK(sig_button_press), NULL);
if (!to->hold)
g_signal_connect(G_OBJECT(term), "child-exited",
G_CALLBACK(sig_child_exited), win);
g_signal_connect(G_OBJECT(term), "decrease-font-size",
G_CALLBACK(sig_decrease_font_size), win);
g_signal_connect(G_OBJECT(term), "increase-font-size",
G_CALLBACK(sig_increase_font_size), win);
g_signal_connect(G_OBJECT(term), "key-press-event",
G_CALLBACK(sig_key_press), win);
g_signal_connect(G_OBJECT(term), "resize-window",
G_CALLBACK(sig_window_resize), win);
g_signal_connect(G_OBJECT(term), "window-title-changed",
G_CALLBACK(sig_window_title_changed), win);
/* Spawn child. */
return vte_terminal_spawn_sync(VTE_TERMINAL(term), VTE_PTY_DEFAULT, to->cwd,
args_use, NULL, spawn_flags,
NULL, NULL, NULL, NULL, NULL);
}
static void
create_table_window (void)
{
GtkWidget *window;
GtkWidget *table;
GtkWidget *toggle;
GtkWidget *alignment;
GtkWidget *colorbox;
GdkRGBA red, blue;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Table");
table = gtk_table_new (4, 3, FALSE);
gtk_table_attach (GTK_TABLE (table),
gtk_label_new ("Top"),
1, 2, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table),
gtk_label_new ("Bottom"),
1, 2, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table),
gtk_label_new ("Left"),
0, 1, 1, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table),
gtk_label_new ("Right"),
2, 3, 1, 3,
GTK_FILL, GTK_FILL, 0, 0);
gdk_rgba_parse (&red, "red");
gdk_rgba_parse (&blue, "blue");
colorbox = gtk_event_box_new ();
gtk_widget_override_background_color (colorbox, GTK_STATE_NORMAL, &red);
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 5, 5);
gtk_container_add (GTK_CONTAINER (colorbox), alignment);
toggle = gtk_toggle_button_new_with_label ("H Expand");
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_hexpand), NULL);
gtk_container_add (GTK_CONTAINER (alignment), toggle);
gtk_table_attach (GTK_TABLE (table),
colorbox,
1, 2, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
colorbox = gtk_event_box_new ();
gtk_widget_override_background_color (colorbox, 0, &blue);
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 5, 5);
gtk_container_add (GTK_CONTAINER (colorbox), alignment);
toggle = gtk_toggle_button_new_with_label ("V Expand");
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_vexpand), NULL);
gtk_container_add (GTK_CONTAINER (alignment), toggle);
gtk_table_attach (GTK_TABLE (table),
colorbox,
1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_container_add (GTK_CONTAINER (window), table);
gtk_widget_show_all (window);
}
static void main_window_init(MainWindow *wnd)
{
GdkRGBA vid_area_bg_color;
wnd->fullscreen = FALSE;
wnd->playlist_visible = FALSE;
wnd->playlist_width = PLAYLIST_DEFAULT_WIDTH;
wnd->timeout_tag = 0;
wnd->settings = gtk_settings_get_default();
wnd->header_bar = gtk_header_bar_new();
wnd->open_hdr_btn = NULL;
wnd->fullscreen_hdr_btn = NULL;
wnd->menu_hdr_btn = NULL;
wnd->main_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
wnd->vid_area_paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
wnd->vid_area = gtk_drawing_area_new();
wnd->fs_control = gtk_window_new(GTK_WINDOW_POPUP);
wnd->control_box = control_box_new();
wnd->playlist = playlist_widget_new();
gdk_rgba_parse(&vid_area_bg_color, VID_AREA_BG_COLOR);
gtk_widget_add_events( wnd->fs_control,
GDK_ENTER_NOTIFY_MASK
|GDK_LEAVE_NOTIFY_MASK );
gtk_widget_add_events(wnd->vid_area, GDK_BUTTON_PRESS_MASK);
gtk_header_bar_set_show_close_button( GTK_HEADER_BAR(wnd->header_bar),
TRUE );
gtk_window_set_title(GTK_WINDOW(wnd), g_get_application_name());
gtk_paned_set_position( GTK_PANED(wnd->vid_area_paned),
MAIN_WINDOW_DEFAULT_WIDTH
-PLAYLIST_DEFAULT_WIDTH );
gtk_window_set_default_size( GTK_WINDOW(wnd),
MAIN_WINDOW_DEFAULT_WIDTH,
MAIN_WINDOW_DEFAULT_HEIGHT );
gtk_widget_override_background_color( wnd->vid_area,
GTK_STATE_NORMAL,
&vid_area_bg_color);
gtk_box_pack_start
(GTK_BOX(wnd->main_box), wnd->vid_area_paned, TRUE, TRUE, 0);
gtk_paned_pack1
(GTK_PANED(wnd->vid_area_paned), wnd->vid_area, TRUE, TRUE);
gtk_paned_pack2
(GTK_PANED(wnd->vid_area_paned), wnd->playlist, FALSE, TRUE);
gtk_container_add
(GTK_CONTAINER(wnd->main_box), wnd->control_box);
gtk_container_add
(GTK_CONTAINER(wnd), wnd->main_box);
g_signal_connect( wnd,
"focus-in-event",
G_CALLBACK(focus_in_handler),
wnd );
g_signal_connect( wnd,
"focus-out-event",
G_CALLBACK(focus_out_handler),
wnd );
g_signal_connect( wnd->fs_control,
"enter-notify-event",
G_CALLBACK(fs_control_enter_handler),
wnd->fs_control );
g_signal_connect( wnd->fs_control,
"leave-notify-event",
G_CALLBACK(fs_control_leave_handler),
wnd->fs_control );
g_signal_connect( wnd,
"motion-notify-event",
G_CALLBACK(motion_notify_handler),
wnd );
}
static void
create_box_window (void)
{
GtkWidget *window;
GtkWidget *box1, *box2, *box3;
GtkWidget *toggle;
GtkWidget *alignment;
GtkWidget *colorbox;
GdkRGBA red, blue;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Boxes");
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (box1),
gtk_label_new ("VBox 1 Top"),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box1),
box2,
FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (box1),
gtk_label_new ("VBox 1 Bottom"),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box2),
gtk_label_new ("HBox 2 Left"),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box2),
box3,
FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (box2),
gtk_label_new ("HBox 2 Right"),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box3),
gtk_label_new ("VBox 3 Top"),
FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (box3),
gtk_label_new ("VBox 3 Bottom"),
FALSE, FALSE, 0);
gdk_rgba_parse (&red, "red");
gdk_rgba_parse (&blue, "blue");
colorbox = gtk_event_box_new ();
gtk_widget_override_background_color (colorbox, 0, &red);
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 5, 5);
gtk_container_add (GTK_CONTAINER (colorbox), alignment);
toggle = gtk_toggle_button_new_with_label ("H Expand");
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_hexpand), NULL);
gtk_container_add (GTK_CONTAINER (alignment), toggle);
gtk_box_pack_start (GTK_BOX (box3),
colorbox,
FALSE, TRUE, 0);
colorbox = gtk_event_box_new ();
gtk_widget_override_background_color (colorbox, 0, &blue);
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 5, 5);
gtk_container_add (GTK_CONTAINER (colorbox), alignment);
toggle = gtk_toggle_button_new_with_label ("V Expand");
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_vexpand), NULL);
gtk_container_add (GTK_CONTAINER (alignment), toggle);
gtk_box_pack_start (GTK_BOX (box3),
colorbox,
FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show_all (window);
}
int
main (int argc, char *argv[])
{
GtkWidget *win, *overlay, *grid, *main_child, *child, *label, *sw;
GdkRGBA color;
gchar *str;
gtk_init (&argc, &argv);
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (win), 600, 600);
grid = gtk_grid_new ();
child = gtk_event_box_new ();
gdk_rgba_parse (&color, "red");
gtk_widget_override_background_color (child, 0, &color);
gtk_widget_set_hexpand (child, TRUE);
gtk_widget_set_vexpand (child, TRUE);
gtk_container_add (GTK_CONTAINER (grid), child);
label = gtk_label_new ("Out of overlay");
gtk_container_add (GTK_CONTAINER (child), label);
overlay = gtk_overlay_new ();
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_ALWAYS,
GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (overlay), sw);
main_child = gtk_event_box_new ();
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw),
main_child);
gdk_rgba_parse (&color, "green");
gtk_widget_override_background_color (main_child, 0, &color);
gtk_widget_set_hexpand (main_child, TRUE);
gtk_widget_set_vexpand (main_child, TRUE);
label = gtk_label_new ("Main child");
gtk_container_add (GTK_CONTAINER (main_child), label);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
g_print ("Bottom/Right child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_END);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
g_print ("Left/Top child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
g_print ("Right/Center child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_CENTER);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
gtk_widget_set_margin_left (child, 55);
gtk_widget_set_margin_top (child, 4);
g_print ("Left/Top margined child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
child = gtk_label_new (NULL);
str = g_strdup_printf ("%p", child);
gtk_label_set_text (GTK_LABEL (child), str);
g_free (str);
g_print ("Custom get-child-position child: %p\n", child);
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_signal_connect (child, "size-allocate",
G_CALLBACK (child_size_allocate), overlay);
g_signal_connect (overlay, "get-child-position",
G_CALLBACK (overlay_get_child_position), child);
gtk_grid_attach (GTK_GRID (grid), overlay, 1, 0, 1, 3);
gtk_container_add (GTK_CONTAINER (win), grid);
g_print ("\n");
gtk_widget_show_all (win);
gtk_main ();
return 0;
}
static void
value_icon_activate (GtkCellRendererToggle *cell_renderer,
gchar *path,
GladeEPropAttrs *eprop_attrs)
{
GtkWidget *dialog;
GtkTreeIter iter;
PangoAttrType type;
AttrEditType edit_type;
GdkRGBA color = {0,};
gchar *text = NULL, *new_text;
/* Find type etc */
if (!gtk_tree_model_get_iter_from_string (eprop_attrs->model, &iter, path))
return;
gtk_tree_model_get (eprop_attrs->model, &iter,
COLUMN_TEXT, &text,
COLUMN_TYPE, &type,
COLUMN_EDIT_TYPE, &edit_type, -1);
/* Launch dialog etc. */
switch (edit_type)
{
case EDIT_COLOR:
dialog = gtk_color_chooser_dialog_new (_("Select a color"),
GTK_WINDOW (glade_app_get_window ()));
/* Get response etc... */
if (text && gdk_rgba_parse (&color, text))
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (dialog), &color);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (dialog), &color);
/* Use GdkColor string format */
if (((guint8)(color.red * 0xFF)) * 0x101 == (guint16)(color.red * 0xFFFF) &&
((guint8)(color.green * 0xFF)) * 0x101 == (guint16)(color.green * 0xFFFF) &&
((guint8)(color.blue * 0xFF)) * 0x101 == (guint16)(color.blue * 0xFFFF))
new_text = g_strdup_printf ("#%02X%02X%02X",
(guint8)(color.red * 0xFF),
(guint8)(color.green * 0xFF),
(guint8)(color.blue * 0xFF));
else
new_text = g_strdup_printf ("#%04X%04X%04X",
(guint16)(color.red * 0xFFFF),
(guint16)(color.green * 0xFFFF),
(guint16)(color.blue * 0xFFFF));
gtk_list_store_set (GTK_LIST_STORE (eprop_attrs->model), &iter,
COLUMN_TEXT, new_text,
COLUMN_NAME_WEIGHT, PANGO_WEIGHT_BOLD,
COLUMN_TEXT_STYLE, PANGO_STYLE_NORMAL,
COLUMN_TEXT_FG, "Black", -1);
g_free (new_text);
gtk_widget_destroy (dialog);
break;
case EDIT_FONT:
dialog = gtk_font_chooser_dialog_new (_("Select a font"),
GTK_WINDOW (glade_app_get_window ()));
/* Get response etc... */
if (text)
gtk_font_chooser_set_font (GTK_FONT_CHOOSER (dialog), text);
gtk_dialog_run (GTK_DIALOG (dialog));
new_text = gtk_font_chooser_get_font (GTK_FONT_CHOOSER (dialog));
gtk_list_store_set (GTK_LIST_STORE (eprop_attrs->model), &iter,
COLUMN_TEXT, new_text,
COLUMN_NAME_WEIGHT, PANGO_WEIGHT_BOLD,
COLUMN_TEXT_STYLE, PANGO_STYLE_NORMAL,
COLUMN_TEXT_FG, "Black", -1);
g_free (new_text);
gtk_widget_destroy (dialog);
break;
default:
break;
}
sync_object (eprop_attrs, FALSE);
g_free (text);
}
void main_gui(int argc, char **argv)
{
/* inits */
gdk_threads_init();
gdk_threads_enter();
gtk_init (&argc, &argv);
pthread_mutex_init(&mutex_guichange, NULL);
/* window */
gres.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(gres.window), 0);
gtk_window_set_urgency_hint (GTK_WINDOW(gres.window), TRUE);
gtk_window_set_title (GTK_WINDOW (gres.window), _PROJECTNAME);
gtk_window_set_default_size(GTK_WINDOW(gres.window), 800, 600);
gtk_window_set_position(GTK_WINDOW(gres.window), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(gres.window), TRUE);
/* setting window icon */
gtk_window_set_icon(GTK_WINDOW(gres.window), create_pixbuf(GUI_ICON));
gtk_widget_show(gres.window);
g_signal_connect(G_OBJECT(gres.window), "delete_event", G_CALLBACK(on_destroy), NULL);
g_signal_connect(G_OBJECT(gres.window), "destroy", G_CALLBACK(on_destroy), NULL);
/* vbox principale */
gres.vbox_main = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
gtk_container_add(GTK_CONTAINER(gres.window), gres.vbox_main);
gtk_container_set_border_width(GTK_CONTAINER(gres.vbox_main),0);
/* accellgroup */
gres.accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(gres.window), gres.accel_group);
/* menubar */
gres.menubar = gtk_menu_bar_new();
gres.filemenu = gtk_menu_new();
gres.helpmenu = gtk_menu_new();
gres.file = gtk_menu_item_new_with_label("File");
//gres.connect = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
gres.open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
gres.font = gtk_image_menu_item_new_from_stock(GTK_STOCK_SELECT_FONT, NULL);
gres.sep = gtk_separator_menu_item_new();
gres.quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, gres.accel_group);
gres.help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, NULL);
gres.about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gres.file), gres.filemenu);
//gtk_menu_shell_append(GTK_MENU_SHELL(gres.filemenu), gres.connect);
gtk_menu_shell_append(GTK_MENU_SHELL(gres.filemenu), gres.font);
gtk_menu_shell_append(GTK_MENU_SHELL(gres.filemenu), gres.sep);
gtk_menu_shell_append(GTK_MENU_SHELL(gres.filemenu), gres.quit);
gtk_menu_shell_append(GTK_MENU_SHELL(gres.menubar), gres.file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gres.help), gres.helpmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(gres.helpmenu), gres.about);
gtk_menu_shell_append(GTK_MENU_SHELL(gres.menubar), gres.help);
gtk_box_pack_start(GTK_BOX(gres.vbox_main), gres.menubar, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(gres.quit), "activate", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(gres.font), "activate", G_CALLBACK(select_font), G_OBJECT(gres.window));
g_signal_connect(G_OBJECT(gres.about), "activate", G_CALLBACK(show_about), NULL);
/* toolbar */
gres.toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(gres.toolbar), GTK_TOOLBAR_BOTH);
gtk_container_set_border_width(GTK_CONTAINER(gres.toolbar), 2);
gres.toolbar_connect = gtk_tool_button_new_from_stock(GTK_STOCK_NETWORK);
if (!c_core->GetSession()->IsConnected())
gtk_tool_button_set_label(GTK_TOOL_BUTTON(gres.toolbar_connect), "Connect");
else
gtk_tool_button_set_label(GTK_TOOL_BUTTON(gres.toolbar_connect), "Disconnect");
gtk_toolbar_insert(GTK_TOOLBAR(gres.toolbar), gres.toolbar_connect, -1);
g_signal_connect(G_OBJECT(gres.toolbar_connect), "clicked", G_CALLBACK(toolbar_connect_click), NULL);
//gres.toolbar_refresh = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH);
//gtk_toolbar_insert(GTK_TOOLBAR(gres.toolbar), gres.toolbar_refresh, -1);
//g_signal_connect(G_OBJECT(gres.toolbar_refresh), "clicked", G_CALLBACK(set_nick), G_OBJECT(gres.window));
gres.toolbar_reset = gtk_tool_button_new_from_stock(GTK_STOCK_CLEAR);
gtk_toolbar_insert(GTK_TOOLBAR(gres.toolbar), gres.toolbar_reset, -1);
g_signal_connect(G_OBJECT(gres.toolbar_reset), "clicked", G_CALLBACK(toolbar_reset_click), NULL);
gres.toolbar_separator = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(gres.toolbar), gres.toolbar_separator, -1);
gres.toolbar_exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
gtk_toolbar_insert(GTK_TOOLBAR(gres.toolbar), gres.toolbar_exit, -1);
g_signal_connect(G_OBJECT(gres.toolbar_exit), "clicked", G_CALLBACK(gtk_main_quit), NULL);
gtk_box_pack_start(GTK_BOX(gres.vbox_main), gres.toolbar, FALSE, FALSE, 0);
/* Paned */
gres.paned_main = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(gres.vbox_main), gres.paned_main, TRUE, TRUE, 0);
gres.scrolledwindow_chat = gtk_scrolled_window_new (NULL, NULL);
gtk_paned_pack1 (GTK_PANED(gres.paned_main), gres.scrolledwindow_chat, true, true);
gtk_container_set_border_width (GTK_CONTAINER (gres.scrolledwindow_chat), 2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (gres.scrolledwindow_chat),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gres.view_chat = gtk_text_view_new();
GdkRGBA color;
gdk_rgba_parse (&color, CFG_GET_STRING("chat_bg").c_str());
gtk_widget_override_background_color(GTK_WIDGET(gres.view_chat),
GTK_STATE_FLAG_NORMAL, &color);
PangoFontDescription *font_desc = pango_font_description_from_string(CFG_GET_STRING("chat_font").c_str());
if (font_desc)
gtk_widget_modify_font(gres.view_chat, font_desc);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(gres.view_chat), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (gres.view_chat), FALSE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (gres.view_chat), 1);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (gres.view_chat), 1);
gtk_text_view_set_editable(GTK_TEXT_VIEW(gres.view_chat), FALSE);
gtk_container_add (GTK_CONTAINER (gres.scrolledwindow_chat), gres.view_chat);
gres.tbuf_chat = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gres.view_chat));
gtk_text_buffer_create_tag(gres.tbuf_chat, "chat_bg", "background", CFG_GET_STRING("chat_bg").c_str() , NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "chat_sys_msg_fg", "foreground", CFG_GET_STRING("chat_sys_msg_fg").c_str() , NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "chat_msg_fg", "foreground", CFG_GET_STRING("chat_msg_fg").c_str() , NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "chat_join_fg", "foreground", CFG_GET_STRING("chat_join_fg").c_str() , NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "chat_leave_fg", "foreground", CFG_GET_STRING("chat_leave_fg").c_str() , NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "chat_whisp_fg", "foreground", CFG_GET_STRING("chat_whisp_fg").c_str() , NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "gap", "pixels_above_lines", 30, NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "lmarg", "left_margin", 5, NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "black_fg", "foreground", "#000000", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "white_fg", "foreground", "#ffffff", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "blue_fg", "foreground", "#3200ff", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "magenta_fg", "foreground", "#ff32ff", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "green_fg", "foreground", "#55ff00", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "red_fg", "foreground", "#ff3200", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "green_bg", "background", "#55ff00", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "blue_bg", "background", "#3200ff", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "red_bg", "background", "#ff3200", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "yellow_bg", "background", "#f7f732", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "magenta_bg", "background", "#ff32ff", NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "italic", "style", PANGO_STYLE_ITALIC, NULL);
gtk_text_buffer_create_tag(gres.tbuf_chat, "bold", "weight", PANGO_WEIGHT_BOLD, NULL);
gres.scrolledwindow_user_list = gtk_scrolled_window_new (NULL, NULL);
gtk_paned_pack2 (GTK_PANED(gres.paned_main), gres.scrolledwindow_user_list, false, false);
gtk_container_set_border_width (GTK_CONTAINER (gres.scrolledwindow_user_list), 2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (gres.scrolledwindow_user_list),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (gres.scrolledwindow_user_list);
gres.model_user_list = gtk_list_store_new(COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
gres.view_user_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(gres.model_user_list));
gres.selection_user_list = gtk_tree_view_get_selection(GTK_TREE_VIEW(gres.view_user_list));
gtk_tree_selection_set_mode(gres.selection_user_list, GTK_SELECTION_SINGLE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(gres.view_user_list), TRUE);
gres.renderer_user_list = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(gres.view_user_list), /* vista */
-1, /* posizione della colonna */
"Name", /* titolo della colonna */
gres.renderer_user_list, /* cella inserita nella colonna */
"text", /* attributo colonna */
COLUMN_STRING1, /* colonna inserita */
NULL); /* fine ;-) */
gres.renderer_user_list = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(gres.view_user_list),
-1,
"Type",
gres.renderer_user_list,
"text",
COLUMN_STRING2,
NULL);
gtk_widget_show (gres.view_user_list);
g_object_unref(gres.model_user_list);
gtk_container_add (GTK_CONTAINER (gres.scrolledwindow_user_list), gres.view_user_list);
gtk_container_set_border_width (GTK_CONTAINER (gres.view_user_list), 0);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (gres.view_user_list), TRUE);
/* INPUTS */
gres.hbox_inputs = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX (gres.vbox_main), gres.hbox_inputs, FALSE, FALSE, 0);
gres.label_nick = gtk_label_new((gchar *) CFG_GET_STRING("username").c_str());
gtk_misc_set_alignment(GTK_MISC(gres.label_nick), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX (gres.hbox_inputs), gres.label_nick, FALSE, FALSE, 2 );
gres.entry_command = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (gres.hbox_inputs), gres.entry_command, TRUE, TRUE, 5);
gres.button_send = gtk_button_new_with_label("Send");
gtk_widget_set_size_request (GTK_WIDGET (gres.button_send), 70, 30);
gtk_box_pack_start(GTK_BOX (gres.hbox_inputs), gres.button_send, FALSE, FALSE, 0);
gres.text_entry = gres.entry_command;
g_signal_connect(G_OBJECT(gres.entry_command), "activate", G_CALLBACK(button_send_click), NULL);
g_signal_connect(G_OBJECT(gres.button_send), "clicked", G_CALLBACK(button_send_click), NULL);
/* status_bar */
gres.status_bar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX (gres.vbox_main), gres.status_bar, FALSE, FALSE, 0);
/* end_widgets */
gtk_widget_show_all(gres.window);
/* default focus on command entry */
gtk_widget_grab_focus (GTK_WIDGET(gres.text_entry));
INFO ("debug", "GUI: starting GUI thread\n");
pthread_t tid;
StartThread(GuiThread, (void*)&gres, tid);
INFO ("debug", "GUI: starting GTK+3\n");
gtk_main();
gdk_threads_leave();
pthread_mutex_destroy(&mutex_guichange);
return;
}
bool
zathura_init(zathura_t* zathura)
{
if (zathura == NULL) {
return false;
}
/* create zathura (config/data) directory */
if (g_mkdir_with_parents(zathura->config.config_dir, 0771) == -1) {
girara_error("Could not create '%s': %s", zathura->config.config_dir, strerror(errno));
}
if (g_mkdir_with_parents(zathura->config.data_dir, 0771) == -1) {
girara_error("Could not create '%s': %s", zathura->config.data_dir, strerror(errno));
}
/* load plugins */
zathura_plugin_manager_load(zathura->plugins.manager);
/* configuration */
config_load_default(zathura);
config_load_files(zathura);
/* UI */
if (girara_session_init(zathura->ui.session, "zathura") == false) {
goto error_free;
}
/* girara events */
zathura->ui.session->events.buffer_changed = cb_buffer_changed;
zathura->ui.session->events.unknown_command = cb_unknown_command;
/* zathura signals */
zathura->signals.refresh_view = g_signal_new("refresh-view",
GTK_TYPE_WIDGET,
G_SIGNAL_RUN_LAST,
0,
NULL,
NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE,
1,
G_TYPE_POINTER);
g_signal_connect(G_OBJECT(zathura->ui.session->gtk.view), "refresh-view",
G_CALLBACK(cb_refresh_view), zathura);
/* page view */
zathura->ui.page_widget = gtk_grid_new();
gtk_grid_set_row_homogeneous(GTK_GRID(zathura->ui.page_widget), TRUE);
gtk_grid_set_column_homogeneous(GTK_GRID(zathura->ui.page_widget), TRUE);
if (zathura->ui.page_widget == NULL) {
goto error_free;
}
g_signal_connect(G_OBJECT(zathura->ui.session->gtk.window), "size-allocate", G_CALLBACK(cb_view_resized), zathura);
GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment(
GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view));
/* Connect hadjustment signals */
g_signal_connect(G_OBJECT(hadjustment), "value-changed",
G_CALLBACK(cb_view_hadjustment_value_changed), zathura);
g_signal_connect(G_OBJECT(hadjustment), "changed",
G_CALLBACK(cb_view_hadjustment_changed), zathura);
GtkAdjustment* vadjustment = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view));
/* Connect vadjustment signals */
g_signal_connect(G_OBJECT(vadjustment), "value-changed",
G_CALLBACK(cb_view_vadjustment_value_changed), zathura);
g_signal_connect(G_OBJECT(vadjustment), "changed",
G_CALLBACK(cb_view_vadjustment_changed), zathura);
/* page view alignment */
gtk_widget_set_halign(zathura->ui.page_widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign(zathura->ui.page_widget, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand_set(zathura->ui.page_widget, TRUE);
gtk_widget_set_hexpand(zathura->ui.page_widget, FALSE);
gtk_widget_set_vexpand_set(zathura->ui.page_widget, TRUE);
gtk_widget_set_vexpand(zathura->ui.page_widget, FALSE);
gtk_widget_show(zathura->ui.page_widget);
/* statusbar */
zathura->ui.statusbar.file = girara_statusbar_item_add(zathura->ui.session, TRUE, TRUE, TRUE, NULL);
if (zathura->ui.statusbar.file == NULL) {
goto error_free;
}
zathura->ui.statusbar.buffer = girara_statusbar_item_add(zathura->ui.session, FALSE, FALSE, FALSE, NULL);
if (zathura->ui.statusbar.buffer == NULL) {
goto error_free;
}
zathura->ui.statusbar.page_number = girara_statusbar_item_add(zathura->ui.session, FALSE, FALSE, FALSE, NULL);
if (zathura->ui.statusbar.page_number == NULL) {
goto error_free;
}
girara_statusbar_item_set_text(zathura->ui.session, zathura->ui.statusbar.file, _("[No name]"));
/* signals */
g_signal_connect(G_OBJECT(zathura->ui.session->gtk.window), "destroy", G_CALLBACK(cb_destroy), zathura);
/* database */
char* database = NULL;
girara_setting_get(zathura->ui.session, "database", &database);
if (g_strcmp0(database, "plain") == 0) {
girara_debug("Using plain database backend.");
zathura->database = zathura_plaindatabase_new(zathura->config.data_dir);
#ifdef WITH_SQLITE
} else if (g_strcmp0(database, "sqlite") == 0) {
girara_debug("Using sqlite database backend.");
char* tmp = g_build_filename(zathura->config.data_dir, "bookmarks.sqlite", NULL);
zathura->database = zathura_sqldatabase_new(tmp);
g_free(tmp);
#endif
} else if (g_strcmp0(database, "null") != 0) {
girara_error("Database backend '%s' is not supported.", database);
}
if (zathura->database == NULL && g_strcmp0(database, "null") != 0) {
girara_error("Unable to initialize database. Bookmarks won't be available.");
} else {
g_object_set(G_OBJECT(zathura->ui.session->command_history), "io", zathura->database, NULL);
}
g_free(database);
/* bookmarks */
zathura->bookmarks.bookmarks = girara_sorted_list_new2((girara_compare_function_t) zathura_bookmarks_compare,
(girara_free_function_t) zathura_bookmark_free);
/* jumplist */
int jumplist_size = 20;
girara_setting_get(zathura->ui.session, "jumplist-size", &jumplist_size);
zathura->jumplist.max_size = jumplist_size < 0 ? 0 : jumplist_size;
zathura->jumplist.list = NULL;
zathura->jumplist.size = 0;
zathura->jumplist.cur = NULL;
/* CSS for index mode */
GiraraTemplate* csstemplate = girara_session_get_template(zathura->ui.session);
static const char* index_settings[] = {
"index-fg",
"index-bg",
"index-active-fg",
"index-active-bg"
};
for (size_t s = 0; s < LENGTH(index_settings); ++s) {
girara_template_add_variable(csstemplate, index_settings[s]);
char* tmp_value = NULL;
GdkRGBA rgba = { 0, 0, 0, 0 };
girara_setting_get(zathura->ui.session, index_settings[s], &tmp_value);
if (tmp_value != NULL) {
gdk_rgba_parse(&rgba, tmp_value);
g_free(tmp_value);
}
char* color = gdk_rgba_to_string(&rgba);
girara_template_set_variable_value(csstemplate,
index_settings[s], color);
g_free(color);
}
char* css = g_strdup_printf("%s\n%s", girara_template_get_base(csstemplate), CSS_TEMPLATE_INDEX);
girara_template_set_base(csstemplate, css);
g_free(css);
/* Start D-Bus service */
bool dbus = true;
girara_setting_get(zathura->ui.session, "dbus-service", &dbus);
if (dbus == true) {
zathura->dbus = zathura_dbus_new(zathura);
}
return true;
error_free:
if (zathura->ui.page_widget != NULL) {
g_object_unref(zathura->ui.page_widget);
}
return false;
}
static void
vte_config(VteTerminal* vte)
{
GRegex* regex = g_regex_new(url_regex, G_REGEX_CASELESS, G_REGEX_MATCH_NOTEMPTY, NULL);
vte_terminal_search_set_gregex(vte, regex, G_REGEX_MATCH_NOTEMPTY);
vte_terminal_search_set_wrap_around (vte, TINYTERM_SEARCH_WRAP_AROUND);
vte_terminal_set_audible_bell (vte, TINYTERM_AUDIBLE_BELL);
vte_terminal_set_cursor_shape (vte, TINYTERM_CURSOR_SHAPE);
vte_terminal_set_cursor_blink_mode (vte, TINYTERM_CURSOR_BLINK);
vte_terminal_set_word_char_exceptions (vte, TINYTERM_WORD_CHARS);
vte_terminal_set_scrollback_lines (vte, TINYTERM_SCROLLBACK_LINES);
PangoFontDescription *font = pango_font_description_from_string(TINYTERM_FONT);
vte_terminal_set_font(vte, font);
GdkRGBA color_fg, color_bg;
GdkRGBA color_palette[16];
gdk_rgba_parse(&color_fg, TINYTERM_COLOR_FOREGROUND);
gdk_rgba_parse(&color_bg, TINYTERM_COLOR_BACKGROUND);
gdk_rgba_parse(&color_palette[0], TINYTERM_COLOR00);
gdk_rgba_parse(&color_palette[1], TINYTERM_COLOR01);
gdk_rgba_parse(&color_palette[2], TINYTERM_COLOR02);
gdk_rgba_parse(&color_palette[3], TINYTERM_COLOR03);
gdk_rgba_parse(&color_palette[4], TINYTERM_COLOR04);
gdk_rgba_parse(&color_palette[5], TINYTERM_COLOR05);
gdk_rgba_parse(&color_palette[6], TINYTERM_COLOR06);
gdk_rgba_parse(&color_palette[7], TINYTERM_COLOR07);
gdk_rgba_parse(&color_palette[8], TINYTERM_COLOR08);
gdk_rgba_parse(&color_palette[9], TINYTERM_COLOR09);
gdk_rgba_parse(&color_palette[10], TINYTERM_COLOR0A);
gdk_rgba_parse(&color_palette[11], TINYTERM_COLOR0B);
gdk_rgba_parse(&color_palette[12], TINYTERM_COLOR0C);
gdk_rgba_parse(&color_palette[13], TINYTERM_COLOR0D);
gdk_rgba_parse(&color_palette[14], TINYTERM_COLOR0E);
gdk_rgba_parse(&color_palette[15], TINYTERM_COLOR0F);
vte_terminal_set_colors(vte, &color_fg, &color_bg, &color_palette, 16);
}
static void
overshot (GtkScrolledWindow *sw, GtkPositionType pos, GtkWidget *widget)
{
GtkWidget *box, *row, *label, *swatch;
GdkRGBA rgba;
const gchar *color;
gchar *text;
GtkWidget *silver;
GtkWidget *gold;
silver = GTK_WIDGET (g_object_get_data (G_OBJECT (widget), "Silver"));
gold = GTK_WIDGET (g_object_get_data (G_OBJECT (widget), "Gold"));
if (pos == GTK_POS_TOP)
{
if (silver)
{
gtk_container_remove (GTK_CONTAINER (widget), silver);
g_object_set_data (G_OBJECT (widget), "Silver", NULL);
}
if (gold)
{
gtk_container_remove (GTK_CONTAINER (widget), gold);
g_object_set_data (G_OBJECT (widget), "Gold", NULL);
}
#ifdef HAVE_LIBCANBERRA
if (silver || gold)
ca_gtk_play_for_widget (widget, 0, "event.id", "message", NULL);
#endif
return;
}
if (gold)
return;
else if (silver)
color = "Gold";
else
color = "Silver";
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20);
text = g_strconcat ("<b>", color, "</b>", NULL);
label = gtk_label_new (text);
g_free (text);
g_object_set (label,
"use-markup", TRUE,
"halign", GTK_ALIGN_START,
"valign", GTK_ALIGN_CENTER,
"margin", 6,
"xalign", 0.0,
NULL);
gtk_box_pack_start (GTK_BOX (row), label, TRUE, TRUE, 0);
gdk_rgba_parse (&rgba, color);
swatch = g_object_new (g_type_from_name ("GtkColorSwatch"),
"rgba", &rgba,
"selectable", FALSE,
"halign", GTK_ALIGN_END,
"valign", GTK_ALIGN_CENTER,
"margin", 6,
"height-request", 24,
NULL);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (box), swatch);
gtk_box_pack_start (GTK_BOX (row), box, FALSE, FALSE, 0);
gtk_widget_show_all (row);
gtk_list_box_insert (GTK_LIST_BOX (widget), row, -1);
row = gtk_widget_get_parent (row);
gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE);
g_object_set_data (G_OBJECT (widget), color, row);
#ifdef HAVE_LIBCANBERRA
ca_gtk_play_for_widget (widget, 0, "event.id", "complete", NULL);
#endif
}
void
dv_viewport_draw_rulers(dv_viewport_t * VP, cairo_t * cr) {
dv_view_t * V = VP->mainV;
if (!V) {
fprintf(stderr, "Error: Viewport %ld does not have main View to draw rulers.\n", VP - DVG->VP);
return;
}
cairo_save(cr);
cairo_new_path(cr);
/* background */
double x = 0.0;
double y = 0.0;
double ruler_width = DVG->opts.ruler_width;
dv_draw_path_rectangle(cr, x, y, VP->vpw, ruler_width);
dv_draw_path_rectangle(cr, x, y, ruler_width, VP->vph);
GdkRGBA c;
gdk_rgba_parse(&c, "#F0F0F0");
cairo_set_source_rgba(cr, c.red, c.green, c.blue, c.alpha);
cairo_fill(cr);
/* prepare */
cairo_select_font_face(cr, "Courier", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size(cr, 8.3);
cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
char s[DV_STRING_LENGTH];
cairo_text_extents_t ext;
/* horizontal ruler */
{
double tick_length = ruler_width;
double tick_length_2 = tick_length / 2.0;
double tick_length_3 = tick_length / 4.0;
double tick_interval_threshold = 200;
const double A[3] = {2.0, 2.0, 2.5};
const int An = 3;
int Ai = 0;
double tick_interval = 1.0;
double tick_interval_next = tick_interval * A[Ai++ % An];
double zr = V->S->zoom_ratio_x;
while (tick_interval_next * zr < tick_interval_threshold) {
tick_interval = tick_interval_next;
tick_interval_next *= A[Ai++ % An];
}
double tick_interval_2 = tick_interval / 5.0;
double tick_interval_3 = tick_interval / 10.0;
double x_left = dv_view_convert_viewport_x_to_graph_x(V, ruler_width);
double x_right = dv_view_convert_viewport_x_to_graph_x(V, VP->vpw);
double x_0 = floor(x_left / tick_interval) * tick_interval;
double x_n = ceil(x_right / tick_interval) * tick_interval;
double y1 = ruler_width;
/* 1st level ticks */
{
double x_ = x_0;
while (x_ <= x_n) {
if (x_left <= x_ && x_ <= x_right) {
double x = dv_view_convert_graph_x_to_viewport_x(V, x_);
dv_viewport_draw_ruler_tick(cr, x, y1 - tick_length, x, y1);
dv_convert_tick_value_to_simplified_string(x_, s);
cairo_text_extents(cr, s, &ext);
cairo_move_to(cr, x + 2 - ext.x_bearing, y1 - tick_length_2 - 1 - (ext.y_bearing + ext.height));
cairo_show_text(cr, s);
}
x_ += tick_interval;
}
}
/* 2nd level ticks */
{
double x_ = x_0;
while (x_ <= x_n) {
if (x_left <= x_ && x_ <= x_right) {
double x = dv_view_convert_graph_x_to_viewport_x(V, x_);
dv_viewport_draw_ruler_tick(cr, x, y1 - tick_length_2, x, y1);
}
x_ += tick_interval_2;
}
}
/* 3nd level ticks */
if (tick_interval_3 * zr >= 5.0) {
double x_ = x_0;
while (x_ <= x_n) {
if (x_left <= x_ && x_ <= x_right) {
double x = dv_view_convert_graph_x_to_viewport_x(V, x_);
dv_viewport_draw_ruler_tick(cr, x, y1 - tick_length_3, x, y1);
}
x_ += tick_interval_3;
}
}
} /* horizontal ruler */
/* vertical ruler */
{
double tick_length = ruler_width;
double tick_length_2 = tick_length / 2.0;
double tick_length_3 = tick_length / 4.0;
double tick_interval_threshold = 200;
const double A[3] = {2.0, 2.0, 2.5};
const int An = 3;
int Ai = 0;
double tick_interval = 1.0;
double tick_interval_next = tick_interval * A[Ai++ % An];
double zr = V->S->zoom_ratio_y;
while (tick_interval_next * zr < tick_interval_threshold) {
tick_interval = tick_interval_next;
tick_interval_next *= A[Ai++ % An];
}
double tick_interval_2 = tick_interval / 5.0;
double tick_interval_3 = tick_interval / 10.0;
double y_top = dv_view_convert_viewport_y_to_graph_y(V, ruler_width);
double y_bottom = dv_view_convert_viewport_y_to_graph_y(V, VP->vph);
double y_0 = floor(y_top / tick_interval) * tick_interval;
double y_n = ceil(y_bottom / tick_interval) * tick_interval;
double x1 = ruler_width;
/* 1st level ticks */
{
double y_ = y_0;
while (y_ <= y_n) {
if (y_top <= y_ && y_ <= y_bottom) {
double y = dv_view_convert_graph_y_to_viewport_y(V, y_);
dv_viewport_draw_ruler_tick(cr, x1 - tick_length, y, x1, y);
dv_convert_tick_value_to_simplified_string(y_, s);
char ss[5];
size_t i;
for (i = 0; i < strlen(s); i++) {
sprintf(ss, "%c", s[i]);
cairo_text_extents(cr, ss, &ext);
cairo_move_to(cr, x1 - tick_length + 1 - ext.x_bearing, y + 3 - ext.y_bearing);
y += ext.height + 2;
cairo_show_text(cr, ss);
}
}
y_ += tick_interval;
}
}
/* 2nd level ticks */
{
double y_ = y_0;
while (y_ <= y_n) {
if (y_top <= y_ && y_ <= y_bottom) {
double y = dv_view_convert_graph_y_to_viewport_y(V, y_);
dv_viewport_draw_ruler_tick(cr, x1 - tick_length_2, y, x1, y);
}
y_ += tick_interval_2;
}
}
/* 3nd level ticks */
if (tick_interval_3 * zr >= 5.0) {
double y_ = y_0;
while (y_ <= y_n) {
if (y_top <= y_ && y_ <= y_bottom) {
double y = dv_view_convert_graph_y_to_viewport_y(V, y_);
dv_viewport_draw_ruler_tick(cr, x1 - tick_length_3, y, x1, y);
}
y_ += tick_interval_3;
}
}
} /* vertical ruler */
/* cairo stroke */
cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
cairo_set_line_width(cr, 0.8);
cairo_stroke(cr);
/* horizontal slider */
{
double x = (VP->x < ruler_width) ? ruler_width : (VP->x > VP->vpw) ? VP->vpw : VP->x;
double y = ruler_width;
const double base = 4.0;
cairo_move_to(cr, x, y);
cairo_rel_line_to(cr, -base, -base);
cairo_rel_line_to(cr, 2 * base, 0.0);
cairo_close_path(cr);
}
/* vertical slider */
{
double x = ruler_width;
double y = (VP->y < ruler_width) ? ruler_width : (VP->y > VP->vph) ? VP->vph : VP->y;
const double base = 4.0;
cairo_move_to(cr, x, y);
cairo_rel_line_to(cr, -base, base);
cairo_rel_line_to(cr, 0.0, -2 * base);
cairo_close_path(cr);
}
/* cairo fill */
cairo_fill(cr);
cairo_restore(cr);
}
MetaColorSpec *
meta_color_spec_new_from_string (const gchar *str,
GError **error)
{
MetaColorSpec *spec;
spec = NULL;
if (strncmp (str, "gtk:custom", 10) == 0)
{
const gchar *color_name_start;
const gchar *fallback_str_start;
const gchar *end;
gchar *fallback_str;
MetaColorSpec *fallback;
gchar *color_name;
if (str[10] != '(')
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("GTK custom color specification must have color name and fallback in parentheses, e.g. gtk:custom(foo,bar); could not parse '%s'"),
str);
return NULL;
}
color_name_start = str + 11;
fallback_str_start = color_name_start;
while (*fallback_str_start && *fallback_str_start != ',')
{
if (!(g_ascii_isalnum (*fallback_str_start)
|| *fallback_str_start == '-' || *fallback_str_start == '_'))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Invalid character '%c' in color_name parameter of gtk:custom, only A-Za-z0-9-_ are valid"),
*fallback_str_start);
return NULL;
}
fallback_str_start++;
}
fallback_str_start++;
end = strrchr (str, ')');
if (color_name_start == NULL || fallback_str_start == NULL || end == NULL)
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Gtk:custom format is 'gtk:custom(color_name,fallback)', '%s' does not fit the format"),
str);
return NULL;
}
fallback_str = g_strndup (fallback_str_start, end - fallback_str_start);
fallback = meta_color_spec_new_from_string (fallback_str, error);
g_free (fallback_str);
if (fallback == NULL)
return NULL;
color_name = g_strndup (color_name_start, fallback_str_start - color_name_start - 1);
spec = meta_color_spec_new (META_COLOR_SPEC_GTK_CUSTOM);
spec->data.gtkcustom.color_name = color_name;
spec->data.gtkcustom.fallback = fallback;
}
else if (strncmp (str, "gtk:", 4) == 0)
{
const gchar *bracket;
const gchar *end_bracket;
gchar *tmp;
GtkStateFlags state;
MetaGtkColorComponent component;
bracket = str;
while (*bracket && *bracket != '[')
++bracket;
if (*bracket == '\0')
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("GTK color specification must have the state in brackets, e.g. gtk:fg[NORMAL] where NORMAL is the state; could not parse '%s'"),
str);
return NULL;
}
end_bracket = bracket;
++end_bracket;
while (*end_bracket && *end_bracket != ']')
++end_bracket;
if (*end_bracket == '\0')
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("GTK color specification must have a close bracket after the state, e.g. gtk:fg[NORMAL] where NORMAL is the state; could not parse '%s'"),
str);
return NULL;
}
tmp = g_strndup (bracket + 1, end_bracket - bracket - 1);
if (!meta_gtk_state_from_string (tmp, &state))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Did not understand state '%s' in color specification"),
tmp);
g_free (tmp);
return NULL;
}
g_free (tmp);
tmp = g_strndup (str + 4, bracket - str - 4);
component = meta_color_component_from_string (tmp);
if (component == META_GTK_COLOR_LAST)
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Did not understand color component '%s' in color specification"),
tmp);
g_free (tmp);
return NULL;
}
g_free (tmp);
spec = meta_color_spec_new (META_COLOR_SPEC_GTK);
spec->data.gtk.state = state;
spec->data.gtk.component = component;
g_assert (spec->data.gtk.component < META_GTK_COLOR_LAST);
}
else if (strncmp (str, "blend/", 6) == 0)
{
gchar **split;
gdouble alpha;
gchar *end;
MetaColorSpec *fg;
MetaColorSpec *bg;
split = g_strsplit (str, "/", 4);
if (split[0] == NULL || split[1] == NULL ||
split[2] == NULL || split[3] == NULL)
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Blend format is 'blend/bg_color/fg_color/alpha', '%s' does not fit the format"),
str);
g_strfreev (split);
return NULL;
}
alpha = g_ascii_strtod (split[3], &end);
if (end == split[3])
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Could not parse alpha value '%s' in blended color"),
split[3]);
g_strfreev (split);
return NULL;
}
if (alpha < (0.0 - 1e6) || alpha > (1.0 + 1e6))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Alpha value '%s' in blended color is not between 0.0 and 1.0"),
split[3]);
g_strfreev (split);
return NULL;
}
fg = NULL;
bg = NULL;
bg = meta_color_spec_new_from_string (split[1], error);
if (bg == NULL)
{
g_strfreev (split);
return NULL;
}
fg = meta_color_spec_new_from_string (split[2], error);
if (fg == NULL)
{
meta_color_spec_free (bg);
g_strfreev (split);
return NULL;
}
g_strfreev (split);
spec = meta_color_spec_new (META_COLOR_SPEC_BLEND);
spec->data.blend.alpha = alpha;
spec->data.blend.background = bg;
spec->data.blend.foreground = fg;
}
else if (strncmp (str, "shade/", 6) == 0)
{
gchar **split;
gdouble factor;
gchar *end;
MetaColorSpec *base;
split = g_strsplit (str, "/", 3);
if (split[0] == NULL || split[1] == NULL || split[2] == NULL)
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Shade format is 'shade/base_color/factor', '%s' does not fit the format"),
str);
g_strfreev (split);
return NULL;
}
factor = g_ascii_strtod (split[2], &end);
if (end == split[2])
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Could not parse shade factor '%s' in shaded color"),
split[2]);
g_strfreev (split);
return NULL;
}
if (factor < (0.0 - 1e6))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Shade factor '%s' in shaded color is negative"),
split[2]);
g_strfreev (split);
return NULL;
}
base = meta_color_spec_new_from_string (split[1], error);
if (base == NULL)
{
g_strfreev (split);
return NULL;
}
g_strfreev (split);
spec = meta_color_spec_new (META_COLOR_SPEC_SHADE);
spec->data.shade.factor = factor;
spec->data.shade.base = base;
}
else
{
spec = meta_color_spec_new (META_COLOR_SPEC_BASIC);
if (!gdk_rgba_parse (&spec->data.basic.color, str))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Could not parse color '%s'"), str);
meta_color_spec_free (spec);
return NULL;
}
}
g_assert (spec);
return spec;
}
gboolean
ide_source_style_scheme_apply_style (GtkSourceStyleScheme *style_scheme,
const gchar *style_name,
GtkTextTag *tag)
{
g_autofree gchar *foreground = NULL;
g_autofree gchar *background = NULL;
g_autofree gchar *underline_color = NULL;
GdkRGBA underline_rgba;
GtkSourceStyle *style;
const gchar *colon;
PangoUnderline pango_underline;
gboolean foreground_set = FALSE;
gboolean background_set = FALSE;
gboolean bold = FALSE;
gboolean bold_set = FALSE;
gboolean underline_set = FALSE;
gboolean underline_color_set = FALSE;
gboolean italic = FALSE;
gboolean italic_set = FALSE;
g_return_val_if_fail (GTK_SOURCE_IS_STYLE_SCHEME (style_scheme), FALSE);
g_return_val_if_fail (style_name != NULL, FALSE);
g_object_set (tag,
"foreground-set", FALSE,
"background-set", FALSE,
"weight-set", FALSE,
"underline-set", FALSE,
"underline-rgba-set", FALSE,
"style-set", FALSE,
NULL);
style = gtk_source_style_scheme_get_style (style_scheme, style_name);
if (style == NULL && (colon = strchr (style_name, ':')))
{
gchar defname[64];
g_snprintf (defname, sizeof defname, "def%s", colon);
style = gtk_source_style_scheme_get_style (style_scheme, defname);
if (style == NULL)
return FALSE;
}
g_object_get (style,
"background", &background,
"background-set", &background_set,
"foreground", &foreground,
"foreground-set", &foreground_set,
"bold", &bold,
"bold-set", &bold_set,
"pango-underline", &pango_underline,
"underline-set", &underline_set,
"underline-color", &underline_color,
"underline-color-set", &underline_color_set,
"italic", &italic,
"italic-set", &italic_set,
NULL);
if (background_set)
g_object_set (tag, "background", background, NULL);
if (foreground_set)
g_object_set (tag, "foreground", foreground, NULL);
if (bold_set && bold)
g_object_set (tag, "weight", PANGO_WEIGHT_BOLD, NULL);
if (italic_set && italic)
g_object_set (tag, "style", PANGO_STYLE_ITALIC, NULL);
if (underline_set)
g_object_set (tag, "underline", pango_underline, NULL);
if (underline_color_set && underline_color != NULL)
{
gdk_rgba_parse (&underline_rgba, underline_color);
g_object_set (tag,
"underline-rgba", &underline_rgba,
NULL);
}
return TRUE;
}
static void
gnc_header_draw_offscreen (GncHeader *header)
{
SheetBlockStyle *style = header->style;
Table *table = header->sheet->table;
VirtualLocation virt_loc;
VirtualCell *vcell;
guint32 color_type;
GtkStyleContext *stylectxt = gtk_widget_get_style_context (GTK_WIDGET(header));
GdkRGBA color;
int row_offset;
CellBlock *cb;
int i;
cairo_t *cr;
virt_loc.vcell_loc.virt_row = 0;
virt_loc.vcell_loc.virt_col = 0;
virt_loc.phys_row_offset = 0;
virt_loc.phys_col_offset = 0;
gtk_style_context_save (stylectxt);
// Get the background color type and apply the css class
color_type = gnc_table_get_bg_color (table, virt_loc, NULL);
gnucash_get_style_classes (header->sheet, stylectxt, color_type);
if (header->surface)
cairo_surface_destroy (header->surface);
header->surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
header->width,
header->height);
cr = cairo_create (header->surface);
// Fill background color of header
gtk_render_background (stylectxt, cr, 0, 0, header->width, header->height);
gdk_rgba_parse (&color, "black");
cairo_set_source_rgb (cr, color.red, color.green, color.blue);
cairo_rectangle (cr, 0.5, 0.5, header->width - 1.0, header->height - 1.0);
cairo_set_line_width (cr, 1.0);
cairo_stroke (cr);
// Draw bottom horizontal line, makes bottom line thicker
cairo_move_to (cr, 0.5, header->height - 1.5);
cairo_line_to (cr, header->width - 1.0, header->height - 1.5);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_width (cr, 1.0);
cairo_stroke (cr);
/*font = gnucash_register_font;*/
vcell = gnc_table_get_virtual_cell
(table, table->current_cursor_loc.vcell_loc);
cb = vcell ? vcell->cellblock : NULL;
row_offset = 0;
for (i = 0; i < style->nrows; i++)
{
int col_offset = 0;
int h = 0, j;
virt_loc.phys_row_offset = i;
/* TODO: This routine is duplicated in several places.
Can we abstract at least the cell drawing routine?
That way we'll be sure everything is drawn
consistently, and cut down on maintenance issues. */
for (j = 0; j < style->ncols; j++)
{
CellDimensions *cd;
double text_x, text_y, text_w, text_h;
BasicCell *cell;
const char *text;
int w;
PangoLayout *layout;
virt_loc.phys_col_offset = j;
cd = gnucash_style_get_cell_dimensions (style, i, j);
h = cd->pixel_height;
if (header->in_resize && (j == header->resize_col))
w = header->resize_col_width;
else
w = cd->pixel_width;
cell = gnc_cellblock_get_cell (cb, i, j);
if (!cell || !cell->cell_name)
{
col_offset += w;
continue;
}
cairo_rectangle (cr, col_offset - 0.5, row_offset + 0.5, w, h);
cairo_set_line_width (cr, 1.0);
cairo_stroke (cr);
virt_loc.vcell_loc =
table->current_cursor_loc.vcell_loc;
text = gnc_table_get_label (table, virt_loc);
if (!text)
text = "";
layout = gtk_widget_create_pango_layout (GTK_WIDGET (header->sheet), text);
switch (gnc_table_get_align (table, virt_loc))
{
default:
case CELL_ALIGN_LEFT:
pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
break;
case CELL_ALIGN_RIGHT:
pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);
break;
case CELL_ALIGN_CENTER:
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
break;
}
text_x = col_offset + CELL_HPADDING;
text_y = row_offset + 1;
text_w = MAX (0, w - (2 * CELL_HPADDING));
text_h = h - 2;
cairo_save (cr);
cairo_rectangle (cr, text_x, text_y, text_w, text_h);
cairo_clip (cr);
gtk_render_layout (stylectxt, cr, text_x, text_y, layout);
cairo_restore (cr);
g_object_unref (layout);
col_offset += w;
}
row_offset += h;
}
gtk_style_context_restore (stylectxt);
cairo_destroy (cr);
}
/* Common XML format for both Bijiben / Tomboy */
static void
processNode (BijiLazyDeserializer *self)
{
xmlTextReaderPtr r = self->priv->r;
BijiNoteObj * n = self->priv->note;
xmlChar *name;
GdkRGBA *color;
gchar *tag;
GString *norm;
gchar *debug;
name = xmlTextReaderName (r);
if ( g_strcmp0((gchar*)name,"title") == 0 )
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_title, n);
if ( g_strcmp0((gchar*)name,"text") == 0 )
{
if (self->priv->type == BIJIBEN_1)
{
self->priv->content = (gchar*) xmlTextReaderReadInnerXml (r);
process_bijiben_html_content (self);
}
else if (self->priv->type == TOMBOY_1 ||
self->priv->type == TOMBOY_2 ||
self->priv->type == TOMBOY_3 )
{
self->priv->content = (gchar*) xmlTextReaderReadInnerXml (r);
process_tomboy_xml_content (self);
}
}
if (g_strcmp0 ((gchar*) name, "last-change-date") == 0)
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_last_change_date, n);
if (g_strcmp0 ((gchar*) name, "last-metadata-change-date") == 0)
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_last_metadata_change_date, n);
if (g_strcmp0 ((gchar*) name, "create-date") == 0)
biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_create_date, n);
if (g_strcmp0 ((gchar*) name, "color") == 0 )
{
color = g_new (GdkRGBA,1);
debug = (gchar*) xmlTextReaderReadString (r);
if ( gdk_rgba_parse (color,debug))
{
biji_note_obj_set_rgba (n, color);
}
else
{
g_warning ("color invalid:%s",debug);
}
free (debug);
}
if ( g_strcmp0((gchar*)name,"tag") == 0 )
{
tag = (gchar*) xmlTextReaderReadString(r);
if (g_str_has_prefix (tag,"system:template"))
{
note_obj_set_is_template(n,TRUE);
}
else if (g_str_has_prefix (tag,"system:notebook:"))
{
norm = g_string_new (tag);
g_string_erase (norm,0,16);
_biji_note_obj_set_tags (n, g_list_prepend((GList*)_biji_note_obj_get_tags(n),
g_string_free (norm,FALSE)));
}
free (tag);
}
xmlFree(name);
}
GtkWidget *
text_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
w = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
text_view = gtk_text_view_new ();
gtk_widget_set_name (text_view, "yad-text-widget");
text_buffer = gtk_text_buffer_new (NULL);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view), text_buffer);
gtk_text_view_set_justification (GTK_TEXT_VIEW (text_view), options.text_data.justify);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (text_view), options.text_data.margins);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (text_view), options.text_data.margins);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), options.common_data.editable);
if (!options.common_data.editable)
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE);
if (options.text_data.wrap)
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD_CHAR);
if (options.text_data.fore)
{
#if GTK_CHECK_VERSION(3,0,0)
GdkRGBA clr;
if (gdk_rgba_parse (&clr, options.text_data.fore))
gtk_widget_override_color (text_view, GTK_STATE_FLAG_NORMAL, &clr);
#else
GdkColor clr;
if (gdk_color_parse (options.text_data.fore, &clr))
gtk_widget_modify_text (text_view, GTK_STATE_NORMAL, &clr);
#endif
}
if (options.text_data.back)
{
#if GTK_CHECK_VERSION(3,0,0)
GdkRGBA clr;
if (gdk_rgba_parse (&clr, options.text_data.fore))
gtk_widget_override_background_color (text_view, GTK_STATE_FLAG_NORMAL, &clr);
#else
GdkColor clr;
if (gdk_color_parse (options.text_data.back, &clr))
gtk_widget_modify_base (text_view, GTK_STATE_NORMAL, &clr);
#endif
}
if (options.common_data.font)
{
PangoFontDescription *fd =
pango_font_description_from_string (options.common_data.font);
#if GTK_CHECK_VERSION(3,0,0)
gtk_widget_override_font (text_view, fd);
#else
gtk_widget_modify_font (text_view, fd);
#endif
pango_font_description_free (fd);
}
/* Add submit on ctrl+enter */
g_signal_connect (text_view, "key-press-event", G_CALLBACK (key_press_cb), dlg);
/* Initialize linkifying */
if (options.text_data.uri)
{
GRegex *regex;
regex = g_regex_new (YAD_URL_REGEX,
G_REGEX_CASELESS | G_REGEX_OPTIMIZE | G_REGEX_EXTENDED,
G_REGEX_MATCH_NOTEMPTY,
NULL);
/* Create text tag for URI */
tag = gtk_text_buffer_create_tag (text_buffer, NULL,
"foreground", "blue",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
g_object_set_data (G_OBJECT (tag), "is_link", GINT_TO_POINTER (1));
g_signal_connect (G_OBJECT (tag), "event", G_CALLBACK (tag_event_cb), NULL);
/* Create cursors */
hand = gdk_cursor_new (GDK_HAND2);
normal= gdk_cursor_new (GDK_XTERM);
g_signal_connect (G_OBJECT (text_view), "motion-notify-event", G_CALLBACK (motion_cb), NULL);
g_signal_connect_after (G_OBJECT (text_buffer), "changed", G_CALLBACK (linkify_cb), regex);
}
gtk_container_add (GTK_CONTAINER (w), text_view);
if (options.common_data.uri)
fill_buffer_from_file ();
else
fill_buffer_from_stdin ();
return w;
}
