コード例 #1
0
ファイル: testentryicons.c プロジェクト: BYC/gtk
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
    }
}
コード例 #2
0
ファイル: callbacks.c プロジェクト: eaglexmw/gtkhash
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);
}
コード例 #3
0
ファイル: gtkeditable.c プロジェクト: rightpeter/gtk-1
/**
 * 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);
}
コード例 #4
0
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);
}
コード例 #5
0
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;
}
コード例 #6
0
ファイル: text-entry.c プロジェクト: xchat-gnome/xchat-gnome
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);
        }
}
コード例 #7
0
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;
}
コード例 #8
0
ファイル: nautilus-entry.c プロジェクト: barkinet/nautilus
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;
}
コード例 #9
0
ファイル: wbc-gtk-edit.c プロジェクト: nzinfo/gnumeric
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);
}
コード例 #10
0
ファイル: chatline.c プロジェクト: longturn/freeciv-S2_5
/**************************************************************************
  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);
}
コード例 #11
0
ファイル: misc.c プロジェクト: jjk-jacky/donnatella
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;
}
コード例 #12
0
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;
		}
	}
}
コード例 #13
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") ;
    }
  }
コード例 #14
0
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);
    }
}
コード例 #15
0
ファイル: iupgtk_list.c プロジェクト: svn2github/iup-iup
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;
}
コード例 #16
0
ファイル: iupgtk_list.c プロジェクト: svn2github/iup-iup
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;
}
コード例 #17
0
ファイル: main-win.c プロジェクト: gilir/libfm-debian
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);
        }
    }
}
コード例 #18
0
ファイル: tags.c プロジェクト: matiasdelellis/dissonance
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);
}
コード例 #19
0
ファイル: combobox.cpp プロジェクト: czxxjtu/wxPython-1
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;
    }
}
コード例 #20
0
ファイル: tags.c プロジェクト: matiasdelellis/dissonance
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);
}
コード例 #21
0
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);
	}
}
コード例 #22
0
ファイル: ekiga-window.cpp プロジェクト: GNOME/ekiga
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);
}
コード例 #23
0
ファイル: iupgtk_list.c プロジェクト: svn2github/iup-iup
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;
}
コード例 #24
0
ファイル: text-util.c プロジェクト: TheSLinux-forks/uim
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;
}
コード例 #25
0
ファイル: tags.c プロジェクト: matiasdelellis/dissonance
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);
}
コード例 #26
0
ファイル: chatline.c プロジェクト: longturn/freeciv-S2_5
/**************************************************************************
  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);
}
コード例 #27
0
ファイル: panel-run-dialog.c プロジェクト: braikar/mate-panel
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;
}
コード例 #28
0
ファイル: text-util.c プロジェクト: TheSLinux-forks/uim
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)),
				       &current,
				       gtk_text_buffer_get_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(uic->widget)), "insert"));
      if (gtk_text_iter_compare(&start, &current) == 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;
}
コード例 #29
0
/* 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);
        }
    }
}