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