void init_right_tree(void) { GtkTreeView *view = GTK_TREE_VIEW(tree2_w); GtkCellRenderer *renderer; GtkTreeSelection *sel; GtkTreeViewColumn *column; gint i; gtk_tree_view_set_model(view, model2); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_rules_hint(view, TRUE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, column); gtk_tree_view_column_set_title(column, _("Options")); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "pixbuf", COL_PIXBUF, "visible", COL_PIXVIS, NULL); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "active", COL_BTNACT, "inconsistent", COL_BTNINC, "visible", COL_BTNVIS, "radio", COL_BTNRAD, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE); gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer, "text", COL_OPTION, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COL_NAME, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "N", renderer, "text", COL_NO, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "M", renderer, "text", COL_MOD, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "Y", renderer, "text", COL_YES, "foreground-gdk", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Value"), renderer, "text", COL_VALUE, "editable", COL_EDIT, "foreground-gdk", COL_COLOR, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(renderer_edited), NULL); column = gtk_tree_view_get_column(view, COL_NAME); gtk_tree_view_column_set_visible(column, show_name); column = gtk_tree_view_get_column(view, COL_NO); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_MOD); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_YES); gtk_tree_view_column_set_visible(column, show_range); column = gtk_tree_view_get_column(view, COL_VALUE); gtk_tree_view_column_set_visible(column, show_value); if (resizeable) { for (i = 0; i < COL_VALUE; i++) { column = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(column, TRUE); } } sel = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); }
GtkWidget* create_windowMain () { GtkWidget *vbox1; GtkWidget *hpaned1; GtkWidget *scrolledwindow1; GtkWidget *hbuttonbox1; GtkWidget *buttonRefresh; GtkWidget *buttonConfigure; GtkWidget *buttonClose; GtkWidget *buttonAbout; GdkPixbuf *icon; GtkCellRenderer *treeRenderer; GtkTreeViewColumn *treeColumn; windowMain = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (windowMain, "windowMain"); gtk_window_set_title (GTK_WINDOW (windowMain), "USB Viewer"); gtk_window_set_default_size (GTK_WINDOW (windowMain), 600, 300); icon = gdk_pixbuf_new_from_xpm_data((const char **)usbview_icon); gtk_window_set_icon(GTK_WINDOW(windowMain), icon); vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_set_name (vbox1, "vbox1"); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (windowMain), vbox1); hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_name (hpaned1, "hpaned1"); gtk_widget_show (hpaned1); gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0); treeStore = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, /* NAME_COLUMN */ G_TYPE_INT, /* DEVICE_ADDR_COLUMN */ G_TYPE_STRING /* COLOR_COLUMN */); treeUSB = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treeStore)); treeRenderer = gtk_cell_renderer_text_new (); treeColumn = gtk_tree_view_column_new_with_attributes ( "USB devices", treeRenderer, "text", NAME_COLUMN, "foreground", COLOR_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeUSB), treeColumn); gtk_widget_set_name (treeUSB, "treeUSB"); gtk_widget_show (treeUSB); gtk_paned_pack1 (GTK_PANED (hpaned1), treeUSB, FALSE, FALSE); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_name (scrolledwindow1, "scrolledwindow1"); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_show (scrolledwindow1); gtk_paned_pack2 (GTK_PANED (hpaned1), scrolledwindow1, TRUE, FALSE); textDescriptionBuffer = gtk_text_buffer_new(NULL); //textDescription = gtk_text_new (NULL, NULL); textDescriptionView = gtk_text_view_new_with_buffer(textDescriptionBuffer); gtk_widget_set_name (textDescriptionView, "textDescription"); gtk_text_view_set_editable(GTK_TEXT_VIEW(textDescriptionView), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textDescriptionView), FALSE); gtk_widget_show (textDescriptionView); gtk_container_add (GTK_CONTAINER (scrolledwindow1), textDescriptionView); hbuttonbox1 = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_name (hbuttonbox1, "hbuttonbox1"); gtk_widget_show (hbuttonbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, FALSE, 5); //gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10); //gtk_button_box_set_child_size (GTK_BUTTON_BOX (hbuttonbox1), 50, 25); //gtk_button_box_set_child_ipadding (GTK_BUTTON_BOX (hbuttonbox1), 25, 10); buttonRefresh = gtk_button_new_with_label("Refresh"); gtk_widget_set_name (buttonRefresh, "buttonRefresh"); gtk_widget_show (buttonRefresh); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonRefresh); gtk_container_set_border_width (GTK_CONTAINER (buttonRefresh), 4); gtk_widget_set_can_default (buttonRefresh, TRUE); buttonConfigure = gtk_button_new_with_label ("Configure..."); gtk_widget_set_name (buttonConfigure, "buttonConfigure"); gtk_widget_show (buttonConfigure); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonConfigure); gtk_container_set_border_width (GTK_CONTAINER (buttonConfigure), 4); gtk_widget_set_can_default (buttonConfigure, TRUE); buttonAbout = gtk_button_new_with_label("About"); gtk_widget_set_name (buttonAbout, "buttonAbout"); gtk_widget_show (buttonAbout); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonAbout); gtk_container_set_border_width (GTK_CONTAINER (buttonAbout), 4); gtk_widget_set_can_default (buttonAbout, TRUE); buttonClose = gtk_button_new_with_label("Quit"); gtk_widget_set_name (buttonClose, "buttonClose"); gtk_widget_show (buttonClose); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonClose); gtk_container_set_border_width (GTK_CONTAINER (buttonClose), 4); gtk_widget_set_can_default (buttonClose, TRUE); g_signal_connect (G_OBJECT (windowMain), "delete_event", G_CALLBACK (on_window1_delete_event), NULL); g_signal_connect (G_OBJECT (buttonRefresh), "clicked", G_CALLBACK (on_buttonRefresh_clicked), NULL); g_signal_connect (G_OBJECT (buttonConfigure), "clicked", G_CALLBACK (on_buttonConfigure_clicked), NULL); g_signal_connect (G_OBJECT (buttonAbout), "clicked", G_CALLBACK (on_buttonAbout_clicked), NULL); g_signal_connect (G_OBJECT (buttonClose), "clicked", G_CALLBACK (on_buttonClose_clicked), NULL); /* create our timer */ //timer = gtk_timeout_add (2000, on_timer_timeout, 0); return windowMain; }
static void games_scores_dialog_init (GamesScoresDialog *self) { GtkWidget *vbox; GtkWidget *scroll; GtkWidget *listview; GtkTreeViewColumn *column; GtkTreeViewColumn *timecolumn; GtkCellRenderer *renderer; GtkCellRenderer *timerenderer; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GAMES_TYPE_SCORES_DIALOG, GamesScoresDialogPrivate); self->priv->style = GAMES_SCORES_STYLE_PLAIN_DESCENDING; /* These two hashes are the reverse of each other. As an optimisation * they share the same set of strings (as keys in the first case and * as data in the second). The first hash is responsible for * deallocating the memory for the strings. These two are only * valid as a pair. */ self->priv->categories = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); self->priv->catindices = g_hash_table_new (g_direct_hash, g_direct_equal); self->priv->catcounter = 0; self->priv->hilight = 0; gtk_container_set_border_width (GTK_CONTAINER (self), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), 2); g_signal_connect (G_OBJECT (self), "show", G_CALLBACK (games_scores_dialog_show), NULL); g_signal_connect (G_OBJECT (self), "hide", G_CALLBACK (games_scores_dialog_hide), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), vbox, TRUE, TRUE, 0); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scroll, 200, 265); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_ETCHED_IN); gtk_box_pack_end (GTK_BOX (vbox), scroll, TRUE, TRUE, 0); self->priv->message = gtk_label_new (""); gtk_label_set_use_markup (GTK_LABEL (self->priv->message), TRUE); gtk_label_set_justify (GTK_LABEL (self->priv->message), GTK_JUSTIFY_CENTER); gtk_box_pack_start (GTK_BOX (vbox), self->priv->message, FALSE, FALSE, 0); self->priv->hdiv = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), self->priv->hdiv, FALSE, FALSE, 0); self->priv->catbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), self->priv->catbar, FALSE, FALSE, 0); self->priv->label = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (self->priv->label), TRUE); gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->label, FALSE, FALSE, 0); self->priv->combo = gtk_combo_box_text_new (); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (self->priv->combo), FALSE); gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->combo, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (self->priv->label), self->priv->combo); g_signal_connect (G_OBJECT (self->priv->combo), "changed", G_CALLBACK (games_scores_dialog_change_category), self); self->priv->list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); listview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->list)); self->priv->treeview = GTK_TREE_VIEW (listview); timerenderer = gtk_cell_renderer_text_new (); timecolumn = gtk_tree_view_column_new_with_attributes (/* Score dialog column header for the date the score was recorded */ _("Date"), timerenderer, "text", 0, NULL); g_object_set (G_OBJECT (timerenderer), "xalign", 1.0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (listview), GTK_TREE_VIEW_COLUMN (timecolumn)); self->priv->timecolumn = timecolumn; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", 1, NULL); g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (listview), GTK_TREE_VIEW_COLUMN (column)); self->priv->column = column; gtk_container_add (GTK_CONTAINER (scroll), listview); games_scores_dialog_set_buttons (self, GAMES_SCORES_CLOSE_BUTTON); gtk_window_set_destroy_with_parent (GTK_WINDOW (self), TRUE); gtk_widget_grab_focus (self->priv->combo); gtk_widget_show_all (vbox); gtk_widget_hide (self->priv->hdiv); gtk_widget_hide (self->priv->message); }
void preferences_dialog_init (PreferencesDialog *pd) { GtkWidget *widget, *entry; GtkComboBox *combo; GtkListStore *store; GtkTreeIter treeiter; GtkAdjustment *itemCount; GtkTreeStore *treestore; GtkTreeViewColumn *column; GSList *list; gchar *proxyport; gchar *configuredBrowser, *name; gboolean enabled; static int manual; struct browser *iter; gint tmp, i, iSetting, proxy_port; gboolean bSetting; gchar *proxy_host, *proxy_user, *proxy_passwd; gchar *browser_command; prefdialog = pd; pd->priv = PREFERENCES_DIALOG_GET_PRIVATE (pd); pd->priv->dialog = liferea_dialog_new ("prefs.ui", "prefdialog"); /* Set up browser selection popup */ store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); for(i = 0, iter = browser_get_all (); iter->id != NULL; iter++, i++) { gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _(iter->display), 1, i, -1); } manual = i; /* This allows the user to choose their own browser by typing in the command. */ gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("Manual"), 1, i, -1); combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserpopup")); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); ui_common_setup_combo_text (combo, 0); g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_changed), pd); /* Create location menu */ store = gtk_list_store_new (1, G_TYPE_STRING); combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserlocpopup")); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); ui_common_setup_combo_text (combo, 0); g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_place_changed), pd); gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("Browser default"), -1); gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("Existing window"), -1); gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("New window"), -1); gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, _("New tab"), -1); /* ================== panel 1 "feeds" ==================== */ /* check box for feed startup update */ conf_get_int_value (STARTUP_FEED_ACTION, &iSetting); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "startupactionbtn")), (iSetting == 0)); /* cache size setting */ widget = liferea_dialog_lookup (pd->priv->dialog, "itemCountBtn"); itemCount = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); conf_get_int_value (DEFAULT_MAX_ITEMS, &iSetting); gtk_adjustment_set_value (itemCount, iSetting); /* set default update interval spin button and unit combo box */ ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox"), default_update_interval_unit_options, G_CALLBACK (on_default_update_interval_unit_changed), -1); widget = liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox"); conf_get_int_value (DEFAULT_UPDATE_INTERVAL, &tmp); if (tmp % 1440 == 0) { /* days */ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 2); tmp /= 1440; } else if (tmp % 60 == 0) { /* hours */ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1); tmp /= 60; } else { /* minutes */ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); } widget = liferea_dialog_lookup (pd->priv->dialog,"globalRefreshIntervalSpinButton"); gtk_spin_button_set_range (GTK_SPIN_BUTTON (widget), 0, 1000000000); gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), tmp); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (on_default_update_interval_value_changed), pd); /* ================== panel 2 "folders" ==================== */ g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "updateAllFavicons")), "clicked", G_CALLBACK(on_updateallfavicons_clicked), pd); conf_get_int_value (FOLDER_DISPLAY_MODE, &iSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "folderdisplaybtn")), iSetting?TRUE:FALSE); conf_get_bool_value (FOLDER_DISPLAY_HIDE_READ, &bSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "hidereadbtn")), bSetting?TRUE:FALSE); /* ================== panel 3 "headlines" ==================== */ conf_get_int_value (BROWSE_KEY_SETTING, &iSetting); ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "skimKeyCombo"), browser_skim_key_options, G_CALLBACK (on_skim_key_changed), iSetting); conf_get_int_value (DEFAULT_VIEW_MODE, &iSetting); ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "defaultViewModeCombo"), default_view_mode_options, G_CALLBACK (on_default_view_mode_changed), iSetting); /* Setup social bookmarking list */ i = 0; conf_get_str_value (SOCIAL_BM_SITE, &name); store = gtk_list_store_new (1, G_TYPE_STRING); list = bookmarkSites; while (list) { socialSitePtr siter = list->data; if (name && !strcmp (siter->name, name)) tmp = i; gtk_list_store_append (store, &treeiter); gtk_list_store_set (store, &treeiter, 0, siter->name, -1); list = g_slist_next (list); i++; } combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "socialpopup")); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (on_socialsite_changed), pd); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); ui_common_setup_combo_text (combo, 0); gtk_combo_box_set_active (combo, tmp); /* ================== panel 4 "browser" ==================== */ /* set the inside browsing flag */ widget = liferea_dialog_lookup(pd->priv->dialog, "browseinwindow"); conf_get_bool_value(BROWSE_INSIDE_APPLICATION, &bSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting); /* set the javascript-disabled flag */ widget = liferea_dialog_lookup(pd->priv->dialog, "disablejavascript"); conf_get_bool_value(DISABLE_JAVASCRIPT, &bSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting); /* set the enable Plugins flag */ widget = liferea_dialog_lookup(pd->priv->dialog, "enableplugins"); conf_get_bool_value(ENABLE_PLUGINS, &bSetting); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting); tmp = 0; conf_get_str_value(BROWSER_ID, &configuredBrowser); if(!strcmp(configuredBrowser, "manual")) tmp = manual; else for(i=0, iter = browser_get_all (); iter->id != NULL; iter++, i++) if(!strcmp(configuredBrowser, iter->id)) tmp = i; gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserpopup")), tmp); g_free(configuredBrowser); conf_get_int_value (BROWSER_PLACE, &iSetting); gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserlocpopup")), iSetting); conf_get_str_value (BROWSER_COMMAND, &browser_command); entry = liferea_dialog_lookup(pd->priv->dialog, "browsercmd"); gtk_entry_set_text(GTK_ENTRY(entry), browser_command); g_free (browser_command); gtk_widget_set_sensitive (GTK_WIDGET (entry), tmp == manual); gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "manuallabel"), tmp == manual); gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "urlhintlabel"), tmp == manual); /* ================== panel 4 "GUI" ================ */ /* tool bar settings */ widget = liferea_dialog_lookup (pd->priv->dialog, "hidetoolbarbtn"); conf_get_bool_value(DISABLE_TOOLBAR, &bSetting); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting); /* select currently active toolbar style option */ conf_get_str_value (TOOLBAR_STYLE, &name); for (i = 0; gui_toolbar_style_values[i] != NULL; ++i) { if (strcmp (name, gui_toolbar_style_values[i]) == 0) break; } g_free (name); /* On invalid key value: revert to default */ if (gui_toolbar_style_values[i] == NULL) i = 0; /* create toolbar style menu */ ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "toolbarCombo"), gui_toolbar_style_options, G_CALLBACK (on_gui_toolbar_style_changed), i); /* ================= panel 5 "proxy" ======================== */ conf_get_str_value (PROXY_HOST, &proxy_host); gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), proxy_host); g_free (proxy_host); conf_get_int_value (PROXY_PORT, &proxy_port); proxyport = g_strdup_printf ("%d", proxy_port); gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), proxyport); g_free (proxyport); conf_get_bool_value (PROXY_USEAUTH, &enabled); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "useProxyAuth")), enabled); conf_get_str_value (PROXY_USER, &proxy_user); gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), proxy_user); g_free (proxy_user); conf_get_str_value (PROXY_PASSWD, &proxy_passwd); gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), proxy_passwd); g_free (proxy_passwd); gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup(pd->priv->dialog, "proxyauthtable")), enabled); conf_get_int_value (PROXY_DETECT_MODE, &i); switch (i) { default: case 0: /* proxy auto detect */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), TRUE); enabled = FALSE; break; case 1: /* no proxy */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), TRUE); enabled = FALSE; break; case 2: /* manual proxy */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), TRUE); enabled = TRUE; break; } gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup (pd->priv->dialog, "proxybox")), enabled); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), "clicked", G_CALLBACK (on_proxyAutoDetect_clicked), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), "clicked", G_CALLBACK (on_noProxy_clicked), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), "clicked", G_CALLBACK (on_manualProxy_clicked), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), "changed", G_CALLBACK (on_proxyhostentry_changed), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), "changed", G_CALLBACK (on_proxyportentry_changed), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), "changed", G_CALLBACK (on_proxyusernameentry_changed), pd); g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), "changed", G_CALLBACK (on_proxypasswordentry_changed), pd); /* ================= panel 6 "Enclosures" ======================== */ /* menu for download tool */ conf_get_int_value (DOWNLOAD_TOOL, &iSetting); ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "downloadToolCombo"), enclosure_download_tool_options, G_CALLBACK (on_enclosure_download_tool_changed), iSetting); /* set up list of configured enclosure types */ treestore = gtk_tree_store_new (FTS_LEN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); list = (GSList *)enclosure_mime_types_get (); while (list) { GtkTreeIter *newIter = g_new0 (GtkTreeIter, 1); gtk_tree_store_append (treestore, newIter, NULL); gtk_tree_store_set (treestore, newIter, FTS_TYPE, (NULL != ((encTypePtr)(list->data))->mime)?((encTypePtr)(list->data))->mime:((encTypePtr)(list->data))->extension, FTS_CMD, ((encTypePtr)(list->data))->cmd, FTS_PTR, list->data, -1); list = g_slist_next (list); } widget = liferea_dialog_lookup (pd->priv->dialog, "enc_action_view"); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (treestore)); column = gtk_tree_view_column_new_with_attributes (_("Type"), gtk_cell_renderer_text_new (), "text", FTS_TYPE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column); gtk_tree_view_column_set_sort_column_id (column, FTS_TYPE); column = gtk_tree_view_column_new_with_attributes (_("Program"), gtk_cell_renderer_text_new (), "text", FTS_CMD, NULL); gtk_tree_view_column_set_sort_column_id (column, FTS_CMD); gtk_tree_view_append_column (GTK_TREE_VIEW(widget), column); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW(widget)), GTK_SELECTION_SINGLE); /* ================= panel 7 "Plugins" ======================== */ pd->priv->plugins_box = liferea_dialog_lookup (pd->priv->dialog, "plugins_box"); g_assert (pd->priv->plugins_box != NULL); GtkWidget *alignment; alignment = gtk_alignment_new (0., 0., 1., 1.); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12); widget = peas_gtk_plugin_manager_new (NULL); g_assert (widget != NULL); gtk_container_add (GTK_CONTAINER (alignment), widget); gtk_box_pack_start (GTK_BOX (pd->priv->plugins_box), alignment, TRUE, TRUE, 0); g_signal_connect_object (pd->priv->dialog, "destroy", G_CALLBACK (preferences_dialog_destroy_cb), pd, 0); gtk_widget_show_all (pd->priv->dialog); gtk_window_present (GTK_WINDOW (pd->priv->dialog)); }
static void parasite_actionlist_init(ParasiteActionList *actionlist, ParasiteActionListClass *klass) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GTypeClass *uimanager_type; guint uimanager_signal; actionlist->priv = PARASITE_ACTIONLIST_GET_PRIVATE(actionlist); actionlist->priv->uimanagers = NULL; actionlist->priv->model = gtk_tree_store_new(NUM_COLUMNS, G_TYPE_STRING, // ACTION_LABEL G_TYPE_STRING, // ACTION_NAME G_TYPE_STRING, // ACTION_ICON G_TYPE_STRING, // ROW_COLOR, G_TYPE_STRING, // SORT_NAME G_TYPE_POINTER); // ADDRESS gtk_tree_view_set_model(GTK_TREE_VIEW(actionlist), GTK_TREE_MODEL(actionlist->priv->model)); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(actionlist), column); gtk_tree_view_column_set_title(column, "Label"); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "stock-id", ACTION_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "text", ACTION_LABEL, "foreground", ROW_COLOR, NULL); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Action", renderer, "text", ACTION_NAME, "foreground", ROW_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(actionlist), column); gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE(actionlist->priv->model), SORT_NAME, GTK_SORT_ASCENDING); // Listen to all "actions-changed" signal emissions uimanager_type = g_type_class_ref(GTK_TYPE_UI_MANAGER); uimanager_signal = g_signal_lookup("actions-changed", GTK_TYPE_UI_MANAGER); g_signal_add_emission_hook(uimanager_signal, 0, actions_changed_cb, actionlist, NULL); g_type_class_unref(uimanager_type); }
GtkWindow* BuildMenuDialog_construct(ModalDialog& modal, ProjectList& projectList) { GtkWindow* window = create_dialog_window(MainFrame_getWindow(), "Build Menu", G_CALLBACK(dialog_delete_callback), &modal, -1, 400); GtkWidget* buildView = 0; { GtkTable* table1 = create_dialog_table(2, 2, 4, 4, 4); gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(table1)); { GtkVBox* vbox = create_dialog_vbox(4); gtk_table_attach(table1, GTK_WIDGET(vbox), 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); { GtkButton* button = create_dialog_button("OK", G_CALLBACK(dialog_button_ok), &modal); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0); } { GtkButton* button = create_dialog_button("Cancel", G_CALLBACK(dialog_button_cancel), &modal); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0); } } { GtkFrame* frame = create_dialog_frame("Build menu"); gtk_table_attach(table1, GTK_WIDGET(frame), 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); { GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(scr)); { GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING); GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); GtkCellRenderer* renderer = gtk_cell_renderer_text_new(); object_set_boolean_property(G_OBJECT(renderer), "editable", TRUE); g_signal_connect(renderer, "edited", G_CALLBACK(project_cell_edited), &projectList); GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, 0); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); gtk_widget_show(view); buildView = view; projectList.m_store = store; gtk_container_add(GTK_CONTAINER (scr), view); g_signal_connect(G_OBJECT(view), "key_press_event", G_CALLBACK(project_key_press), &projectList); g_object_unref(G_OBJECT(store)); } } } { GtkFrame* frame = create_dialog_frame("Commandline"); gtk_table_attach(table1, GTK_WIDGET(frame), 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); { GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(scr)); { GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING); GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); GtkCellRenderer* renderer = gtk_cell_renderer_text_new(); object_set_boolean_property(G_OBJECT(renderer), "editable", TRUE); g_signal_connect(renderer, "edited", G_CALLBACK(commands_cell_edited), store); GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, 0); gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); gtk_widget_show(view); gtk_container_add(GTK_CONTAINER (scr), view); g_object_unref(G_OBJECT(store)); g_signal_connect(G_OBJECT(view), "key_press_event", G_CALLBACK(commands_key_press), store); g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(buildView))), "changed", G_CALLBACK(project_selection_changed), store); } } } } BSPCommandList_Construct(projectList.m_store, g_build_project); return window; }
void OnDPress_rub(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, t_window *window) { column = column; tree_view = tree_view; char *tmp ; GtkTreeIter iter; /* Clear zone d affichage */ gtk_container_foreach(GTK_CONTAINER(window->pBox_aff_p), (GtkCallback)OnClear_HBox_p, window); GtkWidget *pTable = gtk_table_new(5, 5, TRUE); gtk_box_pack_start(GTK_BOX(window->pBox_aff_p), pTable, TRUE, TRUE, 0); /* nom de la rub 2clique */ gtk_tree_model_get_iter (GTK_TREE_MODEL(window->pTreeStore_p), &iter, path); gtk_tree_model_get(GTK_TREE_MODEL(window->pTreeStore_p), &iter, 0, &tmp, -1); if (!strcmp(tmp,"Contacts")) { GtkListStore* pListstore; GtkWidget *pListView; GtkCellRenderer *pCellRenderer; GtkTreeViewColumn *pColumn; GtkWidget *pScrollbar; pListstore = gtk_list_store_new(N_COLUMN, GDK_TYPE_PIXBUF, G_TYPE_STRING); /*** Insertion contact ***/ GdkPixbuf *pPixBufA; GtkTreeIter pIter; t_contact *p; p = window->contacts; while (p!= NULL){ gtk_list_store_append(pListstore, &pIter); pPixBufA = gdk_pixbuf_new_from_file(p->pic, NULL); gtk_list_store_set(pListstore, &pIter, PIX_COLUMN, pPixBufA, TEXT_COLUMN, p->name, -1); p = p->next; } /**************************/ /* Creation de la vue */ pListView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pListstore)); /* Creation de la premiere colonne */ pCellRenderer = gtk_cell_renderer_pixbuf_new(); pColumn = gtk_tree_view_column_new_with_attributes("B", pCellRenderer, "pixbuf", PIX_COLUMN, NULL); /* Ajout de la colonne à la vue */ gtk_tree_view_append_column(GTK_TREE_VIEW(pListView), pColumn); /* Creation de la deuxieme colonne */ pCellRenderer = gtk_cell_renderer_text_new(); pColumn = gtk_tree_view_column_new_with_attributes("login", pCellRenderer, "text", TEXT_COLUMN, NULL); /* Ajout de la colonne à la vue*/ gtk_tree_view_append_column(GTK_TREE_VIEW(pListView), pColumn); /* scrollbar */ pScrollbar = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(pScrollbar), pListView); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); /*BOUTONS*/ GtkWidget *pVBox = gtk_vbox_new(FALSE, 0); /* ajouter*/ GtkWidget *pBajouter = gtk_button_new_with_label("Ajouter"); g_signal_connect(G_OBJECT(pBajouter), "clicked", G_CALLBACK(OnButton_contact_ajouter), window); gtk_box_pack_start(GTK_BOX(pVBox), pBajouter, FALSE, FALSE, 0); /*supprimer*/ GtkWidget *pBsupprimer = gtk_button_new_with_label("Supprimer"); g_signal_connect(G_OBJECT(pBsupprimer), "clicked", G_CALLBACK(OnButton_contact_supprimer), window); gtk_box_pack_start(GTK_BOX(pVBox), pBsupprimer, FALSE, FALSE, 0); /*modifier*/ GtkWidget *pBmodifier = gtk_button_new_with_label("Modifier"); g_signal_connect(G_OBJECT(pBmodifier), "clicked", G_CALLBACK(OnButton_contact_modifier), window); gtk_box_pack_start(GTK_BOX(pVBox), pBmodifier, FALSE, FALSE, 0); /* mis dans la zone d affichage */ GtkWidget *label; label = gtk_label_new(" Gestion des contacts "); gtk_table_attach_defaults(GTK_TABLE(pTable), label, 1,4, 0,1); gtk_table_attach_defaults(GTK_TABLE(pTable), pScrollbar, 0,4, 1,5); gtk_table_attach_defaults(GTK_TABLE(pTable), pVBox, 4,5, 1,5); /*affichage */ gtk_widget_show_all(GTK_WIDGET(window->pHBox_p)); } if (!strcmp(tmp,"Apparence")) { GtkWidget *label; label = gtk_label_new(" Choisir un theme : "); gtk_table_attach_defaults(GTK_TABLE(pTable), label, 0,2, 0,1); GtkWidget *pbred = gtk_button_new_with_label("red"); gtk_table_attach_defaults(GTK_TABLE(pTable), pbred, 0,1, 1,2); g_signal_connect(G_OBJECT(pbred), "clicked", G_CALLBACK(OnButton_red), window); GtkWidget *pbdual = gtk_button_new_with_label("dual"); gtk_table_attach_defaults(GTK_TABLE(pTable), pbdual, 1,2, 1,2); g_signal_connect(G_OBJECT(pbdual), "clicked", G_CALLBACK(OnButton_dual), window); GtkWidget *pblogo = gtk_button_new_with_label("logo"); gtk_table_attach_defaults(GTK_TABLE(pTable), pblogo, 2,3, 1,2); g_signal_connect(G_OBJECT(pblogo), "clicked", G_CALLBACK(OnButton_logo), window); gtk_widget_show_all(GTK_WIDGET(window->pHBox_p)); } }
void gui_init(dt_lib_module_t *self) { dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); // gtk_widget_set_size_request(self->widget, DT_PIXEL_APPLY_DPI(100), -1); GtkBox *box, *hbox; GtkWidget *button; GtkWidget *w; GtkListStore *liststore; // left side, current box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->current = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->current, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->current, 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_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->current), "tooltip-text", _("attached tags,\ndoubleclick to detach"), (char *)NULL); g_signal_connect(G_OBJECT(d->current), "row-activated", G_CALLBACK(detach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current)); // attach/detach buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("attach")); d->attach_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("attach tag to all selected images"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(attach_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("detach")); d->detach_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("detach tag from all selected images"), (char *)NULL); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(detach_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // right side, related box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5); // text entry and new button w = gtk_entry_new(); g_object_set(G_OBJECT(w), "tooltip-text", _("enter tag name"), (char *)NULL); gtk_box_pack_start(box, w, TRUE, TRUE, 0); gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK); // g_signal_connect(G_OBJECT(w), "key-release-event", g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(tag_name_changed), (gpointer)self); g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), (gpointer)self); d->entry = GTK_ENTRY(w); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); // related tree view w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->related = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->related, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->related, col); 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_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->related), "tooltip-text", _("related tags,\ndoubleclick to attach"), (char *)NULL); g_signal_connect(G_OBJECT(d->related), "row-activated", G_CALLBACK(attach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related)); // attach and delete buttons hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5)); button = gtk_button_new_with_label(_("new")); d->new_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("create a new tag with the\nname you entered"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(new_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("delete")); d->delete_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("delete selected tag"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(delete_button_clicked), (gpointer)self); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, 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->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* connect to mouse over id */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self); dt_control_signal_connect(darktable.signals, DT_SIGNAL_TAG_CHANGED, G_CALLBACK(_lib_tagging_tags_changed_callback), self); update(self, 0); set_keyword(self, d); }
void _camera_import_dialog_new(_camera_import_dialog_t *data) { data->dialog=gtk_dialog_new_with_buttons(_("import images from camera"),NULL,GTK_DIALOG_MODAL,_("cancel"),GTK_RESPONSE_NONE,C_("camera import", "import"),GTK_RESPONSE_ACCEPT,NULL); GtkWidget *content = gtk_dialog_get_content_area (GTK_DIALOG (data->dialog)); // List - setup store data->store = gtk_list_store_new (2,GDK_TYPE_PIXBUF,G_TYPE_STRING); // IMPORT PAGE data->import.page=gtk_vbox_new(FALSE,5); gtk_container_set_border_width(GTK_CONTAINER(data->import.page),5); // Top info data->import.info=gtk_label_new( _("please wait while prefetching thumbnails of images from camera...") ); gtk_label_set_single_line_mode( GTK_LABEL(data->import.info) , FALSE ); gtk_misc_set_alignment(GTK_MISC(data->import.info), 0.0, 0.0); gtk_box_pack_start(GTK_BOX(data->import.page),data->import.info,FALSE,FALSE,0); // jobcode data->import.jobname=_camera_import_gconf_widget(data,_("jobcode"),"plugins/capture/camera/import/jobcode"); gtk_box_pack_start(GTK_BOX(data->import.page),GTK_WIDGET(data->import.jobname->widget),FALSE,FALSE,0); // Create the treview with list model data store data->import.treeview=gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview),GTK_POLICY_NEVER,GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new()); GtkTreeView *treeview=GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview))); GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new( ); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes( _("thumbnail") , renderer,"pixbuf",0, (char *)NULL); gtk_tree_view_append_column( treeview , column); renderer = gtk_cell_renderer_text_new( ); column = gtk_tree_view_column_new_with_attributes( _("storage file"), renderer, "text", 1, (char *)NULL); gtk_tree_view_append_column( treeview , column); gtk_tree_view_column_set_expand( column, TRUE); GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); gtk_tree_selection_set_mode(selection,GTK_SELECTION_MULTIPLE); gtk_tree_view_set_model(treeview,GTK_TREE_MODEL(data->store)); gtk_tree_view_set_headers_visible(treeview,FALSE); gtk_box_pack_start(GTK_BOX(data->import.page),data->import.treeview,TRUE,TRUE,0); // SETTINGS PAGE data->settings.page=gtk_vbox_new(FALSE,5); gtk_container_set_border_width(GTK_CONTAINER(data->settings.page),5); // general settings gtk_box_pack_start(GTK_BOX(data->settings.page),dtgtk_label_new(_("general"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT),FALSE,FALSE,0); // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories. data->settings.general.ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files")); g_object_set(data->settings.general.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(data->settings.general.ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs")); gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0); g_signal_connect (G_OBJECT(data->settings.general.ignore_jpeg), "clicked",G_CALLBACK (_check_button_callback),data); GtkWidget *hbox=gtk_hbox_new(FALSE,5); data->settings.general.date_override=gtk_check_button_new_with_label(_("override today's date")); gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_override,FALSE,FALSE,0); g_object_set(data->settings.general.date_override,"tooltip-text",_("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), $(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)"),(char *)NULL); data->settings.general.date_entry=gtk_entry_new(); gtk_widget_set_sensitive( data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override))); gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_entry,TRUE,TRUE,0); g_signal_connect (G_OBJECT (data->settings.general.date_override), "clicked",G_CALLBACK (_check_button_callback),data); gtk_box_pack_start(GTK_BOX(data->settings.page),hbox,FALSE,FALSE,0); // THE NOTEBOOK data->notebook=gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->import.page,gtk_label_new(_("images"))); gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->settings.page,gtk_label_new(_("settings"))); // end gtk_box_pack_start(GTK_BOX(content),data->notebook,TRUE,TRUE,0); //gtk_widget_set_size_request(content, DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(400)); }
/** * vdpdbg_window_create_lstRegList(): Create the register list. * @param container Container for the register list. */ static void vdpdbg_window_create_lstRegList(GtkWidget *container) { // Create the list model. if (lmRegList) { // List model already exists. Clear it. gtk_list_store_clear(GTK_LIST_STORE(lmRegList)); } else { lmRegList = gtk_list_store_new(5, G_TYPE_INT, // Register number. G_TYPE_STRING, // Register name. G_TYPE_INT, // Value. G_TYPE_STRING, // Value (in hex). G_TYPE_STRING); // Description. } // GtkTreeView containing the register list. lstRegList = gtk_tree_view_new(); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(lstRegList), FALSE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(lstRegList)), GTK_SELECTION_SINGLE); gtk_widget_show(lstRegList); gtk_container_add(GTK_CONTAINER(container), lstRegList); // Create the renderers and columns for the treeview. // Register number. GtkCellRenderer *rendRegNo = gtk_cell_renderer_text_new(); GtkTreeViewColumn *colRegNo = gtk_tree_view_column_new_with_attributes("#", rendRegNo, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(lstRegList), colRegNo); // Register name. GtkCellRenderer *rendRegName = gtk_cell_renderer_text_new(); GtkTreeViewColumn *colRegName = gtk_tree_view_column_new_with_attributes("Name", rendRegName, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(lstRegList), colRegName); // Value. GtkCellRenderer *rendValue = gtk_cell_renderer_text_new(); GValue editable = {0, {{0}, {0}}}; g_value_init(&editable, G_TYPE_BOOLEAN); g_value_set_boolean(&editable, TRUE); g_object_set_property(G_OBJECT(rendValue), "editable", &editable); g_signal_connect((gpointer)rendValue, "edited", G_CALLBACK(vdpdbg_window_callback_reg_edited), NULL); GtkTreeViewColumn *colValue = gtk_tree_view_column_new_with_attributes("Value", rendValue, "text", 3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(lstRegList), colValue); // Description. GtkCellRenderer *rendDescription = gtk_cell_renderer_text_new(); GtkTreeViewColumn *colDescription = gtk_tree_view_column_new_with_attributes("Description", rendDescription, "text", 4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(lstRegList), colDescription); // Populate the register list. // NOTE: These names are correct for MD mode only. // SMS mode may be different. for (int reg_num = 0; reg_num < 24; reg_num++) { GtkTreeIter iter; gtk_list_store_append(lmRegList, &iter); gtk_list_store_set(GTK_LIST_STORE(lmRegList), &iter, 0, reg_num, // Register number. 1, vdp_m5_reg_name[reg_num], // Register name. 2, -1, // Value. 3, "0x00", // Value (in hex). 4, "", -1); // Description. } // Set the GtkTreeView's list model. gtk_tree_view_set_model(GTK_TREE_VIEW(lstRegList), GTK_TREE_MODEL(lmRegList)); }
void add_cartesian_columns (GtkTreeView *tree_view, cartesianMover* cm) { int k; int ADDITIONAL_COLUMNS = 2; char buffer[40]; GtkCellRenderer *renderer; GtkTreeViewColumn *column; //GtkTreeModel *myModel = gtk_tree_view_get_model (tree_view); //Sequence order renderer = gtk_cell_renderer_text_new (); GTK_CELL_RENDERER_TEXT(renderer)->editable=true; GTK_CELL_RENDERER_TEXT(renderer)->editable_set=true; renderer->mode=GTK_CELL_RENDERER_MODE_EDITABLE; g_signal_connect (renderer, "edited", G_CALLBACK (cm->edited_cartesian_sequence), cm); column = gtk_tree_view_column_new_with_attributes ("Sequence", renderer, "text", 0, NULL); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 80); gtk_tree_view_append_column (tree_view, column); //Sequence timing renderer = gtk_cell_renderer_text_new (); GTK_CELL_RENDERER_TEXT(renderer)->editable=true; GTK_CELL_RENDERER_TEXT(renderer)->editable_set=true; renderer->mode=GTK_CELL_RENDERER_MODE_EDITABLE; g_signal_connect (renderer, "edited", G_CALLBACK (cm->edited_cartesian_timing), cm); column = gtk_tree_view_column_new_with_attributes ("Timing", renderer, "text", 1, NULL); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 80); gtk_tree_view_append_column (tree_view, column); //Sequence description renderer = gtk_cell_renderer_text_new (); GTK_CELL_RENDERER_TEXT(renderer)->editable=false; GTK_CELL_RENDERER_TEXT(renderer)->editable_set=false; renderer->mode=GTK_CELL_RENDERER_MODE_EDITABLE; //fprintf(stderr, "Current add_columns received %d\n", NUMBER_OF_JOINTS); for (k =0; k < NUMBER_OF_CARTESIAN_COORDINATES; k++) { if(k<3) sprintf(buffer, "x%d", k); else sprintf(buffer, "th%d", k-3); column = gtk_tree_view_column_new_with_attributes (buffer, renderer, "text", k+ADDITIONAL_COLUMNS, NULL); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 40); //gtk_tree_view_column_set_sort_column_id (column, COLUMN_ADD_INFO); gtk_tree_view_append_column (tree_view, column); } }
/*! \brief Adds a treeview to confirmation dialog for selecting of pages. * \par Function Description * This function adds a treeview and caption to display the content * of the dialog model of pages with unsaved changes. * * The treeview displays the page names with check boxes. * * \param [in] dialog The dialog. * \returns A pointer on the GtkVBox to add to dialog. */ static GtkWidget* close_confirmation_dialog_build_page_list (CloseConfirmationDialog *dialog) { GtkWidget *vbox, *scrolled_window, *treeview, *label; GtkCellRenderer *renderer; GtkTreeViewColumn *column; const gchar *text; /* place the treeview and its caption into their own box */ vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX, /* GtkBox */ "homogeneous", FALSE, "spacing", 8, NULL)); /* the list of pages with changes */ /* - scrolled window as container for the treeview first */ scrolled_window = GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW, /* GtkScrolledWindow */ "hscrollbar-policy", GTK_POLICY_AUTOMATIC, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, "shadow-type", GTK_SHADOW_IN, NULL)); /* - then the treeview */ /* create model for treeview and populate */ treeview = GTK_WIDGET (g_object_new (GTK_TYPE_TREE_VIEW, /* GtkTreeView */ "enable-search", FALSE, "headers-visible", FALSE, "model", dialog->store_unsaved_pages, NULL)); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK ( close_confirmation_dialog_callback_renderer_toggled), dialog); column = gtk_tree_view_column_new_with_attributes ("Save?", renderer, "active", COLUMN_SAVE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); renderer = gtk_cell_renderer_text_new (); column = GTK_TREE_VIEW_COLUMN ( g_object_new (GTK_TYPE_TREE_VIEW_COLUMN, /* GtkTreeViewColumn */ "title", _("Name"), NULL)); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, close_confirmation_dialog_set_page_name, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_container_add (GTK_CONTAINER (scrolled_window), treeview); gtk_box_pack_end (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0); /* the caption label above the list of pages */ label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL, /* GtkMisc */ "xalign", 0.0, "yalign", 0.0, /* GtkLabel */ "wrap", TRUE, "mnemonic-widget", treeview, NULL)); text = _("S_elect the schematics you want to save:"); gtk_label_set_text_with_mnemonic (GTK_LABEL (label), text); gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); return vbox; }
static void setup_filters (EventLog *log) { int i; EventType last_toplevel_type = EVENT_TYPE_LAST; GtkTreeIter cur_toplevel; GtkCellRenderer *cell; GtkTreeViewColumn *column; log->filters = gtk_tree_store_new(FILTER_COLUMN_LAST, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING); g_signal_connect (log->filters, "row_changed", G_CALLBACK (update_listener_row_changed), log); for (i = 0; i < G_N_ELEMENTS (event_info); i++) { GtkTreeIter item; EventType type = event_info[i].type; const char *event_type_name = event_type_names[type]; if (type != last_toplevel_type) { char *event_type_name_colon = g_strconcat (event_type_name, ":", NULL); last_toplevel_type = type; gtk_tree_store_append (log->filters, &cur_toplevel, NULL); gtk_tree_store_set (log->filters, &cur_toplevel, FILTER_COLUMN_NAME, event_type_name, FILTER_COLUMN_ENABLED, (gboolean) FALSE, FILTER_COLUMN_INCONSISTENT, (gboolean) FALSE, FILTER_COLUMN_FULL_NAME, event_type_name_colon, -1); g_free (event_type_name_colon); } if (event_info[i].name) { char *full_name; gtk_tree_store_append (log->filters, &item, &cur_toplevel); full_name = g_strconcat (event_type_name, ":", event_info[i].name, NULL); gtk_tree_store_set (log->filters, &item, FILTER_COLUMN_NAME, event_info[i].name, FILTER_COLUMN_ENABLED, (gboolean) FALSE, FILTER_COLUMN_INCONSISTENT, (gboolean) FALSE, FILTER_COLUMN_FULL_NAME, full_name, -1); g_free (full_name); } } column = gtk_tree_view_column_new (); gtk_tree_view_column_set_reorderable (column, TRUE); gtk_tree_view_column_set_title (column, "Name"); cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "active", FILTER_COLUMN_ENABLED, "inconsistent", FILTER_COLUMN_INCONSISTENT, NULL); gtk_tree_view_column_set_resizable (column, TRUE); g_signal_connect (cell, "toggled", G_CALLBACK (update_filter_model), log); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", FILTER_COLUMN_NAME, NULL); gtk_tree_view_column_set_sort_column_id (column, FILTER_COLUMN_NAME); gtk_tree_view_append_column (log->filters_view, column); gtk_tree_view_insert_column_with_attributes (log->filters_view, 2, "Full name", gtk_cell_renderer_text_new (), "text", FILTER_COLUMN_FULL_NAME, NULL); gtk_tree_view_set_model (log->filters_view, GTK_TREE_MODEL (log->filters)); gtk_tree_view_set_headers_visible (log->filters_view, TRUE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (log->filters_view), GTK_SELECTION_NONE); gtk_tree_view_columns_autosize (log->filters_view); }
void setup_tree_view(struct _properties *properties) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; char strike[200] = { 0 }; char call[200] = { 0 }; char put[200] = { 0 }; // delete previous column names if any... GtkTreeViewColumn *col; while((col = gtk_tree_view_get_column(GTK_TREE_VIEW(properties->GtkInfo.treeview),0)) != NULL) { gtk_tree_view_remove_column(GTK_TREE_VIEW(properties->GtkInfo.treeview),col); } if( option_algorithms[properties->modeltype].assetClass == FUTURES_CLASS ) { //g_print("tree Future detected\n"); if(properties->decimalorcalendar == CALENDAR ) { //g_print("tree CALENDAR future detect\n"); if( properties->spreads == 0 ) { properties->GtkInfo.liststore1 = gtk_list_store_new (5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); } else if( properties->spreads == 1 ) { properties->GtkInfo.liststore1 = gtk_list_store_new (12, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); } gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expiration", renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Price", renderer, "text", X2, NULL); //(option_algorithms[properties->modeltype].price, renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Days to Expr", renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes // ("Decimal Time", renderer, "text", X4, NULL); ("Years to Expr", renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Ticker", renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( properties->spreads == 1 ) { renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expiration", renderer, "text", X6 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Price", renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Days to Expr", renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Years to Expr", renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Ticker", renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread", renderer, "text", X11, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread Ticker", renderer, "text", X12, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } return; } if(properties->decimalorcalendar == DECIMALS ) { //g_print("DECIMALS future detect\n"); properties->GtkInfo.liststore1 = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Value", renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); return; } } if( option_algorithms[properties->modeltype].assetClass == BOND_CLASS ) { g_print("Bonds detected\n"); properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Value", renderer, "text", X2 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", X3 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Time", renderer, "text", X4 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); return; } if( option_algorithms[properties->modeltype].assetClass == TERMSTRUCTURE_CLASS ) { g_print("Termstructure detected\n"); properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Value", renderer, "text", X2 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", X3 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Time", renderer, "text", X4 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); return; } if( properties->decimalorcalendar == DECIMALS ) { properties->GtkInfo.liststore1 = gtk_list_store_new (14, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1 , NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (call, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (put, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Delta", renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Delta", renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Gamma", renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Vega", renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Theta", renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Theta", renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Rho", renderer, "text", X11, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Rho", renderer, "text", X12, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Elast", renderer, "text", X13, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Elast", renderer, "text", X14, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } else if(properties->decimalorcalendar == CALENDAR && properties->format == CALENDAR_OPTIONS6 ) { properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1)); g_object_unref (properties->GtkInfo.liststore1); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); char textDate[500] = { 0 }; snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } else if( properties->decimalorcalendar == CALENDAR && properties->format == CALENDAR_OPTIONS5 ) { properties->GtkInfo.liststore1 = gtk_list_store_new( 10, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) ); g_object_unref( properties->GtkInfo.liststore1 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); char textDate[400] = { 0 }; snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+3)],*(properties->days_to_expiration+3),(double)*(properties->expiration_year+3) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+4)],*(properties->days_to_expiration+4),(double)*(properties->expiration_year+4) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+5)],*(properties->days_to_expiration+5),(double)*(properties->expiration_year+5) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+6)],*(properties->days_to_expiration+6),(double)*(properties->expiration_year+6) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+7)],*(properties->days_to_expiration+7),(double)*(properties->expiration_year+7) + 2000 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (textDate, renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } else if( properties->decimalorcalendar == CALENDAR && properties->spreads == 0 && ( properties->format == CALENDAR_OPTIONS4 || properties->format == CALENDAR_OPTIONS3 || properties->format == CALENDAR_CUSTOM )) { properties->GtkInfo.liststore1 = gtk_list_store_new( 17, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING ); gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) ); g_object_unref(properties->GtkInfo.liststore1 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expr Date", renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (call, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if(option_algorithms[properties->modeltype].supportPuts) snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put); else put[0] = 0; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (put, renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Days to Expr", renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Years to Expr", renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Delta", renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Delta", renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Gamma", renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Vega", renderer, "text", X11, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Theta", renderer, "text", X12, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Theta", renderer, "text", X13, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Call Rho", renderer, "text", X14, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Put Rho", renderer, "text", X15, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Legacy C", renderer, "text", X16, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Legacy P", renderer, "text", X17, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } else if( properties->decimalorcalendar == CALENDAR && properties->spreads == 1 && ( properties->format == CALENDAR_OPTIONS4 || properties->format == CALENDAR_OPTIONS3 || properties->format == CALENDAR_CUSTOM )) { g_print("Spreads for Options\n"); properties->GtkInfo.liststore1 = gtk_list_store_new( 13, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) ); g_object_unref(properties->GtkInfo.liststore1 ); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expr Date", renderer, "text", X2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (call, renderer, "text", X4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if(option_algorithms[properties->modeltype].supportPuts) snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put); else put[0] = 0; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (put, renderer, "text", X5, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Expr Date", renderer, "text", X6, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if( option_algorithms[properties->modeltype].supportStrikes ) { snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike); } else { strike[0] = 0; } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (strike, renderer, "text", X7, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (call, renderer, "text", X8, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); if(option_algorithms[properties->modeltype].supportPuts) snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put); else put[0] = 0; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (put, renderer, "text", X9, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread C-C", renderer, "text", X10, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread P-P", renderer, "text", X11, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread C-P", renderer, "text", X12, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes ("Spread P-C", renderer, "text", X13, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column); } } // void setup_tree_view(struct _properties *properties)
gint main (gint argc, gchar * argv[]) { IconBrowserData *data; gchar **themes = NULL; GList *ic, *icat; GtkListStore *store; GtkTreeSelection *sel; GtkTreeViewColumn *col; GtkCellRenderer *r; GtkWidget *w, *p, *box, *t; GOptionEntry entrs[] = { {G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &themes, NULL, NULL}, {NULL} }; data = g_new0 (IconBrowserData, 1); #ifdef ENABLE_NLS bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif data = g_new0 (IconBrowserData, 1); /* initialize GTK+ and parse the command line arguments */ gtk_init_with_args (&argc, &argv, _("- Icon browser"), entrs, GETTEXT_PACKAGE, NULL); /* load icon theme */ if (themes && themes[0]) { data->theme = gtk_icon_theme_new (); gtk_icon_theme_set_custom_theme (data->theme, themes[0]); } else data->theme = gtk_icon_theme_get_default (); /* create interface */ data->win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (data->win), _("Icon browser")); gtk_window_set_icon_name (GTK_WINDOW (data->win), "gtk-info"); gtk_window_set_default_size (GTK_WINDOW (data->win), 500, 400); g_signal_connect (G_OBJECT (data->win), "delete-event", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (G_OBJECT (data->win), "key-press-event", G_CALLBACK (key_press_cb), NULL); #if !GTK_CHECK_VERSION(3,0,0) box = gtk_vbox_new (FALSE, 5); #else box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); #endif gtk_container_add (GTK_CONTAINER (data->win), box); gtk_container_set_border_width (GTK_CONTAINER (data->win), 5); /* create icon info box */ #if !GTK_CHECK_VERSION(3,0,0) t = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (t), 5); gtk_table_set_row_spacings (GTK_TABLE (t), 5); #else t = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (t), 5); gtk_grid_set_column_spacing (GTK_GRID (t), 5); #endif gtk_box_pack_start (GTK_BOX (box), t, FALSE, FALSE, 2); data->image = gtk_image_new_from_stock ("gtk-missing-image", GTK_ICON_SIZE_DIALOG); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), data->image, 0, 1, 0, 3, GTK_FILL, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), data->image, 0, 0, 1, 3); #endif w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), _("<b>Name:</b>")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), w, 1, 2, 0, 1, GTK_FILL, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), w, 1, 0, 1, 1); #endif data->lname = gtk_label_new (NULL); gtk_label_set_selectable (GTK_LABEL (data->lname), TRUE); gtk_misc_set_alignment (GTK_MISC (data->lname), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), data->lname, 2, 3, 0, 1, GTK_FILL | GTK_EXPAND, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), data->lname, 2, 0, 1, 1); gtk_widget_set_hexpand (data->lname, TRUE); #endif w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), _("<b>Sizes:</b>")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), w, 1, 2, 1, 2, GTK_FILL, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), w, 1, 1, 1, 1); #endif data->lsize = gtk_label_new (NULL); gtk_label_set_selectable (GTK_LABEL (data->lsize), TRUE); gtk_misc_set_alignment (GTK_MISC (data->lsize), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), data->lsize, 2, 3, 1, 2, GTK_FILL | GTK_EXPAND, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), data->lsize, 2, 1, 1, 1); gtk_widget_set_hexpand (data->lsize, TRUE); #endif w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), _("<b>Filename:</b>")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), w, 1, 2, 2, 3, GTK_FILL, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), w, 1, 2, 1, 1); #endif data->lfile = gtk_label_new (NULL); gtk_label_set_selectable (GTK_LABEL (data->lfile), TRUE); gtk_misc_set_alignment (GTK_MISC (data->lfile), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), data->lfile, 2, 3, 2, 3, GTK_FILL | GTK_EXPAND, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), data->lfile, 2, 2, 1, 1); gtk_widget_set_hexpand (data->lfile, TRUE); #endif /* create icon browser */ #if !GTK_CHECK_VERSION(3,0,0) p = gtk_hpaned_new (); #else p = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); #endif gtk_paned_set_position (GTK_PANED (p), 150); gtk_box_pack_start (GTK_BOX (box), p, TRUE, TRUE, 2); /* create category list */ w = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN); gtk_paned_add1 (GTK_PANED (p), w); store = gtk_list_store_new (1, G_TYPE_STRING); data->cat_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->cat_list), TRUE); gtk_container_add (GTK_CONTAINER (w), data->cat_list); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->cat_list)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (select_cat), data); r = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Category"), r, "text", 0, NULL); gtk_tree_view_column_set_expand (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (data->cat_list), col); /* load icons category */ data->icons = g_hash_table_new (g_direct_hash, g_direct_equal); icat = gtk_icon_theme_list_contexts (data->theme); for (ic = icat; ic; ic = ic->next) { GtkTreeIter iter; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, ic->data, -1); g_free (ic->data); } g_list_free (icat); /* create icons list */ w = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN); gtk_paned_add2 (GTK_PANED (p), w); data->icon_list = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->icon_list), TRUE); gtk_container_add (GTK_CONTAINER (w), data->icon_list); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->icon_list)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (select_icon), data); col = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (col, _("Icons")); gtk_tree_view_column_set_sort_column_id (col, 1); r = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, r, FALSE); gtk_tree_view_column_set_attributes (col, r, "pixbuf", 0, NULL); r = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, r, FALSE); gtk_tree_view_column_set_attributes (col, r, "text", 1, NULL); gtk_tree_view_column_set_expand (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (data->icon_list), col); gtk_widget_show_all (data->win); /* run it */ gtk_main (); return 0; }
static void set_columns_type (GtkTreeView *tree_view, ColumnsType type) { GtkTreeViewColumn *col; GtkCellRenderer *rend; GdkPixbuf *pixbuf; GtkWidget *image; GtkObject *adjustment; current_column_type = type; col = gtk_tree_view_get_column (tree_view, 0); while (col) { gtk_tree_view_remove_column (tree_view, col); col = gtk_tree_view_get_column (tree_view, 0); } gtk_tree_view_set_rules_hint (tree_view, FALSE); switch (type) { case COLUMNS_NONE: break; case COLUMNS_LOTS: /* with lots of columns we need to turn on rules */ gtk_tree_view_set_rules_hint (tree_view, TRUE); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 1", rend, "text", 1, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (col, "Column 2"); rend = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, rend, FALSE); gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2); rend = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, rend, TRUE); gtk_tree_view_column_add_attribute (col, rend, "text", 0); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); gtk_tree_view_set_expander_column (tree_view, col); rend = gtk_cell_renderer_toggle_new (); g_signal_connect (rend, "toggled", G_CALLBACK (toggled_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 3", rend, "active", BOOL_COLUMN, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm); image = gtk_image_new_from_pixbuf (pixbuf); g_object_unref (pixbuf); gtk_widget_show (image); gtk_tree_view_column_set_widget (col, image); rend = gtk_cell_renderer_toggle_new (); /* you could also set this per-row by tying it to a column * in the model of course. */ g_object_set (rend, "radio", TRUE, NULL); g_signal_connect (rend, "toggled", G_CALLBACK (toggled_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 4", rend, "active", BOOL_COLUMN, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_spin_new (); adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100); g_object_set (rend, "editable", TRUE, NULL); g_object_set (rend, "adjustment", adjustment, NULL); g_signal_connect (rend, "edited", G_CALLBACK (edited_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 5", rend, "text", 4, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); #if 0 rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 6", rend, "text", 4, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 7", rend, "text", 5, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 8", rend, "text", 6, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 9", rend, "text", 7, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 10", rend, "text", 8, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); #endif /* FALL THRU */ case COLUMNS_ONE: rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 0", rend, "text", 0, NULL); setup_column (col); gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0); default: break; } }
static void property_dialog_setup_list (GtkWidget *dialog) { PlannerPropertyDialogPriv *priv; GtkTreeView *tree; GtkTreeViewColumn *col; GtkCellRenderer *cell; GtkTreeModel *model; priv = g_object_get_data (G_OBJECT (dialog), "priv"); tree = GTK_TREE_VIEW (priv->tree); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (tree), GTK_SELECTION_SINGLE); gtk_tree_view_set_headers_visible (tree, TRUE); /* Name */ cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); col = gtk_tree_view_column_new_with_attributes (_("Name"), cell, "text", COL_NAME, NULL); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_column_set_min_width (col, 100); gtk_tree_view_append_column (tree, col); /* Label */ cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", TRUE, NULL); g_signal_connect (cell, "edited", G_CALLBACK (property_dialog_label_edited), dialog); col = gtk_tree_view_column_new_with_attributes (_("Label"), cell, "text", COL_LABEL, NULL); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_column_set_min_width (col, 200); gtk_tree_view_append_column (tree, col); /* Type */ cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); col = gtk_tree_view_column_new_with_attributes (_("Type"), cell, "text", COL_TYPE, NULL); gtk_tree_view_column_set_resizable (col, TRUE); /* gtk_tree_view_column_set_min_width (col, 200); */ gtk_tree_view_append_column (tree, col); /* Create the shop (a type of store). */ priv->shop = g_new0 (MrpPropertyStore, 1); model = planner_property_model_new (priv->project, priv->owner, priv->shop); priv->model = model; gtk_tree_view_set_model (tree, model); }
static void anjuta_save_prompt_init(AnjutaSavePrompt *obj) { GtkWidget *vbox; GtkWidget *treeview; GtkListStore *store; GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkWidget *label; GtkWidget *scrolledwindow; obj->priv = g_new0(AnjutaSavePromptPrivate, 1); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (obj), "Uninitialized"); gtk_window_set_resizable (GTK_WINDOW (obj), TRUE); gtk_window_set_default_size (GTK_WINDOW (obj), 400, 300); vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (obj))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); label = gtk_label_new (_("Select the items to save:")); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_misc_set_padding (GTK_MISC (label), 10, -1); gtk_misc_set_alignment (GTK_MISC (label), 0, -1); gtk_widget_show (label); store = gtk_list_store_new (N_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow), 10); gtk_widget_show (scrolledwindow); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview); gtk_widget_show (treeview); label = gtk_label_new (_("If you do not save, all your changes will be lost.")); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_misc_set_padding (GTK_MISC (label), 10, -1); gtk_misc_set_alignment (GTK_MISC (label), 0, -1); gtk_widget_show (label); renderer = gtk_cell_renderer_toggle_new (); col = gtk_tree_view_column_new_with_attributes (_("Save"), renderer, "active", COL_SAVE_ENABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col); renderer = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Item"), renderer, "markup", COL_LABEL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col); gtk_dialog_add_buttons (GTK_DIALOG (obj), _("_Discard changes"), ANJUTA_SAVE_PROMPT_RESPONSE_DISCARD, GTK_STOCK_CANCEL, ANJUTA_SAVE_PROMPT_RESPONSE_CANCEL, GTK_STOCK_SAVE, ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE, NULL); /* TRUE is the default and Gtk warns that this has no effect */ /* gtk_dialog_set_has_separator (GTK_DIALOG (obj), TRUE); */ gtk_dialog_set_default_response (GTK_DIALOG (obj), ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE); g_signal_connect (obj, "response", G_CALLBACK (on_dialog_response), obj); obj->priv->treeview = treeview; }
/************************************************************************** * Dialog Building Functions **************************************************************************/ static GtkWidget * setup_tree(PidginXferDialog *dialog) { GtkWidget *sw; GtkWidget *tree; GtkListStore *model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; /* Create the scrolled window. */ sw = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(sw); /* Build the tree model */ /* Transfer type, Progress Bar, Filename, Size, Remaining */ model = gtk_list_store_new(NUM_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_DOUBLE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); dialog->model = model; /* Create the treeview */ dialog->tree = tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); /* gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); */ gtk_widget_show(tree); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed_cb), dialog); g_object_unref(G_OBJECT(model)); /* Columns */ /* Transfer Type column */ renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "pixbuf", COLUMN_STATUS, NULL); gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width(GTK_TREE_VIEW_COLUMN(column), 25); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); /* Progress bar column */ renderer = pidgin_cell_renderer_progress_new(); column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, "percentage", COLUMN_PROGRESS, NULL); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); /* Filename column */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Filename"), renderer, "text", COLUMN_FILENAME, NULL); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); /* File Size column */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, "text", COLUMN_SIZE, NULL); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); /* Bytes Remaining column */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Remaining"), renderer, "text", COLUMN_REMAINING, NULL); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); gtk_tree_view_columns_autosize(GTK_TREE_VIEW(tree)); gtk_container_add(GTK_CONTAINER(sw), tree); gtk_widget_show(tree); return sw; }
static gboolean nimf_candidate_start (NimfService *service) { g_debug (G_STRLOC ": %s", G_STRFUNC); NimfCandidate *candidate = NIMF_CANDIDATE (service); if (candidate->active) return TRUE; GtkCellRenderer *renderer; GtkTreeViewColumn *column[N_COLUMNS]; GtkListStore *store; gint fixed_height = 32; gint horizontal_space; gtk_init (NULL, NULL); /* gtk entry */ candidate->entry = gtk_entry_new (); gtk_editable_set_editable (GTK_EDITABLE (candidate->entry), FALSE); gtk_widget_set_no_show_all (candidate->entry, TRUE); g_signal_connect_after (candidate->entry, "draw", G_CALLBACK (on_entry_draw), NULL); /* gtk tree view */ store = gtk_list_store_new (N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING); candidate->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (candidate->treeview), FALSE); gtk_widget_style_get (candidate->treeview, "horizontal-separator", &horizontal_space, NULL); candidate->cell_height = fixed_height + horizontal_space / 2; gtk_widget_set_size_request (candidate->treeview, (gint) (candidate->cell_height * 10 / 1.6), candidate->cell_height * 10); g_signal_connect (candidate->treeview, "row-activated", (GCallback) on_tree_view_row_activated, candidate); /* column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "height", fixed_height, "font", "Sans 14", NULL); column[INDEX_COLUMN] = gtk_tree_view_column_new_with_attributes ("Index", renderer, "text", INDEX_COLUMN, NULL); column[MAIN_COLUMN] = gtk_tree_view_column_new_with_attributes ("Main", renderer, "text", MAIN_COLUMN, NULL); column[EXTRA_COLUMN] = gtk_tree_view_column_new_with_attributes ("Extra", renderer, "text", EXTRA_COLUMN, NULL); gtk_tree_view_column_set_sizing (column[INDEX_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sizing (column[MAIN_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sizing (column[EXTRA_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview), column[INDEX_COLUMN]); gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview), column[MAIN_COLUMN]); gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview), column[EXTRA_COLUMN]); /* scrollbar */ GtkAdjustment *adjustment = gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 1.0, 1.0); candidate->scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment); gtk_range_set_slider_size_fixed (GTK_RANGE (candidate->scrollbar), FALSE); g_signal_connect (candidate->scrollbar, "change-value", G_CALLBACK (on_range_change_value), candidate); GtkCssProvider *provider; GtkStyleContext *style_context; provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider), ".scrollbar {" " -GtkScrollbar-has-backward-stepper: true;" " -GtkScrollbar-has-forward-stepper: true;" " -GtkScrollbar-has-secondary-forward-stepper: true;" "}" , -1, NULL); style_context = gtk_widget_get_style_context (candidate->scrollbar); gtk_style_context_add_provider (style_context, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref (provider); /* gtk box */ GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), candidate->entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), candidate->treeview, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (hbox), candidate->scrollbar, FALSE, TRUE, 0); /* gtk window */ candidate->window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_type_hint (GTK_WINDOW (candidate->window), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_container_set_border_width (GTK_CONTAINER (candidate->window), 1); gtk_container_add (GTK_CONTAINER (candidate->window), vbox); gtk_widget_realize (candidate->window); candidate->active = TRUE; return TRUE; }
int init_preferences(t_window * window) { /* INIT Fenetre Gestion */ window->pWindow_p = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); gtk_window_set_title(GTK_WINDOW(window->pWindow_p), "TUTTI 0.1 : Gestion"); gtk_window_set_position(GTK_WINDOW(window->pWindow_p), GTK_WIN_POS_NONE ); gtk_window_set_default_size(GTK_WINDOW(window->pWindow_p),600 , 500); g_signal_connect(G_OBJECT(window->pWindow_p), "destroy", G_CALLBACK(OnKill_p), NULL); g_signal_connect(G_OBJECT(window->pWindow_p), "delete_event", G_CALLBACK(OnKill_p), NULL); /* box principale */ window->pHBox_p = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window->pWindow_p), window->pHBox_p); /* Creation de l arbre des parametres */ window->pTreeStore_p = gtk_tree_store_new( 1, G_TYPE_STRING); int i; int j; char titres[5][20]; char ssmenu[5][3][20]; g_sprintf(titres[0], "Generale"); g_sprintf(ssmenu[0][0], "prop 1"); g_sprintf(ssmenu[0][1], "prop 2"); g_sprintf(ssmenu[0][2], "0"); g_sprintf(titres[1], "Apparence"); g_sprintf(ssmenu[1][0], "0"); g_sprintf(titres[2], "Contacts"); g_sprintf(ssmenu[2][0], "0"); g_sprintf(titres[3], "Connexion"); g_sprintf(ssmenu[3][0], "prop 1"); g_sprintf(ssmenu[3][1], "prop 2"); g_sprintf(ssmenu[3][2], "0"); g_sprintf(titres[4], "0"); GtkTreeIter pIter_p; GtkTreeIter pIter2_p; i=0; while (strcmp(titres[i],"0")){ gtk_tree_store_append(window->pTreeStore_p, &pIter_p, NULL); gtk_tree_store_set(window->pTreeStore_p, &pIter_p, 0, titres[i], -1); j = 0; while (strcmp(ssmenu[i][j], "0")){ gtk_tree_store_append(window->pTreeStore_p, &pIter2_p, &pIter_p ); gtk_tree_store_set(window->pTreeStore_p, &pIter2_p, 0, ssmenu[i][j], -1); j++; } i++; } /* creation de la vue */ window->pTreeView_p = gtk_tree_view_new_with_model(GTK_TREE_MODEL(window->pTreeStore_p)); /* Creation de la colonne */ window->pCellRenderer_p = gtk_cell_renderer_text_new(); window->pColumn_p = gtk_tree_view_column_new_with_attributes("Rubriques ~", window->pCellRenderer_p, "text", 0, NULL); /* Ajout de la colonne à la vue */ gtk_tree_view_append_column(GTK_TREE_VIEW(window->pTreeView_p), window->pColumn_p); /* Creation scrollbar contenant la liste des contacts */ window->pScrollbar_p = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(window->pHBox_p), window->pScrollbar_p, FALSE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window->pScrollbar_p), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); /* ajout de la vue a la ScrollBar */ gtk_container_add(GTK_CONTAINER(window->pScrollbar_p), window->pTreeView_p); /* Creation des rubriques */ window->pBox_rub_p = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(window->pHBox_p), window->pBox_rub_p, TRUE, TRUE, 0); /* contenue des rubriques */ window->pBox_aff_p = gtk_hbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(window->pHBox_p), window->pBox_aff_p, TRUE, TRUE, 0); g_signal_connect(window->pTreeView_p, "row-activated", G_CALLBACK(OnDPress_rub), window); return 1 ; }
static GtkWidget * zenity_forms_create_and_fill_list ( ZenityFormsData *forms_data, int list_number, gchar *header) { GtkListStore *list_store; GtkWidget *tree_view; GtkWidget *scrolled_window; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GType *column_types = NULL; gchar *list_values; gchar *column_values; gint i = 0; /* If no column names available, default is one */ gint n_columns = 1; gint column_index = 0; tree_view = gtk_tree_view_new (); if (forms_data->column_values) { int columns_values_count = g_slist_length (forms_data->column_values); int column_number = 0; if (list_number < columns_values_count) { column_number = list_number; } column_values = g_slist_nth_data (forms_data->column_values, column_number); if (column_values) { gchar **values = g_strsplit_set (column_values, "|", -1); if (values) { n_columns = g_strv_length (values); column_types = g_new (GType, n_columns); for (i = 0; i < n_columns; i++) column_types[i] = G_TYPE_STRING; for (i = 0; i < n_columns; i++) { gchar *column_name = values[i]; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ( column_name, renderer, "text", column_index, NULL); gtk_tree_view_append_column ( GTK_TREE_VIEW (tree_view), column); column_index++; } } } else { /* If no values available, add one with string type*/ column_types = g_new (GType, n_columns); column_types[0] = G_TYPE_STRING; } } list_store = g_object_new (GTK_TYPE_LIST_STORE, NULL); gtk_list_store_set_column_types (list_store, n_columns, column_types); if (forms_data->list_values) { list_values = g_slist_nth_data (forms_data->list_values, list_number); if (list_values) { gchar **row_values = g_strsplit_set (list_values, "|", -1); if (row_values) { GtkTreeIter iter; gchar *row = row_values[0]; gint position = -1; i = 0; while (row != NULL) { if (position >= n_columns || position == -1) { position = 0; gtk_list_store_append (list_store, &iter); } gtk_list_store_set (list_store, &iter, position, row, -1); position++; row = row_values[++i]; } g_strfreev (row_values); } g_free (list_values); } } gtk_tree_view_set_model ( GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store)); g_object_unref (list_store); scrolled_window = gtk_scrolled_window_new (NULL, NULL); // gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW // (scrolled_window), // GTK_WIDGET (tree_view)); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view)); gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100); gtk_tree_view_set_headers_visible ( GTK_TREE_VIEW (tree_view), forms_data->show_header); return scrolled_window; }
static void tab_panel_app_add_browser_cb (MidoriApp* app, MidoriBrowser* browser, MidoriExtension* extension) { GtkTreeStore* model; GtkWidget* treeview; GtkTreeViewColumn* column; GtkCellRenderer* renderer_pixbuf; GtkCellRenderer* renderer_text; GtkWidget* panel; GtkWidget* toolbar; gint i; /* GtkToolItem* toolitem; */ g_object_set (browser, "show-tabs", FALSE, NULL); panel = katze_object_get_object (browser, "panel"); model = gtk_tree_store_new (8, MIDORI_TYPE_VIEW, G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, GDK_TYPE_COLOR, GDK_TYPE_COLOR); g_object_set_data (G_OBJECT (browser), "tab-panel-ext-model", model); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (treeview), FALSE); #if GTK_CHECK_VERSION (2, 12, 0) g_signal_connect (treeview, "query-tooltip", G_CALLBACK (tab_panel_treeview_query_tooltip_cb), NULL); gtk_widget_set_has_tooltip (treeview, TRUE); #endif column = gtk_tree_view_column_new (); renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf, "pixbuf", 3, "cell-background-gdk", 6, NULL); renderer_text = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer_text, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_text, "text", 4, "ellipsize", 5, "cell-background-gdk", 6, "foreground-gdk", 7, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); column = gtk_tree_view_column_new (); renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf, "stock-id", 1, "follow-state", 2, "visible", 2, "cell-background-gdk", 6, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); g_object_connect (treeview, "signal::row-activated", midori_extension_row_activated_cb, extension, "signal::cursor-changed", midori_extension_cursor_or_row_changed_cb, extension, "signal::columns-changed", midori_extension_cursor_or_row_changed_cb, extension, "signal::button-release-event", midori_extension_button_release_event_cb, extension, "signal::key-release-event", midori_extension_key_release_event_cb, extension, "signal::popup-menu", midori_extension_popup_menu_cb, extension, NULL); gtk_widget_show (treeview); toolbar = gtk_toolbar_new (); g_object_set_data (G_OBJECT (browser), "tab-panel-ext-toolbar", toolbar); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON); gtk_widget_show (toolbar); /* TODO: Implement optional thumbnail images toolitem = gtk_toggle_tool_button_new_from_stock (STOCK_IMAGE); gtk_tool_item_set_is_important (toolitem, TRUE); g_signal_connect (toolitem, "toggled", G_CALLBACK (tab_panel_button_thumbnail_toggled_cb), notebook); gtk_widget_show (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); */ i = midori_panel_append_widget (MIDORI_PANEL (panel), treeview, STOCK_TAB_PANEL, _("Tab Panel"), toolbar); if (gtk_widget_get_visible (GTK_WIDGET (browser))) midori_panel_set_current_page (MIDORI_PANEL (panel), i); g_object_unref (panel); midori_browser_foreach (browser, (GtkCallback)tab_panel_browser_foreach_cb, treeview); g_signal_connect_after (browser, "add-tab", G_CALLBACK (tab_panel_browser_add_tab_cb), extension); g_signal_connect (browser, "remove-tab", G_CALLBACK (tab_panel_browser_remove_tab_cb), extension); g_signal_connect (browser, "notify::tab", G_CALLBACK (tab_panel_browser_notify_tab_cb), treeview); g_signal_connect (extension, "deactivate", G_CALLBACK (tab_panel_deactivate_cb), treeview); g_signal_connect (browser, "move-tab", G_CALLBACK (tab_panel_browser_move_tab_cb), NULL); }
static void init_tree() { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeStore *store; int i; PangoFontDescription *font_desc = pango_font_description_from_string(prefs.divelist_font); gtk_widget_modify_font(yearly_tree, font_desc); pango_font_description_free(font_desc); renderer = gtk_cell_renderer_text_new (); /* don't use empty strings "" - they confuse gettext */ char *columnstop[] = { N_("Year"), N_("#"), N_("Duration"), " ", " ", " ", N_("Depth"), " ", " ", N_("SAC"), " ", " ", N_("Temperature"), " ", " " }; const char *columnsbot[15]; columnsbot[0] = C_("Stats", " > Month"); columnsbot[1] = " "; columnsbot[2] = C_("Duration","Total"); columnsbot[3] = C_("Duration","Average"); columnsbot[4] = C_("Duration","Shortest"); columnsbot[5] = C_("Duration","Longest"); columnsbot[6] = C_("Depth", "Average"); columnsbot[7] = C_("Depth","Minimum"); columnsbot[8] = C_("Depth","Maximum"); columnsbot[9] = C_("SAC","Average"); columnsbot[10]= C_("SAC","Minimum"); columnsbot[11]= C_("SAC","Maximum"); columnsbot[12]= C_("Temp","Average"); columnsbot[13]= C_("Temp","Minimum"); columnsbot[14]= C_("Temp","Maximum"); /* Add all the columns to the tree view */ for (i = 0; i < N_COLUMNS; ++i) { char buf[80]; column = gtk_tree_view_column_new(); snprintf(buf, sizeof(buf), "%s\n%s", _(columnstop[i]), columnsbot[i]); gtk_tree_view_column_set_title(column, buf); gtk_tree_view_append_column(GTK_TREE_VIEW(yearly_tree), column); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", i); gtk_tree_view_column_set_resizable(column, TRUE); } /* Field types */ store = gtk_tree_store_new ( N_COLUMNS, // Columns in structure G_TYPE_STRING, // Period (year or month) G_TYPE_STRING, // Number of dives G_TYPE_STRING, // Total duration G_TYPE_STRING, // Average dive duation G_TYPE_STRING, // Shortest dive G_TYPE_STRING, // Longest dive G_TYPE_STRING, // Average depth G_TYPE_STRING, // Shallowest dive G_TYPE_STRING, // Deepest dive G_TYPE_STRING, // Average air consumption (SAC) G_TYPE_STRING, // Minimum SAC G_TYPE_STRING, // Maximum SAC G_TYPE_STRING, // Average temperature G_TYPE_STRING, // Minimum temperature G_TYPE_STRING // Maximum temperature ); gtk_tree_view_set_model (GTK_TREE_VIEW (yearly_tree), GTK_TREE_MODEL (store)); g_object_unref (store); }
/* 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, /* ID */ G_TYPE_STRING, /* Operation Code */ G_TYPE_INT, /* Invokes */ G_TYPE_INT, /* Num Bytes */ G_TYPE_FLOAT, /* Avg Bytes */ G_TYPE_INT, /* RetResult */ G_TYPE_INT, /* Num Bytes */ G_TYPE_FLOAT, /* Avg Bytes */ G_TYPE_INT, /* Total Bytes */ G_TYPE_FLOAT); /* Avg Bytes */ /* 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, ID_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 */ /* 1:st column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("ID", renderer, "text", ID_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, ID_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, 40); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); /* 2:nd column..Operation Code. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Operation Code", renderer, "text", OP_CODE_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, OP_CODE_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, 210); gtk_tree_view_append_column (list_view, column); /* 3:d column..Invokes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Invokes", renderer, "text", INVOKES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, INVOKES_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, 60); gtk_tree_view_append_column (list_view, column); /* 4:th column.. Num Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer, "text", NUM_BYTES_FWD_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_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, 100); gtk_tree_view_append_column (list_view, column); /* 5:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_FWD_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_FWD_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_FWD_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, 80); gtk_tree_view_append_column (list_view, column); /* 6:d column..Invokes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("ReturnResult", renderer, "text", RET_RES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, RET_RES_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, 60); gtk_tree_view_append_column (list_view, column); /* 7:th column.. Num Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer, "text", NUM_BYTES_REV_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_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, 100); gtk_tree_view_append_column (list_view, column); /* 8:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_REV_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_REV_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_REV_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, 80); gtk_tree_view_append_column (list_view, column); /* 9:th column.. Total Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Total Bytes", renderer, "text", TOT_BYTES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_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, 100); gtk_tree_view_append_column (list_view, column); /* 10:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_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, 60); 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; }
static GtkWidget *create_window(void) { GtkWidget *startwin; GtkWidget *hlayout; GtkWidget *banner; GtkWidget *vlayout; GtkWidget *tabs; GtkWidget *configvlayout; GtkWidget *configlayout; GtkWidget *fullscreencheck; GtkWidget *vmode3dlabel; GtkWidget *inputdevlabel; GtkWidget *inputmousecheck; GtkWidget *inputjoycheck; GtkWidget *vmode3dcombo; GtkWidget *alwaysshowcheck; GtkWidget *configtab; GtkWidget *gamevlayout; GtkWidget *gamelabel; GtkWidget *gamescroll; GtkWidget *gamelist; GtkWidget *gametab; GtkWidget *messagesscroll; GtkWidget *messagestext; GtkWidget *messagestab; GtkWidget *buttons; GtkWidget *cancelbutton; GtkWidget *cancelbuttonalign; GtkWidget *cancelbuttonlayout; GtkWidget *cancelbuttonicon; GtkWidget *cancelbuttonlabel; GtkWidget *startbutton; GtkWidget *startbuttonalign; GtkWidget *startbuttonlayout; GtkWidget *startbuttonicon; GtkWidget *startbuttonlabel; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); // Basic window startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (startwin), apptitle); // NOTE: use global app title gtk_window_set_position (GTK_WINDOW (startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable (GTK_WINDOW (startwin), FALSE); gtk_window_set_type_hint (GTK_WINDOW (startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls hlayout = gtk_hbox_new (FALSE, 0); gtk_widget_show (hlayout); gtk_container_add (GTK_CONTAINER (startwin), hlayout); // Banner { GdkPixbuf *pixbuf = load_banner(); banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_widget_show (banner); gtk_box_pack_start (GTK_BOX (hlayout), banner, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons vlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (vlayout); gtk_box_pack_start (GTK_BOX (hlayout), vlayout, TRUE, TRUE, 0); // Tab control tabs = gtk_notebook_new (); gtk_widget_show (tabs); gtk_box_pack_start (GTK_BOX (vlayout), tabs, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (tabs), 4); // Vertical layout of config page main body configvlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (configvlayout); gtk_container_add (GTK_CONTAINER (tabs), configvlayout); // Fixed-position layout of config page controls configlayout = gtk_fixed_new (); gtk_widget_show (configlayout); gtk_box_pack_start (GTK_BOX (configvlayout), configlayout, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (configlayout), 6); // Fullscreen checkbox fullscreencheck = gtk_check_button_new_with_mnemonic ("_Fullscreen"); gtk_widget_show (fullscreencheck); gtk_fixed_put (GTK_FIXED (configlayout), fullscreencheck, 248, 0); gtk_widget_set_size_request (fullscreencheck, 85, 29); gtk_widget_add_accelerator (fullscreencheck, "grab_focus", accel_group, GDK_F, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // 3D video mode label vmode3dlabel = gtk_label_new_with_mnemonic ("_Video mode:"); gtk_widget_show (vmode3dlabel); gtk_fixed_put (GTK_FIXED (configlayout), vmode3dlabel, 0, 0); gtk_widget_set_size_request (vmode3dlabel, 88, 29); gtk_misc_set_alignment (GTK_MISC (vmode3dlabel), 0, 0.5); inputdevlabel = gtk_label_new ("Input devices:"); gtk_widget_show (inputdevlabel); gtk_fixed_put (GTK_FIXED (configlayout), inputdevlabel, 0, 120); gtk_widget_set_size_request (inputdevlabel, 88, 20); gtk_misc_set_alignment (GTK_MISC (inputdevlabel), 0, 0.5); inputmousecheck = gtk_check_button_new_with_mnemonic ("Mo_use"); gtk_widget_show (inputmousecheck); gtk_fixed_put (GTK_FIXED (configlayout), inputmousecheck, 88, 120); gtk_widget_set_size_request (inputmousecheck, 80, 20); gtk_widget_add_accelerator (inputmousecheck, "grab_focus", accel_group, GDK_U, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); inputjoycheck = gtk_check_button_new_with_mnemonic ("_Joystick"); gtk_widget_show (inputjoycheck); gtk_fixed_put (GTK_FIXED (configlayout), inputjoycheck, 168, 120); gtk_widget_set_size_request (inputjoycheck, 80, 20); gtk_widget_add_accelerator (inputjoycheck, "grab_focus", accel_group, GDK_J, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; 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(vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(vmode3dcombo), cell, "text", 0, NULL); } gtk_widget_show (vmode3dcombo); gtk_fixed_put (GTK_FIXED (configlayout), vmode3dcombo, 88, 0); gtk_widget_set_size_request (vmode3dcombo, 150, 29); gtk_widget_add_accelerator (vmode3dcombo, "grab_focus", accel_group, GDK_V, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Always show config checkbox alwaysshowcheck = gtk_check_button_new_with_mnemonic ("_Always show configuration on start"); gtk_widget_show (alwaysshowcheck); gtk_box_pack_start (GTK_BOX (configvlayout), alwaysshowcheck, FALSE, FALSE, 0); gtk_widget_add_accelerator (alwaysshowcheck, "grab_focus", accel_group, GDK_A, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Configuration tab configtab = gtk_label_new ("Configuration"); gtk_widget_show (configtab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 0), configtab); // Game data layout gamevlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (gamevlayout); gtk_container_add (GTK_CONTAINER (tabs), gamevlayout); gtk_container_set_border_width (GTK_CONTAINER (gamevlayout), 4); // Game data field label gamelabel = gtk_label_new_with_mnemonic ("_Game or addon:"); gtk_widget_show (gamelabel); gtk_box_pack_start (GTK_BOX (gamevlayout), gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (gamelabel), 0, 0.5); // Game data scrollable area gamescroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (gamescroll); gtk_box_pack_start (GTK_BOX (gamevlayout), gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (gamescroll), GTK_SHADOW_IN); // Game data list { GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); GtkCellRenderer *cell; GtkTreeViewColumn *col; gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING); gamelist = gtk_tree_view_new_with_model (GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL); gtk_tree_view_column_set_expand(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(gamelist), col); col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL); gtk_tree_view_column_set_min_width(col, 64); gtk_tree_view_append_column(GTK_TREE_VIEW(gamelist), col); } gtk_widget_show (gamelist); gtk_container_add (GTK_CONTAINER (gamescroll), gamelist); gtk_widget_add_accelerator (gamelist, "grab_focus", accel_group, GDK_G, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gamelist), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (gamelist), FALSE); // Game tab gametab = gtk_label_new ("Game"); gtk_widget_show (gametab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 1), gametab); // Messages scrollable area messagesscroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (messagesscroll); gtk_container_add (GTK_CONTAINER (tabs), messagesscroll); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area messagestext = gtk_text_view_new (); gtk_widget_show (messagestext); gtk_container_add (GTK_CONTAINER (messagesscroll), messagestext); gtk_text_view_set_editable (GTK_TEXT_VIEW (messagestext), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (messagestext), FALSE); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (messagestext), 2); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (messagestext), 2); // Messages tab messagestab = gtk_label_new ("Messages"); gtk_widget_show (messagestab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 2), messagestab); // Dialogue box buttons layout buttons = gtk_hbutton_box_new (); gtk_widget_show (buttons); gtk_box_pack_start (GTK_BOX (vlayout), buttons, FALSE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (buttons), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (buttons), GTK_BUTTONBOX_END); // Cancel button cancelbutton = gtk_button_new (); gtk_widget_show (cancelbutton); gtk_container_add (GTK_CONTAINER (buttons), cancelbutton); GTK_WIDGET_SET_FLAGS (cancelbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (cancelbutton, "grab_focus", accel_group, GDK_C, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (cancelbutton, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); cancelbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (cancelbuttonalign); gtk_container_add (GTK_CONTAINER (cancelbutton), cancelbuttonalign); cancelbuttonlayout = gtk_hbox_new (FALSE, 2); gtk_widget_show (cancelbuttonlayout); gtk_container_add (GTK_CONTAINER (cancelbuttonalign), cancelbuttonlayout); cancelbuttonicon = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_widget_show (cancelbuttonicon); gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonicon, FALSE, FALSE, 0); cancelbuttonlabel = gtk_label_new_with_mnemonic ("_Cancel"); gtk_widget_show (cancelbuttonlabel); gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonlabel, FALSE, FALSE, 0); // Start button startbutton = gtk_button_new (); gtk_widget_show (startbutton); gtk_container_add (GTK_CONTAINER (buttons), startbutton); GTK_WIDGET_SET_FLAGS (startbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (startbutton, "grab_focus", accel_group, GDK_S, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (startbutton, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); startbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (startbuttonalign); gtk_container_add (GTK_CONTAINER (startbutton), startbuttonalign); startbuttonlayout = gtk_hbox_new (FALSE, 2); gtk_widget_show (startbuttonlayout); gtk_container_add (GTK_CONTAINER (startbuttonalign), startbuttonlayout); startbuttonicon = gtk_image_new_from_stock ("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_widget_show (startbuttonicon); gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonicon, FALSE, FALSE, 0); startbuttonlabel = gtk_label_new_with_mnemonic ("_Start"); gtk_widget_show (startbuttonlabel); gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect ((gpointer) startwin, "delete_event", G_CALLBACK (on_startwin_delete_event), NULL); g_signal_connect ((gpointer) fullscreencheck, "toggled", G_CALLBACK (on_fullscreencheck_toggled), NULL); g_signal_connect ((gpointer) inputmousecheck, "toggled", G_CALLBACK (on_inputmousecheck_toggled), NULL); g_signal_connect ((gpointer) inputjoycheck, "toggled", G_CALLBACK (on_inputjoycheck_toggled), NULL); g_signal_connect ((gpointer) vmode3dcombo, "changed", G_CALLBACK (on_vmode3dcombo_changed), NULL); g_signal_connect ((gpointer) alwaysshowcheck, "toggled", G_CALLBACK (on_alwaysshowcheck_toggled), NULL); g_signal_connect ((gpointer) cancelbutton, "clicked", G_CALLBACK (on_cancelbutton_clicked), NULL); g_signal_connect ((gpointer) startbutton, "clicked", G_CALLBACK (on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(gamelist)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect ((gpointer) sel, "changed", G_CALLBACK (on_gamelist_selection_changed), NULL); } // Associate labels with their controls gtk_label_set_mnemonic_widget (GTK_LABEL (vmode3dlabel), vmode3dcombo); gtk_label_set_mnemonic_widget (GTK_LABEL (gamelabel), gamelist); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin"); GLADE_HOOKUP_OBJECT (startwin, hlayout, "hlayout"); GLADE_HOOKUP_OBJECT (startwin, banner, "banner"); GLADE_HOOKUP_OBJECT (startwin, vlayout, "vlayout"); GLADE_HOOKUP_OBJECT (startwin, tabs, "tabs"); GLADE_HOOKUP_OBJECT (startwin, configvlayout, "configvlayout"); GLADE_HOOKUP_OBJECT (startwin, configlayout, "configlayout"); GLADE_HOOKUP_OBJECT (startwin, fullscreencheck, "fullscreencheck"); GLADE_HOOKUP_OBJECT (startwin, vmode3dlabel, "vmode3dlabel"); GLADE_HOOKUP_OBJECT (startwin, inputdevlabel, "inputdevlabel"); GLADE_HOOKUP_OBJECT (startwin, inputmousecheck, "inputmousecheck"); GLADE_HOOKUP_OBJECT (startwin, inputjoycheck, "inputjoycheck"); GLADE_HOOKUP_OBJECT (startwin, vmode3dcombo, "vmode3dcombo"); GLADE_HOOKUP_OBJECT (startwin, alwaysshowcheck, "alwaysshowcheck"); GLADE_HOOKUP_OBJECT (startwin, configtab, "configtab"); GLADE_HOOKUP_OBJECT (startwin, gamevlayout, "gamevlayout"); GLADE_HOOKUP_OBJECT (startwin, gamelabel, "gamelabel"); GLADE_HOOKUP_OBJECT (startwin, gamescroll, "gamescroll"); GLADE_HOOKUP_OBJECT (startwin, gamelist, "gamelist"); GLADE_HOOKUP_OBJECT (startwin, gametab, "gametab"); GLADE_HOOKUP_OBJECT (startwin, messagesscroll, "messagesscroll"); GLADE_HOOKUP_OBJECT (startwin, messagestext, "messagestext"); GLADE_HOOKUP_OBJECT (startwin, messagestab, "messagestab"); GLADE_HOOKUP_OBJECT (startwin, buttons, "buttons"); GLADE_HOOKUP_OBJECT (startwin, cancelbutton, "cancelbutton"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonalign, "cancelbuttonalign"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlayout, "cancelbuttonlayout"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonicon, "cancelbuttonicon"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlabel, "cancelbuttonlabel"); GLADE_HOOKUP_OBJECT (startwin, startbutton, "startbutton"); GLADE_HOOKUP_OBJECT (startwin, startbuttonalign, "startbuttonalign"); GLADE_HOOKUP_OBJECT (startwin, startbuttonlayout, "startbuttonlayout"); GLADE_HOOKUP_OBJECT (startwin, startbuttonicon, "startbuttonicon"); GLADE_HOOKUP_OBJECT (startwin, startbuttonlabel, "startbuttonlabel"); gtk_window_add_accel_group (GTK_WINDOW (startwin), accel_group); return startwin; }
GtkWidget * AP_UnixDialog_Field::_constructWindow(void) { GtkWidget * window; const XAP_StringSet * pSS = m_pApp->getStringSet(); GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkBuilder * builder = newDialogBuilder("ap_UnixDialog_Field.xml"); // Update our member variables with the important widgets that // might need to be queried or altered later window = GTK_WIDGET(gtk_builder_get_object(builder, "ap_UnixDialog_Field")); m_listTypes = GTK_WIDGET(gtk_builder_get_object(builder, "tvTypes")); m_listFields = GTK_WIDGET(gtk_builder_get_object(builder, "tvFields")); m_entryParam = GTK_WIDGET(gtk_builder_get_object(builder, "edExtraParameters")); // set the single selection mode for the TreeViews gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_listTypes)), GTK_SELECTION_SINGLE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_listFields)), GTK_SELECTION_SINGLE); // set the dialog title UT_UTF8String s; pSS->getValueUTF8(AP_STRING_ID_DLG_Field_FieldTitle_Capital,s); abiDialogSetTitle(window, s.utf8_str()); // localize the strings in our dialog, and set some userdata for some widg localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbTypes")), pSS, AP_STRING_ID_DLG_Field_Types_No_Colon); localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbFields")), pSS, AP_STRING_ID_DLG_Field_Fields_No_Colon); localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbExtraParameters")), pSS, AP_STRING_ID_DLG_Field_Parameters_Capital); localizeButtonUnderline(GTK_WIDGET(gtk_builder_get_object(builder, "btInsert")), pSS, AP_STRING_ID_DLG_InsertButton); // add a column to our TreeViews renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Format", renderer, "text", 0, NULL); gtk_tree_view_append_column( GTK_TREE_VIEW(m_listTypes), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Format", renderer, "text", 0, NULL); gtk_tree_view_append_column( GTK_TREE_VIEW(m_listFields), column); // connect a clicked signal to the column g_signal_connect_after(G_OBJECT(m_listTypes), "cursor-changed", G_CALLBACK(s_types_clicked), static_cast<gpointer>(this)); g_signal_connect_after(G_OBJECT(m_listFields), "row-activated", G_CALLBACK(s_field_dblclicked), static_cast<gpointer>(this)); g_object_unref(G_OBJECT(builder)); return window; }
/* * Open the window to select and type the picture properties */ void Picture_Properties_Button_Clicked (GObject *object) { GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow; GtkWidget *type, *label, *desc; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkListStore *store; GtkTreeIter type_iter_to_select, iter; GtkTreeModel *model; GtkWindow *parent_window = NULL; GList *selection_list = NULL; GList *l; gint selection_nbr, selection_i = 1; gint response; EtPictureType pic_type; g_return_if_fail (PictureEntryView != NULL); parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object))); if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window))) { g_warning("Could not get parent window\n"); return; } model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView)); selection_list = gtk_tree_selection_get_selected_rows(selection, NULL); selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection)); for (l = selection_list; l != NULL; l = g_list_next (l)) { GtkTreePath *path = l->data; Picture *pic = NULL; GtkTreeSelection *selectiontype; gchar *title; GtkTreePath *rowPath; gboolean valid; // Get corresponding picture valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path); if (valid) gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1); title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++, selection_nbr); PictureTypesWindow = gtk_dialog_new_with_buttons(title, parent_window, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_free(title); gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK); ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT); type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref (store); gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_title (column, _("Image Type")); gtk_tree_view_column_set_attributes(column, renderer, "text", PICTURE_TYPE_COLUMN_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(type), column); gtk_widget_set_size_request(type, 256, 256); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0); // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { /* Load picture type (only Front Cover!). */ GtkTreeIter itertype; gtk_list_store_insert_with_values (store, &itertype, G_MAXINT, PICTURE_TYPE_COLUMN_TEXT, _(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)), PICTURE_TYPE_COLUMN_TYPE_CODE, ET_PICTURE_TYPE_FRONT_COVER, -1); /* Line to select by default. */ type_iter_to_select = itertype; break; } // Other tag types default: { // Load pictures types for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++) { GtkTreeIter itertype; gtk_list_store_insert_with_values (store, &itertype, G_MAXINT, PICTURE_TYPE_COLUMN_TEXT, _(Picture_Type_String (pic_type)), PICTURE_TYPE_COLUMN_TYPE_CODE, pic_type, -1); /* Line to select by default. */ if (pic->type == pic_type) type_iter_to_select = itertype; } break; } } // Select the line by default selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type)); gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select); // Set visible the current selected line rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0); gtk_tree_path_free(rowPath); // Description of the picture label = gtk_label_new (_("Image Description:")); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4); // Entry for the description desc = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0); if (pic->description) { gchar *tmp = Try_To_Validate_Utf8_String(pic->description); gtk_entry_set_text(GTK_ENTRY(desc), tmp); g_free(tmp); } // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE); break; } // Other tag types default: { break; } } gtk_widget_show_all(PictureTypesWindow); response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow)); if (response == GTK_RESPONSE_OK) { GtkTreeModel *modeltype; GtkTreeIter itertype; modeltype = gtk_tree_view_get_model(GTK_TREE_VIEW(type)); selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type)); if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype)) { gchar *buffer, *pic_info; gint t; gtk_tree_model_get(modeltype, &itertype, PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1); pic->type = t; buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc))); Strip_String(buffer); if (pic->description) g_free(pic->description); /* If the entry was empty, buffer will be the empty string "". * This can be safely passed to the underlying * FLAC__metadata_object_picture_set_description(). See * https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804 * and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for * downstream bugs when 0 was passed instead. */ pic->description = buffer; // Update value in the PictureEntryView pic_info = Picture_Info(pic); gtk_list_store_set(GTK_LIST_STORE(model), &iter, PICTURE_COLUMN_TEXT, pic_info, -1); g_free(pic_info); } } gtk_widget_destroy(PictureTypesWindow); } g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free); }
/* * plugin management */ void gtkui_plugin_mgmt(void) { GtkWidget *scrolled, *vbox; GtkCellRenderer *renderer; GtkTreeViewColumn *column; DEBUG_MSG("gtk_plugin_mgmt"); /* if the object already exist, set the focus to it */ if (plugins_window) { if(GTK_IS_WINDOW (plugins_window)) gtk_window_present(GTK_WINDOW (plugins_window)); else gtkui_page_present(plugins_window); return; } plugins_window = gtkui_page_new("Plugins", >kui_plug_destroy, >kui_plugins_detach); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER (plugins_window), vbox); gtk_widget_show(vbox); /* list */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); treeview = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER (scrolled), treeview); gtk_widget_show(treeview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (treeview), "row_activated", G_CALLBACK (gtkui_select_plugin), NULL); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (" ", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id (column, 1); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Version", renderer, "text", 2, NULL); gtk_tree_view_column_set_sort_column_id (column, 2); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Info", renderer, "text", 3, NULL); gtk_tree_view_column_set_sort_column_id (column, 3); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); /* create the array for the list widget */ /* or refreshes it if it exists */ gtkui_create_plug_array(); gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (ls_plugins)); gtk_widget_show(plugins_window); }
static PidginLogViewer *display_log_viewer(struct log_viewer_hash_t *ht, GList *logs, const char *title, GtkWidget *icon, int log_size) { PidginLogViewer *lv; GtkWidget *title_box; char *text; GtkWidget *pane; GtkWidget *sw; GtkCellRenderer *rend; GtkTreeViewColumn *col; GtkTreeSelection *sel; GtkWidget *vbox; GtkWidget *frame; GtkWidget *hbox; GtkWidget *find_button; GtkWidget *size_label; if (logs == NULL) { /* No logs were found. */ const char *log_preferences = NULL; if (ht == NULL) { if (!purple_prefs_get_bool("/purple/logging/log_system")) log_preferences = _("System events will only be logged if the \"Log all status changes to system log\" preference is enabled."); } else { if (ht->type == PURPLE_LOG_IM) { if (!purple_prefs_get_bool("/purple/logging/log_ims")) log_preferences = _("Instant messages will only be logged if the \"Log all instant messages\" preference is enabled."); } else if (ht->type == PURPLE_LOG_CHAT) { if (!purple_prefs_get_bool("/purple/logging/log_chats")) log_preferences = _("Chats will only be logged if the \"Log all chats\" preference is enabled."); } g_free(ht->buddyname); g_free(ht); } if(icon != NULL) gtk_widget_destroy(icon); purple_notify_info(NULL, title, _("No logs were found"), log_preferences); return NULL; } lv = g_new0(PidginLogViewer, 1); lv->logs = logs; if (ht != NULL) g_hash_table_insert(log_viewers, ht, lv); /* Window ***********/ lv->window = gtk_dialog_new_with_buttons(title, NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); #ifdef _WIN32 /* Steal the "HELP" response and use it to trigger browsing to the logs folder */ gtk_dialog_add_button(GTK_DIALOG(lv->window), _("_Browse logs folder"), GTK_RESPONSE_HELP); #endif gtk_container_set_border_width (GTK_CONTAINER(lv->window), PIDGIN_HIG_BOX_SPACE); gtk_dialog_set_has_separator(GTK_DIALOG(lv->window), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(lv->window)->vbox), 0); g_signal_connect(G_OBJECT(lv->window), "response", G_CALLBACK(destroy_cb), ht); gtk_window_set_role(GTK_WINDOW(lv->window), "log_viewer"); /* Icon *************/ if (icon != NULL) { title_box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_container_set_border_width(GTK_CONTAINER(title_box), PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), title_box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(title_box), icon, FALSE, FALSE, 0); } else title_box = GTK_DIALOG(lv->window)->vbox; /* Label ************/ lv->label = gtk_label_new(NULL); text = g_strdup_printf("<span size='larger' weight='bold'>%s</span>", title); gtk_label_set_markup(GTK_LABEL(lv->label), text); gtk_misc_set_alignment(GTK_MISC(lv->label), 0, 0); gtk_box_pack_start(GTK_BOX(title_box), lv->label, FALSE, FALSE, 0); g_free(text); /* Pane *************/ pane = gtk_hpaned_new(); gtk_container_set_border_width(GTK_CONTAINER(pane), PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), pane, TRUE, TRUE, 0); /* List *************/ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_paned_add1(GTK_PANED(pane), sw); lv->treestore = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); lv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (lv->treestore)); g_object_unref(G_OBJECT(lv->treestore)); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes ("time", rend, "markup", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(lv->treeview), col); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (lv->treeview), FALSE); gtk_container_add (GTK_CONTAINER (sw), lv->treeview); populate_log_tree(lv); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (lv->treeview)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (log_select_cb), lv); g_signal_connect (G_OBJECT(lv->treeview), "row-activated", G_CALLBACK(log_row_activated_cb), lv); pidgin_set_accessible_label(lv->treeview, lv->label); g_signal_connect(lv->treeview, "button-press-event", G_CALLBACK(log_button_press_cb), lv); g_signal_connect(lv->treeview, "popup-menu", G_CALLBACK(log_popup_menu_cb), lv); /* Log size ************/ if(log_size) { char *sz_txt = purple_str_size_to_units(log_size); text = g_strdup_printf("<span weight='bold'>%s</span> %s", _("Total log size:"), sz_txt); size_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(size_label), text); /* gtk_paned_add1(GTK_PANED(pane), size_label); */ gtk_misc_set_alignment(GTK_MISC(size_label), 0, 0); gtk_box_pack_end(GTK_BOX(GTK_DIALOG(lv->window)->vbox), size_label, FALSE, FALSE, 0); g_free(sz_txt); g_free(text); } /* A fancy little box ************/ vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_paned_add2(GTK_PANED(pane), vbox); /* Viewer ************/ frame = pidgin_create_imhtml(FALSE, &lv->imhtml, NULL, NULL); gtk_widget_set_name(lv->imhtml, "pidgin_log_imhtml"); gtk_widget_set_size_request(lv->imhtml, 320, 200); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); gtk_widget_show(frame); /* Search box **********/ hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); lv->entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), lv->entry, TRUE, TRUE, 0); find_button = gtk_button_new_from_stock(GTK_STOCK_FIND); gtk_box_pack_start(GTK_BOX(hbox), find_button, FALSE, FALSE, 0); g_signal_connect(GTK_ENTRY(lv->entry), "activate", G_CALLBACK(search_cb), lv); g_signal_connect(GTK_BUTTON(find_button), "clicked", G_CALLBACK(search_cb), lv); select_first_log(lv); gtk_widget_show_all(lv->window); return lv; }