static void drag_data_get_cb (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *data, guint info, guint time, gpointer user_data) { gint pos; pos = gtk_entry_get_current_icon_drag_source (GTK_ENTRY (widget)); if (pos == GTK_ENTRY_ICON_PRIMARY) { #if 0 gint start, end; if (gtk_editable_get_selection_bounds (GTK_EDITABLE (widget), &start, &end)) { gchar *str; str = gtk_editable_get_chars (GTK_EDITABLE (widget), start, end); gtk_selection_data_set_text (data, str, -1); g_free (str); } #else gtk_selection_data_set_text (data, "XXX", -1); #endif } }
static void on_menuitem_edit_activate(void) { GtkWidget *widget = gtk_window_get_focus(gui.window); bool selectable = false; bool editable = false; bool selection_ready = false; bool clipboard_ready = false; if (GTK_IS_ENTRY(widget)) { selectable = gtk_entry_get_text_length(GTK_ENTRY(widget)); editable = gtk_editable_get_editable(GTK_EDITABLE(widget)); selection_ready = gtk_editable_get_selection_bounds( GTK_EDITABLE(widget), NULL, NULL); clipboard_ready = gtk_clipboard_wait_is_text_available( gtk_clipboard_get(GDK_NONE)); } gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_cut), selection_ready && editable); gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_copy), selection_ready); gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_paste), editable && clipboard_ready); gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_delete), selection_ready && editable); gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_select_all), selectable); }
/** * gtk_editable_delete_selection: * @editable: a #GtkEditable * * Deletes the currently selected text of the editable. * This call doesn’t do anything if there is no selected text. */ void gtk_editable_delete_selection (GtkEditable *editable) { gint start, end; g_return_if_fail (GTK_IS_EDITABLE (editable)); if (gtk_editable_get_selection_bounds (editable, &start, &end)) gtk_editable_delete_text (editable, start, end); }
gboolean gnc_item_edit_get_has_selection (GncItemEdit *item_edit) { GtkEditable *editable; g_return_val_if_fail ((item_edit != NULL), FALSE); g_return_val_if_fail (GNC_IS_ITEM_EDIT (item_edit), FALSE); editable = GTK_EDITABLE (item_edit->editor); return gtk_editable_get_selection_bounds(editable, NULL, NULL); }
static gboolean position_and_selection_are_at_end (GtkEditable *editable) { int end; int start_sel, end_sel; end = get_editable_number_of_chars (editable); if (gtk_editable_get_selection_bounds (editable, &start_sel, &end_sel)) { if (start_sel != end || end_sel != end) { return FALSE; } } return gtk_editable_get_position (editable) == end; }
void text_entry_set_current(TextEntry *entry, struct session *sess) { TextEntryPriv *priv = entry->priv; GtkWidget *widget = GTK_WIDGET(entry); GtkClipboard *clipboard; char *selection = NULL; char *text = NULL; int start, end; g_return_if_fail(gtk_widget_get_realized(widget)); if (sess == priv->session) { return; } /* If the entry owns PRIMARY, setting the new text will clear PRIMARY; * so we need to re-set PRIMARY after setting the text. * See bug #345356 and bug #347067. */ clipboard = gtk_widget_get_clipboard(widget, GDK_SELECTION_PRIMARY); g_assert(clipboard != NULL); if (gtk_clipboard_get_owner(clipboard) == G_OBJECT(entry) && gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end)) { selection = gtk_editable_get_chars(GTK_EDITABLE(entry), start, end); } if (priv->session) { g_hash_table_replace(priv->current_text, priv->session, g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)))); } priv->session = sess; if (priv->session) { text = g_hash_table_lookup(priv->current_text, priv->session); } gtk_entry_set_text(GTK_ENTRY(entry), text ? text : ""); gtk_editable_set_position(GTK_EDITABLE(entry), -1); /* Restore the selection (note that it's not owned by us anymore!) */ if (selection) { gtk_clipboard_set_text(clipboard, selection, strlen(selection)); g_free(selection); } }
static gboolean draw_text_cursor_cb (GtkWidget *widget, cairo_t *cr, gpointer user_data) { GtkEditable *editable = GTK_EDITABLE(widget); GtkStyleContext *stylectxt = gtk_widget_get_style_context (GTK_WIDGET(widget)); gint height = gtk_widget_get_allocated_height (widget); const gchar *text; GdkRGBA *fg_color; GdkRGBA color; gint x_offset; gint cursor_x = 0; // Get the layout x offset gtk_entry_get_layout_offsets (GTK_ENTRY(widget), &x_offset, NULL); // Get the foreground color gdk_rgba_parse (&color, "black"); gtk_style_context_get_color (stylectxt, GTK_STATE_FLAG_NORMAL, &color); fg_color = &color; text = gtk_entry_get_text (GTK_ENTRY (widget)); if ((text != NULL) && (*text != '\0')) { PangoLayout *layout; PangoRectangle strong_pos; gint start_pos, end_pos, cursor_pos, cursor_byte_pos; cursor_pos = gtk_editable_get_position (editable); cursor_byte_pos = g_utf8_offset_to_pointer (text, cursor_pos) - text; gtk_editable_get_selection_bounds (editable, &start_pos, &end_pos); layout = gtk_entry_get_layout (GTK_ENTRY(widget)); pango_layout_get_cursor_pos (layout, cursor_byte_pos, &strong_pos, NULL); cursor_x = x_offset + PANGO_PIXELS (strong_pos.x); } else cursor_x = x_offset; // Now draw a vertical line cairo_set_source_rgb (cr, fg_color->red, fg_color->green, fg_color->blue); cairo_set_line_width (cr, 1.0); cairo_move_to (cr, cursor_x + 0.5, 2); cairo_rel_line_to (cr, 0, height - 4); cairo_stroke (cr); return FALSE; }
static gboolean nautilus_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event) { int result; gboolean old_had, new_had; int old_start, old_end, new_start, new_end; GtkEditable *editable; editable = GTK_EDITABLE (widget); old_had = gtk_editable_get_selection_bounds (editable, &old_start, &old_end); result = GTK_WIDGET_CLASS (nautilus_entry_parent_class)->motion_notify_event (widget, event); /* Send a signal if dragging the mouse caused the selection to change. */ if (result) { new_had = gtk_editable_get_selection_bounds (editable, &new_start, &new_end); if (old_had != new_had || (old_had && (old_start != new_start || old_end != new_end))) { g_signal_emit (widget, signals[SELECTION_CHANGED], 0); } } return result; }
static void cb_entry_cursor_pos (WBCGtk *wbcg) { gint start, end, target_pos_in_chars, target_pos_in_bytes; GtkEditable *entry = GTK_EDITABLE (wbcg_get_entry (wbcg)); char const *str = gtk_entry_get_text (GTK_ENTRY (entry)); int edit_pos = gtk_editable_get_position (entry); if (str[0] == 0) return; if (edit_pos != gtk_entry_get_text_length (GTK_ENTRY (entry))) { /* The cursor is no longer at the end. */ wbcg->auto_completing = FALSE; } if (!wbcg->edit_line.full_content) return; /* 1) Use first selected character if there is a selection * 2) Use the character just before the edit pos if it exists * 3) Use the first character */ if (gtk_editable_get_selection_bounds (entry, &start, &end)) target_pos_in_chars = start; else { target_pos_in_chars = edit_pos; if (target_pos_in_chars > 0) target_pos_in_chars--; } target_pos_in_bytes = g_utf8_offset_to_pointer (str, target_pos_in_chars) - str; /* Make bold/italic/etc buttons show the right thing. */ { GnmStyle *style = gnm_style_new (); GSList *ptr, *attrs = attrs_at_byte (wbcg->edit_line.full_content, target_pos_in_bytes); for (ptr = attrs; ptr != NULL ; ptr = ptr->next) { PangoAttribute *attr = ptr->data; gnm_style_set_from_pango_attribute (style, attr); pango_attribute_destroy (attr); } wb_control_style_feedback (GNM_WBC (wbcg), style); gnm_style_unref (style); g_slist_free (attrs); } set_cur_fmt (wbcg, target_pos_in_bytes); }
/************************************************************************** Make a text tag for the selected text. **************************************************************************/ void inputline_make_tag(GtkEntry *entry, enum text_tag_type type) { char buf[MAX_LEN_MSG]; GtkEditable *editable = GTK_EDITABLE(entry); gint start_pos, end_pos; gchar *selection; if (!gtk_editable_get_selection_bounds(editable, &start_pos, &end_pos)) { /* Let's say the selection starts and ends at the current position. */ start_pos = end_pos = gtk_editable_get_position(editable); } selection = gtk_editable_get_chars(editable, start_pos, end_pos); if (type == TTT_COLOR) { /* Get the color arguments. */ char fg_color_text[32], bg_color_text[32]; GdkColor *fg_color = g_object_get_data(G_OBJECT(entry), "fg_color"); GdkColor *bg_color = g_object_get_data(G_OBJECT(entry), "bg_color"); if (!fg_color && !bg_color) { goto CLEAN_UP; } color_to_string(fg_color, fg_color_text, sizeof(fg_color_text)); color_to_string(bg_color, bg_color_text, sizeof(bg_color_text)); if (0 == featured_text_apply_tag(selection, buf, sizeof(buf), TTT_COLOR, 0, FT_OFFSET_UNSET, ft_color(fg_color_text, bg_color_text))) { goto CLEAN_UP; } } else if (0 == featured_text_apply_tag(selection, buf, sizeof(buf), type, 0, FT_OFFSET_UNSET)) { goto CLEAN_UP; } /* Replace the selection. */ gtk_editable_delete_text(editable, start_pos, end_pos); end_pos = start_pos; gtk_editable_insert_text(editable, buf, -1, &end_pos); gtk_editable_select_region(editable, start_pos, end_pos); CLEAN_UP: g_free(selection); }
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; }
static void editable_event_after_callback (GtkEntry *entry, GdkEvent *event, AthenaLocationEntry *location_entry) { GtkEditable *editable; GdkEventKey *keyevent; if (event->type != GDK_KEY_PRESS) { return; } editable = GTK_EDITABLE (entry); keyevent = (GdkEventKey *)event; /* After typing the right arrow key we move the selection to * the end, if we have a valid selection - since this is most * likely an auto-completion. We ignore shift / control since * they can validly be used to extend the selection. */ if ((keyevent->keyval == GDK_KEY_Right || keyevent->keyval == GDK_KEY_End) && !(keyevent->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) && gtk_editable_get_selection_bounds (editable, NULL, NULL)) { set_position_and_selection_to_end (editable); } /* Only do expanding when we are typing at the end of the * text. Do the expand at idle time to avoid slowing down * typing when the directory is large. Only trigger the expand * when we type a key that would have inserted characters. */ if (position_and_selection_are_at_end (editable)) { if (entry_would_have_inserted_characters (keyevent)) { if (location_entry->details->idle_id == 0) { location_entry->details->idle_id = g_idle_add (try_to_expand_path, location_entry); } } } else { /* FIXME: Also might be good to do this when you click * to change the position or selection. */ if (location_entry->details->idle_id != 0) { g_source_remove (location_entry->details->idle_id); location_entry->details->idle_id = 0; } } }
static void entry_insert_text (GtkWidget *entry, char *new_text, gint new_text_length, gint *position, gpointer data) { int start_pos, end_pos ; gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start_pos, &end_pos) ; if (0 == start_pos && strlen (gtk_entry_get_text (GTK_ENTRY (entry))) == end_pos) { if (strlen (new_text) > 0) { bus_name_entry_set_quiet (entry, TRUE, FALSE) ; gtk_entry_set_text (GTK_ENTRY (entry), new_text) ; bus_name_entry_set_quiet (entry, FALSE, FALSE) ; } g_signal_stop_emission_by_name (G_OBJECT (entry), "insert-text") ; } }
static void ide_editor_frame__search_populate_popup (IdeEditorFrame *self, GtkWidget *popup, GdTaggedEntry *entry) { g_assert (IDE_IS_EDITOR_FRAME (self)); g_assert (GTK_IS_WIDGET (popup)); g_assert (GD_IS_TAGGED_ENTRY (entry)); if (GTK_IS_MENU_SHELL (popup)) { GMenu *menu; GActionGroup *group; GAction *action; GtkEntryBuffer *buffer; GtkClipboard *clipboard; gboolean clipboard_contains_text; gboolean entry_has_selection; group = gtk_widget_get_action_group (GTK_WIDGET (self->search_frame), "search-entry"); menu = ide_application_get_menu_by_id (IDE_APPLICATION_DEFAULT, "ide-editor-frame-search-menu"); gtk_menu_shell_bind_model (GTK_MENU_SHELL (popup), G_MENU_MODEL (menu), NULL, TRUE); clipboard = gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_CLIPBOARD); clipboard_contains_text = gtk_clipboard_wait_is_text_available (clipboard); action = g_action_map_lookup_action (G_ACTION_MAP (group), "paste-clipboard"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), clipboard_contains_text); entry_has_selection = gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), NULL, NULL); action = g_action_map_lookup_action (G_ACTION_MAP (group), "cut-clipboard"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection); action = g_action_map_lookup_action (G_ACTION_MAP (group), "copy-clipboard"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection); action = g_action_map_lookup_action (G_ACTION_MAP (group), "delete-selection"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection); action = g_action_map_lookup_action (G_ACTION_MAP (group), "select-all"); buffer = gtk_entry_get_buffer (GTK_ENTRY (self->search_entry)); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), gtk_entry_buffer_get_length (buffer) > 0); } }
static char* gtkListGetSelectedTextAttrib(Ihandle* ih) { int start, end; GtkEntry* entry; if (!ih->data->has_editbox) return NULL; entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY"); if (gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end)) { char* selectedtext = gtk_editable_get_chars(GTK_EDITABLE(entry), start, end); char* str = iupStrGetMemoryCopy(iupgtkStrConvertFromUTF8(selectedtext)); g_free(selectedtext); return str; } return NULL; }
static char* gtkListGetSelectionPosAttrib(Ihandle* ih) { int start, end; char *str; GtkEntry* entry; if (!ih->data->has_editbox) return NULL; entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY"); if (gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end)) { str = iupStrGetMemory(100); sprintf(str, "%d:%d", (int)start, (int)end); return str; } return NULL; }
void on_copy(GtkAction* act, FmMainWin* win) { GtkWidget* focus = gtk_window_get_focus((GtkWindow*)win); if(GTK_IS_EDITABLE(focus) && gtk_editable_get_selection_bounds((GtkEditable*)focus, NULL, NULL) ) { gtk_editable_copy_clipboard((GtkEditable*)focus); } else { FmPathList* files = fm_folder_view_get_selected_file_paths(FM_FOLDER_VIEW(win->folder_view)); if(files) { fm_clipboard_copy_files(win, files); fm_list_unref(files); } } }
static void file_entry_populate_popup (GtkEntry *entry, GtkMenu *menu, gpointer storage) { GtkWidget *submenu, *item; GtkWidget *entry_file; item = gtk_separator_menu_item_new (); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); item = gtk_menu_item_new_with_mnemonic (_("Selection to")); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu); item = gtk_menu_item_new_with_label (_("Title")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_title), storage); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); item = gtk_menu_item_new_with_label (_("Artist")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_artist), storage); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); item = gtk_menu_item_new_with_label (_("Album")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_album), storage); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); item = gtk_menu_item_new_with_label (_("Genre")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_genre), storage); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); item = gtk_menu_item_new_with_label (_("Comment")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_selection_to_comment), storage); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); gtk_widget_show_all (submenu); entry_file = g_object_get_data (storage, "entry_file"); if (!gtk_editable_get_selection_bounds (GTK_EDITABLE(entry_file), NULL, NULL)) gtk_widget_set_sensitive (submenu, FALSE); item = gtk_menu_item_new_with_mnemonic (_("Open folder")); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_open_folder), storage); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); }
void wxComboBox::GetSelection( long* from, long* to ) const { GtkEntry *entry = NULL; #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) entry = GTK_ENTRY( GTK_BIN(m_widget)->child ); else #endif entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry ); if (IsEditable()) { GtkEditable *editable = GTK_EDITABLE(entry); gint start, end; gtk_editable_get_selection_bounds(editable, & start, & end); *from = start; *to = end; } }
static void popup_menu_selection_to_genre (GtkMenuItem *menuitem, gpointer storage) { GtkWidget *entry_file, *entry_genre; gint start_sel, end_sel; gchar *clip = NULL; entry_file = g_object_get_data (storage, "entry_file"); if (!gtk_editable_get_selection_bounds (GTK_EDITABLE(entry_file), &start_sel, &end_sel)) return; clip = gtk_editable_get_chars (GTK_EDITABLE(entry_file), start_sel, end_sel); entry_genre = g_object_get_data (storage, "entry_genre"); gtk_entry_set_text (GTK_ENTRY(entry_genre), clip); gtk_widget_grab_focus(GTK_WIDGET(entry_genre)); g_free(clip); }
static void selection_changed_callback (GtkWidget *widget, gpointer callback_data) { TargetCallbackData *target_data; GtkEditable *editable; int start, end; target_data = (TargetCallbackData *) callback_data; g_assert (target_data != NULL); editable = GTK_EDITABLE (widget); g_assert (editable != NULL); if (gtk_editable_get_selection_bounds (editable, &start, &end) && start != end) { set_clipboard_menu_items_sensitive (target_data->action_group); } else { set_clipboard_menu_items_insensitive (target_data->action_group); } }
static void ekiga_window_append_call_url (EkigaWindow *mw, const char *url) { int pos = -1; GtkEditable *entry; g_return_if_fail (EKIGA_IS_WINDOW (mw)); g_return_if_fail (url != NULL); entry = GTK_EDITABLE (mw->priv->entry); if (gtk_editable_get_selection_bounds (entry, NULL, NULL)) gtk_editable_delete_selection (entry); pos = gtk_editable_get_position (entry); gtk_editable_insert_text (entry, url, strlen (url), &pos); gtk_editable_select_region (entry, -1, -1); gtk_editable_set_position (entry, pos); }
static int gtkListSetSelectedTextAttrib(Ihandle* ih, const char* value) { int start, end; GtkEntry* entry; if (!ih->data->has_editbox) return 0; if (!value) return 0; entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY"); if (gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end)) { /* disable callbacks */ iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", "1"); gtk_editable_delete_selection(GTK_EDITABLE(entry)); gtk_editable_insert_text(GTK_EDITABLE(entry), iupgtkStrConvertToUTF8(value), -1, &start); iupAttribSetStr(ih, "_IUPGTK_DISABLE_TEXT_CB", NULL); } return 0; }
static int delete_selection_in_gtk_entry(GtkEntry *entry, enum UTextOrigin origin, int former_req_len, int latter_req_len) { gint start, end, current_pos; gboolean cursor_at_beginning = FALSE; if (!gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end)) return -1; current_pos = gtk_editable_get_position(GTK_EDITABLE(entry)); if (current_pos == start) cursor_at_beginning = TRUE; if (origin == UTextOrigin_Beginning || (origin == UTextOrigin_Cursor && cursor_at_beginning)) { if (latter_req_len >= 0) { if (latter_req_len < end - start) end = start + latter_req_len; } else { if (!(~latter_req_len & (~UTextExtent_Line | ~UTextExtent_Full))) return -1; } } else if (origin == UTextOrigin_End || (origin == UTextOrigin_Cursor && !cursor_at_beginning)) { if (former_req_len >= 0) { if (former_req_len < end - start) start = end - former_req_len; } else { if (!(~former_req_len & (~UTextExtent_Line | ~UTextExtent_Full))) return -1; } } else { return -1; } gtk_editable_delete_text(GTK_EDITABLE(entry), start, end); return 0; }
static void popup_menu_selection_to_comment (GtkMenuItem *menuitem, gpointer storage) { GtkWidget *entry_file, *entry_comment; GtkTextBuffer *buffer; gint start_sel, end_sel; gchar *clip = NULL; entry_file = g_object_get_data (storage, "entry_file"); if (!gtk_editable_get_selection_bounds (GTK_EDITABLE(entry_file), &start_sel, &end_sel)) return; clip = gtk_editable_get_chars (GTK_EDITABLE(entry_file), start_sel, end_sel); entry_comment = g_object_get_data (storage, "entry_comment"); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (entry_comment)); gtk_text_buffer_set_text (buffer, clip, -1); gtk_widget_grab_focus(GTK_WIDGET(entry_comment)); g_free(clip); }
/************************************************************************** Make a chat link at the current position or make the current selection clickable. **************************************************************************/ void inputline_make_chat_link(struct tile *ptile, bool unit) { char buf[MAX_LEN_MSG]; GtkWidget *entry = toolkit.entry; GtkEditable *editable = GTK_EDITABLE(entry); gint start_pos, end_pos; gchar *chars; struct unit *punit; /* Get the target. */ if (unit) { punit = find_visible_unit(ptile); if (!punit) { output_window_append(ftc_client, _("No visible unit on this tile.")); return; } } else { punit = NULL; } if (gtk_editable_get_selection_bounds(editable, &start_pos, &end_pos)) { /* There is a selection, make it clickable. */ gpointer target; enum text_link_type type; chars = gtk_editable_get_chars(editable, start_pos, end_pos); if (punit) { type = TLT_UNIT; target = punit; } else if (tile_city(ptile)) { type = TLT_CITY; target = tile_city(ptile); } else { type = TLT_TILE; target = ptile; } if (0 != featured_text_apply_tag(chars, buf, sizeof(buf), TTT_LINK, 0, FT_OFFSET_UNSET, type, target)) { /* Replace the selection. */ gtk_editable_delete_text(editable, start_pos, end_pos); end_pos = start_pos; gtk_editable_insert_text(editable, buf, -1, &end_pos); gtk_widget_grab_focus(entry); gtk_editable_select_region(editable, start_pos, end_pos); } } else { /* Just insert the link at the current position. */ start_pos = gtk_editable_get_position(editable); end_pos = start_pos; chars = gtk_editable_get_chars(editable, MAX(start_pos - 1, 0), start_pos + 1); if (punit) { sz_strlcpy(buf, unit_link(punit)); } else if (tile_city(ptile)) { sz_strlcpy(buf, city_link(tile_city(ptile))); } else { sz_strlcpy(buf, tile_link(ptile)); } if (start_pos > 0 && strlen(chars) > 0 && chars[0] != ' ') { /* Maybe insert an extra space. */ gtk_editable_insert_text(editable, " ", 1, &end_pos); } gtk_editable_insert_text(editable, buf, -1, &end_pos); if (chars[start_pos > 0 ? 1 : 0] != '\0' && chars[start_pos > 0 ? 1 : 0] != ' ') { /* Maybe insert an extra space. */ gtk_editable_insert_text(editable, " ", 1, &end_pos); } gtk_widget_grab_focus(entry); gtk_editable_set_position(editable, end_pos); } g_free(chars); }
static gboolean entry_event (GtkEditable *entry, GdkEventKey *event, PanelRunDialog *dialog) { GtkTreeSelection *selection; char *prefix; char *nospace_prefix; char *nprefix; char *temp; int pos, tmp; if (event->type != GDK_KEY_PRESS) return FALSE; /* if user typed something we're not using the list anymore */ dialog->use_program_list = FALSE; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->program_list)); gtk_tree_selection_unselect_all (selection); if (!panel_profile_get_enable_autocompletion ()) return FALSE; /* tab completion */ if (event->keyval == GDK_KEY_Tab) { gtk_editable_get_selection_bounds (entry, &pos, &tmp); if (dialog->completion_started && pos != tmp && pos != 1 && tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) { gtk_editable_select_region (entry, 0, 0); gtk_editable_set_position (entry, -1); return TRUE; } } else if (event->length > 0) { gtk_editable_get_selection_bounds (entry, &pos, &tmp); if (dialog->completion_started && pos != tmp && pos != 0 && tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) { temp = gtk_editable_get_chars (entry, 0, pos); prefix = g_strconcat (temp, event->string, NULL); g_free (temp); } else if (pos == tmp && tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) { prefix = g_strconcat (gtk_entry_get_text (GTK_ENTRY (entry)), event->string, NULL); } else { return FALSE; } nospace_prefix = prefix; while (*nospace_prefix != '\0' && g_ascii_isspace (*nospace_prefix)) nospace_prefix++; if (*nospace_prefix == '\0') return FALSE; panel_run_dialog_update_completion (dialog, nospace_prefix); if (!dialog->completion) { g_free (prefix); return FALSE; } pos = strlen (prefix); nprefix = NULL; g_completion_complete_utf8 (dialog->completion, nospace_prefix, &nprefix); if (nprefix) { int insertpos; insertpos = 0; temp = g_strndup (prefix, nospace_prefix - prefix); g_free (prefix); prefix = g_strconcat (temp, nprefix, NULL); g_signal_handler_block (dialog->combobox, dialog->changed_id); gtk_editable_delete_text (entry, 0, -1); g_signal_handler_unblock (dialog->combobox, dialog->changed_id); gtk_editable_insert_text (entry, prefix, strlen (prefix), &insertpos); gtk_editable_set_position (entry, pos); gtk_editable_select_region (entry, pos, -1); dialog->completion_started = TRUE; g_free (temp); g_free (nprefix); g_free (prefix); return TRUE; } g_free (prefix); } return FALSE; }
int im_uim_acquire_selection_text(IMUIMContext *uic, enum UTextOrigin origin, int former_req_len, int latter_req_len, char **former, char **latter) { gchar *former_start, *text = NULL, *p; gint len, text_len; int offset, err = 0; gboolean cursor_at_beginning = FALSE; if (GTK_IS_ENTRY(uic->widget)) { gint start, end, current; if (gtk_editable_get_selection_bounds(GTK_EDITABLE(uic->widget), &start, &end)) { text = gtk_editable_get_chars(GTK_EDITABLE(uic->widget), start, end); current = gtk_editable_get_position(GTK_EDITABLE(uic->widget)); if (current == start) cursor_at_beginning = TRUE; } } else if (GTK_IS_TEXT_VIEW(uic->widget)) { GtkTextIter start, end, current; if (gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)) && gtk_text_buffer_get_selection_bounds(gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)), &start, &end)) { text = gtk_text_iter_get_visible_text(&start, &end); gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)), ¤t, gtk_text_buffer_get_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)), "insert")); if (gtk_text_iter_compare(&start, ¤t) == 0) cursor_at_beginning = TRUE; } } else { /* * We use GDK_SELECTION_PRIMARY for the rest of widget, which means it is * impossible to guarantee whether the obtained one is the selected text on * the target application. */ text = gtk_clipboard_wait_for_text(gtk_widget_get_clipboard(GTK_WIDGET(uic->widget), GDK_SELECTION_PRIMARY)); } if (!text) return -1; len = strlen(text); text_len = g_utf8_strlen(text, -1); if (origin == UTextOrigin_Beginning || (origin == UTextOrigin_Cursor && cursor_at_beginning)) { *former = NULL; offset = 0; if (latter_req_len >= 0) { if (latter_req_len < text_len) offset = text + len - g_utf8_offset_to_pointer(text, latter_req_len); } else { if (!(~latter_req_len & (~UTextExtent_Line | ~UTextExtent_Full))) { g_free(text); return -1; } } *latter = g_strndup(text, len - offset); if (latter_req_len == UTextExtent_Line && (p = strchr(*latter, '\n'))) *p = '\0'; } else if (origin == UTextOrigin_End || (origin == UTextOrigin_Cursor && !cursor_at_beginning)) { offset = 0; if (former_req_len >= 0) { if (former_req_len < text_len) offset = text_len - former_req_len; } else { if (!(~former_req_len & (~UTextExtent_Line | ~UTextExtent_Full))) { g_free(text); return -1; } } former_start = g_utf8_offset_to_pointer(text, offset); if (former_req_len == UTextExtent_Line && (p = strrchr(former_start, '\n'))) *former = g_strdup(p + 1); else *former = g_strndup(former_start, text + len - former_start); *latter = NULL; } else { err = -1; } g_free(text); return err; }
/* Draw method handler for the icon text item */ static void mate_icon_text_item_draw (MateCanvasItem *item, GdkDrawable *drawable, int x, int y, int width, int height) { GtkWidget *widget; GtkStyle *style; int xofs, yofs; int text_xofs, text_yofs; int w, h; MateIconTextItem *iti; MateIconTextItemPrivate *priv; GtkStateType state; widget = GTK_WIDGET (item->canvas); iti = MATE_ICON_TEXT_ITEM (item); priv = iti->_priv; style = GTK_WIDGET (MATE_CANVAS_ITEM (iti)->canvas)->style; w = priv->layout_width + 2 * MARGIN_X; h = priv->layout_height + 2 * MARGIN_Y; xofs = item->x1 - x; yofs = item->y1 - y; text_xofs = xofs - (iti->width - priv->layout_width - 2 * MARGIN_X) / 2; text_yofs = yofs + MARGIN_Y; if (iti->selected && GTK_WIDGET_HAS_FOCUS (widget)) state = GTK_STATE_SELECTED; else if (iti->selected) state = GTK_STATE_ACTIVE; else state = GTK_STATE_NORMAL; if (iti->selected && !iti->editing) gdk_draw_rectangle (drawable, style->base_gc[state], TRUE, xofs + 1, yofs + 1, w - 2, h - 2); if (GTK_WIDGET_HAS_FOCUS (widget) && iti->focused && ! iti->editing) { GdkRectangle r; r.x = xofs; r.y = yofs; r.width = w - 1; r.height = h - 1; gtk_paint_focus (style, drawable, iti->selected ? GTK_STATE_SELECTED: GTK_STATE_NORMAL, &r, widget, NULL, xofs, yofs, w - 1, h - 1); #if 0 gtk_draw_focus (style, drawable, xofs, yofs, w - 1, h - 1); #endif } if (iti->editing) { /* FIXME: are these the right graphics contexts? */ gdk_draw_rectangle (drawable, style->base_gc[GTK_STATE_NORMAL], TRUE, xofs, yofs, w - 1, h - 1); gdk_draw_rectangle (drawable, style->fg_gc[GTK_STATE_NORMAL], FALSE, xofs, yofs, w - 1, h - 1); } gdk_draw_layout (drawable, style->text_gc[iti->editing ? GTK_STATE_NORMAL : state], text_xofs, text_yofs, priv->layout); if (iti->editing) { int range[2]; if (gtk_editable_get_selection_bounds (GTK_EDITABLE (priv->entry), &range[0], &range[1])) { GdkRegion *clip_region; GdkColor *selection_color, *text_color; guint8 state; range[0] = g_utf8_offset_to_pointer (GTK_ENTRY (priv->entry)->text, range[0]) - GTK_ENTRY (priv->entry)->text; range[1] = g_utf8_offset_to_pointer (GTK_ENTRY (priv->entry)->text, range[1]) - GTK_ENTRY (priv->entry)->text; state = GTK_WIDGET_HAS_FOCUS (widget) ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE; selection_color = &widget->style->base[state]; text_color = &widget->style->text[state]; clip_region = gdk_pango_layout_get_clip_region (priv->layout, text_xofs, text_yofs, range, 1); gdk_gc_set_clip_region (widget->style->black_gc, clip_region); gdk_draw_layout_with_colors (drawable, widget->style->black_gc, text_xofs, text_yofs, priv->layout, text_color, selection_color); gdk_gc_set_clip_region (widget->style->black_gc, NULL); gdk_region_destroy (clip_region); } else { iti_draw_cursor (iti, drawable, text_xofs, text_yofs); } } }