Fix PostScript output of multiple charts.
[pspp] / lib / gtksheet / gtkitementry.c
1 /* GTK - The GIMP Toolkit
2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 /*
21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
22  * file for a list of people on the GTK+ Team.  See the ChangeLog
23  * files for a list of changes.  These files are distributed with
24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
25  */
26
27 #include <string.h>
28
29 #include <pango/pango.h>
30
31 #include <gdk/gdkkeysyms.h>
32 #include <gtk/gtk.h>
33 #include "gtkitementry.h"
34
35 #define MIN_ENTRY_WIDTH  150
36 #define DRAW_TIMEOUT     20
37 #define INNER_BORDER     0
38
39 /* Initial size of buffer, in bytes */
40 #define MIN_SIZE 16
41
42 /* Maximum size of text buffer, in bytes */
43 #define MAX_SIZE G_MAXUSHORT
44
45 typedef enum {
46   CURSOR_STANDARD,
47   CURSOR_DND
48 } CursorType;
49
50 /* GObject, GtkObject methods
51  */
52 static void   gtk_item_entry_class_init           (GtkItemEntryClass        *klass);
53 static void   gtk_item_entry_init                 (GtkItemEntry         *entry);
54 static void   gtk_item_entry_editable_init (GtkEditableClass *iface);
55
56 /* GtkWidget methods
57  */
58 static void   gtk_entry_realize              (GtkWidget        *widget);
59 static void   gtk_entry_size_request         (GtkWidget        *widget,
60                                               GtkRequisition   *requisition);
61 static void   gtk_entry_size_allocate        (GtkWidget        *widget,
62                                               GtkAllocation    *allocation);
63 static void   gtk_entry_draw_frame           (GtkWidget        *widget);
64 static gint   gtk_entry_expose               (GtkWidget        *widget,
65                                               GdkEventExpose   *event);
66 static void   gtk_entry_grab_focus           (GtkWidget        *widget);
67 static void   gtk_entry_style_set            (GtkWidget        *widget,
68                                               GtkStyle         *previous_style);
69 static void   gtk_entry_direction_changed    (GtkWidget        *widget,
70                                               GtkTextDirection  previous_dir);
71 static void   gtk_entry_state_changed        (GtkWidget        *widget,
72                                               GtkStateType      previous_state);
73
74 /* GtkEditable method implementations
75  */
76 static void     gtk_entry_insert_text          (GtkEditable *editable,
77                                                 const gchar *new_text,
78                                                 gint         new_text_length,
79                                                 gint        *position);
80 static void     gtk_entry_delete_text          (GtkEditable *editable,
81                                                 gint         start_pos,
82                                                 gint         end_pos);
83
84 static void     gtk_entry_real_set_position    (GtkEditable *editable,
85                                                 gint         position);
86 static gint     gtk_entry_get_position         (GtkEditable *editable);
87
88 /* Default signal handlers
89  */
90 static void gtk_entry_real_insert_text   (GtkEditable     *editable,
91                                           const gchar     *new_text,
92                                           gint             new_text_length,
93                                           gint            *position);
94 static void gtk_entry_real_delete_text   (GtkEditable     *editable,
95                                           gint             start_pos,
96                                           gint             end_pos);
97 static void gtk_entry_move_cursor        (GtkEntry        *entry,
98                                           GtkMovementStep  step,
99                                           gint             count,
100                                           gboolean         extend_selection);
101 static void gtk_entry_insert_at_cursor   (GtkEntry        *entry,
102                                           const gchar     *str);
103 static void gtk_entry_delete_from_cursor (GtkEntry        *entry,
104                                           GtkDeleteType    type,
105                                           gint             count);
106
107 /* IM Context Callbacks
108  */
109 static void     gtk_entry_commit_cb               (GtkIMContext *context,
110                                                    const gchar  *str,
111                                                    GtkEntry     *entry);
112 static void     gtk_entry_preedit_changed_cb      (GtkIMContext *context,
113                                                    GtkEntry     *entry);
114 static gboolean gtk_entry_retrieve_surrounding_cb (GtkIMContext *context,
115                                                    GtkEntry     *entry);
116 static gboolean gtk_entry_delete_surrounding_cb   (GtkIMContext *context,
117                                                    gint          offset,
118                                                    gint          n_chars,
119                                                    GtkEntry     *entry);
120
121 /* Internal routines
122  */
123 static void         gtk_entry_enter_text               (GtkEntry       *entry,
124                                                         const gchar    *str);
125 static void         gtk_entry_set_positions            (GtkEntry       *entry,
126                                                         gint            current_pos,
127                                                         gint            selection_bound);
128 static void         gtk_entry_draw_text                (GtkEntry       *entry);
129 static void         gtk_entry_draw_cursor              (GtkEntry       *entry,
130                                                         CursorType      type);
131 static PangoLayout *gtk_entry_ensure_layout            (GtkEntry       *entry,
132                                                         gboolean        include_preedit);
133 static void         gtk_entry_queue_draw               (GtkEntry       *entry);
134 static void         gtk_entry_reset_im_context         (GtkEntry       *entry);
135 static void         gtk_entry_recompute                (GtkEntry       *entry);
136 static void         gtk_entry_get_cursor_locations     (GtkEntry       *entry,
137                                                         CursorType      type,
138                                                         gint           *strong_x,
139                                                         gint           *weak_x);
140 static void         gtk_entry_adjust_scroll            (GtkEntry       *entry);
141 static gint         gtk_entry_move_visually            (GtkEntry       *editable,
142                                                         gint            start,
143                                                         gint            count);
144 static gint         gtk_entry_move_logically           (GtkEntry       *entry,
145                                                         gint            start,
146                                                         gint            count);
147 static gint         gtk_entry_move_forward_word        (GtkEntry       *entry,
148                                                         gint            start);
149 static gint         gtk_entry_move_backward_word       (GtkEntry       *entry,
150                                                         gint            start);
151 static void         gtk_entry_delete_whitespace        (GtkEntry       *entry);
152 static char *       gtk_entry_get_public_chars         (GtkEntry       *entry,
153                                                         gint            start,
154                                                         gint            end);
155 static void         gtk_entry_update_primary_selection (GtkEntry       *entry);
156 static void         gtk_entry_state_changed            (GtkWidget      *widget,
157                                                         GtkStateType    previous_state);
158 static void         gtk_entry_check_cursor_blink       (GtkEntry       *entry);
159 static void         gtk_entry_pend_cursor_blink        (GtkEntry       *entry);
160 static void         get_text_area_size                 (GtkEntry       *entry,
161                                                         gint           *x,
162                                                         gint           *y,
163                                                         gint           *width,
164                                                         gint           *height);
165 static void         get_widget_window_size             (GtkEntry       *entry,
166                                                         gint           *x,
167                                                         gint           *y,
168                                                         gint           *width,
169                                                         gint           *height);
170
171 static GtkEntryClass *parent_class = NULL;
172
173 GtkType
174 gtk_item_entry_get_type (void)
175 {
176   static GtkType item_entry_type = 0;
177
178   if (!item_entry_type)
179     {
180       static const GtkTypeInfo item_entry_info =
181       {
182         "GtkItemEntry",
183         sizeof (GtkItemEntry),
184         sizeof (GtkItemEntryClass),
185         (GtkClassInitFunc) gtk_item_entry_class_init,
186         (GtkObjectInitFunc) gtk_item_entry_init,
187         /* reserved_1 */ NULL,
188         /* reserved_2 */ NULL,
189         (GtkClassInitFunc) NULL,
190       };
191
192       static const GInterfaceInfo item_editable_info =
193       {
194         (GInterfaceInitFunc) gtk_item_entry_editable_init,    /* interface_init */
195         NULL,                                            /* interface_finalize */
196         NULL                                             /* interface_data */
197       };
198
199
200       item_entry_type = gtk_type_unique (GTK_TYPE_ENTRY, &item_entry_info);
201
202       g_type_add_interface_static (item_entry_type,
203                                    GTK_TYPE_EDITABLE,
204                                    &item_editable_info);
205
206     }
207
208   return item_entry_type;
209 }
210
211 static void
212 gtk_item_entry_class_init (GtkItemEntryClass *class)
213 {
214   GtkObjectClass *object_class;
215   GtkWidgetClass *widget_class;
216   GtkEntryClass *entry_class;
217
218   object_class = (GtkObjectClass*) class;
219   widget_class = (GtkWidgetClass*) class;
220   parent_class = gtk_type_class (GTK_TYPE_ENTRY);
221   entry_class = (GtkEntryClass *) class;
222
223   widget_class->realize = gtk_entry_realize;
224   widget_class->size_request = gtk_entry_size_request;
225   widget_class->size_allocate = gtk_entry_size_allocate;
226   widget_class->expose_event = gtk_entry_expose;
227   widget_class->grab_focus = gtk_entry_grab_focus;
228   widget_class->style_set = gtk_entry_style_set;
229   widget_class->direction_changed = gtk_entry_direction_changed;
230   widget_class->state_changed = gtk_entry_state_changed;
231
232   entry_class->move_cursor = gtk_entry_move_cursor;
233   entry_class->insert_at_cursor = gtk_entry_insert_at_cursor;
234   entry_class->delete_from_cursor = gtk_entry_delete_from_cursor;
235
236 }
237
238 static void
239 gtk_item_entry_editable_init (GtkEditableClass *iface)
240 {
241   iface->do_insert_text = gtk_entry_insert_text;
242   iface->do_delete_text = gtk_entry_delete_text;
243   iface->insert_text = gtk_entry_real_insert_text;
244   iface->delete_text = gtk_entry_real_delete_text;
245   iface->set_position = gtk_entry_real_set_position;
246   iface->get_position = gtk_entry_get_position;
247 }
248
249 static void
250 gtk_item_entry_init (GtkItemEntry *entry)
251 {
252   entry->justification = GTK_JUSTIFY_LEFT;
253   entry->text_max_size = 0;
254   GTK_ENTRY(entry)->has_frame = FALSE;
255
256   g_object_unref(G_OBJECT(GTK_ENTRY(entry)->im_context));
257
258   GTK_ENTRY(entry)->im_context = gtk_im_multicontext_new ();
259
260   g_signal_connect (G_OBJECT (GTK_ENTRY(entry)->im_context), "commit",
261                     G_CALLBACK (gtk_entry_commit_cb), entry);
262   g_signal_connect (G_OBJECT (GTK_ENTRY(entry)->im_context), "preedit_changed",
263                     G_CALLBACK (gtk_entry_preedit_changed_cb), entry);
264   g_signal_connect (G_OBJECT (GTK_ENTRY(entry)->im_context), "retrieve_surrounding",
265                     G_CALLBACK (gtk_entry_retrieve_surrounding_cb), entry);
266   g_signal_connect (G_OBJECT (GTK_ENTRY(entry)->im_context), "delete_surrounding",
267                     G_CALLBACK (gtk_entry_delete_surrounding_cb), entry);
268
269 }
270
271 static void
272 gtk_entry_realize (GtkWidget *widget)
273 {
274   GtkEntry *entry;
275   GtkEditable *editable;
276   GdkWindowAttr attributes;
277   gint attributes_mask;
278
279   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
280   entry = GTK_ENTRY (widget);
281   editable = GTK_EDITABLE (widget);
282
283   attributes.window_type = GDK_WINDOW_CHILD;
284  
285   get_widget_window_size (entry, &attributes.x, &attributes.y, &attributes.width, &attributes.height);
286
287   attributes.wclass = GDK_INPUT_OUTPUT;
288   attributes.visual = gtk_widget_get_visual (widget);
289   attributes.colormap = gtk_widget_get_colormap (widget);
290   attributes.event_mask = gtk_widget_get_events (widget);
291   attributes.event_mask |= (GDK_EXPOSURE_MASK |
292                             GDK_BUTTON_PRESS_MASK |
293                             GDK_BUTTON_RELEASE_MASK |
294                             GDK_BUTTON1_MOTION_MASK |
295                             GDK_BUTTON3_MOTION_MASK |
296                             GDK_POINTER_MOTION_HINT_MASK |
297                             GDK_POINTER_MOTION_MASK |
298                             GDK_ENTER_NOTIFY_MASK |
299                             GDK_LEAVE_NOTIFY_MASK);
300   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
301
302   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
303   gdk_window_set_user_data (widget->window, entry);
304
305   get_text_area_size (entry, &attributes.x, &attributes.y, &attributes.width, &attributes.height);
306
307   attributes.cursor = gdk_cursor_new (GDK_XTERM);
308   attributes_mask |= GDK_WA_CURSOR;
309
310   entry->text_area = gdk_window_new (widget->window, &attributes, attributes_mask);
311   gdk_window_set_user_data (entry->text_area, entry);
312
313   gdk_cursor_unref (attributes.cursor);
314
315   widget->style = gtk_style_attach (widget->style, widget->window);
316
317   gdk_window_set_background (widget->window, &widget->style->bg[GTK_WIDGET_STATE(widget)]);
318   gdk_window_set_background (entry->text_area, &widget->style->bg[GTK_WIDGET_STATE (widget)]);
319
320   gdk_window_show (entry->text_area);
321
322   gtk_im_context_set_client_window (entry->im_context, entry->text_area);
323
324   gtk_entry_adjust_scroll (entry);
325 }
326
327 static void
328 get_borders (GtkEntry *entry,
329              gint     *xborder,
330              gint     *yborder)
331 {
332   GtkWidget *widget = GTK_WIDGET (entry);
333   gint focus_width;
334   gboolean interior_focus;
335
336   gtk_widget_style_get (widget,
337                         "interior-focus", &interior_focus,
338                         "focus-line-width", &focus_width,
339                         NULL);
340
341   if (entry->has_frame)
342     {
343       *xborder = widget->style->xthickness;
344       *yborder = widget->style->ythickness;
345     }
346   else
347     {
348       *xborder = 0;
349       *yborder = 0;
350     }
351
352   if (!interior_focus)
353     {
354       *xborder += focus_width;
355       *yborder += focus_width;
356     }
357
358 }
359
360 static void
361 gtk_entry_size_request (GtkWidget      *widget,
362                         GtkRequisition *requisition)
363 {
364   GtkEntry *entry = GTK_ENTRY (widget);
365   PangoFontMetrics *metrics;
366   gint xborder, yborder;
367   PangoContext *context;
368   
369   context = gtk_widget_get_pango_context (widget);
370   metrics = pango_context_get_metrics (context,
371                                        widget->style->font_desc,
372                                        pango_context_get_language (context));
373
374   entry->ascent = pango_font_metrics_get_ascent (metrics);
375   entry->descent = pango_font_metrics_get_descent (metrics);
376
377   get_borders (entry, &xborder, &yborder);
378   
379   xborder += INNER_BORDER;
380   yborder += INNER_BORDER;
381   
382   if (entry->width_chars < 0)
383     requisition->width = MIN_ENTRY_WIDTH + xborder * 2;
384   else
385     {
386       gint char_width = pango_font_metrics_get_approximate_char_width (metrics);
387       requisition->width = PANGO_PIXELS (char_width) * entry->width_chars + xborder * 2;
388     }
389     
390   requisition->height = PANGO_PIXELS (entry->ascent + entry->descent) + yborder * 2;
391
392   pango_font_metrics_unref (metrics);
393 }
394
395 static void
396 get_text_area_size (GtkEntry *entry,
397                     gint     *x,
398                     gint     *y,
399                     gint     *width,
400                     gint     *height)
401 {
402   gint xborder, yborder;
403   GtkRequisition requisition;
404   GtkWidget *widget = GTK_WIDGET (entry);
405
406   gtk_widget_get_child_requisition (widget, &requisition);
407
408   get_borders (entry, &xborder, &yborder);
409
410   if (x)
411     *x = xborder;
412
413   if (y)
414     *y = yborder;
415   
416   if (width)
417     *width = GTK_WIDGET (entry)->allocation.width - xborder * 2;
418
419   if (height)
420     *height = requisition.height - yborder * 2;
421 }
422
423 static void
424 get_widget_window_size (GtkEntry *entry,
425                         gint     *x,
426                         gint     *y,
427                         gint     *width,
428                         gint     *height)
429 {
430   GtkRequisition requisition;
431   GtkWidget *widget = GTK_WIDGET (entry);
432       
433   gtk_widget_get_child_requisition (widget, &requisition);
434
435   if (x)
436     *x = widget->allocation.x;
437
438   if (y)
439     {
440       if (entry->is_cell_renderer)
441         *y = widget->allocation.y;
442       else
443         *y = widget->allocation.y + (widget->allocation.height - requisition.height) / 2;
444     }
445
446   if (width)
447     *width = widget->allocation.width;
448
449   if (height)
450     {
451       if (entry->is_cell_renderer)
452         *height = widget->allocation.height;
453       else
454         *height = requisition.height;
455     }
456 }
457
458 static void
459 gtk_entry_size_allocate (GtkWidget     *widget,
460                          GtkAllocation *allocation)
461 {
462   GtkEntry *entry = GTK_ENTRY (widget);
463   GtkItemEntry *ientry = GTK_ITEM_ENTRY (widget);
464
465   if(ientry->text_max_size > 0)
466     allocation->width = MIN(ientry->text_max_size, allocation->width);
467  
468   widget->allocation = *allocation;
469  
470   if (GTK_WIDGET_REALIZED (widget))
471     {
472       /* We call gtk_widget_get_child_requisition, since we want (for
473        * backwards compatibility reasons) the realization here to
474        * be affected by the usize of the entry, if set
475        */
476       gint x, y, width, height;
477
478       get_widget_window_size (entry, &x, &y, &width, &height);
479      
480       gdk_window_move_resize (widget->window,
481                               allocation->x, allocation->y, allocation->width, allocation->height);   
482
483       get_text_area_size (entry, &x, &y, &width, &height);
484       
485       gdk_window_move_resize (entry->text_area,
486                               0, allocation->height - height, allocation->width, height);   
487
488       gtk_entry_recompute (entry);
489     }
490 }
491
492 static void
493 gtk_entry_draw_frame (GtkWidget *widget)
494 {
495 }
496
497 static gint
498 gtk_entry_expose (GtkWidget      *widget,
499                   GdkEventExpose *event)
500 {
501   GtkEntry *entry = GTK_ENTRY (widget);
502
503   if (widget->window == event->window)
504     gtk_entry_draw_frame (widget);
505   else if (entry->text_area == event->window)
506     {
507       gint area_width, area_height;
508
509       get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
510
511       gdk_draw_rectangle (entry->text_area,
512                           widget->style->bg_gc[GTK_WIDGET_STATE(widget)],
513                           TRUE,
514                           0, 0, area_width, area_height);
515
516       if ((entry->visible || entry->invisible_char != 0) &&
517           GTK_WIDGET_HAS_FOCUS (widget) &&
518           entry->selection_bound == entry->current_pos && entry->cursor_visible)
519         gtk_entry_draw_cursor (GTK_ENTRY (widget), CURSOR_STANDARD);
520
521       if (entry->dnd_position != -1)
522         gtk_entry_draw_cursor (GTK_ENTRY (widget), CURSOR_DND);
523       
524       gtk_entry_draw_text (GTK_ENTRY (widget));
525     }
526
527   return FALSE;
528 }
529
530 static void
531 gtk_entry_grab_focus (GtkWidget        *widget)
532 {
533   GtkEntry *entry = GTK_ENTRY (widget);
534   gboolean select_on_focus;
535
536   GTK_WIDGET_CLASS (parent_class)->grab_focus (widget);
537
538   g_object_get (G_OBJECT (gtk_settings_get_default ()),
539                 "gtk-entry-select-on-focus",
540                 &select_on_focus,
541                 NULL);
542   
543   if (select_on_focus && entry->editable && !entry->in_click)
544     gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1);
545 }
546
547 static void 
548 gtk_entry_direction_changed (GtkWidget        *widget,
549                              GtkTextDirection  previous_dir)
550 {
551   GtkEntry *entry = GTK_ENTRY (widget);
552
553   gtk_entry_recompute (entry);
554       
555   GTK_WIDGET_CLASS (parent_class)->direction_changed (widget, previous_dir);
556 }
557
558 static void
559 gtk_entry_state_changed (GtkWidget      *widget,
560                          GtkStateType    previous_state)
561 {
562   GtkEntry *entry = GTK_ENTRY (widget);
563   
564   if (GTK_WIDGET_REALIZED (widget))
565     {
566       gdk_window_set_background (widget->window, &widget->style->bg[GTK_WIDGET_STATE (widget)]);
567       gdk_window_set_background (entry->text_area, &widget->style->bg[GTK_WIDGET_STATE (widget)]);
568     }
569
570   if (!GTK_WIDGET_IS_SENSITIVE (widget))
571     {
572       /* Clear any selection */
573       gtk_editable_select_region (GTK_EDITABLE (entry), entry->current_pos, entry->current_pos);      
574     }
575   
576   gtk_widget_queue_clear (widget);
577 }
578
579 /* GtkEditable method implementations
580  */
581 static void
582 gtk_entry_insert_text (GtkEditable *editable,
583                        const gchar *new_text,
584                        gint         new_text_length,
585                        gint        *position)
586 {
587   GtkEntry *entry = GTK_ENTRY (editable);
588   gchar buf[64];
589   gchar *text;
590
591   if (*position < 0 || *position > entry->text_length)
592     *position = entry->text_length;
593   
594   g_object_ref (G_OBJECT (editable));
595   
596   if (new_text_length <= 63)
597     text = buf;
598   else
599     text = g_new (gchar, new_text_length + 1);
600
601   text[new_text_length] = '\0';
602   strncpy (text, new_text, new_text_length);
603   
604   g_signal_emit_by_name (editable, "insert_text", text, new_text_length, position);
605
606   if (new_text_length > 63)
607     g_free (text);
608
609   g_object_unref (G_OBJECT (editable));
610 }
611
612 static void
613 gtk_entry_delete_text (GtkEditable *editable,
614                        gint         start_pos,
615                        gint         end_pos)
616 {
617   GtkEntry *entry = GTK_ENTRY (editable);
618
619   if (end_pos < 0 || end_pos > entry->text_length)
620     end_pos = entry->text_length;
621   if (start_pos < 0)
622     start_pos = 0;
623   if (start_pos > end_pos)
624     start_pos = end_pos;
625   
626   g_object_ref (G_OBJECT (editable));
627
628   g_signal_emit_by_name (editable, "delete_text", start_pos, end_pos);
629
630   g_object_unref (G_OBJECT (editable));
631 }
632
633 static void 
634 gtk_entry_style_set     (GtkWidget      *widget,
635                          GtkStyle       *previous_style)
636 {
637   GtkEntry *entry = GTK_ENTRY (widget);
638
639   if (previous_style && GTK_WIDGET_REALIZED (widget))
640     {
641       gtk_entry_recompute (entry);
642
643       gdk_window_set_background (widget->window, &widget->style->bg[GTK_WIDGET_STATE(widget)]);
644       gdk_window_set_background (entry->text_area, &widget->style->bg[GTK_WIDGET_STATE (widget)]);
645     }
646 }
647
648 static void
649 gtk_entry_real_set_position (GtkEditable *editable,
650                              gint         position)
651 {
652   GtkEntry *entry = GTK_ENTRY (editable);
653
654   if (position < 0 || position > entry->text_length)
655     position = entry->text_length;
656
657   if (position != entry->current_pos ||
658       position != entry->selection_bound)
659     {
660       gtk_entry_reset_im_context (entry);
661       gtk_entry_set_positions (entry, position, position);
662     }
663 }
664
665 static gint
666 gtk_entry_get_position (GtkEditable *editable)
667 {
668   return GTK_ENTRY (editable)->current_pos;
669 }
670
671
672 /* Default signal handlers
673  */
674 static void
675 gtk_entry_real_insert_text (GtkEditable *editable,
676                             const gchar *new_text,
677                             gint         new_text_length,
678                             gint        *position)
679 {
680   gint index;
681   gint n_chars;
682
683   GtkEntry *entry = GTK_ENTRY (editable);
684
685   if (new_text_length < 0)
686     new_text_length = strlen (new_text);
687
688   n_chars = g_utf8_strlen (new_text, new_text_length);
689   if (entry->text_max_length > 0 && n_chars + entry->text_length > entry->text_max_length)
690     {
691       gdk_beep ();
692       n_chars = entry->text_max_length - entry->text_length;
693       new_text_length = g_utf8_offset_to_pointer (new_text, n_chars) - new_text;
694     }
695
696   if (new_text_length + entry->n_bytes + 1 > entry->text_size)
697     {
698       while (new_text_length + entry->n_bytes + 1 > entry->text_size)
699         {
700           if (entry->text_size == 0)
701             entry->text_size = MIN_SIZE;
702           else
703             {
704               if (2 * (guint)entry->text_size < MAX_SIZE &&
705                   2 * (guint)entry->text_size > entry->text_size)
706                 entry->text_size *= 2;
707               else
708                 {
709                   entry->text_size = MAX_SIZE;
710                   if (new_text_length > (gint)entry->text_size - (gint)entry->n_bytes - 1)
711                     {
712                       new_text_length = (gint)entry->text_size - (gint)entry->n_bytes - 1;
713                       new_text_length = g_utf8_find_prev_char (new_text, new_text + new_text_length + 1) - new_text;
714                       n_chars = g_utf8_strlen (new_text, new_text_length);
715                     }
716                   break;
717                 }
718             }
719         }
720
721       entry->text = g_realloc (entry->text, entry->text_size);
722     }
723
724   index = g_utf8_offset_to_pointer (entry->text, *position) - entry->text;
725
726   g_memmove (entry->text + index + new_text_length, entry->text + index, entry->n_bytes - index);
727   memcpy (entry->text + index, new_text, new_text_length);
728
729   entry->n_bytes += new_text_length;
730   entry->text_length += n_chars;
731
732   /* NUL terminate for safety and convenience */
733   entry->text[entry->n_bytes] = '\0';
734   
735   if (entry->current_pos > *position)
736     entry->current_pos += n_chars;
737   
738   if (entry->selection_bound > *position)
739     entry->selection_bound += n_chars;
740
741   *position += n_chars;
742
743   gtk_entry_recompute (entry);
744
745   g_signal_emit_by_name (editable, "changed");
746   g_object_notify (G_OBJECT (editable), "text");
747 }
748
749 static void
750 gtk_entry_real_delete_text (GtkEditable *editable,
751                             gint         start_pos,
752                             gint         end_pos)
753 {
754   GtkEntry *entry = GTK_ENTRY (editable);
755
756   if (start_pos < 0)
757     start_pos = 0;
758   if (end_pos < 0 || end_pos > entry->text_length)
759     end_pos = entry->text_length;
760   
761   if (start_pos < end_pos)
762     {
763       gint start_index = g_utf8_offset_to_pointer (entry->text, start_pos) - entry->text;
764       gint end_index = g_utf8_offset_to_pointer (entry->text, end_pos) - entry->text;
765
766       g_memmove (entry->text + start_index, entry->text + end_index, entry->n_bytes + 1 - end_index);
767       entry->text_length -= (end_pos - start_pos);
768       entry->n_bytes -= (end_index - start_index);
769       
770       if (entry->current_pos > start_pos)
771         entry->current_pos -= MIN (entry->current_pos, end_pos) - start_pos;
772
773       if (entry->selection_bound > start_pos)
774         entry->selection_bound -= MIN (entry->selection_bound, end_pos) - start_pos;
775       /* We might have deleted the selection
776        */
777       gtk_entry_update_primary_selection (entry);
778       
779       gtk_entry_recompute (entry);
780       
781       g_signal_emit_by_name (editable, "changed");
782       g_object_notify (G_OBJECT (editable), "text");
783     }
784 }
785
786 /* Compute the X position for an offset that corresponds to the "more important
787  * cursor position for that offset. We use this when trying to guess to which
788  * end of the selection we should go to when the user hits the left or
789  * right arrow key.
790  */
791 static gint
792 get_better_cursor_x (GtkEntry *entry,
793                      gint      offset)
794 {
795   GtkTextDirection keymap_direction =
796     (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
797     GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
798   GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (entry));
799   gboolean split_cursor;
800   
801   PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
802   gint index = g_utf8_offset_to_pointer (entry->text, offset) - entry->text;
803   
804   PangoRectangle strong_pos, weak_pos;
805   
806   g_object_get (gtk_widget_get_settings (GTK_WIDGET (entry)),
807                 "gtk-split-cursor", &split_cursor,
808                 NULL);
809
810   pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);
811
812   if (split_cursor)
813     return strong_pos.x / PANGO_SCALE;
814   else
815     return (keymap_direction == widget_direction) ? strong_pos.x / PANGO_SCALE : weak_pos.x / PANGO_SCALE;
816 }
817
818 static void
819 gtk_entry_move_cursor (GtkEntry       *entry,
820                        GtkMovementStep step,
821                        gint            count,
822                        gboolean        extend_selection)
823 {
824   gint new_pos = entry->current_pos;
825
826   gtk_entry_reset_im_context (entry);
827
828   if (entry->current_pos != entry->selection_bound && !extend_selection)
829     {
830       /* If we have a current selection and aren't extending it, move to the
831        * start/or end of the selection as appropriate
832        */
833       switch (step)
834         {
835         case GTK_MOVEMENT_VISUAL_POSITIONS:
836           {
837             gint current_x = get_better_cursor_x (entry, entry->current_pos);
838             gint bound_x = get_better_cursor_x (entry, entry->selection_bound);
839
840             if (count < 0)
841               new_pos = current_x < bound_x ? entry->current_pos : entry->selection_bound;
842             else
843               new_pos = current_x > bound_x ? entry->current_pos : entry->selection_bound;
844
845             break;
846           }
847         case GTK_MOVEMENT_LOGICAL_POSITIONS:
848         case GTK_MOVEMENT_WORDS:
849           if (count < 0)
850             new_pos = MIN (entry->current_pos, entry->selection_bound);
851           else
852             new_pos = MAX (entry->current_pos, entry->selection_bound);
853           break;
854         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
855         case GTK_MOVEMENT_PARAGRAPH_ENDS:
856         case GTK_MOVEMENT_BUFFER_ENDS:
857           new_pos = count < 0 ? 0 : entry->text_length;
858           break;
859         case GTK_MOVEMENT_DISPLAY_LINES:
860         case GTK_MOVEMENT_PARAGRAPHS:
861         case GTK_MOVEMENT_PAGES:
862           break;
863         default:
864           break;
865         }
866     }
867   else
868     {
869       switch (step)
870         {
871         case GTK_MOVEMENT_LOGICAL_POSITIONS:
872           new_pos = gtk_entry_move_logically (entry, new_pos, count);
873           break;
874         case GTK_MOVEMENT_VISUAL_POSITIONS:
875           new_pos = gtk_entry_move_visually (entry, new_pos, count);
876           break;
877         case GTK_MOVEMENT_WORDS:
878           while (count > 0)
879             {
880               new_pos = gtk_entry_move_forward_word (entry, new_pos);
881               count--;
882             }
883           while (count < 0)
884             {
885               new_pos = gtk_entry_move_backward_word (entry, new_pos);
886               count++;
887             }
888           break;
889         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
890         case GTK_MOVEMENT_PARAGRAPH_ENDS:
891         case GTK_MOVEMENT_BUFFER_ENDS:
892           new_pos = count < 0 ? 0 : entry->text_length;
893           break;
894         case GTK_MOVEMENT_DISPLAY_LINES:
895         case GTK_MOVEMENT_PARAGRAPHS:
896         case GTK_MOVEMENT_PAGES:
897           break;
898         default:
899           break;
900         }
901     }
902
903   if (extend_selection)
904     gtk_editable_select_region (GTK_EDITABLE (entry), entry->selection_bound, new_pos);
905   else
906     gtk_editable_set_position (GTK_EDITABLE (entry), new_pos);
907   
908   gtk_entry_pend_cursor_blink (entry);
909 }
910
911 static void
912 gtk_entry_insert_at_cursor (GtkEntry    *entry,
913                             const gchar *str)
914 {
915   GtkEditable *editable = GTK_EDITABLE (entry);
916   gint pos = entry->current_pos;
917
918   if (entry->editable)
919     {
920       gtk_entry_reset_im_context (entry);
921
922       gtk_editable_insert_text (editable, str, -1, &pos);
923       gtk_editable_set_position (editable, pos);
924     }
925 }
926
927 static void
928 gtk_entry_delete_from_cursor (GtkEntry       *entry,
929                               GtkDeleteType   type,
930                               gint            count)
931 {
932   GtkEditable *editable = GTK_EDITABLE (entry);
933   gint start_pos = entry->current_pos;
934   gint end_pos = entry->current_pos;
935   
936   gtk_entry_reset_im_context (entry);
937
938   if (!entry->editable)
939     return;
940
941   if (entry->selection_bound != entry->current_pos)
942     {
943       gtk_editable_delete_selection (editable);
944       return;
945     }
946   
947   switch (type)
948     {
949     case GTK_DELETE_CHARS:
950       end_pos = gtk_entry_move_logically (entry, entry->current_pos, count);
951       gtk_editable_delete_text (editable, MIN (start_pos, end_pos), MAX (start_pos, end_pos));
952       break;
953     case GTK_DELETE_WORDS:
954       if (count < 0)
955         {
956           /* Move to end of current word, or if not on a word, end of previous word */
957           end_pos = gtk_entry_move_backward_word (entry, end_pos);
958           end_pos = gtk_entry_move_forward_word (entry, end_pos);
959         }
960       else if (count > 0)
961         {
962           /* Move to beginning of current word, or if not on a word, begining of next word */
963           start_pos = gtk_entry_move_forward_word (entry, start_pos);
964           start_pos = gtk_entry_move_backward_word (entry, start_pos);
965         }
966         
967       /* Fall through */
968     case GTK_DELETE_WORD_ENDS:
969       while (count < 0)
970         {
971           start_pos = gtk_entry_move_backward_word (entry, start_pos);
972           count++;
973         }
974       while (count > 0)
975         {
976           end_pos = gtk_entry_move_forward_word (entry, end_pos);
977           count--;
978         }
979       gtk_editable_delete_text (editable, start_pos, end_pos);
980       break;
981     case GTK_DELETE_DISPLAY_LINE_ENDS:
982     case GTK_DELETE_PARAGRAPH_ENDS:
983       if (count < 0)
984         gtk_editable_delete_text (editable, 0, entry->current_pos);
985       else
986         gtk_editable_delete_text (editable, entry->current_pos, -1);
987       break;
988     case GTK_DELETE_DISPLAY_LINES:
989     case GTK_DELETE_PARAGRAPHS:
990       gtk_editable_delete_text (editable, 0, -1);  
991       break;
992     case GTK_DELETE_WHITESPACE:
993       gtk_entry_delete_whitespace (entry);
994       break;
995     }
996   
997   gtk_entry_pend_cursor_blink (entry);
998 }
999
1000 /* IM Context Callbacks
1001  */
1002
1003 static void
1004 gtk_entry_commit_cb (GtkIMContext *context,
1005                      const gchar  *str,
1006                      GtkEntry     *entry)
1007 {
1008   gtk_entry_enter_text (entry, str);
1009 }
1010
1011 static void
1012 gtk_entry_preedit_changed_cb (GtkIMContext *context,
1013                               GtkEntry     *entry)
1014 {
1015   gchar *preedit_string;
1016   gint cursor_pos;
1017
1018   gtk_im_context_get_preedit_string (entry->im_context,
1019                                      &preedit_string, NULL,
1020                                      &cursor_pos);
1021   entry->preedit_length = strlen (preedit_string);
1022   cursor_pos = CLAMP (cursor_pos, 0, g_utf8_strlen (preedit_string, -1));
1023   entry->preedit_cursor = cursor_pos;
1024   g_free (preedit_string);
1025
1026   gtk_entry_recompute (entry);
1027 }
1028
1029 static gboolean
1030 gtk_entry_retrieve_surrounding_cb (GtkIMContext *context,
1031                                GtkEntry     *entry)
1032 {
1033   gtk_im_context_set_surrounding (context,
1034                                   entry->text,
1035                                   entry->n_bytes,
1036                                   g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text);
1037
1038   return TRUE;
1039 }
1040
1041 static gboolean
1042 gtk_entry_delete_surrounding_cb (GtkIMContext *slave,
1043                                  gint          offset,
1044                                  gint          n_chars,
1045                                  GtkEntry     *entry)
1046 {
1047   gtk_editable_delete_text (GTK_EDITABLE (entry),
1048                             entry->current_pos + offset,
1049                             entry->current_pos + offset + n_chars);
1050
1051   return TRUE;
1052 }
1053
1054
1055 /* Internal functions
1056  */
1057
1058 /* Used for im_commit_cb and inserting Unicode chars */
1059 static void
1060 gtk_entry_enter_text (GtkEntry       *entry,
1061                       const gchar    *str)
1062 {
1063   GtkEditable *editable = GTK_EDITABLE (entry);
1064   gint tmp_pos;
1065
1066   if (gtk_editable_get_selection_bounds (editable, NULL, NULL))
1067     gtk_editable_delete_selection (editable);
1068   else
1069     {
1070       if (entry->overwrite_mode)
1071         gtk_entry_delete_from_cursor (entry, GTK_DELETE_CHARS, 1);
1072     }
1073
1074   tmp_pos = entry->current_pos;
1075   gtk_editable_insert_text (editable, str, strlen (str), &tmp_pos);
1076   gtk_editable_set_position (editable, tmp_pos);
1077 }
1078
1079 /* All changes to entry->current_pos and entry->selection_bound
1080  * should go through this function.
1081  */
1082 static void
1083 gtk_entry_set_positions (GtkEntry *entry,
1084                          gint      current_pos,
1085                          gint      selection_bound)
1086 {
1087   gboolean changed = FALSE;
1088
1089   g_object_freeze_notify (G_OBJECT (entry));
1090
1091   if (current_pos != -1 &&
1092       entry->current_pos != current_pos)
1093     {
1094       entry->current_pos = current_pos;
1095       changed = TRUE;
1096
1097       g_object_notify (G_OBJECT (entry), "cursor_position");
1098     }
1099
1100   if (selection_bound != -1 &&
1101       entry->selection_bound != selection_bound)
1102     {
1103       entry->selection_bound = selection_bound;
1104       changed = TRUE;
1105
1106       g_object_notify (G_OBJECT (entry), "selection_bound");
1107     }
1108
1109   g_object_thaw_notify (G_OBJECT (entry));
1110
1111   if (changed)
1112     gtk_entry_recompute (entry);
1113 }
1114
1115 static void
1116 gtk_entry_reset_layout (GtkEntry *entry)
1117 {
1118   if (entry->cached_layout)
1119     {
1120       g_object_unref (G_OBJECT (entry->cached_layout));
1121       entry->cached_layout = NULL;
1122     }
1123 }
1124
1125 static void
1126 update_im_cursor_location (GtkEntry *entry)
1127 {
1128   GdkRectangle area;
1129   gint strong_x;
1130   gint strong_xoffset;
1131   gint x, y, area_width, area_height;
1132
1133   gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &strong_x, NULL)
1134 ;
1135   get_text_area_size (entry, &x, &y, &area_width, &area_height);
1136
1137   strong_xoffset = strong_x - entry->scroll_offset;
1138   if (strong_xoffset < 0)
1139     {
1140       strong_xoffset = 0;
1141     }
1142   else if (strong_xoffset > area_width)
1143     {
1144       strong_xoffset = area_width;
1145     }
1146   area.x = x + strong_xoffset;
1147   area.y = y + area_height;
1148   area.width = area_width;
1149   area.height = area_height;
1150
1151   gtk_im_context_set_cursor_location (entry->im_context, &area);
1152 }
1153
1154 static gboolean
1155 recompute_idle_func (gpointer data)
1156 {
1157   GtkEntry *entry;
1158
1159   GDK_THREADS_ENTER ();
1160
1161   entry = GTK_ENTRY (data);
1162
1163   gtk_entry_adjust_scroll (entry);
1164   gtk_entry_queue_draw (entry);
1165
1166   entry->recompute_idle = FALSE;
1167   
1168   update_im_cursor_location (entry);
1169
1170   GDK_THREADS_LEAVE ();
1171
1172   return FALSE;
1173 }
1174
1175 static void
1176 gtk_entry_recompute (GtkEntry *entry)
1177 {
1178   gtk_entry_reset_layout (entry);
1179   gtk_entry_check_cursor_blink (entry);
1180
1181
1182   if (!entry->recompute_idle)
1183     {
1184       entry->recompute_idle = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 15, /* between resize and redraw */
1185                                                recompute_idle_func, entry, NULL); 
1186     }
1187 }
1188
1189 static void
1190 append_char (GString *str,
1191              gunichar ch,
1192              gint     count)
1193 {
1194   gint i;
1195   gint char_len;
1196   gchar buf[7];
1197   
1198   char_len = g_unichar_to_utf8 (ch, buf);
1199   
1200   i = 0;
1201   while (i < count)
1202     {
1203       g_string_append_len (str, buf, char_len);
1204       ++i;
1205     }
1206 }
1207      
1208 static PangoLayout *
1209 gtk_entry_create_layout (GtkEntry *entry,
1210                          gboolean  include_preedit)
1211 {
1212   PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET (entry), NULL);
1213   PangoAttrList *tmp_attrs = pango_attr_list_new ();
1214   
1215   gchar *preedit_string = NULL;
1216   gint preedit_length = 0;
1217   PangoAttrList *preedit_attrs = NULL;
1218
1219   pango_layout_set_single_paragraph_mode (layout, TRUE);
1220   
1221   if (include_preedit)
1222     {
1223       gtk_im_context_get_preedit_string (entry->im_context,
1224                                          &preedit_string, &preedit_attrs, NULL);
1225       preedit_length = entry->preedit_length;
1226     }
1227
1228   if (preedit_length)
1229     {
1230       GString *tmp_string = g_string_new (NULL);
1231       
1232       gint cursor_index = g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text;
1233       
1234       if (entry->visible)
1235         {
1236           g_string_prepend_len (tmp_string, entry->text, entry->n_bytes);
1237           g_string_insert (tmp_string, cursor_index, preedit_string);
1238         }
1239       else
1240         {
1241           gint ch_len;
1242           gint preedit_len_chars;
1243           gunichar invisible_char;
1244           
1245           ch_len = g_utf8_strlen (entry->text, entry->n_bytes);
1246           preedit_len_chars = g_utf8_strlen (preedit_string, -1);
1247           ch_len += preedit_len_chars;
1248
1249           if (entry->invisible_char != 0)
1250             invisible_char = entry->invisible_char;
1251           else
1252             invisible_char = ' '; /* just pick a char */
1253           
1254           append_char (tmp_string, invisible_char, ch_len);
1255           
1256           /* Fix cursor index to point to invisible char corresponding
1257            * to the preedit, fix preedit_length to be the length of
1258            * the invisible chars representing the preedit
1259            */
1260           cursor_index =
1261             g_utf8_offset_to_pointer (tmp_string->str, entry->current_pos) -
1262             tmp_string->str;
1263           preedit_length =
1264             preedit_len_chars *
1265             g_unichar_to_utf8 (invisible_char, NULL);
1266         }
1267       
1268       pango_layout_set_text (layout, tmp_string->str, tmp_string->len);
1269       
1270       pango_attr_list_splice (tmp_attrs, preedit_attrs,
1271                               cursor_index, preedit_length);
1272       
1273       g_string_free (tmp_string, TRUE);
1274     }
1275   else
1276     {
1277       if (entry->visible)
1278         {
1279           pango_layout_set_text (layout, entry->text, entry->n_bytes);
1280         }
1281       else
1282         {
1283           GString *str = g_string_new (NULL);
1284           gunichar invisible_char;
1285           
1286           if (entry->invisible_char != 0)
1287             invisible_char = entry->invisible_char;
1288           else
1289             invisible_char = ' '; /* just pick a char */
1290           
1291           append_char (str, invisible_char, entry->text_length);
1292           pango_layout_set_text (layout, str->str, str->len);
1293           g_string_free (str, TRUE);
1294         }
1295     }
1296       
1297   pango_layout_set_attributes (layout, tmp_attrs);
1298
1299   if (preedit_string)
1300     g_free (preedit_string);
1301   if (preedit_attrs)
1302     pango_attr_list_unref (preedit_attrs);
1303       
1304   pango_attr_list_unref (tmp_attrs);
1305
1306   return layout;
1307 }
1308
1309 static PangoLayout *
1310 gtk_entry_ensure_layout (GtkEntry *entry,
1311                          gboolean  include_preedit)
1312 {
1313   if (entry->preedit_length > 0 &&
1314       !include_preedit != !entry->cache_includes_preedit)
1315     gtk_entry_reset_layout (entry);
1316
1317   if (!entry->cached_layout)
1318     {
1319       entry->cached_layout = gtk_entry_create_layout (entry, include_preedit);
1320       entry->cache_includes_preedit = include_preedit;
1321     }
1322   
1323   return entry->cached_layout;
1324 }
1325
1326 static void
1327 get_layout_position (GtkEntry *entry,
1328                      gint     *x,
1329                      gint     *y)
1330 {
1331   PangoLayout *layout;
1332   PangoRectangle logical_rect;
1333   gint area_width, area_height;
1334   gint y_pos;
1335   PangoLayoutLine *line;
1336   
1337   layout = gtk_entry_ensure_layout (entry, TRUE);
1338
1339   get_text_area_size (entry, NULL, NULL, &area_width, &area_height);      
1340       
1341   area_height = PANGO_SCALE * (area_height);
1342   
1343   line = pango_layout_get_lines (layout)->data;
1344   pango_layout_line_get_extents (line, NULL, &logical_rect);
1345   
1346   /* Align primarily for locale's ascent/descent */
1347
1348   y_pos = ((area_height - entry->ascent - entry->descent) / 2 + 
1349            entry->ascent + logical_rect.y);
1350
1351   
1352   /* Now see if we need to adjust to fit in actual drawn string */
1353
1354   if (logical_rect.height > area_height)
1355     y_pos = (area_height - logical_rect.height) / 2;
1356   else if (y_pos < 0)
1357     y_pos = 0;
1358   else if (y_pos + logical_rect.height > area_height)
1359     y_pos = area_height - logical_rect.height;
1360   
1361   y_pos = y_pos / PANGO_SCALE;
1362
1363   if (x)
1364     *x = - entry->scroll_offset;
1365
1366   if (y)
1367     *y = y_pos;
1368 }
1369
1370 static void
1371 gtk_entry_draw_text (GtkEntry *entry)
1372 {
1373   GtkWidget *widget;
1374   PangoLayoutLine *line;
1375   
1376   if (!entry->visible && entry->invisible_char == 0)
1377     return;
1378   
1379   if (GTK_WIDGET_DRAWABLE (entry))
1380     {
1381       PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
1382       gint area_width, area_height;
1383
1384       gint x, y;
1385       gint start_pos, end_pos;
1386       
1387       widget = GTK_WIDGET (entry);
1388       
1389       get_layout_position (entry, &x, &y);
1390
1391       get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
1392
1393
1394       gdk_draw_layout (entry->text_area, widget->style->text_gc [widget->state],       
1395                        x, y,
1396                        layout);
1397      
1398  
1399       if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start_pos, &end_pos))
1400         {
1401           gint *ranges;
1402           gint n_ranges, i;
1403           PangoRectangle logical_rect;
1404           const gchar *text = pango_layout_get_text (layout);
1405           gint start_index = g_utf8_offset_to_pointer (text, start_pos) - text;
1406           gint end_index = g_utf8_offset_to_pointer (text, end_pos) - text;
1407           GdkRegion *clip_region = gdk_region_new ();
1408           GdkGC *text_gc;
1409           GdkGC *selection_gc;
1410
1411           line = pango_layout_get_lines (layout)->data;
1412           
1413           pango_layout_line_get_x_ranges (line, start_index, end_index, &ranges, &n_ranges);
1414
1415           pango_layout_get_extents (layout, NULL, &logical_rect);
1416           
1417           if (GTK_WIDGET_HAS_FOCUS (entry))
1418             {
1419               selection_gc = widget->style->base_gc [GTK_STATE_SELECTED];
1420               text_gc = widget->style->text_gc [GTK_STATE_SELECTED];
1421             }
1422           else
1423             {
1424               selection_gc = widget->style->base_gc [GTK_STATE_ACTIVE];
1425               text_gc = widget->style->text_gc [GTK_STATE_ACTIVE];
1426             }
1427           
1428           for (i=0; i < n_ranges; i++)
1429             {
1430               GdkRectangle rect;
1431
1432               rect.x = INNER_BORDER - entry->scroll_offset + ranges[2*i] / PANGO_SCALE;
1433               rect.y = y;
1434               rect.width = (ranges[2*i + 1] - ranges[2*i]) / PANGO_SCALE;
1435               rect.height = logical_rect.height / PANGO_SCALE;
1436                 
1437               gdk_draw_rectangle (entry->text_area, selection_gc, TRUE,
1438                                   rect.x, rect.y, rect.width, rect.height);
1439
1440               gdk_region_union_with_rect (clip_region, &rect);
1441             }
1442
1443           gdk_gc_set_clip_region (text_gc, clip_region);
1444           gdk_draw_layout (entry->text_area, text_gc, 
1445                            x, y,
1446                            layout);
1447           gdk_gc_set_clip_region (text_gc, NULL);
1448           
1449           gdk_region_destroy (clip_region);
1450           g_free (ranges);
1451         }
1452     }
1453 }
1454
1455 /*
1456  * From _gtk_get_insertion_cursor_gc
1457  */
1458
1459 typedef struct _CursorInfo CursorInfo;
1460
1461 struct _CursorInfo
1462 {
1463   GType for_type;
1464   GdkGC *primary_gc;
1465   GdkGC *secondary_gc;
1466 };
1467
1468 static GdkGC *
1469 make_cursor_gc (GtkWidget *widget,
1470                const gchar *property_name,
1471                GdkColor *fallback)
1472 {
1473   GdkGCValues gc_values;
1474   GdkGCValuesMask gc_values_mask;
1475   GdkColor *cursor_color;
1476
1477   gtk_widget_style_get (widget, property_name, &cursor_color, NULL);
1478   
1479   gc_values_mask = GDK_GC_FOREGROUND;
1480   if (cursor_color)
1481     {
1482       gc_values.foreground = *cursor_color;
1483       gdk_color_free (cursor_color);
1484     }
1485   else
1486     gc_values.foreground = *fallback;
1487   
1488   gdk_rgb_find_color (widget->style->colormap, &gc_values.foreground);
1489   return gtk_gc_get (widget->style->depth, widget->style->colormap,
1490     &gc_values, gc_values_mask);
1491 }
1492
1493 static GdkGC *
1494 _gtkextra_get_insertion_cursor_gc (GtkWidget *widget,
1495                                   gboolean   is_primary)
1496 {
1497   CursorInfo *cursor_info;
1498
1499   cursor_info = g_object_get_data (G_OBJECT (widget->style), "gtk-style-cursor-info");
1500   if (!cursor_info)
1501     {
1502       cursor_info = g_new (CursorInfo, 1);
1503       g_object_set_data (G_OBJECT (widget->style), "gtk-style-cursor-info", cursor_info);
1504       cursor_info->primary_gc = NULL;
1505       cursor_info->secondary_gc = NULL;
1506       cursor_info->for_type = G_TYPE_INVALID;
1507     }
1508
1509   /* We have to keep track of the type because gtk_widget_style_get()
1510    * can return different results when called on the same property and
1511    * same style but for different widgets. :-(. That is,
1512    * GtkEntry::cursor-color = "red" in a style will modify the cursor
1513    * color for entries but not for text view.
1514    */
1515   if (cursor_info->for_type != G_OBJECT_TYPE (widget))
1516     {
1517       cursor_info->for_type = G_OBJECT_TYPE (widget);
1518       if (cursor_info->primary_gc)
1519         {
1520           gtk_gc_release (cursor_info->primary_gc);
1521           cursor_info->primary_gc = NULL;
1522         }
1523       if (cursor_info->secondary_gc)
1524         {
1525           gtk_gc_release (cursor_info->secondary_gc);
1526           cursor_info->secondary_gc = NULL;
1527         }
1528     }
1529
1530   if (is_primary)
1531     {
1532       if (!cursor_info->primary_gc)
1533         cursor_info->primary_gc = make_cursor_gc (widget,
1534                                                   "cursor-color",
1535                                                   &widget->style->black);
1536         
1537       return g_object_ref (cursor_info->primary_gc);
1538     }
1539   else
1540     {
1541       static GdkColor gray = { 0, 0x8888, 0x8888, 0x8888 };
1542       
1543       if (!cursor_info->secondary_gc)
1544         cursor_info->secondary_gc = make_cursor_gc (widget,
1545                                                     "secondary-cursor-color",
1546                                                     &gray);
1547         
1548       return g_object_ref (cursor_info->secondary_gc);
1549     }
1550 }
1551
1552 /*
1553  * From _gtk_draw_insertion_cursor
1554  */
1555 static void
1556 _gtkextra_draw_insertion_cursor (GtkWidget *widget,
1557                                 GdkDrawable *drawable,
1558                                 GdkGC *gc,
1559                                 GdkRectangle *location,
1560                                 GtkTextDirection direction,
1561                                 gboolean draw_arrow)
1562 {
1563   gint stem_width;
1564   gint arrow_width;
1565   gint x, y;
1566   gint i;
1567   gfloat cursor_aspect_ratio;
1568   gint offset;
1569   
1570   g_return_if_fail (direction != GTK_TEXT_DIR_NONE);
1571   
1572   gtk_widget_style_get (widget, "cursor-aspect-ratio", &cursor_aspect_ratio, NULL);
1573   
1574   stem_width = location->height * cursor_aspect_ratio + 1;
1575   arrow_width = stem_width + 1;
1576
1577   /* put (stem_width % 2) on the proper side of the cursor */
1578   if (direction == GTK_TEXT_DIR_LTR)
1579     offset = stem_width / 2;
1580   else
1581     offset = stem_width - stem_width / 2;
1582   
1583   for (i = 0; i < stem_width; i++)
1584     gdk_draw_line (drawable, gc,
1585                    location->x + i - offset, location->y,
1586                    location->x + i - offset, location->y + location->height - 1);
1587
1588   if (draw_arrow)
1589     {
1590       if (direction == GTK_TEXT_DIR_RTL)
1591         {
1592           x = location->x - offset - 1;
1593           y = location->y + location->height - arrow_width * 2 - arrow_width + 1;
1594   
1595           for (i = 0; i < arrow_width; i++)
1596             {
1597               gdk_draw_line (drawable, gc,
1598                              x, y + i + 1,
1599                              x, y + 2 * arrow_width - i - 1);
1600               x --;
1601             }
1602         }
1603       else if (direction == GTK_TEXT_DIR_LTR)
1604         {
1605           x = location->x + stem_width - offset;
1606           y = location->y + location->height - arrow_width * 2 - arrow_width + 1;
1607   
1608           for (i = 0; i < arrow_width; i++) 
1609             {
1610               gdk_draw_line (drawable, gc,
1611                              x, y + i + 1,
1612                              x, y + 2 * arrow_width - i - 1);
1613               x++;
1614             }
1615         }
1616     }
1617 }
1618
1619 static void
1620 gtk_entry_draw_cursor (GtkEntry  *entry,
1621                        CursorType type)
1622 {
1623   GtkTextDirection keymap_direction =
1624     (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
1625     GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
1626   GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (entry));
1627  
1628   if (GTK_WIDGET_DRAWABLE (entry) && GTK_ENTRY(entry)->cursor_visible)
1629     {
1630       GtkWidget *widget = GTK_WIDGET (entry);
1631       GdkRectangle cursor_location;
1632       gboolean split_cursor;
1633
1634       gint xoffset = INNER_BORDER - entry->scroll_offset;
1635       gint strong_x, weak_x;
1636       gint text_area_height;
1637       GtkTextDirection dir1 = GTK_TEXT_DIR_NONE;
1638       GtkTextDirection dir2 = GTK_TEXT_DIR_NONE;
1639       gint x1 = 0;
1640       gint x2 = 0;
1641       GdkGC *gc;
1642
1643       gdk_window_get_size (entry->text_area, NULL, &text_area_height);
1644       
1645       gtk_entry_get_cursor_locations (entry, type, &strong_x, &weak_x);
1646
1647       g_object_get (gtk_widget_get_settings (widget),
1648                     "gtk-split-cursor", &split_cursor,
1649                     NULL);
1650
1651       dir1 = widget_direction;
1652       
1653       if (split_cursor)
1654         {
1655           x1 = strong_x;
1656
1657           if (weak_x != strong_x)
1658             {
1659               dir2 = (widget_direction == GTK_TEXT_DIR_LTR) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
1660               x2 = weak_x;
1661             }
1662         }
1663       else
1664         {
1665           if (keymap_direction == widget_direction)
1666             x1 = strong_x;
1667           else
1668             x1 = weak_x;
1669         }
1670
1671       cursor_location.x = xoffset + x1;
1672       cursor_location.y = INNER_BORDER;
1673       cursor_location.width = 0;
1674       cursor_location.height = text_area_height - 2 * INNER_BORDER ;
1675
1676       gc = _gtkextra_get_insertion_cursor_gc (widget, TRUE);
1677       _gtkextra_draw_insertion_cursor (widget, entry->text_area, gc,
1678                                   &cursor_location, dir1,
1679                                   dir2 != GTK_TEXT_DIR_NONE);
1680       g_object_unref (gc);
1681       
1682       if (dir2 != GTK_TEXT_DIR_NONE)
1683         {
1684           cursor_location.x = xoffset + x2;
1685           gc = _gtkextra_get_insertion_cursor_gc (widget, FALSE);
1686           _gtkextra_draw_insertion_cursor (widget, entry->text_area, gc,
1687                                       &cursor_location, dir2,
1688                                       TRUE);
1689           g_object_unref (gc);
1690         }
1691     }
1692 }
1693
1694 static void
1695 gtk_entry_queue_draw (GtkEntry *entry)
1696 {
1697   if (GTK_WIDGET_REALIZED (entry))
1698     gdk_window_invalidate_rect (entry->text_area, NULL, FALSE);
1699 }
1700
1701 static void
1702 gtk_entry_reset_im_context (GtkEntry *entry)
1703 {
1704   if (entry->need_im_reset)
1705     {
1706       entry->need_im_reset = 0;
1707       gtk_im_context_reset (entry->im_context);
1708     }
1709 }
1710
1711 static void
1712 gtk_entry_get_cursor_locations (GtkEntry   *entry,
1713                                 CursorType  type,
1714                                 gint       *strong_x,
1715                                 gint       *weak_x)
1716 {
1717   PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
1718   const gchar *text;
1719   PangoRectangle strong_pos, weak_pos;
1720   gint index;
1721   
1722   if (type == CURSOR_STANDARD)
1723     {
1724       text = pango_layout_get_text (layout);
1725       index = g_utf8_offset_to_pointer (text, entry->current_pos + entry->preedit_cursor) - text;
1726     }
1727   else /* type == CURSOR_DND */
1728     {
1729       index = g_utf8_offset_to_pointer (entry->text, entry->dnd_position) - entry->text;
1730       if (entry->dnd_position > entry->current_pos)
1731         index += entry->preedit_length;
1732     }
1733       
1734   pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);
1735
1736   if (strong_x)
1737     *strong_x = strong_pos.x / PANGO_SCALE;
1738
1739   if (weak_x)
1740     *weak_x = weak_pos.x / PANGO_SCALE;
1741 }
1742
1743 static void
1744 gtk_entry_adjust_scroll (GtkEntry *entry)
1745 {
1746   gint min_offset, max_offset;
1747   gint text_area_width;
1748   gint strong_x, weak_x;
1749   PangoLayout *layout;
1750   PangoLayoutLine *line;
1751   PangoRectangle logical_rect;
1752   GtkItemEntry *item_entry;
1753   gint text_width;
1754
1755   if (!GTK_WIDGET_REALIZED (entry))
1756     return;
1757
1758   item_entry = GTK_ITEM_ENTRY(entry);
1759   
1760   gdk_window_get_size (entry->text_area, &text_area_width, NULL);
1761   text_area_width -= 2 * INNER_BORDER;
1762
1763   layout = gtk_entry_ensure_layout (entry, TRUE);
1764   line = pango_layout_get_lines (layout)->data;
1765
1766   pango_layout_line_get_extents (line, NULL, &logical_rect);
1767   text_width = logical_rect.width / PANGO_SCALE + 2; /* 2 for cursor */
1768
1769   gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &strong_x, &weak_x);
1770
1771   /* Display as much text as we can */
1772
1773   if (gtk_widget_get_direction (GTK_WIDGET (entry)) == GTK_TEXT_DIR_LTR)
1774     {
1775       entry->scroll_offset = 0;
1776       switch(item_entry->justification){
1777
1778         case GTK_JUSTIFY_FILL:
1779         case GTK_JUSTIFY_LEFT:
1780
1781 /* LEFT JUSTIFICATION */
1782
1783           strong_x -= entry->scroll_offset;
1784           if (strong_x < 0)
1785             entry->scroll_offset += strong_x;
1786           else if (strong_x > text_area_width){
1787             if(item_entry->text_max_size != 0 &&
1788                text_area_width + 2 <= item_entry->text_max_size){
1789                GtkAllocation allocation;
1790                allocation = GTK_WIDGET(entry)->allocation;
1791                allocation.width += text_width - text_area_width;
1792                entry->scroll_offset = 0;
1793                gtk_entry_size_allocate(GTK_WIDGET(entry), &allocation);
1794             }else{
1795                entry->scroll_offset += (strong_x - text_area_width) + 1;
1796             }
1797           }
1798  
1799           break;
1800
1801         case GTK_JUSTIFY_RIGHT:
1802     
1803     /* RIGHT JUSTIFICATION FOR NUMBERS */
1804           if(entry->text){
1805
1806             entry->scroll_offset=  -(text_area_width - text_width) + 1;
1807             if(entry->scroll_offset > 0){
1808               if(item_entry->text_max_size != 0 &&
1809                 text_area_width + 2 <= item_entry->text_max_size){
1810                 GtkAllocation allocation;
1811                 allocation = GTK_WIDGET(entry)->allocation;
1812                 allocation.x -= text_width - text_area_width;
1813                 allocation.width += text_width - text_area_width;
1814                 entry->scroll_offset = 0;
1815                 gtk_entry_size_allocate(GTK_WIDGET(entry), &allocation);
1816               }
1817               else
1818               {
1819                 entry->scroll_offset= -(text_area_width - strong_x) + 1;
1820                 if(entry->scroll_offset < 0) entry->scroll_offset = 0;
1821               }
1822             } 
1823           }
1824           else
1825             entry->scroll_offset=0;
1826
1827           break;
1828         case GTK_JUSTIFY_CENTER:
1829     
1830           if(entry->text){
1831      
1832             entry->scroll_offset=  -(text_area_width - text_width)/2;
1833             if(entry->scroll_offset > 0){
1834               if(item_entry->text_max_size != 0 &&
1835                           text_area_width+1<=item_entry->text_max_size){
1836                 GtkAllocation allocation;
1837                 allocation = GTK_WIDGET(entry)->allocation;
1838                 allocation.x += (text_area_width/2 - text_width/2);
1839                 allocation.width += text_width - text_area_width;
1840                 entry->scroll_offset = 0;
1841                 gtk_entry_size_allocate(GTK_WIDGET(entry), &allocation);
1842               }
1843               else
1844               {
1845                 entry->scroll_offset= -(text_area_width - strong_x) + 1;
1846                 if(entry->scroll_offset < 0) entry->scroll_offset = 0;
1847               }
1848             }
1849           }
1850           else
1851             entry->scroll_offset=0;
1852
1853           break;
1854
1855       }
1856
1857     }
1858   else
1859     {
1860       max_offset = text_width - text_area_width;
1861       min_offset = MIN (0, max_offset);
1862       entry->scroll_offset = CLAMP (entry->scroll_offset, min_offset, max_offset);
1863     }
1864
1865   g_object_notify (G_OBJECT (entry), "scroll_offset");
1866 }
1867
1868 static gint
1869 gtk_entry_move_visually (GtkEntry *entry,
1870                          gint      start,
1871                          gint      count)
1872 {
1873   gint index;
1874   PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
1875   const gchar *text;
1876
1877   text = pango_layout_get_text (layout);
1878   
1879   index = g_utf8_offset_to_pointer (text, start) - text;
1880
1881   while (count != 0)
1882     {
1883       int new_index, new_trailing;
1884       gboolean split_cursor;
1885       gboolean strong;
1886
1887       g_object_get (gtk_widget_get_settings (GTK_WIDGET (entry)),
1888                     "gtk-split-cursor", &split_cursor,
1889                     NULL);
1890
1891       if (split_cursor)
1892         strong = TRUE;
1893       else
1894         {
1895           GtkTextDirection keymap_direction =
1896             (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ?
1897             GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
1898
1899           strong = keymap_direction == gtk_widget_get_direction (GTK_WIDGET (entry));
1900         }
1901       
1902       if (count > 0)
1903         {
1904           pango_layout_move_cursor_visually (layout, strong, index, 0, 1, &new_index, &new_trailing);
1905           count--;
1906         }
1907       else
1908         {
1909           pango_layout_move_cursor_visually (layout, strong, index, 0, -1, &new_index, &new_trailing);
1910           count++;
1911         }
1912
1913       if (new_index < 0 || new_index == G_MAXINT)
1914         break;
1915
1916       index = new_index;
1917       
1918       while (new_trailing--)
1919         index = g_utf8_next_char (entry->text + new_index) - entry->text;
1920     }
1921   
1922   return g_utf8_pointer_to_offset (text, text + index);
1923 }
1924
1925 static gint
1926 gtk_entry_move_logically (GtkEntry *entry,
1927                           gint      start,
1928                           gint      count)
1929 {
1930   gint new_pos = start;
1931
1932   /* Prevent any leak of information */
1933   if (!entry->visible)
1934     {
1935       new_pos = CLAMP (start + count, 0, entry->text_length);
1936     }
1937   else if (entry->text)
1938     {
1939       PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
1940       PangoLogAttr *log_attrs;
1941       gint n_attrs;
1942
1943       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
1944
1945       while (count > 0 && new_pos < entry->text_length)
1946         {
1947           do
1948             new_pos++;
1949           while (new_pos < entry->text_length && !log_attrs[new_pos].is_cursor_position);
1950           
1951           count--;
1952         }
1953       while (count < 0 && new_pos > 0)
1954         {
1955           do
1956             new_pos--;
1957           while (new_pos > 0 && !log_attrs[new_pos].is_cursor_position);
1958           
1959           count++;
1960         }
1961       
1962       g_free (log_attrs);
1963     }
1964
1965   return new_pos;
1966 }
1967
1968 static gint
1969 gtk_entry_move_forward_word (GtkEntry *entry,
1970                              gint      start)
1971 {
1972   gint new_pos = start;
1973
1974   /* Prevent any leak of information */
1975   if (!entry->visible)
1976     {
1977       new_pos = entry->text_length;
1978     }
1979   else if (entry->text && (new_pos < entry->text_length))
1980     {
1981       PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
1982       PangoLogAttr *log_attrs;
1983       gint n_attrs;
1984
1985       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
1986       
1987       /* Find the next word end */
1988       new_pos++;
1989       while (new_pos < n_attrs && !log_attrs[new_pos].is_word_end)
1990         new_pos++;
1991
1992       g_free (log_attrs);
1993     }
1994
1995   return new_pos;
1996 }
1997
1998
1999 static gint
2000 gtk_entry_move_backward_word (GtkEntry *entry,
2001                               gint      start)
2002 {
2003   gint new_pos = start;
2004
2005   /* Prevent any leak of information */
2006   if (!entry->visible)
2007     {
2008       new_pos = 0;
2009     }
2010   else if (entry->text && start > 0)
2011     {
2012       PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
2013       PangoLogAttr *log_attrs;
2014       gint n_attrs;
2015
2016       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
2017
2018       new_pos = start - 1;
2019
2020       /* Find the previous word beginning */
2021       while (new_pos > 0 && !log_attrs[new_pos].is_word_start)
2022         new_pos--;
2023
2024       g_free (log_attrs);
2025     }
2026
2027   return new_pos;
2028 }
2029
2030 static void
2031 gtk_entry_delete_whitespace (GtkEntry *entry)
2032 {
2033   PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
2034   PangoLogAttr *log_attrs;
2035   gint n_attrs;
2036   gint start, end;
2037
2038   pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
2039
2040   start = end = entry->current_pos;
2041   
2042   while (start > 0 && log_attrs[start-1].is_white)
2043     start--;
2044
2045   while (end < n_attrs && log_attrs[end].is_white)
2046     end++;
2047
2048   g_free (log_attrs);
2049
2050   if (start != end)
2051     gtk_editable_delete_text (GTK_EDITABLE (entry), start, end);
2052 }
2053
2054
2055 /*
2056  * Like gtk_editable_get_chars, but if the editable is not
2057  * visible, return asterisks; also convert result to UTF-8.
2058  */
2059 static char *    
2060 gtk_entry_get_public_chars (GtkEntry *entry,
2061                             gint      start,
2062                             gint      end)
2063 {
2064   if (end < 0)
2065     end = entry->text_length;
2066   
2067   if (entry->visible)
2068     return gtk_editable_get_chars (GTK_EDITABLE (entry), start, end);
2069   else
2070     {
2071       gchar *str;
2072       gint i;
2073       gint n_chars = end - start;
2074        
2075       str = g_malloc (n_chars + 1);
2076       for (i = 0; i < n_chars; i++)
2077         str[i] = '*';
2078       str[i] = '\0';
2079       
2080       return str;
2081     }
2082
2083 }
2084
2085 static void
2086 primary_get_cb (GtkClipboard     *clipboard,
2087                 GtkSelectionData *selection_data,
2088                 guint             info,
2089                 gpointer          data)
2090 {
2091   GtkEntry *entry = GTK_ENTRY (data);
2092   gint start, end;
2093   
2094   if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
2095     {
2096       gchar *str = gtk_entry_get_public_chars (entry, start, end);
2097       gtk_selection_data_set_text (selection_data, str, -1);
2098       g_free (str);
2099     }
2100 }
2101
2102 static void
2103 primary_clear_cb (GtkClipboard *clipboard,
2104                   gpointer      data)
2105 {
2106   GtkEntry *entry = GTK_ENTRY (data);
2107
2108   gtk_editable_select_region (GTK_EDITABLE (entry), entry->current_pos, entry->current_pos);
2109 }
2110
2111 static void
2112 gtk_entry_update_primary_selection (GtkEntry *entry)
2113 {
2114   static const GtkTargetEntry targets[] = {
2115     { "UTF8_STRING", 0, 0 },
2116     { "STRING", 0, 0 },
2117     { "TEXT",   0, 0 }, 
2118     { "COMPOUND_TEXT", 0, 0 }
2119   };
2120   
2121   GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
2122   gint start, end;
2123   
2124   if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
2125     {
2126       if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
2127                                          primary_get_cb, primary_clear_cb, G_OBJECT (entry)))
2128         primary_clear_cb (clipboard, entry);
2129     }
2130   else
2131     {
2132       if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (entry))
2133         gtk_clipboard_clear (clipboard);
2134     }
2135 }
2136
2137 /* Public API
2138  */
2139
2140 GtkWidget*
2141 gtk_item_entry_new (void)
2142 {
2143   GtkWidget *widget;
2144
2145   widget = GTK_WIDGET (gtk_type_new (GTK_TYPE_ITEM_ENTRY));
2146   return widget;
2147 }
2148
2149 GtkWidget*
2150 gtk_item_entry_new_with_max_length (gint max)
2151 {
2152   GtkItemEntry *entry;
2153
2154   entry = gtk_type_new (GTK_TYPE_ITEM_ENTRY);
2155   gtk_entry_set_max_length(GTK_ENTRY(entry), max);
2156
2157   return GTK_WIDGET (entry);
2158 }
2159
2160 void
2161 gtk_item_entry_set_text (GtkItemEntry    *entry,
2162                          const gchar *text,
2163                          GtkJustification justification)
2164 {
2165   gint tmp_pos;
2166
2167   g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
2168   g_return_if_fail (text != NULL);
2169
2170   entry->justification = justification;
2171
2172   /* Actually setting the text will affect the cursor and selection;
2173    * if the contents don't actually change, this will look odd to the user.
2174    */
2175   if (strcmp (GTK_ENTRY(entry)->text, text) == 0)
2176     return;
2177
2178   if (GTK_ENTRY(entry)->recompute_idle){
2179     g_source_remove (GTK_ENTRY(entry)->recompute_idle);
2180     GTK_ENTRY(entry)->recompute_idle = 0;
2181   }
2182   if (GTK_ENTRY(entry)->blink_timeout){
2183     g_source_remove (GTK_ENTRY(entry)->blink_timeout);
2184     GTK_ENTRY(entry)->blink_timeout = 0;
2185   }
2186
2187   gtk_editable_delete_text (GTK_EDITABLE (entry), 0, -1);
2188
2189   tmp_pos = 0;
2190   gtk_editable_insert_text (GTK_EDITABLE (entry), text, strlen (text), &tmp_pos);
2191 }
2192
2193 /**
2194  * gtk_entry_get_layout_offsets:
2195  * @entry: a #GtkEntry
2196  * @x: location to store X offset of layout, or %NULL
2197  * @y: location to store Y offset of layout, or %NULL
2198  *
2199  *
2200  * Obtains the position of the #PangoLayout used to render text
2201  * in the entry, in widget coordinates. Useful if you want to line
2202  * up the text in an entry with some other text, e.g. when using the
2203  * entry to implement editable cells in a sheet widget.
2204  *
2205  * Also useful to convert mouse events into coordinates inside the
2206  * #PangoLayout, e.g. to take some action if some part of the entry text
2207  * is clicked.
2208  * 
2209  * Note that as the user scrolls around in the entry the offsets will
2210  * change; you'll need to connect to the "notify::scroll_offset"
2211  * signal to track this. Remember when using the #PangoLayout
2212  * functions you need to convert to and from pixels using
2213  * PANGO_PIXELS() or #PANGO_SCALE.
2214  *
2215  * Keep in mind that the layout text may contain a preedit string, so
2216  * gtk_entry_layout_index_to_text_index() and
2217  * gtk_entry_text_index_to_layout_index() are needed to convert byte
2218  * indices in the layout to byte indices in the entry contents.
2219  * 
2220  **/
2221 void
2222 gtk_item_entry_get_layout_offsets (GtkItemEntry *entry,
2223                                    gint     *x,
2224                                    gint     *y)
2225 {
2226   gint text_area_x, text_area_y;
2227   
2228   g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
2229
2230   /* this gets coords relative to text area */
2231   get_layout_position (GTK_ENTRY(entry), x, y);
2232
2233   /* convert to widget coords */
2234   get_text_area_size (GTK_ENTRY(entry), &text_area_x, &text_area_y, NULL, NULL);
2235   
2236   if (x)
2237     *x += text_area_x;
2238
2239   if (y)
2240     *y += text_area_y;
2241 }
2242
2243 void
2244 gtk_item_entry_set_justification(GtkItemEntry *entry, GtkJustification just)
2245 {
2246   g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
2247
2248   entry->justification = just;
2249 }
2250
2251
2252 /* We display the cursor when
2253  *
2254  *  - the selection is empty, AND
2255  *  - the widget has focus
2256  */
2257
2258 #define CURSOR_ON_MULTIPLIER 0.66
2259 #define CURSOR_OFF_MULTIPLIER 0.34
2260 #define CURSOR_PEND_MULTIPLIER 1.0
2261
2262 static gboolean
2263 cursor_blinks (GtkEntry *entry)
2264 {
2265   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
2266   gboolean blink;
2267
2268   if (GTK_WIDGET_HAS_FOCUS (entry) &&
2269       entry->selection_bound == entry->current_pos)
2270     {
2271       g_object_get (G_OBJECT (settings), "gtk-cursor-blink", &blink, NULL);
2272       return blink;
2273     }
2274   else
2275     return FALSE;
2276 }
2277
2278 static gint
2279 get_cursor_time (GtkEntry *entry)
2280 {
2281   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
2282   gint time;
2283
2284   g_object_get (G_OBJECT (settings), "gtk-cursor-blink-time", &time, NULL);
2285
2286   return time;
2287 }
2288
2289 static void
2290 show_cursor (GtkEntry *entry)
2291 {
2292   if (!entry->cursor_visible)
2293     {
2294       entry->cursor_visible = TRUE;
2295
2296       if (GTK_WIDGET_HAS_FOCUS (entry) && entry->selection_bound == entry->current_pos)
2297         gtk_widget_queue_draw (GTK_WIDGET (entry));
2298     }
2299 }
2300
2301 static void
2302 hide_cursor (GtkEntry *entry)
2303 {
2304   if (entry->cursor_visible)
2305     {
2306       entry->cursor_visible = FALSE;
2307
2308       if (GTK_WIDGET_HAS_FOCUS (entry) && entry->selection_bound == entry->current_pos)
2309         gtk_widget_queue_draw (GTK_WIDGET (entry));
2310     }
2311 }
2312
2313 /*
2314  * Blink!
2315  */
2316 static gint
2317 blink_cb (gpointer data)
2318 {
2319   GtkEntry *entry;
2320
2321   GDK_THREADS_ENTER ();
2322
2323   entry = GTK_ENTRY (data);
2324   
2325   g_assert (GTK_WIDGET_HAS_FOCUS (entry));
2326   g_assert (entry->selection_bound == entry->current_pos);
2327
2328   if (entry->cursor_visible)
2329     {
2330       hide_cursor (entry);
2331       entry->blink_timeout = gtk_timeout_add (get_cursor_time (entry) * CURSOR_OFF_MULTIPLIER,
2332                                               blink_cb,
2333                                               entry);
2334     }
2335   else
2336     {
2337       show_cursor (entry);
2338       entry->blink_timeout = gtk_timeout_add (get_cursor_time (entry) * CURSOR_ON_MULTIPLIER,
2339                                               blink_cb,
2340                                               entry);
2341     }
2342
2343   GDK_THREADS_LEAVE ();
2344
2345   /* Remove ourselves */
2346   return FALSE;
2347 }
2348
2349 static void
2350 gtk_entry_check_cursor_blink (GtkEntry *entry)
2351 {
2352   if (cursor_blinks (entry))
2353     {
2354       if (!entry->blink_timeout)
2355         {
2356           entry->blink_timeout = gtk_timeout_add (get_cursor_time (entry) * CURSOR_ON_MULTIPLIER,
2357                                                   blink_cb,
2358                                                   entry);
2359           show_cursor (entry);
2360         }
2361     }
2362   else
2363     {
2364       if (entry->blink_timeout)  
2365         { 
2366           gtk_timeout_remove (entry->blink_timeout);
2367           entry->blink_timeout = 0;
2368         }
2369       
2370       entry->cursor_visible = TRUE;
2371     }
2372   
2373 }
2374
2375 static void
2376 gtk_entry_pend_cursor_blink (GtkEntry *entry)
2377 {
2378   if (cursor_blinks (entry))
2379     {
2380       if (entry->blink_timeout != 0)
2381         gtk_timeout_remove (entry->blink_timeout);
2382       
2383       entry->blink_timeout = gtk_timeout_add (get_cursor_time (entry) * CURSOR_PEND_MULTIPLIER,
2384                                               blink_cb,
2385                                               entry);
2386       show_cursor (entry);
2387     }
2388 }
2389
2390 void
2391 gtk_item_entry_set_cursor_visible(GtkItemEntry *entry, gboolean visible)
2392 {
2393   g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
2394
2395   GTK_ENTRY(entry)->cursor_visible = visible;
2396 }
2397
2398 gboolean
2399 gtk_item_entry_get_cursor_visible(GtkItemEntry *entry)
2400 {
2401   g_return_val_if_fail (GTK_IS_ITEM_ENTRY (entry), FALSE);
2402
2403   return(GTK_ENTRY(entry)->cursor_visible);
2404 }