GtkWidget * pgd_forms_create_widget (PopplerDocument *document) { PgdFormsDemo *demo; GtkWidget *label; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *hpaned; GtkWidget *swindow, *treeview; GtkTreeSelection *selection; GtkCellRenderer *renderer; gchar *str; gint n_pages; demo = g_new0 (PgdFormsDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_vbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_forms_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Forms Fields"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_forms_get_form_fields), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No form fields found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_hpaned_new (); demo->field_view = pgd_form_field_view_new (); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_OBJECT); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 0, "Form Field Type", renderer, "text", FORMS_FIELD_TYPE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 1, "Form Field Id", renderer, "text", FORMS_ID_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 2, "Read Only", renderer, "active", FORMS_READ_ONLY_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 3, "X1", renderer, "text", FORMS_X1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 4, "Y1", renderer, "text", FORMS_Y1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 5, "X2", renderer, "text", FORMS_X2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 6, "Y2", renderer, "text", FORMS_Y2_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (pgd_forms_selection_changed), (gpointer)demo); 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), demo->field_view); gtk_widget_show (demo->field_view); gtk_paned_set_position (GTK_PANED (hpaned), 300); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_forms_free, demo); return vbox; }
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; }
GtkWidget * gnome_prefs_string_option_menu_new (GtkWidget *table, const gchar *label_txt, const gchar **options, const gchar *conf_key, const gchar *tooltip, int row, const gchar *default_value) { GnomePrefsWindow *gpw = NULL; GtkWidget *label = NULL; GtkWidget *option_menu = NULL; GtkListStore *list_store = NULL; GtkCellRenderer *renderer = NULL; GtkTreeIter iter; gchar *conf_string = NULL; gboolean writable = FALSE; int history = -1; int cpt = 0; writable = gm_conf_is_key_writable (conf_key); label = gtk_label_new (label_txt); if (!writable) gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE); gtk_table_attach (GTK_TABLE (table), label, 0, 1, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); list_store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); option_menu = gtk_combo_box_new_with_model (GTK_TREE_MODEL (list_store)); if (!writable) gtk_widget_set_sensitive (GTK_WIDGET (option_menu), FALSE); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (option_menu), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (option_menu), renderer, "text", COLUMN_STRING_TRANSLATED, "sensitive", COLUMN_SENSITIVE, NULL); g_object_set (G_OBJECT (renderer), "ellipsize-set", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, "width-chars", 45, NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), option_menu); conf_string = gm_conf_get_string (conf_key); if (conf_string == NULL) conf_string = g_strdup (default_value); while (options [cpt]) { if (conf_string && !g_strcmp0 (conf_string, options [cpt])) history = cpt; gtk_list_store_append (GTK_LIST_STORE (list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (list_store), &iter, COLUMN_STRING_RAW, options [cpt], COLUMN_STRING_TRANSLATED, gettext (options [cpt]), COLUMN_SENSITIVE, TRUE, -1); cpt++; } if (history == -1) { if (conf_string && g_strcmp0 (conf_string, "")) { gtk_list_store_append (GTK_LIST_STORE (list_store), &iter); gtk_list_store_set (GTK_LIST_STORE (list_store), &iter, COLUMN_STRING_RAW, conf_string, COLUMN_STRING_TRANSLATED, gettext (conf_string), COLUMN_SENSITIVE, FALSE, -1); history = cpt; } else history = 0; } gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu), history); gtk_table_attach (GTK_TABLE (table), option_menu, 1, 2, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gpw = (GnomePrefsWindow *) g_object_get_data (G_OBJECT (table), "gpw"); if (gpw && tooltip) gtk_widget_set_tooltip_text (option_menu, tooltip); g_signal_connect (option_menu, "changed", G_CALLBACK (string_option_menu_changed), (gpointer) conf_key); gm_conf_notifier_add (conf_key, string_option_menu_changed_nt, (gpointer) option_menu); g_free (conf_string); gtk_widget_show_all (table); return option_menu; }
static void _preferences_window(Camera * camera) { GtkWidget * dialog; GtkWidget * notebook; GtkWidget * vbox; GtkWidget * widget; GtkListStore * store; GtkTreeIter iter; GtkCellRenderer * renderer; const struct { GdkInterpType type; char const * name; } interp[] = { { GDK_INTERP_NEAREST, N_("Nearest") }, { GDK_INTERP_TILES, N_("Tiles") }, { GDK_INTERP_BILINEAR, N_("Bilinear") }, { GDK_INTERP_HYPER, N_("Hyperbolic") }, }; const struct { CameraSnapshotFormat format; char const * name; } sformats[CSF_COUNT - 1] = { { CSF_JPEG, "JPEG" }, { CSF_PNG, "PNG" } }; size_t i; dialog = gtk_dialog_new_with_buttons(_("Preferences"), GTK_WINDOW(camera->window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); camera->pr_window = dialog; g_signal_connect(dialog, "response", G_CALLBACK( _preferences_on_response), camera); notebook = gtk_notebook_new(); /* picture */ #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); #else vbox = gtk_vbox_new(FALSE, 4); #endif camera->pr_hflip = gtk_check_button_new_with_mnemonic( _("Flip _horizontally")); gtk_box_pack_start(GTK_BOX(vbox), camera->pr_hflip, FALSE, TRUE, 0); camera->pr_vflip = gtk_check_button_new_with_mnemonic( _("Flip _vertically")); gtk_box_pack_start(GTK_BOX(vbox), camera->pr_vflip, FALSE, TRUE, 0); camera->pr_ratio = gtk_check_button_new_with_mnemonic( _("Keep aspect _ratio")); gtk_box_pack_start(GTK_BOX(vbox), camera->pr_ratio, FALSE, TRUE, 0); /* interpolation */ #if GTK_CHECK_VERSION(3, 0, 0) widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); #else widget = gtk_hbox_new(FALSE, 4); #endif gtk_box_pack_start(GTK_BOX(widget), gtk_label_new(_("Interpolation: ")), FALSE, TRUE, 0); store = gtk_list_store_new(2, G_TYPE_UINT, G_TYPE_STRING); for(i = 0; i < sizeof(interp) / sizeof(*interp); i++) { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, interp[i].type, 1, _(interp[i].name), -1); } camera->pr_interp = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(camera->pr_interp), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(camera->pr_interp), renderer, "text", 1, NULL); gtk_box_pack_start(GTK_BOX(widget), camera->pr_interp, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, gtk_label_new(_("Picture"))); /* snapshots */ #if GTK_CHECK_VERSION(3, 0, 0) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); #else vbox = gtk_vbox_new(FALSE, 4); #endif /* format */ #if GTK_CHECK_VERSION(3, 0, 0) widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); #else widget = gtk_hbox_new(FALSE, 4); #endif gtk_box_pack_start(GTK_BOX(widget), gtk_label_new(_("Format: ")), FALSE, TRUE, 0); store = gtk_list_store_new(2, G_TYPE_UINT, G_TYPE_STRING); for(i = 0; i < sizeof(sformats) / sizeof(*sformats); i++) { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, sformats[i].format, 1, sformats[i].name, -1); } camera->pr_sformat = gtk_combo_box_new_with_model( GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(camera->pr_sformat), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(camera->pr_sformat), renderer, "text", 1, NULL); gtk_box_pack_start(GTK_BOX(widget), camera->pr_sformat, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, gtk_label_new(_("Snapshots"))); #if GTK_CHECK_VERSION(2, 14, 0) vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); #else vbox = dialog->vbox; #endif gtk_box_set_spacing(GTK_BOX(vbox), 4); gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0); gtk_widget_show_all(vbox); _preferences_cancel(camera); }
static GtkWidget* _lib_import_get_extra_widget(dt_lib_import_metadata_t *data, gboolean import_folder) { // add extra lines to 'extra'. don't forget to destroy the widgets later. GtkWidget *expander = gtk_expander_new(_("import options")); gtk_expander_set_expanded(GTK_EXPANDER(expander), dt_conf_get_bool("ui_last/import_options_expanded")); GtkWidget *frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_IN); GtkWidget *alignment = gtk_alignment_new(1.0, 1.0, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 8, 8, 8, 8); GtkWidget *event_box = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(frame), event_box); gtk_container_add(GTK_CONTAINER(event_box), alignment); gtk_container_add(GTK_CONTAINER(alignment), expander); GtkWidget *extra; extra = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(expander), extra); GtkWidget *recursive = NULL, *ignore_jpeg = NULL; if(import_folder == TRUE) { // recursive opening. recursive = gtk_check_button_new_with_label (_("import directories recursively")); g_object_set(recursive, "tooltip-text", _("recursively import subdirectories. each directory goes into a new film roll."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (recursive), dt_conf_get_bool("ui_last/import_recursive")); gtk_box_pack_start(GTK_BOX (extra), recursive, FALSE, FALSE, 0); // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories. ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files")); g_object_set(ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+JPEG in a directory."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs")); gtk_box_pack_start(GTK_BOX (extra), ignore_jpeg, FALSE, FALSE, 0); } // default metadata GtkWidget *apply_metadata; GtkWidget *table, *label, *creator, *publisher, *rights, *tags; apply_metadata = gtk_check_button_new_with_label (_("apply metadata on import")); g_object_set(apply_metadata, "tooltip-text", _("apply some metadata to all newly imported images."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (apply_metadata), dt_conf_get_bool("ui_last/import_apply_metadata")); gtk_box_pack_start(GTK_BOX (extra), apply_metadata, FALSE, FALSE, 0); GValue value = {0, }; g_value_init(&value, G_TYPE_INT); gtk_widget_style_get_property(apply_metadata, "indicator-size", &value); gint indicator_size = g_value_get_int(&value); // gtk_widget_style_get_property(apply_metadata, "indicator-spacing", &value); // gint indicator_spacing = g_value_get_int(&value); table = gtk_table_new(6, 3, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 5); gtk_table_set_col_spacings(GTK_TABLE(table), 5); alignment = gtk_alignment_new(0, 0, 1, 1); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 2*indicator_size, 0); gtk_container_add(GTK_CONTAINER(alignment), table); gtk_box_pack_start(GTK_BOX (extra), alignment, FALSE, FALSE, 0); creator = gtk_entry_new(); gtk_widget_set_size_request(creator, 300, -1); gtk_entry_set_text(GTK_ENTRY(creator), dt_conf_get_string("ui_last/import_last_creator")); publisher = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(publisher), dt_conf_get_string("ui_last/import_last_publisher")); rights = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(rights), dt_conf_get_string("ui_last/import_last_rights")); tags = gtk_entry_new(); g_object_set(tags, "tooltip-text", _("comma separated list of tags"), NULL); gtk_entry_set_text(GTK_ENTRY(tags), dt_conf_get_string("ui_last/import_last_tags")); // presets from the metadata plugin GtkCellRenderer *renderer; GtkTreeIter iter; GtkListStore *model = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING /*name*/, G_TYPE_STRING /*creator*/, G_TYPE_STRING /*publisher*/, G_TYPE_STRING /*rights*/); GtkWidget *presets = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(presets), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(presets), renderer, "text", NAME_COLUMN, NULL); sqlite3_stmt *stmt; DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params from presets where operation = \"metadata\"", -1, &stmt, NULL); while(sqlite3_step(stmt) == SQLITE_ROW) { void *op_params = (void *)sqlite3_column_blob(stmt, 1); int32_t op_params_size = sqlite3_column_bytes(stmt, 1); char *buf = (char* )op_params; char *title = buf; buf += strlen(title) + 1; char *description = buf; buf += strlen(description) + 1; char *rights = buf; buf += strlen(rights) + 1; char *creator = buf; buf += strlen(creator) + 1; char *publisher = buf; if(op_params_size == strlen(title) + strlen(description) + strlen(rights) + strlen(creator) + strlen(publisher) + 5) { gtk_list_store_append(model, &iter); gtk_list_store_set (model, &iter, NAME_COLUMN, (char *)sqlite3_column_text(stmt, 0), CREATOR_COLUMN, creator, PUBLISHER_COLUMN, publisher, RIGHTS_COLUMN, rights, -1); } } sqlite3_finalize(stmt); g_object_unref(model); int line = 0; label = gtk_label_new(_("preset")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), presets, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); line++; label = gtk_label_new(_("creator")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), creator, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); line++; label = gtk_label_new(_("publisher")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), publisher, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); line++; label = gtk_label_new(_("rights")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), rights, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); line++; label = gtk_label_new(_("tags")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), tags, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); gtk_widget_show_all(frame); if(data != NULL) { data->frame = frame; data->recursive = recursive; data->ignore_jpeg = ignore_jpeg; data->expander = expander; data->apply_metadata = apply_metadata; data->presets = presets; data->creator = creator; data->publisher = publisher; data->rights = rights; data->tags = tags; } g_signal_connect(apply_metadata, "toggled", G_CALLBACK (_lib_import_apply_metadata_toggled), table); _lib_import_apply_metadata_toggled(apply_metadata, table); // needed since the apply_metadata starts being turned off, // and setting it to off doesn't emit the 'toggled' signal ... g_signal_connect(presets, "changed", G_CALLBACK(_lib_import_presets_changed), data); g_signal_connect(GTK_ENTRY(creator), "changed", G_CALLBACK (_lib_import_metadata_changed), presets); g_signal_connect(GTK_ENTRY(publisher), "changed", G_CALLBACK (_lib_import_metadata_changed), presets); g_signal_connect(GTK_ENTRY(rights), "changed", G_CALLBACK (_lib_import_metadata_changed), presets); return frame; }
static void load_options_cb (GtkWidget *w, DialogData *data) { LoadOptionsDialogData *aod_data; GtkWidget *ok_button; GtkWidget *cancel_button; GtkWidget *remove_button; GtkCellRenderer *renderer; GtkTreeViewColumn *column; aod_data = g_new0 (LoadOptionsDialogData, 1); aod_data->data = data; aod_data->builder = _gtk_builder_new_from_file ("add-options.ui"); if (aod_data->builder == NULL) { g_free (aod_data); return; } /* Get the widgets. */ aod_data->dialog = _gtk_builder_get_widget (aod_data->builder, "add_options_dialog"); aod_data->aod_treeview = _gtk_builder_get_widget (aod_data->builder, "aod_treeview"); ok_button = _gtk_builder_get_widget (aod_data->builder, "aod_okbutton"); cancel_button = _gtk_builder_get_widget (aod_data->builder, "aod_cancelbutton"); remove_button = _gtk_builder_get_widget (aod_data->builder, "aod_remove_button"); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (aod_data->dialog), "destroy", G_CALLBACK (aod_destroy_cb), aod_data); g_signal_connect (G_OBJECT (aod_data->aod_treeview), "row_activated", G_CALLBACK (aod_activated_cb), aod_data); g_signal_connect_swapped (G_OBJECT (cancel_button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (aod_data->dialog)); g_signal_connect (G_OBJECT (ok_button), "clicked", G_CALLBACK (aod_apply_cb), aod_data); g_signal_connect (G_OBJECT (remove_button), "clicked", G_CALLBACK (aod_remove_cb), aod_data); /* Set data. */ aod_data->aod_model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (aod_data->aod_model), 0, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (aod_data->aod_treeview), aod_data->aod_model); g_object_unref (aod_data->aod_model); /**/ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW (aod_data->aod_treeview), column); aod_update_option_list (aod_data); /* Run */ gtk_window_set_transient_for (GTK_WINDOW (aod_data->dialog), GTK_WINDOW (data->dialog)); gtk_window_set_modal (GTK_WINDOW (aod_data->dialog), TRUE); gtk_widget_show (aod_data->dialog); }
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; }
bool sc_toggle_index(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; if (zathura->document == NULL) { return false; } girara_tree_node_t* document_index = NULL; GtkWidget* treeview = NULL; GtkTreeModel* model = NULL; GtkCellRenderer* renderer = NULL; GtkCellRenderer* renderer2 = NULL; if (zathura->ui.index == NULL) { /* create new index widget */ zathura->ui.index = gtk_scrolled_window_new(NULL, NULL); if (zathura->ui.index == NULL) { goto error_ret; } gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zathura->ui.index), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* create index */ document_index = zathura_document_index_generate(zathura->document, NULL); if (document_index == NULL) { girara_notify(session, GIRARA_WARNING, _("This document does not contain any index")); goto error_free; } model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER)); if (model == NULL) { goto error_free; } treeview = gtk_tree_view_new_with_model(model); if (treeview == NULL) { goto error_free; } g_object_unref(model); renderer = gtk_cell_renderer_text_new(); if (renderer == NULL) { goto error_free; } renderer2 = gtk_cell_renderer_text_new(); if (renderer2 == NULL) { goto error_free; } document_index_build(model, NULL, document_index); girara_node_free(document_index); /* setup widget */ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 0, "Title", renderer, "markup", 0, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 1, "Target", renderer2, "text", 1, NULL); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); 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); gtk_tree_view_column_set_alignment(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 1), 1.0f); gtk_tree_view_set_cursor(GTK_TREE_VIEW(treeview), gtk_tree_path_new_first(), NULL, FALSE); g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(cb_index_row_activated), zathura); gtk_container_add(GTK_CONTAINER(zathura->ui.index), treeview); gtk_widget_show(treeview); } static double vvalue = 0; static double hvalue = 0; if (gtk_widget_get_visible(GTK_WIDGET(zathura->ui.index))) { girara_set_view(session, zathura->ui.page_widget_alignment); gtk_widget_hide(GTK_WIDGET(zathura->ui.index)); girara_mode_set(zathura->ui.session, zathura->modes.normal); /* reset adjustment */ position_set_delayed(zathura, hvalue, vvalue); } else { /* save adjustment */ GtkAdjustment* vadjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(session->gtk.view)); GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(session->gtk.view)); vvalue = gtk_adjustment_get_value(vadjustment); hvalue = gtk_adjustment_get_value(hadjustment); /* save current position to the jumplist */ zathura_jumplist_save(zathura); girara_set_view(session, zathura->ui.index); gtk_widget_show(GTK_WIDGET(zathura->ui.index)); girara_mode_set(zathura->ui.session, zathura->modes.index); } return false; error_free: if (zathura->ui.index != NULL) { g_object_ref_sink(zathura->ui.index); zathura->ui.index = NULL; } if (document_index != NULL) { girara_node_free(document_index); } error_ret: return false; }
void TreeViewCreate(void) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; ReportStore = gtk_list_store_new(N_COLS, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING ); ReportTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ReportStore)); g_signal_connect(GTK_OBJECT(ReportTreeView), "button_press_event", G_CALLBACK(ReportTreeView_clicked),NULL); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Hostname", renderer, "text", COL_HOSTNAME, "foreground", COL_COLOR, NULL); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes ("Loss", renderer, "text", COL_LOSS, "foreground", COL_COLOR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, percent_formatter, (void*)COL_LOSS, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes ("Snt", renderer, "text", 3, "foreground", COL_COLOR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes ("Last", renderer, "text", 4, "foreground", COL_COLOR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes ("Avg", renderer, "text", 6, "foreground", COL_COLOR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes ("Best", renderer, "text", 5, "foreground", COL_COLOR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes ("Worst", renderer, "text", 7, "foreground", COL_COLOR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL); column = gtk_tree_view_column_new_with_attributes ("StDev", renderer, "text", 8, "foreground", COL_COLOR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, float_formatter, (void*)COL_STDEV, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column); }
static GtkWidget *create_window(void) { stwidgets.accel_group = gtk_accel_group_new(); // Basic window stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE); gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls stwidgets.hlayout = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout); // banner { GdkPixbuf *pixbuf = load_banner(); stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons stwidgets.vlayout = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0); // Tab control stwidgets.tabs = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4); // layout table of config page stwidgets.configtlayout = gtk_table_new(4, 3, FALSE); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout); // 2D video mode label stwidgets.vmode2dlabel = gtk_label_new_with_mnemonic("_2D Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode2dlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode2dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 6); // 2D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.vmode2dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode2dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode2dcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode2dcombo, 1,2, 0,1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 6); gtk_widget_add_accelerator(stwidgets.vmode2dcombo, "grab_focus", stwidgets.accel_group, GDK_2, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Fullscreen checkbox stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.fullscreencheck, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 6); gtk_widget_add_accelerator(stwidgets.fullscreencheck, "grab_focus", stwidgets.accel_group, GDK_F, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // 3D video mode label stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_3D Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 1,2, GTK_FILL, (GtkAttachOptions)0, 4, 6); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 1,2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0); gtk_widget_add_accelerator(stwidgets.vmode3dcombo, "grab_focus", stwidgets.accel_group, GDK_3, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Empty horizontal layout stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,1, 2,3, (GtkAttachOptions)0, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); // Always show config checkbox stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show configuration on start"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,2, 3,4, GTK_FILL, (GtkAttachOptions)0, 4, 6); gtk_widget_add_accelerator(stwidgets.alwaysshowcheck, "grab_focus", stwidgets.accel_group, GDK_A, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Configuration tab stwidgets.configtab = gtk_label_new("Configuration"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab); // Messages scrollable area stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area stwidgets.messagestext = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext); gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); // Messages tab stwidgets.messagestab = gtk_label_new("Messages"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.messagestab); // Dialogue box buttons layout stwidgets.buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3); gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END); // Cancel button stwidgets.cancelbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton); GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator(stwidgets.cancelbutton, "grab_focus", stwidgets.accel_group, GDK_C, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator(stwidgets.cancelbutton, "clicked", stwidgets.accel_group, GDK_Escape, (GdkModifierType)0, GTK_ACCEL_VISIBLE); stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign); stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout); stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0); stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel"); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0); // Start button stwidgets.startbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton); GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator(stwidgets.startbutton, "grab_focus", stwidgets.accel_group, GDK_S, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator(stwidgets.startbutton, "clicked", stwidgets.accel_group, GDK_Return, (GdkModifierType)0, GTK_ACCEL_VISIBLE); stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign); stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout); stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0); stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start"); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect((gpointer) stwidgets.startwin, "delete_event", G_CALLBACK(on_startwin_delete_event), NULL); g_signal_connect((gpointer) stwidgets.vmode2dcombo, "changed", G_CALLBACK(on_vmode2dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled", G_CALLBACK(on_alwaysshowcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked", G_CALLBACK(on_cancelbutton_clicked), NULL); g_signal_connect((gpointer) stwidgets.startbutton, "clicked", G_CALLBACK(on_startbutton_clicked), NULL); // Associate labels with their controls gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode2dlabel), stwidgets.vmode2dcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo); gtk_window_add_accel_group(GTK_WINDOW(stwidgets.startwin), stwidgets.accel_group); return stwidgets.startwin; }
GncSxSinceLastRunDialog* gnc_ui_sx_since_last_run_dialog(GncSxInstanceModel *sx_instances, GList *auto_created_txn_guids) { GncSxSinceLastRunDialog *dialog; GladeXML *glade; dialog = g_new0(GncSxSinceLastRunDialog, 1); glade = gnc_glade_xml_new("sched-xact.glade", "since-last-run-dialog"); dialog->dialog = glade_xml_get_widget(glade, "since-last-run-dialog"); dialog->editing_model = gnc_sx_slr_tree_model_adapter_new(sx_instances); dialog->review_created_txns_toggle = GTK_TOGGLE_BUTTON(glade_xml_get_widget(glade, "review_txn_toggle")); dialog->created_txns = auto_created_txn_guids; { GtkCellRenderer *renderer; GtkTreeViewColumn *col; dialog->instance_view = GTK_TREE_VIEW(glade_xml_get_widget(glade, "instance_view")); gtk_tree_view_set_model(dialog->instance_view, GTK_TREE_MODEL(dialog->editing_model)); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes(_("Transaction"), renderer, "text", SLR_MODEL_COL_NAME, NULL); gtk_tree_view_append_column(dialog->instance_view, col); renderer = gtk_cell_renderer_combo_new(); g_object_set(G_OBJECT(renderer), "model", gnc_sx_get_slr_state_model(), "text-column", 0, "has-entry", FALSE, "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(instance_state_changed_cb), dialog); col = gtk_tree_view_column_new_with_attributes(_("Status"), renderer, "text", SLR_MODEL_COL_INSTANCE_STATE, "visible", SLR_MODEL_COL_INSTANCE_VISIBILITY, // you might think only "sensitive" is required to // control the ability of the combo box to select // a new state, but you'd be wrong. "editable", SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY, "sensitive", SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY, NULL); gtk_tree_view_append_column(dialog->instance_view, col); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(variable_value_changed_cb), dialog); col = gtk_tree_view_column_new_with_attributes(_("Value"), renderer, "text", SLR_MODEL_COL_VARAIBLE_VALUE, "visible", SLR_MODEL_COL_VARIABLE_VISIBILITY, NULL); gtk_tree_view_append_column(dialog->instance_view, col); gtk_tree_view_expand_all(dialog->instance_view); } g_signal_connect(G_OBJECT(dialog->dialog), "response", G_CALLBACK(dialog_response_cb), dialog); g_signal_connect(G_OBJECT(dialog->dialog), "destroy", G_CALLBACK(dialog_destroy_cb), dialog); gnc_restore_window_size(GCONF_SECTION, GTK_WINDOW(dialog->dialog)); dialog->component_id = gnc_register_gui_component (DIALOG_SX_SINCE_LAST_RUN_CM_CLASS, NULL, close_handler, dialog); gnc_gui_component_set_session(dialog->component_id, gnc_get_current_session()); gtk_widget_show_all(dialog->dialog); return dialog; }
/** * ldap_favorite_selector_new * * Returns: a new #GtkWidget */ GtkWidget * ldap_favorite_selector_new (TConnection *tcnc) { LdapFavoriteSelector *fsel; GdaTreeManager *manager; gchar *signame; g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL); fsel = LDAP_FAVORITE_SELECTOR (g_object_new (LDAP_FAVORITE_SELECTOR_TYPE, NULL)); fsel->priv->tcnc = g_object_ref (tcnc); signame = g_strdup_printf ("favorites-changed::%s", t_favorites_type_to_string (T_FAVORITES_LDAP_DN)); g_signal_connect (t_connection_get_favorites (fsel->priv->tcnc), signame, G_CALLBACK (favorites_changed_cb), fsel); g_free (signame); signame = g_strdup_printf ("favorites-changed::%s", t_favorites_type_to_string (T_FAVORITES_LDAP_CLASS)); g_signal_connect (t_connection_get_favorites (fsel->priv->tcnc), signame, G_CALLBACK (favorites_changed_cb), fsel); g_free (signame); /* create tree managers */ fsel->priv->tree = gda_tree_new (); manager = mgr_favorites_new (tcnc, T_FAVORITES_LDAP_DN, ORDER_KEY_LDAP); gda_tree_add_manager (fsel->priv->tree, manager); g_object_unref (manager); manager = mgr_favorites_new (tcnc, T_FAVORITES_LDAP_CLASS, ORDER_KEY_LDAP); gda_tree_add_manager (fsel->priv->tree, manager); g_object_unref (manager); /* update the tree's contents */ if (! gda_tree_update_all (fsel->priv->tree, NULL)) { if (fsel->priv->idle_update_favorites == 0) fsel->priv->idle_update_favorites = g_idle_add ((GSourceFunc) idle_update_favorites, fsel); } /* header */ GtkWidget *label; gchar *str; str = g_strdup_printf ("<b>%s</b>", _("Favorites")); label = gdaui_bar_new (str); g_free (str); gdaui_bar_set_icon_from_pixbuf (GDAUI_BAR (label), ui_get_pixbuf_icon (UI_ICON_BOOKMARK)); gtk_box_pack_start (GTK_BOX (fsel), label, FALSE, FALSE, 0); gtk_widget_show (label); /* tree model & tree view */ GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; model = gdaui_tree_store_new (fsel->priv->tree, COLUMN_LAST, G_TYPE_INT, MGR_FAVORITES_ID_ATT_NAME, G_TYPE_STRING, MGR_FAVORITES_CONTENTS_ATT_NAME, G_TYPE_OBJECT, "icon", G_TYPE_STRING, "markup", G_TYPE_INT, MGR_FAVORITES_ID_ATT_NAME, G_TYPE_STRING, "descr", G_TYPE_UINT, MGR_FAVORITES_TYPE_ATT_NAME); treeview = ui_make_tree_view (model); fsel->priv->treeview = treeview; g_object_unref (model); g_signal_connect (G_OBJECT (treeview), "row-activated", G_CALLBACK (selection_changed_cb), fsel); g_signal_connect (G_OBJECT (treeview), "key-press-event", G_CALLBACK (key_press_event_cb), fsel); g_signal_connect (G_OBJECT (treeview), "popup-menu", G_CALLBACK (popup_menu_cb), fsel); g_signal_connect (G_OBJECT (treeview), "button-press-event", G_CALLBACK (button_press_event_cb), fsel); /* icon */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COLUMN_ICON); g_object_set ((GObject*) renderer, "yalign", 0., NULL); /* text */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "markup", COLUMN_MARKUP); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); /* scrolled window packing */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_box_pack_start (GTK_BOX (fsel), sw, TRUE, TRUE, 0); gtk_widget_show_all (sw); /* DnD */ gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (treeview), dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview), GDK_BUTTON1_MASK, dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (model, "drag-drop", G_CALLBACK (tree_store_drag_drop_cb), fsel); g_signal_connect (model, "drag-can-drag", G_CALLBACK (tree_store_drag_can_drag_cb), fsel); g_signal_connect (model, "drag-get", G_CALLBACK (tree_store_drag_get_cb), fsel); return (GtkWidget*) fsel; }
/** * init_view_raw_attr: * @view: * @raw_attr: * * TODO: Write me */ void init_view_raw_attr(CongAdvancedNodePropertiesView *view, struct RawAttr* raw_attr) { /* FIXME: use libglade for this... */ GtkWidget *vbox = gtk_vbox_new(FALSE, 6); GtkWidget *hbox = gtk_hbox_new(FALSE, 6); g_assert(view); g_assert(raw_attr); g_assert(cong_node_type(view->node)==CONG_NODE_TYPE_ELEMENT); raw_attr->category = cong_dialog_content_add_category(view->dialog_content, _("Raw Attributes")); raw_attr->list_store = GTK_LIST_STORE(gtk_list_store_new(RAW_ATTR_MODEL_NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING)); /* Initialise store: */ raw_attr_list_refresh(view, &view->raw_attr); /* Initialise treeview */ { GtkCellRenderer *renderer; GtkTreeViewColumn *column; raw_attr->tree_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(raw_attr->list_store))); /* Build columns & renderers: */ renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(on_name_edited), view); column = gtk_tree_view_column_new_with_attributes( _("Name"), renderer, "text", RAW_ATTR_MODEL_COLUMN_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (raw_attr->tree_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(on_value_edited), view); column = gtk_tree_view_column_new_with_attributes( _("Value"), renderer, "text", RAW_ATTR_MODEL_COLUMN_VALUE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (raw_attr->tree_view), column); g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(raw_attr->tree_view)), "changed", G_CALLBACK(on_tree_view_selection_change), view); } /* Buttons to add and remove attributes: */ { GtkWidget *add_button = gtk_button_new_from_stock(GTK_STOCK_ADD); raw_attr->delete_button = gtk_button_new_from_stock(GTK_STOCK_DELETE); gtk_container_add(GTK_CONTAINER(hbox), add_button); gtk_container_add(GTK_CONTAINER(hbox), raw_attr->delete_button); gtk_widget_set_sensitive(raw_attr->delete_button, FALSE); g_signal_connect(G_OBJECT(add_button), "clicked", G_CALLBACK(on_add_attribute), view); g_signal_connect(G_OBJECT(raw_attr->delete_button), "clicked", G_CALLBACK(on_delete_attribute), view); gtk_widget_show(raw_attr->delete_button); gtk_widget_show(add_button); } gtk_container_add(GTK_CONTAINER(vbox), GTK_WIDGET(raw_attr->tree_view)); gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 0); gtk_widget_show(GTK_WIDGET(raw_attr->tree_view)); gtk_widget_show(hbox); gtk_widget_show(vbox); cong_dialog_category_add_selflabelled_field(raw_attr->category, vbox, TRUE); }
static void bt_settings_dialog_init_ui (const BtSettingsDialog * self) { GtkWidget *box, *scrolled_window, *pages; GtkCellRenderer *renderer; GtkListStore *store; GtkTreeIter tree_iter; gtk_widget_set_name (GTK_WIDGET (self), "buzztrax settings"); //gtk_widget_set_size_request(GTK_WIDGET(self),800,600); gtk_window_set_title (GTK_WINDOW (self), _("buzztrax settings")); // add dialog commision widgets (okay, cancel) gtk_dialog_add_buttons (GTK_DIALOG (self), _("_OK"), GTK_RESPONSE_ACCEPT, _("_Cancel"), GTK_RESPONSE_REJECT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (self), GTK_RESPONSE_ACCEPT); // add widgets to the dialog content area box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (box), 6); // add a list on the right and a notebook without tabs on the left scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); self->priv->settings_list = GTK_TREE_VIEW (gtk_tree_view_new ()); gtk_tree_view_set_headers_visible (self->priv->settings_list, FALSE); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_insert_column_with_attributes (self->priv->settings_list, -1, NULL, renderer, "icon-name", COL_ICON_NAME, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); gtk_tree_view_insert_column_with_attributes (self->priv->settings_list, -1, NULL, renderer, "text", COL_LABEL, NULL); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (self-> priv->settings_list), GTK_SELECTION_BROWSE); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (self->priv->settings_list)); gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (scrolled_window), FALSE, FALSE, 0); g_signal_connect (self->priv->settings_list, "realize", G_CALLBACK (on_settings_list_realize), (gpointer) scrolled_window); g_signal_connect (self->priv->settings_list, "cursor-changed", G_CALLBACK (on_settings_list_cursor_changed), (gpointer) self); store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_LONG, G_TYPE_STRING); //-- append entries for settings pages gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Audio Devices"), COL_ID, BT_SETTINGS_PAGE_AUDIO_DEVICES, COL_ICON_NAME, "audio-card", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Directories"), COL_ID, BT_SETTINGS_PAGE_DIRECTORIES, COL_ICON_NAME, "folder", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Interaction Controller"), COL_ID, BT_SETTINGS_PAGE_INTERACTION_CONTROLLER, COL_ICON_NAME, "input-gaming", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Playback Controller"), COL_ID, BT_SETTINGS_PAGE_PLAYBACK_CONTROLLER, COL_ICON_NAME, "media-playback-start", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Shortcuts"), COL_ID, BT_SETTINGS_PAGE_SHORTCUTS, COL_ICON_NAME, "input-keyboard", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("User interface"), COL_ID, BT_SETTINGS_PAGE_UI, COL_ICON_NAME, "preferences-desktop-theme", -1); gtk_tree_view_set_model (self->priv->settings_list, GTK_TREE_MODEL (store)); g_object_unref (store); // drop with treeview // add notebook pages = gtk_notebook_new (); self->priv->settings_pages = GTK_NOTEBOOK (pages); gtk_widget_set_name (pages, "settings pages"); gtk_notebook_set_show_tabs (self->priv->settings_pages, FALSE); gtk_notebook_set_show_border (self->priv->settings_pages, FALSE); gtk_container_add (GTK_CONTAINER (box), pages); // add audio device page self->priv->audiodevices_page = bt_settings_page_audiodevices_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->audiodevices_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_AUDIO_DEVICES), gtk_label_new (_("Audio Devices"))); // add directories page self->priv->directories_page = bt_settings_page_directories_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->directories_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_DIRECTORIES), gtk_label_new (_("Directories"))); // add interaction controller page self->priv->interaction_controller_page = bt_settings_page_interaction_controller_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->interaction_controller_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_INTERACTION_CONTROLLER), gtk_label_new (_("Interaction Controller"))); // add playback controller page self->priv->playback_controller_page = bt_settings_page_playback_controller_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->playback_controller_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_PLAYBACK_CONTROLLER), gtk_label_new (_("Playback Controller"))); // add shortcuts pags self->priv->shortcuts_page = bt_settings_page_shortcuts_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->shortcuts_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_SHORTCUTS), gtk_label_new (_("Shortcuts"))); // add ui page self->priv->ui_page = bt_settings_page_ui_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->ui_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_UI), gtk_label_new (_("User Interface"))); /* TODO(ensonic): more settings * - misc * - initial song bpm (from, to) * - cpu monitor (view menu?) */ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), box, TRUE, TRUE, 0); }
void gui_create_tasks(GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table; GtkWidget *label; GtkWidget *top_scrolledwindow; GtkWidget *hseparator; GtkWidget *close_button; GtkCellRenderer *renderer; GtkWidget *top_viewport; GtkWidget *bottom_viewport; GtkTextBuffer *text_buffer; GError *error = NULL; GtkActionGroup *action_group = NULL; gchar tmpbuf[BUFFER_SIZE]; const gchar *ui_info = " <toolbar name=\"toolbar\">\n" " <toolitem name=\"add\" action=\"add\" />\n" " <toolitem name=\"delete\" action=\"delete\" />\n" " <separator name=\"sep1\" />\n" " <toolitem name=\"edit\" action=\"edit\" />\n" " </toolbar>\n"; GtkActionEntry entries[] = { { "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL }, { "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL }, { "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL }, }; guint n_entries = G_N_ELEMENTS (entries); appGUI->tsk->filter_index = 0; vbox1 = gtk_vbox_new (FALSE, 1); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8); sprintf(tmpbuf, "<b>%s</b>", _("Tasks")); gui_add_to_notebook (vbox1, tmpbuf, appGUI); appGUI->tsk->vbox = GTK_BOX(vbox1); if (config.hide_tasks == TRUE) { gtk_widget_hide(GTK_WIDGET(appGUI->tsk->vbox)); } /*-------------------------------------------------------------------------------------*/ action_group = gtk_action_group_new ("_actions"); gtk_action_group_add_actions (action_group, entries, n_entries, NULL); gtk_action_group_set_sensitive(action_group, TRUE); appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0); g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI); if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) { g_message ("building toolbar failed: %s", error->message); g_error_free (error); } gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget); gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS); gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips); /*-------------------------------------------------------------------------------------*/ /* assign callbacks */ g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked", G_CALLBACK(tasks_add_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked", G_CALLBACK(tasks_edit_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked", G_CALLBACK(tasks_remove_item_cb), appGUI); /*-------------------------------------------------------------------------------------*/ gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE); gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "<b>%s:</b>", _("Category filter")); 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_label_set_use_markup (GTK_LABEL (label), TRUE); appGUI->tsk->cf_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->cf_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(appGUI->tsk->cf_combobox, "changed", G_CALLBACK(category_filter_cb), appGUI); g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus", G_CALLBACK(category_combo_box_focus_cb), NULL); appGUI->tsk->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->tsk->n_items_label); gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); /*-------------------------------------------------------------------------------------*/ appGUI->tsk->tasks_paned = gtk_vpaned_new(); gtk_widget_show (appGUI->tsk->tasks_paned); gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999); gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0); top_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (top_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE); gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE); top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (top_scrolledwindow); gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT); appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), (GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb, appGUI, NULL); appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter)); appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint); gtk_widget_show (appGUI->tsk->tasks_list); GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED])); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL])); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event", G_CALLBACK(list_dbclick_cb), appGUI); appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list)); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed", G_CALLBACK(tasks_item_selected), appGUI); /* create columns */ renderer = gtk_cell_renderer_toggle_new(); appGUI->tsk->tasks_columns[TA_COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"), renderer, "active", TA_COLUMN_DONE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DONE]); g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"), renderer, "text", TA_COLUMN_DUE_DATE, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE], config.visible_due_date_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", TA_COLUMN_DUE_DATE_JULIAN, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DUE_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", TA_COLUMN_START_DATE_JULIAN, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_START_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"), renderer, "text", TA_COLUMN_PRIORITY, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY], config.visible_priority_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_PRIORITY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", TA_COLUMN_CATEGORY, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY], config.visible_category_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_CATEGORY]); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_renderer_set_fixed_size(renderer, 0, -1); appGUI->tsk->tasks_columns[TA_COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"), renderer, "text", TA_COLUMN_SUMMARY, "strikethrough", TA_COLUMN_DONE, "foreground", TA_COLUMN_COLOR, "weight", TA_COLUMN_BOLD, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_SUMMARY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", TA_COLUMN_DESCRIPTION, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_DESCRIPTION]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", TA_COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_COLOR], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_COLOR]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[TA_COLUMN_BOLD] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", TA_COLUMN_BOLD, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[TA_COLUMN_BOLD], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[TA_COLUMN_BOLD]); /* configure list options */ gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE); /* configure sorting */ gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0, (GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_DUE_DATE, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_PRIORITY, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, TA_COLUMN_DONE, config.tasks_sorting_order); /*----------------------------------------------------------------------------*/ bottom_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (bottom_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE); gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0); gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2); appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0); gtk_widget_show(appGUI->tsk->panel_hbox); sprintf(tmpbuf, "%s:", _("Task details")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0); if (config.default_stock_icons) { close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE); } else { close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE); } GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL); gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (panel_close_desc_cb), appGUI); appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (appGUI->tsk->panel_scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_widget_show (appGUI->tsk->tasks_desc_textview); gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview)); gtk_text_buffer_create_tag (text_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL); appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font", "font", (gchar *) config.task_info_font, NULL); }
static void setup_search (CinnamonControlCenter *shell) { GtkWidget *search_view, *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; CinnamonControlCenterPrivate *priv = shell->priv; g_return_if_fail (priv->store != NULL); /* create the search filter */ priv->search_filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->search_filter), (GtkTreeModelFilterVisibleFunc) model_filter_func, priv, NULL); /* set up the search view */ priv->search_view = search_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (search_view), FALSE); gtk_tree_view_set_model (GTK_TREE_VIEW (search_view), GTK_TREE_MODEL (priv->search_filter)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "follow-state", TRUE, "xpad", 15, "ypad", 10, "stock-size", GTK_ICON_SIZE_DIALOG, NULL); column = gtk_tree_view_column_new_with_attributes ("Icon", renderer, "gicon", COL_GICON, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 0, NULL); column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", COL_NAME, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 15, NULL); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", COL_DESCRIPTION, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); priv->search_scrolled = W (priv->builder, "search-scrolled-window"); gtk_container_add (GTK_CONTAINER (priv->search_scrolled), search_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->search_view)), "changed", G_CALLBACK (on_search_selection_changed), shell); }
void gui_create_tasks_page (GtkWidget *vbox, GUI *appGUI) { GtkWidget *vbox5, *vbox6; GtkWidget *vbox7, *vbox11, *vbox12; GtkWidget *label; GtkWidget *hbox1; GtkWidget *frame; GtkWidget *table; GtkWidget *alignment; GtkWidget *ti_font_button; GtkWidget *scrolledwindow; GtkWidget *tasks_category_table; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gchar tmpbuf[BUFFER_SIZE]; GdkColor color; 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); vbox5 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox5); gtk_container_add (GTK_CONTAINER (alignment), vbox5); table = gtk_table_new (3, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox5), table, FALSE, FALSE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 4); gtk_table_set_row_spacings (GTK_TABLE (table), 8); hbox1 = gtk_hbox_new (FALSE, 8); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (table), hbox1, 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); gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->due_today_color_picker, _("Color of items that are due today"), NULL); 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 (hbox1), 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); gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->due_7days_color_picker, _("Color of items that are due in the next 7 days"), NULL); 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 (hbox1), 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); gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->past_due_color_picker, _("Color of items that are past due"), NULL); 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 (hbox1), 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 = gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE); } else { ti_font_button = 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); 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); vbox12 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox12); gtk_container_add (GTK_CONTAINER (alignment), vbox12); table = gtk_table_new (1, 3, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox12), 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_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, 1, 2, 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, 2, 3, 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); vbox6 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox6); gtk_container_add (GTK_CONTAINER (alignment), vbox6); tasks_category_table = gtk_table_new (4, 3, FALSE); gtk_widget_show (tasks_category_table); gtk_box_pack_start (GTK_BOX (vbox6), 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(1, G_TYPE_STRING); 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), FALSE); 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, 80); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column); if (config.default_stock_icons) { appGUI->opt->tasks_category_add_button = gui_stock_button(GTK_STOCK_ADD, FALSE); } else { appGUI->opt->tasks_category_add_button = 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 = gui_stock_button(GTK_STOCK_REMOVE, FALSE); } else { appGUI->opt->tasks_category_remove_button = 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); vbox7 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox7); gtk_container_add (GTK_CONTAINER (alignment), vbox7); table = gtk_table_new (1, 5, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox7), 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); vbox11 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox11); gtk_container_add (GTK_CONTAINER (alignment), vbox11); 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 (vbox11), 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 (vbox11), 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); }
void cal_notes_browser (GUI *appGUI) { GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *scrolledwindow; GtkWidget *hseparator; GtkWidget *hbuttonbox; GtkWidget *close_button; GtkWidget *notes_tools_table; GtkWidget *label; GtkObject *notes_month_spinbutton_adj; GtkObject *notes_year_spinbutton_adj; GtkTreeViewColumn *column; GtkCellRenderer *renderer; gchar tmpbuf[BUFFER_SIZE]; appGUI->cal->day_notes_list = NULL; appGUI->cal->day_notes_list_store = NULL; appGUI->cal->day_notes_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (appGUI->cal->day_notes_window), _("Calendar notes")); gtk_window_set_position (GTK_WINDOW (appGUI->cal->day_notes_window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_default_size (GTK_WINDOW(appGUI->cal->day_notes_window), config.cb_window_size_x, config.cb_window_size_y); gtk_window_set_modal (GTK_WINDOW (appGUI->cal->day_notes_window), TRUE); g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "delete_event", G_CALLBACK(day_notes_window_close_cb), appGUI); gtk_window_set_transient_for(GTK_WINDOW(appGUI->cal->day_notes_window), GTK_WINDOW(appGUI->main_window)); gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->day_notes_window), 8); g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "key_press_event", G_CALLBACK (day_notes_key_press_cb), appGUI); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (appGUI->cal->day_notes_window), vbox1); notes_tools_table = gtk_table_new (6, 3, FALSE); gtk_widget_show (notes_tools_table); gtk_box_pack_start (GTK_BOX (vbox1), notes_tools_table, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (notes_tools_table), 3); gtk_table_set_col_spacings (GTK_TABLE (notes_tools_table), 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); sprintf(tmpbuf, "<b>%s:</b>", _("Search")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (notes_tools_table), hbox1, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); notes_month_spinbutton_adj = gtk_adjustment_new (1, 1, 12, 1, 5, 0); appGUI->cal->notes_month_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_month_spinbutton_adj), 1, 0); gtk_widget_show (appGUI->cal->notes_month_spinbutton); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_month_spinbutton, TRUE, TRUE, 0); g_signal_connect (appGUI->cal->notes_month_spinbutton, "value-changed", G_CALLBACK (notes_filter_changed_cb), appGUI); notes_year_spinbutton_adj = gtk_adjustment_new (utl_date_get_current_year (), 1, 9999, 1, 10, 0); appGUI->cal->notes_year_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_year_spinbutton_adj), 1, 0); gtk_widget_show (appGUI->cal->notes_year_spinbutton); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_year_spinbutton, TRUE, TRUE, 0); g_signal_connect (appGUI->cal->notes_year_spinbutton, "value-changed", G_CALLBACK (notes_filter_changed_cb), appGUI); sprintf(tmpbuf, "<b>%s:</b>", _("Filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->cal->notes_filter_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->cal->notes_filter_combobox); g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "focus", G_CALLBACK(notes_filter_combo_box_focus_cb), NULL); g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "changed", G_CALLBACK(notes_filter_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_filter_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current month")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month and year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("All notes")); gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->cal->notes_filter_combobox), config.day_notes_browser_filter); appGUI->cal->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->cal->n_items_label); gtk_widget_set_size_request (appGUI->cal->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->n_items_label, 2, 3, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->cal->n_items_label), TRUE); appGUI->cal->notes_search_entry = gtk_entry_new (); gtk_widget_show (appGUI->cal->notes_search_entry); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_entry, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (appGUI->cal->notes_search_entry), "key_press_event", G_CALLBACK (search_entry_key_press_cb), appGUI); appGUI->cal->notes_search_checkbutton = gtk_check_button_new_with_mnemonic (_("Case sensitive")); gtk_widget_show (appGUI->cal->notes_search_checkbutton); GTK_WIDGET_UNSET_FLAGS(appGUI->cal->notes_search_checkbutton, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_checkbutton, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); appGUI->cal->past_notes_checkbutton = gtk_check_button_new_with_mnemonic (_("Strikethrough past day notes")); GTK_WIDGET_UNSET_FLAGS(appGUI->cal->past_notes_checkbutton, GTK_CAN_FOCUS); g_signal_connect (G_OBJECT (appGUI->cal->past_notes_checkbutton), "toggled", G_CALLBACK (browser_past_notes_cb), appGUI); gtk_widget_show (appGUI->cal->past_notes_checkbutton); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->past_notes_checkbutton, 0, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->cal->day_notes_list_store = gtk_list_store_new(DAY_NOTES_NUM_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN); appGUI->cal->day_notes_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->cal->day_notes_list_store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->cal->day_notes_list), TRUE); gtk_widget_show (appGUI->cal->day_notes_list); GTK_WIDGET_SET_FLAGS (appGUI->cal->day_notes_list, GTK_CAN_DEFAULT); gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->cal->day_notes_list); g_signal_connect(G_OBJECT(appGUI->cal->day_notes_list), "button_press_event", G_CALLBACK(day_notes_list_dbclick_cb), appGUI); appGUI->cal->day_notes_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->cal->day_notes_list)); /* create columns */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Date"), renderer, "text", DN_COLUMN_DATE, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Julian", renderer, "text", DN_COLUMN_DATE_JULIAN, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); gtk_tree_view_column_set_sort_column_id (column, DN_COLUMN_DATE_JULIAN); g_signal_emit_by_name(column, "clicked"); if (config.ascending_sorting_in_day_notes_browser == FALSE) { g_signal_emit_by_name(column, "clicked"); } renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes(_("Note"), renderer, "text", DN_COLUMN_NOTE_LINE, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); refresh_notes_list (config.day_notes_browser_filter, NULL, appGUI); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4); close_button = utl_gui_create_button (GTK_STOCK_CLOSE, OSMO_STOCK_BUTTON_CLOSE, _("Close")); gtk_widget_show (close_button); GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); g_signal_connect(close_button, "clicked", G_CALLBACK(button_day_notes_window_close_cb), appGUI); gtk_container_add(GTK_CONTAINER(hbuttonbox), close_button); gtk_widget_show(appGUI->cal->day_notes_window); gtk_widget_grab_focus (appGUI->cal->day_notes_list); }
int I_PickIWad_Gtk (WadStuff *wads, int numwads, bool showwin, int defaultiwad) { GtkWidget *window; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *bbox; GtkWidget *widget; GtkWidget *tree; GtkWidget *check; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkTreeIter iter, defiter; int close_style = 0; int i; char caption[100]; // Create the dialog window. window = gtk_window_new (GTK_WINDOW_TOPLEVEL); mysnprintf(caption, countof(caption), GAMESIG " %s: Select an IWAD to use", GetVersionString()); gtk_window_set_title (GTK_WINDOW(window), caption); gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width (GTK_CONTAINER(window), 10); g_signal_connect (window, "delete_event", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect (window, "key_press_event", G_CALLBACK(CheckEscape), NULL); // Create the vbox container. vbox = gtk_vbox_new (FALSE, 10); gtk_container_add (GTK_CONTAINER(window), vbox); // Create the top label. widget = gtk_label_new ("ZDoom found more than one IWAD\nSelect from the list below to determine which one to use:"); gtk_box_pack_start (GTK_BOX(vbox), widget, false, false, 0); gtk_misc_set_alignment (GTK_MISC(widget), 0, 0); // Create a list store with all the found IWADs. store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); for (i = 0; i < numwads; ++i) { const char *filepart = strrchr (wads[i].Path, '/'); if (filepart == NULL) filepart = wads[i].Path; else filepart++; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, filepart, 1, wads[i].Name.GetChars(), 2, i, -1); if (i == defaultiwad) { defiter = iter; } } // Create the tree view control to show the list. tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("IWAD", renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Game", renderer, "text", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column); gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(tree), true, true, 0); g_signal_connect(G_OBJECT(tree), "button_press_event", G_CALLBACK(DoubleClickChecker), &close_style); g_signal_connect(G_OBJECT(tree), "key_press_event", G_CALLBACK(AllowDefault), window); // Select the default IWAD. selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree)); gtk_tree_selection_select_iter (selection, &defiter); // Create the hbox for the bottom row. hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_end (GTK_BOX(vbox), hbox, false, false, 0); // Create the "Don't ask" checkbox. check = gtk_check_button_new_with_label ("Don't ask me this again"); gtk_box_pack_start (GTK_BOX(hbox), check, false, false, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), !showwin); // Create the OK/Cancel button box. bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX(bbox), 10); gtk_box_pack_end (GTK_BOX(hbox), bbox, false, false, 0); // Create the OK button. widget = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0); GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT); gtk_widget_grab_default (widget); g_signal_connect (widget, "clicked", G_CALLBACK(ClickedOK), &close_style); g_signal_connect (widget, "activate", G_CALLBACK(ClickedOK), &close_style); // Create the cancel button. widget = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0); g_signal_connect (widget, "clicked", G_CALLBACK(gtk_main_quit), &window); // Finally we can show everything. gtk_widget_show_all (window); gtk_main (); if (close_style == 1) { GtkTreeModel *model; GValue value = { 0, { {0} } }; // Find out which IWAD was selected. gtk_tree_selection_get_selected (selection, &model, &iter); gtk_tree_model_get_value (GTK_TREE_MODEL(model), &iter, 2, &value); i = g_value_get_int (&value); g_value_unset (&value); // Set state of queryiwad based on the checkbox. queryiwad = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check)); } else { i = -1; } if (GTK_IS_WINDOW(window)) { gtk_widget_destroy (window); // If we don't do this, then the X window might not actually disappear. while (g_main_context_iteration (NULL, FALSE)) {} } return i; }
void properties_cb (GtkAction *action, EyesApplet *eyes_applet) { GtkWidget *pbox, *hbox; GtkWidget *vbox, *indent; GtkWidget *categories_vbox; GtkWidget *category_vbox, *control_vbox; GtkWidget *tree; GtkWidget *scrolled; GtkWidget *label; GtkListStore *model; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; GtkTreeIter iter; DIR *dfd; struct dirent *dp; int i; #ifdef PATH_MAX gchar filename [PATH_MAX]; #else gchar *filename; #endif gchar *title; if (eyes_applet->prop_box.pbox) { gtk_window_set_screen ( GTK_WINDOW (eyes_applet->prop_box.pbox), gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet))); gtk_window_present (GTK_WINDOW (eyes_applet->prop_box.pbox)); return; } pbox = gtk_dialog_new_with_buttons (_("Geyes Preferences"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_window_set_screen (GTK_WINDOW (pbox), gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet))); gtk_widget_set_size_request (GTK_WIDGET (pbox), 300, 200); gtk_dialog_set_default_response(GTK_DIALOG (pbox), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (pbox), FALSE); gtk_container_set_border_width (GTK_CONTAINER (pbox), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), 2); g_signal_connect (pbox, "response", G_CALLBACK (presponse_cb), eyes_applet); vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_widget_show (vbox); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), vbox, TRUE, TRUE, 0); categories_vbox = gtk_vbox_new (FALSE, 18); gtk_box_pack_start (GTK_BOX (vbox), categories_vbox, TRUE, TRUE, 0); gtk_widget_show (categories_vbox); category_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0); gtk_widget_show (category_vbox); title = g_strconcat ("<span weight=\"bold\">", _("Themes"), "</span>", NULL); label = gtk_label_new (_(title)); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0); g_free (title); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); indent = gtk_label_new (HIG_IDENTATION); gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0); gtk_widget_show (indent); control_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0); gtk_widget_show (control_vbox); label = gtk_label_new_with_mnemonic (_("_Select a theme:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (control_vbox), label, FALSE, FALSE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = gtk_list_store_new (TOTAL_COLS, G_TYPE_STRING, G_TYPE_STRING); tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree), FALSE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), tree); g_object_unref (model); gtk_container_add (GTK_CONTAINER (scrolled), tree); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("not used", cell, "text", COL_THEME_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); g_signal_connect (selection, "changed", G_CALLBACK (theme_selected_cb), eyes_applet); if ( ! g_settings_is_writable (eyes_applet->settings, "theme-path")) { gtk_widget_set_sensitive (tree, FALSE); gtk_widget_set_sensitive (label, FALSE); } for (i = 0; i < NUM_THEME_DIRECTORIES; i++) { if ((dfd = opendir (theme_directories[i])) != NULL) { while ((dp = readdir (dfd)) != NULL) { if (dp->d_name[0] != '.') { gchar *theme_dir; gchar *theme_name; #ifdef PATH_MAX strcpy (filename, theme_directories[i]); strcat (filename, dp->d_name); #else asprintf (&filename, theme_directories[i], dp->d_name); #endif theme_dir = g_strdup_printf ("%s/", filename); theme_name = g_path_get_basename (filename); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_THEME_DIR, &filename, COL_THEME_NAME, theme_name, -1); if (!g_ascii_strncasecmp (eyes_applet->theme_dir, theme_dir, strlen (theme_dir))) { GtkTreePath *path; path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree), path, NULL, FALSE); gtk_tree_path_free (path); } g_free (theme_name); g_free (theme_dir); } } closedir (dfd); } } #ifndef PATH_MAX g_free (filename); #endif gtk_box_pack_start (GTK_BOX (control_vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show_all (pbox); eyes_applet->prop_box.pbox = pbox; return; }
/* Create list */ static GtkWidget* create_list(void) { GtkListStore *list_store; GtkWidget *list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSortable *sortable; GtkTreeView *list_view; GtkTreeSelection *selection; /* Create the store */ list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/ G_TYPE_UINT, /* IEI */ G_TYPE_STRING, /* Message Name */ G_TYPE_UINT); /* Count */ /* Create a view */ list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); list_view = GTK_TREE_VIEW(list); sortable = GTK_TREE_SORTABLE(list_store); /* Speed up the list display */ gtk_tree_view_set_fixed_height_mode(list_view, TRUE); /* Setup the sortable columns */ gtk_tree_sortable_set_sort_column_id(sortable, IEI_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_headers_clickable(list_view, FALSE); /* The view now holds a reference. We can get rid of our own reference */ g_object_unref (G_OBJECT (list_store)); /* * Create the first column packet, associating the "text" attribute of the * cell_renderer to the first column of the model */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("IEI", renderer, "text", IEI_COLUMN, NULL); /* gtk_tree_view_column_set_cell_data_func(column, renderer, present_as_hex_func, GINT_TO_POINTER(IEI_COLUMN), NULL); */ gtk_tree_view_column_set_sort_column_id(column, IEI_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 50); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); /* Second column.. Message Name. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Message Name", renderer, "text", MSG_NAME_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, MSG_NAME_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 280); gtk_tree_view_append_column (list_view, column); /* Third column.. Count. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Count", renderer, "text", COUNT_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, COUNT_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 50); gtk_tree_view_append_column (list_view, column); /* Now enable the sorting of each column */ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE); /* Setup the selection handler */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); return list; }
void gui_init(dt_lib_module_t *self) { dt_lib_styles_t *d = (dt_lib_styles_t *)malloc(sizeof(dt_lib_styles_t)); self->data = (void *)d; d->edit_button = NULL; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); GtkWidget *w; GtkWidget *scrolled; /* list */ d->list = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->list, FALSE); GtkListStore *liststore = gtk_list_store_new(DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(d->list), col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_STYLES_COL_NAME); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore)); g_object_unref(liststore); gtk_widget_set_tooltip_text(GTK_WIDGET(d->list), _("available styles,\ndoubleclick to apply")); g_signal_connect(d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d); /* filter entry */ w = gtk_entry_new(); d->entry = GTK_ENTRY(w); gtk_widget_set_tooltip_text(w, _("enter style name")); g_signal_connect(d->entry, "changed", G_CALLBACK(entry_callback), d); g_signal_connect(d->entry, "activate", G_CALLBACK(entry_activated), d); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), DT_PIXEL_APPLY_DPI(150)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->entry), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scrolled), TRUE, FALSE, 0); gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(d->list)); d->duplicate = gtk_check_button_new_with_label(_("create duplicate")); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->duplicate), TRUE, FALSE, 0); g_signal_connect(d->duplicate, "toggled", G_CALLBACK(duplicate_callback), d); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->duplicate), dt_conf_get_bool("ui_last/styles_create_duplicate")); gtk_widget_set_tooltip_text(d->duplicate, _("creates a duplicate of the image before applying style")); GtkWidget *hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); GtkWidget *hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), hbox2, TRUE, FALSE, 0); // create GtkWidget *cbutton = gtk_button_new_with_label(_("create")); g_signal_connect(G_OBJECT(cbutton), "clicked", G_CALLBACK(create_clicked), d); gtk_widget_set_tooltip_text(cbutton, _("create styles from history stack of selected images")); gtk_box_pack_start(GTK_BOX(hbox1), cbutton, TRUE, TRUE, 0); // edit GtkWidget *widget = gtk_button_new_with_label(_("edit")); d->edit_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(edit_clicked), d); gtk_widget_set_tooltip_text(widget, _("edit the selected style in list above")); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // delete widget = gtk_button_new_with_label(_("delete")); d->delete_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(delete_clicked), d); gtk_widget_set_tooltip_text(widget, _("deletes the selected style in list above")); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // import button GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import")); d->import_button = importButton; gtk_widget_set_tooltip_text(importButton, _("import style from a style file")); g_signal_connect(importButton, "clicked", G_CALLBACK(import_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), importButton, TRUE, TRUE, 0); // export button GtkWidget *exportButton = gtk_button_new_with_label(_("export")); d->export_button = exportButton; gtk_widget_set_tooltip_text(exportButton, _("export the selected style into a style file")); g_signal_connect(exportButton, "clicked", G_CALLBACK(export_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), exportButton, TRUE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->list))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* update filtered list */ _gui_styles_update_view(d); dt_control_signal_connect(darktable.signals, DT_SIGNAL_STYLE_CHANGED, G_CALLBACK(_styles_changed_callback), d); }
bool wxListBox::Create( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, int n, const wxString choices[], long style, const wxValidator& validator, const wxString &name ) { if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxListBox creation failed") ); return false; } m_widget = gtk_scrolled_window_new( NULL, NULL ); g_object_ref(m_widget); if (style & wxLB_ALWAYS_SB) { gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS ); } else { gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); } GTKScrolledWindowSetBorder(m_widget, style); m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) ); //wxListBox doesn't have a header :) //NB: If enabled SetFirstItem doesn't work correctly gtk_tree_view_set_headers_visible(m_treeview, FALSE); #if wxUSE_CHECKLISTBOX if(m_hasCheckBoxes) ((wxCheckListBox*)this)->DoCreateCheckList(); #endif // wxUSE_CHECKLISTBOX // Create the data column gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "", gtk_cell_renderer_text_new(), "text", WXLISTBOX_DATACOLUMN, NULL); // Now create+set the model (GtkListStore) - first argument # of columns #if wxUSE_CHECKLISTBOX if(m_hasCheckBoxes) m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN, WX_TYPE_TREE_ENTRY); else #endif m_liststore = gtk_list_store_new(1, WX_TYPE_TREE_ENTRY); gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore)); g_object_unref (m_liststore); //free on treeview destruction // Disable the pop-up textctrl that enables searching - note that // the docs specify that even if this disabled (which we are doing) // the user can still have it through the start-interactive-search // key binding...either way we want to provide a searchequal callback // NB: If this is enabled a doubleclick event (activate) gets sent // on a successful search gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN); gtk_tree_view_set_search_equal_func(m_treeview, (GtkTreeViewSearchEqualFunc) gtk_listbox_searchequal_callback, this, NULL); gtk_tree_view_set_enable_search(m_treeview, FALSE); GtkSelectionMode mode; // GTK_SELECTION_EXTENDED is a deprecated synonym for GTK_SELECTION_MULTIPLE if ( style & (wxLB_MULTIPLE | wxLB_EXTENDED) ) { mode = GTK_SELECTION_MULTIPLE; } else // no multi-selection flags specified { m_windowStyle |= wxLB_SINGLE; // Notice that we must use BROWSE and not GTK_SELECTION_SINGLE because // the latter allows to not select any items at all while a single // selection listbox is supposed to always have a selection (at least // once the user selected something, it might not have any initially). mode = GTK_SELECTION_BROWSE; } GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview ); gtk_tree_selection_set_mode( selection, mode ); // Handle sortable stuff if(HasFlag(wxLB_SORT)) { // Setup sorting in ascending (wx) order gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore), WXLISTBOX_DATACOLUMN, GTK_SORT_ASCENDING); // Set the sort callback gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore), WXLISTBOX_DATACOLUMN, (GtkTreeIterCompareFunc) gtk_listbox_sort_callback, this, //userdata NULL //"destroy notifier" ); } gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) ); gtk_widget_show( GTK_WIDGET(m_treeview) ); m_focusWidget = GTK_WIDGET(m_treeview); Append(n, choices); // insert initial items // generate dclick events g_signal_connect_after(m_treeview, "row-activated", G_CALLBACK(gtk_listbox_row_activated_callback), this); // for intercepting dclick generation by <ENTER> g_signal_connect (m_treeview, "key_press_event", G_CALLBACK (gtk_listbox_key_press_callback), this); m_parent->DoAddChild( this ); PostCreation(size); SetInitialSize(size); // need this too because this is a wxControlWithItems g_signal_connect_after (selection, "changed", G_CALLBACK (gtk_listitem_changed_callback), this); return true; }
GtkWidget * gnome_prefs_window_new (const gchar *logo_name) { GnomePrefsWindow *gpw = NULL; GtkTreeSelection *selection = NULL; GtkCellRenderer *cell = NULL; GtkTreeStore *model = NULL; GtkTreeViewColumn *column = NULL; GtkWidget *window = NULL; GtkWidget *event_box = NULL; GtkWidget *hbox = NULL; GtkWidget *vbox = NULL; GtkWidget *frame = NULL; GtkWidget *pixmap = NULL; GtkWidget *hsep = NULL; GdkColor cwhite; PangoAttrList *attrs = NULL; PangoAttribute *attr = NULL; /* Box inside the prefs window */ GtkWidget *dialog_vbox = NULL; /* Build the window */ window = gtk_dialog_new (); gpw = (GnomePrefsWindow *) g_malloc (sizeof (GnomePrefsWindow)); gpw->last_page = 1; g_object_set_data_full (G_OBJECT (window), "gpw", (gpointer) gpw, g_free); gtk_dialog_add_button (GTK_DIALOG (window), GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL); /* The sections */ gpw->notebook = gtk_notebook_new (); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (gpw->notebook), FALSE); gtk_notebook_set_show_border (GTK_NOTEBOOK (gpw->notebook), FALSE); pixmap = gtk_image_new_from_file (logo_name); event_box = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (event_box), GTK_WIDGET (pixmap)); cwhite.red = 0xff * 0x100; cwhite.green = 0xff * 0x100; cwhite.blue = 0xff * 0x100; gdk_colormap_alloc_color(gdk_colormap_get_system (), &cwhite, FALSE, TRUE); gtk_widget_modify_bg (GTK_WIDGET (event_box), GTK_STATE_NORMAL, &cwhite); gtk_notebook_prepend_page (GTK_NOTEBOOK (gpw->notebook), event_box, NULL); /* The sections */ dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (window)); hbox = gtk_hbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); gtk_container_add (GTK_CONTAINER (dialog_vbox), hbox); /* Build the TreeView on the left */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); model = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_INT); gpw->sections_tree_view = gtk_tree_view_new (); gtk_tree_view_set_model (GTK_TREE_VIEW (gpw->sections_tree_view), GTK_TREE_MODEL (model)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (gpw->sections_tree_view)); gtk_container_add (GTK_CONTAINER (frame), gpw->sections_tree_view); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gpw->sections_tree_view), FALSE); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, cell, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (gpw->sections_tree_view), GTK_TREE_VIEW_COLUMN (column)); gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection), GTK_SELECTION_BROWSE); /* Some design stuff to put the notebook pages in it */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); gpw->section_label = gtk_label_new (NULL); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); gtk_container_set_border_width (GTK_CONTAINER (frame), 4); gtk_misc_set_alignment (GTK_MISC (gpw->section_label), 0.0, 0.5); gtk_container_add (GTK_CONTAINER (frame), gpw->section_label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); attrs = pango_attr_list_new (); attr = pango_attr_scale_new (PANGO_SCALE_LARGE); attr->start_index = 0; attr->end_index = G_MAXUINT; pango_attr_list_insert (attrs, attr); attr = pango_attr_weight_new (PANGO_WEIGHT_HEAVY); attr->start_index = 0; attr->end_index = G_MAXUINT; pango_attr_list_insert (attrs, attr); gtk_label_set_attributes (GTK_LABEL (gpw->section_label), attrs); pango_attr_list_unref (attrs); gtk_widget_show (gpw->section_label); hsep = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), hsep, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), gpw->notebook, TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (dialog_vbox)); gtk_widget_show_all (GTK_WIDGET (gpw->sections_tree_view)); g_signal_connect (selection, "changed", G_CALLBACK (tree_selection_changed_cb), gpw); return window; }
void ags_automation_toolbar_init(AgsAutomationToolbar *automation_toolbar) { GtkMenuToolButton *menu_tool_button; GtkMenu *menu; GtkLabel *label; GtkCellRenderer *cell_renderer; automation_toolbar->position = g_object_new(GTK_TYPE_TOGGLE_BUTTON, "image\0", gtk_image_new_from_stock(GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_LARGE_TOOLBAR), "relief\0", GTK_RELIEF_NONE, NULL); gtk_toolbar_append_widget((GtkToolbar *) automation_toolbar, (GtkWidget *) automation_toolbar->position, "position cursor\0", NULL); automation_toolbar->edit = g_object_new(GTK_TYPE_TOGGLE_BUTTON, "image\0", gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_LARGE_TOOLBAR), "relief\0", GTK_RELIEF_NONE, NULL); automation_toolbar->selected_edit_mode = automation_toolbar->edit; gtk_toolbar_append_widget((GtkToolbar *) automation_toolbar, (GtkWidget *) automation_toolbar->edit, "edit automation\0", NULL); automation_toolbar->clear = g_object_new(GTK_TYPE_TOGGLE_BUTTON, "image\0", gtk_image_new_from_stock(GTK_STOCK_CLEAR, GTK_ICON_SIZE_LARGE_TOOLBAR), "relief\0", GTK_RELIEF_NONE, NULL); automation_toolbar->select = g_object_new(GTK_TYPE_TOGGLE_BUTTON, "image\0", gtk_image_new_from_stock(GTK_STOCK_SELECT_ALL, GTK_ICON_SIZE_LARGE_TOOLBAR), "relief\0", GTK_RELIEF_NONE, NULL); gtk_toolbar_append_widget((GtkToolbar *) automation_toolbar, (GtkWidget *) automation_toolbar->select, "select automation\0", NULL); automation_toolbar->copy = (GtkButton *) g_object_new(GTK_TYPE_BUTTON, "image\0", gtk_image_new_from_stock(GTK_STOCK_COPY, GTK_ICON_SIZE_LARGE_TOOLBAR), "relief\0", GTK_RELIEF_NONE, NULL); gtk_toolbar_append_widget((GtkToolbar *) automation_toolbar, automation_toolbar->copy, "copy automation\0", NULL); automation_toolbar->cut = (GtkButton *) g_object_new(GTK_TYPE_BUTTON, "image\0", gtk_image_new_from_stock(GTK_STOCK_CUT, GTK_ICON_SIZE_LARGE_TOOLBAR), "relief\0", GTK_RELIEF_NONE, NULL); gtk_toolbar_append_widget((GtkToolbar *) automation_toolbar, automation_toolbar->cut, "cut automation\0", NULL); automation_toolbar->paste = (GtkButton *) g_object_new(GTK_TYPE_BUTTON, "image\0", gtk_image_new_from_stock(GTK_STOCK_PASTE, GTK_ICON_SIZE_LARGE_TOOLBAR), "relief\0", GTK_RELIEF_NONE, NULL); gtk_toolbar_append_widget((GtkToolbar *) automation_toolbar, automation_toolbar->paste, "paste automation\0", NULL); /* */ automation_toolbar->zoom_history = 4; label = gtk_label_new("zoom\0"); gtk_container_add(GTK_CONTAINER(automation_toolbar), label); automation_toolbar->zoom = ags_zoom_combo_box_new(); gtk_combo_box_set_active(automation_toolbar->zoom, 4); gtk_toolbar_append_widget((GtkToolbar *) automation_toolbar, (GtkWidget *) automation_toolbar->zoom, NULL, NULL); /* */ label = gtk_label_new("port\0"); gtk_container_add(GTK_CONTAINER(automation_toolbar), label); automation_toolbar->port = gtk_combo_box_new(); cell_renderer = gtk_cell_renderer_toggle_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(automation_toolbar->port), cell_renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(automation_toolbar->port), cell_renderer, "active\0", 0, NULL); gtk_cell_renderer_toggle_set_activatable(cell_renderer, TRUE); cell_renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(automation_toolbar->port), cell_renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(automation_toolbar->port), cell_renderer, "text\0", 1, NULL); gtk_toolbar_append_widget((GtkToolbar *) automation_toolbar, (GtkWidget *) automation_toolbar->port, NULL, NULL); }