GtkWidget * do_popover (GtkWidget *do_widget) { static GtkWidget *window = NULL; GtkWidget *popover, *box, *widget; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 24); gtk_container_set_border_width (GTK_CONTAINER (box), 24); gtk_container_add (GTK_CONTAINER (window), box); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); widget = gtk_toggle_button_new_with_label ("Button"); popover = create_popover (widget, gtk_label_new ("This popover does not grab input"), GTK_POS_TOP); gtk_popover_set_modal (GTK_POPOVER (popover), FALSE); g_signal_connect (widget, "toggled", G_CALLBACK (toggle_changed_cb), popover); gtk_container_add (GTK_CONTAINER (box), widget); widget = gtk_entry_new (); popover = create_complex_popover (widget, GTK_POS_TOP); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget), GTK_ENTRY_ICON_PRIMARY, "edit-find"); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, "edit-clear"); g_signal_connect (widget, "icon-press", G_CALLBACK (entry_icon_press_cb), popover); g_signal_connect (widget, "size-allocate", G_CALLBACK (entry_size_allocate_cb), popover); gtk_container_add (GTK_CONTAINER (box), widget); widget = gtk_calendar_new (); g_signal_connect (widget, "day-selected", G_CALLBACK (day_selected_cb), NULL); gtk_container_add (GTK_CONTAINER (box), widget); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else { gtk_widget_destroy (window); window = NULL; } return window; }
void gtkhash_properties_list_check_digests(struct page_s *page) { const char *check = gtk_entry_get_text(page->entry_check); const char *icon = NULL; GtkTreeModel *model = gtkhash_properties_list_get_model(page); GtkTreeIter iter; if (*check && gtk_tree_model_get_iter_first(model, &iter)) { do { char *digest = NULL;; gtk_tree_model_get(model, &iter, COL_DIGEST, &digest, -1); if (g_ascii_strcasecmp(check, digest) == 0) { // FIXME: find a real alternative for GTK_STOCK_YES icon = "gtk-yes"; break; } g_free(digest); } while (gtk_tree_model_iter_next(model, &iter)); } gtk_entry_set_icon_from_icon_name(page->entry_check, GTK_ENTRY_ICON_SECONDARY, icon); }
static gboolean presence_chooser_flash_timeout_cb (EmpathyPresenceChooser *chooser) { EmpathyPresenceChooserPriv *priv; TpConnectionPresenceType state; static gboolean on = FALSE; GtkWidget *entry; priv = GET_PRIV (chooser); if (on) { state = priv->flash_state_1; } else { state = priv->flash_state_2; } entry = gtk_bin_get_child (GTK_BIN (chooser)); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, empathy_icon_name_for_presence (state)); on = !on; return TRUE; }
static void open_cb (GtkWidget *w, gpointer d) { GtkWidget *dlg, *cnt, *lbl, *entry; dlg = gtk_dialog_new_with_buttons (_("Open URI"), GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_default_size (GTK_WINDOW (dlg), 350, -1); cnt = gtk_dialog_get_content_area (GTK_DIALOG (dlg)); lbl = gtk_label_new (_("Enter URI or file name:")); gtk_label_set_xalign (GTK_LABEL (lbl), 0); gtk_widget_show (lbl); gtk_box_pack_start (GTK_BOX (cnt), lbl, TRUE, FALSE, 2); entry = gtk_entry_new (); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, "gtk-directory"); gtk_widget_show (entry); gtk_box_pack_start (GTK_BOX (cnt), entry, TRUE, FALSE, 2); g_signal_connect (G_OBJECT (entry), "icon-press", G_CALLBACK (select_file_cb), NULL); g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (do_open_cb), dlg); if (gtk_dialog_run (GTK_DIALOG (dlg)) == GTK_RESPONSE_ACCEPT) load_uri (gtk_entry_get_text (GTK_ENTRY (entry))); gtk_widget_destroy (dlg); }
void set_entry_generation_icon (GtkEntry *entry) { g_object_set (entry, "caps-lock-warning", FALSE, NULL); gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "system-run-symbolic"); gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, TRUE); }
void set_entry_validation_checkmark (GtkEntry *entry) { g_object_set (entry, "caps-lock-warning", FALSE, NULL); gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "object-select-symbolic"); gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, FALSE); }
/* * entry_check_content_mask: * @entry: the entry for which to check the mask * @user_data: user data set when the signal was connected * * Display an icon in the entry if the current text contains an invalid mask. */ static void entry_check_content_mask (GtkEntry *entry, gpointer user_data) { gchar *tmp = NULL; gchar *mask = NULL; g_return_if_fail (entry != NULL); mask = g_strdup (gtk_entry_get_text (entry)); if (et_str_empty (mask)) goto Bad_Mask; while (mask) { if ( (tmp=strrchr(mask,'%'))==NULL ) { /* There is no more code. */ /* No code in mask is accepted. */ goto Good_Mask; } if (strlen(tmp)>1 && (tmp[1]=='t' || tmp[1]=='a' || tmp[1]=='b' || tmp[1]=='y' || tmp[1]=='g' || tmp[1]=='n' || tmp[1]=='l' || tmp[1]=='c' || tmp[1]=='i')) { /* The code is valid. */ /* No separator is accepted. */ *(mask+strlen(mask)-strlen(tmp)) = '\0'; }else { goto Bad_Mask; } } Bad_Mask: g_free(mask); gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "emblem-unreadable"); gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY, _("Invalid scanner mask")); return; Good_Mask: g_free(mask); gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, NULL); return; }
static gboolean dict_check_word_timeout_cb (IdeEditorSpellWidget *self) { const gchar *word; g_autofree gchar *tooltip = NULL; gchar *icon_name; gboolean valid = FALSE; g_assert (IDE_IS_EDITOR_SPELL_WIDGET (self)); self->dict_check_word_state = CHECK_WORD_CHECKING; word = gtk_entry_get_text (GTK_ENTRY (self->dict_word_entry)); if (!ide_str_empty0 (word)) { if (ide_editor_spell_dict_personal_contains (self->dict, word)) gtk_widget_set_tooltip_text (self->dict_word_entry, _("This word is already in the personal dictionary")); else if (gspell_checker_check_word (self->checker, word, -1, NULL)) { tooltip = g_strdup_printf (_("This word is already in the %s dictionary"), gspell_language_get_name (self->spellchecker_language)); gtk_widget_set_tooltip_text (self->dict_word_entry, tooltip); } else { valid = TRUE; gtk_widget_set_tooltip_text (self->dict_word_entry, NULL); } icon_name = valid ? "" : "dialog-warning-symbolic"; } else icon_name = ""; gtk_widget_set_sensitive (GTK_WIDGET (self->dict_add_button), valid); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->dict_word_entry), GTK_ENTRY_ICON_SECONDARY, icon_name); self->dict_check_word_state = CHECK_WORD_NONE; self->dict_check_word_timeout_id = 0; if (self->is_dict_check_word_invalid == TRUE) { self->dict_check_word_timeout_id = g_timeout_add_full (G_PRIORITY_DEFAULT, DICT_CHECK_WORD_INTERVAL_MIN, (GSourceFunc)dict_check_word_timeout_cb, self, NULL); self->dict_check_word_state = CHECK_WORD_IDLE; self->is_dict_check_word_invalid = FALSE; } return G_SOURCE_REMOVE; }
static gboolean validate_entry (GtkEntry *entry, const gchar *str) { gint argcp = 0; gchar **argvp; gboolean ret = FALSE; if (g_shell_parse_argv (str, &argcp, &argvp, NULL)) { if (argcp > 0) { gchar *path_exec = g_find_program_in_path (argvp[0]); if (path_exec) { ret = TRUE; } else { if (!g_file_test (str, G_FILE_TEST_IS_DIR) && g_file_test (str, G_FILE_TEST_IS_EXECUTABLE)) { ret = TRUE; } } g_free (path_exec); } } g_strfreev (argvp); if (ret) { gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "ok"); gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY, _("Valid")); } else { gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "stop"); gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY, _("Not a valid executable. Spaces in the file path must be escaped with backslash (\\).")); } return ret; }
static void presence_chooser_set_favorite_icon (EmpathyPresenceChooser *self) { GtkWidget *entry; PresenceChooserEntryType type; entry = gtk_bin_get_child (GTK_BIN (self)); type = presence_chooser_get_entry_type (self); if (type == ENTRY_TYPE_CUSTOM || type == ENTRY_TYPE_SAVED) { if (presence_chooser_is_preset (self)) { /* saved entries can be removed from the list */ gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, "empathy-starred"); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, _("Click to remove this status as a favorite")); } else { /* custom entries can be favorited */ gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, "empathy-unstarred"); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, _("Click to make this status a favorite")); } } else { /* built-in entries cannot be favorited */ gtk_entry_set_icon_from_stock (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, NULL); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, NULL); } }
void _gtk_entry_use_as_password_entry (GtkEntry *entry) { gtk_entry_set_visibility (entry, FALSE); gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "security-medium-symbolic"); gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, TRUE); gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY, _("Change password visibility")); g_signal_connect (entry, "icon-press", G_CALLBACK (password_entry_icon_press_cb), NULL); }
static void custom_command_entry_changed_cb (GtkEntry *entry) { const char *command; gs_free_error GError *error = NULL; command = gtk_entry_get_text (entry); if (command[0] == '\0' || g_shell_parse_argv (command, NULL, NULL, &error)) { gtk_entry_set_icon_from_icon_name (entry, GTK_PACK_END, NULL); } else { gs_free char *tooltip; gtk_entry_set_icon_from_icon_name (entry, GTK_PACK_END, "dialog-warning"); tooltip = g_strdup_printf (_("Error parsing command: %s"), error->message); gtk_entry_set_icon_tooltip_text (entry, GTK_PACK_END, tooltip); } }
static gboolean check_word_timeout_cb (IdeEditorSpellWidget *self) { const gchar *word; g_autoptr(GError) error = NULL; gchar *icon_name; gboolean ret = TRUE; g_assert (IDE_IS_EDITOR_SPELL_WIDGET (self)); self->check_word_state = CHECK_WORD_CHECKING; word = gtk_entry_get_text (self->word_entry); if (!ide_str_empty0 (word)) { /* FIXME: suggestions can give a multiple-words suggestion * that failed to the checkword test, ex: auto tools */ ret = gspell_checker_check_word (self->checker, word, -1, &error); if (error != NULL) { g_message ("check error:%s\n", error->message); } icon_name = ret ? "" : "dialog-warning-symbolic"; } else icon_name = ""; gtk_entry_set_icon_from_icon_name (self->word_entry, GTK_ENTRY_ICON_SECONDARY, icon_name); self->check_word_state = CHECK_WORD_NONE; self->is_word_entry_valid = ret; self->check_word_timeout_id = 0; if (self->is_check_word_invalid == TRUE) { self->check_word_timeout_id = g_timeout_add_full (G_PRIORITY_DEFAULT, CHECK_WORD_INTERVAL_MIN, (GSourceFunc)check_word_timeout_cb, self, NULL); self->check_word_state = CHECK_WORD_IDLE; self->is_check_word_invalid = FALSE; } return G_SOURCE_REMOVE; }
static void custom_entry_changed_cb (GtkEditable *entry, gpointer user_data) { NemoMimeApplicationChooser *chooser = user_data; const gchar *entry_text = gtk_entry_get_text (GTK_ENTRY (entry)); gboolean empty = g_strcmp0 (entry_text, "") == 0; if (!empty && validate_entry (GTK_ENTRY (entry), entry_text)) { GAppInfo *default_app; gchar *cl = g_strdup_printf ("%s", entry_text); GAppInfo *info = g_app_info_create_from_commandline (cl, get_nice_name (cl), G_APP_INFO_CREATE_NONE, NULL); default_app = g_app_info_get_default_for_type (chooser->details->content_type, FALSE); gtk_widget_set_sensitive (chooser->details->set_as_default_button, !g_app_info_equal (info, default_app)); gtk_widget_set_sensitive (chooser->details->add_button, app_info_can_add (info, chooser->details->content_type)); g_object_unref (default_app); if (chooser->details->custom_info != NULL) { g_object_unref (chooser->details->custom_info); chooser->details->custom_info = NULL; } chooser->details->custom_info = info; } else { if (chooser->details->custom_info != NULL) { g_object_unref (chooser->details->custom_info); chooser->details->custom_info = NULL; } if (empty) { gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, NULL); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, NULL); } gtk_widget_set_sensitive (chooser->details->set_as_default_button, FALSE); gtk_widget_set_sensitive (chooser->details->add_button, FALSE); } }
static void change_password_storage_icon (GtkWidget *passwd_entry, MenuItem item) { const char *old_pwd; gboolean ask_mode; g_return_if_fail (item >= 0 && item <= ITEM_STORAGE_MAX); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (passwd_entry), GTK_ENTRY_ICON_SECONDARY, icon_name_table[item]); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (passwd_entry), GTK_ENTRY_ICON_SECONDARY, gettext (icon_desc_table[item])); /* We want to make entry insensitive when ITEM_STORAGE_ASK is selected * Unfortunately, making GtkEntry insensitive will also make the icon * insensitive, which prevents user from reverting the action. * Let's workaround that by disabling focus for entry instead of * sensitivity change. */ ask_mode = !!g_object_get_data (G_OBJECT (passwd_entry), ASK_MODE_TAG); if ( (item == ITEM_STORAGE_ASK && !ask_mode) || item == ITEM_STORAGE_UNUSED) { /* Store the old password */ old_pwd = gtk_entry_get_text (GTK_ENTRY (passwd_entry)); if (old_pwd && *old_pwd) g_object_set_data_full (G_OBJECT (passwd_entry), "password-old", g_strdup (old_pwd), g_free_str0); gtk_entry_set_text (GTK_ENTRY (passwd_entry), ""); if (gtk_widget_is_focus (passwd_entry)) gtk_widget_child_focus ((gtk_widget_get_toplevel (passwd_entry)), GTK_DIR_TAB_BACKWARD); gtk_widget_set_can_focus (passwd_entry, FALSE); } else { /* Set the old password to the entry */ old_pwd = g_object_get_data (G_OBJECT (passwd_entry), "password-old"); if (old_pwd && *old_pwd) gtk_entry_set_text (GTK_ENTRY (passwd_entry), old_pwd); g_object_set_data (G_OBJECT (passwd_entry), "password-old", NULL); if (!gtk_widget_get_can_focus (passwd_entry)) { gtk_widget_set_can_focus (passwd_entry, TRUE); gtk_widget_grab_focus (passwd_entry); } } }
static void presence_chooser_flash_stop (EmpathyPresenceChooser *chooser, TpConnectionPresenceType state) { EmpathyPresenceChooserPriv *priv = GET_PRIV (chooser); GtkWidget *entry; if (priv->flash_timeout_id) { g_source_remove (priv->flash_timeout_id); priv->flash_timeout_id = 0; } entry = gtk_bin_get_child (GTK_BIN (chooser)); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, empathy_icon_name_for_presence (state)); }
static void xmr_search_box_init(XmrSearchBox *box) { XmrSearchBoxPrivate *priv; GtkWidget *vbox; priv = box->priv = G_TYPE_INSTANCE_GET_PRIVATE(box, XMR_TYPE_SEARCH_BOX, XmrSearchBoxPrivate); priv->parent = NULL; priv->need_to_show = FALSE; priv->thread = NULL; priv->chooser = XMR_CHOOSER(xmr_chooser_new(_("Artist Radio"), GTK_ORIENTATION_VERTICAL)); priv->event_queue = g_async_queue_new(); priv->event_idle_id = 0; priv->progress_idle_id = 0; vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); gtk_container_add(GTK_CONTAINER(box), vbox); priv->entry_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(vbox), priv->entry_box, TRUE, TRUE, 0); gtk_entry_set_icon_from_icon_name(GTK_ENTRY(priv->entry_box), GTK_ENTRY_ICON_SECONDARY, "edit-find"); gtk_entry_set_placeholder_text(GTK_ENTRY(priv->entry_box), _("Enter artist name...")); gtk_window_set_skip_taskbar_hint(GTK_WINDOW(box), TRUE); gtk_window_set_skip_pager_hint(GTK_WINDOW(box), TRUE); gtk_window_set_title(GTK_WINDOW(box), _("Search Artist Radio")); gtk_widget_set_size_request(GTK_WIDGET(box), 350, 45); gtk_window_set_decorated(GTK_WINDOW(priv->chooser), FALSE); gtk_window_set_transient_for(GTK_WINDOW(priv->chooser), GTK_WINDOW(box)); gtk_window_set_resizable(GTK_WINDOW(priv->chooser), FALSE); gtk_widget_set_size_request(GTK_WIDGET(priv->chooser), 350, 200); xmr_chooser_set_hide_on_clicked(priv->chooser, FALSE); g_signal_connect(box, "delete-event", G_CALLBACK(on_delete), NULL); g_signal_connect(box, "key-release-event", G_CALLBACK(on_key_release), NULL); g_signal_connect(priv->entry_box, "activate", G_CALLBACK(on_search_box_activate), box); g_signal_connect(priv->chooser, "widget-selected", G_CALLBACK(on_artist_clicked), box); gtk_window_set_position(GTK_WINDOW(box), GTK_WIN_POS_CENTER); gtk_widget_show_all(vbox); }
void set_entry_validation_error (GtkEntry *entry, const gchar *text) { g_object_set (entry, "caps-lock-warning", FALSE, NULL); gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_SECONDARY, "dialog-warning-symbolic"); gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, TRUE); g_signal_connect (entry, "icon-release", G_CALLBACK (icon_released), FALSE); g_signal_connect (entry, "query-tooltip", G_CALLBACK (query_tooltip), NULL); g_object_set (entry, "has-tooltip", TRUE, NULL); gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY, text); }
static void gimp_combo_tag_entry_init (GimpComboTagEntry *entry) { entry->popup = NULL; entry->normal_item_attr = NULL; entry->selected_item_attr = NULL; entry->insensitive_item_attr = NULL; gtk_widget_add_events (GTK_WIDGET (entry), GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, "go-down"); g_signal_connect (entry, "icon-press", G_CALLBACK (gimp_combo_tag_entry_icon_press), NULL); }
static void rejilla_project_name_icon_update (RejillaProjectName *self, RejillaTrackDataCfg *track) { GIcon *icon; icon = rejilla_track_data_cfg_get_icon (track); if (!icon) { gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self), GTK_ENTRY_ICON_PRIMARY, "media-optical"); return; } gtk_entry_set_icon_from_gicon (GTK_ENTRY (self), GTK_ENTRY_ICON_PRIMARY, icon); g_object_unref (icon); }
static void ui_set_custom_state (EmpathyPresenceChooser *self, TpConnectionPresenceType state, const char *status) { EmpathyPresenceChooserPriv *priv = GET_PRIV (self); GtkWidget *entry; const char *icon_name; entry = gtk_bin_get_child (GTK_BIN (self)); priv->block_set_editing++; priv->block_changed++; icon_name = empathy_icon_name_for_presence (state); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, icon_name); gtk_entry_set_text (GTK_ENTRY (entry), status == NULL ? "" : status); presence_chooser_set_favorite_icon (self); priv->block_changed--; priv->block_set_editing--; }
static GtkWidget* pocketvox_setup_get_pocketsphinx_grid(PocketvoxSetup *setup) { setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup, TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate); PocketvoxSetupPrivate *priv = setup->priv; GtkWidget *grid = gtk_grid_new(); GtkWidget *entry_lm = gtk_entry_new(); GtkWidget *entry_acoustic = gtk_entry_new(); GtkWidget *entry_dictionnary = gtk_entry_new(); GtkWidget *et_lm = gtk_label_new(""); GtkWidget *et_dict = gtk_label_new(""); GtkWidget *et_hmm = gtk_label_new(""); gtk_label_set_markup(GTK_LABEL(et_lm), _("<b> Language model </b>")); gtk_label_set_markup(GTK_LABEL(et_hmm), _("<b> Acoustic model </b>")); gtk_label_set_markup(GTK_LABEL(et_dict),_("<b> Dictionnary </b>")); gtk_misc_set_alignment(GTK_MISC(et_lm), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(et_dict), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(et_hmm), 0.0, 0.5); gtk_widget_set_hexpand(et_lm, TRUE); gtk_widget_set_hexpand(et_dict, TRUE); gtk_widget_set_hexpand(et_hmm, TRUE); gtk_widget_set_hexpand(entry_lm, TRUE); gtk_widget_set_hexpand(entry_acoustic, TRUE); gtk_widget_set_hexpand(entry_dictionnary, TRUE); gtk_widget_set_tooltip_text(entry_lm, _("Set the pocketsphinx's language model")); gtk_widget_set_tooltip_text(entry_acoustic, _("Set the pocketsphinx's acoustic model")); gtk_widget_set_tooltip_text(entry_dictionnary, _("Set the pocketsphinx's dictionnary")); gtk_widget_set_name(entry_lm, "lm"); gtk_widget_set_name(entry_dictionnary, "dict"); gtk_widget_set_name(entry_acoustic, "hmm"); gtk_entry_set_icon_from_icon_name (GTK_ENTRY(entry_lm), GTK_ENTRY_ICON_SECONDARY, "gtk-search"); g_signal_connect(entry_lm, "icon-press", G_CALLBACK(pocketvox_setup_search_dict), NULL); gtk_entry_set_icon_from_icon_name (GTK_ENTRY(entry_dictionnary), GTK_ENTRY_ICON_SECONDARY, "gtk-search"); g_signal_connect(entry_dictionnary, "icon-press", G_CALLBACK(pocketvox_setup_search_dict), NULL); gtk_entry_set_icon_from_icon_name (GTK_ENTRY(entry_acoustic), GTK_ENTRY_ICON_SECONDARY, "gtk-search"); g_signal_connect(entry_acoustic, "icon-press", G_CALLBACK(pocketvox_setup_search_dict), NULL); g_settings_bind(priv->settings, "lm", entry_lm, "text", G_SETTINGS_BIND_DEFAULT); g_settings_bind(priv->settings, "hmm", entry_acoustic, "text", G_SETTINGS_BIND_DEFAULT); g_settings_bind(priv->settings, "dict", entry_dictionnary, "text", G_SETTINGS_BIND_DEFAULT); gtk_grid_attach(GTK_GRID(grid), et_lm, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(grid), entry_lm, 0, 1, 2, 1); gtk_grid_attach(GTK_GRID(grid), et_hmm, 0, 2, 1, 1); gtk_grid_attach(GTK_GRID(grid), entry_acoustic, 0, 3, 2, 1); gtk_grid_attach(GTK_GRID(grid), et_dict, 0, 4, 1, 1); gtk_grid_attach(GTK_GRID(grid), entry_dictionnary, 0, 5, 2, 1); gtk_widget_show_all(grid); return grid; }
static void build_tab_view(AccountGeneralTab *view) { g_return_if_fail(IS_ACCOUNT_GENERAL_TAB(view)); AccountGeneralTabPrivate *priv = ACCOUNT_GENERAL_TAB_GET_PRIVATE(view); int grid_row = 0; GtkWidget *label = NULL; /* separate pointers for each so that we reference them in the account changed callback */ GtkWidget *entry_alias = NULL; GtkWidget *entry_username = NULL; GtkWidget *entry_hostname = NULL; GtkWidget *entry_password = NULL; GtkWidget *entry_proxy = NULL; GtkWidget *entry_voicemail = NULL; GtkWidget *checkbutton_autoanswer = NULL; GtkWidget *checkbutton_upnp = NULL; GtkWidget *radiobutton_dtmf_rtp = NULL; GtkWidget *radiobutton_dtmf_sip = NULL; /* build account grid */ /* check if its ip2ip account */ const QByteArray& alias = priv->account->alias().toLocal8Bit(); if (strcmp(alias.constData(), "IP2IP") == 0) { label = gtk_label_new("IP2IP"); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_account), label, 0, grid_row, 1, 1); ++grid_row; } else { /* account alias */ label = gtk_label_new(_("Alias")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_account), label, 0, grid_row, 1, 1); entry_alias = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(entry_alias), alias.constData()); gtk_widget_set_halign(entry_alias, GTK_ALIGN_START); g_signal_connect(entry_alias, "changed", G_CALLBACK(account_alias_changed), view); gtk_grid_attach(GTK_GRID(priv->grid_account), entry_alias, 1, grid_row, 1, 1); ++grid_row; /* account type */ label = gtk_label_new(_("Type")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_account), label, 0, grid_row, 1, 1); label = gtk_label_new(""); gtk_widget_set_halign(label, GTK_ALIGN_START); switch (priv->account->protocol()) { case Account::Protocol::SIP: gtk_label_set_text(GTK_LABEL(label), "SIP"); break; case Account::Protocol::IAX: gtk_label_set_text(GTK_LABEL(label), "IAX"); break; case Account::Protocol::RING: gtk_label_set_text(GTK_LABEL(label), "RING"); break; case Account::Protocol::COUNT__: break; } gtk_grid_attach(GTK_GRID(priv->grid_account), label, 1, grid_row, 1, 1); ++grid_row; } if (priv->account->protocol() == Account::Protocol::RING) { label = gtk_label_new("RingID"); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_account), label, 0, grid_row, 1, 1); entry_username = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entry_username), _("auto-generating...")); gtk_entry_set_text(GTK_ENTRY(entry_username), priv->account->username().toLocal8Bit().constData()); g_object_set(G_OBJECT(entry_username), "editable", FALSE, NULL); g_object_set(G_OBJECT(entry_username), "max-width-chars", 50, NULL); gtk_widget_override_font(entry_username, pango_font_description_from_string("monospace")); gtk_entry_set_alignment(GTK_ENTRY(entry_username), 0.5); gtk_grid_attach(GTK_GRID(priv->grid_account), entry_username, 1, grid_row, 1, 1); ++grid_row; } gtk_widget_show_all(priv->grid_account); /* build parameters grid */ grid_row = 0; if (strcmp(alias.constData(), "IP2IP") != 0) { if (priv->account->protocol() != Account::Protocol::RING) { /* SIP and IAX have the same params */ /* host name */ label = gtk_label_new(_("Hostname")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1); entry_hostname = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(entry_hostname), priv->account->hostname().toLocal8Bit().constData()); g_signal_connect(entry_hostname, "changed", G_CALLBACK(account_hostname_changed), view); gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_hostname, 1, grid_row, 1, 1); ++grid_row; /* user name */ label = gtk_label_new(_("Username")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1); entry_username = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(entry_username), priv->account->username().toLocal8Bit().constData()); g_signal_connect(entry_username, "changed", G_CALLBACK(account_username_changed), view); gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_username, 1, grid_row, 1, 1); ++grid_row; /* password */ label = gtk_label_new(_("Password")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1); entry_password = gtk_entry_new(); gtk_entry_set_input_purpose(GTK_ENTRY(entry_password), GTK_INPUT_PURPOSE_PASSWORD); gtk_entry_set_icon_from_icon_name(GTK_ENTRY(entry_password), GTK_ENTRY_ICON_PRIMARY, "dialog-password"); gtk_entry_set_visibility(GTK_ENTRY(entry_password), FALSE); gtk_entry_set_text(GTK_ENTRY(entry_password), priv->account->password().toLocal8Bit().constData()); g_signal_connect(entry_password, "changed", G_CALLBACK(account_password_changed), view); gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_password, 1, grid_row, 1, 1); ++grid_row; /* show password */ GtkWidget *checkbutton = gtk_check_button_new_with_label(_("Show password")); gtk_grid_attach(GTK_GRID(priv->grid_parameters), checkbutton, 1, grid_row, 1, 1); g_signal_connect(checkbutton, "toggled", G_CALLBACK(show_password), entry_password); ++grid_row; /* proxy */ label = gtk_label_new(_("Proxy")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1); entry_proxy = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(entry_proxy), priv->account->proxy().toLocal8Bit().constData()); g_signal_connect(entry_proxy, "changed", G_CALLBACK(account_proxy_changed), view); gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_proxy, 1, grid_row, 1, 1); ++grid_row; /* voicemail number */ label = gtk_label_new(_("Voicemail number")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1); entry_voicemail = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(entry_voicemail), priv->account->mailbox().toLocal8Bit().constData()); g_signal_connect(entry_voicemail, "changed", G_CALLBACK(account_mailbox_changed), view); gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_voicemail, 1, grid_row, 1, 1); ++grid_row; } else { /* RING accoutn */ /* bootstrap */ label = gtk_label_new(C_("The DHT bootstrap server url", "Bootstrap")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1); entry_hostname = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(entry_hostname), priv->account->hostname().toLocal8Bit().constData()); g_signal_connect(entry_hostname, "changed", G_CALLBACK(account_hostname_changed), view); gtk_grid_attach(GTK_GRID(priv->grid_parameters), entry_hostname, 1, grid_row, 1, 1); ++grid_row; } } /* auto answer */ checkbutton_autoanswer = gtk_check_button_new_with_label(_("Auto-answer calls")); gtk_widget_set_halign(checkbutton_autoanswer, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), checkbutton_autoanswer, 0, grid_row, 1, 1); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_autoanswer), priv->account->isAutoAnswer()); g_signal_connect(checkbutton_autoanswer, "toggled", G_CALLBACK(auto_answer), view); ++grid_row; /* upnp */ checkbutton_upnp = gtk_check_button_new_with_label(_("UPnP enabled")); gtk_widget_set_halign(checkbutton_upnp, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), checkbutton_upnp, 0, grid_row, 1, 1); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_upnp), priv->account->isUpnpEnabled()); g_signal_connect(checkbutton_upnp, "toggled", G_CALLBACK(upnp_enabled), view); ++grid_row; /* DTMF tone type */ label = gtk_label_new(_("DTMF tone type:")); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(priv->grid_parameters), label, 0, grid_row, 1, 1); GtkWidget *dtmf_box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout(GTK_BUTTON_BOX(dtmf_box), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(dtmf_box), 10); radiobutton_dtmf_rtp = gtk_radio_button_new_with_label(NULL, "RTP"); radiobutton_dtmf_sip = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(radiobutton_dtmf_rtp), "SIP"); gtk_toggle_button_set_active( priv->account->DTMFType() == DtmfType::OverRtp ? GTK_TOGGLE_BUTTON(radiobutton_dtmf_rtp) : GTK_TOGGLE_BUTTON(radiobutton_dtmf_sip), TRUE); g_signal_connect(radiobutton_dtmf_rtp, "toggled", G_CALLBACK(dtmf_set_rtp), view); gtk_box_pack_start(GTK_BOX(dtmf_box), radiobutton_dtmf_rtp, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(dtmf_box), radiobutton_dtmf_sip, FALSE, TRUE, 0); gtk_grid_attach(GTK_GRID(priv->grid_parameters), dtmf_box, 1, grid_row, 1, 1); ++grid_row; /* update account parameters if model is updated */ priv->account_updated = QObject::connect( priv->account, &Account::changed, [=] () { if (strcmp(alias.constData(), "IP2IP") != 0) { gtk_entry_set_text(GTK_ENTRY(entry_alias), priv->account->alias().toLocal8Bit().constData()); gtk_entry_set_text(GTK_ENTRY(entry_username), priv->account->username().toLocal8Bit().constData()); gtk_entry_set_text(GTK_ENTRY(entry_hostname), priv->account->hostname().toLocal8Bit().constData()); if (priv->account->protocol() != Account::Protocol::RING) { gtk_entry_set_text(GTK_ENTRY(entry_password), priv->account->password().toLocal8Bit().constData()); gtk_entry_set_text(GTK_ENTRY(entry_proxy), priv->account->proxy().toLocal8Bit().constData()); gtk_entry_set_text(GTK_ENTRY(entry_voicemail), priv->account->mailbox().toLocal8Bit().constData()); } } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_autoanswer), priv->account->isAutoAnswer()); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_upnp), priv->account->isUpnpEnabled()); gtk_toggle_button_set_active( priv->account->DTMFType() == DtmfType::OverRtp ? GTK_TOGGLE_BUTTON(radiobutton_dtmf_rtp) : GTK_TOGGLE_BUTTON(radiobutton_dtmf_sip), TRUE); } ); gtk_widget_show_all(priv->grid_parameters); }
static void ugtk_download_form_init_page1 (UgtkDownloadForm* dform, UgtkProxyForm* proxy) { GtkWidget* widget; GtkGrid* top_grid; GtkGrid* grid; GtkWidget* frame; GtkBox* top_vbox; GtkWidget* vbox; GtkWidget* hbox; dform->page1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); top_vbox = (GtkBox*) dform->page1; gtk_container_set_border_width (GTK_CONTAINER (top_vbox), 2); top_grid = (GtkGrid*) gtk_grid_new (); gtk_box_pack_start (top_vbox, (GtkWidget*) top_grid, FALSE, FALSE, 0); // URL - entry widget = gtk_entry_new (); // gtk_entry_set_width_chars (GTK_ENTRY (widget), 20); // remove for GTK+ 3.12 gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin-left", 1, "margin-right", 1, NULL); g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL); g_object_set (widget, "hexpand", TRUE, NULL); gtk_grid_attach (top_grid, widget, 1, 0, 2, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_uri_entry_changed), dform); dform->uri_entry = widget; // URL - label widget = gtk_label_new_with_mnemonic (_("_URI:")); gtk_label_set_mnemonic_widget (GTK_LABEL(widget), dform->uri_entry); g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL); g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL); gtk_grid_attach (top_grid, widget, 0, 0, 1, 1); dform->uri_label = widget; // Mirrors - entry widget = gtk_entry_new (); // gtk_entry_set_width_chars (GTK_ENTRY (widget), 20); // remove for GTK+ 3.12 gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin-left", 1, "margin-right", 1, NULL); g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL); g_object_set (widget, "hexpand", TRUE, NULL); gtk_grid_attach (top_grid, widget, 1, 1, 2, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_uri_entry_changed), dform); dform->mirrors_entry = widget; // Mirrors - label widget = gtk_label_new_with_mnemonic (_("Mirrors:")); gtk_label_set_mnemonic_widget (GTK_LABEL(widget), dform->mirrors_entry); g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL); g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL); gtk_grid_attach (top_grid, widget, 0, 1, 1, 1); dform->mirrors_label = widget; // File - entry widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (top_grid, widget, 1, 2, 2, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_entry_changed), dform); dform->file_entry = widget; // File - label widget = gtk_label_new_with_mnemonic (_("File:")); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->file_entry); g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (top_grid, widget, 0, 2, 1, 1); dform->file_label = widget; // Folder - combo entry + icon dform->folder_combo = gtk_combo_box_text_new_with_entry (); dform->folder_entry = gtk_bin_get_child (GTK_BIN (dform->folder_combo)); widget = dform->folder_entry; gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); #if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, "folder"); #else gtk_entry_set_icon_from_stock (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_DIRECTORY); #endif gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, _("Select Folder")); g_object_set (dform->folder_combo, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (top_grid, dform->folder_combo, 1, 3, 1, 1); g_signal_connect (widget, "icon-release", G_CALLBACK (on_select_folder), dform); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_entry_changed), dform); // Folder - label widget = gtk_label_new_with_mnemonic (_("_Folder:")); gtk_label_set_mnemonic_widget(GTK_LABEL (widget), dform->folder_combo); g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (top_grid, widget, 0, 3, 1, 1); // Referrer - entry widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (top_grid, widget, 1, 4, 2, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_http_entry_changed), dform); dform->referrer_entry = widget; // Referrer - label widget = gtk_label_new_with_mnemonic (_("Referrer:")); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->referrer_entry); g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (top_grid, widget, 0, 4, 1, 1); // dform->referrer_label = widget; // ---------------------------------------------------- // Connections // HBox for Connections hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (top_vbox, hbox, FALSE, FALSE, 2); // connections - label // widget = gtk_label_new (_("connections")); // gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2); // dform->label_connections = widget; // connections - spin button widget = gtk_spin_button_new_with_range (1.0, 16.0, 1.0); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); // gtk_entry_set_width_chars (GTK_ENTRY (widget), 3); // remove for GTK+ 3.12 gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2); dform->spin_connections = widget; // "Max Connections:" - title label widget = gtk_label_new_with_mnemonic (_("_Max Connections:")); gtk_label_set_mnemonic_widget ((GtkLabel*)widget, dform->spin_connections); gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2); dform->title_connections = widget; // ---------------------------------------------------- // HBox for "Status" and "Login" hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (top_vbox, hbox, FALSE, FALSE, 2); // ---------------------------------------------------- // frame for Status (start mode) frame = gtk_frame_new (_("Status")); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); dform->radio_runnable = gtk_radio_button_new_with_mnemonic (NULL, _("_Runnable")); dform->radio_pause = gtk_radio_button_new_with_mnemonic_from_widget ( (GtkRadioButton*)dform->radio_runnable, _("P_ause")); gtk_box_pack_start (GTK_BOX (vbox), dform->radio_runnable, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), dform->radio_pause, FALSE, FALSE, 0); // ---------------------------------------------------- // frame for login frame = gtk_frame_new (_("Login")); grid = (GtkGrid*) gtk_grid_new (); gtk_container_set_border_width (GTK_CONTAINER (grid), 2); gtk_container_add (GTK_CONTAINER (frame), (GtkWidget*) grid); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 2); // User - entry widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 1, 0, 1, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_entry_changed), dform); dform->username_entry = widget; // User - label widget = gtk_label_new (_("User:"******"margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 0, 1, 1); // dform->username_label = widget; // Password - entry widget = gtk_entry_new (); gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 1, 1, 1, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_entry_changed), dform); dform->password_entry = widget; // Password - label widget = gtk_label_new (_("Password:"******"margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 1, 1, 1); // dform->password_label = widget; // ---------------------------------------------------- // proxy // ug_proxy_widget_init (&dform->proxy_dform); if (proxy) { widget = proxy->self; gtk_box_pack_start (top_vbox, widget, FALSE, FALSE, 2); } }
static void ugtk_download_form_init_page2 (UgtkDownloadForm* dform) { GtkWidget* widget; GtkGrid* grid; dform->page2 = gtk_grid_new (); grid = (GtkGrid*) dform->page2; gtk_container_set_border_width (GTK_CONTAINER (grid), 2); // label - cookie file widget = gtk_label_new (_("Cookie file:")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 0, 1, 1); dform->cookie_label = widget; // entry - cookie file widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); #if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, "text-x-generic"); #else gtk_entry_set_icon_from_stock (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FILE); #endif gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, _("Select Cookie File")); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 1, 0, 3, 1); g_signal_connect (widget, "icon-release", G_CALLBACK (on_select_cookie), dform); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_http_entry_changed), dform); dform->cookie_entry = widget; // label - post file widget = gtk_label_new (_("Post file:")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 1, 1, 1); dform->post_label = widget; // entry - post file widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); #if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, "text-x-generic"); #else gtk_entry_set_icon_from_stock (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FILE); #endif gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY, _("Select Post File")); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 1, 1, 3, 1); g_signal_connect (widget, "icon-release", G_CALLBACK (on_select_post), dform); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_http_entry_changed), dform); dform->post_entry = widget; // label - user agent widget = gtk_label_new (_("User Agent:")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 2, 1, 1); dform->agent_label = widget; // entry - user agent widget = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 1, 2, 3, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_http_entry_changed), dform); dform->agent_entry = widget; // Retry limit - label widget = gtk_label_new_with_mnemonic (_("Retry _limit:")); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->spin_retry); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 3, 2, 1); // Retry limit - spin button widget = gtk_spin_button_new_with_range (0.0, 99.0, 1.0); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 2, 3, 1, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_spin_changed), dform); dform->spin_retry = widget; // counts - label widget = gtk_label_new (_("counts")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 3, 3, 1, 1); // Retry delay - label widget = gtk_label_new_with_mnemonic (_("Retry _delay:")); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->spin_delay); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 4, 2, 1); // Retry delay - spin button widget = gtk_spin_button_new_with_range (0.0, 600.0, 1.0); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 2, 4, 1, 1); g_signal_connect (GTK_EDITABLE (widget), "changed", G_CALLBACK (on_spin_changed), dform); dform->spin_delay = widget; // seconds - label widget = gtk_label_new (_("seconds")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 3, 4, 1, 1); // label - Max upload speed widget = gtk_label_new (_("Max upload speed:")); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 5, 2, 1); // spin - Max upload speed widget = gtk_spin_button_new_with_range (0, 99999999, 1); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (widget), 8); g_object_set (widget, "margin", 1, NULL); gtk_grid_attach (grid, widget, 2, 5, 1, 1); dform->spin_upload_speed = (GtkSpinButton*) widget; // label - "KiB/s" widget = gtk_label_new (_("KiB/s")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin", 2, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 3, 5, 1, 1); // label - Max download speed widget = gtk_label_new (_("Max download speed:")); g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL); g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL); gtk_grid_attach (grid, widget, 0, 6, 2, 1); // spin - Max download speed widget = gtk_spin_button_new_with_range (0, 99999999, 1); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (widget), 8); g_object_set (widget, "margin", 1, NULL); gtk_grid_attach (grid, widget, 2, 6, 1, 1); dform->spin_download_speed = (GtkSpinButton*) widget; // label - "KiB/s" widget = gtk_label_new (_("KiB/s")); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center g_object_set (widget, "margin", 2, "hexpand", TRUE, NULL); gtk_grid_attach (grid, widget, 3, 6, 1, 1); // Retrieve timestamp widget = gtk_check_button_new_with_label (_("Retrieve timestamp")); gtk_grid_attach (grid, widget, 0, 7, 3, 1); dform->timestamp = (GtkToggleButton*) widget; }
static void presence_chooser_changed_cb (GtkComboBox *self, gpointer user_data) { EmpathyPresenceChooserPriv *priv = GET_PRIV (self); GtkTreeIter iter; char *icon_name; TpConnectionPresenceType new_state; gboolean customisable = TRUE; PresenceChooserEntryType type = -1; GtkWidget *entry; GtkTreeModel *model; if (priv->block_changed || !gtk_combo_box_get_active_iter (self, &iter)) { return; } model = gtk_combo_box_get_model (self); gtk_tree_model_get (model, &iter, COL_STATE_ICON_NAME, &icon_name, COL_STATE, &new_state, COL_STATUS_CUSTOMISABLE, &customisable, COL_TYPE, &type, -1); entry = gtk_bin_get_child (GTK_BIN (self)); /* some types of status aren't editable, set the editability of the * entry appropriately. Unless we're just about to reset it anyway, * in which case, don't fiddle with it */ if (type != ENTRY_TYPE_EDIT_CUSTOM) { gtk_editable_set_editable (GTK_EDITABLE (entry), customisable); priv->state = new_state; } if (type == ENTRY_TYPE_EDIT_CUSTOM) { GtkWidget *window, *dialog; presence_chooser_reset_status (EMPATHY_PRESENCE_CHOOSER (self)); /* attempt to get the toplevel for this widget */ window = gtk_widget_get_toplevel (GTK_WIDGET (self)); if (!GTK_WIDGET_TOPLEVEL (window) || !GTK_IS_WINDOW (window)) { window = NULL; } dialog = empathy_status_preset_dialog_new (GTK_WINDOW (window)); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } else if (type == ENTRY_TYPE_CUSTOM) { gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, icon_name); /* preseed the status */ if (priv->previous_type == ENTRY_TYPE_BUILTIN) { /* if their previous entry was a builtin, don't * preseed */ gtk_entry_set_text (GTK_ENTRY (entry), ""); } else { /* else preseed the text of their currently entered * status message */ const char *status; status = empathy_idle_get_status (priv->idle); gtk_entry_set_text (GTK_ENTRY (entry), status); } /* grab the focus */ gtk_widget_grab_focus (entry); } else { char *status; /* just in case we were setting a new status when * things were changed */ presence_chooser_set_status_editing ( EMPATHY_PRESENCE_CHOOSER (self), FALSE); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, icon_name); gtk_tree_model_get (model, &iter, COL_STATUS_TEXT, &status, -1); empathy_idle_set_presence (priv->idle, priv->state, status); g_free (status); } if (type != ENTRY_TYPE_EDIT_CUSTOM) { priv->previous_type = type; } g_free (icon_name); }
static void pocketvox_setup_add_module(PocketvoxSetup *setup, gchar* key, gchar* value, gboolean isapps) { g_return_if_fail(NULL != setup); setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup, TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate); PocketvoxSetupPrivate *priv = setup->priv; ModuleInfos *info = (ModuleInfos *)g_malloc0(sizeof(ModuleInfos)); GtkWidget* row = gtk_list_box_row_new(); gchar *name = g_strdup_printf("row_%d",current_line); gtk_widget_set_name(row, name); GtkWidget* grid = gtk_grid_new(); info->entry_id = gtk_entry_new(); if(key != NULL) { gtk_entry_set_text(GTK_ENTRY(info->entry_id), key); } gtk_entry_set_placeholder_text(GTK_ENTRY(info->entry_id), _("your-id")); gtk_widget_set_tooltip_text(info->entry_id, _("Set the module's id")); info->sw = gtk_switch_new(); gtk_widget_set_tooltip_text(info->sw, _("is this module associated to an desktop application ?")); info->entry_path = gtk_entry_new(); gtk_entry_set_icon_from_icon_name (GTK_ENTRY(info->entry_path), GTK_ENTRY_ICON_SECONDARY, "gtk-search"); gtk_entry_set_placeholder_text(GTK_ENTRY(info->entry_path), _("your path")); gtk_widget_set_tooltip_text(info->entry_path,_("Set the dictionnary's path")); g_signal_connect(info->entry_path, "icon-press", G_CALLBACK(pocketvox_setup_search_dict), NULL); //gtk_widget_set_hexpand(label_app, TRUE); gtk_widget_set_hexpand(info->entry_path, TRUE); gtk_widget_set_hexpand(info->entry_id, TRUE); gtk_widget_set_hexpand(info->sw, FALSE); g_object_set(G_OBJECT(info->sw), "active", isapps, NULL); if(value != NULL) { gtk_entry_set_text(GTK_ENTRY(info->entry_path), value); } gtk_grid_set_row_homogeneous(GTK_GRID(grid), FALSE); gtk_grid_attach(GTK_GRID(grid), info->entry_id, 0, 0, 2, 1); gtk_grid_attach(GTK_GRID(grid), info->entry_path, 2, 0, 2, 1); gtk_grid_attach(GTK_GRID(grid), info->sw, 4, 0, 1, 1); gtk_container_add(GTK_CONTAINER(row), grid); gtk_widget_show_all(row); gtk_list_box_prepend(GTK_LIST_BOX(priv->listBox), row); g_hash_table_insert(priv->apps, g_strdup(name), info); current_line ++; }
static void * search_get_widget (void) { GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); entry = gtk_entry_new (); gtk_entry_set_icon_from_icon_name ((GtkEntry *) entry, GTK_ENTRY_ICON_PRIMARY, "edit-find"); gtk_entry_set_placeholder_text ((GtkEntry *) entry, _("Search library")); g_signal_connect (entry, "destroy", (GCallback) gtk_widget_destroyed, & entry); gtk_box_pack_start ((GtkBox *) vbox, entry, FALSE, FALSE, 0); help_label = gtk_label_new (_("To import your music library into " "Audacious, choose a folder and then click the \"refresh\" icon.")); gtk_widget_set_size_request (help_label, 194, -1); gtk_label_set_line_wrap ((GtkLabel *) help_label, TRUE); g_signal_connect (help_label, "destroy", (GCallback) gtk_widget_destroyed, & help_label); gtk_widget_set_no_show_all (help_label, TRUE); gtk_box_pack_start ((GtkBox *) vbox, help_label, TRUE, FALSE, 0); wait_label = gtk_label_new (_("Please wait ...")); g_signal_connect (wait_label, "destroy", (GCallback) gtk_widget_destroyed, & wait_label); gtk_widget_set_no_show_all (wait_label, TRUE); gtk_box_pack_start ((GtkBox *) vbox, wait_label, TRUE, FALSE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); g_signal_connect (scrolled, "destroy", (GCallback) gtk_widget_destroyed, & scrolled); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN); gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scrolled, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_widget_set_no_show_all (scrolled, TRUE); gtk_box_pack_start ((GtkBox *) vbox, scrolled, TRUE, TRUE, 0); results_list = audgui_list_new (& list_callbacks, NULL, items ? index_count (items) : 0); g_signal_connect (results_list, "destroy", (GCallback) gtk_widget_destroyed, & results_list); gtk_tree_view_set_headers_visible ((GtkTreeView *) results_list, FALSE); audgui_list_add_column (results_list, NULL, 0, G_TYPE_STRING, -1); gtk_container_add ((GtkContainer *) scrolled, results_list); GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_end ((GtkBox *) vbox, hbox, FALSE, FALSE, 0); GtkWidget * chooser = gtk_file_chooser_button_new (_("Choose Folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_box_pack_start ((GtkBox *) hbox, chooser, TRUE, TRUE, 0); char * path = get_path (); gtk_file_chooser_set_filename ((GtkFileChooser *) chooser, path); str_unref (path); GtkWidget * button = gtk_button_new (); gtk_container_add ((GtkContainer *) button, gtk_image_new_from_icon_name ("view-refresh", GTK_ICON_SIZE_BUTTON)); gtk_button_set_relief ((GtkButton *) button, GTK_RELIEF_NONE); gtk_box_pack_start ((GtkBox *) hbox, button, FALSE, FALSE, 0); g_signal_connect (entry, "changed", (GCallback) entry_cb, NULL); g_signal_connect (entry, "activate", (GCallback) action_play, NULL); g_signal_connect (button, "clicked", (GCallback) refresh_cb, chooser); gtk_widget_show_all (vbox); gtk_widget_show (results_list); show_hide_widgets (); return vbox; }
static GtkWidget *cd_build_events_widget (void) { GtkWidget *pMainBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, MARGIN); // category toolbar. GtkWidget *pToolBar = gtk_toolbar_new (); ///gtk_toolbar_set_orientation (GTK_TOOLBAR (pToolBar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR (pToolBar), GTK_TOOLBAR_BOTH); // overwrite system preference (GTK_TOOLBAR_ICONS) gtk_style_context_add_class (gtk_widget_get_style_context (pToolBar), GTK_STYLE_CLASS_INLINE_TOOLBAR); // style: inline GtkCssProvider *css = gtk_css_provider_new (); // but without border gtk_css_provider_load_from_data (css, ".inline-toolbar.toolbar { " "background: transparent; border-color: transparent; }", -1, NULL); GtkStyleContext *ctx = gtk_widget_get_style_context (pToolBar); gtk_style_context_add_provider (ctx, GTK_STYLE_PROVIDER (css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gtk_toolbar_set_show_arrow (GTK_TOOLBAR (pToolBar), FALSE); // force to display all the entries. gtk_box_pack_start (GTK_BOX (pMainBox), pToolBar, TRUE, TRUE, MARGIN); int i = 0; GtkToolItem *group = _add_category_button (pToolBar, D_("All"), "stock_search", i++, NULL); _add_category_button (pToolBar, D_("Applications"), "exec", i++, group); _add_category_button (pToolBar, D_("Documents"), "document", i++, group); ///_add_category_button (pToolBar, D_("Folders"), "folder", i++, group); _add_category_button (pToolBar, D_("Images"), "image", i++, group); _add_category_button (pToolBar, D_("Audio"), "sound", i++, group); _add_category_button (pToolBar, D_("Videos"), "video", i++, group); _add_category_button (pToolBar, D_("Web"), "text-html", i++, group); _add_category_button (pToolBar, D_("Others"), "unknown", i++, group); _add_category_button (pToolBar, D_("Top Results"), "gtk-about", i, group); // search entry. GtkWidget *pFilterBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, CAIRO_DOCK_GUI_MARGIN); gtk_box_pack_start (GTK_BOX (pMainBox), pFilterBox, FALSE, FALSE, MARGIN); GtkWidget *pFilterLabel = gtk_label_new (D_("Look for events")); gldi_dialog_set_widget_text_color (GTK_WIDGET (pFilterLabel)); gtk_box_pack_start (GTK_BOX (pFilterBox), pFilterLabel, FALSE, FALSE, MARGIN); GtkWidget *pEntry = gtk_entry_new (); // press any key: g_signal_connect (pEntry, "key-release-event", G_CALLBACK (on_key_press_filter), NULL); gtk_box_pack_start (GTK_BOX (pFilterBox), pEntry, TRUE, TRUE, MARGIN); gtk_widget_set_tooltip_text (pEntry, D_("The default boolean operator is AND. Thus the query foo bar will be interpreted as foo AND bar. To exclude a term from the result set prepend it with a minus sign - eg foo -bar. Phrase queries can be done by double quoting the string \"foo is a bar\". You can truncate terms by appending a *. ")); gtk_entry_set_icon_activatable (GTK_ENTRY (pEntry), GTK_ENTRY_ICON_SECONDARY, TRUE); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (pEntry), GTK_ENTRY_ICON_SECONDARY, GLDI_ICON_NAME_CLEAR); g_signal_connect (pEntry, "icon-press", G_CALLBACK (on_clear_filter), NULL); myData.pEntry = pEntry; gtk_widget_grab_focus (pEntry); // model GtkListStore *pModel = gtk_list_store_new (CD_MODEL_NB_COLUMNS, G_TYPE_STRING, /* CD_MODEL_NAME */ G_TYPE_STRING, /* CD_MODEL_URI */ G_TYPE_STRING, /* CD_MODEL_PATH */ GDK_TYPE_PIXBUF, /* CD_MODEL_ICON */ G_TYPE_INT64, /* CD_MODEL_DATE */ G_TYPE_UINT); /* CD_MODEL_ID */ myData.pModel = pModel; // tree-view GtkWidget *pOneWidget = gtk_tree_view_new (); gtk_tree_view_set_model (GTK_TREE_VIEW (pOneWidget), GTK_TREE_MODEL (pModel)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pOneWidget), TRUE); gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (pOneWidget), TRUE); GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pOneWidget)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /**gtk_tree_selection_set_select_function (selection, (GtkTreeSelectionFunc) _cairo_dock_select_one_item_in_tree, NULL, NULL);*/ g_signal_connect (G_OBJECT (pOneWidget), "button-release-event", G_CALLBACK (_on_click_module_tree_view), NULL); // pour le menu du clic droit g_signal_connect (G_OBJECT (pOneWidget), "button-press-event", G_CALLBACK (_on_click_module_tree_view), NULL); // pour le menu du clic droit g_object_set (G_OBJECT (pOneWidget), "tooltip-column", CD_MODEL_PATH, NULL); GtkTreeViewColumn* col; GtkCellRenderer *rend; // icon rend = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (pOneWidget), -1, NULL, rend, "pixbuf", CD_MODEL_ICON, NULL); // file name rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (D_("File name"), rend, "text", CD_MODEL_NAME, NULL); gtk_tree_view_column_set_min_width (col, 200); gtk_tree_view_column_set_max_width (col, MAX (500, g_desktopGeometry.Xscreen.width / g_desktopGeometry.iNbScreens * .67)); // we don't know on which screen is place the container... gtk_tree_view_column_set_sort_column_id (col, CD_MODEL_NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col); // date rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (D_("Last access"), rend, "text", CD_MODEL_DATE, NULL); gtk_tree_view_column_set_cell_data_func (col, rend, (GtkTreeCellDataFunc)_render_date, NULL, NULL); gtk_tree_view_column_set_sort_column_id (col, CD_MODEL_DATE); gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col); // barres de defilement GtkAdjustment *adj = gtk_adjustment_new (0., 0., 100., 1, 10, 10); gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (pOneWidget), GTK_ADJUSTMENT (adj)); GtkWidget *pScrolledWindow = gtk_scrolled_window_new (NULL, NULL); g_object_set (pScrolledWindow, "height-request", 300, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pScrolledWindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); #if GTK_CHECK_VERSION (3, 8, 0) gtk_container_add (GTK_CONTAINER (pScrolledWindow), pOneWidget); #else gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (pScrolledWindow), pOneWidget); #endif gtk_box_pack_start (GTK_BOX (pMainBox), pScrolledWindow, FALSE, FALSE, MARGIN); return pMainBox; }