EntityPropertyEditor::EntityPropertyEditor (Entity* entity, const std::string& name) { _widget = gtk_vbox_new(FALSE, 6); GtkWidget* editBox = gtk_hbox_new(FALSE, 3); gtk_container_set_border_width(GTK_CONTAINER(editBox), 3); // Set up the combobox TreeModel _comboBox = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(gtk_list_store_new(1, G_TYPE_STRING)), 0); // number of the "text" column populateComboBox(); // Add completion functionality to the combobox entry GtkEntryCompletion* completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(gtk_combo_box_get_model(GTK_COMBO_BOX(_comboBox))) ); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_set_completion(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(_comboBox))), completion); std::string caption = name + ": "; gtk_box_pack_start(GTK_BOX(editBox), gtk_label_new(caption.c_str()), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(editBox), _comboBox, TRUE, TRUE, 0); GtkWidget* vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), editBox, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(_widget), vbox, TRUE, TRUE, 0); }
bool wxTextEntry::DoAutoCompleteStrings(const wxArrayString& choices) { GtkEntry* const entry = (GtkEntry*)GetEditable(); wxCHECK_MSG(GTK_IS_ENTRY(entry), false, "auto completion doesn't work with this control"); GtkListStore * const store = gtk_list_store_new(1, G_TYPE_STRING); GtkTreeIter iter; for ( wxArrayString::const_iterator i = choices.begin(); i != choices.end(); ++i ) { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, (const gchar *)i->utf8_str(), -1); } GtkEntryCompletion * const completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(store)); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_set_completion(entry, completion); g_object_unref(completion); return true; }
static gboolean on_idle_create_widget (void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *entry; GtkEntryCompletion *completion; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 400, 200); g_signal_connect ( window, "delete-event", G_CALLBACK (gtk_main_quit), NULL); vbox = gtk_vbox_new (FALSE, 3); gtk_container_add (GTK_CONTAINER (window), vbox); entry = gtk_entry_new (); completion = e_category_completion_new (); gtk_entry_set_completion (GTK_ENTRY (entry), completion); gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0); gtk_widget_show_all (window); return FALSE; }
static void setup_timezone_dialog (CcDateTimePanel *self) { CcDateTimePanelPrivate *priv = self->priv; GtkEntryCompletion *completion; GtkTreeModel *completion_model; GtkWidget *dialog; GtkWidget *entry; /* set up timezone map */ priv->map = (GtkWidget *) cc_timezone_map_new (); gtk_widget_show (priv->map); gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (priv->builder, "aspectmap")), priv->map); dialog = W ("timezone-dialog"); entry = W ("timezone-searchentry"); g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); /* Create the completion object */ completion = gtk_entry_completion_new (); gtk_entry_set_completion (GTK_ENTRY (entry), completion); g_object_unref (completion); completion_model = GTK_TREE_MODEL (gtk_builder_get_object (priv->builder, "city-modelsort")); gtk_entry_completion_set_model (completion, completion_model); gtk_entry_completion_set_text_column (completion, CITY_COL_CITY_HUMAN_READABLE); }
static void fm_path_entry_init(FmPathEntry *entry) { FmPathEntryPrivate *priv = FM_PATH_ENTRY_GET_PRIVATE(entry); GtkEntryCompletion* completion = gtk_entry_completion_new(); GtkCellRenderer* render; priv->model = NULL; priv->completion_model = NULL; priv->completion_len = 0; priv->in_change = FALSE; priv->completion = completion; priv->highlight_completion_match = TRUE; priv->common_suffix_append_idle_id = -1; priv->common_suffix[0] = 0; gtk_entry_completion_set_minimum_key_length(completion, 1); gtk_entry_completion_set_match_func(completion, fm_path_entry_match_func, NULL, NULL); g_signal_connect(G_OBJECT(completion), "match-selected", G_CALLBACK(fm_path_entry_match_selected), (gpointer)NULL); g_object_set(completion, "text-column", COL_FILE_NAME, NULL); render = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( (GtkCellLayout*)completion, render, TRUE ); gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion), render, fm_path_entry_completion_render_func, entry, NULL); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_completion_set_popup_set_width(completion, TRUE); g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(fm_path_entry_key_press), NULL); gtk_entry_set_completion(GTK_ENTRY(entry), completion); }
/* * fill completion model for the entry, using list of * available gajim contacts */ static GtkWidget * get_contacts_widget (NstPlugin *plugin) { GtkWidget *entry; GtkEntryCompletion *completion; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeModel *completion_model; entry = gtk_entry_new (); completion = gtk_entry_completion_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (completion), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (completion), renderer, "pixbuf", 0, NULL); store = gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING); if(!add_gajim_contacts_to_model (store)) { gtk_widget_set_sensitive(entry, FALSE); } completion_model = GTK_TREE_MODEL (store); gtk_entry_completion_set_model (completion, completion_model); gtk_entry_set_completion (GTK_ENTRY (entry), completion); gtk_entry_completion_set_text_column (completion, 1); g_object_unref (completion_model); g_object_unref (completion); return entry; }
GtkWidget * do_entry_completion (GtkWidget *do_widget) { GtkWidget *vbox; GtkWidget *label; GtkWidget *entry; GtkEntryCompletion *completion; GtkTreeModel *completion_model; if (!window) { window = gtk_dialog_new_with_buttons ("GtkEntryCompletion", GTK_WINDOW (do_widget), 0, GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL); gtk_window_set_resizable (GTK_WINDOW (window), FALSE); g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); vbox = gtk_vbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "Completion demo, try writing <b>total</b> or <b>gnome</b> for example."); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); /* Create our entry */ entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); /* Create the completion object */ completion = gtk_entry_completion_new (); /* Assign the completion to the entry */ gtk_entry_set_completion (GTK_ENTRY (entry), completion); g_object_unref (completion); /* Create a tree model and use it as the completion model */ completion_model = create_completion_model (); gtk_entry_completion_set_model (completion, completion_model); g_object_unref (completion_model); /* Use model column 0 as the text column */ gtk_entry_completion_set_text_column (completion, 0); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); return window; }
void C4PropertyDlg::UpdateInputCtrl(C4Object *pObj) { int cnt; #ifdef WITH_DEVELOPER_MODE GtkEntryCompletion *completion = gtk_entry_get_completion(GTK_ENTRY(entry)); GtkListStore *store; // Uncouple list store from completion so that the completion is not // notified for every row we are going to insert. This enhances // performance significantly. if (!completion) { completion = gtk_entry_completion_new(); store = gtk_list_store_new(1, G_TYPE_STRING); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_set_completion(GTK_ENTRY(entry), completion); g_object_unref(G_OBJECT(completion)); } else { store = GTK_LIST_STORE(gtk_entry_completion_get_model(completion)); g_object_ref(G_OBJECT(store)); gtk_entry_completion_set_model(completion, NULL); } GtkTreeIter iter; gtk_list_store_clear(store); #endif // WITH_DEVELOPER_MODE // add global and standard functions for (C4AulFunc *pFn = Game.ScriptEngine.GetFirstFunc(); pFn; pFn = Game.ScriptEngine.GetNextFunc(pFn)) if (pFn->GetPublic()) { SCopy(pFn->Name, OSTR); #ifdef WITH_DEVELOPER_MODE gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, OSTR, -1); #endif } // Add object script functions C4AulScriptFunc *pRef; // Object script available if (pObj && pObj->Def) // Scan all functions for (cnt = 0; pRef = pObj->Def->Script.GetSFunc(cnt); cnt++) // Public functions only if (pRef->Access = AA_PUBLIC) { // Add function SCopy(pRef->Name, OSTR); #ifdef WITH_DEVELOPER_MODE gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, OSTR, -1); #endif } #if WITH_DEVELOPER_MODE // Reassociate list store with completion gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(store)); #endif }
static VALUE entry_set_completion(VALUE self, VALUE completion) { gtk_entry_set_completion(_SELF(self), GTK_ENTRY_COMPLETION(RVAL2GOBJ(completion))); G_CHILD_SET(self, rb_intern("completion"), completion); return self; }
static void make_xpath_completion (XpathExplorer *ttt) { GtkEntryCompletion *completion; completion = gtk_entry_completion_new(); gtk_entry_completion_set_text_column(completion, XML_TREE_MODEL_COL_XPATH); gtk_entry_set_completion(GTK_ENTRY(ttt->entry), completion); //g_signal_connect(G_OBJECT (completion), "match-selected", G_CALLBACK (xpath_match_select), ttt); g_signal_connect(ttt, "xpath-model-changed", G_CALLBACK(xpath_update_completion), ttt->entry); }
static gboolean fm_path_entry_focus_in_event(GtkWidget *widget, GdkEvent *event) { FmPathEntry *entry = FM_PATH_ENTRY(widget); FmPathEntryPrivate *priv = FM_PATH_ENTRY_GET_PRIVATE(entry); /* activate auto-completion */ gtk_entry_set_completion(entry, priv->completion); /* listen to 'changed' signal for auto-completion */ g_signal_connect(entry, "changed", G_CALLBACK(fm_path_entry_changed), NULL); return GTK_WIDGET_CLASS(fm_path_entry_parent_class)->focus_in_event(widget, event); }
int main(int argc, char *argv[]) { GtkWidget *window; GtkWidget *vbox; GtkWidget *label; GtkWidget *entry; GtkEntryCompletion *completion; GtkListStore *store; GtkTreeIter iter; int i; // 作為自動完成時的項目提示 gchar *topics[] = { "C", "C++", "Java", "JSP", "JSF", "JUnit", "JavaScript" }; gtk_init (&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "GtkEntryCompletion"); gtk_window_set_default_size(GTK_WINDOW(window), 300, 50); // 使用GtkListStore儲存項目提示 store = gtk_list_store_new(1, G_TYPE_STRING); for(i = 0; i < 7; i++) { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, topics[i], -1); } // 將GtkListStore設定給GtkEntryCompletion completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(store)); gtk_entry_completion_set_text_column (completion, 0); label = gtk_label_new("請輸入技術主題"); // 建立GtkEntry entry = gtk_entry_new(); // 設定GtkEntryCompletion gtk_entry_set_completion(GTK_ENTRY(entry), completion); vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER (window), vbox); g_signal_connect(GTK_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_widget_show_all (window); gtk_main(); return 0; }
static void gimp_container_entry_init (GimpContainerEntry *entry) { GtkEntryCompletion *completion; GtkTreeModel *model; GtkCellRenderer *cell; GType types[GIMP_CONTAINER_TREE_STORE_N_COLUMNS]; gint n_types = 0; completion = g_object_new (GTK_TYPE_ENTRY_COMPLETION, "inline-completion", TRUE, "popup-single-match", FALSE, "popup-set-width", FALSE, NULL); gimp_container_tree_store_columns_init (types, &n_types); model = gimp_container_tree_store_new (GIMP_CONTAINER_VIEW (entry), n_types, types); gimp_container_tree_store_set_use_name (GIMP_CONTAINER_TREE_STORE (model), TRUE); gtk_entry_completion_set_model (completion, model); g_object_unref (model); gtk_entry_set_completion (GTK_ENTRY (entry), completion); g_signal_connect (completion, "match-selected", G_CALLBACK (gimp_container_entry_match_selected), entry); g_object_unref (completion); /* FIXME: This can be done better with GTK+ 2.6. */ cell = gimp_cell_renderer_viewable_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (completion), cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (completion), cell, "renderer", GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, NULL); gimp_container_tree_store_add_renderer_cell (GIMP_CONTAINER_TREE_STORE (model), cell); gtk_entry_completion_set_text_column (completion, GIMP_CONTAINER_TREE_STORE_COLUMN_NAME); g_signal_connect (entry, "changed", G_CALLBACK (gimp_container_entry_changed), entry); }
virtual ~wxTextAutoCompleteData() { // Note that we must not use m_entry here because this could result in // using an already half-destroyed wxTextEntry when we're destroyed // from its dtor (which is executed after wxTextCtrl dtor, which had // already destroyed the actual entry). So use the stored widget // instead and only after checking that it is still valid. if ( GTK_IS_ENTRY(m_widgetEntry) ) { gtk_entry_set_completion(m_widgetEntry, NULL); g_signal_handlers_disconnect_by_data(m_widgetEntry, this); } }
static gboolean fm_path_entry_focus_out_event(GtkWidget *widget, GdkEvent *event) { FmPathEntry *entry = FM_PATH_ENTRY(widget); FmPathEntryPrivate *priv = FM_PATH_ENTRY_GET_PRIVATE(entry); /* de-activate auto-completion */ gtk_entry_set_completion(entry, NULL); /* release all resources allocated for completion. */ clear_completion(priv); /* disconnect from 'changed' signal since we don't do auto-completion * when we have no keyboard focus. */ g_signal_handlers_disconnect_by_func(entry, fm_path_entry_changed, NULL); return GTK_WIDGET_CLASS(fm_path_entry_parent_class)->focus_out_event(widget, event); }
explicit wxTextAutoCompleteData(wxTextEntry* entry) : m_entry(entry), m_widgetEntry(entry->GetEntry()) { // This will be really set in ToggleProcessEnterFlag(). m_hadProcessEnterFlag = false; GtkEntryCompletion* const completion = gtk_entry_completion_new(); gtk_entry_completion_set_text_column (completion, 0); gtk_entry_set_completion(m_widgetEntry, completion); g_signal_connect (m_widgetEntry, "grab-notify", G_CALLBACK (wx_gtk_entry_parent_grab_notify), this); }
static void hotssh_tab_init (HotSshTab *self) { HotSshTabPrivate *priv = hotssh_tab_get_instance_private (self); priv->settings = g_settings_new ("org.gnome.hotssh"); gtk_widget_init_template (GTK_WIDGET (self)); gtk_notebook_set_show_tabs ((GtkNotebook*)self, FALSE); g_signal_connect (priv->create_and_connect_button, "clicked", G_CALLBACK (on_create_and_connect), self); g_signal_connect (priv->add_new_connection_button, "clicked", G_CALLBACK (on_add_new_connection), self); g_signal_connect (priv->connect_cancel_button, "clicked", G_CALLBACK (on_connect_cancel), self); g_signal_connect (priv->error_disconnect, "clicked", G_CALLBACK (on_connect_cancel), self); g_signal_connect (priv->auth_cancel_button, "clicked", G_CALLBACK (on_connect_cancel), self); g_signal_connect (priv->approve_hostkey_button, "clicked", G_CALLBACK (on_approve_hostkey_clicked), self); g_signal_connect (priv->disapprove_hostkey_button, "clicked", G_CALLBACK (on_connect_cancel), self); g_signal_connect_swapped (priv->password_entry, "activate", G_CALLBACK (submit_password), self); g_signal_connect_swapped (priv->password_submit, "clicked", G_CALLBACK (submit_password), self); g_signal_connect (priv->connections_treeview, "row-activated", G_CALLBACK (on_connection_row_activated), self); priv->password_interaction = hotssh_password_interaction_new ((GtkEntry*)priv->password_entry); priv->terminal = vte_terminal_new (); g_signal_connect (priv->terminal, "realize", G_CALLBACK (on_vte_realize), self); vte_terminal_set_audible_bell ((VteTerminal*)priv->terminal, FALSE); /* Audible bell is a terrible idea */ g_signal_connect ((GObject*)priv->terminal, "size-allocate", G_CALLBACK (on_terminal_size_allocate), self); g_signal_connect ((GObject*)priv->terminal, "commit", G_CALLBACK (on_terminal_commit), self); gtk_box_pack_start ((GtkBox*)priv->terminal_box, priv->terminal, TRUE, TRUE, 0); gtk_range_set_adjustment ((GtkRange*)priv->terminal_vscrollbar, gtk_scrollable_get_vadjustment ((GtkScrollable*)priv->terminal)); gtk_widget_show_all (priv->terminal_box); g_queue_init (&priv->write_queue); { gs_unref_object HotSshHostDB *hostdb = hotssh_hostdb_get_instance (); gs_unref_object GtkTreeModel *hostdb_model = hotssh_hostdb_get_model (hostdb); priv->host_completion = gtk_entry_completion_new (); gtk_entry_completion_set_match_func (priv->host_completion, host_entry_match, self, NULL); gtk_entry_completion_set_model (priv->host_completion, hostdb_model); gtk_entry_completion_set_text_column (priv->host_completion, 0); gtk_entry_completion_set_inline_completion (priv->host_completion, TRUE); gtk_entry_set_completion ((GtkEntry*)priv->host_entry, priv->host_completion); } }
int main(int argc, char *argv[]) { GtkWidget *window; GtkWidget *grid; GtkWidget *label; GtkWidget *entry; GtkWidget *radio1; GtkWidget *radio2; GtkListStore *store; gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "Completion"); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_container_set_border_width(GTK_CONTAINER(window), 10); grid = gtk_grid_new(); gtk_container_add(GTK_CONTAINER(window), grid); label = gtk_label_new("There are completions for numbers from 'one' to 'ten'"); gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 2, 1); radio1 = gtk_radio_button_new_with_label(NULL, "Popup"); gtk_grid_attach(GTK_GRID(grid), radio1, 0, 1, 1, 1); radio2 = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(radio1), "Inline"); gtk_grid_attach(GTK_GRID(grid), radio2, 1, 1, 1, 1); entry = gtk_entry_new(); gtk_grid_attach(GTK_GRID(grid), entry, 0, 2, 2, 1); store = create_completion_list_store(); g_completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(g_completion, GTK_TREE_MODEL(store)); gtk_entry_completion_set_text_column(g_completion, 0); gtk_entry_set_completion(GTK_ENTRY(entry), g_completion); g_signal_connect(radio1, "toggled", G_CALLBACK(popup_radio_toggled), NULL); g_signal_connect(radio2, "toggled", G_CALLBACK(inline_radio_toggled), NULL); gtk_widget_show_all(window); gtk_main(); return 0; }
/* --------------------------------------------------------------------- * Create the dialog, return the entry * --------------------------------------------------------------------- */ static GtkWidget* create_dialog(GtkWidget **dialog, GtkTreeModel *completion_model) { GtkWidget *entry; GtkWidget *label; GtkWidget *vbox; GtkEntryCompletion *completion; *dialog = gtk_dialog_new_with_buttons("Go to File...", GTK_WINDOW(geany->main_widgets->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response(GTK_DIALOG(*dialog), GTK_RESPONSE_ACCEPT); gtk_widget_set_name(*dialog, "GotoFile"); vbox = ui_dialog_vbox_new(GTK_DIALOG(*dialog)); label = gtk_label_new(_("Enter the file you want to open:")); gtk_container_add(GTK_CONTAINER(vbox), label); /* Entry definition */ entry = gtk_entry_new(); gtk_container_add(GTK_CONTAINER(vbox), entry); gtk_entry_set_text(GTK_ENTRY(entry), ""); gtk_entry_set_max_length(GTK_ENTRY(entry), MAX_FILENAME_LENGTH); gtk_entry_set_width_chars(GTK_ENTRY(entry), 40); gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE); /* 'enter' key */ /* Completion definition */ completion = gtk_entry_completion_new(); gtk_entry_set_completion(GTK_ENTRY(entry), completion); gtk_entry_completion_set_model (completion, completion_model); /* Completion options */ gtk_entry_completion_set_inline_completion(completion, 1); gtk_entry_completion_set_text_column (completion, 0); /* Signals */ g_signal_connect_after(GTK_ENTRY(entry), "changed", G_CALLBACK(directory_check), completion); gtk_widget_show_all(*dialog); return entry; }
void completion_add(struct tab *t) { /* enable completion for tab */ t->completion = gtk_entry_completion_new(); gtk_entry_completion_set_text_column(t->completion, 0); gtk_entry_set_completion(GTK_ENTRY(t->uri_entry), t->completion); gtk_entry_completion_set_model(t->completion, GTK_TREE_MODEL(completion_model)); gtk_entry_completion_set_match_func(t->completion, completion_match, NULL, NULL); gtk_entry_completion_set_minimum_key_length(t->completion, 1); gtk_entry_completion_set_inline_selection(t->completion, TRUE); g_signal_connect(G_OBJECT (t->completion), "match-selected", G_CALLBACK(completion_select_cb), t); g_signal_connect(G_OBJECT (t->completion), "cursor-on-match", G_CALLBACK(completion_hover_cb), t); }
static void share_nfs_add_hosts_completion (void) { GtkWidget *entry = gst_dialog_get_widget (tool->main_dialog, "share_nfs_hostname"); GtkEntryCompletion *completion; GtkListStore *store; completion = gtk_entry_completion_new (); store = gtk_list_store_new (1, G_TYPE_STRING); gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (store)); g_object_unref (store); gtk_entry_set_completion (GTK_ENTRY (entry), completion); g_object_unref (completion); gtk_entry_completion_set_text_column (completion, 0); populate_hosts_completion (store); }
/** * This function initializes entry with an autocomplete table * specified by compl_list. To set the default darktable variables, * use dt_gtkentry_get_default_path_compl_list(). * * @param[in] entry GtkEntry * @param[in] compl_list A {NULL,NULL} terminated array containing * {variable,description} for each available * completion text. */ void dt_gtkentry_setup_completion(GtkEntry *entry, const dt_gtkentry_completion_spec *compl_list) { GtkEntryCompletion *completion = gtk_entry_completion_new(); GtkListStore *model = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); GtkTreeIter iter; gtk_entry_completion_set_text_column(completion, COMPL_DESCRIPTION); gtk_entry_set_completion(entry, completion); g_signal_connect(G_OBJECT(completion), "match-selected", G_CALLBACK(on_match_select), NULL); /* Populate the completion database. */ for(const dt_gtkentry_completion_spec *l = compl_list; l && l->varname; l++) { gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, COMPL_VARNAME, l->varname, COMPL_DESCRIPTION, _(l->description), -1); } gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(model)); gtk_entry_completion_set_match_func(completion, on_match_func, NULL, NULL); g_object_unref(model); }
static void setup_combo (VinagreConnectDialog *dialog) { GtkListStore *store; GtkEntryCompletion *completion; GPtrArray *history; gint i, size; GtkEntry *entry; entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (dialog->host_entry))); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING); history = saved_history (); g_object_get (vinagre_prefs_get_default (), "history-size", &size, NULL); if (size <= 0) size = G_MAXINT; for (i=history->len-1; i>=0 && i>=(gint)history->len-size; i--) { GtkTreeIter iter; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLUMN_TEXT, g_ptr_array_index (history, i), -1); } g_ptr_array_free (history, TRUE); gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->host_entry), GTK_TREE_MODEL (store)); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (dialog->host_entry), 0); completion = gtk_entry_completion_new (); gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (store)); gtk_entry_completion_set_text_column (completion, 0); gtk_entry_completion_set_inline_completion (completion, TRUE); gtk_entry_set_completion (entry, completion); g_object_unref (completion); gtk_entry_set_activates_default (entry, TRUE); g_signal_connect (entry, "changed", G_CALLBACK (control_connect_button), dialog); }
void gnc_cbwe_add_completion (GtkComboBox *cbwe) { GtkEntry *entry; GtkEntryCompletion *completion; GtkTreeModel *model; entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(cbwe))); completion = gtk_entry_get_completion(entry); if (completion) return; /* No completion yet? Set one up. */ completion = gtk_entry_completion_new(); model = gtk_combo_box_get_model(GTK_COMBO_BOX(cbwe)); gtk_entry_completion_set_model(completion, model); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(entry, completion); g_object_unref(completion); }
static void hildon_touch_selector_entry_init (HildonTouchSelectorEntry *self) { HildonTouchSelectorEntryPrivate *priv; GtkEntryCompletion *completion; HildonGtkInputMode input_mode; priv = HILDON_TOUCH_SELECTOR_ENTRY_GET_PRIVATE (self); priv->converter = g_iconv_open ("ascii//translit", "utf-8"); priv->entry = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT); gtk_entry_set_activates_default (GTK_ENTRY (priv->entry), TRUE); input_mode = hildon_gtk_entry_get_input_mode (GTK_ENTRY (priv->entry)); /* Disable unsupported input modes. */ input_mode &= ~HILDON_GTK_INPUT_MODE_MULTILINE; input_mode &= ~HILDON_GTK_INPUT_MODE_INVISIBLE; input_mode &= ~HILDON_GTK_INPUT_MODE_DICTIONARY; hildon_gtk_entry_set_input_mode (GTK_ENTRY (priv->entry), input_mode); completion = gtk_entry_completion_new (); gtk_entry_completion_set_inline_completion (completion, TRUE); gtk_entry_completion_set_popup_completion (completion, FALSE); gtk_entry_set_completion (GTK_ENTRY (priv->entry), completion); g_object_unref (completion); gtk_widget_show (priv->entry); g_signal_connect (G_OBJECT (priv->entry), "changed", G_CALLBACK (entry_on_text_changed), self); priv->signal_id = g_signal_connect (G_OBJECT (self), "changed", G_CALLBACK (hildon_touch_selector_entry_changed), NULL); hildon_touch_selector_set_print_func (HILDON_TOUCH_SELECTOR (self), hildon_touch_selector_entry_print_func); gtk_box_pack_start (GTK_BOX (self), priv->entry, FALSE, FALSE, 0); }
//This function returns a table containing the elements of the page arranged GtkWidget * setPageLayout(GtkWidget* window, GtkWidget* browserForm){ GtkWidget * tableInitialing; GtkWidget *image; GtkWidget * mainSearchBox, *miniSearchBox, *centerSearchBox; GtkWidget *searchMainBut, *searchMiniBut, *searchCenterBut, *exitButton , *goBackBut, *stopBut, *frontBut; GtkWidget *scrolledWindow; GtkWidget *webView; GtkWidget *pageLayoutExpander; webView = webkit_web_view_new(); pageLayoutExpander = gtk_expander_new_with_mnemonic("V_iew page"); //creates a table with 20 rows and 17 columns tableInitialing = gtk_table_new( 30, 17, TRUE); exitButton = gtk_button_new_with_mnemonic("E_xit One click browser"); g_signal_connect_swapped( G_OBJECT(exitButton), "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer) window); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), exitButton, 0, 17, 29,30); //Start of expander setting //declaration of variables involved in setting position of tabs GtkWidget *settingExpander, *expanderVBox; GtkWidget *setTapUpRadio, *setTapDownRadio, *clearHistoryBut, *viewHistoryBut; GtkWidget *facebookLogo, *twitterLogo, *gmailLogo, *skypeLogo, *googleLogo; GtkWidget *facebookEventBox, *twitterEventBox, *gmailEventBox, *skypeEventBox, *googleEventBox; //Initialising variables setTapUpRadio = gtk_radio_button_new_with_label(NULL,"Set tab position up"); setTapDownRadio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(setTapUpRadio), "Set tab position down"); //Initialises the clearHistoryBut and associate a callback to it clearHistoryBut = gtk_button_new_with_mnemonic("_Clear history"); g_signal_connect(G_OBJECT(clearHistoryBut), "clicked", G_CALLBACK(clearHistory), NULL); viewHistoryBut = gtk_button_new_with_mnemonic("_View history"); g_signal_connect_swapped(G_OBJECT(viewHistoryBut),"clicked", G_CALLBACK(viewHistory), NULL); //Initialises the expander and the vbox settingExpander = gtk_expander_new_with_mnemonic("_Settings"); expanderVBox = gtk_vbox_new(TRUE, 0); //Adds radio buttons to the vbox gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapUpRadio); gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapDownRadio); gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), clearHistoryBut); gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), viewHistoryBut); //Linking signals of radio buttons to the respective callbacks g_signal_connect_swapped( G_OBJECT(setTapUpRadio), "toggled", G_CALLBACK(setTapUp), browserForm); g_signal_connect_swapped( G_OBJECT(setTapDownRadio), "toggled", G_CALLBACK(setTapDown), browserForm); gtk_container_add( GTK_CONTAINER(settingExpander), expanderVBox); gtk_table_attach_defaults( GTK_TABLE(tableInitialing),settingExpander, 0,3,20,24); //End of expander setting goBackBut = gtk_button_new_with_label(" <-- "); gtk_widget_set_size_request(goBackBut, 10, 25); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), goBackBut, 1, 2, 1, 2); g_signal_connect_swapped(goBackBut, "clicked", G_CALLBACK(back), webView); stopBut = gtk_button_new_with_label(" X "); gtk_widget_set_size_request(stopBut, 10, 25); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), stopBut, 2, 3, 1, 2); g_signal_connect_swapped(stopBut, "clicked", G_CALLBACK(stop), webView); frontBut = gtk_button_new_with_label(" --> "); gtk_widget_set_size_request(frontBut, 10, 25); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), frontBut, 16, 17, 1, 2); g_signal_connect_swapped(frontBut, "clicked", G_CALLBACK(forward), webView); //This patch of code initiates autocompletion of the search box GtkEntryCompletion *completion; GtkTreeIter *iter; GtkListStore *store_list; FILE * historyPtr; store_list = gtk_list_store_new(1,G_TYPE_STRING); completion = gtk_entry_completion_new(); if( (historyPtr = fopen("History/History.htm","r+")) == NULL) g_print("Error"); gchar historyString[100]; while( !feof(historyPtr)){ fscanf(historyPtr,"%s",historyString); gtk_list_store_append(store_list, iter); gtk_list_store_set(store_list, iter, 0, historyString, -1); } fclose(historyPtr); gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(store_list)); gtk_entry_completion_set_text_column(completion, 0); mainSearchBox = gtk_entry_new(); gtk_entry_set_completion(GTK_ENTRY(mainSearchBox), completion); gtk_widget_set_size_request(mainSearchBox, 500, 25); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), mainSearchBox, 3, 15, 1, 2 ); g_signal_connect_swapped(mainSearchBox, "activate", G_CALLBACK(activate), webView); searchMainBut = gtk_button_new_with_mnemonic("Sear_ch"); gtk_widget_set_size_request(searchMainBut, 10,15); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), searchMainBut, 15, 16, 1, 2 ); g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(setUri), mainSearchBox); g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(go), webView); //g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(initialiseEntryCompletion), completion); //Linking callbacks to signals emitted by webview widget g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-progress-changed",G_CALLBACK(progress),mainSearchBox); g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(finished),mainSearchBox); scrolledWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(scrolledWindow), webView); gtk_widget_show_all(scrolledWindow); //PageLayout expander //gtk_widget_set_sensitive(pageLayoutExpander, FALSE); gtk_container_add( GTK_CONTAINER(pageLayoutExpander), scrolledWindow); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), pageLayoutExpander, 0, 17, 2, 29); g_signal_connect_swapped(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(viewSearchedPage),pageLayoutExpander); image = gtk_image_new_from_file("images/OneClickLogo.png"); GtkWidget* imageEventBox = initialiseEventBox(image); g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(searchOneClick), webView); g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(logoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), imageEventBox, 3, 14, 14, 24); //Adding pictures of some social media to the browser's home page facebookLogo = gtk_image_new_from_file("images/facebook.jpg"); skypeLogo = gtk_image_new_from_file("images/skype.jpg"); twitterLogo = gtk_image_new_from_file("images/twitter.jpg"); gmailLogo = gtk_image_new_from_file("images/gmail.jpg"); googleLogo = gtk_image_new_from_file("images/google.jpg"); //Adding event handlers to images facebookEventBox = initialiseEventBox(facebookLogo); g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(searchFacebook), webView); g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(facebookLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), facebookEventBox, 4, 6, 24, 28 ); gmailEventBox = initialiseEventBox(gmailLogo); g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(searchGmail), webView); g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(gmailLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), gmailEventBox, 6, 8, 24, 28 ); twitterEventBox = initialiseEventBox(twitterLogo); g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(searchTwitter), webView); g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(twitterLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), twitterEventBox, 8, 10, 24, 28 ); skypeEventBox = initialiseEventBox(skypeLogo); g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(searchSKype), webView); g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(skypeLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), skypeEventBox, 10, 12, 24, 28 ); googleEventBox = initialiseEventBox(googleLogo); g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(searchGoogle), webView); g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(googleLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), googleEventBox, 12, 14, 24, 28 ); //This patch of code implements the file chooser button that opens files on the user's computer GtkWidget *openFileChooser; openFileChooser = gtk_file_chooser_button_new("Select an html document to open",GTK_FILE_CHOOSER_ACTION_OPEN); g_signal_connect_swapped(G_OBJECT(openFileChooser), "selection_changed", G_CALLBACK(openFile), webView); //gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openFileChooser), g_get_home_dir()); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), openFileChooser, 4, 12, 0, 1 ); GtkFileFilter *filter; filter = gtk_file_filter_new(); gtk_file_filter_set_name (filter, "HTML Files"); gtk_file_filter_add_pattern (filter, "*.html"); gtk_file_filter_add_pattern (filter, "*.htm"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (openFileChooser), filter); return tableInitialing; }
void gui_init (dt_lib_module_t *self) { dt_lib_styles_t *d = (dt_lib_styles_t *)malloc (sizeof (dt_lib_styles_t)); self->data = (void *)d; d->edit_button = NULL; self->widget = gtk_vbox_new (FALSE, 5); GtkWidget *w; /* list */ d->list = GTK_TREE_VIEW (gtk_tree_view_new ()); gtk_tree_view_set_headers_visible(d->list,FALSE); GtkListStore *liststore = gtk_list_store_new (DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new (); gtk_tree_view_append_column (GTK_TREE_VIEW (d->list), col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", DT_STYLES_COL_NAME); int ht = get_font_height( GTK_WIDGET (d->list), "Dreggn"); gtk_widget_set_size_request (GTK_WIDGET (d->list), -1, 5*ht); gtk_tree_selection_set_mode (gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE); gtk_tree_view_set_model (GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore)); g_object_unref (liststore); g_object_set(G_OBJECT(d->list), "tooltip-text", _("available styles,\ndoubleclick to apply"), (char *)NULL); g_signal_connect (d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d); /* filter entry */ w = gtk_entry_new(); d->entry=GTK_ENTRY(w); g_object_set(G_OBJECT(w), "tooltip-text", _("enter style name"), (char *)NULL); g_signal_connect (d->entry, "changed", G_CALLBACK(entry_callback),d); g_signal_connect (d->entry, "activate", G_CALLBACK(entry_activated),d); dt_gui_key_accel_block_on_focus ( GTK_WIDGET (d->entry)); gtk_box_pack_start(GTK_BOX (self->widget),GTK_WIDGET (d->entry),TRUE,FALSE,0); gtk_box_pack_start(GTK_BOX (self->widget),GTK_WIDGET (d->list),TRUE,FALSE,0); GtkWidget *hbox=gtk_hbox_new (FALSE,5); GtkWidget *widget; d->duplicate = gtk_check_button_new_with_label(_("create duplicate")); gtk_box_pack_start(GTK_BOX (self->widget),GTK_WIDGET (d->duplicate),TRUE,FALSE,0); g_signal_connect (d->duplicate, "toggled", G_CALLBACK(duplicate_callback),d); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (d->duplicate), dt_conf_get_bool("ui_last/styles_create_duplicate")); g_object_set (d->duplicate, "tooltip-text", _("creates a duplicate of the image before applying style"), (char *)NULL); #if 0 // TODO: Unfinished stuff GtkWidget *widget=gtk_button_new_with_label(_("edit")); d->edit_button = widget; also add to the init function g_signal_connect (widget, "clicked", G_CALLBACK(edit_clicked),d); gtk_box_pack_start(GTK_BOX (hbox),widget,TRUE,TRUE,0); #endif widget=gtk_button_new_with_label(_("delete")); d->delete_button = widget; g_signal_connect (widget, "clicked", G_CALLBACK(delete_clicked),d); g_object_set (widget, "tooltip-text", _("deletes the selected style in list above"), (char *)NULL); gtk_box_pack_start(GTK_BOX (hbox),widget,TRUE,TRUE,0); gtk_box_pack_start(GTK_BOX (self->widget),hbox,TRUE,FALSE,0); // Export Button GtkWidget *exportButton = gtk_button_new_with_label(_("export")); d->export_button = exportButton; g_object_set (exportButton, "tooltip-text", _("export the selected style into a style file"), (char *)NULL); g_signal_connect (exportButton, "clicked", G_CALLBACK(export_clicked),d); gtk_box_pack_start(GTK_BOX (hbox),exportButton,TRUE,TRUE,0); // Import Button GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import")); d->import_button = importButton; g_object_set (importButton, "tooltip-text", _("import style from a style file"), (char *)NULL); g_signal_connect (importButton, "clicked", G_CALLBACK(import_clicked),d); gtk_box_pack_start(GTK_BOX (hbox),importButton,TRUE,TRUE,0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->list))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* update filtered list */ _gui_styles_update_view(d); }
GtkWidget * terminal_search_dialog_new (GtkWindow *parent) { GtkWidget *dialog; TerminalSearchDialogPrivate *priv; GtkListStore *store; GtkEntryCompletion *completion; priv = g_new0 (TerminalSearchDialogPrivate, 1); if (!terminal_util_load_builder_file ("find-dialog.ui", "find-dialog", &dialog, "search-label", &priv->search_label, "search-entry", &priv->search_entry, "match-case-checkbutton", &priv->match_case_checkbutton, "entire-word-checkbutton", &priv->entire_word_checkbutton, "regex-checkbutton", &priv->regex_checkbutton, "search-backwards-checkbutton", &priv->backwards_checkbutton, "wrap-around-checkbutton", &priv->wrap_around_checkbutton, NULL)) { g_free (priv); return NULL; } g_object_set_qdata_full (G_OBJECT (dialog), get_quark (), priv, (GDestroyNotify) terminal_search_dialog_private_destroy); priv->search_text_entry = gtk_bin_get_child (GTK_BIN (priv->search_entry)); gtk_widget_set_size_request (priv->search_entry, 300, -1); priv->store = store = gtk_list_store_new (1, G_TYPE_STRING); g_object_set (G_OBJECT (priv->search_entry), "model", store, #if GTK_CHECK_VERSION (2, 91, 0) "entry-text-column", 0, #else "text-column", 0, #endif NULL); priv->completion = completion = gtk_entry_completion_new (); gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (store)); gtk_entry_completion_set_text_column (completion, 0); gtk_entry_completion_set_minimum_key_length (completion, HISTORY_MIN_ITEM_LEN); gtk_entry_completion_set_popup_completion (completion, FALSE); gtk_entry_completion_set_inline_completion (completion, TRUE); gtk_entry_set_completion (GTK_ENTRY (priv->search_text_entry), completion); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, FALSE); gtk_entry_set_activates_default (GTK_ENTRY (priv->search_text_entry), TRUE); g_signal_connect (priv->search_text_entry, "changed", G_CALLBACK (update_sensitivity), dialog); g_signal_connect (priv->regex_checkbutton, "toggled", G_CALLBACK (update_sensitivity), dialog); g_signal_connect (dialog, "response", G_CALLBACK (response_handler), NULL); if (parent) gtk_window_set_transient_for (GTK_WINDOW (dialog), parent); return GTK_WIDGET (dialog); }
/** * main: **/ int main (int argc, char *argv[]) { GOptionContext *context; GConfClient *gconf_client; GtkWidget *widget; GtkTreeSelection *selection; GtkEntryCompletion *completion; UniqueApp *unique_app; gboolean ret; guint retval; guint xid = 0; GError *error = NULL; const GOptionEntry options[] = { { "filter", 'f', 0, G_OPTION_ARG_STRING, &filter, /* TRANSLATORS: preset the GtktextBox with this filter text */ N_("Set the filter to this value"), NULL }, { "parent-window", 'p', 0, G_OPTION_ARG_INT, &xid, /* TRANSLATORS: we can make this modal (stay on top of) another window */ _("Set the parent window to make this modal"), NULL }, { NULL} }; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); if (! g_thread_supported ()) g_thread_init (NULL); g_type_init (); gtk_init (&argc, &argv); context = g_option_context_new (NULL); g_option_context_set_summary (context, _("Software Log Viewer")); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, egg_debug_get_option_group ()); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, NULL); g_option_context_free (context); /* are we running privileged */ ret = gpk_check_privileged_user (_("Log viewer"), TRUE); if (!ret) return 1; /* are we already activated? */ unique_app = unique_app_new ("org.freedesktop.PackageKit.LogViewer", NULL); if (unique_app_is_running (unique_app)) { egg_debug ("You have another instance running. This program will now close"); unique_app_send_message (unique_app, UNIQUE_ACTIVATE, NULL); goto unique_out; } g_signal_connect (unique_app, "message-received", G_CALLBACK (gpk_log_message_received_cb), NULL); /* add application specific icons to search path */ gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), GPK_DATA G_DIR_SEPARATOR_S "icons"); client = pk_client_new (); g_object_set (client, "background", FALSE, NULL); /* get UI */ builder = gtk_builder_new (); retval = gtk_builder_add_from_file (builder, GPK_DATA "/gpk-log.ui", &error); if (retval == 0) { egg_warning ("failed to load ui: %s", error->message); g_error_free (error); goto out_build; } widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple")); gtk_window_set_icon_name (GTK_WINDOW (widget), GPK_ICON_SOFTWARE_LOG); /* set a size, if the screen allows */ gpk_window_set_size_request (GTK_WINDOW (widget), 900, 300); /* if command line arguments are set, then setup UI */ if (filter != NULL) { widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package")); gtk_entry_set_text (GTK_ENTRY(widget), filter); } /* Get the main window quit */ g_signal_connect_swapped (widget, "delete_event", G_CALLBACK (gtk_main_quit), NULL); widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_close")); g_signal_connect_swapped (widget, "clicked", G_CALLBACK (gtk_main_quit), NULL); gtk_widget_grab_default (widget); widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_help")); g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_help_cb), NULL); widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_refresh")); g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_refresh_cb), NULL); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_filter")); g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_filter_cb), NULL); /* hit enter in the search box for filter */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package")); g_signal_connect (widget, "activate", G_CALLBACK (gpk_log_button_filter_cb), NULL); /* autocompletion can be turned off as it's slow */ gconf_client = gconf_client_get_default (); ret = gconf_client_get_bool (gconf_client, GPK_CONF_AUTOCOMPLETE, NULL); if (ret) { /* create the completion object */ completion = gpk_package_entry_completion_new (); widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package")); gtk_entry_set_completion (GTK_ENTRY (widget), completion); g_object_unref (completion); } else { /* use search as you type */ g_signal_connect (widget, "key-release-event", G_CALLBACK (gpk_log_entry_filter_cb), NULL); } g_object_unref (gconf_client); /* create list stores */ list_store = gtk_list_store_new (GPK_LOG_COLUMN_LAST, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); /* create transaction_id tree view */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "treeview_simple")); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (list_store)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); g_signal_connect (selection, "changed", G_CALLBACK (gpk_log_treeview_clicked_cb), NULL); /* add columns to the tree view */ pk_treeview_add_general_columns (GTK_TREE_VIEW (widget)); gtk_tree_view_columns_autosize (GTK_TREE_VIEW (widget)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store), GPK_LOG_COLUMN_TIMESPEC, GTK_SORT_DESCENDING); /* show */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple")); gtk_widget_show (widget); /* set the parent window if it is specified */ if (xid != 0) { egg_debug ("Setting xid %i", xid); gpk_window_set_parent_xid (GTK_WINDOW (widget), xid); } /* get the update list */ gpk_log_refresh (); gtk_main (); out_build: g_object_unref (builder); g_object_unref (list_store); g_object_unref (client); g_free (transaction_id); g_free (filter); if (transactions != NULL) g_ptr_array_unref (transactions); unique_out: g_object_unref (unique_app); return 0; }
static void _setup_ui (OlPlayerChooser *window) { OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window); gtk_container_set_border_width (GTK_CONTAINER (window), WINDOW_BORDER_SIZE); /* Setup info widgets */ priv->info_label = GTK_LABEL (gtk_label_new (NULL)); gtk_label_set_line_wrap (priv->info_label, TRUE); gtk_misc_set_alignment (GTK_MISC (priv->info_label), 0.0, 0.0); priv->info_icon = GTK_IMAGE (gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG)); GtkWidget *info_box = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (info_box), GTK_WIDGET (priv->info_icon), FALSE, /* expand */ FALSE, /* fill */ 0); gtk_box_pack_start (GTK_BOX (info_box), GTK_WIDGET (priv->info_label), TRUE, /* expand */ TRUE, /* fill */ 0); /* Setup app choosers */ priv->page_button_panel = GTK_BOX (gtk_hbox_new (FALSE, 0)); priv->chooser_panel = GTK_BOX (gtk_hbox_new (FALSE, 0)); _new_page (window, _("Supported players")); _new_page (window, _("All players")); _set_apps_to_page (window, ALL_CHOOSER_INDEX, g_app_info_get_all_for_type ("audio/mp3")); GtkWidget *apps_frame = gtk_frame_new (_("Choose a player to launch")); GtkBox *page_vbox = GTK_BOX (gtk_vbox_new (FALSE, 0)); gtk_widget_show (GTK_WIDGET (page_vbox)); gtk_box_pack_start (page_vbox, GTK_WIDGET (priv->page_button_panel), FALSE, /* expand */ FALSE, /* fill */ 0); /* padding */ gtk_box_pack_end (page_vbox, GTK_WIDGET (priv->chooser_panel), FALSE, /* expand */ FALSE, /* fill */ 0); /* padding */ gtk_container_add (GTK_CONTAINER (apps_frame), GTK_WIDGET (page_vbox)); /* Setup custom command */ priv->custom_cmd_panel = GTK_BOX (gtk_hbox_new (FALSE, 5)); GtkWidget *cmd_label = gtk_label_new (_("Use command:")); GtkWidget *cmd_entry = gtk_entry_new (); priv->cmd_entry = GTK_ENTRY (cmd_entry); gtk_entry_set_activates_default (priv->cmd_entry, TRUE); gtk_entry_set_completion (priv->cmd_entry, _new_bin_completion ()); GtkWidget *launch_button = gtk_button_new_with_label (_("Launch")); gtk_widget_set_can_default (launch_button, TRUE); gtk_window_set_default (GTK_WINDOW (window), launch_button); priv->launch_button = launch_button; g_signal_connect (launch_button, "clicked", G_CALLBACK (_launch_button_clicked_cb), window); gtk_box_pack_start (priv->custom_cmd_panel, cmd_label, FALSE, TRUE, 0); gtk_box_pack_start (priv->custom_cmd_panel, cmd_entry, TRUE, TRUE, 0); gtk_box_pack_start (priv->custom_cmd_panel, launch_button, FALSE, TRUE, 0); GtkWidget *final_hbox = gtk_hbox_new (FALSE, 0); GtkWidget *remember_button = gtk_check_button_new_with_label (_("Remember my choice")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (remember_button), TRUE); priv->remember_button = remember_button; gtk_box_pack_start (GTK_BOX (final_hbox), remember_button, FALSE, TRUE, 0); /* Setup the whole dialog */ GtkWidget *vbox = gtk_dialog_get_content_area (GTK_DIALOG (window)); gtk_box_set_spacing (GTK_BOX (vbox), 10); gtk_box_pack_start (GTK_BOX (vbox), info_box, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), apps_frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (priv->custom_cmd_panel), FALSE, TRUE, 0); gtk_box_pack_end (GTK_BOX (vbox), final_hbox, FALSE, TRUE, 0); gtk_widget_show (vbox); gtk_widget_show_all (info_box); gtk_widget_show (apps_frame); gtk_widget_show_all (GTK_WIDGET (priv->page_button_panel)); gtk_widget_show (GTK_WIDGET (priv->chooser_panel)); gtk_widget_show_all (GTK_WIDGET (priv->custom_cmd_panel)); gtk_widget_show_all (GTK_WIDGET (final_hbox)); gtk_dialog_add_button (GTK_DIALOG (window), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_window_set_title (GTK_WINDOW (window), _("Choose a player to launch")); gtk_window_set_resizable (GTK_WINDOW (window), FALSE); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); }