GtkWidget *
pgd_layers_create_widget (PopplerDocument *document)
{
PgdLayersDemo *demo;
GtkWidget *swindow;
GtkWidget *treeview;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkWidget *hpaned, *viewer;
demo = g_new0 (PgdLayersDemo, 1);
demo->doc = g_object_ref (document);
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
viewer = pgd_layers_create_viewer (demo);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
model = pgd_layers_create_model (document);
treeview = gtk_tree_view_new_with_model (model);
demo->treeview = treeview;
g_object_unref (model);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
0, "Layer",
renderer,
"markup", LAYERS_TITLE_COLUMN,
NULL);
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_object_set (G_OBJECT (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0)),
"expand", TRUE, NULL);
if (GTK_IS_TREE_STORE (model)) {
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
1, "Show/Hide",
renderer,
"active", LAYERS_VISIBILITY_COLUMN,
"activatable", LAYERS_ENABLE_COLUMN,
"visible", LAYERS_SHOWTOGGLE_COLUMN,
NULL);
g_signal_connect (renderer, "toggled",
G_CALLBACK (pgd_layers_visibility_changed),
(gpointer)demo);
gtk_tree_view_column_set_clickable (gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 1),
TRUE);
}
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_NONE);
gtk_container_add (GTK_CONTAINER (swindow), treeview);
gtk_widget_show (treeview);
gtk_paned_add1 (GTK_PANED (hpaned), swindow);
gtk_widget_show (swindow);
gtk_paned_add2 (GTK_PANED (hpaned), viewer);
gtk_widget_show (viewer);
gtk_paned_set_position (GTK_PANED (hpaned), 150);
g_object_weak_ref (G_OBJECT (hpaned),
(GWeakNotify)pgd_layers_free,
(gpointer)demo);
return hpaned;
}
static void
set_up (EmpathyGroupsWidget *self)
{
EmpathyGroupsWidgetPriv *priv;
GtkWidget *label, *alignment;
GtkBox *vbox, *hbox;
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
guint col_offset;
GtkScrolledWindow *scrolled_window;
gchar *markup;
priv = GET_PRIV (self);
/* Set up ourself */
gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
GTK_ORIENTATION_VERTICAL);
gtk_box_set_spacing (GTK_BOX (self), 6);
/* Create our child widgets */
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
markup = g_strdup_printf ("<b>%s</b>", _("Groups"));
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
gtk_box_pack_start (GTK_BOX (self), label, FALSE, FALSE, 0);
gtk_widget_show (label);
alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 6));
label = gtk_label_new (_("Select the groups you want this contact to appear "
"in. Note that you can select more than one group or no groups."));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (vbox, label, FALSE, FALSE, 0);
gtk_widget_show (label);
hbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12));
priv->add_group_entry = gtk_entry_new ();
g_signal_connect (priv->add_group_entry, "changed",
(GCallback) add_group_entry_changed_cb, self);
g_signal_connect (priv->add_group_entry, "activate",
(GCallback) add_group_entry_activate_cb, self);
gtk_box_pack_start (hbox, priv->add_group_entry, TRUE, TRUE, 0);
gtk_widget_show (priv->add_group_entry);
priv->add_group_button = gtk_button_new_with_mnemonic (_("_Add Group"));
gtk_widget_set_sensitive (priv->add_group_button, FALSE);
gtk_widget_set_receives_default (priv->add_group_button, TRUE);
g_signal_connect (priv->add_group_button, "clicked",
(GCallback) add_group_button_clicked_cb, self);
gtk_box_pack_start (hbox, priv->add_group_button, FALSE, FALSE, 0);
gtk_widget_show (priv->add_group_button);
gtk_box_pack_start (vbox, GTK_WIDGET (hbox), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (hbox));
scrolled_window = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
gtk_scrolled_window_set_policy (scrolled_window, GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (scrolled_window, GTK_SHADOW_IN);
gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100);
priv->group_store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_STRING, /* name */
G_TYPE_BOOLEAN, /* enabled */
G_TYPE_BOOLEAN); /* editable */
tree_view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (
GTK_TREE_MODEL (priv->group_store)));
gtk_tree_view_set_headers_visible (tree_view, FALSE);
gtk_tree_view_set_enable_search (tree_view, FALSE);
selection = gtk_tree_view_get_selection (tree_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled", (GCallback) cell_toggled_cb, self);
column = gtk_tree_view_column_new_with_attributes (
C_("verb in a column header displaying group names", "Select"), renderer,
"active", COL_ENABLED,
NULL);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (column, 50);
gtk_tree_view_append_column (tree_view, column);
renderer = gtk_cell_renderer_text_new ();
col_offset = gtk_tree_view_insert_column_with_attributes (tree_view,
-1, _("Group"),
renderer,
"text", COL_NAME,
/* "editable", COL_EDITABLE, */
NULL);
column = gtk_tree_view_get_column (tree_view, col_offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_NAME);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->group_store),
COL_NAME, GTK_SORT_ASCENDING);
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view));
gtk_widget_show (GTK_WIDGET (tree_view));
gtk_box_pack_start (vbox, GTK_WIDGET (scrolled_window), TRUE, TRUE, 0);
gtk_widget_show (GTK_WIDGET (scrolled_window));
gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox));
gtk_widget_show (GTK_WIDGET (vbox));
gtk_box_pack_start (GTK_BOX (self), alignment, TRUE, TRUE, 0);
gtk_widget_show (alignment);
}
static void
add_columns (GtkTreeView *treeview)
{
gint col_offset;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
/* column for holiday names */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Holiday",
renderer, "text",
HOLIDAY_NAME_COLUMN,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* alex column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
g_object_set_data (G_OBJECT (renderer), "column", (gint *)ALEX_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Alex",
renderer,
"active",
ALEX_COLUMN,
"visible",
VISIBLE_COLUMN,
"activatable",
WORLD_COLUMN, NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* havoc column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
g_object_set_data (G_OBJECT (renderer), "column", (gint *)HAVOC_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Havoc",
renderer,
"active",
HAVOC_COLUMN,
"visible",
VISIBLE_COLUMN,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* tim column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
g_object_set_data (G_OBJECT (renderer), "column", (gint *)TIM_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Tim",
renderer,
"active",
TIM_COLUMN,
"visible",
VISIBLE_COLUMN,
"activatable",
WORLD_COLUMN, NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* owen column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
g_object_set_data (G_OBJECT (renderer), "column", (gint *)OWEN_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Owen",
renderer,
"active",
OWEN_COLUMN,
"visible",
VISIBLE_COLUMN,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* dave column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
g_object_set_data (G_OBJECT (renderer), "column", (gint *)DAVE_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Dave",
renderer,
"active",
DAVE_COLUMN,
"visible",
VISIBLE_COLUMN,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
}
static GtkTreeStore* ctree_create(GtkWidget *widget)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreeStore *store;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gint i;
store = gtk_tree_store_new(CTREE_NCOLS,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_POINTER,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
-1
);
model = GTK_TREE_MODEL(store);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_rules_hint(view, TRUE);
// col 1
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"Name", renderer,
"text", COL_NAME,
"font", COL_FONT,
NULL);
// col 2
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(view, column);
gtk_tree_view_column_set_title(column, "Value");
renderer = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer,
"active", COL_BTNACT,
"visible", COL_BTNVIS,
NULL);
g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(renderer_toggled), widget);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer,
"text", COL_VALUE,
"editable", COL_EDIT,
"font", COL_FONT,
NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(renderer_edited), widget);
// col 3
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"Address", renderer,
"text", COL_ADDR,
"font", COL_FONT,
NULL);
// col 4
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"Mask", renderer,
"text", COL_MASK,
"font", COL_FONT,
NULL);
for (i = 0; i < CTREE_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL);
return store;
}
void initTreeView(){
GtkTreeModel *model;
//Create Data
gint i = 0;
GtkListStore *store;
GtkTreeIter iter;
/* create list store */
/*store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_UINT,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_UINT,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
*/
/* add data to the list store */
for (i = 0; i < G_N_ELEMENTS (data); i++){
gchar *icon_name;
gboolean sensitive;
if (i == 1 || i == 3)
icon_name = "battery-caution-charging-symbolic";
else
icon_name = NULL;
if (i == 3)
sensitive = FALSE;
else
sensitive = TRUE;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COLUMN_FIXED, data[i].fixed,
COLUMN_NUMBER, data[i].number,
COLUMN_SEVERITY, data[i].severity,
COLUMN_DESCRIPTION, data[i].description,
COLUMN_PULSE, 0,
COLUMN_ICON, icon_name,
COLUMN_ACTIVE, FALSE,
COLUMN_SENSITIVE, sensitive,
-1);
}
model=GTK_TREE_MODEL(store);
//model=gtk_tree_view_get_model((GtkTreeView*)treeview);
gtk_tree_view_set_model((GtkTreeView*)treeview, model);
GtkCellRenderer* renderer;
GtkTreeViewColumn *column;
renderer=gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",G_CALLBACK (fixed_toggled), model);
column = gtk_tree_view_column_new_with_attributes ("Fixed?",renderer,"active", COLUMN_FIXED,NULL);
/* set this column to a fixed sizing (of 50 pixels) */
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_append_column ((GtkTreeView*)treeview, column);
/* column for bug numbers */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Bug number",renderer,"text",COLUMN_NUMBER,NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_NUMBER);
gtk_tree_view_append_column ((GtkTreeView*)treeview, column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("COLUMN_DESCRIPTION",renderer,"text",COLUMN_DESCRIPTION,NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_DESCRIPTION);
gtk_tree_view_append_column ((GtkTreeView*)treeview, column);
//GtkTreeIter iter;
gboolean valid;
gint row_count = 0;
valid = gtk_tree_model_get_iter_first (model,&iter);
gtk_list_store_set (store, &iter,
COLUMN_FIXED, data[i].fixed,
COLUMN_NUMBER, 20,
COLUMN_SEVERITY, data[i].severity,
COLUMN_DESCRIPTION, "sgdfrgs",
COLUMN_PULSE, 0,
COLUMN_ICON, "battery-caution-charging-symbolic",
COLUMN_ACTIVE, FALSE,
COLUMN_SENSITIVE, TRUE,
-1);
}
static void
anjuta_save_prompt_init(AnjutaSavePrompt *obj)
{
GtkWidget *vbox;
GtkWidget *treeview;
GtkListStore *store;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *label;
GtkWidget *scrolledwindow;
obj->priv = g_new0(AnjutaSavePromptPrivate, 1);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (obj), "Uninitialized");
gtk_window_set_resizable (GTK_WINDOW (obj), TRUE);
gtk_window_set_default_size (GTK_WINDOW (obj), 400, 300);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (obj))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
label = gtk_label_new (_("Select the items to save:"));
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (label), 10, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
gtk_widget_show (label);
store = gtk_list_store_new (N_COLS, G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_POINTER,
G_TYPE_POINTER, G_TYPE_POINTER);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow), 10);
gtk_widget_show (scrolledwindow);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview);
gtk_widget_show (treeview);
label = gtk_label_new (_("If you do not save, all your changes will be lost."));
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (label), 10, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
gtk_widget_show (label);
renderer = gtk_cell_renderer_toggle_new ();
col = gtk_tree_view_column_new_with_attributes (_("Save"),
renderer,
"active", COL_SAVE_ENABLE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
renderer = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Item"),
renderer,
"markup", COL_LABEL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
gtk_dialog_add_buttons (GTK_DIALOG (obj), _("_Discard changes"),
ANJUTA_SAVE_PROMPT_RESPONSE_DISCARD,
GTK_STOCK_CANCEL,
ANJUTA_SAVE_PROMPT_RESPONSE_CANCEL,
GTK_STOCK_SAVE,
ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE,
NULL);
/* TRUE is the default and Gtk warns that this has no effect */
/* gtk_dialog_set_has_separator (GTK_DIALOG (obj), TRUE); */
gtk_dialog_set_default_response (GTK_DIALOG (obj),
ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE);
g_signal_connect (obj, "response",
G_CALLBACK (on_dialog_response),
obj);
obj->priv->treeview = treeview;
}
static void
create_categories_section (GtkWidget *categories_vbox, GUI *appGUI)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkWidget *table, *scrolledwindow, *treeview;
table = gtk_table_new (4, 3, FALSE);
gtk_box_pack_start (GTK_BOX (categories_vbox), table, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table), 8);
gtk_table_set_row_spacings (GTK_TABLE (table), 8);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
appGUI->opt->tasks_category_entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_category_entry, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_entry), "key_release_event",
G_CALLBACK (tasks_category_entry_key_release_cb), appGUI);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_table_attach (GTK_TABLE (table), scrolledwindow, 0, 3, 0, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (appGUI->opt->tasks_category_store));
gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview);
gtk_container_set_border_width (GTK_CONTAINER (treeview), 4);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), FALSE);
gtk_widget_set_size_request (treeview, -1, 120);
appGUI->opt->tasks_category_treeview = treeview;
appGUI->opt->tasks_category_select = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_select), "changed", G_CALLBACK (tasks_category_selected_cb), appGUI);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, "editable-set", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (tasks_category_cell_edited_cb), appGUI);
column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", TC_COLUMN_NAME, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_column_set_expand (column, TRUE);
renderer = gtk_cell_renderer_toggle_new (); /* Show in calendar */
column = gtk_tree_view_column_new_with_attributes(_("Calendar"), renderer, "active", TC_COLUMN_CALENDAR, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_calendar_toggled), appGUI);
renderer = gtk_cell_renderer_toggle_new (); /* Show in tasks list */
column = gtk_tree_view_column_new_with_attributes (_("Tasks"), renderer, "active", TC_COLUMN_TASKS, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_tasks_list_toggled), appGUI);
if (config.default_stock_icons)
appGUI->opt->tasks_category_add_button = utl_gui_stock_button (GTK_STOCK_ADD, FALSE);
else
appGUI->opt->tasks_category_add_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_ADD, FALSE);
gtk_widget_set_sensitive (appGUI->opt->tasks_category_add_button, FALSE);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_category_add_button, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
g_signal_connect (appGUI->opt->tasks_category_add_button, "clicked", G_CALLBACK (tasks_category_add_cb), appGUI);
if (config.default_stock_icons)
appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (GTK_STOCK_REMOVE, FALSE);
else
appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_REMOVE, FALSE);
gtk_widget_set_sensitive (appGUI->opt->tasks_category_remove_button, FALSE);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_category_remove_button, 2, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
g_signal_connect (appGUI->opt->tasks_category_remove_button, "clicked", G_CALLBACK (tasks_category_remove_cb), appGUI);
}
GList *a_select_geoname_from_list(GtkWindow *parent, GList *geonames, gboolean multiple_selection_allowed, const gchar *title, const gchar *msg)
{
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkCellRenderer *toggle_render;
GtkWidget *view;
found_geoname *geoname;
gchar *latlon_string;
int column_runner;
gboolean checked;
gboolean to_copy;
GtkWidget *dialog = gtk_dialog_new_with_buttons (title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
GtkWidget *label = gtk_label_new ( msg );
GtkTreeStore *store;
if (multiple_selection_allowed)
{
store = gtk_tree_store_new(4, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
}
else
{
store = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
}
GList *geoname_runner = geonames;
while (geoname_runner)
{
geoname = (found_geoname *)geoname_runner->data;
latlon_string = g_strdup_printf("(%f,%f)", geoname->ll.lat, geoname->ll.lon);
gtk_tree_store_append(store, &iter, NULL);
if (multiple_selection_allowed)
{
gtk_tree_store_set(store, &iter, 0, FALSE, 1, geoname->name, 2, geoname->country, 3, latlon_string, -1);
}
else
{
gtk_tree_store_set(store, &iter, 0, geoname->name, 1, geoname->country, 2, latlon_string, -1);
}
geoname_runner = g_list_next(geoname_runner);
g_free(latlon_string);
}
view = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new();
column_runner = 0;
if (multiple_selection_allowed)
{
toggle_render = gtk_cell_renderer_toggle_new();
g_object_set(toggle_render, "activatable", TRUE, NULL);
g_signal_connect(toggle_render, "toggled", (GCallback) buttonToggled, GTK_TREE_MODEL(store));
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Select", toggle_render, "active", column_runner, NULL);
column_runner++;
}
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Name", renderer, "text", column_runner, NULL);
column_runner++;
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Country", renderer, "text", column_runner, NULL);
column_runner++;
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Lat/Lon", renderer, "text", column_runner, NULL);
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
multiple_selection_allowed ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_BROWSE );
g_object_unref(store);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE, 0);
gtk_widget_show ( label );
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), view, FALSE, FALSE, 0);
gtk_widget_show ( view );
while ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT )
{
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
GList *selected_geonames = NULL;
gtk_tree_model_get_iter_first( GTK_TREE_MODEL(store), &iter);
geoname_runner = geonames;
while (geoname_runner)
{
to_copy = FALSE;
if (multiple_selection_allowed)
{
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &checked, -1);
if (checked) {
to_copy = TRUE;
}
}
else
{
if (gtk_tree_selection_iter_is_selected(selection, &iter))
{
to_copy = TRUE;
}
}
if (to_copy) {
found_geoname *copied = copy_found_geoname(geoname_runner->data);
selected_geonames = g_list_prepend(selected_geonames, copied);
}
geoname_runner = g_list_next(geoname_runner);
gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
}
if (selected_geonames)
{
gtk_widget_destroy ( dialog );
return (selected_geonames);
}
a_dialog_error_msg(parent, _("Nothing was selected"));
}
gtk_widget_destroy ( dialog );
return NULL;
}
void
gui_create_tasks_options_page (GtkWidget *vbox, GUI *appGUI) {
GtkWidget *appearance_vbox, *categories_vbox;
GtkWidget *sorting_vbox, *tasks_opt_vbox, *visible_columns_vbox;
GtkWidget *label;
GtkWidget *colors_hbox;
GtkWidget *valid_hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *alignment;
GtkWidget *ti_font_button;
GtkWidget *scrolledwindow;
GtkWidget *tasks_category_table;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GdkColor color;
GtkObject *postpone_time_spinbutton_adj;
gchar tmpbuf[BUFFER_SIZE];
appGUI->opt->tasks_vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), appGUI->opt->tasks_vbox, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Appearance"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
appearance_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (appearance_vbox);
gtk_container_add (GTK_CONTAINER (alignment), appearance_vbox);
table = gtk_table_new (4, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (appearance_vbox), table, FALSE, FALSE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 8);
colors_hbox = gtk_hbox_new (FALSE, 8);
gtk_widget_show (colors_hbox);
gtk_table_attach (GTK_TABLE (table), colors_hbox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
appGUI->opt->due_today_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->due_today_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->due_today_color_picker), "color-set",
G_CALLBACK(due_today_color_changed_cb), appGUI);
if (config.enable_tooltips) {
gtk_widget_set_tooltip_text (appGUI->opt->due_today_color_picker, _("Color of items that are due today"));
}
gdk_color_parse(config.due_today_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_today_color_picker), &color);
gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->due_today_color_picker, FALSE, FALSE, 0);
appGUI->opt->due_7days_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->due_7days_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->due_7days_color_picker), "color-set",
G_CALLBACK(due_7days_color_changed_cb), appGUI);
if (config.enable_tooltips) {
gtk_widget_set_tooltip_text (appGUI->opt->due_7days_color_picker, _("Color of items that are due in the next 7 days"));
}
gdk_color_parse(config.due_7days_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_7days_color_picker), &color);
gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->due_7days_color_picker, FALSE, FALSE, 0);
appGUI->opt->past_due_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->past_due_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->past_due_color_picker), "color-set",
G_CALLBACK(past_due_color_changed_cb), appGUI);
if (config.enable_tooltips) {
gtk_widget_set_tooltip_text (appGUI->opt->past_due_color_picker, _("Color of items that are past due"));
}
gdk_color_parse(config.past_due_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->past_due_color_picker), &color);
gtk_box_pack_start (GTK_BOX (colors_hbox), appGUI->opt->past_due_color_picker, FALSE, FALSE, 0);
appGUI->opt->ti_font_entry = gtk_entry_new ();
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ti_font_entry, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ti_font_entry);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->ti_font_entry, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
if (config.default_stock_icons) {
ti_font_button = utl_gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE);
} else {
ti_font_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(ti_font_button, GTK_CAN_FOCUS);
gtk_widget_show (ti_font_button);
g_signal_connect (G_OBJECT (ti_font_button), "clicked",
G_CALLBACK (ti_font_select_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), ti_font_button, 2, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
sprintf(tmpbuf, "%s:", _("Task info font"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
sprintf(tmpbuf, "%s:", _("Colors"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->opt->tasks_enable_rules_hint_checkbutton = gtk_check_button_new_with_mnemonic (_("Draw rows in alternating colors"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_enable_rules_hint_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_enable_rules_hint_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_enable_rules_hint_checkbutton), "toggled",
G_CALLBACK (tasks_enable_rules_hint_checkbutton_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_enable_rules_hint_checkbutton, 0, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->ct_bold_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Show in bold tasks with high priority"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_bold_items_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_bold_items_checkbutton);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->ct_bold_items_checkbutton, 0, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect (G_OBJECT (appGUI->opt->ct_bold_items_checkbutton), "toggled",
G_CALLBACK (bold_items_cb), appGUI);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Visible columns"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
visible_columns_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (visible_columns_vbox);
gtk_container_add (GTK_CONTAINER (alignment), visible_columns_vbox);
table = gtk_table_new (1, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (visible_columns_vbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
appGUI->opt->vc_due_date_checkbutton = gtk_check_button_new_with_mnemonic (_("Due date"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_due_date_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_due_date_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_due_date_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_due_date_checkbutton, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->vc_type_checkbutton = gtk_check_button_new_with_mnemonic (_("Type"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_type_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_type_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_type_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_type_checkbutton, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->vc_priority_checkbutton = gtk_check_button_new_with_mnemonic (_("Priority"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_priority_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_priority_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_priority_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_priority_checkbutton, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->vc_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Category"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_category_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_category_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_category_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_category_checkbutton, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Categories"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
categories_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (categories_vbox);
gtk_container_add (GTK_CONTAINER (alignment), categories_vbox);
tasks_category_table = gtk_table_new (4, 3, FALSE);
gtk_widget_show (tasks_category_table);
gtk_box_pack_start (GTK_BOX (categories_vbox), tasks_category_table, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (tasks_category_table), 8);
gtk_table_set_row_spacings (GTK_TABLE (tasks_category_table), 8);
gtk_table_set_col_spacings (GTK_TABLE (tasks_category_table), 4);
appGUI->opt->tasks_category_entry = gtk_entry_new ();
gtk_widget_show (appGUI->opt->tasks_category_entry);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_entry, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_entry), "key_release_event",
G_CALLBACK (tasks_category_entry_key_release_cb), appGUI);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_table_attach (GTK_TABLE (tasks_category_table), scrolledwindow, 0, 3, 0, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN);
appGUI->opt->tasks_category_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
appGUI->opt->tasks_category_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->opt->tasks_category_store));
appGUI->opt->tasks_category_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview));
gtk_widget_show (appGUI->opt->tasks_category_treeview);
g_signal_connect(G_OBJECT(appGUI->opt->tasks_category_select), "changed",
G_CALLBACK(tasks_category_selected_cb), appGUI);
gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->opt->tasks_category_treeview);
gtk_container_set_border_width (GTK_CONTAINER (appGUI->opt->tasks_category_treeview), 4);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), TRUE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), FALSE);
gtk_widget_set_size_request (appGUI->opt->tasks_category_treeview, -1, 120);
renderer = gtk_cell_renderer_text_new();
g_object_set (renderer, "editable", TRUE, "editable-set", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (tasks_category_cell_edited_cb), appGUI);
column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", TC_COLUMN_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
gtk_tree_view_column_set_expand (column, TRUE);
renderer = gtk_cell_renderer_toggle_new(); /* Show in calendar */
column = gtk_tree_view_column_new_with_attributes(_("Calendar"), renderer, "active", TC_COLUMN_CALENDAR, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_calendar_toggled), appGUI);
renderer = gtk_cell_renderer_toggle_new(); /* Show in tasks list */
column = gtk_tree_view_column_new_with_attributes(_("Tasks"), renderer, "active", TC_COLUMN_TASKS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_tasks_list_toggled), appGUI);
if (config.default_stock_icons) {
appGUI->opt->tasks_category_add_button = utl_gui_stock_button (GTK_STOCK_ADD, FALSE);
} else {
appGUI->opt->tasks_category_add_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_ADD, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_add_button, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_category_add_button);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_add_button, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect(appGUI->opt->tasks_category_add_button, "clicked",
G_CALLBACK(tasks_category_add_cb), appGUI);
gtk_widget_set_sensitive(appGUI->opt->tasks_category_add_button, FALSE);
if (config.default_stock_icons) {
appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (GTK_STOCK_REMOVE, FALSE);
} else {
appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_REMOVE, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_remove_button, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_category_remove_button);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_remove_button, 2, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect(appGUI->opt->tasks_category_remove_button, "clicked",
G_CALLBACK(tasks_category_remove_cb), appGUI);
gtk_widget_set_sensitive(appGUI->opt->tasks_category_remove_button, FALSE);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Sorting"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
sorting_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (sorting_vbox);
gtk_container_add (GTK_CONTAINER (alignment), sorting_vbox);
table = gtk_table_new (1, 5, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (sorting_vbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
sprintf(tmpbuf, "%s:", _("Order"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
sprintf(tmpbuf, "%s:", _("Mode"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->opt->tasks_sort_order_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->opt->tasks_sort_order_combobox);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_order_combobox), "changed",
G_CALLBACK(tasks_sort_order_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_order_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Ascending"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Descending"));
gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_order_combobox), config.tasks_sorting_order);
appGUI->opt->tasks_sort_mode_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->opt->tasks_sort_mode_combobox);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_mode_combobox), "changed",
G_CALLBACK(tasks_sort_mode_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_mode_combobox, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Due date"), _("Priority"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Priority"), _("Due date"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Due date"), _("Done"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Done"), _("Due date"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Priority"), _("Done"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Done"), _("Priority"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_mode_combobox), config.tasks_sorting_mode);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Tasks options"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
tasks_opt_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (tasks_opt_vbox);
gtk_container_add (GTK_CONTAINER (alignment), tasks_opt_vbox);
appGUI->opt->ct_hide_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Hide completed tasks"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_hide_items_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_hide_items_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled",
G_CALLBACK (hide_delete_changed_cb), appGUI);
gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_hide_items_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled",
G_CALLBACK (hide_items_cb), appGUI);
appGUI->opt->ct_delete_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Delete completed tasks without confirmation"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_delete_items_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_delete_items_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled",
G_CALLBACK (hide_delete_changed_cb), appGUI);
gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_delete_items_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled",
G_CALLBACK (delete_items_cb), appGUI);
appGUI->opt->ct_add_item_checkbutton = gtk_check_button_new_with_mnemonic (_("Add new task when double clicked on tasks list"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_add_item_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_add_item_checkbutton);
gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_add_item_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_add_item_checkbutton), "toggled",
G_CALLBACK (add_item_cb), appGUI);
appGUI->opt->ct_remember_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Remember the last selected category"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_remember_category_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_remember_category_checkbutton);
gtk_box_pack_start (GTK_BOX (tasks_opt_vbox), appGUI->opt->ct_remember_category_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_remember_category_checkbutton), "toggled",
G_CALLBACK (remember_category_cb), appGUI);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
g_snprintf (tmpbuf, BUFFER_SIZE, "<b>%s</b>", _("Reminder options"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
table = gtk_table_new (2, 4, FALSE);
gtk_widget_show (table);
gtk_container_add (GTK_CONTAINER (alignment), table);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 8);
g_snprintf (tmpbuf, BUFFER_SIZE, "%s:", _("Postpone time"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
postpone_time_spinbutton_adj = gtk_adjustment_new (0, 0, 1440, 1, 10, 0);
appGUI->opt->postpone_time_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (postpone_time_spinbutton_adj), 1, 0);
g_signal_connect (G_OBJECT (appGUI->opt->postpone_time_spinbutton), "value-changed",
G_CALLBACK (postpone_time_changed_cb), appGUI);
gtk_widget_show (appGUI->opt->postpone_time_spinbutton);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->postpone_time_spinbutton, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (appGUI->opt->postpone_time_spinbutton), TRUE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(appGUI->opt->postpone_time_spinbutton), config.postpone_time);
g_snprintf (tmpbuf, BUFFER_SIZE, "%s (%s)", _("minutes"), _("0 for disable"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
g_snprintf (tmpbuf, BUFFER_SIZE, "%s:", _("Global notification command"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
valid_hbox = gtk_hbox_new (FALSE, 2);
gtk_widget_show (valid_hbox);
gtk_table_attach (GTK_TABLE (table), valid_hbox, 1, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
appGUI->opt->global_notification_cmd_entry = gtk_entry_new ();
gtk_widget_show (appGUI->opt->global_notification_cmd_entry);
g_signal_connect (G_OBJECT (appGUI->opt->global_notification_cmd_entry), "key_release_event",
G_CALLBACK (global_notification_entry_key_release_cb), appGUI);
gtk_box_pack_start (GTK_BOX (valid_hbox), appGUI->opt->global_notification_cmd_entry, TRUE, TRUE, 0);
appGUI->opt->global_notification_valid_image = gtk_image_new ();
gtk_widget_show (appGUI->opt->global_notification_valid_image);
gtk_box_pack_start (GTK_BOX (valid_hbox), appGUI->opt->global_notification_valid_image, FALSE, FALSE, 0);
}
void
FormDialog::multiple_choice (const std::string name,
const std::string description,
const std::set<std::string> values,
const std::map<std::string, std::string> choices,
bool advanced)
{
GtkWidget *label = NULL;
GtkWidget *scroll = NULL;
GtkWidget *tree_view = NULL;
GtkWidget *frame = NULL;
GtkListStore *list_store = NULL;
GtkTreeViewColumn *column = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeIter iter;
gchar *label_text = NULL;
MultipleChoiceSubmitter *submitter = NULL;
grow_fields (advanced);
/* The label */
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
label_text = g_strdup_printf ("<b>%s</b>", description.c_str());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
g_free (label_text);
/* The GtkListStore containing the choices */
tree_view = gtk_tree_view_new ();
list_store = gtk_list_store_new (MultipleChoiceSubmitter::COLUMN_NUMBER,
G_TYPE_BOOLEAN, G_TYPE_STRING);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
frame = gtk_frame_new (NULL);
gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (frame), scroll);
gtk_container_add (GTK_CONTAINER (scroll), tree_view);
renderer = gtk_cell_renderer_toggle_new ();
column =
gtk_tree_view_column_new_with_attributes (NULL, renderer,
"active", MultipleChoiceSubmitter::COLUMN_ACTIVE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
g_signal_connect (renderer, "toggled",
G_CALLBACK (multiple_choice_choice_toggled_cb), list_store);
renderer = gtk_cell_renderer_text_new ();
column =
gtk_tree_view_column_new_with_attributes (NULL, renderer,
"text", MultipleChoiceSubmitter::COLUMN_NAME,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
for (std::map<std::string, std::string>::const_iterator map_iter
= choices.begin ();
map_iter != choices.end ();
map_iter++) {
bool active = (std::find (values.begin (), values.end (), map_iter->first) != values.end ());
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
MultipleChoiceSubmitter::COLUMN_ACTIVE, active,
MultipleChoiceSubmitter::COLUMN_NAME, map_iter->second.c_str (),
-1);
}
if (advanced) {
gtk_table_attach (GTK_TABLE (advanced_fields), label,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
gtk_table_attach (GTK_TABLE (advanced_fields), frame,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
} else {
gtk_table_attach (GTK_TABLE (fields), label,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
gtk_table_attach (GTK_TABLE (fields), frame,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
}
submitter = new MultipleChoiceSubmitter (name, description,
choices, advanced, tree_view);
submitters.push_back (submitter);
}
void
FormDialog::editable_set (const std::string name,
const std::string description,
const std::set<std::string> values,
const std::set<std::string> proposed_values,
bool advanced)
{
GtkWidget *label = NULL;
GtkWidget *scroll = NULL;
GtkWidget *button = NULL;
GtkWidget *tree_view = NULL;
GtkWidget *frame = NULL;
GtkWidget *hbox = NULL;
GtkWidget *entry = NULL;
GtkListStore *list_store = NULL;
GtkTreeViewColumn *column = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeIter iter;
gchar *label_text = NULL;
EditableSetSubmitter *submitter = NULL;
/* The label */
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
label_text = g_strdup_printf ("<b>%s</b>", description.c_str());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
g_free (label_text);
/* The GtkListStore containing the values */
list_store = gtk_list_store_new (EditableSetSubmitter::COLUMN_NUMBER,
G_TYPE_BOOLEAN, G_TYPE_STRING);
tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
frame = gtk_frame_new (NULL);
gtk_widget_set_size_request (GTK_WIDGET (frame), -1, 125);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (frame), scroll);
gtk_container_add (GTK_CONTAINER (scroll), tree_view);
renderer = gtk_cell_renderer_toggle_new ();
column =
gtk_tree_view_column_new_with_attributes (NULL, renderer,
"active", EditableSetSubmitter::COLUMN_ACTIVE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
g_signal_connect (renderer, "toggled",
G_CALLBACK (editable_set_choice_toggled_cb), list_store);
renderer = gtk_cell_renderer_text_new ();
column =
gtk_tree_view_column_new_with_attributes (NULL, renderer,
"text", EditableSetSubmitter::COLUMN_VALUE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
for (std::set<std::string>::const_iterator set_iter = values.begin ();
set_iter != values.end ();
set_iter++) {
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
EditableSetSubmitter::COLUMN_ACTIVE, TRUE,
EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (),
-1);
}
for (std::set<std::string>::const_iterator set_iter
= proposed_values.begin ();
set_iter != proposed_values.end ();
set_iter++) {
if (values.find (*set_iter) == values.end ()) {
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
EditableSetSubmitter::COLUMN_ACTIVE, FALSE,
EditableSetSubmitter::COLUMN_VALUE, set_iter->c_str (),
-1);
}
}
if (advanced) {
grow_fields (advanced);
gtk_table_attach (GTK_TABLE (advanced_fields), label,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
grow_fields (advanced);
gtk_table_attach (GTK_TABLE (advanced_fields), frame,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
} else {
grow_fields (advanced);
gtk_table_attach (GTK_TABLE (fields), label,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
grow_fields (advanced);
gtk_table_attach (GTK_TABLE (fields), frame,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
}
hbox = gtk_hbox_new (FALSE, 2);
entry = gtk_entry_new ();
button = gtk_button_new_from_stock (GTK_STOCK_ADD);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
g_signal_connect (entry, "activate",
(GCallback) editable_set_add_value_activated_cb,
(gpointer) tree_view);
g_signal_connect (button, "clicked",
(GCallback) editable_set_add_value_clicked_cb,
(gpointer) entry);
grow_fields (advanced);
if (advanced) {
gtk_table_attach (GTK_TABLE (advanced_fields), hbox,
0, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
} else {
gtk_table_attach (GTK_TABLE (fields), hbox,
0, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
}
submitter = new EditableSetSubmitter (name, description, advanced, tree_view);
submitters.push_back (submitter);
}
/**
* empathy_irc_network_dialog_show:
* @network: the #EmpathyIrcNetwork to configure
* @parent: the parent of this dialog
*
* Display a dialog to configure a given #EmpathyIrcNetwork.
* This function is a singleton so if a configuration dialog already
* exists we use this one to edit the network.
*
* Returns: The displayed #GtkDialog
*/
GtkWidget *
empathy_irc_network_dialog_show (EmpathyIrcNetwork *network,
GtkWidget *parent)
{
static EmpathyIrcNetworkDialog *dialog = NULL;
GtkBuilder *gui;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkAdjustment *adjustment;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gchar *filename;
g_return_val_if_fail (network != NULL, NULL);
if (dialog != NULL)
{
change_network (dialog, network);
gtk_window_present (GTK_WINDOW (dialog->dialog));
return dialog->dialog;
}
dialog = g_slice_new0 (EmpathyIrcNetworkDialog);
dialog->network = network;
g_object_ref (dialog->network);
filename = empathy_file_lookup ("empathy-account-widget-irc.ui",
"libempathy-gtk");
gui = empathy_builder_get_file (filename,
"irc_network_dialog", &dialog->dialog,
"button_close", &dialog->button_close,
"entry_network", &dialog->entry_network,
"combobox_charset", &dialog->combobox_charset,
"treeview_servers", &dialog->treeview_servers,
"button_add", &dialog->button_add,
"button_remove", &dialog->button_remove,
"button_up", &dialog->button_up,
"button_down", &dialog->button_down,
NULL);
g_free (filename);
store = gtk_list_store_new (4, G_TYPE_OBJECT, G_TYPE_STRING,
G_TYPE_UINT, G_TYPE_BOOLEAN);
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview_servers),
GTK_TREE_MODEL (store));
g_object_unref (store);
/* address */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (irc_network_dialog_address_edited_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("Server"), renderer, "text", COL_ADR,
NULL);
/* port */
adjustment = (GtkAdjustment *) gtk_adjustment_new (6667, 1, G_MAXUINT16,
1, 10, 0);
renderer = gtk_cell_renderer_spin_new ();
g_object_set (renderer,
"editable", TRUE,
"adjustment", adjustment,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (irc_network_dialog_port_edited_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("Port"), renderer, "text", COL_PORT,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->treeview_servers),
1);
gtk_tree_view_column_set_expand (column, TRUE);
/* SSL */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "activatable", TRUE, NULL);
g_signal_connect (renderer, "toggled",
G_CALLBACK (irc_network_dialog_ssl_toggled_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("SSL"), renderer, "active", COL_SSL,
NULL);
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (dialog->treeview_servers));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
/* charset */
totem_subtitle_encoding_init (GTK_COMBO_BOX (dialog->combobox_charset));
irc_network_dialog_setup (dialog);
empathy_builder_connect (gui, dialog,
"irc_network_dialog", "destroy", irc_network_dialog_destroy_cb,
"button_close", "clicked", irc_network_dialog_close_clicked_cb,
"entry_network", "focus-out-event", irc_network_dialog_network_focus_cb,
"button_add", "clicked", irc_network_dialog_button_add_clicked_cb,
"button_remove", "clicked", irc_network_dialog_button_remove_clicked_cb,
"button_up", "clicked", irc_network_dialog_button_up_clicked_cb,
"button_down", "clicked", irc_network_dialog_button_down_clicked_cb,
"combobox_charset", "changed", irc_network_dialog_combobox_charset_changed_cb,
NULL);
g_object_unref (gui);
g_object_add_weak_pointer (G_OBJECT (dialog->dialog),
(gpointer) &dialog);
g_signal_connect (selection, "changed",
G_CALLBACK (irc_network_dialog_selection_changed_cb),
dialog);
gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog),
GTK_WINDOW (parent));
gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE);
irc_network_dialog_network_update_buttons (dialog);
gtk_widget_show_all (dialog->dialog);
return dialog->dialog;
}
static void
add_columns (GtkTreeView *treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
/* column for fixed toggles */
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (fixed_toggled), model);
column = gtk_tree_view_column_new_with_attributes ("Fixed?",
renderer,
"active", COLUMN_FIXED,
NULL);
/* set this column to a fixed sizing (of 50 pixels) */
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
gtk_tree_view_append_column (treeview, column);
/* column for bug numbers */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Bug number",
renderer,
"text",
COLUMN_NUMBER,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_NUMBER);
gtk_tree_view_append_column (treeview, column);
/* column for severities */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Severity",
renderer,
"text",
COLUMN_SEVERITY,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_SEVERITY);
gtk_tree_view_append_column (treeview, column);
/* column for description */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Description",
renderer,
"text",
COLUMN_DESCRIPTION,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_DESCRIPTION);
gtk_tree_view_append_column (treeview, column);
/* column for spinner */
renderer = gtk_cell_renderer_spinner_new ();
column = gtk_tree_view_column_new_with_attributes ("Spinning",
renderer,
"pulse",
COLUMN_PULSE,
"active",
COLUMN_ACTIVE,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_PULSE);
gtk_tree_view_append_column (treeview, column);
/* column for symbolic icon */
renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes ("Symbolic icon",
renderer,
"icon-name",
COLUMN_ICON,
"sensitive",
COLUMN_SENSITIVE,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_ICON);
gtk_tree_view_append_column (treeview, column);
}
GtkWidget *
module_dialog_new (Gimp *gimp)
{
GtkWidget *shell;
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *view;
GtkWidget *image;
ModuleDialog *dialog;
GtkTreeSelection *sel;
GtkTreeIter iter;
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
dialog = g_slice_new0 (ModuleDialog);
dialog->gimp = gimp;
shell = gimp_dialog_new (_("Module Manager"),
"gimp-modules", NULL, 0,
gimp_standard_help_func, GIMP_HELP_MODULE_DIALOG,
GTK_STOCK_REFRESH, RESPONSE_REFRESH,
GTK_STOCK_CLOSE, GTK_STOCK_CLOSE,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell),
GTK_RESPONSE_CLOSE,
RESPONSE_REFRESH,
-1);
g_signal_connect (shell, "response",
G_CALLBACK (dialog_response),
dialog);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
dialog->hint = gimp_hint_box_new (_("You will have to restart GIMP "
"for the changes to take effect."));
gtk_box_pack_start (GTK_BOX (vbox), dialog->hint, FALSE, FALSE, 0);
if (gimp->write_modulerc)
gtk_widget_show (dialog->hint);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_widget_set_size_request (sw, 124, 100);
gtk_widget_show (sw);
dialog->list = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
GIMP_TYPE_MODULE);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list));
g_object_unref (dialog->list);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
g_list_foreach (gimp->module_db->modules, make_list_item, dialog);
rend = gtk_cell_renderer_toggle_new ();
g_signal_connect (rend, "toggled",
G_CALLBACK (dialog_enabled_toggled),
dialog);
col = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "active", COLUMN_ENABLED);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1,
_("Module"),
gtk_cell_renderer_text_new (),
"text", COLUMN_NAME,
NULL);
gtk_container_add (GTK_CONTAINER (sw), view);
gtk_widget_show (view);
dialog->table = gtk_table_new (2, N_INFOS, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (dialog->table), 6);
gtk_box_pack_start (GTK_BOX (vbox), dialog->table, FALSE, FALSE, 0);
gtk_widget_show (dialog->table);
dialog->error_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), dialog->error_box, FALSE, FALSE, 0);
image = gtk_image_new_from_stock (GIMP_STOCK_WARNING, GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (dialog->error_box), image, FALSE, FALSE, 0);
gtk_widget_show (image);
dialog->error_label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (dialog->error_label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (dialog->error_box),
dialog->error_label, TRUE, TRUE, 0);
gtk_widget_show (dialog->error_label);
dialog_info_init (dialog, dialog->table);
dialog_info_update (gimp->module_db, dialog->selected, dialog);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (sel, "changed",
G_CALLBACK (dialog_select_callback),
dialog);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->list), &iter))
gtk_tree_selection_select_iter (sel, &iter);
/* hook the GimpModuleDB signals so we can refresh the display
* appropriately.
*/
g_signal_connect (gimp->module_db, "add",
G_CALLBACK (dialog_info_add),
dialog);
g_signal_connect (gimp->module_db, "remove",
G_CALLBACK (dialog_info_remove),
dialog);
g_signal_connect (gimp->module_db, "module-modified",
G_CALLBACK (dialog_info_update),
dialog);
g_signal_connect (shell, "destroy",
G_CALLBACK (dialog_destroy_callback),
dialog);
return shell;
}
/*! \brief Adds a treeview to confirmation dialog for selecting of pages.
* \par Function Description
* This function adds a treeview and caption to display the content
* of the dialog model of pages with unsaved changes.
*
* The treeview displays the page names with check boxes.
*
* \param [in] dialog The dialog.
* \returns A pointer on the GtkVBox to add to dialog.
*/
static GtkWidget*
close_confirmation_dialog_build_page_list (CloseConfirmationDialog *dialog)
{
GtkWidget *vbox, *scrolled_window, *treeview, *label;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
const gchar *text;
/* place the treeview and its caption into their own box */
vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
/* GtkBox */
"homogeneous", FALSE,
"spacing", 8,
NULL));
/* the list of pages with changes */
/* - scrolled window as container for the treeview first */
scrolled_window = GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
/* GtkScrolledWindow */
"hscrollbar-policy", GTK_POLICY_AUTOMATIC,
"vscrollbar-policy", GTK_POLICY_AUTOMATIC,
"shadow-type", GTK_SHADOW_IN,
NULL));
/* - then the treeview */
/* create model for treeview and populate */
treeview = GTK_WIDGET (g_object_new (GTK_TYPE_TREE_VIEW,
/* GtkTreeView */
"enable-search", FALSE,
"headers-visible", FALSE,
"model", dialog->store_unsaved_pages,
NULL));
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (
close_confirmation_dialog_callback_renderer_toggled),
dialog);
column = gtk_tree_view_column_new_with_attributes ("Save?",
renderer,
"active", COLUMN_SAVE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
renderer = gtk_cell_renderer_text_new ();
column = GTK_TREE_VIEW_COLUMN (
g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
/* GtkTreeViewColumn */
"title", _("Name"),
NULL));
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
close_confirmation_dialog_set_page_name,
NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
gtk_box_pack_end (GTK_BOX (vbox), scrolled_window,
TRUE, TRUE, 0);
/* the caption label above the list of pages */
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
/* GtkMisc */
"xalign", 0.0,
"yalign", 0.0,
/* GtkLabel */
"wrap", TRUE,
"mnemonic-widget", treeview,
NULL));
text = _("S_elect the schematics you want to save:");
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), text);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
gtk_box_pack_start (GTK_BOX (vbox), label,
FALSE, FALSE, 0);
return vbox;
}
/* A dialog to allow a user to select which unsaved files to save
* (if any) or to abort exiting
*
* @param parent_window This is needed for modal behavior.
* @param title Text display on the dialog's title bar.
* @return The dialog.
*/
GtkWidget *
exit_dialog_make (GtkWindow * parent_window,
gchar * title)
{
GtkWidget * dialog = gtk_dialog_new_with_buttons (title, parent_window,
GTK_DIALOG_MODAL,
_("Do Not Exit"),
EXIT_DIALOG_EXIT_CANCEL,
_("Exit Without Save"),
EXIT_DIALOG_EXIT_NO_SAVE,
_("Save Selected"),
EXIT_DIALOG_EXIT_SAVE_SELECTED,
NULL);
GtkBox * vbox = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG(dialog)));
GtkWidget * label = gtk_label_new (_("The following are not saved:"));
GtkWidget * scrolled;
GtkWidget * button;
GtkWidget * hbox;
GtkWidget * treeview;
GtkListStore * model;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
GdkGeometry geometry = { 0 };
gtk_box_pack_start (vbox, label, FALSE, FALSE, 0);
gtk_widget_show (label);
/* Scrolled window for displaying things which need saving */
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (vbox, scrolled, TRUE, TRUE, 0);
gtk_widget_show (scrolled);
model = gtk_list_store_new (NUM_COL, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL(model));
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes (_("Save"), renderer,
"active", CHECK_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (toggle_check_button),
treeview);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer,
"text", NAME_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Path"), renderer,
"text", PATH_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled), GTK_WIDGET (treeview));
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
button = gtk_button_new_with_label (_("Select All"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 3);
gtk_widget_show (button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (select_all_clicked),
treeview);
button = gtk_button_new_with_label (_("Select None"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 3);
gtk_widget_show (button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (select_none_clicked),
treeview);
g_object_unref (model);
gtk_widget_show (GTK_WIDGET (treeview));
gtk_widget_show_all (GTK_WIDGET(vbox));
g_object_set_data (G_OBJECT (dialog), EXIT_DIALOG_TREEVIEW, treeview);
g_signal_connect (G_OBJECT (dialog), "destroy",
G_CALLBACK (exit_dialog_destroy),
treeview);
/* golden ratio */
geometry.min_aspect = 0.618;
geometry.max_aspect = 1.618;
geometry.win_gravity = GDK_GRAVITY_CENTER;
gtk_window_set_geometry_hints (GTK_WINDOW (dialog), GTK_WIDGET (vbox), &geometry,
GDK_HINT_ASPECT|GDK_HINT_WIN_GRAVITY);
return dialog;
}
static void
set_columns_type (GtkTreeView *tree_view, ColumnsType type)
{
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
GdkPixbuf *pixbuf;
GtkWidget *image;
GtkObject *adjustment;
current_column_type = type;
col = gtk_tree_view_get_column (tree_view, 0);
while (col)
{
gtk_tree_view_remove_column (tree_view, col);
col = gtk_tree_view_get_column (tree_view, 0);
}
gtk_tree_view_set_rules_hint (tree_view, FALSE);
switch (type)
{
case COLUMNS_NONE:
break;
case COLUMNS_LOTS:
/* with lots of columns we need to turn on rules */
gtk_tree_view_set_rules_hint (tree_view, TRUE);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 1",
rend,
"text", 1,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (col, "Column 2");
rend = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2);
rend = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, rend, TRUE);
gtk_tree_view_column_add_attribute (col, rend, "text", 0);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
gtk_tree_view_set_expander_column (tree_view, col);
rend = gtk_cell_renderer_toggle_new ();
g_signal_connect (rend, "toggled",
G_CALLBACK (toggled_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 3",
rend,
"active", BOOL_COLUMN,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
image = gtk_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
gtk_widget_show (image);
gtk_tree_view_column_set_widget (col, image);
rend = gtk_cell_renderer_toggle_new ();
/* you could also set this per-row by tying it to a column
* in the model of course.
*/
g_object_set (rend, "radio", TRUE, NULL);
g_signal_connect (rend, "toggled",
G_CALLBACK (toggled_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 4",
rend,
"active", BOOL_COLUMN,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_spin_new ();
adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100);
g_object_set (rend, "editable", TRUE, NULL);
g_object_set (rend, "adjustment", adjustment, NULL);
g_signal_connect (rend, "edited",
G_CALLBACK (edited_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 5",
rend,
"text", 4,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#if 0
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 6",
rend,
"text", 4,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 7",
rend,
"text", 5,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 8",
rend,
"text", 6,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 9",
rend,
"text", 7,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 10",
rend,
"text", 8,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#endif
/* FALL THRU */
case COLUMNS_ONE:
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 0",
rend,
"text", 0,
NULL);
setup_column (col);
gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
default:
break;
}
}
/*
* create variables tree view widget
* arguments:
* on_render_name - custom name column renderer function
* on_expression_changed - callback to call on expression changed
*/
GtkWidget* vtree_create(watch_render_name on_render_name, watch_expression_changed on_expression_changed)
{
/* create tree view */
GtkTreeStore* store = gtk_tree_store_new (
W_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
GtkWidget* tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
g_object_unref(store);
/* set tree view parameters */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_level_indentation(GTK_TREE_VIEW(tree), 10);
/* connect signals */
if (NULL != on_key_pressed)
{
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
}
/* create columns */
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* Name */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_end(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "text", W_NAME, NULL);
GtkCellRenderer *icon_renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set(icon_renderer, "follow-state", TRUE, NULL);
gtk_tree_view_column_pack_end(column, icon_renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, icon_renderer, render_icon, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
if (on_render_name)
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_name, NULL, NULL);
if (on_expression_changed)
{
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (on_expression_changed), NULL);
}
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Value */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Value"), renderer, "text", W_VALUE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, render_value, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Type */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Type"), renderer, "text", W_TYPE, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last invisible column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", W_LAST_VISIBLE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Internal (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Internal", renderer, "text", W_INTERNAL, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Path expression (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Expression", renderer, "text", W_EXPRESSION, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* STUB (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Need Update", renderer, "active", W_STUB, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
/* Changed (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Changed", renderer, "active", W_CHANGED, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
return tree;
}
static GtkCellEditable *
cg_cell_renderer_flags_start_editing (GtkCellRenderer *cell,
G_GNUC_UNUSED GdkEvent *event,
G_GNUC_UNUSED GtkWidget *widget,
const gchar *path,
G_GNUC_UNUSED const GdkRectangle *background_area,
G_GNUC_UNUSED const GdkRectangle *cell_area,
G_GNUC_UNUSED GtkCellRendererState flags)
{
CgCellRendererFlags *cell_flags;
CgCellRendererFlagsPrivate *priv;
GtkCellRendererText *cell_text;
gboolean editable;
gchar *text;
const gchar *prev;
const gchar *pos;
GtkWidget *combo;
GtkCellRenderer *cell_combo_set;
GtkCellRenderer *cell_combo_text;
cell_flags = CG_CELL_RENDERER_FLAGS (cell);
priv = CG_CELL_RENDERER_FLAGS_PRIVATE (cell_flags);
cell_text = GTK_CELL_RENDERER_TEXT (cell);
g_object_get (cell_text,
"editable", &editable,
"text", &text,
NULL);
if (editable == FALSE) return NULL;
if (priv->model == NULL || priv->text_column < 0 || priv->abbr_column < 0)
return NULL;
cell_combo_set = gtk_cell_renderer_toggle_new ();
cell_combo_text = gtk_cell_renderer_text_new ();
combo = cg_combo_flags_new_with_model (priv->model);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo),
cell_combo_set, FALSE);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo),
cell_combo_text, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo),
cell_combo_text, "text", priv->text_column);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo),
cell_combo_set,
cg_cell_renderer_flags_set_data_func,
cell_flags, NULL);
g_object_set (G_OBJECT (cell_combo_set), "activatable", FALSE, NULL);
/* Create hash table with current status. We could also operate
* directly on a string here, but a hash table is probably more
* efficient. */
g_assert (priv->edit_status == NULL);
priv->edit_status = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free, NULL);
pos = text;
prev = text;
while (prev != NULL && *prev != '\0')
{
while (*pos != '|' && *pos != '\0') ++ pos;
g_hash_table_insert (priv->edit_status, g_strndup(prev, pos - prev),
GINT_TO_POINTER(1));
if(*pos != '\0') ++ pos;
prev = pos;
}
g_free (text);
g_object_set_data_full (G_OBJECT (combo), CG_CELL_RENDERER_FLAGS_PATH,
g_strdup (path), g_free);
gtk_widget_show (combo);
g_signal_connect (G_OBJECT (combo), "editing-done",
G_CALLBACK (cg_cell_renderer_flags_editing_done),
cell_flags);
g_signal_connect (G_OBJECT (combo), "selected",
G_CALLBACK (cg_cell_renderer_flags_selected),
cell_flags);
priv->focus_out_id =
g_signal_connect (G_OBJECT (combo), "focus_out_event",
G_CALLBACK (cg_cell_renderer_flags_focus_out_event),
cell_flags);
return GTK_CELL_EDITABLE (combo);
}
// show a popup window with a list of updated images/xmp files and allow the user to tell dt what to do about
// them
void dt_control_crawler_show_image_list(GList *images)
{
if(!images) return;
dt_control_crawler_gui_t *gui = (dt_control_crawler_gui_t *)malloc(sizeof(dt_control_crawler_gui_t));
// a list with all the images
GtkTreeViewColumn *column;
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_vexpand(scroll, TRUE);
GtkListStore *store = gtk_list_store_new(DT_CONTROL_CRAWLER_NUM_COLS,
G_TYPE_BOOLEAN, // selection toggle
G_TYPE_INT, // id
G_TYPE_STRING, // image path
G_TYPE_STRING, // xmp path
G_TYPE_STRING, // timestamp from xmp
G_TYPE_STRING // timestamp from db
);
gui->model = GTK_TREE_MODEL(store);
GList *list_iter = g_list_first(images);
while(list_iter)
{
GtkTreeIter iter;
dt_control_crawler_result_t *item = list_iter->data;
char timestamp_db[64], timestamp_xmp[64];
strftime(timestamp_db, sizeof(timestamp_db), "%c", localtime(&item->timestamp_db));
strftime(timestamp_xmp, sizeof(timestamp_xmp), "%c", localtime(&item->timestamp_xmp));
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, DT_CONTROL_CRAWLER_COL_SELECTED, 0, DT_CONTROL_CRAWLER_COL_ID, item->id,
DT_CONTROL_CRAWLER_COL_IMAGE_PATH, item->image_path, DT_CONTROL_CRAWLER_COL_XMP_PATH,
item->xmp_path, DT_CONTROL_CRAWLER_COL_TS_XMP, timestamp_xmp,
DT_CONTROL_CRAWLER_COL_TS_DB, timestamp_db, -1);
g_free(item->image_path);
g_free(item->xmp_path);
list_iter = g_list_next(list_iter);
}
g_list_free_full(images, g_free);
GtkWidget *tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(renderer, "toggled", G_CALLBACK(_select_toggled_callback), gui);
column = gtk_tree_view_column_new_with_attributes(_("select"), renderer, "active",
DT_CONTROL_CRAWLER_COL_SELECTED, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
column = gtk_tree_view_column_new_with_attributes(_("path"), gtk_cell_renderer_text_new(), "text",
DT_CONTROL_CRAWLER_COL_IMAGE_PATH, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
column = gtk_tree_view_column_new_with_attributes(_("xmp timestamp"), gtk_cell_renderer_text_new(), "text",
DT_CONTROL_CRAWLER_COL_TS_XMP, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
column = gtk_tree_view_column_new_with_attributes(_("database timestamp"), gtk_cell_renderer_text_new(),
"text", DT_CONTROL_CRAWLER_COL_TS_DB, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_container_add(GTK_CONTAINER(scroll), tree);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
// build a dialog window that contains the list of images
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *dialog = gtk_dialog_new_with_buttons(_("updated xmp sidecar files found"), GTK_WINDOW(win),
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
_("_close"), GTK_RESPONSE_CLOSE, NULL);
gtk_widget_set_size_request(dialog, -1, DT_PIXEL_APPLY_DPI(400));
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(win));
GtkWidget *content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget *content_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_widget_set_margin_start(content_box, DT_PIXEL_APPLY_DPI(10));
gtk_widget_set_margin_end(content_box, DT_PIXEL_APPLY_DPI(10));
gtk_widget_set_margin_top(content_box, DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_bottom(content_box, DT_PIXEL_APPLY_DPI(0));
gtk_container_add(GTK_CONTAINER(content_area), content_box);
gtk_box_pack_start(GTK_BOX(content_box), scroll, TRUE, TRUE, 0);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(content_box), box, FALSE, FALSE, 0);
GtkWidget *select_all = gtk_check_button_new_with_label(_("select all"));
gtk_box_pack_start(GTK_BOX(box), select_all, FALSE, FALSE, 0);
gui->select_all_handler_id = g_signal_connect(select_all, "toggled", G_CALLBACK(_select_all_callback), gui);
gui->select_all = select_all;
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(content_box), box, FALSE, FALSE, 0);
GtkWidget *reload_button = gtk_button_new_with_label(_("reload selected xmp files"));
GtkWidget *overwrite_button = gtk_button_new_with_label(_("overwrite selected xmp files"));
gtk_box_pack_start(GTK_BOX(box), reload_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), overwrite_button, FALSE, FALSE, 0);
g_signal_connect(reload_button, "clicked", G_CALLBACK(_reload_button_clicked), gui);
g_signal_connect(overwrite_button, "clicked", G_CALLBACK(_overwrite_button_clicked), gui);
gtk_widget_show_all(dialog);
g_signal_connect(dialog, "response", G_CALLBACK(dt_control_crawler_response_callback), gui);
}
/**
* cact_providers_list_create_model:
* @treeview: the #GtkTreeView.
*
* Create the treeview model when initially loading the widget from
* the UI manager.
*/
void
cact_providers_list_create_model( GtkTreeView *treeview )
{
static const char *thisfn = "cact_providers_list_create_model";
GtkListStore *model;
GtkCellRenderer *toggled_cell;
GtkTreeViewColumn *column;
GtkCellRenderer *text_cell;
GtkTreeSelection *selection;
ProvidersListData *data;
g_return_if_fail( GTK_IS_TREE_VIEW( treeview ));
g_debug( "%s: treeview=%p", thisfn, ( void * ) treeview );
data = get_providers_list_data( treeview );
model = gtk_list_store_new( PROVIDER_N_COLUMN,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_OBJECT );
gtk_tree_view_set_model( treeview, GTK_TREE_MODEL( model ));
g_object_unref( model );
/* readable */
toggled_cell = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(
_( "Readable" ),
toggled_cell,
"active", PROVIDER_READABLE_COLUMN,
NULL );
gtk_tree_view_append_column( treeview, column );
/* readable mandatory */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column( treeview, column );
gtk_tree_view_column_set_visible( column, FALSE );
/* writable */
toggled_cell = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(
_( "Writable" ),
toggled_cell,
"active", PROVIDER_WRITABLE_COLUMN,
NULL );
gtk_tree_view_append_column( treeview, column );
/* writable mandatory */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column( treeview, column );
gtk_tree_view_column_set_visible( column, FALSE );
/* label */
text_cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_( "I/O Provider" ),
text_cell,
"text", PROVIDER_LIBELLE_COLUMN,
NULL );
gtk_tree_view_column_set_cell_data_func( column, text_cell, ( GtkTreeCellDataFunc ) display_label, data, NULL );
gtk_tree_view_append_column( treeview, column );
/* id */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column( treeview, column );
gtk_tree_view_column_set_visible( column, FALSE );
/* provider */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column( treeview, column );
gtk_tree_view_column_set_visible( column, FALSE );
gtk_tree_view_set_headers_visible( treeview, TRUE );
selection = gtk_tree_view_get_selection( treeview );
gtk_tree_selection_set_mode( selection, GTK_SELECTION_BROWSE );
}
int dt_gui_hist_dialog_new(dt_gui_hist_dialog_t *d, int imgid, gboolean iscopy)
{
int res;
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkDialog *dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(
_("select parts"), GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, _("_cancel"),
GTK_RESPONSE_CANCEL, _("select _all"), GTK_RESPONSE_YES, _("select _none"), GTK_RESPONSE_NONE, _("_ok"),
GTK_RESPONSE_OK, NULL));
#ifdef GDK_WINDOWING_QUARTZ
dt_osx_disallow_fullscreen(GTK_WIDGET(dialog));
#endif
GtkContainer *content_area = GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
GtkBox *box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 3));
gtk_widget_set_margin_start(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_end(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_top(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_bottom(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_container_add(content_area, GTK_WIDGET(box));
/* create the list of items */
d->items = GTK_TREE_VIEW(gtk_tree_view_new());
GtkListStore *liststore
= gtk_list_store_new(DT_HIST_ITEMS_NUM_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT);
/* enabled */
GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(renderer), TRUE);
g_object_set_data(G_OBJECT(renderer), "column", (gint *)DT_HIST_ITEMS_COL_ENABLED);
g_signal_connect(renderer, "toggled", G_CALLBACK(_gui_hist_item_toggled), d);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(d->items), -1, _("include"), renderer, "active",
DT_HIST_ITEMS_COL_ENABLED, NULL);
/* name */
renderer = gtk_cell_renderer_text_new();
g_object_set_data(G_OBJECT(renderer), "column", (gint *)DT_HIST_ITEMS_COL_NAME);
g_object_set(renderer, "xalign", 0.0, (gchar *)0);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(d->items), -1, _("item"), renderer, "text",
DT_HIST_ITEMS_COL_NAME, NULL);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->items)), GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(GTK_TREE_VIEW(d->items), GTK_TREE_MODEL(liststore));
gtk_box_pack_start(box, GTK_WIDGET(d->items), TRUE, TRUE, 0);
/* fill list with history items */
GtkTreeIter iter;
GList *items = dt_history_get_items(imgid, FALSE);
if(items)
{
do
{
dt_history_item_t *item = (dt_history_item_t *)items->data;
gtk_list_store_append(GTK_LIST_STORE(liststore), &iter);
gtk_list_store_set(GTK_LIST_STORE(liststore), &iter, DT_HIST_ITEMS_COL_ENABLED,
iscopy ? TRUE : _gui_is_set(d->selops, item->num), DT_HIST_ITEMS_COL_NAME,
item->name, DT_HIST_ITEMS_COL_NUM, (guint)item->num, -1);
} while((items = g_list_next(items)));
g_list_free_full(items, dt_history_item_free);
}
else
{
dt_control_log(_("can't copy history out of unaltered image"));
return GTK_RESPONSE_CANCEL;
}
g_object_unref(liststore);
g_signal_connect(dialog, "response", G_CALLBACK(_gui_hist_copy_response), d);
gtk_widget_show_all(GTK_WIDGET(dialog));
while(1)
{
res = gtk_dialog_run(GTK_DIALOG(dialog));
if(res == GTK_RESPONSE_CANCEL || res == GTK_RESPONSE_DELETE_EVENT || res == GTK_RESPONSE_OK) break;
}
gtk_widget_destroy(GTK_WIDGET(dialog));
return res;
}
static void
dialog_init (SortFlowState *state)
{
GtkTable *table;
GtkWidget *scrolled;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
gboolean col_rb;
GnmRange const *range;
table = GTK_TABLE (go_gtk_builder_get_widget (state->gui, "cell_sort_options_table"));
/* setup range entry */
state->range_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->range_entry,
GNM_EE_SINGLE_RANGE,
GNM_EE_MASK);
gtk_table_attach (table, GTK_WIDGET (state->range_entry),
2, 3, 1, 2,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
gnumeric_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->range_entry));
gnm_expr_entry_set_update_policy (state->range_entry, GTK_UPDATE_DISCONTINUOUS);
gtk_widget_show (GTK_WIDGET (state->range_entry));
g_signal_connect_swapped (G_OBJECT (state->range_entry),
"changed",
G_CALLBACK (cb_update_to_new_range), state);
state->locale_selector = GO_LOCALE_SEL (go_locale_sel_new ());
gtk_widget_show_all (GTK_WIDGET (state->locale_selector));
gtk_table_attach (table, GTK_WIDGET (state->locale_selector),
2, 3, 5, 6,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
table = GTK_TABLE (go_gtk_builder_get_widget (state->gui, "cell_sort_spec_table"));
/* setup add entry */
state->add_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->add_entry,
GNM_EE_SINGLE_RANGE,
GNM_EE_MASK);
gtk_table_attach (table, GTK_WIDGET (state->add_entry),
1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
gnumeric_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->add_entry));
gtk_widget_show (GTK_WIDGET (state->add_entry));
/* Set-up tree view */
scrolled = go_gtk_builder_get_widget (state->gui, "scrolled_cell_sort_list");
state->model = gtk_list_store_new (NUM_COLMNS, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_BOOLEAN,
GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_INT);
state->treeview = GTK_TREE_VIEW (
gtk_tree_view_new_with_model (GTK_TREE_MODEL (state->model)));
state->selection = gtk_tree_view_get_selection (state->treeview);
gtk_tree_selection_set_mode (state->selection, GTK_SELECTION_BROWSE);
g_signal_connect_swapped (state->selection,
"changed",
G_CALLBACK (cb_sort_selection_changed), state);
state->header_column = gtk_tree_view_column_new_with_attributes (_("Header"),
gtk_cell_renderer_text_new (),
"text", ITEM_HEADER, NULL);
gtk_tree_view_append_column (state->treeview, state->header_column);
column = gtk_tree_view_column_new_with_attributes (_("Row/Column"),
gtk_cell_renderer_text_new (),
"text", ITEM_NAME, NULL);
gtk_tree_view_append_column (state->treeview, column);
renderer = gnumeric_cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT (renderer),
"toggled",
G_CALLBACK (cb_toggled_descending), state);
column = gtk_tree_view_column_new_with_attributes ("",
renderer,
"active", ITEM_DESCENDING,
"pixbuf", ITEM_DESCENDING_IMAGE,
NULL);
gtk_tree_view_append_column (state->treeview, column);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT (renderer),
"toggled",
G_CALLBACK (cb_toggled_case_sensitive), state);
column = gtk_tree_view_column_new_with_attributes (_("Case Sensitive"),
renderer,
"active", ITEM_CASE_SENSITIVE, NULL);
gtk_tree_view_append_column (state->treeview, column);
gtk_tree_view_columns_autosize (state->treeview);
g_signal_connect (G_OBJECT (state->treeview),
"key_press_event",
G_CALLBACK (cb_treeview_keypress), state);
g_signal_connect (G_OBJECT (state->treeview),
"button_press_event",
G_CALLBACK (cb_treeview_button_press), state);
#if 0
/* We are currently not supporting `by-value' vs not. */
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT (renderer),
"toggled",
G_CALLBACK (cb_toggled_sort_by_value), state);
column = gtk_tree_view_column_new_with_attributes (_("By Value"),
renderer,
"active", ITEM_SORT_BY_VALUE, NULL);
gtk_tree_view_append_column (state->treeview, column);
#endif
gtk_tree_view_set_reorderable (state->treeview,TRUE);
gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (state->treeview));
gtk_widget_show (GTK_WIDGET (state->treeview));
/* Set-up other widgets */
state->cell_sort_row_rb = go_gtk_builder_get_widget (state->gui, "cell_sort_row_rb");
state->cell_sort_col_rb = go_gtk_builder_get_widget (state->gui, "cell_sort_col_rb");
g_signal_connect_swapped (G_OBJECT (state->cell_sort_row_rb),
"toggled",
G_CALLBACK (cb_update_to_new_range), state);
state->cell_sort_header_check = go_gtk_builder_get_widget (state->gui,
"cell_sort_header_check");
g_signal_connect_swapped (G_OBJECT (state->cell_sort_header_check),
"toggled",
G_CALLBACK (cb_sort_header_check), state);
state->retain_format_check = go_gtk_builder_get_widget (state->gui,
"retain_format_button");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->retain_format_check),
gnm_conf_get_core_sort_default_retain_formats ());
/* Set-up buttons */
state->up_button = go_gtk_builder_get_widget (state->gui, "up_button");
g_signal_connect_swapped (G_OBJECT (state->up_button),
"clicked",
G_CALLBACK (cb_up), state);
state->down_button = go_gtk_builder_get_widget (state->gui, "down_button");
g_signal_connect_swapped (G_OBJECT (state->down_button),
"clicked",
G_CALLBACK (cb_down), state);
state->add_button = go_gtk_builder_get_widget (state->gui, "add_button");
g_signal_connect_swapped (G_OBJECT (state->add_button),
"clicked",
G_CALLBACK (cb_add_clicked), state);
gtk_widget_set_sensitive (state->add_button, TRUE);
state->delete_button = go_gtk_builder_get_widget (state->gui, "delete_button");
g_signal_connect (G_OBJECT (state->delete_button),
"clicked",
G_CALLBACK (cb_delete_clicked), state);
gtk_widget_set_sensitive (state->delete_button, FALSE);
state->clear_button = go_gtk_builder_get_widget (state->gui, "clear_button");
g_signal_connect_swapped (G_OBJECT (state->clear_button),
"clicked",
G_CALLBACK (cb_clear_clicked), state);
gtk_widget_set_sensitive (state->clear_button, FALSE);
gtk_button_set_alignment (GTK_BUTTON (state->up_button), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->down_button), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->add_button), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->delete_button), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->clear_button), 0., .5);
gnumeric_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_CELL_SORT);
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect_swapped (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_ok_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_cancel_clicked), state);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
/* Finish dialog signals */
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_destroy);
range = dialog_load_selection (state, &col_rb);
cb_sort_selection_changed (state);
gnm_expr_entry_grab_focus(GNM_EXPR_ENTRY (state->add_entry), TRUE);
}
void init_right_tree(void)
{
GtkTreeView *view = GTK_TREE_VIEW(tree2_w);
GtkCellRenderer *renderer;
GtkTreeSelection *sel;
GtkTreeViewColumn *column;
gint i;
gtk_tree_view_set_model(view, model2);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_rules_hint(view, TRUE);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(view, column);
gtk_tree_view_column_set_title(column, _("Options"));
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer,
"pixbuf", COL_PIXBUF,
"visible", COL_PIXVIS, NULL);
renderer = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer,
"active", COL_BTNACT,
"inconsistent", COL_BTNINC,
"visible", COL_BTNVIS,
"radio", COL_BTNRAD, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer,
"text", COL_OPTION,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Name"), renderer,
"text", COL_NAME,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"N", renderer,
"text", COL_NO,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"M", renderer,
"text", COL_MOD,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
"Y", renderer,
"text", COL_YES,
"foreground-gdk",
COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Value"), renderer,
"text", COL_VALUE,
"editable",
COL_EDIT,
"foreground-gdk",
COL_COLOR, NULL);
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(renderer_edited), NULL);
column = gtk_tree_view_get_column(view, COL_NAME);
gtk_tree_view_column_set_visible(column, show_name);
column = gtk_tree_view_get_column(view, COL_NO);
gtk_tree_view_column_set_visible(column, show_range);
column = gtk_tree_view_get_column(view, COL_MOD);
gtk_tree_view_column_set_visible(column, show_range);
column = gtk_tree_view_get_column(view, COL_YES);
gtk_tree_view_column_set_visible(column, show_range);
column = gtk_tree_view_get_column(view, COL_VALUE);
gtk_tree_view_column_set_visible(column, show_value);
if (resizeable) {
for (i = 0; i < COL_VALUE; i++) {
column = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(column, TRUE);
}
}
sel = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkTreeModel *tree_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GtkTreeView editing sample");
g_signal_connect (window, "destroy", gtk_main_quit, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
tree_model = create_model ();
tree_view = gtk_tree_view_new_with_model (tree_model);
g_signal_connect (tree_view, "button_press_event", G_CALLBACK (button_press_event), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), TRUE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "String");
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", PIXBUF_COLUMN, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", STRING_COLUMN,
"editable", IS_EDITABLE_COLUMN,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (edited), tree_model);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", STRING_COLUMN,
"editable", IS_EDITABLE_COLUMN,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (edited), tree_model);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", PIXBUF_COLUMN, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (toggled), tree_model);
g_object_set (renderer,
"xalign", 0.0,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Editable",
renderer,
"active", IS_EDITABLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_progress_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Progress",
renderer,
"value", PROGRESS_COLUMN,
NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
gtk_window_set_default_size (GTK_WINDOW (window),
800, 175);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void
save_got_message(CamelFolder *folder, const char *uid, CamelMimeMessage *msg, void *d)
{
struct _save_data *data = d;
GtkDialog *dialog;
GtkWidget *w, *tree;
GtkTreeStore *model;
GtkCellRenderer *renderer;
/* not found, the mailer will show an error box for this */
if (msg == NULL) {
free_data(data);
return;
}
data->msg = msg;
camel_object_ref(msg);
dialog = (GtkDialog *)gtk_dialog_new_with_buttons(_("Save attachments"),
NULL, /* target->parent? */
0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
w = gtk_file_chooser_button_new (_("Select save base name"), GTK_FILE_CHOOSER_ACTION_OPEN);
data->entry = w;
g_object_set(w, "filechooser_action", GTK_FILE_CHOOSER_ACTION_SAVE, NULL);
gtk_widget_show(w);
gtk_box_pack_start((GtkBox *)dialog->vbox, w, FALSE, TRUE, 6);
g_signal_connect(GTK_FILE_CHOOSER_BUTTON (w), "selection-changed", G_CALLBACK(entry_changed), data);
model = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
data->model = model;
fill_model(msg, model);
tree = gtk_tree_view_new_with_model((GtkTreeModel *)model);
data->tree = tree;
gtk_widget_show(tree);
gtk_tree_view_expand_all((GtkTreeView *)tree);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("MIME Type"), renderer, "text", 1, NULL);
gtk_tree_view_set_expander_column((GtkTreeView *)tree, gtk_tree_view_get_column((GtkTreeView *)tree, 0));
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer, "activatable", TRUE, NULL);
g_signal_connect(renderer, "toggled", G_CALLBACK(toggle_changed), data);
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("Save"), renderer, "active", 0, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes((GtkTreeView *)tree, -1,
_("Name"), renderer, "text", 2, NULL);
w = g_object_new(gtk_frame_get_type(),
"shadow_type", GTK_SHADOW_NONE,
"label_widget", g_object_new(gtk_label_get_type(),
"label", "<span weight=\"bold\">Attachments</span>",
"use_markup", TRUE,
"xalign", 0.0, NULL),
"child", g_object_new(gtk_alignment_get_type(),
"left_padding", 12,
"top_padding", 6,
"child", g_object_new(gtk_scrolled_window_get_type(),
"hscrollbar_policy", GTK_POLICY_AUTOMATIC,
"vscrollbar_policy", GTK_POLICY_AUTOMATIC,
"shadow_type", GTK_SHADOW_IN,
"child", tree,
NULL),
NULL),
NULL);
gtk_widget_show_all(w);
gtk_box_pack_start((GtkBox *)dialog->vbox, w, TRUE, TRUE, 0);
g_signal_connect(dialog, "response", G_CALLBACK(save_response), data);
gtk_window_set_default_size((GtkWindow *)dialog, 500, 500);
gtk_widget_show((GtkWidget *)dialog);
}
static SyncDialog *sync_dialog_new(GtkWidget *parent)
{
SyncDialog *sd;
GtkWidget *dialog;
GtkWidget *dialog1_vbox;
GtkWidget *scrolledwindow2;
GtkWidget *treeview2;
GtkWidget *dialog1_action_area;
GtkWidget *button8;
GtkWidget *button7;
GtkWidget *button6;
GtkWidget *label;
GtkWidget *hbox;
GtkTreeViewColumn *column;
GtkTreeModel *model;
GtkListStore *store;
GtkCellRenderer *cr_text, *cr_toggle;
sd = g_new0(SyncDialog, 1);
sd->sna = sync_dialog_netarea_new();
dialog = gtk_dialog_new();
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));
gtk_window_set_title(GTK_WINDOW(dialog), "Network Updater");
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_window_set_icon(GTK_WINDOW(dialog),
icon_cache_get_pixbuf("syncmanager.png"));
gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260);
gtk_window_set_position(GTK_WINDOW(dialog),
GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_type_hint(GTK_WINDOW(dialog),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
dialog1_vbox = GTK_DIALOG(dialog)->vbox;
gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5);
gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4);
gtk_widget_show(dialog1_vbox);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new(LABEL_SYNC_DEFAULT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox),
icon_cache_get_image("syncmanager.png"),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_widget_show_all(hbox);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), sd->sna->vbox, TRUE, TRUE,
0);
scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow2);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE,
0);
gtk_widget_set_size_request(scrolledwindow2, -1, 200);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW
(scrolledwindow2), GTK_SHADOW_IN);
store =
gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING,
G_TYPE_POINTER);
model = GTK_TREE_MODEL(store);
treeview2 = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE);
gtk_widget_show(treeview2);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column);
cr_toggle = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(column, cr_toggle, FALSE);
g_signal_connect(cr_toggle, "toggled", G_CALLBACK(sel_toggle), model);
gtk_tree_view_column_add_attribute(column, cr_toggle, "active", 0);
cr_text = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, cr_text, TRUE);
gtk_tree_view_column_add_attribute(column, cr_text, "markup", 1);
populate_store(store);
dialog1_action_area = GTK_DIALOG(dialog)->action_area;
gtk_widget_show(dialog1_action_area);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area),
GTK_BUTTONBOX_END);
button8 = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_widget_show(button8);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8,
GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT);
button7 = gtk_button_new_with_mnemonic("_Synchronize");
gtk_widget_show(button7);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7,
GTK_RESPONSE_ACCEPT);
GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT);
button6 = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect(G_OBJECT(button6), "clicked",
(GCallback) close_clicked, NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button6,
GTK_RESPONSE_ACCEPT);
GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT);
sd->dialog = dialog;
sd->button_sync = button7;
sd->button_cancel = button8;
sd->button_close = button6;
sd->scroll_box = scrolledwindow2;
sd->label = label;
return sd;
}
static void
setup_filters (EventLog *log)
{
int i;
EventType last_toplevel_type = EVENT_TYPE_LAST;
GtkTreeIter cur_toplevel;
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
log->filters = gtk_tree_store_new(FILTER_COLUMN_LAST,
G_TYPE_STRING, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN, G_TYPE_STRING);
g_signal_connect (log->filters, "row_changed",
G_CALLBACK (update_listener_row_changed), log);
for (i = 0; i < G_N_ELEMENTS (event_info); i++) {
GtkTreeIter item;
EventType type = event_info[i].type;
const char *event_type_name = event_type_names[type];
if (type != last_toplevel_type) {
char *event_type_name_colon = g_strconcat (event_type_name, ":", NULL);
last_toplevel_type = type;
gtk_tree_store_append (log->filters, &cur_toplevel, NULL);
gtk_tree_store_set (log->filters, &cur_toplevel,
FILTER_COLUMN_NAME, event_type_name,
FILTER_COLUMN_ENABLED, (gboolean) FALSE,
FILTER_COLUMN_INCONSISTENT, (gboolean) FALSE,
FILTER_COLUMN_FULL_NAME, event_type_name_colon,
-1);
g_free (event_type_name_colon);
}
if (event_info[i].name) {
char *full_name;
gtk_tree_store_append (log->filters, &item, &cur_toplevel);
full_name = g_strconcat (event_type_name, ":", event_info[i].name, NULL);
gtk_tree_store_set (log->filters, &item,
FILTER_COLUMN_NAME, event_info[i].name,
FILTER_COLUMN_ENABLED, (gboolean) FALSE,
FILTER_COLUMN_INCONSISTENT, (gboolean) FALSE,
FILTER_COLUMN_FULL_NAME, full_name,
-1);
g_free (full_name);
}
}
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_title (column, "Name");
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes
(column, cell, "active", FILTER_COLUMN_ENABLED,
"inconsistent", FILTER_COLUMN_INCONSISTENT, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
g_signal_connect (cell, "toggled", G_CALLBACK (update_filter_model), log);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes
(column, cell, "text", FILTER_COLUMN_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (column, FILTER_COLUMN_NAME);
gtk_tree_view_append_column (log->filters_view, column);
gtk_tree_view_insert_column_with_attributes
(log->filters_view, 2, "Full name",
gtk_cell_renderer_text_new (), "text",
FILTER_COLUMN_FULL_NAME, NULL);
gtk_tree_view_set_model (log->filters_view,
GTK_TREE_MODEL (log->filters));
gtk_tree_view_set_headers_visible (log->filters_view, TRUE);
gtk_tree_selection_set_mode
(gtk_tree_view_get_selection (log->filters_view),
GTK_SELECTION_NONE);
gtk_tree_view_columns_autosize (log->filters_view);
}
GtkWidget *gtkui_cheats() {
// Create the Cheats window
if (cheatwindow) { return NULL; }
cheatwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (cheatwindow), "Cheat Manager");
GtkWidget *cheatbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(cheatwindow), cheatbox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 512, 256);
treeview = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER (scrolledwindow), treeview);
infobar = gtk_info_bar_new();
infolabel = gtk_widget_new(GTK_TYPE_LABEL,"label", "", NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), infobar, TRUE, TRUE, 0);
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar));
gtk_box_pack_start(GTK_BOX(content_area), infolabel, TRUE, TRUE, 0);
GtkWidget *opensavebox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), opensavebox, FALSE, FALSE, 0);
GtkWidget *cheatopen = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_OPEN,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cheatopen), TRUE);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatopen, FALSE, FALSE, 0);
GtkWidget *cheatclear = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_CLEAR,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cheatclear), TRUE);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatclear, FALSE, FALSE, 0);
GtkWidget *cheatremove = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_REMOVE,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cheatremove), TRUE);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatremove, FALSE, FALSE, 0);
GtkWidget *descbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), descbox, FALSE, FALSE, 0);
GtkWidget *desclabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Description:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), desclabel, FALSE, FALSE, 0);
descedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), descedit, TRUE, TRUE, 0);
GtkWidget *ggbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), ggbox, FALSE, FALSE, 0);
GtkWidget *gglabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Game Genie:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), gglabel, FALSE, FALSE, 0);
ggedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), ggedit, TRUE, TRUE, 0);
GtkWidget *genieadd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_ADD,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(genieadd), TRUE);
gtk_box_pack_start(GTK_BOX(ggbox), genieadd, FALSE, FALSE, 0);
GtkWidget *parbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), parbox, FALSE, FALSE, 0);
GtkWidget *parlabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Pro Action Rocky:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), parlabel, FALSE, FALSE, 0);
paredit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), paredit, FALSE, FALSE, 0);
GtkWidget *paradd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_ADD,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(paradd), TRUE);
gtk_box_pack_start(GTK_BOX(parbox), paradd, FALSE, FALSE, 0);
GtkWidget *cheatok = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_OK,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cheatok), TRUE);
gtk_box_pack_start(GTK_BOX(cheatbox), cheatok, FALSE, FALSE, 0);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), FALSE);
treestore = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
GtkCellRenderer *checkbox = gtk_cell_renderer_toggle_new();
GtkTreeViewColumn *column[5];
// create the display columns
column[0] = gtk_tree_view_column_new_with_attributes("Enable", checkbox, "active", 0, NULL);
column[1] = gtk_tree_view_column_new_with_attributes("Game Genie", renderer, "text", 1, NULL);
column[2] = gtk_tree_view_column_new_with_attributes("PAR", renderer, "text", 2, NULL);
column[3] = gtk_tree_view_column_new_with_attributes("Raw", renderer, "text", 3, NULL);
column[4] = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", 4, NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[0]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[1]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[2]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[3]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[4]);
gtkui_cheats_fill_tree(nstpaths.cheatpath);
/*g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(gtkui_cheats_check), NULL);*/
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(gtkui_cheats_toggle), NULL);
g_signal_connect(G_OBJECT(cheatopen), "clicked",
G_CALLBACK(gtkui_cheats_load), NULL);
g_signal_connect(G_OBJECT(cheatclear), "clicked",
G_CALLBACK(gtkui_cheats_clear), NULL);
g_signal_connect(G_OBJECT(cheatremove), "clicked",
G_CALLBACK(gtkui_cheats_remove), NULL);
g_signal_connect(G_OBJECT(genieadd), "clicked",
G_CALLBACK(gtkui_cheats_gg_add), NULL);
g_signal_connect(G_OBJECT(paradd), "clicked",
G_CALLBACK(gtkui_cheats_par_add), NULL);
g_signal_connect(G_OBJECT(cheatok), "clicked",
G_CALLBACK(gtkui_cheats_ok), NULL);
g_signal_connect(G_OBJECT(cheatwindow), "destroy",
G_CALLBACK(gtkui_cheats_ok), NULL);
gtk_widget_show_all(cheatwindow);
gtk_widget_hide(infobar);
return cheatwindow;
}
static GtkTreeView *
build_view (GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
static GtkListStore *direction_store = NULL, *size_store =
NULL, *state_store = NULL;
GtkTreeView *view = (GtkTreeView *) gtk_tree_view_new ();
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
if (!direction_store)
{
direction_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_TEXT_DIRECTION, FALSE);
size_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_ICON_SIZE, FALSE);
state_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_STATE_TYPE, FALSE);
}
/* Filename / icon name column/renderer */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_filename_edited), eprop);
eprop_sources->filename_column =
gtk_tree_view_column_new_with_attributes (_("File Name"), renderer,
"text", COLUMN_TEXT,
"weight", COLUMN_TEXT_WEIGHT,
"editable",
COLUMN_TEXT_EDITABLE, NULL);
gtk_tree_view_column_set_expand (eprop_sources->filename_column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view),
eprop_sources->filename_column);
g_object_set_data (G_OBJECT (eprop_sources->filename_column), "column-id",
GINT_TO_POINTER (COLUMN_TEXT));
/********************* Size *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_SIZE_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE, "active", COLUMN_SIZE_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_SIZE_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", size_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_SIZE));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_SIZE_ACTIVE, "text", COLUMN_SIZE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_SIZE));
/********************* State *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_STATE_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE, "active", COLUMN_STATE_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_STATE_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", state_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_STATE));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_STATE_ACTIVE, "text", COLUMN_STATE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_STATE));
/********************* Direction *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_DIRECTION_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"active", COLUMN_DIRECTION_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_DIRECTION_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", direction_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_DIRECTION));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_DIRECTION_ACTIVE, "text", COLUMN_DIRECTION, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_DIRECTION));
/* Connect ::query-tooltip here for fancy tooltips... */
g_object_set (G_OBJECT (view), "has-tooltip", TRUE, NULL);
g_signal_connect (G_OBJECT (view), "query-tooltip",
G_CALLBACK (icon_sources_query_tooltip), eprop);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (view), FALSE);
return view;
}
