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; }