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);
}
