#include "gtkdialog.h"
#include "gtkmessagedialog.h"
#include "gtkintl.h"
+#include "gtkdnd.h"
+#include "gtkeventbox.h"
#if defined(G_OS_WIN32) || defined(G_WITH_CYGWIN)
#define STRICT
GtkWidget *confirm_area;
GtkWidget *pulldown_hbox;
GtkWidget *scrolled_win;
+ GtkWidget *eventbox;
GtkDialog *dialog;
char *dir_title [2];
entry_vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE, 2);
gtk_widget_show (entry_vbox);
-
+
+ eventbox = gtk_event_box_new ();
filesel->selection_text = label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (entry_vbox), label, FALSE, FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (eventbox), label);
+ gtk_box_pack_start (GTK_BOX (entry_vbox), eventbox, FALSE, FALSE, 0);
gtk_widget_show (label);
+ gtk_widget_show (eventbox);
filesel->selection_entry = gtk_entry_new ();
gtk_signal_connect (GTK_OBJECT (filesel->selection_entry), "key_press_event",
gtk_widget_grab_focus (filesel->selection_entry);
}
+static gchar *
+uri_list_extract_first_uri (const gchar* uri_list)
+{
+ const gchar *p, *q;
+
+ g_return_val_if_fail (uri_list != NULL, NULL);
+
+ p = uri_list;
+ /* We don't actually try to validate the URI according to RFC
+ * 2396, or even check for allowed characters - we just ignore
+ * comments and trim whitespace off the ends. We also
+ * allow LF delimination as well as the specified CRLF.
+ *
+ * We do allow comments like specified in RFC 2483.
+ */
+ while (p)
+ {
+ if (*p != '#')
+ {
+ while (g_ascii_isspace(*p))
+ p++;
+
+ q = p;
+ while (*q && (*q != '\n') && (*q != '\r'))
+ q++;
+
+ if (q > p)
+ {
+ q--;
+ while (q > p && g_ascii_isspace (*q))
+ q--;
+
+ if (q > p)
+ return g_strndup (p, q - p + 1);
+ }
+ }
+ p = strchr (p, '\n');
+ if (p)
+ p++;
+ }
+ return NULL;
+}
+
+static void
+dnd_really_drop (GtkWidget *dialog, gint response_id, GtkFileSelection *fs)
+{
+ gchar *filename;
+
+ if (response_id == GTK_RESPONSE_YES)
+ {
+ filename = g_object_get_data (G_OBJECT (dialog), "gtk-fs-dnd-filename");
+
+ gtk_file_selection_set_filename (fs, filename);
+ }
+
+ gtk_widget_destroy (dialog);
+}
+
+
+static void
+filenames_dropped (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint time)
+{
+ char *uri = NULL;
+ char *filename = NULL;
+ char *hostname;
+ char this_hostname[257];
+ int res;
+ GError *error = NULL;
+
+ if (!selection_data->data)
+ return;
+
+ uri = uri_list_extract_first_uri ((char *)selection_data->data);
+
+ if (!uri)
+ return;
+
+ filename = g_filename_from_uri (uri, &hostname, &error);
+ g_free (uri);
+
+ if (!filename)
+ {
+ g_warning ("Error getting dropped filename: %s\n",
+ error->message);
+ g_error_free (error);
+ return;
+ }
+
+ res = gethostname (this_hostname, 256);
+ this_hostname[256] = 0;
+
+ if ((hostname == NULL) ||
+ (res == 0 && strcmp (hostname, this_hostname) == 0) ||
+ (strcmp (hostname, "localhost") == 0))
+ gtk_file_selection_set_filename (GTK_FILE_SELECTION (widget),
+ filename);
+ else
+ {
+ GtkWidget *dialog;
+
+ dialog = gtk_message_dialog_new (GTK_WINDOW (widget),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_QUESTION,
+ GTK_BUTTONS_YES_NO,
+ _("The file \"%s\" resides on another machine (called %s) and may not be availible to this program.\n"
+ "Are you sure that you want to select it?"), filename, hostname);
+
+ g_object_set_data_full (G_OBJECT (dialog), "gtk-fs-dnd-filename", g_strdup (filename), g_free);
+
+ g_signal_connect_data (dialog, "response",
+ (GCallback) dnd_really_drop,
+ widget, NULL, 0);
+
+ gtk_widget_show (dialog);
+ }
+
+ g_free (hostname);
+ g_free (filename);
+}
+
+enum
+{
+ TARGET_URILIST,
+ TARGET_UTF8_STRING,
+ TARGET_STRING,
+ TARGET_TEXT,
+ TARGET_COMPOUND_TEXT
+};
+
+
+static void
+filenames_drag_get (GtkWidget *widget,
+ GdkDragContext *context,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint time,
+ GtkFileSelection *filesel)
+{
+ gchar *file;
+ gchar *uri_list;
+ char hostname[256];
+ int res;
+ GError *error;
+
+ file = gtk_file_selection_get_filename (filesel);
+
+ if (file)
+ {
+ if (info == TARGET_URILIST)
+ {
+ res = gethostname (hostname, 256);
+
+ error = NULL;
+ uri_list = g_filename_to_uri (file, (!res)?hostname:NULL, &error);
+ if (!uri_list)
+ {
+ g_warning ("Error getting filename: %s\n",
+ error->message);
+ g_error_free (error);
+ return;
+ }
+
+ gtk_selection_data_set (selection_data,
+ selection_data->target, 8,
+ (void *)uri_list, strlen((char *)uri_list));
+ g_free (uri_list);
+ }
+ else
+ {
+ g_print ("Setting text: '%s'\n", file);
+ gtk_selection_data_set_text (selection_data, file);
+ }
+ }
+}
+
+static void
+file_selection_setup_dnd (GtkFileSelection *filesel)
+{
+ GtkWidget *eventbox;
+ static GtkTargetEntry drop_types[] = {
+ { "text/uri-list", 0, TARGET_URILIST}
+ };
+ static gint n_drop_types = sizeof(drop_types)/sizeof(drop_types[0]);
+ static GtkTargetEntry drag_types[] = {
+ { "text/uri-list", 0, TARGET_URILIST},
+ { "UTF8_STRING", 0, TARGET_UTF8_STRING },
+ { "STRING", 0, 0 },
+ { "TEXT", 0, 0 },
+ { "COMPOUND_TEXT", 0, 0 }
+ };
+ static gint n_drag_types = sizeof(drag_types)/sizeof(drag_types[0]);
+
+ gtk_drag_dest_set (GTK_WIDGET (filesel),
+ GTK_DEST_DEFAULT_ALL,
+ drop_types, n_drop_types,
+ GDK_ACTION_COPY);
+
+ gtk_signal_connect (GTK_OBJECT(filesel), "drag_data_received",
+ GTK_SIGNAL_FUNC(filenames_dropped), NULL);
+
+ eventbox = gtk_widget_get_parent (filesel->selection_text);
+ gtk_drag_source_set (eventbox,
+ GDK_BUTTON1_MASK,
+ drag_types, n_drag_types,
+ GDK_ACTION_COPY);
+
+ gtk_signal_connect (GTK_OBJECT (eventbox),
+ "drag_data_get",
+ GTK_SIGNAL_FUNC (filenames_drag_get),
+ filesel);
+}
+
GtkWidget*
gtk_file_selection_new (const gchar *title)
{
gtk_window_set_title (GTK_WINDOW (filesel), title);
gtk_dialog_set_has_separator (GTK_DIALOG (filesel), FALSE);
+ file_selection_setup_dnd (filesel);
+
return GTK_WIDGET (filesel);
}
#include <math.h>
#include <string.h>
#include "gtklabel.h"
+#include "gtkmain.h"
#include "gtksignal.h"
#include "gtkwindow.h"
#include "gdk/gdkkeysyms.h"
#include "gdk/gdki18n.h"
#include <pango/pango.h>
#include "gtkintl.h"
+#include "gtkseparatormenuitem.h"
#include "gtkmenuitem.h"
#include "gtknotebook.h"
+#include "gtkbindings.h"
struct _GtkLabelSelectionInfo
{
GdkWindow *window;
gint selection_anchor;
gint selection_end;
+ GdkGC *cursor_gc;
+ GtkWidget *popup_menu;
};
+enum {
+ MOVE_CURSOR,
+ COPY_CLIPBOARD,
+ POPULATE_POPUP,
+ LAST_SIGNAL
+};
enum {
PROP_0,
PROP_MNEMONIC_WIDGET
};
+static guint signals[LAST_SIGNAL] = { 0 };
+
static void gtk_label_class_init (GtkLabelClass *klass);
static void gtk_label_init (GtkLabel *label);
static void gtk_label_set_property (GObject *object,
gint anchor_index,
gint end_index);
-static gboolean gtk_label_mnemonic_activate (GtkWidget *widget,
- gboolean group_cycling);
-static void gtk_label_setup_mnemonic (GtkLabel *label,
- guint last_key);
-
+static gboolean gtk_label_mnemonic_activate (GtkWidget *widget,
+ gboolean group_cycling);
+static void gtk_label_setup_mnemonic (GtkLabel *label,
+ guint last_key);
+static gboolean gtk_label_focus (GtkWidget *widget,
+ GtkDirectionType direction);
+
+/* For selectable lables: */
+static void gtk_label_move_cursor (GtkLabel *label,
+ GtkMovementStep step,
+ gint count,
+ gboolean extend_selection);
+static void gtk_label_copy_clipboard (GtkLabel *label);
+static void gtk_label_select_all (GtkLabel *label);
+static void gtk_label_do_popup (GtkLabel *label,
+ GdkEventButton *event);
+
+static gint gtk_label_move_forward_word (GtkLabel *label,
+ gint start);
+static gint gtk_label_move_backward_word (GtkLabel *label,
+ gint start);
static GtkMiscClass *parent_class = NULL;
return label_type;
}
+static void
+add_move_binding (GtkBindingSet *binding_set,
+ guint keyval,
+ guint modmask,
+ GtkMovementStep step,
+ gint count)
+{
+ g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);
+
+ gtk_binding_entry_add_signal (binding_set, keyval, modmask,
+ "move_cursor", 3,
+ GTK_TYPE_ENUM, step,
+ G_TYPE_INT, count,
+ G_TYPE_BOOLEAN, FALSE);
+
+ /* Selection-extending version */
+ gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
+ "move_cursor", 3,
+ GTK_TYPE_ENUM, step,
+ G_TYPE_INT, count,
+ G_TYPE_BOOLEAN, TRUE);
+}
+
static void
gtk_label_class_init (GtkLabelClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+ GtkBindingSet *binding_set;
parent_class = gtk_type_class (GTK_TYPE_MISC);
widget_class->motion_notify_event = gtk_label_motion;
widget_class->hierarchy_changed = gtk_label_hierarchy_changed;
widget_class->mnemonic_activate = gtk_label_mnemonic_activate;
+ widget_class->focus = gtk_label_focus;
+
+ class->move_cursor = gtk_label_move_cursor;
+ class->copy_clipboard = gtk_label_copy_clipboard;
+
+ signals[MOVE_CURSOR] =
+ gtk_signal_new ("move_cursor",
+ GTK_RUN_LAST | GTK_RUN_ACTION,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkLabelClass, move_cursor),
+ gtk_marshal_VOID__ENUM_INT_BOOLEAN,
+ GTK_TYPE_NONE, 3, GTK_TYPE_MOVEMENT_STEP, GTK_TYPE_INT, GTK_TYPE_BOOL);
+
+ signals[COPY_CLIPBOARD] =
+ gtk_signal_new ("copy_clipboard",
+ GTK_RUN_LAST | GTK_RUN_ACTION,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkLabelClass, copy_clipboard),
+ gtk_marshal_VOID__VOID,
+ GTK_TYPE_NONE, 0);
+
+ signals[POPULATE_POPUP] =
+ gtk_signal_new ("populate_popup",
+ GTK_RUN_LAST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkLabelClass, populate_popup),
+ gtk_marshal_VOID__OBJECT,
+ GTK_TYPE_NONE, 1, GTK_TYPE_MENU);
g_object_class_install_property (G_OBJECT_CLASS(object_class),
PROP_LABEL,
"key is pressed."),
GTK_TYPE_WIDGET,
G_PARAM_READWRITE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boxed ("cursor_color",
+ _("Cursor color"),
+ _("Color with which to draw insertion cursor"),
+ GDK_TYPE_COLOR,
+ G_PARAM_READABLE));
+
+ /*
+ * Key bindings
+ */
+
+ binding_set = gtk_binding_set_by_class (class);
+
+ /* Moving the insertion point */
+ add_move_binding (binding_set, GDK_Right, 0,
+ GTK_MOVEMENT_VISUAL_POSITIONS, 1);
+
+ add_move_binding (binding_set, GDK_Left, 0,
+ GTK_MOVEMENT_VISUAL_POSITIONS, -1);
+
+ add_move_binding (binding_set, GDK_KP_Right, 0,
+ GTK_MOVEMENT_VISUAL_POSITIONS, 1);
+
+ add_move_binding (binding_set, GDK_KP_Left, 0,
+ GTK_MOVEMENT_VISUAL_POSITIONS, -1);
+
+ add_move_binding (binding_set, GDK_f, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_LOGICAL_POSITIONS, 1);
+
+ add_move_binding (binding_set, GDK_b, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_LOGICAL_POSITIONS, -1);
+
+ add_move_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_WORDS, 1);
+
+ add_move_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_WORDS, -1);
+
+ add_move_binding (binding_set, GDK_KP_Right, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_WORDS, 1);
+
+ add_move_binding (binding_set, GDK_KP_Left, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_WORDS, -1);
+
+ add_move_binding (binding_set, GDK_a, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_PARAGRAPH_ENDS, -1);
+
+ add_move_binding (binding_set, GDK_e, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_PARAGRAPH_ENDS, 1);
+
+ add_move_binding (binding_set, GDK_f, GDK_MOD1_MASK,
+ GTK_MOVEMENT_WORDS, 1);
+
+ add_move_binding (binding_set, GDK_b, GDK_MOD1_MASK,
+ GTK_MOVEMENT_WORDS, -1);
+
+ add_move_binding (binding_set, GDK_Home, 0,
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
+
+ add_move_binding (binding_set, GDK_End, 0,
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
+
+ add_move_binding (binding_set, GDK_KP_Home, 0,
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
+
+ add_move_binding (binding_set, GDK_KP_End, 0,
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
+
+ add_move_binding (binding_set, GDK_Home, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_BUFFER_ENDS, -1);
+
+ add_move_binding (binding_set, GDK_End, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_BUFFER_ENDS, 1);
+
+ add_move_binding (binding_set, GDK_KP_Home, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_BUFFER_ENDS, -1);
+
+ add_move_binding (binding_set, GDK_KP_End, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_BUFFER_ENDS, 1);
+
+ /* copy */
+ gtk_binding_entry_add_signal (binding_set, GDK_c, GDK_CONTROL_MASK,
+ "copy_clipboard", 0);
}
static void
*yp = y;
}
+static void
+gtk_label_draw_cursor (GtkLabel *label, gint xoffset, gint yoffset)
+{
+ if (label->select_info == NULL)
+ return;
+
+ if (GTK_WIDGET_DRAWABLE (label))
+ {
+ GtkWidget *widget = GTK_WIDGET (label);
+
+ GtkTextDirection keymap_direction;
+ GtkTextDirection widget_direction;
+ PangoRectangle strong_pos, weak_pos;
+ gboolean split_cursor;
+ PangoRectangle *cursor1 = NULL;
+ PangoRectangle *cursor2 = NULL;
+ GdkGC *gc1 = NULL;
+ GdkGC *gc2 = NULL;
+
+ keymap_direction =
+ (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+
+ widget_direction = gtk_widget_get_direction (widget);
+
+ gtk_label_ensure_layout (label, NULL, NULL);
+
+ pango_layout_get_cursor_pos (label->layout, label->select_info->selection_end,
+ &strong_pos, &weak_pos);
+
+ g_object_get (gtk_widget_get_settings (widget),
+ "gtk-split-cursor", &split_cursor,
+ NULL);
+
+ if (split_cursor)
+ {
+ gc1 = label->select_info->cursor_gc;
+ cursor1 = &strong_pos;
+
+ if (strong_pos.x != weak_pos.x ||
+ strong_pos.y != weak_pos.y)
+ {
+ gc2 = widget->style->black_gc;
+ cursor2 = &weak_pos;
+ }
+ }
+ else
+ {
+ gc1 = label->select_info->cursor_gc;
+
+ if (keymap_direction == widget_direction)
+ cursor1 = &strong_pos;
+ else
+ cursor1 = &weak_pos;
+ }
+
+ gdk_draw_line (widget->window, gc1,
+ xoffset + PANGO_PIXELS (cursor1->x), yoffset + PANGO_PIXELS (cursor1->y),
+ xoffset + PANGO_PIXELS (cursor1->x), yoffset + PANGO_PIXELS (cursor1->y + cursor1->height));
+
+ if (gc2)
+ gdk_draw_line (widget->window, gc2,
+ xoffset + PANGO_PIXELS (cursor2->x), yoffset + PANGO_PIXELS (cursor2->y),
+ xoffset + PANGO_PIXELS (cursor2->x), yoffset + PANGO_PIXELS (cursor2->y + cursor2->height));
+ }
+}
+
+
static gint
gtk_label_expose (GtkWidget *widget,
GdkEventExpose *event)
{
gint range[2];
GdkRegion *clip;
-
+ GtkStateType state;
+
range[0] = label->select_info->selection_anchor;
range[1] = label->select_info->selection_end;
* region
*/
- gdk_gc_set_clip_region (widget->style->white_gc, clip);
-
+ gdk_gc_set_clip_region (widget->style->black_gc, clip);
+
+
+ state = GTK_STATE_SELECTED;
+ if (!GTK_WIDGET_HAS_FOCUS (widget))
+ state = GTK_STATE_ACTIVE;
+
gdk_draw_layout_with_colors (widget->window,
- widget->style->white_gc,
+ widget->style->black_gc,
x, y,
label->layout,
- &widget->style->fg[GTK_STATE_SELECTED],
- &widget->style->bg[GTK_STATE_SELECTED]);
+ &widget->style->text[state],
+ &widget->style->base[state]);
- gdk_gc_set_clip_region (widget->style->white_gc, NULL);
+ gdk_gc_set_clip_region (widget->style->black_gc, NULL);
gdk_region_destroy (clip);
}
+ else if (label->select_info && GTK_WIDGET_HAS_FOCUS (widget))
+ gtk_label_draw_cursor (label, x, y);
}
return TRUE;
gtk_label_setup_mnemonic (label, last_keyval);
}
+static void
+gtk_label_realize_cursor_gc (GtkLabel *label)
+{
+ GdkColor *cursor_color;
+ GdkColor red = {0, 0xffff, 0x0000, 0x0000};
+
+ if (label->select_info == NULL)
+ return;
+
+ if (label->select_info->cursor_gc)
+ gdk_gc_unref (label->select_info->cursor_gc);
+
+ gtk_widget_style_get (GTK_WIDGET (label), "cursor_color", &cursor_color, NULL);
+ label->select_info->cursor_gc = gdk_gc_new (GTK_WIDGET (label)->window);
+ if (cursor_color)
+ gdk_gc_set_rgb_fg_color (label->select_info->cursor_gc, cursor_color);
+ else
+ gdk_gc_set_rgb_fg_color (label->select_info->cursor_gc, &red);
+}
static void
gtk_label_realize (GtkWidget *widget)
(* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
if (label->select_info)
- gtk_label_create_window (label);
+ {
+ gtk_label_create_window (label);
+ gtk_label_realize_cursor_gc (label);
+ }
+}
+
+static void
+gtk_label_unrealize_cursor_gc (GtkLabel *label)
+{
+ if (label->select_info == NULL)
+ return;
+
+ if (label->select_info->cursor_gc)
+ {
+ gdk_gc_unref (label->select_info->cursor_gc);
+ label->select_info->cursor_gc = NULL;
+ }
}
static void
label = GTK_LABEL (widget);
if (label->select_info)
- gtk_label_destroy_window (label);
+ {
+ gtk_label_unrealize_cursor_gc (label);
+ gtk_label_destroy_window (label);
+ }
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
*index += (cluster_end - cluster);
}
+static void
+gtk_label_select_word (GtkLabel *label)
+{
+ gint min, max;
+
+ gint start_index = gtk_label_move_backward_word (label, label->select_info->selection_end);
+ gint end_index = gtk_label_move_forward_word (label, label->select_info->selection_end);
+
+ min = MIN (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+ max = MAX (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+
+ min = MIN (min, start_index);
+ max = MAX (max, end_index);
+
+ gtk_label_select_region_index (label, min, max);
+}
+
static gint
gtk_label_button_press (GtkWidget *widget,
GdkEventButton *event)
if (label->select_info == NULL)
return FALSE;
- if (event->button != 1)
- return FALSE;
-
- get_layout_index (label, event->x, event->y, &index);
-
- if ((label->select_info->selection_anchor !=
- label->select_info->selection_end) &&
- (event->state & GDK_SHIFT_MASK))
+ if (event->button == 1)
{
- /* extend (same as motion) */
- if (index < label->select_info->selection_end)
- gtk_label_select_region_index (label,
- index,
- label->select_info->selection_end);
- else
- gtk_label_select_region_index (label,
- label->select_info->selection_anchor,
- index);
+ if (!GTK_WIDGET_HAS_FOCUS (widget))
+ gtk_widget_grab_focus (widget);
- /* ensure the anchor is opposite index */
- if (index == label->select_info->selection_anchor)
- {
- gint tmp = label->select_info->selection_end;
- label->select_info->selection_end = label->select_info->selection_anchor;
- label->select_info->selection_anchor = tmp;
- }
+ if (event->type == GDK_3BUTTON_PRESS)
+ {
+ gtk_label_select_region_index (label, 0, strlen (label->label));
+ return TRUE;
+ }
+
+ if (event->type == GDK_2BUTTON_PRESS)
+ {
+ gtk_label_select_word (label);
+ return TRUE;
+ }
+
+ get_layout_index (label, event->x, event->y, &index);
+
+ if ((label->select_info->selection_anchor !=
+ label->select_info->selection_end) &&
+ (event->state & GDK_SHIFT_MASK))
+ {
+ gint min, max;
+
+ /* extend (same as motion) */
+ min = MIN (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+ max = MAX (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+
+ min = MIN (min, index);
+ max = MAX (max, index);
+
+ gtk_label_select_region_index (label,
+ min,
+ max);
+
+ /* ensure the anchor is opposite index */
+ if (index == label->select_info->selection_anchor)
+ {
+ gint tmp = label->select_info->selection_end;
+ label->select_info->selection_end = label->select_info->selection_anchor;
+ label->select_info->selection_anchor = tmp;
+ }
+ }
+ else
+ {
+ if (event->type == GDK_3BUTTON_PRESS)
+ gtk_label_select_region_index (label, 0, strlen (label->label));
+ else if (event->type == GDK_2BUTTON_PRESS)
+ gtk_label_select_word (label);
+ else
+ /* start a replacement */
+ gtk_label_select_region_index (label, index, index);
+ }
+
+ return TRUE;
}
- else
+ else if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
{
- /* start a replacement */
- gtk_label_select_region_index (label, index, index);
+ gtk_label_do_popup (label, event);
+
+ return TRUE;
+
}
-
- return TRUE;
+ return FALSE;
}
static gint
{
if (label->select_info == NULL)
{
- label->select_info = g_new (GtkLabelSelectionInfo, 1);
-
- label->select_info->window = NULL;
- label->select_info->selection_anchor = 0;
- label->select_info->selection_end = 0;
+ label->select_info = g_new0 (GtkLabelSelectionInfo, 1);
+ GTK_WIDGET_SET_FLAGS (label, GTK_CAN_FOCUS);
+
if (GTK_WIDGET_REALIZED (label))
- gtk_label_create_window (label);
+ {
+ gtk_label_create_window (label);
+ gtk_label_realize_cursor_gc (label);
+ }
if (GTK_WIDGET_MAPPED (label))
gdk_window_show (label->select_info->window);
/* unselect, to give up the selection */
gtk_label_select_region (label, 0, 0);
+ gtk_label_unrealize_cursor_gc (label);
+
if (label->select_info->window)
- gtk_label_destroy_window (label);
+ {
+ gtk_label_destroy_window (label);
+ }
g_free (label->select_info);
label->select_info = NULL;
+
+ GTK_WIDGET_UNSET_FLAGS (label, GTK_CAN_FOCUS);
}
}
if (setting != old_setting)
if (label->select_info)
{
- label->select_info->selection_anchor = 0;
- label->select_info->selection_end = 0;
+ label->select_info->selection_anchor = label->select_info->selection_end;
gtk_label_clear_layout (label);
gtk_widget_queue_draw (GTK_WIDGET (label));
{ "COMPOUND_TEXT", 0, 0 },
{ "UTF8_STRING", 0, 0 }
};
-
+
g_return_if_fail (GTK_IS_LABEL (label));
if (label->select_info)
return label->use_underline;
}
+
+static gboolean
+gtk_label_focus (GtkWidget *widget,
+ GtkDirectionType direction)
+{
+ /* We never want to be in the tab chain */
+ return FALSE;
+}
+
+/* Compute the X position for an offset that corresponds to the "more important
+ * cursor position for that offset. We use this when trying to guess to which
+ * end of the selection we should go to when the user hits the left or
+ * right arrow key.
+ */
+static void
+get_better_cursor (GtkLabel *label,
+ gint index,
+ gint *x,
+ gint *y)
+{
+ GtkTextDirection keymap_direction =
+ (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+ GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (label));
+ gboolean split_cursor;
+ PangoRectangle strong_pos, weak_pos;
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
+ "gtk-split-cursor", &split_cursor,
+ NULL);
+
+ gtk_label_ensure_layout (label, NULL, NULL);
+
+ pango_layout_get_cursor_pos (label->layout, index,
+ &strong_pos, &weak_pos);
+
+ if (split_cursor)
+ {
+ *x = strong_pos.x / PANGO_SCALE;
+ *y = strong_pos.y / PANGO_SCALE;
+ }
+ else
+ {
+ if (keymap_direction == widget_direction)
+ {
+ *x = strong_pos.x / PANGO_SCALE;
+ *y = strong_pos.y / PANGO_SCALE;
+ }
+ else
+ {
+ *x = weak_pos.x / PANGO_SCALE;
+ *y = weak_pos.y / PANGO_SCALE;
+ }
+ }
+}
+
+
+static gint
+gtk_label_move_logically (GtkLabel *label,
+ gint start,
+ gint count)
+{
+ gint offset = g_utf8_pointer_to_offset (label->label,
+ label->label + start);
+
+ if (label->label)
+ {
+ PangoLogAttr *log_attrs;
+ gint n_attrs;
+ gint length;
+
+ gtk_label_ensure_layout (label, NULL, NULL);
+
+ length = g_utf8_strlen (label->label, -1);
+
+ pango_layout_get_log_attrs (label->layout, &log_attrs, &n_attrs);
+
+ while (count > 0 && offset < length)
+ {
+ do
+ offset++;
+ while (offset < length && !log_attrs[offset].is_cursor_position);
+
+ count--;
+ }
+ while (count < 0 && offset > 0)
+ {
+ do
+ offset--;
+ while (offset > 0 && !log_attrs[offset].is_cursor_position);
+
+ count++;
+ }
+
+ g_free (log_attrs);
+ }
+
+ return g_utf8_offset_to_pointer (label->label, offset) - label->label;
+}
+
+static gint
+gtk_label_move_visually (GtkLabel *label,
+ gint start,
+ gint count)
+{
+ gint index;
+
+ index = start;
+
+ while (count != 0)
+ {
+ int new_index, new_trailing;
+ gboolean split_cursor;
+ gboolean strong;
+
+ gtk_label_ensure_layout (label, NULL, NULL);
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
+ "gtk-split-cursor", &split_cursor,
+ NULL);
+
+ if (split_cursor)
+ strong = TRUE;
+ else
+ {
+ GtkTextDirection keymap_direction =
+ (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
+ GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+
+ strong = keymap_direction == gtk_widget_get_direction (GTK_WIDGET (label));
+ }
+
+ if (count > 0)
+ {
+ pango_layout_move_cursor_visually (label->layout, strong, index, 0, 1, &new_index, &new_trailing);
+ count--;
+ }
+ else
+ {
+ pango_layout_move_cursor_visually (label->layout, strong, index, 0, -1, &new_index, &new_trailing);
+ count++;
+ }
+
+ if (new_index < 0 || new_index == G_MAXINT)
+ break;
+
+ index = new_index;
+
+ while (new_trailing--)
+ index = g_utf8_next_char (label->label + new_index) - label->label;
+ }
+
+ return index;
+}
+
+static gint
+gtk_label_move_forward_word (GtkLabel *label,
+ gint start)
+{
+ gint new_pos = g_utf8_pointer_to_offset (label->label,
+ label->label + start);
+ gint length;
+
+ length = g_utf8_strlen (label->label, -1);
+ if (new_pos < length)
+ {
+ PangoLogAttr *log_attrs;
+ gint n_attrs;
+
+ gtk_label_ensure_layout (label, NULL, NULL);
+
+ pango_layout_get_log_attrs (label->layout, &log_attrs, &n_attrs);
+
+ /* Find the next word end */
+ new_pos++;
+ while (new_pos < n_attrs && !log_attrs[new_pos].is_word_end)
+ new_pos++;
+
+ g_free (log_attrs);
+ }
+
+ return g_utf8_offset_to_pointer (label->label, new_pos) - label->label;
+}
+
+
+static gint
+gtk_label_move_backward_word (GtkLabel *label,
+ gint start)
+{
+ gint new_pos = g_utf8_pointer_to_offset (label->label,
+ label->label + start);
+ gint length;
+
+ length = g_utf8_strlen (label->label, -1);
+
+ if (new_pos > 0)
+ {
+ PangoLogAttr *log_attrs;
+ gint n_attrs;
+
+ gtk_label_ensure_layout (label, NULL, NULL);
+
+ pango_layout_get_log_attrs (label->layout, &log_attrs, &n_attrs);
+
+ new_pos -= 1;
+
+ /* Find the previous word beginning */
+ while (new_pos > 0 && !log_attrs[new_pos].is_word_start)
+ new_pos--;
+
+ g_free (log_attrs);
+ }
+
+ return g_utf8_offset_to_pointer (label->label, new_pos) - label->label;
+}
+
+static void
+gtk_label_move_cursor (GtkLabel *label,
+ GtkMovementStep step,
+ gint count,
+ gboolean extend_selection)
+{
+ gint new_pos;
+
+ if (label->select_info == NULL)
+ return;
+
+ new_pos = label->select_info->selection_end;
+
+ if (label->select_info->selection_end != label->select_info->selection_anchor &&
+ !extend_selection)
+ {
+ /* If we have a current selection and aren't extending it, move to the
+ * start/or end of the selection as appropriate
+ */
+ switch (step)
+ {
+ case GTK_MOVEMENT_VISUAL_POSITIONS:
+ {
+ gint end_x, end_y;
+ gint anchor_x, anchor_y;
+ gboolean end_is_left;
+
+ get_better_cursor (label, label->select_info->selection_end, &end_x, &end_y);
+ get_better_cursor (label, label->select_info->selection_anchor, &anchor_x, &anchor_y);
+
+ end_is_left = (end_y < anchor_y) || (end_y == anchor_y && end_x < anchor_x);
+
+ if (count < 0)
+ new_pos = end_is_left ? label->select_info->selection_end : label->select_info->selection_anchor;
+ else
+ new_pos = !end_is_left ? label->select_info->selection_end : label->select_info->selection_anchor;
+
+ break;
+ }
+ case GTK_MOVEMENT_LOGICAL_POSITIONS:
+ case GTK_MOVEMENT_WORDS:
+ if (count < 0)
+ new_pos = MIN (label->select_info->selection_end, label->select_info->selection_anchor);
+ else
+ new_pos = MAX (label->select_info->selection_end, label->select_info->selection_anchor);
+ break;
+ case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
+ case GTK_MOVEMENT_PARAGRAPH_ENDS:
+ case GTK_MOVEMENT_BUFFER_ENDS:
+ /* FIXME: Can do better here */
+ new_pos = count < 0 ? 0 : strlen (label->label);
+ break;
+ case GTK_MOVEMENT_DISPLAY_LINES:
+ case GTK_MOVEMENT_PARAGRAPHS:
+ case GTK_MOVEMENT_PAGES:
+ break;
+ }
+ }
+ else
+ {
+ switch (step)
+ {
+ case GTK_MOVEMENT_LOGICAL_POSITIONS:
+ new_pos = gtk_label_move_logically (label, new_pos, count);
+ break;
+ case GTK_MOVEMENT_VISUAL_POSITIONS:
+ new_pos = gtk_label_move_visually (label, new_pos, count);
+ break;
+ case GTK_MOVEMENT_WORDS:
+ while (count > 0)
+ {
+ new_pos = gtk_label_move_forward_word (label, new_pos);
+ count--;
+ }
+ while (count < 0)
+ {
+ new_pos = gtk_label_move_backward_word (label, new_pos);
+ count++;
+ }
+ break;
+ case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
+ case GTK_MOVEMENT_PARAGRAPH_ENDS:
+ case GTK_MOVEMENT_BUFFER_ENDS:
+ /* FIXME: Can do better here */
+ new_pos = count < 0 ? 0 : strlen (label->label);
+ break;
+ case GTK_MOVEMENT_DISPLAY_LINES:
+ case GTK_MOVEMENT_PARAGRAPHS:
+ case GTK_MOVEMENT_PAGES:
+ break;
+ }
+ }
+
+ if (extend_selection)
+ gtk_label_select_region_index (label,
+ label->select_info->selection_anchor,
+ new_pos);
+ else
+ gtk_label_select_region_index (label, new_pos, new_pos);
+}
+
+static void
+gtk_label_copy_clipboard (GtkLabel *label)
+{
+ if (label->text && label->select_info)
+ {
+ gint start, end;
+ gint len;
+
+ start = MIN (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+ end = MAX (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+
+ len = strlen (label->text);
+
+ if (end > len)
+ end = len;
+
+ if (start > len)
+ start = len;
+
+ if (start != end)
+ gtk_clipboard_set_text (gtk_clipboard_get (GDK_NONE),
+ label->text + start, end - start);
+ }
+}
+
+static void
+gtk_label_select_all (GtkLabel *label)
+{
+ gtk_label_select_region_index (label, 0, strlen (label->label));
+}
+
+/* Quick hack of a popup menu
+ */
+static void
+activate_cb (GtkWidget *menuitem,
+ GtkLabel *label)
+{
+ const gchar *signal = gtk_object_get_data (GTK_OBJECT (menuitem), "gtk-signal");
+ gtk_signal_emit_by_name (GTK_OBJECT (label), signal);
+}
+
+static void
+append_action_signal (GtkLabel *label,
+ GtkWidget *menu,
+ const gchar *label_text,
+ const gchar *signal,
+ gboolean sensitive)
+{
+ GtkWidget *menuitem = gtk_menu_item_new_with_label (label_text);
+
+ gtk_object_set_data (GTK_OBJECT (menuitem), "gtk-signal", (char *)signal);
+ gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
+ GTK_SIGNAL_FUNC (activate_cb), label);
+
+ gtk_widget_set_sensitive (menuitem, sensitive);
+
+ gtk_widget_show (menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
+}
+
+static void
+popup_menu_detach (GtkWidget *attach_widget,
+ GtkMenu *menu)
+{
+ GtkLabel *label;
+ label = GTK_LABEL (attach_widget);
+
+ if (label->select_info)
+ label->select_info->popup_menu = NULL;
+}
+
+static void
+popup_position_func (GtkMenu *menu,
+ gint *x,
+ gint *y,
+ gboolean *push_in,
+ gpointer user_data)
+{
+ GtkLabel *label;
+ GtkWidget *widget;
+ GtkRequisition req;
+
+ label = GTK_LABEL (user_data);
+ widget = GTK_WIDGET (label);
+
+ if (label->select_info == NULL)
+ return;
+
+ g_return_if_fail (GTK_WIDGET_REALIZED (label));
+
+ gdk_window_get_origin (widget->window, x, y);
+
+ gtk_widget_size_request (label->select_info->popup_menu, &req);
+
+ *x += widget->allocation.width / 2;
+ *y += widget->allocation.height;
+
+ *x = CLAMP (*x, 0, MAX (0, gdk_screen_width () - req.width));
+ *y = CLAMP (*y, 0, MAX (0, gdk_screen_height () - req.height));
+}
+
+
+static void
+gtk_label_do_popup (GtkLabel *label,
+ GdkEventButton *event)
+{
+ GtkWidget *menuitem;
+ gboolean have_selection;
+
+ if (label->select_info == NULL)
+ return;
+
+ if (label->select_info->popup_menu)
+ gtk_widget_destroy (label->select_info->popup_menu);
+
+ label->select_info->popup_menu = gtk_menu_new ();
+
+ gtk_menu_attach_to_widget (GTK_MENU (label->select_info->popup_menu),
+ GTK_WIDGET (label),
+ popup_menu_detach);
+
+ have_selection =
+ label->select_info->selection_anchor != label->select_info->selection_end;
+
+
+ append_action_signal (label, label->select_info->popup_menu, _("Cut"), "cut_clipboard",
+ FALSE);
+ append_action_signal (label, label->select_info->popup_menu, _("Copy"), "copy_clipboard",
+ have_selection);
+ append_action_signal (label, label->select_info->popup_menu, _("Paste"), "paste_clipboard",
+ FALSE);
+
+ menuitem = gtk_menu_item_new_with_label (_("Select All"));
+ gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
+ GTK_SIGNAL_FUNC (gtk_label_select_all), label);
+ gtk_widget_show (menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (label->select_info->popup_menu), menuitem);
+
+ menuitem = gtk_separator_menu_item_new ();
+ gtk_widget_show (menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (label->select_info->popup_menu), menuitem);
+
+ menuitem = gtk_menu_item_new_with_label (_("Input Methods"));
+ gtk_widget_show (menuitem);
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), gtk_menu_new ());
+ gtk_widget_set_sensitive (menuitem, FALSE);
+ gtk_menu_shell_append (GTK_MENU_SHELL (label->select_info->popup_menu), menuitem);
+
+ gtk_signal_emit (GTK_OBJECT (label),
+ signals[POPULATE_POPUP],
+ label->select_info->popup_menu);
+
+ if (event)
+ gtk_menu_popup (GTK_MENU (label->select_info->popup_menu), NULL, NULL,
+ NULL, NULL,
+ event->button, event->time);
+ else
+ gtk_menu_popup (GTK_MENU (label->select_info->popup_menu), NULL, NULL,
+ popup_position_func, label,
+ 0, gtk_get_current_event_time ());
+}
projects / ~andy / gtk / commitdiff