GtkWidget * status_menu_new (Ekiga::ServiceCore & core) { StatusMenu *self = NULL; sigc::connection conn; GtkCellRenderer *renderer = NULL; GSList *custom_status_array [NUM_STATUS_TYPES]; self = (StatusMenu *) g_object_new (STATUS_MENU_TYPE, NULL); self->priv = new StatusMenuPrivate (); self->priv->personal_details = core.get ("personal-details"); self->priv->parent = NULL; self->priv->list_store = gtk_list_store_new (NUM_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN); gtk_combo_box_set_model (GTK_COMBO_BOX (self), GTK_TREE_MODEL (self->priv->list_store)); g_object_unref (self->priv->list_store); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self), renderer, "pixbuf", COL_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self), renderer, "text", COL_MESSAGE, NULL); g_object_set (renderer, "width", 130, "ellipsize-set", true, "ellipsize", PANGO_ELLIPSIZE_END, NULL); for (int i = 0 ; i < NUM_STATUS_TYPES ; i++) custom_status_array [i] = gm_conf_get_string_list (status_types_keys [i]); status_menu_populate (self, custom_status_array); for (int i = 0 ; i < NUM_STATUS_TYPES ; i++) { g_slist_foreach (custom_status_array [i], (GFunc) g_free, 0); g_slist_free (custom_status_array [i]); } gtk_combo_box_set_active (GTK_COMBO_BOX (self), 0); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (self), (GtkTreeViewRowSeparatorFunc) status_menu_row_is_separator, NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (self), 0); status_menu_set_option (self, self->priv->personal_details->get_presence (), self->priv->personal_details->get_status ()); g_signal_connect (G_OBJECT (self), "changed", G_CALLBACK (status_menu_option_changed), self); gm_conf_notifier_add (PERSONAL_DATA_KEY "online_custom_status", status_menu_custom_messages_changed, self); gm_conf_notifier_add (PERSONAL_DATA_KEY "away_custom_status", status_menu_custom_messages_changed, self); gm_conf_notifier_add (PERSONAL_DATA_KEY "dnd_custom_status", status_menu_custom_messages_changed, self); conn = self->priv->personal_details->updated.connect (sigc::bind (sigc::ptr_fun (on_details_updated), self)); self->priv->connections.push_back (conn); return GTK_WIDGET (self); }
static void dlg_photo_importer (GthBrowser *browser, GFile *source, DlgImporterSourceType selector_type) { DialogData *data; GtkCellRenderer *renderer; GthFileDataSort *sort_type; GList *tests, *scan; char *general_filter; int i, active_filter; int i_general; if (gth_browser_get_dialog (browser, "photo_importer") != NULL) { gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "photo_importer"))); return; } data = g_new0 (DialogData, 1); data->browser = browser; data->builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/photo_importer/data/ui/photo-importer.ui"); data->settings = g_settings_new (GTHUMB_PHOTO_IMPORTER_SCHEMA); data->selector_type = selector_type; data->source = _g_object_ref (source); data->cancellable = g_cancellable_new (); data->vfs_source = g_object_new (GTH_TYPE_FILE_SOURCE_VFS, NULL); gth_file_source_monitor_entry_points (GTH_FILE_SOURCE (data->vfs_source)); /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "photo_importer_dialog"); _gtk_window_resize_to_fit_screen_height (data->dialog, 580); gth_browser_set_dialog (browser, "photo_importer", data->dialog); g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) { gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Removable Device")); data->device_list_store = gtk_list_store_new (SOURCE_LIST_COLUMNS, G_TYPE_OBJECT, G_TYPE_ICON, G_TYPE_STRING); data->device_chooser = gtk_combo_box_new_with_model (GTK_TREE_MODEL (data->device_list_store)); gtk_widget_show (data->device_chooser); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->device_chooser, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->device_chooser); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser), renderer, "gicon", SOURCE_LIST_COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser), renderer, "text", SOURCE_LIST_COLUMN_NAME, NULL); g_object_unref (data->device_list_store); } else { if (data->source == NULL) { if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser))) data->source = _g_object_ref (gth_browser_get_location (browser)); if (data->source == NULL) data->source = g_file_new_for_uri (get_home_uri ()); } gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Folder")); data->folder_chooser = gtk_file_chooser_button_new (_("Choose a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->folder_chooser); gtk_file_chooser_set_file (GTK_FILE_CHOOSER (data->folder_chooser), data->source, NULL); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->folder_chooser), FALSE); gtk_widget_show (data->folder_chooser); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->folder_chooser, TRUE, TRUE, 0); } data->file_list = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NORMAL, FALSE); sort_type = gth_main_get_sort_type ("file::mtime"); gth_file_list_set_sort_func (GTH_FILE_LIST (data->file_list), sort_type->cmp_func, FALSE); gth_file_list_enable_thumbs (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_thumb_size (GTH_FILE_LIST (data->file_list), 128); gth_file_list_set_caption (GTH_FILE_LIST (data->file_list), "standard::display-name,gth::file::display-size"); gtk_widget_show (data->file_list); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("filelist_box")), data->file_list, TRUE, TRUE, 0); tests = gth_main_get_registered_objects_id (GTH_TYPE_TEST); general_filter = "file::type::is_media"; /* default value */ active_filter = 0; data->filter_combobox = gtk_combo_box_text_new (); for (i = 0, i_general = -1, scan = tests; scan; scan = scan->next, i++) { const char *registered_test_id = scan->data; GthTest *test; if (strncmp (registered_test_id, "file::type::", 12) != 0) continue; i_general += 1; test = gth_main_get_registered_object (GTH_TYPE_TEST, registered_test_id); if (strcmp (registered_test_id, general_filter) == 0) { active_filter = i_general; gth_file_list_set_filter (GTH_FILE_LIST (data->file_list), test); } data->general_tests = g_list_prepend (data->general_tests, g_strdup (gth_test_get_id (test))); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->filter_combobox), gth_test_get_display_name (test)); g_object_unref (test); } data->general_tests = g_list_reverse (data->general_tests); gtk_combo_box_set_active (GTK_COMBO_BOX (data->filter_combobox), active_filter); gtk_widget_show (data->filter_combobox); gtk_container_add (GTK_CONTAINER (GET_WIDGET ("filter_box")), data->filter_combobox); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("filter_label")), data->filter_combobox); gtk_label_set_use_underline (GTK_LABEL (GET_WIDGET ("filter_label")), TRUE); _g_string_list_free (tests); data->tags_entry = gth_tags_entry_new (GTH_TAGS_ENTRY_MODE_POPUP); gtk_widget_show (data->tags_entry); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("tags_entry_box")), data->tags_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("tags_label")), data->tags_entry); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("delete_checkbutton")), g_settings_get_boolean (data->settings, PREF_PHOTO_IMPORTER_DELETE_FROM_DEVICE)); data->preferences_dialog = gth_import_preferences_dialog_new (); gtk_window_set_transient_for (GTK_WINDOW (data->preferences_dialog), GTK_WINDOW (data->dialog)); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("destination_button_box")), gth_import_destination_button_new (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog)), TRUE, TRUE, 0); gtk_widget_show_all (GET_WIDGET ("destination_button_box")); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "delete-event", G_CALLBACK (dialog_delete_event_cb), data); g_signal_connect (GET_WIDGET ("ok_button"), "clicked", G_CALLBACK (ok_clicked_cb), data); g_signal_connect (GET_WIDGET ("cancel_button"), "clicked", G_CALLBACK (close_dialog), data); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) g_signal_connect (data->device_chooser, "changed", G_CALLBACK (device_chooser_changed_cb), data); else g_signal_connect (data->folder_chooser, "selection-changed", G_CALLBACK (folder_chooser_file_set_cb), data); g_signal_connect (data->filter_combobox, "changed", G_CALLBACK (filter_combobox_changed_cb), data); g_signal_connect (gth_file_view_get_model (GTH_FILE_VIEW (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)))), "visibility_changed", G_CALLBACK (file_store_changed_cb), data); g_signal_connect (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)), "file-selection-changed", G_CALLBACK (file_view_selection_changed_cb), data); data->entry_points_changed_id = g_signal_connect (gth_main_get_default_monitor (), "entry-points-changed", G_CALLBACK (entry_points_changed_cb), data); g_signal_connect_after (GET_WIDGET ("event_entry"), "changed", G_CALLBACK (event_entry_changed_cb), data); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser)); gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE); gtk_widget_show (data->dialog); gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog), gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("event_entry")))); if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) update_device_source_list (data); else load_file_list (data); }
void themes_init(AppearanceData* data) { GtkWidget *w, *del_button; GList *theme_list, *l; GtkListStore *theme_store; GtkTreeModel *sort_model; MateThemeMetaInfo *meta_theme = NULL; GtkIconView *icon_view; GtkCellRenderer *renderer; GtkSettings *settings; char *url; /* initialise some stuff */ mate_theme_init (); mate_wm_manager_init (); data->revert_application_font = NULL; data->revert_documents_font = NULL; data->revert_desktop_font = NULL; data->revert_windowtitle_font = NULL; data->revert_monospace_font = NULL; data->theme_save_dialog = NULL; data->theme_message_area = NULL; data->theme_info_icon = NULL; data->theme_error_icon = NULL; data->theme_custom = mate_theme_meta_info_new (); data->theme_icon = gdk_pixbuf_new_from_file (MATECC_PIXMAP_DIR "/theme-thumbnailing.png", NULL); data->theme_store = theme_store = gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); /* set up theme list */ theme_list = mate_theme_meta_info_find_all (); mate_theme_info_register_theme_change ((ThemeChangedCallback) theme_changed_on_disk_cb, data); data->theme_custom = theme_load_from_gsettings (data); data->theme_custom->name = g_strdup (CUSTOM_THEME_NAME); data->theme_custom->readable_name = g_strdup_printf ("<i>%s</i>", _("Custom")); for (l = theme_list; l; l = l->next) { MateThemeMetaInfo *info = l->data; gtk_list_store_insert_with_values (theme_store, NULL, 0, COL_LABEL, info->readable_name, COL_NAME, info->name, COL_THUMBNAIL, data->theme_icon, -1); if (!meta_theme && theme_is_equal (data->theme_custom, info)) meta_theme = info; } if (!meta_theme) { /* add custom theme */ meta_theme = data->theme_custom; gtk_list_store_insert_with_values (theme_store, NULL, 0, COL_LABEL, meta_theme->readable_name, COL_NAME, meta_theme->name, COL_THUMBNAIL, data->theme_icon, -1); theme_thumbnail_generate (meta_theme, data); } theme_list = g_list_sort (theme_list, (GCompareFunc) theme_list_sort_func); g_list_foreach (theme_list, (GFunc) theme_thumbnail_generate, data); g_list_free (theme_list); icon_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xpad", 5, "ypad", 5, "xalign", 0.5, "yalign", 1.0, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_view), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer, "pixbuf", COL_THUMBNAIL, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "alignment", PANGO_ALIGN_CENTER, "wrap-mode", PANGO_WRAP_WORD_CHAR, "wrap-width", gtk_icon_view_get_item_width (icon_view), "width", gtk_icon_view_get_item_width (icon_view), "xalign", 0.5, "yalign", 0.0, NULL); gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (icon_view), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer, "markup", COL_LABEL, NULL); sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (theme_store)); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL, theme_store_sort_func, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), COL_LABEL, GTK_SORT_ASCENDING); gtk_icon_view_set_model (icon_view, GTK_TREE_MODEL (sort_model)); g_signal_connect (icon_view, "selection-changed", (GCallback) theme_selection_changed_cb, data); g_signal_connect_after (icon_view, "realize", (GCallback) theme_select_name, meta_theme->name); w = appearance_capplet_get_widget (data, "theme_install"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_install_cb, data); w = appearance_capplet_get_widget (data, "theme_save"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_icon_name ("document-save-as", GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_save_cb, data); w = appearance_capplet_get_widget (data, "theme_custom"); gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON)); g_signal_connect (w, "clicked", (GCallback) theme_custom_cb, data); del_button = appearance_capplet_get_widget (data, "theme_delete"); g_signal_connect (del_button, "clicked", (GCallback) theme_delete_cb, data); w = appearance_capplet_get_widget (data, "theme_vbox"); gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL, drop_types, G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_MOVE); g_signal_connect (w, "drag-data-received", (GCallback) theme_drag_data_received_cb, data); if (is_locked_down ()) gtk_widget_set_sensitive (w, FALSE); w = appearance_capplet_get_widget (data, "more_themes_linkbutton"); url = g_settings_get_string (data->settings, MORE_THEMES_URL_KEY); if (url != NULL && url[0] != '\0') { gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url); gtk_widget_show (w); } else { gtk_widget_hide (w); } g_free (url); /* listen to gsettings changes, too */ g_signal_connect (data->marco_settings, "changed::" MARCO_THEME_KEY, G_CALLBACK (theme_gsettings_changed), data); g_signal_connect (data->mouse_settings, "changed::" CURSOR_THEME_KEY, G_CALLBACK (theme_gsettings_changed), data); g_signal_connect (data->mouse_settings, "changed::" CURSOR_SIZE_KEY, G_CALLBACK (theme_gsettings_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_FILE_KEY, G_CALLBACK (background_or_font_changed), data); g_signal_connect (data->interface_settings, "changed::" GTK_FONT_KEY, G_CALLBACK (background_or_font_changed), data); g_signal_connect (data->interface_settings, "changed::" DOCUMENT_FONT_KEY, G_CALLBACK (background_or_font_changed), data); if (data->caja_settings) g_signal_connect (data->caja_settings, "changed::" DESKTOP_FONT_KEY, G_CALLBACK (background_or_font_changed), data); g_signal_connect (data->marco_settings, "changed::" WINDOW_TITLE_FONT_KEY, G_CALLBACK (background_or_font_changed), data); g_signal_connect (data->interface_settings, "changed::" MONOSPACE_FONT_KEY, G_CALLBACK (background_or_font_changed), data); settings = gtk_settings_get_default (); g_signal_connect (settings, "notify::gtk-color-scheme", (GCallback) theme_setting_changed_cb, data); g_signal_connect (settings, "notify::gtk-theme-name", (GCallback) theme_setting_changed_cb, data); g_signal_connect (settings, "notify::gtk-icon-theme-name", (GCallback) theme_setting_changed_cb, data); /* monitor individual font choice buttons, so "revert font" option (if any) can be cleared */ w = appearance_capplet_get_widget (data, "application_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "document_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "desktop_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "window_title_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); w = appearance_capplet_get_widget (data, "monospace_font"); g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data); }
CExpressDlg::CExpressDlg(GtkWindow *pParent):m_pParent(pParent), m_ConvertBtn(NULL), m_ChannelCombo(NULL), m_TimeCorrBtn(NULL), m_SecondsEdit(NULL), m_SecondsBtn(NULL), m_BiasCorrBtn(NULL), m_BiasFrameEdit(NULL), m_BiasFrameBtn(NULL), m_DarkCorrBtn(NULL), m_DarkFrameEdit(NULL), m_DarkFrameBtn(NULL), m_FlatCorrBtn(NULL), m_FlatFrameEdit(NULL), m_FlatFrameBtn(NULL), m_PhotometryBtn(NULL), m_MatchingBtn(NULL), m_RefBtn(NULL), m_RefFrameCombo(NULL), m_RefFrameBtn(NULL), m_CatBtn(NULL), m_CatFrameEdit(NULL), m_CatFrameBtn(NULL), m_TimeCorr(0), m_Updating(false), m_Matching(false) { int row = 0; tProjectType type = g_Project->ProjectType(); GtkWidget *table; GSList *group; GtkCellRenderer *renderer; GtkTreeIter iter; memset(&m_Params, 0, sizeof(tProcParams)); m_Channels = gtk_list_store_new(2, GTK_TYPE_INT, GTK_TYPE_STRING); for (int i=0; RAWChannels[i].caption; i++) { if (!RAWChannels[i].debug || type==PROJECT_TEST) { gtk_list_store_append(m_Channels, &iter); gtk_list_store_set(m_Channels, &iter, 0, RAWChannels[i].type, 1, RAWChannels[i].caption, -1); } } m_Frames = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING); // Dialog with buttons m_pDlg = gtk_dialog_new_with_buttons("Express reduction", pParent, (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg)); gtk_dialog_set_tooltip_by_response(GTK_DIALOG(m_pDlg), GTK_RESPONSE_ACCEPT, "Start the process"); g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this); // Dialog icon gchar *icon = get_icon_file("reduction"); gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL)); g_free(icon); // Dialog layout table = gtk_table_new(4, 3, FALSE); gtk_widget_set_size_request(table, 360, -1); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), table, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(table), 8); gtk_table_set_row_spacings(GTK_TABLE(table), 4); gtk_table_set_col_spacings(GTK_TABLE(table), 4); gtk_table_set_row_spacing(GTK_TABLE(table), 2, 12); gtk_table_set_col_spacing(GTK_TABLE(table), 0, 16); // All frames / selected frames GtkWidget *label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), "<b>Process</b>"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 3, row, row+1); m_AllBtn = gtk_radio_button_new_with_label(NULL, "all files in current project"); gtk_widget_set_tooltip_text(m_AllBtn, "Process all frames in the current project"); g_signal_connect(G_OBJECT(m_AllBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_AllBtn, 0, 3, row+1, row+2); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(m_AllBtn)); m_SelBtn = gtk_radio_button_new_with_label(group, "selected files only"); gtk_widget_set_tooltip_text(m_SelBtn, "Process frames that are selected in the main window"); g_signal_connect(G_OBJECT(m_SelBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_SelBtn, 0, 3, row+2, row+3); row += 3; // Actions label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), "<b>Execute</b>"); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 3, row, row+1); row++; // Fetch / convert m_ConvertBtn = gtk_check_button_new_with_label("Fetch/convert files"); gtk_widget_set_tooltip_text(m_ConvertBtn, "Start reduction with a fresh copy of the source frames"); g_signal_connect(G_OBJECT(m_ConvertBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_ConvertBtn, 0, 3, row, row+1); m_ChannelCombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(m_Channels)); gtk_widget_set_tooltip_text(m_ChannelCombo, "Color to grayscale conversion mode"); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(m_ChannelCombo), renderer, TRUE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(m_ChannelCombo), renderer, "text", 1); gtk_table_attach(GTK_TABLE(table), m_ChannelCombo, 1, 2, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0); row+=2; // Time correction if (type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) { m_TimeCorrBtn = gtk_check_button_new_with_label("Time correction"); gtk_widget_set_tooltip_text(m_TimeCorrBtn, "Adjust the date and time of observation (time correction)"); g_signal_connect(G_OBJECT(m_TimeCorrBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_TimeCorrBtn, 0, 3, row, row+1); m_SecondsEdit = gtk_entry_new(); gtk_entry_set_editable(GTK_ENTRY(m_SecondsEdit), false); gtk_table_attach(GTK_TABLE(table), m_SecondsEdit, 1, 2, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0); m_SecondsBtn = gtk_button_new_with_label("More"); gtk_widget_set_tooltip_text(m_SecondsBtn, "Specify time correction in a separate dialog"); g_signal_connect(G_OBJECT(m_SecondsBtn), "clicked", G_CALLBACK(button_clicked), this); gtk_table_attach(GTK_TABLE(table), m_SecondsBtn, 2, 3, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0); row+=2; } // Bias correction if (g_Project->Profile()->GetBool(CProfile::ADVANCED_CALIBRATION)) { if (type==PROJECT_MASTER_DARK || type==PROJECT_MASTER_FLAT || type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) { m_BiasCorrBtn = gtk_check_button_new_with_label("Bias-frame correction"); gtk_widget_set_tooltip_text(m_BiasCorrBtn, "Apply the bias correction"); g_signal_connect(G_OBJECT(m_BiasCorrBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_BiasCorrBtn, 0, 3, row, row+1); m_BiasFrameEdit = gtk_entry_new(); gtk_widget_set_tooltip_text(m_BiasFrameEdit, "Path to the bias frame"); gtk_table_attach(GTK_TABLE(table), m_BiasFrameEdit, 1, 2, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0); m_BiasFrameBtn = gtk_button_new_with_label("Browse"); gtk_widget_set_tooltip_text(m_BiasCorrBtn, "Choose a bias frame in a separate dialog"); g_signal_connect(G_OBJECT(m_BiasFrameBtn), "clicked", G_CALLBACK(button_clicked), this); gtk_table_attach(GTK_TABLE(table), m_BiasFrameBtn, 2, 3, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0); row+=2; } } // Dark correction if (type==PROJECT_MASTER_FLAT || type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) { m_DarkCorrBtn = gtk_check_button_new_with_label("Dark-frame correction"); gtk_widget_set_tooltip_text(m_DarkCorrBtn, "Apply the dark correction"); g_signal_connect(G_OBJECT(m_DarkCorrBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_DarkCorrBtn, 0, 3, row, row+1); m_DarkFrameEdit = gtk_entry_new(); gtk_widget_set_tooltip_text(m_DarkFrameEdit, "Path to the dark frame"); gtk_table_attach(GTK_TABLE(table), m_DarkFrameEdit, 1, 2, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0); m_DarkFrameBtn = gtk_button_new_with_label("Browse"); gtk_widget_set_tooltip_text(m_DarkFrameBtn, "Choose a dark frame in a separate dialog"); g_signal_connect(G_OBJECT(m_DarkFrameBtn), "clicked", G_CALLBACK(button_clicked), this); gtk_table_attach(GTK_TABLE(table), m_DarkFrameBtn, 2, 3, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0); row+=2; } // Flat correction if (type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) { m_FlatCorrBtn = gtk_check_button_new_with_label("Flat-frame correction"); gtk_widget_set_tooltip_text(m_FlatCorrBtn, "Apply the flat correction"); g_signal_connect(G_OBJECT(m_FlatCorrBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_FlatCorrBtn, 0, 3, row, row+1); m_FlatFrameEdit = gtk_entry_new(); gtk_widget_set_tooltip_text(m_FlatFrameEdit, "Path to the flat frame"); gtk_table_attach(GTK_TABLE(table), m_FlatFrameEdit, 1, 2, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0); m_FlatFrameBtn = gtk_button_new_with_label("Browse"); gtk_widget_set_tooltip_text(m_FlatFrameBtn, "Choose a flat frame in a separate dialog"); g_signal_connect(G_OBJECT(m_FlatFrameBtn), "clicked", G_CALLBACK(button_clicked), this); gtk_table_attach(GTK_TABLE(table), m_FlatFrameBtn, 2, 3, row+1, row+2, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0); row+=2; } // Photometry if (type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) { m_PhotometryBtn = gtk_check_button_new_with_label("Photometry"); gtk_widget_set_tooltip_text(m_PhotometryBtn, "Run photometry"); g_signal_connect(G_OBJECT(m_PhotometryBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_PhotometryBtn, 0, 3, row, row+1); row++; } // Matching if (type==PROJECT_REDUCE || type==PROJECT_COMBINING || type==PROJECT_TEST) { m_MatchingBtn = gtk_check_button_new_with_label("Matching"); gtk_widget_set_tooltip_text(m_MatchingBtn, "Run matching"); g_signal_connect(G_OBJECT(m_MatchingBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_MatchingBtn, 0, 3, row, row+1); m_RefBtn = gtk_radio_button_new_with_label(NULL, "using reference frame"); gtk_widget_set_tooltip_text(m_RefBtn, "Use one of the source frames as a reference frame"); g_signal_connect(G_OBJECT(m_RefBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_RefBtn, 1, 3, row+1, row+2); m_RefFrameCombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(m_Frames)); gtk_widget_set_tooltip_text(m_RefFrameCombo, "A frame that shall be used as a reference frame"); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(m_RefFrameCombo), renderer, TRUE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(m_RefFrameCombo), renderer, "text", 1); gtk_table_attach(GTK_TABLE(table), m_RefFrameCombo, 1, 2, row+2, row+3, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0); m_RefFrameBtn = gtk_button_new_with_label("Browse"); gtk_widget_set_tooltip_text(m_RefFrameBtn, "Choose a reference frame in a separate dialog"); g_signal_connect(G_OBJECT(m_RefFrameBtn), "clicked", G_CALLBACK(button_clicked), this); gtk_table_attach(GTK_TABLE(table), m_RefFrameBtn, 2, 3, row+2, row+3, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(m_RefBtn)); m_CatBtn = gtk_radio_button_new_with_label(group, "using catalog file"); gtk_widget_set_tooltip_text(m_CatBtn, "Use a catalog file as a reference frame"); g_signal_connect(G_OBJECT(m_CatBtn), "toggled", G_CALLBACK(button_toggled), this); gtk_table_attach_defaults(GTK_TABLE(table), m_CatBtn, 1, 3, row+3, row+4); m_CatFrameEdit = gtk_entry_new(); gtk_widget_set_tooltip_text(m_CatFrameEdit, "Path to the catalog file that shall be used as a reference frame"); gtk_table_attach(GTK_TABLE(table), m_CatFrameEdit, 1, 2, row+4, row+5, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0); m_CatFrameBtn = gtk_button_new_with_label("Browse"); gtk_widget_set_tooltip_text(m_CatFrameBtn, "Choose a catalog file in a separate dialog"); g_signal_connect(G_OBJECT(m_CatFrameBtn), "clicked", G_CALLBACK(button_clicked), this); gtk_table_attach(GTK_TABLE(table), m_CatFrameBtn, 2, 3, row+4, row+5, (GtkAttachOptions)(GTK_FILL | GTK_SHRINK), GTK_FILL, 0, 0); row+=5; } gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox); }
static GtkWidget *create_window(void) { GtkWidget *startwin; GtkWidget *hlayout; GtkWidget *banner; GtkWidget *vlayout; GtkWidget *tabs; GtkWidget *configvlayout; GtkWidget *configlayout; GtkWidget *vmode3dlabel; GtkWidget *vmode3dcombo; GtkWidget *fullscreencheck; GtkWidget *alwaysshowcheck; GtkWidget *configtab; 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); // 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); // 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); // 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); // 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); // 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), 1), 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) vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), 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); // Associate labels with their controls gtk_label_set_mnemonic_widget(GTK_LABEL(vmode3dlabel), vmode3dcombo); /* 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, vmode3dlabel, "vmode3dlabel"); GLADE_HOOKUP_OBJECT(startwin, vmode3dcombo, "vmode3dcombo"); GLADE_HOOKUP_OBJECT(startwin, fullscreencheck, "fullscreencheck"); GLADE_HOOKUP_OBJECT(startwin, alwaysshowcheck, "alwaysshowcheck"); GLADE_HOOKUP_OBJECT(startwin, configtab, "configtab"); 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; }
void on_final_account_prepare (hierarchy_data *data) { GSList *actlist; GtkTreeView *tree_view; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gnc_commodity *com; /* Anything to do? */ if (!data->category_set_changed) return; data->category_set_changed = FALSE; gnc_suspend_gui_refresh (); /* Delete any existing account tree */ if (data->final_account_tree) { gtk_widget_destroy(GTK_WIDGET(data->final_account_tree)); data->final_account_tree = NULL; } delete_our_account_tree (data); /* Build a new account list */ actlist = get_selected_account_list (data->categories_tree); com = gnc_currency_edit_get_currency (GNC_CURRENCY_EDIT(data->currency_selector)); data->our_account_tree = hierarchy_merge_accounts (actlist, com); /* Now build a new account tree */ data->final_account_tree = GNC_TREE_VIEW_ACCOUNT(gnc_tree_view_account_new_with_root (data->our_account_tree, FALSE)); tree_view = GTK_TREE_VIEW(data->final_account_tree); gnc_tree_view_account_set_name_edited(data->final_account_tree, gnc_tree_view_account_name_edited_cb); gnc_tree_view_account_set_code_edited(data->final_account_tree, gnc_tree_view_account_code_edited_cb); gnc_tree_view_account_set_description_edited(data->final_account_tree, gnc_tree_view_account_description_edited_cb); gnc_tree_view_account_set_notes_edited(data->final_account_tree, gnc_tree_view_account_notes_edited_cb); gtk_tree_view_set_headers_visible (tree_view, TRUE); column = gnc_tree_view_find_column_by_name ( GNC_TREE_VIEW(data->final_account_tree), "type"); g_object_set_data(G_OBJECT(column), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); gnc_tree_view_configure_columns (GNC_TREE_VIEW(data->final_account_tree)); gnc_tree_view_set_show_column_menu (GNC_TREE_VIEW(data->final_account_tree), FALSE); selection = gtk_tree_view_get_selection (tree_view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); // This is a re-definition of the placeholder that the account-tree model // provides, reflecting the to-be-created state of the account tree // post-merge. { renderer = gtk_cell_renderer_toggle_new(); g_object_set(G_OBJECT (renderer), "activatable", FALSE, "sensitive", FALSE, NULL); column = gtk_tree_view_column_new_with_attributes(_("Placeholder"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, placeholder_cell_data_func, (gpointer)data, NULL); gnc_tree_view_append_column (GNC_TREE_VIEW(tree_view), column); } { renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "xalign", 1.0, (char *)NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (balance_cell_edited), data); column = gtk_tree_view_column_new_with_attributes (_("Opening Balance"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, balance_cell_data_func, (gpointer)data, NULL); gnc_tree_view_append_column (GNC_TREE_VIEW(tree_view), column); } // only in the case where there *are* existing accounts... if (gnc_account_n_descendants(gnc_book_get_root_account(gnc_get_current_book())) > 0) { GList *renderers; column = gnc_tree_view_add_text_column(GNC_TREE_VIEW(tree_view), _("Use Existing"), NULL, NULL, "yes", GNC_TREE_VIEW_COLUMN_DATA_NONE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, NULL); renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column)); g_object_set(G_OBJECT(renderer), "xalign", 1.0, (char*)NULL); gtk_tree_view_column_set_cell_data_func(column, GTK_CELL_RENDERER(renderers->data), use_existing_account_data_func, (gpointer)data, NULL); g_list_free(renderers); } gtk_container_add(GTK_CONTAINER(data->final_account_tree_container), GTK_WIDGET(data->final_account_tree)); /* Expand the entire tree */ gtk_tree_view_expand_all (tree_view); gtk_widget_show(GTK_WIDGET(data->final_account_tree)); gnc_resume_gui_refresh (); }
static void mud_connections_show_properties(MudConnections *conn, gchar *mud) { GladeXML *glade; GConfClient *client; GtkTextBuffer *buffer; gchar *key, *buf, *name_strip, *char_strip; gint port; gchar **mud_tuple; glade = glade_xml_new(GLADEDIR "/muds.glade", "mudviewproperties", NULL); conn->priv->properties_window = glade_xml_get_widget(glade, "mudviewproperties"); conn->priv->name_entry = glade_xml_get_widget(glade, "name_entry"); conn->priv->host_entry = glade_xml_get_widget(glade, "host_entry"); conn->priv->port_entry = glade_xml_get_widget(glade, "port_entry"); conn->priv->icon_button = glade_xml_get_widget(glade, "icon_button"); conn->priv->icon_image = glade_xml_get_widget(glade, "icon_image"); conn->priv->profile_combo = glade_xml_get_widget(glade, "profile_combo"); conn->priv->character_name_entry = glade_xml_get_widget(glade, "character_name_entry"); conn->priv->logon_textview = glade_xml_get_widget(glade, "character_logon_textview"); if(conn->priv->icon_current) g_free(conn->priv->icon_current); conn->priv->icon_current = NULL; mud_connections_property_populate_profiles(conn); gtk_combo_box_set_model( GTK_COMBO_BOX(conn->priv->profile_combo), conn->priv->profile_model); g_object_unref(conn->priv->profile_model); conn->priv->profile_combo_renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(conn->priv->profile_combo), conn->priv->profile_combo_renderer, TRUE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(conn->priv->profile_combo), conn->priv->profile_combo_renderer, "text", 0, NULL); g_signal_connect(conn->priv->properties_window, "delete-event", G_CALLBACK(mud_connections_property_delete_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "cancel_button"), "clicked", G_CALLBACK(mud_connections_property_cancel_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "save_button"), "clicked", G_CALLBACK(mud_connections_property_save_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "icon_button"), "clicked", G_CALLBACK(mud_connections_property_icon_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "name_entry"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "host_entry"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "port_entry"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "character_name_entry"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect( glade_xml_get_widget(glade, "character_logon_textview"), "key-press-event", G_CALLBACK(mud_connections_property_changed_cb), conn); g_signal_connect(glade_xml_get_widget(glade, "profile_combo"), "changed", G_CALLBACK(mud_connections_property_combo_changed_cb), conn); g_object_unref(glade); if(conn->priv->original_name != NULL) g_free(conn->priv->original_name); conn->priv->original_name = NULL; if(conn->priv->original_char_name != NULL) g_free(conn->priv->original_char_name); conn->priv->original_char_name = NULL; if(mud != NULL) { gint len; mud_tuple = g_strsplit(mud, "\n", -1); g_free(mud); len = g_strv_length(mud_tuple); switch(len) { case 1: conn->priv->original_name = g_strdup(mud_tuple[0]); break; case 2: conn->priv->original_char_name = g_strdup(mud_tuple[0]); conn->priv->original_name = g_strdup(mud_tuple[1]); break; } g_strfreev(mud_tuple); } else return; name_strip = gconf_escape_key(conn->priv->original_name, -1); gtk_entry_set_text( GTK_ENTRY(conn->priv->name_entry), conn->priv->original_name); if(conn->priv->original_char_name) gtk_entry_set_text(GTK_ENTRY(conn->priv->character_name_entry), conn->priv->original_char_name); client = gconf_client_get_default(); key = g_strdup_printf("/apps/gnome-mud/muds/%s/host", name_strip); buf = gconf_client_get_string(client, key, NULL); g_free(key); if(buf) { gtk_entry_set_text(GTK_ENTRY(conn->priv->host_entry), buf); g_free(buf); } key = g_strdup_printf("/apps/gnome-mud/muds/%s/port", name_strip); port = gconf_client_get_int(client, key, NULL); g_free(key); if(port != 0) gtk_spin_button_set_value( GTK_SPIN_BUTTON(conn->priv->port_entry), port); key = g_strdup_printf("/apps/gnome-mud/muds/%s/profile", name_strip); buf = gconf_client_get_string(client, key, NULL); g_free(key); if(buf) { mud_connections_property_combo_get_index(conn, buf); g_free(buf); } key = g_strdup_printf("/apps/gnome-mud/muds/%s/icon", name_strip); buf = gconf_client_get_string(client, key, NULL); g_free(key); if(buf && strcmp(buf, "gnome-mud") != 0) { GdkPixbuf *icon; conn->priv->icon_current = g_strdup(buf); g_free(buf); icon = gdk_pixbuf_new_from_file_at_size( conn->priv->icon_current, 48, 48, NULL); gtk_image_set_from_pixbuf(GTK_IMAGE(conn->priv->icon_image), icon); g_object_unref(icon); } else conn->priv->icon_current = g_strdup("gnome-mud"); if(conn->priv->original_char_name != NULL) { char_strip = gconf_escape_key(conn->priv->original_char_name, -1); key = g_strdup_printf("/apps/gnome-mud/muds/%s/characters/%s/logon", name_strip, char_strip); buf = gconf_client_get_string(client, key, NULL); g_free(key); if(buf) { buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(conn->priv->logon_textview)); gtk_text_buffer_set_text(buffer, buf, strlen(buf)); g_free(buf); } g_free(char_strip); } g_free(name_strip); g_object_unref(client); conn->priv->changed = FALSE; }
void seahorse_gpgme_add_subkey_new (SeahorseGpgmeKey *pkey, GtkWindow *parent) { SeahorseWidget *swidget; GtkComboBox* combo; GtkTreeModel *model; GtkTreeIter iter; GtkCellRenderer *renderer; GtkWidget *widget, *datetime; swidget = seahorse_object_widget_new ("add-subkey", parent, G_OBJECT (pkey)); g_return_if_fail (swidget != NULL); gtk_window_set_title (GTK_WINDOW (seahorse_widget_get_widget (swidget, swidget->name)), g_strdup_printf (_("Add subkey to %s"), seahorse_object_get_label (SEAHORSE_OBJECT (pkey)))); combo = GTK_COMBO_BOX (seahorse_widget_get_widget (swidget, "type")); model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT)); gtk_combo_box_set_model (combo, model); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", COMBO_STRING); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_STRING, _("DSA (sign only)"), COMBO_INT, 0, -1); gtk_combo_box_set_active_iter (combo, &iter); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_STRING, _("ElGamal (encrypt only)"), COMBO_INT, 1, -1); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_STRING, _("RSA (sign only)"), COMBO_INT, 2, -1); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_STRING, _("RSA (encrypt only)"), COMBO_INT, 3, -1); widget = seahorse_widget_get_widget (swidget, "datetime-placeholder"); g_return_if_fail (widget != NULL); datetime = egg_datetime_new (); gtk_container_add (GTK_CONTAINER (widget), datetime); gtk_widget_show (datetime); gtk_widget_set_sensitive (datetime, FALSE); g_object_set_data (G_OBJECT (swidget), "expires-datetime", datetime); }
static void setup_protocol (VinagreConnectDialog *dialog) { GHashTable *extensions; GHashTableIter hash_iter; gpointer key, value; GtkTreeIter tree_iter; GtkCellRenderer *rend; gchar *last_protocol; gint selected, i; dialog->protocol_store = gtk_list_store_new (N_PROTOCOLS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_OBJECT); extensions = vinagre_plugins_engine_get_plugins_by_protocol (vinagre_plugins_engine_get_default ()); last_protocol = vinagre_cache_prefs_get_string ("connection", "last-protocol", NULL); g_hash_table_iter_init (&hash_iter, extensions); selected = 0; i = 0; while (g_hash_table_iter_next (&hash_iter, &key, &value)) { gchar **description; GtkWidget *widget; VinagreProtocol *ext = (VinagreProtocol *)value; description = vinagre_protocol_get_public_description (ext); if (!description || !description[0]) continue; widget = vinagre_protocol_get_connect_widget (ext, NULL); gtk_list_store_append (dialog->protocol_store, &tree_iter); gtk_list_store_set (dialog->protocol_store, &tree_iter, PROTOCOL_NAME, description[0], PROTOCOL_DESCRIPTION, description[1], PROTOCOL_MDNS, vinagre_protocol_get_mdns_service (ext), PROTOCOL_OPTIONS, widget, PROTOCOL_PLUGIN, ext, -1); if (last_protocol && g_str_equal (last_protocol, description[0])) selected = i; g_strfreev (description); if (widget) g_object_unref (widget); i++; } gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->protocol_combo), GTK_TREE_MODEL (dialog->protocol_store)); rend = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (dialog->protocol_combo), rend, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (dialog->protocol_combo), rend, "text", 0); g_signal_connect (dialog->protocol_combo, "changed", G_CALLBACK (protocol_combo_changed), dialog); gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->protocol_combo), selected); g_free (last_protocol); }
static void setup_main_window (UmUserPanelPrivate *d) { GtkWidget *userlist; GtkTreeModel *model; GtkListStore *store; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; GtkWidget *button; GtkTreeIter iter; gint expander_size; gchar *title; GIcon *icon; gchar *names[3]; userlist = get_widget (d, "list-treeview"); store = gtk_list_store_new (NUM_USER_LIST_COLS, UM_TYPE_USER, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INT, G_TYPE_BOOLEAN); model = (GtkTreeModel *)store; gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model), sort_users, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (userlist), model); gtk_tree_view_set_search_column (GTK_TREE_VIEW (userlist), USER_COL); gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (userlist), match_user, NULL, NULL); g_object_unref (model); g_signal_connect (d->um, "users-loaded", G_CALLBACK (users_loaded), d); gtk_widget_style_get (userlist, "expander-size", &expander_size, NULL); gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (userlist), - (expander_size + 6)); title = g_strdup_printf ("<small><span foreground=\"#555555\">%s</span></small>", _("My Account")); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, TITLE_COL, title, HEADING_ROW_COL, TRUE, SORT_KEY_COL, 0, AUTOLOGIN_COL, FALSE, -1); g_free (title); title = g_strdup_printf ("<small><span foreground=\"#555555\">%s</span></small>", _("Other Accounts")); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, TITLE_COL, title, HEADING_ROW_COL, TRUE, SORT_KEY_COL, 2, AUTOLOGIN_COL, FALSE, -1); g_free (title); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "pixbuf", FACE_COL); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL); cell = gtk_cell_renderer_text_new (); g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "markup", NAME_COL); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "markup", TITLE_COL); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", HEADING_ROW_COL); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), cell, "visible", USER_ROW_COL); gtk_tree_view_column_set_cell_data_func (column, cell, (GtkTreeCellDataFunc) autologin_cell_data_func, d, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (userlist), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (userlist)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (selection, "changed", G_CALLBACK (selected_user_changed), d); gtk_tree_selection_set_select_function (selection, dont_select_headings, NULL, NULL); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (get_widget (d, "list-scrolledwindow")), 300); gtk_widget_set_size_request (get_widget (d, "list-scrolledwindow"), 200, -1); button = get_widget (d, "add-user-toolbutton"); g_signal_connect (button, "clicked", G_CALLBACK (add_user), d); button = get_widget (d, "remove-user-toolbutton"); g_signal_connect (button, "clicked", G_CALLBACK (delete_user), d); button = get_widget (d, "user-icon-nonbutton"); add_unlock_tooltip (button); button = get_widget (d, "full-name-entry"); g_signal_connect (button, "editing-done", G_CALLBACK (change_name_done), d); button = get_widget (d, "account-type-combo"); g_signal_connect (button, "editing-done", G_CALLBACK (account_type_changed), d); button = get_widget (d, "account-password-button"); g_signal_connect (button, "start-editing", G_CALLBACK (change_password), d); button = get_widget (d, "account-language-combo"); g_signal_connect (button, "editing-done", G_CALLBACK (language_changed), d); button = get_widget (d, "autologin-switch"); g_signal_connect (button, "notify::active", G_CALLBACK (autologin_changed), d); button = get_widget (d, "account-fingerprint-button"); g_signal_connect (button, "clicked", G_CALLBACK (change_fingerprint), d); d->permission = (GPermission *)polkit_permission_new_sync ("org.freedesktop.accounts.user-administration", NULL, NULL, NULL); g_signal_connect (d->permission, "notify", G_CALLBACK (on_permission_changed), d); on_permission_changed (d->permission, NULL, d); button = get_widget (d, "add-user-toolbutton"); names[0] = "changes-allow-symbolic"; names[1] = "changes-allow"; names[2] = NULL; icon = (GIcon *)g_themed_icon_new_from_names (names, -1); setup_tooltip_with_embedded_icon (button, _("To create a user account,\nclick the * icon first"), "*", icon); button = get_widget (d, "remove-user-toolbutton"); setup_tooltip_with_embedded_icon (button, _("To delete the selected user account,\nclick the * icon first"), "*", icon); g_object_unref (icon); }
gboolean gnc_tree_util_split_reg_rotate (GncTreeViewSplitReg *view, GtkTreeViewColumn *col, Transaction *trans, Split *split) { GtkCellRenderer *cr0 = NULL; GList *renderers; ViewCol viewcol; // Get the first renderer, it has the view-column value. renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); cr0 = g_list_nth_data (renderers, 0); g_list_free (renderers); viewcol = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cr0), "view_column")); if (viewcol == COL_RECN) { const char recn_flags[] = {NREC, CREC, 0}; // List of reconciled flags const gchar *flags; const gchar *text; gchar *this_flag; gint index = 0; char rec; flags = recn_flags; text = g_strdup_printf("%c", xaccSplitGetReconcile (split)); /* Find the existing text in the list of flags */ this_flag = strstr (flags, text); if (this_flag != NULL && *this_flag != '\0') { /* In the list, choose the next item in the list (wrapping around as necessary). */ index = this_flag - flags; if (flags[index + 1] != '\0') index = index + 1; else index = 0; rec = recn_flags[index]; } else rec = NREC; gnc_tree_view_split_reg_set_dirty_trans (view, trans); if (!xaccTransIsOpen (trans)) xaccTransBeginEdit (trans); xaccSplitSetReconcile (split, rec); return TRUE; } if (viewcol == COL_TYPE) { const char type_flags[] = {TXN_TYPE_INVOICE, TXN_TYPE_PAYMENT, 0}; // list of type flags const gchar *flags; const gchar *text; gchar *this_flag; gint index = 0; char type; flags = type_flags; text = g_strdup_printf("%c", xaccTransGetTxnType (trans)); /* Find the existing text in the list of flags */ this_flag = strstr (flags, text); if (this_flag != NULL && *this_flag != '\0') { /* In the list, choose the next item in the list (wrapping around as necessary). */ index = this_flag - flags; if (flags[index + 1] != '\0') index = index + 1; else index = 0; type = type_flags[index]; } else type = TXN_TYPE_NONE; gnc_tree_view_split_reg_set_dirty_trans (view, trans); if (!xaccTransIsOpen (trans)) xaccTransBeginEdit (trans); xaccTransSetTxnType (trans, type); return TRUE; } return FALSE; }
void gevo_add_buddy_dialog_show(PurpleAccount *account, const char *username, const char *group, const char *alias) { GevoAddBuddyDialog *dialog; GtkWidget *button; GtkWidget *sw; GtkWidget *label; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *bbox; GtkWidget *sep; GtkTreeSelection *selection; GtkCellRenderer *cell; dialog = g_new0(GevoAddBuddyDialog, 1); dialog->account = (account != NULL ? account : purple_connection_get_account(purple_connections_get_all()->data)); if (username != NULL) dialog->username = g_strdup(username); dialog->win = pidgin_create_window(_("Add Buddy"), PIDGIN_HIG_BORDER, "add_buddy", TRUE); gtk_widget_set_size_request(dialog->win, -1, 400); g_signal_connect(G_OBJECT(dialog->win), "delete_event", G_CALLBACK(delete_win_cb), dialog); /* Setup the vbox */ vbox = gtk_vbox_new(FALSE, 12); gtk_container_add(GTK_CONTAINER(dialog->win), vbox); gtk_widget_show(vbox); /* Add the label. */ label = gtk_label_new(_("Select a person from your address book below, " "or add a new person.")); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0); gtk_widget_show(label); /* Add the search hbox */ hbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0); gtk_widget_show(hbox); /* "Search" */ label = gtk_label_new(_("Search")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_widget_show(label); /* Addressbooks */ dialog->addrbooks = gevo_addrbooks_model_new(); dialog->addrbooks_combo = gtk_combo_box_new_with_model( dialog->addrbooks); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dialog->addrbooks_combo), cell, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dialog->addrbooks_combo), cell, "text", ADDRBOOK_COLUMN_NAME, NULL); gtk_box_pack_start(GTK_BOX(hbox), dialog->addrbooks_combo, FALSE, FALSE, 0); gtk_widget_show(dialog->addrbooks_combo); /* Search field */ dialog->search_field = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), dialog->search_field, TRUE, TRUE, 0); gtk_widget_show(dialog->search_field); g_signal_connect(G_OBJECT(dialog->search_field), "changed", G_CALLBACK(search_changed_cb), dialog); /* Clear button */ button = gtk_button_new_from_stock(GTK_STOCK_CLEAR); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); gtk_widget_show(button); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(clear_cb), dialog); /* Scrolled Window */ sw = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); gtk_widget_show(sw); /* Create the list model for the treeview. */ dialog->model = gtk_list_store_new(NUM_COLUMNS, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER); /* Now for the treeview */ dialog->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(dialog->treeview), TRUE); gtk_container_add(GTK_CONTAINER(sw), dialog->treeview); gtk_widget_show(dialog->treeview); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selected_cb), dialog); add_columns(dialog); /* * Catch addressbook selection and populate treeview with the first * addressbook */ gevo_addrbooks_model_populate(dialog->addrbooks); g_signal_connect(G_OBJECT(dialog->addrbooks_combo), "changed", G_CALLBACK(addrbook_change_cb), dialog); gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->addrbooks_combo), 0); /* Group box */ hbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); label = gtk_label_new(_("Group:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_widget_show(label); dialog->group_combo = pidgin_text_combo_box_entry_new(NULL, gevo_get_groups()); gtk_box_pack_start(GTK_BOX(hbox), dialog->group_combo, TRUE, TRUE, 0); gtk_widget_show(dialog->group_combo); /* Cool. Now we only have a little left... */ /* Separator. */ sep = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0); gtk_widget_show(sep); /* Button box */ bbox = gtk_hbutton_box_new(); gtk_box_set_spacing(GTK_BOX(bbox), 6); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, TRUE, 0); gtk_widget_show(bbox); /* "New Person" button */ button = pidgin_pixbuf_button_from_stock(_("New Person"), GTK_STOCK_NEW, PIDGIN_BUTTON_HORIZONTAL); gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_show(button); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(new_person_cb), dialog); /* "Cancel" button */ button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_show(button); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(cancel_cb), dialog); /* "Select Buddy" button */ button = pidgin_pixbuf_button_from_stock(_("Select Buddy"), GTK_STOCK_APPLY, PIDGIN_BUTTON_HORIZONTAL); dialog->select_button = button; gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); gtk_widget_set_sensitive(button, FALSE); gtk_widget_show(button); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(select_buddy_cb), dialog); /* Show it. */ gtk_widget_show(dialog->win); }
static void eom_thumb_view_constructed (GObject *object) { EomThumbView *thumbview; if (G_OBJECT_CLASS (eom_thumb_view_parent_class)->constructed) G_OBJECT_CLASS (eom_thumb_view_parent_class)->constructed (object); thumbview = EOM_THUMB_VIEW (object); thumbview->priv->pixbuf_cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (thumbview), thumbview->priv->pixbuf_cell, FALSE); g_object_set (thumbview->priv->pixbuf_cell, #if !GTK_CHECK_VERSION (3, 16, 0) "follow-state", FALSE, #endif "height", 100, "width", 115, "yalign", 0.5, "xalign", 0.5, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (thumbview), thumbview->priv->pixbuf_cell, "pixbuf", EOM_LIST_STORE_THUMBNAIL, NULL); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (thumbview), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (thumbview), EOM_THUMB_VIEW_SPACING); gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (thumbview), EOM_THUMB_VIEW_SPACING); g_object_set (thumbview, "has-tooltip", TRUE, NULL); g_signal_connect (thumbview, "query-tooltip", G_CALLBACK (thumbview_on_query_tooltip_cb), NULL); thumbview->priv->start_thumb = 0; thumbview->priv->end_thumb = 0; thumbview->priv->menu = NULL; g_signal_connect (G_OBJECT (thumbview), "parent-set", G_CALLBACK (thumbview_on_parent_set_cb), NULL); gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (thumbview), 0, NULL, 0, GDK_ACTION_COPY); gtk_drag_source_add_uri_targets (GTK_WIDGET (thumbview)); g_signal_connect (G_OBJECT (thumbview), "drag-data-get", G_CALLBACK (thumbview_on_drag_data_get_cb), NULL); }
void dlg_import_from_flickr (FlickrServer *server, GthBrowser *browser) { DialogData *data; GthThumbLoader *thumb_loader; char *title; data = g_new0 (DialogData, 1); data->server = server; data->browser = browser; data->location = gth_file_data_dup (gth_browser_get_location_data (browser)); data->builder = _gtk_builder_new_from_file ("import-from-flickr.ui", "flicker_utils"); data->dialog = _gtk_builder_get_widget (data->builder, "import_dialog"); data->cancellable = g_cancellable_new (); { GtkCellLayout *cell_layout; GtkCellRenderer *renderer; cell_layout = GTK_CELL_LAYOUT (GET_WIDGET ("photoset_combobox")); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (cell_layout, renderer, FALSE); gtk_cell_layout_set_attributes (cell_layout, renderer, "icon-name", PHOTOSET_ICON_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (cell_layout, renderer, TRUE); gtk_cell_layout_set_attributes (cell_layout, renderer, "text", PHOTOSET_TITLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (cell_layout, renderer, FALSE); gtk_cell_layout_set_attributes (cell_layout, renderer, "text", PHOTOSET_N_PHOTOS_COLUMN, NULL); } /* Set the widget data */ data->file_list = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NORMAL, FALSE); thumb_loader = gth_file_list_get_thumb_loader (GTH_FILE_LIST (data->file_list)); gth_thumb_loader_set_use_cache (thumb_loader, FALSE); gth_thumb_loader_set_loader_func (thumb_loader, flickr_thumbnail_loader); gth_file_list_set_thumb_size (GTH_FILE_LIST (data->file_list), FLICKR_SIZE_THUMBNAIL); gth_file_list_enable_thumbs (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->file_list), TRUE); gth_file_list_set_caption (GTH_FILE_LIST (data->file_list), "none"); gth_file_list_set_sort_func (GTH_FILE_LIST (data->file_list), flickr_photo_position_func, FALSE); gth_file_list_clear (GTH_FILE_LIST (data->file_list), _("No album selected")); gtk_widget_show (data->file_list); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("images_box")), data->file_list, TRUE, TRUE, 0); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("photoset_liststore")), PHOTOSET_TITLE_COLUMN, GTK_SORT_ASCENDING); gtk_widget_set_sensitive (GET_WIDGET ("download_button"), FALSE); data->preferences_dialog = gth_import_preferences_dialog_new (); gtk_window_set_transient_for (GTK_WINDOW (data->preferences_dialog), GTK_WINDOW (data->dialog)); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("destination_button_box")), gth_import_destination_button_new (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog)), TRUE, TRUE, 0); gtk_widget_show_all (GET_WIDGET ("destination_button_box")); title = g_strdup_printf (_("Import from %s"), data->server->display_name); gtk_window_set_title (GTK_WINDOW (data->dialog), title); g_free (title); _gtk_window_resize_to_fit_screen_height (data->dialog, 500); /* Set the signals handlers. */ g_signal_connect (data->dialog, "destroy", G_CALLBACK (import_dialog_destroy_cb), data); g_signal_connect (data->dialog, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect (data->dialog, "response", G_CALLBACK (import_dialog_response_cb), data); g_signal_connect (GET_WIDGET ("edit_accounts_button"), "clicked", G_CALLBACK (edit_accounts_button_clicked_cb), data); g_signal_connect (GET_WIDGET ("account_combobox"), "changed", G_CALLBACK (account_combobox_changed_cb), data); g_signal_connect (GET_WIDGET ("photoset_combobox"), "changed", G_CALLBACK (photoset_combobox_changed_cb), data); g_signal_connect (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)), "file-selection-changed", G_CALLBACK (file_list_selection_changed_cb), data); update_selection_status (data); gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog), ""); data->service = flickr_service_new (server, data->cancellable, GTK_WIDGET (data->browser), data->dialog); g_signal_connect (data->service, "account-ready", G_CALLBACK (authentication_ready_cb), data); g_signal_connect (data->service, "accounts-changed", G_CALLBACK (authentication_accounts_changed_cb), data); data->progress_dialog = gth_progress_dialog_new (GTK_WINDOW (data->browser)); gth_progress_dialog_add_task (GTH_PROGRESS_DIALOG (data->progress_dialog), GTH_TASK (data->service)); web_service_autoconnect (WEB_SERVICE (data->service)); }
static GtkWidget * create_combo_box_grid_demo (void) { GtkWidget *combo; GtkTreeIter iter; GdkPixbuf *pixbuf; GtkCellRenderer *cell = gtk_cell_renderer_pixbuf_new (); GtkListStore *store; store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_INT, G_TYPE_INT); /* first row */ pixbuf = create_color_pixbuf ("red"); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, pixbuf, 1, 1, /* row span */ 2, 1, /* column span */ -1); g_object_unref (pixbuf); pixbuf = create_color_pixbuf ("green"); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, pixbuf, 1, 1, 2, 1, -1); g_object_unref (pixbuf); pixbuf = create_color_pixbuf ("blue"); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, pixbuf, 1, 1, 2, 1, -1); g_object_unref (pixbuf); /* second row */ pixbuf = create_color_pixbuf ("yellow"); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, pixbuf, 1, 1, 2, 2, /* Span 2 columns */ -1); g_object_unref (pixbuf); pixbuf = create_color_pixbuf ("black"); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, pixbuf, 1, 2, /* Span 2 rows */ 2, 1, -1); g_object_unref (pixbuf); /* third row */ pixbuf = create_color_pixbuf ("gray"); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, pixbuf, 1, 1, 2, 1, -1); g_object_unref (pixbuf); pixbuf = create_color_pixbuf ("magenta"); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, pixbuf, 1, 1, 2, 1, -1); g_object_unref (pixbuf); /* Create ComboBox after model to avoid gtk_menu_attach() warnings(?) */ combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell, "pixbuf", 0, NULL); /* Set wrap-width != 0 to enforce grid mode */ gtk_combo_box_set_wrap_width (GTK_COMBO_BOX (combo), 3); gtk_combo_box_set_row_span_column (GTK_COMBO_BOX (combo), 1); gtk_combo_box_set_column_span_column (GTK_COMBO_BOX (combo), 2); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0); return combo; }
static void build_drmr_ui(DrMrUi* ui) { GtkWidget *drmr_ui_widget; GtkWidget *opts_hbox1, *opts_hbox2, *kit_combo_box, *kit_label, *no_kit_label, *base_label, *base_spin, *position_label, *position_combo_box; GtkCellRenderer *cell_rend; GtkAdjustment *base_adj; drmr_ui_widget = gtk_vbox_new(false,0); g_object_set(drmr_ui_widget,"border-width",6,NULL); ui->kit_store = gtk_list_store_new(1,G_TYPE_STRING); opts_hbox1 = gtk_hbox_new(false,0); opts_hbox2 = gtk_hbox_new(false,0); kit_combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(ui->kit_store)); kit_label = gtk_label_new("Kit:"); no_kit_label = gtk_label_new("<b>No/Invalid Kit Selected</b>"); gtk_label_set_use_markup(GTK_LABEL(no_kit_label),true); cell_rend = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(kit_combo_box), cell_rend, true); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(kit_combo_box), cell_rend,"text",0,NULL); base_label = gtk_label_new("Midi Base Note <b>(C 2)</b>:"); gtk_label_set_use_markup(GTK_LABEL(base_label),true); base_adj = GTK_ADJUSTMENT (gtk_adjustment_new(36.0, // val 21.0,107.0, // min/max 1.0, // step 5.0,0.0)); // page adj/size base_spin = gtk_spin_button_new(base_adj, 1.0, 0); position_label = gtk_label_new("Sample Zero Position: "); position_combo_box = create_position_combo(); ui->velocity_checkbox = gtk_check_button_new_with_label("Ignore Velocity"); ui->note_off_checkbox = gtk_check_button_new_with_label("Ignore Note Off"); gtk_box_pack_start(GTK_BOX(opts_hbox1),kit_label, false,false,15); gtk_box_pack_start(GTK_BOX(opts_hbox1),no_kit_label, true,true,0); gtk_box_pack_start(GTK_BOX(opts_hbox1),kit_combo_box, true,true,0); gtk_box_pack_start(GTK_BOX(opts_hbox1),base_label, false,false,15); gtk_box_pack_start(GTK_BOX(opts_hbox1),base_spin, true,true,0); gtk_box_pack_start(GTK_BOX(opts_hbox2),position_label, false,false,15); gtk_box_pack_start(GTK_BOX(opts_hbox2),position_combo_box, false,false,0); gtk_box_pack_start(GTK_BOX(opts_hbox2),ui->velocity_checkbox, true,true,15); gtk_box_pack_start(GTK_BOX(opts_hbox2),ui->note_off_checkbox, true,true,15); gtk_box_pack_start(GTK_BOX(drmr_ui_widget),gtk_hseparator_new(), false,false,5); gtk_box_pack_start(GTK_BOX(drmr_ui_widget),opts_hbox1, false,false,5); gtk_box_pack_start(GTK_BOX(drmr_ui_widget),opts_hbox2, false,false,5); ui->drmr_widget = drmr_ui_widget; ui->sample_table = NULL; ui->kit_combo = GTK_COMBO_BOX(kit_combo_box); ui->base_label = GTK_LABEL(base_label); ui->base_spin = GTK_SPIN_BUTTON(base_spin); ui->no_kit_label = no_kit_label; g_signal_connect(G_OBJECT(kit_combo_box),"changed",G_CALLBACK(kit_combobox_changed),ui); g_signal_connect(G_OBJECT(base_spin),"value-changed",G_CALLBACK(base_changed),ui); g_signal_connect(G_OBJECT(position_combo_box),"changed",G_CALLBACK(position_combobox_changed),ui); g_signal_connect(G_OBJECT(ui->velocity_checkbox),"toggled",G_CALLBACK(ignore_velocity_toggled),ui); g_signal_connect(G_OBJECT(ui->note_off_checkbox),"toggled",G_CALLBACK(ignore_note_off_toggled),ui); gtk_widget_show_all(drmr_ui_widget); gtk_widget_hide(no_kit_label); }
/** * empathy_account_widget_irc_new: * @account: the #McAccount to configure * * Creates a new IRC account widget to configure a given #McAccount * * Returns: The toplevel container of the configuration widget */ GtkWidget * empathy_account_widget_irc_new (McAccount *account) { EmpathyAccountWidgetIrc *settings; gchar *dir, *user_file_with_path, *global_file_with_path; GladeXML *glade; GtkListStore *store; GtkCellRenderer *renderer; gchar *filename; settings = g_slice_new0 (EmpathyAccountWidgetIrc); settings->account = g_object_ref (account); dir = g_build_filename (g_get_home_dir (), ".gnome2", PACKAGE_NAME, NULL); g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR); user_file_with_path = g_build_filename (dir, IRC_NETWORKS_FILENAME, NULL); g_free (dir); global_file_with_path = g_build_filename (g_getenv ("EMPATHY_SRCDIR"), "libempathy-gtk", IRC_NETWORKS_FILENAME, NULL); if (!g_file_test (global_file_with_path, G_FILE_TEST_EXISTS)) { g_free (global_file_with_path); global_file_with_path = g_build_filename (DATADIR, "empathy", IRC_NETWORKS_FILENAME, NULL); } settings->network_manager = empathy_irc_network_manager_new ( global_file_with_path, user_file_with_path); g_free (global_file_with_path); g_free (user_file_with_path); filename = empathy_file_lookup ("empathy-account-widget-irc.glade", "libempathy-gtk"); glade = empathy_glade_get_file (filename, "vbox_irc_settings", NULL, "vbox_irc_settings", &settings->vbox_settings, "combobox_network", &settings->combobox_network, "button_network", &settings->button_network, "button_add_network", &settings->button_add_network, "button_remove", &settings->button_remove, NULL); g_free (filename); /* Fill the networks combobox */ store = gtk_list_store_new (2, G_TYPE_OBJECT, G_TYPE_STRING); gtk_cell_layout_clear (GTK_CELL_LAYOUT (settings->combobox_network)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (settings->combobox_network), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (settings->combobox_network), renderer, "text", COL_NETWORK_NAME, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), COL_NETWORK_NAME, GTK_SORT_ASCENDING); gtk_combo_box_set_model (GTK_COMBO_BOX (settings->combobox_network), GTK_TREE_MODEL (store)); g_object_unref (store); account_widget_irc_setup (settings); empathy_account_widget_handle_params (account, glade, "entry_nick", "account", "entry_fullname", "fullname", "entry_password", "password", "entry_quit_message", "quit-message", NULL); empathy_glade_connect (glade, settings, "vbox_irc_settings", "destroy", account_widget_irc_destroy_cb, "button_network", "clicked", account_widget_irc_button_edit_network_clicked_cb, "button_add_network", "clicked", account_widget_irc_button_add_network_clicked_cb, "button_remove", "clicked", account_widget_irc_button_remove_clicked_cb, "combobox_network", "changed", account_widget_irc_combobox_network_changed_cb, NULL); g_object_unref (glade); return settings->vbox_settings; }
static void gth_slideshow_preferences_construct (GthSlideshowPreferences *self, const char *current_transition, gboolean automatic, int delay, gboolean wrap_around, gboolean random_order) { GtkListStore *model; GtkCellRenderer *renderer; GList *transitions; int i, i_active; GList *scan; GtkTreeIter iter; self->priv->builder = _gtk_builder_new_from_file ("slideshow-preferences.ui", "slideshow"); gtk_container_add (GTK_CONTAINER (self), _gtk_builder_get_widget (self->priv->builder, "preferences_page")); model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); self->priv->transition_combobox = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model)); g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->priv->transition_combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self->priv->transition_combobox), renderer, "text", TRANSITION_COLUMN_DISPLAY_NAME, NULL); transitions = gth_main_get_registered_objects (GTH_TYPE_TRANSITION); for (i = 0, i_active = 0, scan = transitions; scan; scan = scan->next, i++) { GthTransition *transition = scan->data; if (g_strcmp0 (gth_transition_get_id (transition), current_transition) == 0) i_active = i; gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, TRANSITION_COLUMN_ID, gth_transition_get_id (transition), TRANSITION_COLUMN_DISPLAY_NAME, gth_transition_get_display_name (transition), -1); } if (g_strcmp0 ("random", current_transition) == 0) i_active = i; gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, TRANSITION_COLUMN_ID, "random", TRANSITION_COLUMN_DISPLAY_NAME, _("Random"), -1); gtk_combo_box_set_active (GTK_COMBO_BOX (self->priv->transition_combobox), i_active); gtk_widget_show (self->priv->transition_combobox); gtk_box_pack_start (GTK_BOX (_gtk_builder_get_widget (self->priv->builder, "transition_box")), self->priv->transition_combobox, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "automatic_checkbutton")), automatic); gtk_spin_button_set_value (GTK_SPIN_BUTTON (_gtk_builder_get_widget (self->priv->builder, "change_delay_spinbutton")), ((float) delay) / 1000.0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "wrap_around_checkbutton")), wrap_around); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "random_order_checkbutton")), random_order); /* signals */ g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "personalize_checkbutton"), "toggled", G_CALLBACK (personalize_checkbutton_toggled_cb), self); g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "automatic_checkbutton"), "toggled", G_CALLBACK (automatic_checkbutton_toggled_cb), self); g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "remove_file_button"), "clicked", G_CALLBACK (remove_file_button_clicked_cb), self); g_signal_connect (_gtk_builder_get_widget (self->priv->builder, "add_file_button"), "clicked", G_CALLBACK (add_file_button_clicked_cb), self); }
static void _dtv_init (DiagramTreeView *dtv) { GtkTreeViewColumn *column; GtkCellRenderer *cell; gint font_size; GtkStyle *style; /* connect the model with the view */ gtk_tree_view_set_model (GTK_TREE_VIEW (dtv), diagram_tree_model_new ()); gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (dtv), TRUE); /* the tree requires reading across rows (semantic hint) */ #if 0 /* stripe style */ gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dtv), TRUE); #endif style = gtk_widget_get_style (GTK_WIDGET (dtv)); font_size = pango_font_description_get_size (style->font_desc); font_size = PANGO_PIXELS (font_size); /* first colum: name of diagram/layer/object - here is the tree */ cell = gtk_cell_renderer_text_new (); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (cell), 1); g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Name")); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width (column, font_size * 10); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "text", NAME_COLUMN); gtk_tree_view_insert_column (GTK_TREE_VIEW (dtv), column, -1); /* this is enough for simple name search (just typing) */ gtk_tree_view_set_search_column (GTK_TREE_VIEW (dtv), NAME_COLUMN); /* must have a sortable model ... */ gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN); /* type column - show the type icon */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Type")); /* must have fixed size, too */ gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); /* without it gets zero size - not very useful! */ gtk_tree_view_column_set_min_width (column, font_size * 6); gtk_tree_view_column_set_resizable (column, TRUE); cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (column), cell, _dtv_cell_pixbuf_func, dtv, NULL); gtk_tree_view_insert_column (GTK_TREE_VIEW (dtv), column, -1); gtk_tree_view_column_set_sort_column_id (column, OBJECT_COLUMN); /* TODO: other fancy stuff */ { GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dtv)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (dtv), TRUE); } gtk_widget_set_has_tooltip (GTK_WIDGET (dtv), TRUE); _dtv_create_popup_menu (dtv); }
/* Main UI */ GtkWidget * pgd_annots_create_widget (PopplerDocument *document) { PgdAnnotsDemo *demo; GtkWidget *label; GtkWidget *vbox, *vbox2; GtkWidget *button; GtkWidget *hbox, *page_selector; GtkWidget *hpaned; GtkWidget *swindow, *treeview; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkListStore *model; GtkTreeIter iter; gchar *str; gint n_pages; gint i; demo = g_new0 (PgdAnnotsDemo, 1); demo->doc = g_object_ref (document); demo->cursor = GDK_LAST_CURSOR; demo->mode = MODE_NORMAL; n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_annots_page_selector_value_changed), (gpointer) demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); demo->remove_button = gtk_button_new_with_mnemonic ("_Remove"); gtk_widget_set_sensitive (demo->remove_button, FALSE); g_signal_connect (G_OBJECT (demo->remove_button), "clicked", G_CALLBACK (pgd_annots_remove_annot), (gpointer) demo); gtk_box_pack_end (GTK_BOX (hbox), demo->remove_button, FALSE, FALSE, 6); gtk_widget_show (demo->remove_button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_mnemonic ("_Add"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_annots_start_add_annot), (gpointer) demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); model = gtk_list_store_new(SELECTED_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING); for (i = 0; i < G_N_ELEMENTS (supported_annots); i++) { gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, SELECTED_TYPE_COLUMN, supported_annots[i].type, SELECTED_LABEL_COLUMN, supported_annots[i].label, -1); } demo->type_selector = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model)); g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (demo->type_selector), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (demo->type_selector), renderer, "text", SELECTED_LABEL_COLUMN, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (demo->type_selector), 0); gtk_box_pack_end (GTK_BOX (hbox), demo->type_selector, FALSE, FALSE, 0); gtk_widget_show (demo->type_selector); button = gtk_color_button_new (); demo->annot_color.red = 65535; demo->annot_color.alpha = 1.0; gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), &demo->annot_color); g_signal_connect (button, "notify::color", G_CALLBACK (pgd_annot_color_changed), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_widget_show (button); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No annotations found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); demo->annot_view = pgd_annot_view_new (); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_OBJECT); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); demo->tree_view = treeview; column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "Type"); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", ANNOTS_COLOR_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", ANNOTS_TYPE_COLUMN); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_invisible_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_INVISIBLE_COLUMN, "Invisible", renderer, "active", ANNOTS_FLAG_INVISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_hidden_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_HIDDEN_COLUMN, "Hidden", renderer, "active", ANNOTS_FLAG_HIDDEN_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_print_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_PRINT_COLUMN, "Print", renderer, "active", ANNOTS_FLAG_PRINT_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (pgd_annots_selection_changed), (gpointer) demo); /* Annotation's list */ gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); /* Annotation Properties */ swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (swindow), demo->annot_view); gtk_widget_show (demo->annot_view); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 6); gtk_widget_show (swindow); gtk_paned_add1 (GTK_PANED (hpaned), vbox2); gtk_widget_show (vbox2); /* Demo Area (Render) */ demo->darea = gtk_drawing_area_new (); g_signal_connect (demo->darea, "draw", G_CALLBACK (pgd_annots_view_drawing_area_draw), demo); g_signal_connect (demo->darea, "realize", G_CALLBACK (pgd_annots_drawing_area_realize), (gpointer)demo); g_signal_connect (demo->darea, "button_press_event", G_CALLBACK (pgd_annots_drawing_area_button_press), (gpointer)demo); g_signal_connect (demo->darea, "motion_notify_event", G_CALLBACK (pgd_annots_drawing_area_motion_notify), (gpointer)demo); g_signal_connect (demo->darea, "button_release_event", G_CALLBACK (pgd_annots_drawing_area_button_release), (gpointer)demo); swindow = gtk_scrolled_window_new (NULL, NULL); #if GTK_CHECK_VERSION(3, 7, 8) gtk_container_add(GTK_CONTAINER(swindow), demo->darea); #else gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea); #endif gtk_widget_show (demo->darea); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_paned_set_position (GTK_PANED (hpaned), 300); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_annots_free, demo); pgd_annots_viewer_queue_redraw (demo); pgd_annots_get_annots (demo); demo->main_box = vbox; return vbox; }
GtkWidget* file_properties_dlg_new( GtkWindow* parent, const char* dir_path, GList* sel_files, int page ) { GtkBuilder* builder = _gtk_builder_new_from_file( PACKAGE_UI_DIR "/file_properties.ui", NULL ); GtkWidget * dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" ); GtkNotebook* notebook = (GtkNotebook*)gtk_builder_get_object( builder, "notebook" ); xset_set_window_icon( GTK_WINDOW( dlg ) ); FilePropertiesDialogData* data; gboolean need_calc_size = TRUE; VFSFileInfo *file, *file2; VFSMimeType* mime; const char* multiple_files = _( "( multiple files )" ); const char* calculating; GtkWidget* name = (GtkWidget*)gtk_builder_get_object( builder, "file_name" ); GtkWidget* label_name = (GtkWidget*)gtk_builder_get_object( builder, "label_filename" ); GtkWidget* location = (GtkWidget*)gtk_builder_get_object( builder, "location" ); gtk_editable_set_editable ( GTK_EDITABLE( location ), FALSE ); GtkWidget* target = (GtkWidget*)gtk_builder_get_object( builder, "target" ); GtkWidget* label_target = (GtkWidget*)gtk_builder_get_object( builder, "label_target" ); gtk_editable_set_editable ( GTK_EDITABLE( target ), FALSE ); GtkWidget* mime_type = (GtkWidget*)gtk_builder_get_object( builder, "mime_type" ); GtkWidget* open_with = (GtkWidget*)gtk_builder_get_object( builder, "open_with" ); char buf[ 64 ]; char buf2[ 32 ]; const char* time_format = "%Y-%m-%d %H:%M:%S"; gchar* disp_path; gchar* file_type; int i; GList* l; gboolean same_type = TRUE; gboolean is_dirs = FALSE; char *owner_group, *tmp; gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 ); ptk_dialog_fit_small_screen( GTK_DIALOG(dlg) ); int width = xset_get_int( "app_dlg", "s" ); int height = xset_get_int( "app_dlg", "z" ); if ( width && height ) gtk_window_set_default_size( GTK_WINDOW( dlg ), width, -1 ); data = g_slice_new0( FilePropertiesDialogData ); /* FIXME: When will the data be freed??? */ g_object_set_data( G_OBJECT( dlg ), "DialogData", data ); data->file_list = sel_files; data->dlg = dlg; data->dir_path = g_strdup( dir_path ); disp_path = g_filename_display_name( dir_path ); //gtk_label_set_text( GTK_LABEL( location ), disp_path ); gtk_entry_set_text( GTK_ENTRY( location ), disp_path ); g_free( disp_path ); data->total_size_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "total_size" ) ); data->size_on_disk_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "size_on_disk" ) ); data->count_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "count" ) ); data->owner = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "owner" ) ); data->group = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "group" ) ); data->mtime = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "mtime" ) ); data->atime = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "atime" ) ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { data->chmod_btns[ i ] = GTK_TOGGLE_BUTTON( (GtkWidget*)gtk_builder_get_object( builder, chmod_names[ i ] ) ); } //MOD VFSMimeType* type; VFSMimeType* type2 = NULL; for ( l = sel_files; l ; l = l->next ) { file = ( VFSFileInfo* ) l->data; type = vfs_file_info_get_mime_type( file ); if ( !type2 ) type2 = vfs_file_info_get_mime_type( file ); if ( vfs_file_info_is_dir( file ) ) is_dirs = TRUE; if ( type != type2 ) same_type = FALSE; vfs_mime_type_unref( type ); if ( is_dirs && !same_type ) break; } if ( type2 ) vfs_mime_type_unref( type2 ); data->recurse = (GtkWidget*)gtk_builder_get_object( builder, "recursive" ); gtk_widget_set_sensitive( data->recurse, is_dirs ); /* //MOD for ( l = sel_files; l && l->next; l = l->next ) { VFSMimeType *type, *type2; file = ( VFSFileInfo* ) l->data; file2 = ( VFSFileInfo* ) l->next->data; type = vfs_file_info_get_mime_type( file ); type2 = vfs_file_info_get_mime_type( file2 ); if ( type != type2 ) { vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); same_type = FALSE; break; } vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); } */ file = ( VFSFileInfo* ) sel_files->data; if ( same_type ) { mime = vfs_file_info_get_mime_type( file ); file_type = g_strdup_printf( "%s\n%s", vfs_mime_type_get_description( mime ), vfs_mime_type_get_type( mime ) ); gtk_label_set_text( GTK_LABEL( mime_type ), file_type ); g_free( file_type ); vfs_mime_type_unref( mime ); } else { gtk_label_set_text( GTK_LABEL( mime_type ), _( "( multiple types )" ) ); } /* Open with... * Don't show this option menu if files of different types are selected, * ,the selected file is a folder, or its type is unknown. */ if( ! same_type || vfs_file_info_is_desktop_entry( file ) || /* vfs_file_info_is_unknown_type( file ) || */ vfs_file_info_is_executable( file, NULL ) ) { /* if open with shouldn't show, destroy it. */ gtk_widget_destroy( open_with ); open_with = NULL; gtk_widget_destroy( (GtkWidget*)gtk_builder_get_object( builder, "open_with_label" ) ); } else /* Add available actions to the option menu */ { GtkTreeIter it; char **action, **actions; mime = vfs_file_info_get_mime_type( file ); actions = vfs_mime_type_get_actions( mime ); GtkCellRenderer* renderer; GtkListStore* model; gtk_cell_layout_clear( GTK_CELL_LAYOUT(open_with) ); renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, FALSE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with), renderer, "pixbuf", 0, NULL ); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, TRUE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with),renderer, "text", 1, NULL ); model = gtk_list_store_new( 3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); if( actions ) { for( action = actions; *action; ++action ) { VFSAppDesktop* desktop; GdkPixbuf* icon; desktop = vfs_app_desktop_new( *action ); gtk_list_store_append( model, &it ); icon = vfs_app_desktop_get_icon(desktop, 20, TRUE); gtk_list_store_set( model, &it, 0, icon, 1, vfs_app_desktop_get_disp_name(desktop), 2, *action, -1 ); if( icon ) g_object_unref( icon ); vfs_app_desktop_unref( desktop ); } } else { g_object_set_data( G_OBJECT(open_with), "prev_sel", GINT_TO_POINTER(-1) ); } /* separator */ gtk_list_store_append( model, &it ); gtk_list_store_append( model, &it ); gtk_list_store_set( model, &it, 0, NULL, 1, _("Choose..."), -1 ); gtk_combo_box_set_model( GTK_COMBO_BOX(open_with), GTK_TREE_MODEL(model) ); gtk_combo_box_set_row_separator_func( GTK_COMBO_BOX(open_with), combo_sep, NULL, NULL ); gtk_combo_box_set_active(GTK_COMBO_BOX(open_with), 0); g_signal_connect( open_with, "changed", G_CALLBACK(on_combo_change), mime ); /* vfs_mime_type_unref( mime ); */ /* We can unref mime when combo box gets destroyed */ g_object_weak_ref( G_OBJECT(open_with), (GWeakNotify)vfs_mime_type_unref, mime ); } g_object_set_data( G_OBJECT(dlg), "open_with", open_with ); /* Multiple files are selected */ if ( sel_files && sel_files->next ) { gtk_widget_set_sensitive( name, FALSE ); gtk_entry_set_text( GTK_ENTRY( name ), multiple_files ); data->orig_mtime = NULL; data->orig_atime = NULL; for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { gtk_toggle_button_set_inconsistent ( data->chmod_btns[ i ], TRUE ); data->chmod_states[ i ] = 2; /* Don't touch this bit */ g_signal_connect( G_OBJECT( data->chmod_btns[ i ] ), "toggled", G_CALLBACK( on_chmod_btn_toggled ), data ); } } else { /* special processing for files with special display names */ if( vfs_file_info_is_desktop_entry( file ) ) { char* disp_name = g_filename_display_name( file->name ); gtk_entry_set_text( GTK_ENTRY( name ), disp_name ); g_free( disp_name ); } else { if ( vfs_file_info_is_dir( file ) && !vfs_file_info_is_symlink( file ) ) gtk_label_set_markup_with_mnemonic( GTK_LABEL( label_name ), _("<b>Folder _Name:</b>") ); gtk_entry_set_text( GTK_ENTRY( name ), vfs_file_info_get_disp_name( file ) ); } gtk_editable_set_editable ( GTK_EDITABLE( name ), FALSE ); if ( ! vfs_file_info_is_dir( file ) ) { /* Only single "file" is selected, so we don't need to caculate total file size */ need_calc_size = FALSE; sprintf( buf, _("%s ( %lu bytes )"), vfs_file_info_get_disp_size( file ), ( guint64 ) vfs_file_info_get_size( file ) ); gtk_label_set_text( data->total_size_label, buf ); vfs_file_size_to_string( buf2, vfs_file_info_get_blocks( file ) * 512 ); sprintf( buf, _("%s ( %lu bytes )"), buf2, ( guint64 ) vfs_file_info_get_blocks( file ) * 512 ); gtk_label_set_text( data->size_on_disk_label, buf ); gtk_label_set_text( data->count_label, _("1 file") ); } // Modified / Accessed //gtk_entry_set_text( GTK_ENTRY( mtime ), // vfs_file_info_get_disp_mtime( file ) ); strftime( buf, sizeof( buf ), time_format, localtime( vfs_file_info_get_mtime( file ) ) ); gtk_entry_set_text( GTK_ENTRY( data->mtime ), buf ); data->orig_mtime = g_strdup( buf ); strftime( buf, sizeof( buf ), time_format, localtime( vfs_file_info_get_atime( file ) ) ); gtk_entry_set_text( GTK_ENTRY( data->atime ), buf ); data->orig_atime = g_strdup( buf ); // Permissions owner_group = (char *) vfs_file_info_get_disp_owner( file ); tmp = strchr( owner_group, ':' ); data->owner_name = g_strndup( owner_group, tmp - owner_group ); gtk_entry_set_text( GTK_ENTRY( data->owner ), data->owner_name ); data->group_name = g_strdup( tmp + 1 ); gtk_entry_set_text( GTK_ENTRY( data->group ), data->group_name ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { if ( data->chmod_states[ i ] != 2 ) /* allow to touch this bit */ { data->chmod_states[ i ] = ( vfs_file_info_get_mode( file ) & chmod_flags[ i ] ? 1 : 0 ); gtk_toggle_button_set_active( data->chmod_btns[ i ], data->chmod_states[ i ] ); } } // target if ( vfs_file_info_is_symlink( file ) ) { gtk_label_set_markup_with_mnemonic( GTK_LABEL( label_name ), _("<b>Link _Name:</b>") ); disp_path = g_build_filename( dir_path, file->name, NULL ); char* target_path = g_file_read_link( disp_path, NULL ); if ( target_path ) { gtk_entry_set_text( GTK_ENTRY( target ), target_path ); if ( target_path[0] && target_path[0] != '/' ) { // relative link to absolute char* str = target_path; target_path = g_build_filename( dir_path, str, NULL ); g_free( str ); } if ( !g_file_test( target_path, G_FILE_TEST_EXISTS ) ) gtk_label_set_text( GTK_LABEL( mime_type ), _("( broken link )") ); g_free( target_path ); } else gtk_entry_set_text( GTK_ENTRY( target ), _("( read link error )") ); g_free( disp_path ); gtk_widget_show( target ); gtk_widget_show( label_target ); } } if ( need_calc_size ) { /* The total file size displayed in "File Properties" is not completely calculated yet. So "Calculating..." is displayed. */ calculating = _( "Calculating..." ); gtk_label_set_text( data->total_size_label, calculating ); gtk_label_set_text( data->size_on_disk_label, calculating ); g_object_set_data( G_OBJECT( dlg ), "calc_size", data ); data->calc_size_thread = g_thread_create ( ( GThreadFunc ) calc_size, data, TRUE, NULL ); data->update_label_timer = g_timeout_add( 250, ( GSourceFunc ) on_update_labels, data ); } g_signal_connect( dlg, "response", G_CALLBACK(on_dlg_response), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "ok_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "cancel_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_object_unref( builder ); gtk_notebook_set_current_page( notebook, page ); gtk_window_set_transient_for( GTK_WINDOW( dlg ), parent ); return dlg; }
/*! *\brief Create the matcher dialog */ static void prefs_filtering_action_create(void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *ok_btn; GtkWidget *cancel_btn; GtkWidget *confirm_area; GtkWidget *vbox1; GtkWidget *frame; GtkWidget *table; GtkWidget *hbox1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *action_combo; GtkWidget *account_combo; GtkWidget *header_combo; GtkWidget *header_entry; #ifndef USE_ALT_ADDRBOOK GtkWidget *addressbook_btn; #endif GtkWidget *dest_entry; GtkWidget *dest_btn; GtkWidget *score_entry; GtkWidget *tags_combo; GtkWidget *reg_hbox; GtkWidget *btn_hbox; GtkWidget *arrow; GtkWidget *reg_btn; GtkWidget *subst_btn; GtkWidget *del_btn; GtkWidget *action_hbox; GtkWidget *action_scrolledwin; GtkWidget *action_list_view; GtkWidget *btn_vbox; GtkWidget *up_btn; GtkWidget *down_btn; GtkWidget *exec_btn; #if !GTK_CHECK_VERSION(3, 0, 0) GtkWidget *color_optmenu; #endif static GdkGeometry geometry; GList * accounts; GSList *tmp, *tags; GtkSizeGroup *size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); GtkSizeGroup *size_action = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); GtkTreeModel *model; GtkCellRenderer *renderer; debug_print("Creating matcher configuration window...\n"); window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_filtering_action"); gtk_container_set_border_width(GTK_CONTAINER(window), VBOX_BORDER); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(window), TRUE); vbox = gtk_vbox_new(FALSE, 6); gtk_container_add(GTK_CONTAINER(window), vbox); gtkut_stock_button_set_create(&confirm_area, &cancel_btn, GTK_STOCK_CANCEL, &ok_btn, GTK_STOCK_OK, NULL, NULL); gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(ok_btn); gtk_window_set_title(GTK_WINDOW(window), _("Action configuration")); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(prefs_filtering_action_deleted), NULL); g_signal_connect(G_OBJECT(window), "size_allocate", G_CALLBACK(prefs_filtering_action_size_allocate_cb), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(prefs_filtering_action_key_pressed), NULL); MANAGE_WINDOW_SIGNALS_CONNECT(window); g_signal_connect(G_OBJECT(ok_btn), "clicked", G_CALLBACK(prefs_filtering_action_ok), NULL); g_signal_connect(G_OBJECT(cancel_btn), "clicked", G_CALLBACK(prefs_filtering_action_cancel), NULL); vbox1 = gtk_vbox_new(FALSE, VSPACING); gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER (vbox1), 2); frame = gtk_frame_new(_("Rule")); gtk_frame_set_label_align(GTK_FRAME(frame), 0.01, 0.5); gtk_box_pack_start (GTK_BOX (vbox1), frame, FALSE, FALSE, 0); gtk_widget_set_size_request(frame, -1, 110); table = gtk_table_new(3, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), VSPACING_NARROW_2); gtk_table_set_col_spacings (GTK_TABLE (table), HSPACING_NARROW); gtk_container_add(GTK_CONTAINER(frame), table); /* first row labels */ label1 = gtk_label_new (_("Action")); gtk_widget_set_size_request(label1, LABELS_WIDTH, -1); gtk_size_group_add_widget(size_group, label1); gtk_misc_set_alignment (GTK_MISC (label1), 1, 0.5); gtk_table_attach(GTK_TABLE(table), label1, 0, 1, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); label2 = gtk_label_new (""); gtk_size_group_add_widget(size_group, label2); gtk_misc_set_alignment (GTK_MISC (label2), 1, 0.5); gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 1, 2, GTK_FILL, GTK_SHRINK, 0, 0); label3 = gtk_label_new (""); gtk_size_group_add_widget(size_group, label3); gtk_misc_set_alignment (GTK_MISC (label3), 1, 0.5); gtk_table_attach(GTK_TABLE(table), label3, 0, 1, 2, 3, GTK_FILL, GTK_SHRINK, 0, 0); /* action combo */ hbox1 = gtk_hbox_new(FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0); model = prefs_filtering_action_create_model(); action_combo = gtk_combo_box_new_with_model(model); gtk_size_group_add_widget(size_action, action_combo); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(action_combo), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(action_combo), renderer, "text", ACTION_COMBO_TEXT, "sensitive", ACTION_COMBO_SENS, NULL); gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(action_combo), renderer, cell_is_sensitive, NULL, NULL); combobox_select_by_data(GTK_COMBO_BOX(action_combo), ACTION_MOVE); g_signal_connect(G_OBJECT(action_combo), "changed", G_CALLBACK(prefs_filtering_action_type_selection_changed), NULL); gtk_box_pack_start(GTK_BOX(hbox1), action_combo, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox1), gtk_label_new(""), TRUE, TRUE, 0); /* accounts */ hbox1 = gtk_hbox_new (FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); #if !GTK_CHECK_VERSION(2, 24, 0) account_combo = gtk_combo_box_new_text (); #else account_combo = gtk_combo_box_text_new (); #endif gtk_size_group_add_widget(size_action, account_combo); for (accounts = account_get_list() ; accounts != NULL; accounts = accounts->next) { PrefsAccount *ac = (PrefsAccount *)accounts->data; gchar *name = g_strdup(ac->account_name); #if !GTK_CHECK_VERSION(2, 24, 0) gtk_combo_box_append_text(GTK_COMBO_BOX(account_combo), (gpointer) name); #else gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(account_combo), (gpointer) name); #endif g_free(name); } prefs_filtering_action_check_widget_width(account_combo); gtk_combo_box_set_active(GTK_COMBO_BOX(account_combo), 0); gtk_box_pack_start (GTK_BOX (hbox1), account_combo, FALSE, FALSE, 0); /* header */ header_combo = combobox_text_new(TRUE, "From", "To", "Cc", "Reply-To", "Sender", NULL); gtk_size_group_add_widget(size_action, header_combo); gtk_box_pack_start (GTK_BOX (hbox1), header_combo, FALSE, FALSE, 0); header_entry = gtk_bin_get_child(GTK_BIN((header_combo))); /* destination */ hbox1 = gtk_hbox_new (FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); dest_entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox1), dest_entry, TRUE, TRUE, 0); score_entry = gtk_spin_button_new_with_range(-1000, 1000, 1); gtk_box_pack_start(GTK_BOX(hbox1), score_entry, FALSE, FALSE, 0); #if !GTK_CHECK_VERSION(3, 0, 0) color_optmenu = gtk_cmoption_menu_new(); gtk_size_group_add_widget(size_action, color_optmenu); gtk_cmoption_menu_set_menu(GTK_CMOPTION_MENU(color_optmenu), colorlabel_create_color_menu()); prefs_filtering_action_check_widget_width(color_optmenu); gtk_box_pack_start(GTK_BOX(hbox1), color_optmenu, FALSE, FALSE, 0); #endif #if !GTK_CHECK_VERSION(2, 24, 0) tags_combo = gtk_combo_box_new_text (); #else tags_combo = gtk_combo_box_text_new (); #endif gtk_size_group_add_widget(size_action, tags_combo); for (tmp = tags = tags_get_list() ; tmp != NULL; tmp = tmp->next) { gchar *name = g_strdup(tags_get_tag(GPOINTER_TO_INT(tmp->data))); #if !GTK_CHECK_VERSION(2, 24, 0) gtk_combo_box_append_text(GTK_COMBO_BOX(tags_combo), (gpointer) name); #else gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tags_combo), (gpointer) name); #endif g_free(name); } g_slist_free(tags); prefs_filtering_action_check_widget_width(tags_combo); gtk_combo_box_set_active(GTK_COMBO_BOX(tags_combo), 0); gtk_box_pack_start (GTK_BOX (hbox1), tags_combo, FALSE, FALSE, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox1, 2, 3, 2, 3, GTK_FILL, GTK_SHRINK, 0, 0); dest_btn = gtk_button_new_with_label (_("Select...")); gtk_box_pack_start (GTK_BOX (hbox1), dest_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (dest_btn), "clicked", G_CALLBACK(prefs_filtering_action_select_dest), NULL); #ifndef USE_ALT_ADDRBOOK addressbook_btn = gtk_button_new_with_label (_("Select...")); gtk_box_pack_start (GTK_BOX (hbox1), addressbook_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (addressbook_btn), "clicked", G_CALLBACK(prefs_filtering_action_select_addressbook), NULL); #endif exec_btn = gtk_button_new_from_stock(GTK_STOCK_INFO); gtk_box_pack_start (GTK_BOX (hbox1), exec_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (exec_btn), "clicked", G_CALLBACK(prefs_filtering_action_exec_info), window); /* register / substitute / delete */ reg_hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(vbox1), reg_hbox, FALSE, FALSE, 0); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT); gtk_box_pack_start(GTK_BOX(reg_hbox), arrow, FALSE, FALSE, 0); gtk_widget_set_size_request(arrow, -1, 16); btn_hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start(GTK_BOX(reg_hbox), btn_hbox, FALSE, FALSE, 0); reg_btn = gtk_button_new_from_stock(GTK_STOCK_ADD); gtk_box_pack_start(GTK_BOX(btn_hbox), reg_btn, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(reg_btn), "clicked", G_CALLBACK(prefs_filtering_action_register_cb), NULL); subst_btn = gtkut_get_replace_btn(_("_Replace")); gtk_box_pack_start(GTK_BOX(btn_hbox), subst_btn, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(subst_btn), "clicked", G_CALLBACK(prefs_filtering_action_substitute_cb), NULL); del_btn = gtk_button_new_with_mnemonic (_("Re_move")); gtk_button_set_image(GTK_BUTTON(del_btn), gtk_image_new_from_stock(GTK_STOCK_REMOVE,GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start(GTK_BOX(btn_hbox), del_btn, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(del_btn), "clicked", G_CALLBACK(prefs_filtering_action_delete_cb), NULL); action_hbox = gtk_hbox_new(FALSE, 8); gtk_box_pack_start(GTK_BOX(vbox1), action_hbox, TRUE, TRUE, 0); action_scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(action_scrolledwin, -1, 150); gtk_box_pack_start(GTK_BOX(action_hbox), action_scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(action_scrolledwin), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(action_scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); action_list_view = prefs_filtering_action_list_view_create(); gtk_container_add(GTK_CONTAINER(action_scrolledwin), action_list_view); btn_vbox = gtk_vbox_new(FALSE, 8); gtk_box_pack_start(GTK_BOX(action_hbox), btn_vbox, FALSE, FALSE, 0); up_btn = gtk_button_new_from_stock(GTK_STOCK_GO_UP); gtk_box_pack_start(GTK_BOX(btn_vbox), up_btn, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(up_btn), "clicked", G_CALLBACK(prefs_filtering_action_up), NULL); down_btn = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN); gtk_box_pack_start(GTK_BOX(btn_vbox), down_btn, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(down_btn), "clicked", G_CALLBACK(prefs_filtering_action_down), NULL); if (!geometry.min_height) { geometry.min_width = 490; geometry.min_height = 348; } gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry, GDK_HINT_MIN_SIZE); gtk_widget_set_size_request(window, prefs_common.filteringactionwin_width, prefs_common.filteringactionwin_height); gtk_widget_show_all(window); filtering_action.window = window; filtering_action.label1 = label1; filtering_action.label2 = label2; filtering_action.label3 = label3; filtering_action.action_combo = action_combo; filtering_action.account_combo = account_combo; filtering_action.tags_combo = tags_combo; filtering_action.dest_entry = dest_entry; filtering_action.dest_btn = dest_btn; filtering_action.exec_btn = exec_btn; #if !GTK_CHECK_VERSION(3, 0, 0) filtering_action.color_optmenu = color_optmenu; #endif filtering_action.score_entry = score_entry; filtering_action.header_combo = header_combo; filtering_action.header_entry = header_entry; #ifndef USE_ALT_ADDRBOOK filtering_action.addressbook_btn = addressbook_btn; #endif filtering_action.ok_btn = ok_btn; filtering_action.action_list_view = action_list_view; prefs_filtering_action_type_selection_changed(NULL, NULL); }
static void power_manager_plugin_configure (XfcePanelPlugin *plugin, PowerManagerPlugin *power_manager_plugin) { GtkWidget *dialog; GtkWidget *grid, *combo, *label; gint show_panel_label; XfconfChannel *channel; GtkListStore *list_store; GtkTreeIter iter, active_iter; GtkCellRenderer *cell; gint i; gchar *options[] = { _("None"), _("Percentage"), _("Remaining time"), _("Percentage and remaining time") }; channel = xfconf_channel_get (XFPM_CHANNEL); /* block the plugin menu */ xfce_panel_plugin_block_menu (plugin); /* create the dialog */ dialog = xfce_titled_dialog_new_with_buttons (_("Power Manager Plugin Settings"), GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (plugin))), GTK_DIALOG_DESTROY_WITH_PARENT, "gtk-help", GTK_RESPONSE_HELP, "gtk-close", GTK_RESPONSE_OK, NULL); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_window_set_icon_name (GTK_WINDOW (dialog), "xfce4-power-manager-settings"); gtk_widget_show (dialog); /* Set up the main grid for all settings */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 12); gtk_widget_set_margin_start (grid, 12); gtk_widget_set_margin_end (grid, 12); gtk_widget_set_margin_top (grid, 12); gtk_widget_set_margin_bottom (grid, 12); gtk_container_add_with_properties (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), grid, "expand", TRUE, "fill", TRUE, NULL); /* show-panel-label setting */ label = gtk_label_new (_("Show label:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), GTK_WIDGET (label), 0, 0, 1, 1); show_panel_label = xfconf_channel_get_int (channel, XFPM_PROPERTIES_PREFIX SHOW_PANEL_LABEL, -1); list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_INT, G_TYPE_STRING); for (i = 0; i < 4; i++) { gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_INT, i, COLUMN_STRING, options[i], -1); if (i == show_panel_label) active_iter = iter; } combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (list_store)); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE ); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell, "text", COLUMN_STRING, NULL); gtk_combo_box_set_id_column (GTK_COMBO_BOX (combo), COLUMN_STRING); gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &active_iter); gtk_grid_attach (GTK_GRID (grid), GTK_WIDGET (combo), 1, 0, 1, 1); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (power_manager_plugin_combo_changed), channel); g_signal_connect (G_OBJECT (channel), "property-changed::" XFPM_PROPERTIES_PREFIX SHOW_PANEL_LABEL, G_CALLBACK (power_manager_plugin_panel_label_changed), combo); /* link the dialog to the plugin, so we can destroy it when the plugin * is closed, but the dialog is still open */ g_object_set_data (G_OBJECT (plugin), "dialog", dialog); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK(power_manager_plugin_configure_response), power_manager_plugin); gtk_widget_show_all (grid); }
/** * fm_app_chooser_combo_box_setup * @combo: a #GtkComboBox * @mime_type: (allow-none): a #FmMimeType to select application * @apps: (allow-none) (element-type GAppInfo): custom list of applications * @sel: (allow-none): a selected application in @apps * * Setups a combobox for selecting default application either for * specified mime-type or from a list of pre-defined applications. * If @mime_type is %NULL, and @sel is provided and found in the @apps, * then it will be selected. If @mime_type is not %NULL then default * application for the @mime_type will be selected. * When set up, the combobox will contain a list of available applications. * * Since: 0.1.5 */ void fm_app_chooser_combo_box_setup(GtkComboBox* combo, FmMimeType* mime_type, GList* apps, GAppInfo* sel) { FmAppChooserComboBoxData* data = g_slice_new0(FmAppChooserComboBoxData); GtkListStore* store = gtk_list_store_new(3, G_TYPE_ICON, G_TYPE_STRING, G_TYPE_APP_INFO); GtkTreeIter it; GList* l; GtkCellRenderer* render; gtk_cell_layout_clear(GTK_CELL_LAYOUT(combo)); render = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), render, FALSE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(combo), render, "gicon", 0); render = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), render, FALSE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(combo), render, "text", 1); if(mime_type) { data->mime_type = fm_mime_type_ref(mime_type); apps = g_app_info_get_all_for_type(fm_mime_type_get_type(data->mime_type)); sel = g_app_info_get_default_for_type(fm_mime_type_get_type(data->mime_type), FALSE); } for(l = apps; l; l = l->next) { GAppInfo* app = G_APP_INFO(l->data); gtk_list_store_insert_with_values(store, &it, -1, 0, g_app_info_get_icon(app), 1, g_app_info_get_name(app), 2, app, -1); if(sel && g_app_info_equal(app, sel)) { /* this is the initially selected app */ data->initial_sel_iter = it; data->initial_sel_app = (GAppInfo*)g_object_ref(app); } } if(mime_type) /* if this list is retrived with g_app_info_get_all_for_type() */ { if(apps) { g_list_foreach(apps, (GFunc)g_object_unref, NULL); g_list_free(apps); } if(sel) g_object_unref(sel); } gtk_list_store_append(store, &it); /* separator */ data->separator_iter = it; /* other applications */ gtk_list_store_insert_with_values(store, &it, -1, 0, NULL, 1, _("Customize"), // FIXME: should be "Customize..." 2, NULL, -1); data->other_apps_iter = it; gtk_combo_box_set_model(combo, GTK_TREE_MODEL(store)); if(data->initial_sel_iter.user_data) /* intital selection is set */ { data->prev_sel_iter = data->initial_sel_iter; gtk_combo_box_set_active_iter(combo, &data->initial_sel_iter); } gtk_combo_box_set_row_separator_func(combo, is_row_separator, data, NULL); g_object_unref(store); g_signal_connect(combo, "changed", G_CALLBACK(on_app_selected), data); g_object_set_qdata_full(G_OBJECT(combo), fm_qdata_id, data, free_data); }
static gboolean remap_dialog (gint32 image_ID, guchar *map) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *box; GtkWidget *iconview; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeIter iter; guchar *cmap; gint ncols, i; gboolean valid; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Rearrange Colormap"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC_REMAP, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); cmap = gimp_image_get_colormap (image_ID, &ncols); g_return_val_if_fail ((ncols > 0) && (ncols <= 256), FALSE); store = gtk_list_store_new (NUM_COLS, G_TYPE_INT, G_TYPE_STRING, GIMP_TYPE_RGB, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE); for (i = 0; i < ncols; i++) { GimpRGB rgb; GimpHSV hsv; gint index = map[i]; gchar *text = g_strdup_printf ("%d", index); gimp_rgb_set_uchar (&rgb, cmap[index * 3], cmap[index * 3 + 1], cmap[index * 3 + 2]); gimp_rgb_to_hsv (&rgb, &hsv); reverse_order[i] = ncols - i - 1; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLOR_INDEX, index, COLOR_INDEX_TEXT, text, COLOR_RGB, &rgb, COLOR_H, hsv.h, COLOR_S, hsv.s, COLOR_V, hsv.v, -1); g_free (text); } g_free (cmap); remap_ui = remap_ui_manager_new (dialog, store); iconview = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_box_pack_start (GTK_BOX (vbox), iconview, TRUE, TRUE, 0); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (iconview), GTK_SELECTION_SINGLE); gtk_icon_view_set_orientation (GTK_ICON_VIEW (iconview), GTK_ORIENTATION_VERTICAL); gtk_icon_view_set_columns (GTK_ICON_VIEW (iconview), 16); gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (iconview), 0); gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (iconview), 0); gtk_icon_view_set_reorderable (GTK_ICON_VIEW (iconview), TRUE); renderer = gimp_cell_renderer_color_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer, "color", COLOR_RGB, NULL); g_object_set (renderer, "width", 24, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer, "text", COLOR_INDEX_TEXT, NULL); g_object_set (renderer, "size-points", 6.0, "xalign", 0.5, "ypad", 0, NULL); g_signal_connect (iconview, "popup-menu", G_CALLBACK (remap_popup_menu), NULL); g_signal_connect (iconview, "button-press-event", G_CALLBACK (remap_button_press), NULL); box = gimp_hint_box_new (_("Drag and drop colors to rearrange the colormap. " "The numbers shown are the original indices. " "Right-click for a menu with sort options.")); gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 0); gtk_widget_show (box); g_signal_connect (dialog, "response", G_CALLBACK (remap_response), store); gtk_widget_show_all (dialog); gtk_main (); i = 0; for (valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter); valid; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter)) { gint index; gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COLOR_INDEX, &index, -1); map[i++] = index; } gtk_widget_destroy (dialog); return remap_run; }
static GtkWidget *create_window(GtkWidget *tree_view, gint window_id) { GtkWidget *window; gchar *title; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *button; GtkWidget *label; GtkWidget *scrolled_window; GtkWidget *combobox_field; GtkWidget *combobox_comp; GtkWidget *expander; GtkWidget *hbox_1, *vbox_1, *Frame_1; GtkWidget *scrolled_window_1; GtkWidget *hbox_11; GtkTreeSelection *selection; GtkTreeModel *model; GtkTreeModel *child_model; gulong changed_handler_id; GList *list; GtkCellRenderer *column; char *c_label; c_label = (char *)calloc(KCHARA_C, sizeof(char)); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); title = g_strdup_printf("GtkTreeModelSort #%d", window_id); gtk_window_set_title(GTK_WINDOW(window), title); g_free(title); vbox = gtk_vbox_new(FALSE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* Delete data bottun */ button = gtk_button_new_from_stock(GTK_STOCK_REMOVE); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_model_data), tree_view); /* Close window bottun */ button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(cb_close_window), window); /* ラベル */ label = gtk_label_new(""); gtk_box_pack_end(GTK_BOX(hbox), label, TRUE, TRUE, 0); scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request(scrolled_window, 400, 300); gtk_container_add(GTK_CONTAINER(scrolled_window), tree_view); gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0); /* * selectionにchangedシグナルハンドラを登録する。 * 後で同じchild_modelを使用しているselectionのchangedシグナルをブロック出来るように * child_modelにselectionのリストを、selectionにシグナルハンドラIDを登録する。 * changedハンドラ内で使用するlabelも同様に登録しておく。 */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); changed_handler_id = g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(sum_selected_rows), NULL); g_object_set_data(G_OBJECT(selection), "changed_handler_id", GUINT_TO_POINTER(changed_handler_id)); g_object_set_data(G_OBJECT(selection), "label", label); model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)); child_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model)); list = g_object_get_data(G_OBJECT(child_model), "selection_list"); list = g_list_append(list, selection); g_object_set_data(G_OBJECT(child_model), "selection_list", list); get_label_MHD_control_head(c_label); expander = gtk_expander_new_with_mnemonic("Field to add"); vbox_1 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); Frame_1 = gtk_frame_new(""); gtk_frame_set_shadow_type(GTK_FRAME(Frame_1), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(Frame_1), vbox_1); /* Add data bottun */ hbox_1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); button = gtk_button_new_from_stock(GTK_STOCK_ADD); gtk_box_pack_start(GTK_BOX(hbox_1), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(append_model_data), tree_view); gtk_box_pack_start(GTK_BOX(hbox_1), gtk_label_new(" "), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_1), Frame_1, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(expander), hbox_1); gtk_box_pack_start(GTK_BOX(vbox), expander, TRUE, TRUE, 0); hbox_11 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); combobox_field = gtk_combo_box_new_with_model(model); g_signal_connect(G_OBJECT(combobox_field), "changed", G_CALLBACK(format_entry_text_callback), tree_view); column = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_field), column, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_field), column, "text", COLUMN_FIELD_NAME, NULL); gtk_box_pack_start(GTK_BOX(hbox_11), combobox_field, FALSE, FALSE, 0); combobox_comp = gtk_combo_box_new(); g_signal_connect(G_OBJECT(combobox_comp), "changed", G_CALLBACK(format_entry_text_callback), tree_view); column = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_comp), column, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_comp), column, "text", COLUMN_FIELD_NAME, NULL); gtk_box_pack_start(GTK_BOX(hbox_11), combobox_comp, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox_11, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show_all(window); return window; }
/** * Initialize the buddy-add window. */ static void hybrid_buddyadd_window_init(HybridBuddyAddWindow *window) { GtkWidget *vbox; GtkWidget *action_area; GtkWidget *label; GtkTreeModel *model; GtkCellRenderer *renderer; GtkWidget *button; GtkWidget *table; GtkWidget *scroll; HybridAccount *account = NULL; GtkTreeIter iter; vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window->window), vbox); table = gtk_table_new(5, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 5); gtk_table_set_col_spacings(GTK_TABLE(table), 5); gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Account:</b>")); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); model = create_account_model(); window->account_combo = gtk_combo_box_new_with_model(model); g_signal_connect(window->account_combo, "changed", G_CALLBACK(account_changed_cb), window); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(window->account_combo), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(window->account_combo), renderer, "pixbuf", 0, NULL); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(window->account_combo), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(window->account_combo), renderer, "text", 1, NULL); gtk_combo_box_set_active(GTK_COMBO_BOX(window->account_combo), 0); gtk_widget_set_size_request(window->account_combo, 270, 30); gtk_table_attach_defaults(GTK_TABLE(table), window->account_combo, 1, 2, 0, 1); /* username */ label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Username:</b>")); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); window->username_entry = gtk_entry_new(); gtk_widget_set_size_request(window->username_entry, 270, 30); gtk_table_attach_defaults(GTK_TABLE(table), window->username_entry, 1, 2, 1, 2); /* alias name */ label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Alias(Optional):</b>")); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3); window->localname_entry = gtk_entry_new(); gtk_widget_set_size_request(window->localname_entry, 270, 30); gtk_table_attach_defaults(GTK_TABLE(table), window->localname_entry, 1, 2, 2, 3); /* add-to-group combo box. */ label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Add To Group:</b>")); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4); /* get the active account. */ if (gtk_combo_box_get_active_iter( GTK_COMBO_BOX(window->account_combo), &iter)) { gtk_tree_model_get(model, &iter, BUDDYADD_ACCOUNT_COLUMN, &account, -1); } /* unref the account model. */ g_object_unref(model); model = create_group_model(account); window->group_combo = gtk_combo_box_new_with_model(model); g_object_unref(model); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(window->group_combo), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(window->group_combo), renderer, "text", BUDDYADD_GROUP_NAME_COLUMN, NULL); gtk_combo_box_set_active(GTK_COMBO_BOX(window->group_combo), 0); gtk_table_attach_defaults(GTK_TABLE(table), window->group_combo, 1, 2, 3, 4); /* add-buddy request tips. */ label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Tips(Optional):</b>")); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 4, 5); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN); window->tips_textview = gtk_text_view_new(); gtk_widget_set_size_request(window->tips_textview, 270, 0); gtk_container_add(GTK_CONTAINER(scroll), window->tips_textview); gtk_table_attach_defaults(GTK_TABLE(table), scroll, 1, 2, 4, 5); /* buttons */ action_area = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), action_area, FALSE, FALSE, 5); button = gtk_button_new_with_label(_("Add")); gtk_widget_set_size_request(button, 100, 30); gtk_box_pack_end(GTK_BOX(action_area), button, FALSE, FALSE, 5); g_signal_connect(button, "clicked", G_CALLBACK(add_cb), window); button = gtk_button_new_with_label(_("Cancel")); gtk_widget_set_size_request(button, 100, 30); gtk_box_pack_end(GTK_BOX(action_area), button, FALSE, FALSE, 5); g_signal_connect(button, "clicked", G_CALLBACK(cancel_cb), window); }
int main (int argc, char **argv) { GtkWidget *window, *cellview, *mainbox; GtkWidget *combobox, *comboboxtext, *comboboxgrid; GtkWidget *tmp, *boom; GtkCellRenderer *renderer; GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; GdkRGBA color; GtkCellArea *area; gchar *text; gint i; gtk_init (&argc, &argv); if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); if (g_getenv ("LISTMODE")) { GtkCssProvider *provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, "* { -GtkComboBox-appears-as-list: true; }", -1, NULL); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_FALLBACK); } window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (window), 5); g_signal_connect (window, "destroy", gtk_main_quit, NULL); mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (window), mainbox); /* GtkCellView */ tmp = gtk_frame_new ("GtkCellView"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); cellview = gtk_cell_view_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview), renderer, FALSE); g_object_set (renderer, "icon-name", "dialog-warning", NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview), renderer, TRUE); g_object_set (renderer, "text", "la la la", NULL); gtk_container_add (GTK_CONTAINER (boom), cellview); /* GtkComboBox list */ tmp = gtk_frame_new ("GtkComboBox (list)"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); model = create_list_blaat (); combobox = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (boom), combobox); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "icon-name", 0, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, set_sensitive, NULL, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 1, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, set_sensitive, NULL, NULL); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox), is_separator, NULL, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0); /* GtkComboBox dynamic list */ tmp = gtk_frame_new ("GtkComboBox (dynamic list)"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); model = create_empty_list_blaat (); combobox = gtk_combo_box_new_with_model (model); g_signal_connect (combobox, "notify::popup-shown", G_CALLBACK (populate_list_blaat), combobox); g_object_unref (model); gtk_container_add (GTK_CONTAINER (boom), combobox); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "icon-name", 0, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, set_sensitive, NULL, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 1, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, set_sensitive, NULL, NULL); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox), is_separator, NULL, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0); /* GtkComboBox custom entry */ tmp = gtk_frame_new ("GtkComboBox (custom)"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); model = create_list_blaat (); combobox = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (boom), combobox); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "icon-name", 0, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, set_sensitive, NULL, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 1, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, set_sensitive, NULL, NULL); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox), is_separator, NULL, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0); tmp = gtk_cell_view_new (); gtk_widget_show (tmp); gtk_cell_view_set_model (GTK_CELL_VIEW (tmp), model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tmp), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tmp), renderer, "text", 1, NULL); color.red = 1.0; color.blue = 1.0; color.green = 0; color.alpha = 1.0; gtk_cell_view_set_background_rgba (GTK_CELL_VIEW (tmp), &color); displayed_row_changed (GTK_COMBO_BOX (combobox), GTK_CELL_VIEW (tmp)); g_signal_connect (combobox, "changed", G_CALLBACK (displayed_row_changed), tmp); gtk_container_add (GTK_CONTAINER (combobox), tmp); /* GtkComboBox tree */ tmp = gtk_frame_new ("GtkComboBox (tree)"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); model = create_tree_blaat (); combobox = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (boom), combobox); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "icon-name", 0, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, set_sensitive, NULL, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 1, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, set_sensitive, NULL, NULL); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox), is_separator, NULL, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0); #if 0 g_timeout_add (1000, (GSourceFunc) animation_timer, model); #endif /* GtkComboBox (grid mode) */ tmp = gtk_frame_new ("GtkComboBox (grid mode)"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); comboboxgrid = create_combo_box_grid_demo (); gtk_box_pack_start (GTK_BOX (boom), comboboxgrid, FALSE, FALSE, 0); /* GtkComboBoxEntry */ tmp = gtk_frame_new ("GtkComboBox with entry"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); comboboxtext = gtk_combo_box_text_new_with_entry (); setup_combo_entry (GTK_COMBO_BOX_TEXT (comboboxtext)); gtk_container_add (GTK_CONTAINER (boom), comboboxtext); /* Phylogenetic tree */ tmp = gtk_frame_new ("What are you ?"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); model = create_phylogenetic_tree (); combobox = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (boom), combobox); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0); /* Capitals */ tmp = gtk_frame_new ("Where are you ?"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); model = create_capital_tree (); combobox = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (boom), combobox); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox), renderer, capital_sensitive, NULL, NULL); path = gtk_tree_path_new_from_indices (0, 8, -1); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox), &iter); #if 1 gdk_threads_add_timeout (1000, (GSourceFunc) capital_animation, model); #endif /* Aligned Food */ tmp = gtk_frame_new ("Hungry ?"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); model = create_food_list (); combobox = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (boom), combobox); area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (combobox)); renderer = gtk_cell_renderer_text_new (); gtk_cell_area_add_with_properties (area, renderer, "align", TRUE, "expand", TRUE, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_area_add_with_properties (area, renderer, "align", TRUE, "expand", TRUE, NULL); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 1, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0); /* Ellipsizing growing combos */ tmp = gtk_frame_new ("Unconstrained Menu"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (boom), 5); gtk_container_add (GTK_CONTAINER (tmp), boom); model = create_list_long (); combobox = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (boom), combobox); renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", 0, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0); gtk_combo_box_set_popup_fixed_width (GTK_COMBO_BOX (combobox), FALSE); tmp = gtk_frame_new ("Looong"); gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0); combobox = gtk_combo_box_text_new (); for (i = 0; i < 200; i++) { text = g_strdup_printf ("Item %d", i); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combobox), text); g_free (text); } gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 53); gtk_container_add (GTK_CONTAINER (tmp), combobox); gtk_widget_show_all (window); gtk_main (); return 0; }
void ags_oscillator_init(AgsOscillator *oscillator) { GtkTable *table; GtkCellRenderer *cell_renderer; GtkListStore *model; GtkTreeIter iter; table = (GtkTable *) gtk_table_new(8, 2, FALSE); gtk_container_add((GtkContainer *) oscillator, (GtkWidget *) table); gtk_table_attach_defaults(table, (GtkWidget *) gtk_label_new("wave\0"), 0, 1, 0, 1); /* wave */ oscillator->wave = (GtkComboBox *) gtk_combo_box_text_new(); gtk_table_attach_defaults(table, (GtkWidget *) oscillator->wave, 1, 2, 0, 1); cell_renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(oscillator->wave), cell_renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(oscillator->wave), cell_renderer, "text\0", 0, NULL); model = gtk_list_store_new(1, G_TYPE_STRING); gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, 0, "sin\0", -1); /* gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, 0, "cos\0", -1); */ gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, 0, "sawtooth\0", -1); gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, 0, "square\0", -1); gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, 0, "triangle\0", -1); gtk_combo_box_set_model(oscillator->wave, GTK_TREE_MODEL(model)); gtk_combo_box_set_active(oscillator->wave, 0); /* other controls */ gtk_table_attach_defaults(table, (GtkWidget *) gtk_label_new("attack\0"), 2, 3, 0, 1); oscillator->attack = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, 100000.0, 1.0); oscillator->attack->adjustment->value = 0.0; gtk_table_attach_defaults(table, (GtkWidget *) oscillator->attack, 3, 4, 0, 1); gtk_table_attach_defaults(table, (GtkWidget *) gtk_label_new("length\0"), 4, 5, 0, 1); oscillator->frame_count = (GtkSpinButton *) gtk_spin_button_new_with_range(44100.0 / 27.5, 100000.0, 1.0); oscillator->frame_count->adjustment->value = 3200; gtk_table_attach_defaults(table, (GtkWidget *) oscillator->frame_count, 5, 6, 0, 1); gtk_table_attach_defaults(table, (GtkWidget *) gtk_label_new("phase\0"), 0, 1, 1, 2); oscillator->phase = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, 100000.0, 1.0); oscillator->phase->adjustment->value = 0.0; gtk_table_attach_defaults(table, (GtkWidget *) oscillator->phase, 1, 2, 1, 2); gtk_table_attach_defaults(table, (GtkWidget *) gtk_label_new("frequency\0"), 2, 3, 1, 2); oscillator->frequency = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, 100000.0, 1.0); oscillator->frequency->adjustment->value = 27.5; gtk_table_attach_defaults(table, (GtkWidget *) oscillator->frequency, 3, 4, 1, 2); gtk_table_attach_defaults(table, (GtkWidget *) gtk_label_new("volume\0"), 4, 5, 1, 2); oscillator->volume = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, 1.0, 0.1); oscillator->volume->adjustment->value = 0.2; gtk_table_attach_defaults(table, (GtkWidget *) oscillator->volume, 5, 6, 1, 2); }
/* construct widget above */ void gui_init(struct dt_imageio_module_storage_t *self) { self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t)); dt_storage_facebook_gui_data_t *ui = self->gui_data; ui->facebook_api = fb_api_init(); self->widget = gtk_vbox_new(FALSE, 0); //create labels ui->label_album_title = GTK_LABEL( gtk_label_new( _("title") ) ); ui->label_album_summary = GTK_LABEL( gtk_label_new( _("summary") ) ); ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy"))); ui->label_status = GTK_LABEL(gtk_label_new(NULL)); gtk_misc_set_alignment(GTK_MISC(ui->label_album_title), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label_album_summary), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(ui->label_album_privacy), 0.0, 0.5); //create entries GtkListStore *model_username = gtk_list_store_new (COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); //text, token, id ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username))); GtkCellRenderer *p_cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, "text", 0, NULL); ui->entry_album_title = GTK_ENTRY(gtk_entry_new()); ui->entry_album_summary = GTK_ENTRY(gtk_entry_new()); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title)); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary)); //retrieve saved accounts ui_refresh_users(ui); //////// album list ///////// GtkWidget *albumlist = gtk_hbox_new(FALSE, 0); GtkListStore *model_album = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); //name, id ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album))); p_cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, "text", 0, NULL); gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE); gtk_combo_box_set_row_separator_func(ui->comboBox_album,combobox_separator,ui->comboBox_album,NULL); gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0); ui->comboBox_privacy= GTK_COMBO_BOX(gtk_combo_box_new_text()); GtkListStore *list_store = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT); GtkTreeIter iter; gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1); gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1); gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store)); gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login"))); ui->connected = FALSE; //pack the ui ////the auth box GtkWidget *hbox_auth = gtk_hbox_new(FALSE,5); GtkWidget *vbox_auth_labels=gtk_vbox_new(FALSE,0); GtkWidget *vbox_auth_fields=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2); ////the album creation box ui->hbox_album = GTK_BOX(gtk_hbox_new(FALSE,5)); gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); //hide it by default GtkWidget *vbox_album_labels=gtk_vbox_new(FALSE,0); GtkWidget *vbox_album_fields=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_summary), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_summary), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_privacy), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->comboBox_privacy), TRUE, FALSE, 0); //connect buttons to signals g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox_username), "changed", G_CALLBACK(ui_combo_username_changed), (gpointer)ui); g_signal_connect(G_OBJECT(ui->comboBox_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui); g_object_unref(model_username); g_object_unref(model_album); g_object_unref(list_store); }