/* Starts the selection state in the icon text item */ static void iti_start_selecting (MateIconTextItem *iti, int idx, guint32 event_time) { MateIconTextItemPrivate *priv; GtkEditable *e; GdkCursor *ibeam; priv = iti->_priv; e = GTK_EDITABLE (priv->entry); gtk_editable_select_region (e, idx, idx); gtk_editable_set_position (e, idx); ibeam = gdk_cursor_new (GDK_XTERM); mate_canvas_item_grab (MATE_CANVAS_ITEM (iti), GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, ibeam, event_time); gdk_cursor_unref (ibeam); gtk_editable_select_region (e, idx, idx); priv->selecting = TRUE; priv->selection_start = idx; mate_canvas_item_request_update (MATE_CANVAS_ITEM (iti)); g_signal_emit (iti, iti_signals[SELECTION_STARTED], 0); }
void wxTextCtrl::SetSelection( long from, long to ) { wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") ); if (from == -1 && to == -1) { from = 0; to = GetValue().length(); } if ( (m_windowStyle & wxTE_MULTILINE) && !GTK_TEXT(m_text)->line_start_cache ) { // tell the programmer that it didn't work wxLogDebug(wxT("Can't call SetSelection() before realizing the control")); return; } if (m_windowStyle & wxTE_MULTILINE) { gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to ); } else { gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to ); } }
static int gtkListSetSelectionPosAttrib(Ihandle* ih, const char* value) { int start=0, end=0; GtkEntry* entry; if (!ih->data->has_editbox) return 0; if (!value) return 0; entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY"); if (!value || iupStrEqualNoCase(value, "NONE")) { gtk_editable_select_region(GTK_EDITABLE(entry), 0, 0); return 0; } if (iupStrEqualNoCase(value, "ALL")) { gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1); return 0; } if (iupStrToIntInt(value, &start, &end, ':')!=2) return 0; if(start<0 || end<0) return 0; gtk_editable_select_region(GTK_EDITABLE(entry), start, end); return 0; }
static void fm_list_view_start_renaming_file (FMDirectoryView *view, GOFFile *file, gboolean select_all) { FMListView *list_view; GtkTreeIter iter; GtkTreePath *path; gint start_offset, end_offset; list_view = FM_LIST_VIEW (view); /* Select all if we are in renaming mode already */ if (list_view->details->file_name_column && list_view->details->editable_widget) { gtk_editable_select_region (GTK_EDITABLE (list_view->details->editable_widget), 0, -1); return; } if (!fm_list_model_get_first_iter_for_file (list_view->model, file, &iter)) { g_debug ("%s FAILED", G_STRFUNC); return; } /* Freeze updates to the view to prevent losing rename focus when the tree view updates */ fm_list_view_freeze_updates (FM_LIST_VIEW (view)); path = gtk_tree_model_get_path (GTK_TREE_MODEL (list_view->model), &iter); /* Make filename-cells editable. */ g_object_set (G_OBJECT (list_view->details->file_name_cell), "editable", TRUE, NULL); gtk_tree_view_scroll_to_cell (list_view->tree, NULL, list_view->details->file_name_column, TRUE, 0.0, 0.0); /* set cursor also triggers editing-started, where we save the editable widget */ /*gtk_tree_view_set_cursor (list_view->tree, path, list_view->details->file_name_column, TRUE);*/ /* sound like set_cursor is not enought to trigger editing-started, we use cursor_on_cell instead */ gtk_tree_view_set_cursor_on_cell (list_view->tree, path, list_view->details->file_name_column, (GtkCellRenderer *) list_view->details->file_name_cell, TRUE); if (list_view->details->editable_widget != NULL) { eel_filename_get_rename_region (list_view->details->original_name, &start_offset, &end_offset); gtk_editable_select_region (GTK_EDITABLE (list_view->details->editable_widget), start_offset, end_offset); } gtk_tree_path_free (path); }
void devolucao () { GtkWidget *window; GtkWidget *vbox; GtkWidget *fixed; GtkWidget *label; GtkWidget *entry1, *entry2; GtkWidget *button; gint tmp_pos; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_resizable (window, FALSE); gtk_window_set_title (GTK_WINDOW (window), "Devolução de filmes"); gtk_widget_set_size_request (GTK_WIDGET (window), 380, 240); gtk_container_set_border_width (GTK_CONTAINER (window), 10); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new ("CPF do cliente:"); gtk_container_add (GTK_CONTAINER (vbox), label); entry1 = gtk_entry_new (); gtk_entry_set_max_length (GTK_ENTRY (entry1), 100); g_signal_connect (entry1, "changed", G_CALLBACK (enter_devolucao_cpf), entry1); tmp_pos = GTK_ENTRY (entry1)->text_length; gtk_editable_select_region (GTK_EDITABLE (entry1), 0, GTK_ENTRY (entry1)->text_length); gtk_box_pack_start (GTK_BOX (vbox), entry1, TRUE, TRUE, 0); gtk_widget_show (entry1); label = gtk_label_new ("Código do filme:"); gtk_container_add (GTK_CONTAINER (vbox), label); entry2 = gtk_entry_new (); gtk_entry_set_max_length (GTK_ENTRY (entry2), 100); g_signal_connect (entry2, "changed", G_CALLBACK (enter_devolucao_codigo), entry2); tmp_pos = GTK_ENTRY (entry2)->text_length; gtk_editable_select_region (GTK_EDITABLE (entry2), 0, GTK_ENTRY (entry2)->text_length); gtk_box_pack_start (GTK_BOX (vbox), entry2, TRUE, TRUE, 0); gtk_widget_show (entry2); fixed = gtk_fixed_new (); gtk_container_add (GTK_CONTAINER (vbox), fixed); button = gtk_button_new_with_label ("Ir"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (devolucao_confirmacao), (gpointer) window); gtk_fixed_put (GTK_FIXED (fixed), button, 259, 15); gtk_widget_set_size_request (button, 100, 35); gtk_widget_show_all (window); }
/** * csv_page_custom_toggled * @button : the Checkbutton that emitted the signal * @data : a mother struct * * This will nicely activate the @data->csv_info->csv_customseparator widget * so the user can enter text into it. * It will also gray out this widget if the @button is not selected. * * returns : nothing **/ static void csv_page_custom_toggled (GtkCheckButton *button, StfDialogData *data) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) { gtk_widget_set_sensitive (GTK_WIDGET (data->csv.csv_customseparator), TRUE); gtk_widget_grab_focus (GTK_WIDGET (data->csv.csv_customseparator)); gtk_editable_select_region (GTK_EDITABLE (data->csv.csv_customseparator), 0, -1); } else { gtk_widget_set_sensitive (GTK_WIDGET (data->csv.csv_customseparator), FALSE); gtk_editable_select_region (GTK_EDITABLE (data->csv.csv_customseparator), 0, 0); /* If we don't use this the selection will remain blue */ } csv_page_global_change (NULL, data); }
gboolean gnc_get_username_password (GtkWidget *parent, const char *heading, const char *initial_username, const char *initial_password, char **username, char **password) { GtkWidget *dialog; GtkWidget *heading_label; GtkWidget *username_entry; GtkWidget *password_entry; GtkBuilder *builder; gint result; g_return_val_if_fail (username != NULL, FALSE); g_return_val_if_fail (password != NULL, FALSE); builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "dialog-userpass.glade", "Username Password Dialog"); dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Username Password Dialog")); if (parent) gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent)); heading_label = GTK_WIDGET(gtk_builder_get_object (builder, "heading_label")); username_entry = GTK_WIDGET(gtk_builder_get_object (builder, "username_entry")); password_entry = GTK_WIDGET(gtk_builder_get_object (builder, "password_entry")); if (heading) gtk_label_set_text (GTK_LABEL (heading_label), heading); if (initial_username) gtk_entry_set_text (GTK_ENTRY (username_entry), initial_username); gtk_editable_select_region (GTK_EDITABLE (username_entry), 0, -1); if (initial_password) gtk_entry_set_text (GTK_ENTRY (password_entry), initial_password); result = gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_hide(dialog); if (result == GTK_RESPONSE_OK) { *username = gtk_editable_get_chars (GTK_EDITABLE (username_entry), 0, -1); *password = gtk_editable_get_chars (GTK_EDITABLE (password_entry), 0, -1); gtk_widget_destroy(dialog); return TRUE; } *username = NULL; *password = NULL; g_object_unref(G_OBJECT(builder)); gtk_widget_destroy(dialog); return FALSE; }
static gboolean thunar_location_entry_accept_focus (ThunarLocationBar *location_bar, const gchar *initial_text) { ThunarLocationEntry *location_entry = THUNAR_LOCATION_ENTRY (location_bar); /* give the keyboard focus to the path entry */ gtk_widget_grab_focus (location_entry->path_entry); /* check if we have an initial text for the location bar */ if (G_LIKELY (initial_text != NULL)) { /* setup the new text */ gtk_entry_set_text (GTK_ENTRY (location_entry->path_entry), initial_text); /* move the cursor to the end of the text */ gtk_editable_set_position (GTK_EDITABLE (location_entry->path_entry), -1); } else { /* select the whole path in the path entry */ gtk_editable_select_region (GTK_EDITABLE (location_entry->path_entry), 0, -1); } return TRUE; }
static void dialog_goto_load_selection (GotoState *state) { SheetView *sv = wb_control_cur_sheet_view (WORKBOOK_CONTROL (state->wbcg)); GnmRange const *first = selection_first_range (sv, NULL, NULL); if (first != NULL) { gint rows = range_height (first); gint cols = range_width (first); GnmConventionsOut out; GString *str = g_string_new (NULL); GnmParsePos pp; GnmRangeRef rr; out.accum = str; out.pp = parse_pos_init_sheet (&pp, sv->sheet); out.convs = sheet_get_conventions (sv->sheet); gnm_cellref_init (&rr.a, NULL, first->start.col, first->start.row, TRUE); gnm_cellref_init (&rr.b, NULL, first->start.col, first->start.row, TRUE); rangeref_as_string (&out, &rr); gtk_entry_set_text (state->goto_text, str->str); gtk_editable_select_region (GTK_EDITABLE (state->goto_text), 0, -1); g_string_free (str, TRUE); cb_dialog_goto_update_sensitivity (NULL, state); gtk_spin_button_set_value (state->spin_rows, rows); gtk_spin_button_set_value (state->spin_cols, cols); } else cb_dialog_goto_update_sensitivity (NULL, state); }
void gui_channel_topic_lock(GtkWidget *widget) { ChannelTitle *title; Frame *frame; frame = g_object_get_data(G_OBJECT(widget), "focus_frame"); if (frame != NULL) { gui_frame_remove_focusable_widget(frame, widget); g_object_set_data(G_OBJECT(widget), "focus_frame", NULL); /* reset the topic */ title = g_object_get_data(G_OBJECT(widget), "title"); gtk_entry_set_text(title->topic, title->channel->topic != NULL ? title->channel->topic : ""); /* set locked coloring */ title->locked = TRUE; title_set_colors(title); /* remove focus */ gtk_widget_grab_focus(frame->entry->widget); gtk_editable_select_region(GTK_EDITABLE(frame->entry->widget), 0, 0); } }
int x_create_input (Dlg_head *h, widget_data parent, WInput *in) { GtkWidget *gnome_entry; GtkEntry *entry; /* The widget might have been initialized manually. * Look in gscreen.c for an example */ if (in->widget.wdata) return 1; #ifdef USE_GNOME_ENTRY gnome_entry = gnome_entry_new (in->widget.tkname); #else entry = GTK_ENTRY (gnome_entry = gtk_entry_new ()); gtk_entry_set_visibility (entry, !in->is_password); #endif gtk_widget_show (gnome_entry); in->widget.wdata = (widget_data) gnome_entry; #ifdef USE_GNOME_ENTRY entry = GTK_ENTRY (gnome_entry_gtk_entry (GNOME_ENTRY (gnome_entry))); #endif gtk_entry_set_text (entry, in->buffer); gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1); gtk_entry_set_position (entry, in->point); gtk_signal_connect (GTK_OBJECT (entry), "button_press_event", GTK_SIGNAL_FUNC (entry_click), in); gtk_signal_connect (GTK_OBJECT (entry), "button_release_event", GTK_SIGNAL_FUNC (entry_release), in); return 1; }
void XttFileviewGtk::list_cursor_changed_cb( GtkTreeView *tree_view, gpointer data) { XttFileviewGtk *fileview = (XttFileviewGtk *) data; if ( fileview->type == fileview_eType_Save) { char *text; static char selected_text[80]; GtkTreeIter iter; GtkTreeModel *store; g_object_get( fileview->list, "model", &store, NULL); GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(fileview->list)); if ( gtk_tree_selection_get_selected( selection, NULL, &iter)) { gtk_tree_model_get( GTK_TREE_MODEL( store), &iter, 0, &text, -1); strcpy( selected_text, text); } gint pos = 0; gtk_editable_delete_text( GTK_EDITABLE(fileview->input_text), 0, -1); gtk_editable_insert_text( GTK_EDITABLE(fileview->input_text), selected_text, strlen(selected_text), &pos); // Select the text gtk_editable_set_position( GTK_EDITABLE(fileview->input_text), -1); gtk_editable_select_region( GTK_EDITABLE(fileview->input_text), 0, -1); } }
static gboolean key_pressed(GtkWidget *widget, GdkEventKey *event, SourceWindow *sourcewin) { if (!event || !sourcewin) return FALSE; switch (event->keyval) { case GDK_KEY_A: case GDK_KEY_a: if ((event->state & GDK_CONTROL_MASK) != 0) gtk_editable_select_region(GTK_EDITABLE(sourcewin->text), 0, -1); break; case GDK_KEY_W: case GDK_KEY_w: if ((event->state & GDK_CONTROL_MASK) != 0) gtk_widget_destroy(sourcewin->window); break; case GDK_KEY_Escape: source_window_destroy(sourcewin); return TRUE; break; } return FALSE; }
static void _lib_geotagging_show_offset_window(GtkWidget *widget, dt_lib_module_t *self) { dt_lib_geotagging_t *d = self->data; gint x, y; gint px, py, center_w, center_h, window_w, window_h; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); GtkWidget *center = dt_ui_center(darktable.gui->ui); gdk_window_get_origin(gtk_widget_get_window(center), &px, &py); center_w = gdk_window_get_width(gtk_widget_get_window(center)); center_h = gdk_window_get_height(gtk_widget_get_window(center)); d->floating_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_can_focus(d->floating_window, TRUE); gtk_window_set_decorated(GTK_WINDOW(d->floating_window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(d->floating_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_window_set_transient_for(GTK_WINDOW(d->floating_window), GTK_WINDOW(window)); gtk_window_set_opacity(GTK_WINDOW(d->floating_window), 0.8); gtk_window_set_modal(GTK_WINDOW(d->floating_window), TRUE); GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1, 1); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 5, 5, 5); GtkWidget *vbox = gtk_vbox_new(TRUE, 5); gtk_container_add(GTK_CONTAINER(alignment), vbox); d->floating_window_entry = gtk_entry_new(); gtk_widget_add_events(d->floating_window_entry, GDK_FOCUS_CHANGE_MASK); g_signal_connect_swapped(d->floating_window, "focus-out-event", G_CALLBACK(gtk_widget_destroy), d->floating_window); g_object_set(G_OBJECT(d->floating_window_entry), "tooltip-text", _("enter the time shown on the selected picture\nformat: hh:mm:ss"), (char *)NULL); gtk_editable_select_region(GTK_EDITABLE(d->floating_window_entry), 0, -1); gtk_box_pack_start(GTK_BOX(vbox), d->floating_window_entry, TRUE, TRUE, 0); g_signal_connect(d->floating_window_entry, "key-press-event", G_CALLBACK(_lib_geotagging_floating_key_press), self); GtkWidget *hbox = gtk_hbox_new(TRUE, 5); GtkWidget *cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); GtkWidget *ok_button = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 0); g_signal_connect_swapped(G_OBJECT(cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), d->floating_window); g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(_lib_geotagging_calculate_offset_callback), self); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(d->floating_window), alignment); gtk_widget_show_all(d->floating_window); gtk_widget_grab_focus(d->floating_window_entry); window_w = gdk_window_get_width(gtk_widget_get_window(d->floating_window)); window_h = gdk_window_get_height(gtk_widget_get_window(d->floating_window)); x = px + 0.5*(center_w-window_w); y = py + center_h - 20 - window_h; gtk_window_move(GTK_WINDOW(d->floating_window), x, y); gtk_window_present(GTK_WINDOW(d->floating_window)); }
static void dest_change_dir(Dest_Data *dd, const gchar *path, gboolean retain_name) { const gchar *old_name = NULL; gchar *full_path; gchar *new_directory; if (retain_name) { const gchar *buf = gtk_entry_get_text(GTK_ENTRY(dd->entry)); if (!isdir(buf)) old_name = filename_from_path(buf); } full_path = g_build_filename(path, old_name, NULL); if (old_name) new_directory = g_path_get_dirname(full_path); else new_directory = g_strdup(full_path); gtk_entry_set_text(GTK_ENTRY(dd->entry), full_path); dest_populate(dd, new_directory); g_free(new_directory); if (old_name) { gchar *basename = g_path_get_basename(full_path); gtk_editable_select_region(GTK_EDITABLE(dd->entry), strlen(full_path) - strlen(basename), strlen(full_path)); g_free(basename); } g_free(full_path); }
EXPORT void mlpgui_jump_to_track (void) { bool_t create = (! jump_to_track_win); if (create) create_window (); g_return_if_fail (filter_entry); if (mlp_get_bool ("mlpgui", "remember_jtf_entry")) gtk_editable_select_region ((GtkEditable *) filter_entry, 0, -1); else gtk_entry_set_text ((GtkEntry *) filter_entry, ""); if (! watching) { fill_list (); hook_associate ("playlist update", update_cb, NULL); hook_associate ("playlist activate", activate_cb, NULL); watching = TRUE; } if (create) gtk_widget_show_all (jump_to_track_win); else gtk_window_present ((GtkWindow *) jump_to_track_win); gtk_widget_grab_focus (filter_entry); }
void search_box_fill_search_focus (SearchBox* search_box, gboolean on_replace) { IAnjutaEditor* te = search_box->priv->current_editor; if (IANJUTA_IS_EDITOR (te) && !search_box->priv->regex_mode) { gchar *buffer; buffer = ianjuta_editor_selection_get (IANJUTA_EDITOR_SELECTION (te), NULL); if (buffer != NULL) { g_strstrip (buffer); if (*buffer != 0) { gtk_entry_set_text (GTK_ENTRY (search_box->priv->search_entry), buffer); gtk_editable_select_region (GTK_EDITABLE (search_box->priv->search_entry), 0, -1); } g_free (buffer); } } /* Toggle replace level (replace entry, replace buttons) of search box */ search_box_set_replace (search_box, on_replace); gtk_widget_grab_focus (search_box->priv->search_entry); }
void XttGeGtk::ge_change_value_cb(void* ge_ctx, void* value_object, char* text) { XttGeGtk* ge = (XttGeGtk*)ge_ctx; if (ge->value_input_open) { g_object_set(ge->value_dialog, "visible", FALSE, NULL); ge->value_input_open = 0; return; } g_object_set(ge->value_dialog, "visible", TRUE, NULL); ge->message(' ', ""); gtk_widget_grab_focus(ge->value_input); gint pos = 0; gtk_editable_delete_text(GTK_EDITABLE(ge->value_input), 0, -1); gtk_editable_insert_text( GTK_EDITABLE(ge->value_input), text, strlen(text), &pos); gtk_editable_set_position(GTK_EDITABLE(ge->value_input), -1); gtk_editable_select_region(GTK_EDITABLE(ge->value_input), 0, -1); ge->value_input_open = 1; ge->current_value_object = value_object; }
static gchar* _fm_user_input_dialog_run(GtkDialog* dlg, GtkEntry *entry, GtkWidget *extra) { char* str = NULL; GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(dlg)); int sel_start, sel_end; gboolean has_sel; /* FIXME: this workaround is used to overcome bug of gtk+. * gtk+ seems to ignore select region and select all text for entry in dialog. */ has_sel = gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &sel_start, &sel_end); gtk_box_pack_start(box, GTK_WIDGET(entry), FALSE, TRUE, extra ? 0 : 6); if(extra) gtk_box_pack_start(box, extra, FALSE, TRUE, 0); gtk_widget_show_all(GTK_WIDGET(dlg)); if(has_sel) gtk_editable_select_region(GTK_EDITABLE(entry), sel_start, sel_end); while(gtk_dialog_run(dlg) == GTK_RESPONSE_OK) { const char* pstr = gtk_entry_get_text(entry); if( pstr && *pstr ) { str = g_strdup(pstr); break; } } gtk_widget_destroy(GTK_WIDGET(dlg)); return str; }
static GtkWidget * create_combo (void) { GList *cbitems; GtkCombo *combo; cbitems = NULL; cbitems = g_list_append (cbitems, "item0"); cbitems = g_list_append (cbitems, "item1 item1"); cbitems = g_list_append (cbitems, "item2 item2 item2"); cbitems = g_list_append (cbitems, "item3 item3 item3 item3"); cbitems = g_list_append (cbitems, "item4 item4 item4 item4 item4"); cbitems = g_list_append (cbitems, "item5 item5 item5 item5 item5 item5"); cbitems = g_list_append (cbitems, "item6 item6 item6 item6 item6"); cbitems = g_list_append (cbitems, "item7 item7 item7 item7"); cbitems = g_list_append (cbitems, "item8 item8 item8"); cbitems = g_list_append (cbitems, "item9 item9"); combo = GTK_COMBO (gtk_combo_new ()); gtk_combo_set_popdown_strings (combo, cbitems); gtk_entry_set_text (GTK_ENTRY (combo->entry), "hello world"); gtk_editable_select_region (GTK_EDITABLE (combo->entry), 0, -1); return GTK_WIDGET (combo); }
char *rename_prompt_new_name(const char *old_name) { char *new_name = NULL; int dlg_result; gtk_entry_set_text(ent_file_name, old_name); gtk_editable_select_region(GTK_EDITABLE(ent_file_name), 0, -1); gtk_widget_grab_focus(GTK_WIDGET(ent_file_name)); gtk_window_present(GTK_WINDOW(dlg_rename_file)); dlg_result = gtk_dialog_run(dlg_rename_file); if (dlg_result == GTK_RESPONSE_OK) { new_name = (char *)gtk_entry_get_text(ent_file_name); //printf("1: (%p) %s\n", new_name, new_name); if (strcmp(old_name, new_name) == 0) new_name = NULL; else new_name = g_strdup(new_name); } gtk_widget_hide(GTK_WIDGET(dlg_rename_file)); return new_name; }
static void _lookup_selection(GtkMenuItem *menuitem, gchar *dict_mod_description) { gchar *dict_key = NULL; gchar *mod_name = NULL; GtkWidget *html = _get_html(); if (!html) return; mod_name = main_module_name_from_description(dict_mod_description); XIPHOS_HTML_COPY_SELECTION(html); gtk_editable_select_region((GtkEditable *)widgets.entry_dict, 0, -1); gtk_editable_paste_clipboard((GtkEditable *)widgets.entry_dict); gtk_widget_activate(widgets.entry_dict); dict_key = g_strdup(gtk_editable_get_chars((GtkEditable *)widgets.entry_dict, 0, -1)); if (dict_key && mod_name) { main_display_dictionary(mod_name, dict_key); } if (dict_key) g_free(dict_key); if (mod_name) g_free(mod_name); }
static gboolean gnc_customer_common_key_press_cb( GtkEntry *entry, GdkEventKey *event, gpointer user_data, GtkWidget* editable ) { gboolean done_with_input = FALSE; /* Most "special" keys are allowed to be handled directly by * the entry's key press handler, but in some cases that doesn't * seem to work right, so handle them here. */ switch ( event->keyval ) { case GDK_Tab: case GDK_ISO_Left_Tab: if ( !( event->state & GDK_SHIFT_MASK) ) /* Complete on Tab, * but not Shift-Tab */ { /* NOT done with input, though, since we need to focus to the next * field. Unselect the current field, though. */ gtk_editable_select_region( GTK_EDITABLE(editable), 0, 0 ); } break; } return( done_with_input ); }
static void dest_change_dir(Dest_Data *dd, const gchar *path, gint retain_name) { gchar *old_name = NULL; gint s = 0; if (retain_name) { const gchar *buf = gtk_entry_get_text(GTK_ENTRY(dd->entry)); if (!isdir(buf)) { if (path && strcmp(path, "/") == 0) { old_name = g_strdup(filename_from_path(buf)); } else { old_name = g_strconcat("/", filename_from_path(buf), NULL); s = 1; } } } gtk_entry_set_text(GTK_ENTRY(dd->entry), path); dest_populate(dd, path); /* remember filename */ if (old_name) { gint pos = -1; gtk_editable_insert_text(GTK_EDITABLE(dd->entry), old_name, -1, &pos); gtk_editable_select_region(GTK_EDITABLE(dd->entry), strlen(path) + s, strlen(path) + strlen(old_name)); g_free(old_name); } }
static void edit_hist_forward(edit *e) { hentry *h, *hp; if(!e->ch) return; h = e->h; hp = 0; while(h != e->ch) { hp = h; h = h->h; } if(hp) { e->ch = hp; gtk_entry_set_text(e->edit_w, hp->e); } else if(e->hold) { gtk_entry_set_text(e->edit_w, e->hold); osd_free(e->hold); e->hold = 0; e->ch = 0; } else { gtk_entry_set_text(e->edit_w, ""); e->ch = 0; } gtk_editable_select_region(GTK_EDITABLE(e->edit_w), 0, -1); }
char* _moo_file_view_create_folder_dialog (GtkWidget *parent, MooFolder *folder) { CreateFolderXml *xml; GtkWidget *dialog; char *text, *path, *new_folder_name = NULL; g_return_val_if_fail (MOO_IS_FOLDER (folder), NULL); xml = create_folder_xml_new (); dialog = GTK_WIDGET (xml->CreateFolder); moo_window_set_parent (dialog, parent); path = g_filename_display_name (_moo_folder_get_path (folder)); text = g_strdup_printf ("Create new folder in %s", path); gtk_label_set_text (xml->label, text); g_free (path); g_free (text); gtk_entry_set_text (GTK_ENTRY (xml->entry), "New Folder"); moo_entry_clear_undo (xml->entry); gtk_widget_show_all (dialog); gtk_widget_grab_focus (GTK_WIDGET (xml->entry)); gtk_editable_select_region (GTK_EDITABLE (xml->entry), 0, -1); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) new_folder_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (xml->entry))); else new_folder_name = NULL; gtk_widget_destroy (dialog); return new_folder_name; }
static void on_menuitem_select_all_activate(void) { GtkEditable *widget = GTK_EDITABLE(gtk_window_get_focus(gui.window)); gtk_editable_set_position(widget, -1); gtk_editable_select_region(widget, 0, -1); }
void wxTextEntry::SetSelection(long from, long to) { // in wx convention, (-1, -1) means the entire range but GTK+ translates -1 // (or any negative number for that matter) into last position so we need // to translate manually if ( from == -1 && to == -1 ) from = 0; // for compatibility with MSW, exchange from and to parameters so that the // insertion point is set to the start of the selection and not its end as // GTK+ does by default gtk_editable_select_region(GetEditable(), to, from); #ifndef __WXGTK3__ // avoid reported problem with RHEL 5 GTK+ 2.10 where selection is reset by // a clipboard callback, see #13277 if (gtk_check_version(2,12,0)) { GtkEntry* entry = GTK_ENTRY(GetEditable()); if (to < 0) to = entry->text_length; entry->selection_bound = to; } #endif }
gboolean _key_press_ctrl_a_cb (GtkEntry *entry, GdkEventKey *event) { if ((event->keyval == GDK_KEY_A || event->keyval == GDK_KEY_a) && (event->state & GDK_CONTROL_MASK)) { GtkEditable *editable = (GtkEditable *) entry; gint start, end; /* special handling of Ctrl+A: * - if no selection, select all; * - if basename (i.e. without .extension) is selected, select all * - else select basename */ if (!gtk_editable_get_selection_bounds (editable, &start, &end)) /* no selection, select all */ gtk_editable_select_region (editable, 0, -1); else { const gchar *name; gint len; gint dot; gchar *s; /* locate the dot before the extension */ name = gtk_entry_get_text (entry); dot = 0; for (len = 1, s = g_utf8_next_char (name); *s != '\0'; ++len, s = g_utf8_next_char (s)) { if (*s == '.') dot = len; } if (start == 0 && end == dot) /* already selected, toggle back to all */ gtk_editable_select_region (editable, 0, -1); else if (dot > 0) /* select only up to the .ext */ gtk_editable_select_region (editable, 0, dot); } return TRUE; } return FALSE; }
/** * nautilus_entry_select_all * * Select all text, leaving the text cursor position at the end. * * @entry: A NautilusEntry **/ void nautilus_entry_select_all (NautilusEntry *entry) { g_return_if_fail (NAUTILUS_IS_ENTRY (entry)); gtk_editable_set_position (GTK_EDITABLE (entry), -1); gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1); }