?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial import of gattrib 20040806
[geda-gaf/whiteaudio.git] / gattrib / src / gtkitementry_1_2.c
blob947b9cea19d442a0defe691719e7d04f4dad7648
1 /* GtkItemEntry - widget for gtk+
2 * Copyright (C) 1999-2001 Adrian E. Feiguin <adrian@ifir.ifir.edu.ar>
3 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 *
5 * GtkItemEntry widget by Adrian E. Feiguin
6 * Based on GtkEntry widget
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the Free
20 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include <ctype.h>
24 #include <string.h>
25 #include <gdk/gdkkeysyms.h>
26 #include <gdk/gdki18n.h>
27 #include <gtk/gtkmain.h>
28 #include <gtk/gtkselection.h>
29 #include <gtk/gtksignal.h>
30 #include <gtk/gtkentry.h>
31 #include "gtkitementry_1_2.h"
32
33 #define MIN_ENTRY_WIDTH 150
34 #define DRAW_TIMEOUT 20
35 #define INNER_BORDER 4
36
37 enum {
38 ARG_0,
39 ARG_MAX_LENGTH,
40 ARG_VISIBILITY
41 };
42
43
44 static void gtk_entry_class_init (GtkItemEntryClass *klass);
45 static void gtk_entry_init (GtkItemEntry *entry);
46 static void gtk_entry_set_position_from_editable
47 (GtkEditable *editable,
48 gint position);
49 static void gtk_entry_realize (GtkWidget *widget);
50 static void gtk_entry_unrealize (GtkWidget *widget);
51 static void gtk_entry_draw_focus (GtkWidget *widget);
52 static void gtk_entry_size_allocate (GtkWidget *widget,
53 GtkAllocation *allocation);
54 static void gtk_entry_size_request (GtkWidget *widget,
55 GtkRequisition *requisition);
56 static void gtk_entry_make_backing_pixmap (GtkEntry *entry,
57 gint width, gint height);
58 static void gtk_entry_draw (GtkWidget *widget,
59 GdkRectangle *area);
60 static gint gtk_entry_expose (GtkWidget *widget,
61 GdkEventExpose *event);
62 static gint gtk_entry_button_press (GtkWidget *widget,
63 GdkEventButton *event);
64 static gint gtk_entry_button_release (GtkWidget *widget,
65 GdkEventButton *event);
66 static gint gtk_entry_motion_notify (GtkWidget *widget,
67 GdkEventMotion *event);
68 static gint gtk_entry_key_press (GtkWidget *widget,
69 GdkEventKey *event);
70 static void gtk_entry_draw_text (GtkEntry *entry);
71 static void gtk_entry_draw_cursor (GtkEntry *entry);
72 static void gtk_entry_draw_cursor_on_drawable
73 (GtkEntry *entry,
74 GdkDrawable *drawable);
75 #ifdef USE_XIM
76 static void gtk_entry_update_ic_attr (GtkWidget *widget);
77 #endif
78 static void gtk_entry_queue_draw (GtkEntry *entry);
79 static gint gtk_entry_timer (gpointer data);
80 static gint gtk_entry_position (GtkEntry *entry,
81 gint x);
82 static void entry_adjust_scroll (GtkEntry *entry);
83 static void gtk_entry_grow_text (GtkEntry *entry);
84 static void gtk_entry_insert_text (GtkEditable *editable,
85 const gchar *new_text,
86 gint new_text_length,
87 gint *position);
88 static void gtk_entry_delete_text (GtkEditable *editable,
89 gint start_pos,
90 gint end_pos);
91 static void gtk_entry_update_text (GtkEditable *editable,
92 gint start_pos,
93 gint end_pos);
94 static gchar *gtk_entry_get_chars (GtkEditable *editable,
95 gint start_pos,
96 gint end_pos);
97
98 /* Binding actions */
99 static void gtk_entry_move_cursor (GtkEditable *editable,
100 gint x,
101 gint y);
102 static void gtk_entry_move_word (GtkEditable *editable,
103 gint n);
104 static void gtk_entry_move_to_column (GtkEditable *editable,
105 gint row);
106 static void gtk_entry_kill_char (GtkEditable *editable,
107 gint direction);
108 static void gtk_entry_kill_word (GtkEditable *editable,
109 gint direction);
110 static void gtk_entry_kill_line (GtkEditable *editable,
111 gint direction);
112
113 /* To be removed */
114 static void gtk_move_forward_character (GtkEntry *entry);
115 static void gtk_move_backward_character (GtkEntry *entry);
116 static void gtk_move_forward_word (GtkEntry *entry);
117 static void gtk_move_backward_word (GtkEntry *entry);
118 static void gtk_move_beginning_of_line (GtkEntry *entry);
119 static void gtk_move_end_of_line (GtkEntry *entry);
120 static void gtk_delete_forward_character (GtkEntry *entry);
121 static void gtk_delete_backward_character (GtkEntry *entry);
122 static void gtk_delete_forward_word (GtkEntry *entry);
123 static void gtk_delete_backward_word (GtkEntry *entry);
124 static void gtk_delete_line (GtkEntry *entry);
125 static void gtk_delete_to_line_end (GtkEntry *entry);
126 static void gtk_select_word (GtkEntry *entry,
127 guint32 time);
128 static void gtk_select_line (GtkEntry *entry,
129 guint32 time);
130
131
132 static void gtk_entry_set_selection (GtkEditable *editable,
133 gint start,
134 gint end);
135
136 static gint gtk_entry_find_position (GtkEntry *entry,
137 gint position);
138 static void gtk_entry_set_position_from_editable (GtkEditable *editable,
139 gint position);
140
141 static GtkWidgetClass *parent_class = NULL;
142 static GdkAtom ctext_atom = GDK_NONE;
143
144
145 static const GtkTextFunction control_keys[26] =
146 {
147 (GtkTextFunction)gtk_move_beginning_of_line, /* a */
148 (GtkTextFunction)gtk_move_backward_character, /* b */
149 (GtkTextFunction)gtk_editable_copy_clipboard, /* c */
150 (GtkTextFunction)gtk_delete_forward_character, /* d */
151 (GtkTextFunction)gtk_move_end_of_line, /* e */
152 (GtkTextFunction)gtk_move_forward_character, /* f */
153 NULL, /* g */
154 (GtkTextFunction)gtk_delete_backward_character, /* h */
155 NULL, /* i */
156 NULL, /* j */
157 (GtkTextFunction)gtk_delete_to_line_end, /* k */
158 NULL, /* l */
159 NULL, /* m */
160 NULL, /* n */
161 NULL, /* o */
162 NULL, /* p */
163 NULL, /* q */
164 NULL, /* r */
165 NULL, /* s */
166 NULL, /* t */
167 (GtkTextFunction)gtk_delete_line, /* u */
168 (GtkTextFunction)gtk_editable_paste_clipboard, /* v */
169 (GtkTextFunction)gtk_delete_backward_word, /* w */
170 (GtkTextFunction)gtk_editable_cut_clipboard, /* x */
171 NULL, /* y */
172 NULL, /* z */
173 };
174
175 static const GtkTextFunction alt_keys[26] =
176 {
177 NULL, /* a */
178 (GtkTextFunction)gtk_move_backward_word, /* b */
179 NULL, /* c */
180 (GtkTextFunction)gtk_delete_forward_word, /* d */
181 NULL, /* e */
182 (GtkTextFunction)gtk_move_forward_word, /* f */
183 NULL, /* g */
184 NULL, /* h */
185 NULL, /* i */
186 NULL, /* j */
187 NULL, /* k */
188 NULL, /* l */
189 NULL, /* m */
190 NULL, /* n */
191 NULL, /* o */
192 NULL, /* p */
193 NULL, /* q */
194 NULL, /* r */
195 NULL, /* s */
196 NULL, /* t */
197 NULL, /* u */
198 NULL, /* v */
199 NULL, /* w */
200 NULL, /* x */
201 NULL, /* y */
202 NULL, /* z */
203 };
204
205
206
207 GtkType
208 gtk_item_entry_get_type (void)
209 {
210 static GtkType entry_type = 0;
211
212 if (!entry_type)
213 {
214 static const GtkTypeInfo entry_info =
215 {
216 "GtkItemEntry",
217 sizeof (GtkItemEntry),
218 sizeof (GtkItemEntryClass),
219 (GtkClassInitFunc) gtk_entry_class_init,
220 (GtkObjectInitFunc) gtk_entry_init,
221 /* reserved_1 */ NULL,
222 /* reserved_2 */ NULL,
223 (GtkClassInitFunc) NULL,
224 };
225
226 entry_type = gtk_type_unique (GTK_TYPE_ENTRY, &entry_info);
227 }
228
229 return entry_type;
230 }
231
232 static void
233 gtk_entry_class_init (GtkItemEntryClass *klass)
234 {
235 GtkObjectClass *object_class;
236 GtkWidgetClass *widget_class;
237 GtkEditableClass *editable_class;
238
239 object_class = (GtkObjectClass*) klass;
240 widget_class = (GtkWidgetClass*) klass;
241 editable_class = (GtkEditableClass*) klass;
242 parent_class = gtk_type_class (GTK_TYPE_ENTRY);
243
244 widget_class->realize = gtk_entry_realize;
245 widget_class->unrealize = gtk_entry_unrealize;
246 widget_class->draw_focus = gtk_entry_draw_focus;
247 widget_class->size_allocate = gtk_entry_size_allocate;
248 widget_class->size_request = gtk_entry_size_request;
249 widget_class->draw = gtk_entry_draw;
250 widget_class->expose_event = gtk_entry_expose;
251 widget_class->button_press_event = gtk_entry_button_press;
252 widget_class->button_release_event = gtk_entry_button_release;
253 widget_class->motion_notify_event = gtk_entry_motion_notify;
254 widget_class->key_press_event = gtk_entry_key_press;
255
256 editable_class->insert_text = gtk_entry_insert_text;
257 editable_class->delete_text = gtk_entry_delete_text;
258 editable_class->changed = (void (*)(GtkEditable *)) entry_adjust_scroll;
259
260 editable_class->move_cursor = gtk_entry_move_cursor;
261 editable_class->move_word = gtk_entry_move_word;
262 editable_class->move_to_column = gtk_entry_move_to_column;
263
264 editable_class->kill_char = gtk_entry_kill_char;
265 editable_class->kill_word = gtk_entry_kill_word;
266 editable_class->kill_line = gtk_entry_kill_line;
267
268 editable_class->update_text = gtk_entry_update_text;
269 editable_class->get_chars = gtk_entry_get_chars;
270 editable_class->set_selection = gtk_entry_set_selection;
271 editable_class->set_position = gtk_entry_set_position_from_editable;
272
273 }
274
275
276 static void
277 gtk_entry_init (GtkItemEntry *entry)
278 {
279 }
280
281 GtkWidget*
282 gtk_item_entry_new ()
283 {
284 GtkWidget *item_entry;
285
286 item_entry = GTK_WIDGET (gtk_type_new (gtk_item_entry_get_type ()));
287
288 return item_entry;
289 }
290
291 GtkWidget*
292 gtk_item_entry_new_with_max_length (guint16 max)
293 {
294 GtkItemEntry *item_entry;
295 item_entry = gtk_type_new (gtk_item_entry_get_type ());
296
297 gtk_item_entry_construct_with_max_length(item_entry, max);
298
299 return GTK_WIDGET (item_entry);
300 }
301
302 void
303 gtk_item_entry_construct_with_max_length (GtkItemEntry *item_entry, guint16 max)
304 {
305 GTK_ENTRY (item_entry)->text_max_length = max;
306 }
307
308
309 void
310 gtk_item_entry_set_text (GtkItemEntry *item_entry,
311 const gchar *text,
312 GtkJustification justification )
313 {
314 gint tmp_pos;
315
316 GtkEditable *editable;
317 GtkEntry *entry;
318
319 g_return_if_fail (item_entry != NULL);
320 g_return_if_fail (GTK_IS_ITEM_ENTRY (item_entry));
321 g_return_if_fail (text != NULL);
322
323 editable = GTK_EDITABLE (item_entry);
324 entry = GTK_ENTRY(item_entry);
325
326 item_entry->justification = justification;
327
328 gtk_entry_delete_text (GTK_EDITABLE(entry), 0, entry->text_length);
329
330 tmp_pos = 0;
331 gtk_editable_insert_text (editable, text, strlen (text), &tmp_pos);
332 editable->current_pos = tmp_pos;
333
334 editable->selection_start_pos = 0;
335 editable->selection_end_pos = 0;
336
337 if (GTK_WIDGET_DRAWABLE (entry))
338 gtk_entry_draw_text (entry);
339 }
340
341 static void
342 gtk_entry_set_position_from_editable (GtkEditable *editable,
343 gint position)
344 {
345 GtkEntry *entry;
346
347 g_return_if_fail (editable != NULL);
348 g_return_if_fail (GTK_IS_EDITABLE (editable));
349
350 entry = GTK_ENTRY(editable);
351
352 if ((position == -1) || (position > entry->text_length))
353 GTK_EDITABLE(entry)->current_pos = entry->text_length;
354 else
355 GTK_EDITABLE(entry)->current_pos = position;
356 entry_adjust_scroll (entry);
357 }
358
359 void
360 gtk_item_entry_set_justification (GtkItemEntry *item_entry, GtkJustification justification)
361 {
362 g_return_if_fail (item_entry != NULL);
363 g_return_if_fail (GTK_IS_ITEM_ENTRY (item_entry));
364
365 item_entry->justification = justification;
366 entry_adjust_scroll (GTK_ENTRY(item_entry));
367 gtk_widget_draw(GTK_WIDGET(item_entry), NULL);
368 }
369
370
371 static void
372 gtk_entry_realize (GtkWidget *widget)
373 {
374 GtkItemEntry *item_entry;
375
376 g_return_if_fail (widget != NULL);
377 g_return_if_fail (GTK_IS_ITEM_ENTRY (widget));
378
379 if (GTK_WIDGET_CLASS (parent_class)->realize)
380 (* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
381
382 item_entry = GTK_ITEM_ENTRY (widget);
383
384 item_entry->fg_gc = gdk_gc_new (widget->window);
385 item_entry->bg_gc = gdk_gc_new (widget->window);
386
387 gdk_gc_set_foreground (item_entry->fg_gc, &widget->style->white);
388 gdk_gc_set_foreground (item_entry->bg_gc, &widget->style->black);
389 }
390
391 static void
392 gtk_entry_unrealize (GtkWidget *widget)
393 {
394 GtkItemEntry *item_entry;
395
396 g_return_if_fail (widget != NULL);
397 g_return_if_fail (GTK_IS_ITEM_ENTRY (widget));
398
399 item_entry = GTK_ITEM_ENTRY (widget);
400
401 gdk_gc_destroy (item_entry->fg_gc);
402 gdk_gc_destroy (item_entry->bg_gc);
403
404 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
405 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
406 }
407
408 static void
409 gtk_entry_draw_focus (GtkWidget *widget)
410 {
411 g_return_if_fail (widget != NULL);
412 g_return_if_fail (GTK_IS_ITEM_ENTRY (widget));
413
414 if (GTK_WIDGET_DRAWABLE (widget))
415 {
416 gtk_entry_draw_cursor (GTK_ENTRY (widget));
417 }
418 }
419
420
421 static void
422 gtk_entry_size_allocate (GtkWidget *widget,
423 GtkAllocation *allocation)
424 {
425 GtkEntry *entry;
426 GtkItemEntry *ientry;
427 GtkEditable *editable;
428 gint width = 0, nwidth = 0, height = 0, nheight = 0;
429
430
431 g_return_if_fail (widget != NULL);
432 g_return_if_fail (GTK_IS_ITEM_ENTRY (widget));
433 g_return_if_fail (allocation != NULL);
434
435 entry = GTK_ENTRY (widget);
436 ientry = GTK_ITEM_ENTRY (widget);
437 editable = GTK_EDITABLE (widget);
438
439 if(ientry->text_max_size > 0)
440 allocation->width = MIN(ientry->text_max_size, allocation->width);
441
442 widget->allocation = *allocation;
443
444 if (GTK_WIDGET_REALIZED (widget))
445 {
446 gdk_window_get_size (entry->text_area, &width, &height);
447 gdk_window_move_resize (widget->window,
448 allocation->x + INNER_BORDER,
449 allocation->y + INNER_BORDER,
450 allocation->width - 2 * INNER_BORDER,
451 allocation->height - 2 * INNER_BORDER);
452 gdk_window_move_resize (entry->text_area,
453 0,
454 0,
455 allocation->width - 2 * INNER_BORDER,
456 allocation->height - 2 * INNER_BORDER);
457
458
459 gdk_window_get_size (entry->text_area, &nwidth, &nheight);
460 if(nwidth != width || nheight != height){
461 entry->scroll_offset = 0;
462 entry_adjust_scroll (entry);
463 }
464
465 #ifdef USE_XIM
466 if (editable->ic &&
467 (gdk_ic_get_style (editable->ic) & GDK_IM_PREEDIT_POSITION))
468 {
469 editable->ic_attr->preedit_area.width = nwidth;
470 editable->ic_attr->preedit_area.height = nheight;
471 gdk_ic_set_attr (editable->ic, editable->ic_attr,
472 GDK_IC_PREEDIT_AREA);
473 }
474 #endif
475
476 }
477
478 }
479
480 static void
481 gtk_entry_size_request (GtkWidget *widget,
482 GtkRequisition *requisition)
483 {
484 GtkItemEntry *entry;
485
486 g_return_if_fail (widget != NULL);
487 g_return_if_fail (GTK_IS_ITEM_ENTRY (widget));
488 g_return_if_fail (requisition != NULL);
489
490 requisition->width = MIN_ENTRY_WIDTH + (widget->style->klass->xthickness + INNER_BORDER) * 2;
491 requisition->height = (widget->style->font->ascent +
492 widget->style->font->descent +
493 (widget->style->klass->ythickness + INNER_BORDER) * 2);
494
495 entry = GTK_ITEM_ENTRY(widget);
496
497 if(entry->text_max_size > 0 &&
498 requisition->width > entry->text_max_size)
499 requisition->width = entry->text_max_size;
500 }
501
502 static void
503 gtk_entry_draw (GtkWidget *widget,
504 GdkRectangle *area)
505 {
506 g_return_if_fail (widget != NULL);
507 g_return_if_fail (GTK_IS_ENTRY (widget));
508 g_return_if_fail (area != NULL);
509
510 if (GTK_WIDGET_DRAWABLE (widget))
511 {
512 gtk_widget_draw_focus (widget);
513 gtk_entry_draw_text (GTK_ENTRY (widget));
514 }
515 }
516
517 static gint
518 gtk_entry_expose (GtkWidget *widget,
519 GdkEventExpose *event)
520 {
521 GtkEntry *entry;
522
523 g_return_val_if_fail (widget != NULL, FALSE);
524 g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE);
525 g_return_val_if_fail (event != NULL, FALSE);
526
527 entry = GTK_ENTRY (widget);
528
529 if (widget->window == event->window)
530 gtk_widget_draw_focus (widget);
531 else if (entry->text_area == event->window)
532 gtk_entry_draw_text (GTK_ENTRY (widget));
533
534 return FALSE;
535 }
536
537 static gint
538 gtk_entry_button_press (GtkWidget *widget,
539 GdkEventButton *event)
540 {
541 GtkEntry *entry;
542 GtkEditable *editable;
543 GdkModifierType mods;
544 gint tmp_pos;
545
546 g_return_val_if_fail (widget != NULL, FALSE);
547 g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE);
548 g_return_val_if_fail (event != NULL, FALSE);
549
550 if (ctext_atom == GDK_NONE)
551 ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE);
552
553 entry = GTK_ENTRY (widget);
554 editable = GTK_EDITABLE (widget);
555
556 if (entry->button && (event->button != entry->button))
557 return FALSE;
558
559 gdk_window_get_pointer(widget->window, NULL, NULL, &mods);
560 if (mods & GDK_BUTTON3_MASK)
561 return FALSE;
562
563 entry->button = event->button;
564
565 if (!GTK_WIDGET_HAS_FOCUS (widget))
566 gtk_widget_grab_focus (widget);
567
568 if (event->button == 1)
569 {
570 switch (event->type)
571 {
572 case GDK_BUTTON_PRESS:
573 gtk_grab_add (widget);
574
575 tmp_pos = gtk_entry_position (entry, event->x + entry->scroll_offset);
576 /* Set it now, so we display things right. We'll unset it
577 * later if things don't work out */
578 editable->has_selection = TRUE;
579 gtk_entry_set_selection (editable, tmp_pos, tmp_pos);
580 editable->current_pos = editable->selection_start_pos;
581 break;
582
583 case GDK_2BUTTON_PRESS:
584 gtk_select_word (entry, event->time);
585 break;
586
587 case GDK_3BUTTON_PRESS:
588 gtk_select_line (entry, event->time);
589 break;
590
591 default:
592 break;
593 }
594 }
595 else if (event->type == GDK_BUTTON_PRESS)
596 {
597 if ((event->button == 2) && editable->editable)
598 {
599 if (editable->selection_start_pos == editable->selection_end_pos ||
600 editable->has_selection)
601 editable->current_pos = gtk_entry_position (entry, event->x + entry->scroll_offset);
602 gtk_selection_convert (widget, GDK_SELECTION_PRIMARY,
603 ctext_atom, event->time);
604 }
605 else
606 {
607 gtk_grab_add (widget);
608
609 tmp_pos = gtk_entry_position (entry, event->x + entry->scroll_offset);
610 gtk_entry_set_selection (editable, tmp_pos, tmp_pos);
611 editable->has_selection = FALSE;
612 editable->current_pos = editable->selection_start_pos;
613
614 if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
615 gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, event->time);
616 }
617 }
618
619 return FALSE;
620 }
621
622 static gint
623 gtk_entry_button_release (GtkWidget *widget,
624 GdkEventButton *event)
625 {
626 GtkEntry *entry;
627 GtkEditable *editable;
628
629 g_return_val_if_fail (widget != NULL, FALSE);
630 g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE);
631 g_return_val_if_fail (event != NULL, FALSE);
632
633 entry = GTK_ENTRY (widget);
634 editable = GTK_EDITABLE (widget);
635
636 if (entry->button != event->button)
637 return FALSE;
638
639 entry->button = 0;
640
641 if (event->button == 1)
642 {
643 gtk_grab_remove (widget);
644
645 editable->has_selection = FALSE;
646 if (editable->selection_start_pos != editable->selection_end_pos)
647 {
648 if (gtk_selection_owner_set (widget,
649 GDK_SELECTION_PRIMARY,
650 event->time))
651 editable->has_selection = TRUE;
652 else
653 gtk_entry_queue_draw (entry);
654 }
655 else
656 {
657 if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
658 gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, event->time);
659 }
660 }
661 else if (event->button == 3)
662 {
663 gtk_grab_remove (widget);
664 }
665
666 return FALSE;
667 }
668
669 static gint
670 gtk_entry_motion_notify (GtkWidget *widget,
671 GdkEventMotion *event)
672 {
673 GtkEntry *entry;
674 gint x;
675
676 g_return_val_if_fail (widget != NULL, FALSE);
677 g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE);
678 g_return_val_if_fail (event != NULL, FALSE);
679
680 entry = GTK_ENTRY (widget);
681
682 if (entry->button == 0)
683 return FALSE;
684
685 x = event->x;
686 if (event->is_hint || (entry->text_area != event->window))
687 gdk_window_get_pointer (entry->text_area, &x, NULL, NULL);
688
689 GTK_EDITABLE(entry)->selection_end_pos = gtk_entry_position (entry, x + entry->scroll_offset);
690 GTK_EDITABLE(entry)->current_pos = GTK_EDITABLE(entry)->selection_end_pos;
691 entry_adjust_scroll (entry);
692 gtk_entry_queue_draw (entry);
693
694 return FALSE;
695 }
696
697 static gint
698 gtk_entry_key_press (GtkWidget *widget,
699 GdkEventKey *event)
700 {
701 GtkEntry *entry;
702 GtkEditable *editable;
703
704 gint return_val;
705 gint key;
706 guint initial_pos;
707 gint extend_selection;
708 gint extend_start;
709
710 g_return_val_if_fail (widget != NULL, FALSE);
711 g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE);
712 g_return_val_if_fail (event != NULL, FALSE);
713
714 entry = GTK_ENTRY (widget);
715 editable = GTK_EDITABLE (widget);
716 return_val = FALSE;
717
718 if(!GTK_WIDGET_HAS_FOCUS(widget)) return FALSE;
719
720 if(editable->editable == FALSE)
721 switch(event->keyval){
722 case GDK_Left: case GDK_Right: case GDK_Up: case GDK_Down:
723 case GDK_Tab: case GDK_Return:
724 break;
725 default:
726 return TRUE;
727 }
728
729 initial_pos = editable->current_pos;
730
731 extend_selection = event->state & GDK_SHIFT_MASK;
732 extend_start = FALSE;
733
734 if (extend_selection)
735 {
736 if (editable->selection_start_pos == editable->selection_end_pos)
737 {
738 editable->selection_start_pos = editable->current_pos;
739 editable->selection_end_pos = editable->current_pos;
740 }
741
742 extend_start = (editable->current_pos == editable->selection_start_pos);
743 }
744
745 switch (event->keyval)
746 {
747 case GDK_BackSpace:
748 return_val = TRUE;
749 if (event->state & GDK_CONTROL_MASK)
750 gtk_delete_backward_word (entry);
751 else
752 gtk_delete_backward_character (entry);
753 break;
754 case GDK_Clear:
755 return_val = TRUE;
756 gtk_delete_line (entry);
757 break;
758 case GDK_Insert:
759 return_val = TRUE;
760 if (event->state & GDK_SHIFT_MASK)
761 {
762 extend_selection = FALSE;
763 gtk_editable_paste_clipboard (editable);
764 }
765 else if (event->state & GDK_CONTROL_MASK)
766 {
767 gtk_editable_copy_clipboard (editable);
768 }
769 else
770 {
771 /* gtk_toggle_insert(entry) -- IMPLEMENT */
772 }
773 break;
774 case GDK_Delete:
775 return_val = TRUE;
776 if (event->state & GDK_CONTROL_MASK)
777 gtk_delete_forward_word (entry);
778 else if (event->state & GDK_SHIFT_MASK)
779 {
780 extend_selection = FALSE;
781 gtk_editable_cut_clipboard (editable);
782 }
783 else
784 gtk_delete_forward_character (entry);
785 break;
786 case GDK_Home:
787 return_val = TRUE;
788 gtk_move_beginning_of_line (entry);
789 break;
790 case GDK_End:
791 return_val = TRUE;
792 gtk_move_end_of_line (entry);
793 break;
794 case GDK_Left:
795 return_val = TRUE;
796 if (event->state & GDK_CONTROL_MASK)
797 gtk_move_backward_word (entry);
798 else
799 gtk_move_backward_character (entry);
800 break;
801 case GDK_Right:
802 return_val = TRUE;
803 if (event->state & GDK_CONTROL_MASK)
804 gtk_move_forward_word (entry);
805 else
806 gtk_move_forward_character (entry);
807 break;
808 case GDK_Shift_L:
809 case GDK_Shift_R:
810 case GDK_Tab:
811 case GDK_Escape:
812 case GDK_Up:
813 case GDK_Down:
814 case GDK_Return:
815 return_val = TRUE;
816 gtk_signal_emit_by_name (GTK_OBJECT (entry), "activate");
817 break;
818 default:
819 if ((event->keyval >= 0x20) && (event->keyval <= 0xFF))
820 {
821 key = event->keyval;
822
823 if (event->state & GDK_CONTROL_MASK)
824 {
825 if ((key >= 'A') && (key <= 'Z'))
826 key -= 'A' - 'a';
827
828 if ((key >= 'a') && (key <= 'z') && control_keys[key - 'a'])
829 {
830 (* control_keys[key - 'a']) (editable, event->time);
831 return_val = TRUE;
832 }
833 break;
834 }
835 else if (event->state & GDK_MOD1_MASK)
836 {
837 if ((key >= 'A') && (key <= 'Z'))
838 key -= 'A' - 'a';
839
840 if ((key >= 'a') && (key <= 'z') && alt_keys[key - 'a'])
841 {
842 (* alt_keys[key - 'a']) (editable, event->time);
843 return_val = TRUE;
844 }
845 break;
846 }
847 }
848 if (event->length > 0)
849 {
850 gint tmp_pos;
851
852 extend_selection = FALSE;
853 gtk_editable_delete_selection (editable);
854
855 tmp_pos = editable->current_pos;
856 gtk_editable_insert_text (editable, event->string, event->length, &tmp_pos);
857 editable->current_pos = tmp_pos;
858
859 return_val = TRUE;
860 }
861 break;
862 }
863
864 /* since we emit signals from within the above code,
865 * the widget might already be destroyed or at least
866 * unrealized.
867 */
868 if (GTK_WIDGET_REALIZED (editable) &&
869 return_val && (editable->current_pos != initial_pos))
870 {
871 if (extend_selection)
872 {
873 if (editable->current_pos < editable->selection_start_pos)
874 editable->selection_start_pos = editable->current_pos;
875 else if (editable->current_pos > editable->selection_end_pos)
876 editable->selection_end_pos = editable->current_pos;
877 else
878 {
879 if (extend_start)
880 editable->selection_start_pos = editable->current_pos;
881 else
882 editable->selection_end_pos = editable->current_pos;
883 }
884 }
885 else
886 {
887 editable->selection_start_pos = 0;
888 editable->selection_end_pos = 0;
889 }
890
891 gtk_editable_claim_selection (editable,
892 editable->selection_start_pos != editable->selection_end_pos,
893 event->time);
894
895 entry_adjust_scroll (entry);
896 gtk_entry_queue_draw (entry);
897 }
898
899 return return_val;
900 }
901
902
903 static void
904 gtk_entry_make_backing_pixmap (GtkEntry *entry, gint width, gint height)
905 {
906 gint pixmap_width, pixmap_height;
907
908 if (!entry->backing_pixmap)
909 {
910 /* allocate */
911 entry->backing_pixmap = gdk_pixmap_new (entry->text_area,
912 width, height,
913 -1);
914 }
915 else
916 {
917 /* reallocate if sizes don't match */
918 gdk_window_get_size (entry->backing_pixmap,
919 &pixmap_width, &pixmap_height);
920 if ((pixmap_width != width) || (pixmap_height != height))
921 {
922 gdk_pixmap_unref (entry->backing_pixmap);
923 entry->backing_pixmap = gdk_pixmap_new (entry->text_area,
924 width, height,
925 -1);
926 }
927 }
928 }
929
930 static void
931 gtk_entry_draw_text (GtkEntry *entry)
932 {
933 GtkWidget *widget;
934 GtkItemEntry *item_entry;
935 GtkEditable *editable;
936 GtkStateType selected_state;
937 gint start_pos;
938 gint end_pos;
939 gint start_xoffset;
940 gint selection_start_pos;
941 gint selection_end_pos;
942 gint selection_start_xoffset;
943 gint selection_end_xoffset;
944 gint width, height;
945 gint y;
946 GdkDrawable *drawable;
947 gint use_backing_pixmap;
948 GdkWChar *stars;
949 GdkWChar *toprint;
950
951 g_return_if_fail (entry != NULL);
952 g_return_if_fail (GTK_IS_ENTRY (entry));
953 g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
954
955 item_entry = GTK_ITEM_ENTRY (entry);
956
957 if (entry->timer)
958 {
959 gtk_timeout_remove (entry->timer);
960 entry->timer = 0;
961 }
962
963 if (GTK_WIDGET_DRAWABLE (entry))
964 {
965 widget = GTK_WIDGET (entry);
966 editable = GTK_EDITABLE (entry);
967
968 gdk_window_get_size (entry->text_area, &width, &height);
969
970 if (!entry->text)
971 {
972 gdk_draw_rectangle (entry->text_area,
973 item_entry->bg_gc,
974 TRUE,
975 0, 0,
976 width,
977 height);
978
979 if (editable->editable)
980 gtk_entry_draw_cursor (entry);
981 return;
982 }
983
984
985 /*
986 If the widget has focus, draw on a backing pixmap to avoid flickering
987 and copy it to the text_area.
988 Otherwise draw to text_area directly for better speed.
989 */
990 use_backing_pixmap = GTK_WIDGET_HAS_FOCUS (widget) && (entry->text != NULL);
991
992 if (use_backing_pixmap)
993 {
994 gtk_entry_make_backing_pixmap (entry, width, height);
995 drawable = entry->backing_pixmap;
996 gdk_draw_rectangle (drawable,
997 item_entry->bg_gc,
998 TRUE,
999 0, 0,
1000 width,
1001 height);
1002 }
1003 else
1004 {
1005 drawable = entry->text_area;
1006 gdk_draw_rectangle (entry->text_area,
1007 item_entry->bg_gc,
1008 TRUE,
1009 0, 0,
1010 width,
1011 height);
1012
1013 }
1014
1015
1016 /* CENTER */
1017 /* y = height;
1018 y = (height - (widget->style->font->ascent + widget->style->font->descent)) / 2;
1019 y += widget->style->font->ascent;
1020 */
1021 /* BOTTOM */
1022 y = height;
1023 y = (y - widget->style->font->ascent - widget->style->font->descent);
1024 y += widget->style->font->ascent;
1025
1026 start_pos = gtk_entry_find_position (entry, entry->scroll_offset);
1027 start_xoffset = entry->char_offset[start_pos] - entry->scroll_offset;
1028
1029 end_pos = gtk_entry_find_position (entry, entry->scroll_offset + width);
1030 if (end_pos < entry->text_length)
1031 end_pos += 1;
1032
1033 selected_state = GTK_STATE_SELECTED;
1034 if (!editable->has_selection)
1035 selected_state = GTK_STATE_ACTIVE;
1036
1037 selection_start_pos = MIN (editable->selection_start_pos, editable->selection_end_pos);
1038 selection_end_pos = MAX (editable->selection_start_pos, editable->selection_end_pos);
1039
1040 selection_start_pos = CLAMP (selection_start_pos, start_pos, end_pos);
1041 selection_end_pos = CLAMP (selection_end_pos, start_pos, end_pos);
1042
1043 selection_start_xoffset =
1044 entry->char_offset[selection_start_pos] - entry->scroll_offset;
1045 selection_end_xoffset =
1046 entry->char_offset[selection_end_pos] -entry->scroll_offset;
1047
1048 /* if entry->visible, print a bunch of stars. If not, print the standard text. */
1049 if (entry->visible)
1050 {
1051 toprint = entry->text + start_pos;
1052 }
1053 else
1054 {
1055 gint i;
1056
1057 stars = g_new (GdkWChar, end_pos - start_pos);
1058 for (i = 0; i < end_pos - start_pos; i++)
1059 stars[i] = '*';
1060 toprint = stars;
1061 }
1062
1063 if (selection_start_pos > start_pos)
1064 gdk_draw_text_wc (drawable, widget->style->font,
1065 item_entry->fg_gc,
1066 start_xoffset, y,
1067 toprint,
1068 selection_start_pos - start_pos);
1069
1070 if ((selection_end_pos >= start_pos) &&
1071 (selection_start_pos < end_pos) &&
1072 (selection_start_pos != selection_end_pos))
1073 {
1074 gint yoffset =
1075 (height -
1076 (widget->style->font->ascent + widget->style->font->descent));
1077 gtk_paint_flat_box (widget->style, drawable,
1078 selected_state, GTK_SHADOW_NONE,
1079 NULL, widget, "text",
1080 selection_start_xoffset,
1081 yoffset,
1082 selection_end_xoffset - selection_start_xoffset,
1083 widget->style->font->ascent + widget->style->font->descent);
1084 gdk_draw_text_wc (drawable, widget->style->font,
1085 widget->style->fg_gc[selected_state],
1086 selection_start_xoffset, y,
1087 toprint + selection_start_pos - start_pos,
1088 selection_end_pos - selection_start_pos);
1089 }
1090
1091 if (selection_end_pos < end_pos)
1092 gdk_draw_text_wc (drawable, widget->style->font,
1093 item_entry->fg_gc,
1094 selection_end_xoffset, y,
1095 toprint + selection_end_pos - start_pos,
1096 end_pos - selection_end_pos);
1097 /* free the space allocated for the stars if it's neccessary. */
1098 if (!entry->visible)
1099 g_free (toprint);
1100
1101 if (editable->editable)
1102 gtk_entry_draw_cursor_on_drawable (entry, drawable);
1103
1104 if (use_backing_pixmap)
1105 gdk_draw_pixmap(entry->text_area,
1106 item_entry->fg_gc,
1107 entry->backing_pixmap,
1108 0, 0, 0, 0, width, height);
1109 }
1110
1111
1112 }
1113
1114 static void
1115 gtk_entry_draw_cursor (GtkEntry *entry)
1116 {
1117 g_return_if_fail (entry != NULL);
1118 g_return_if_fail (GTK_IS_ENTRY (entry));
1119
1120 gtk_entry_draw_cursor_on_drawable (entry, entry->text_area);
1121 }
1122
1123 static void
1124 gtk_entry_draw_cursor_on_drawable (GtkEntry *entry, GdkDrawable *drawable)
1125 {
1126 GtkWidget *widget;
1127 GtkEditable *editable;
1128 gint xoffset;
1129 gint text_area_height;
1130
1131 g_return_if_fail (entry != NULL);
1132 g_return_if_fail (GTK_IS_ENTRY (entry));
1133 g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
1134
1135 if (GTK_WIDGET_DRAWABLE (entry))
1136 {
1137 widget = GTK_WIDGET (entry);
1138 editable = GTK_EDITABLE (entry);
1139
1140 xoffset = entry->char_offset[editable->current_pos];
1141 xoffset -= entry->scroll_offset;
1142
1143 gdk_window_get_size (entry->text_area, NULL, &text_area_height);
1144
1145 if (GTK_WIDGET_HAS_FOCUS (widget) &&
1146 (editable->selection_start_pos == editable->selection_end_pos))
1147 {
1148 gint yoffset =
1149 (text_area_height -
1150 (widget->style->font->ascent + widget->style->font->descent));
1151
1152 gdk_draw_line (drawable, widget->style->fg_gc[GTK_STATE_NORMAL],
1153 xoffset, yoffset,
1154 xoffset, text_area_height);
1155 }
1156 else
1157 {
1158 gint yoffset =
1159 (text_area_height -
1160 (widget->style->font->ascent + widget->style->font->descent));
1161
1162 gtk_paint_flat_box (widget->style, drawable,
1163 GTK_WIDGET_STATE(widget), GTK_SHADOW_NONE,
1164 NULL, widget, "entry_bg",
1165 xoffset, yoffset,
1166 1, text_area_height);
1167 /* Draw the character under the cursor again */
1168 /*
1169 gdk_draw_text_wc (drawable, widget->style->font,
1170 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
1171 xoffset, yoffset,
1172 entry->text + editable->current_pos, 1);
1173 */
1174 }
1175
1176
1177 #ifdef USE_XIM
1178 if (GTK_WIDGET_HAS_FOCUS(widget) && gdk_im_ready() && editable->ic &&
1179 (gdk_ic_get_style (editable->ic) & GDK_IM_PREEDIT_POSITION))
1180 {
1181 editable->ic_attr->spot_location.x = xoffset;
1182 editable->ic_attr->spot_location.y =
1183 (text_area_height + (widget->style->font->ascent
1184 - widget->style->font->descent) + 1) / 2;
1185
1186 gdk_ic_set_attr (editable->ic,
1187 editable->ic_attr, GDK_IC_SPOT_LOCATION);
1188 }
1189 #endif
1190 }
1191 }
1192
1193 static void
1194 gtk_entry_queue_draw (GtkEntry *entry)
1195 {
1196 g_return_if_fail (entry != NULL);
1197 g_return_if_fail (GTK_IS_ENTRY (entry));
1198 g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
1199
1200 if (!entry->timer)
1201 entry->timer = gtk_timeout_add (DRAW_TIMEOUT, gtk_entry_timer, (gpointer) entry);
1202 }
1203
1204 static gint
1205 gtk_entry_timer (gpointer data)
1206 {
1207 GtkEntry *entry;
1208
1209 GDK_THREADS_ENTER ();
1210
1211 entry = GTK_ENTRY (data);
1212 entry->timer = 0;
1213 gtk_entry_draw_text (entry);
1214
1215 GDK_THREADS_LEAVE ();
1216
1217 return FALSE;
1218 }
1219
1220 static gint
1221 gtk_entry_find_position (GtkEntry *entry,
1222 gint x)
1223 {
1224 gint start = 0;
1225 gint end = entry->text_length;
1226 gint half;
1227
1228 if (x <= 0)
1229 return 0;
1230 if (x >= entry->char_offset[end])
1231 return end;
1232
1233 /* invariant - char_offset[start] <= x < char_offset[end] */
1234
1235 while (start != end)
1236 {
1237 half = (start+end)/2;
1238 if (half == start)
1239 return half;
1240 else if (entry->char_offset[half] <= x)
1241 start = half;
1242 else
1243 end = half;
1244 }
1245
1246 return start;
1247 }
1248
1249 static gint
1250 gtk_entry_position (GtkEntry *entry,
1251 gint x)
1252 {
1253 return gtk_entry_find_position(entry, x);
1254 }
1255
1256
1257 static void
1258 entry_adjust_scroll (GtkEntry *entry)
1259 {
1260 GtkItemEntry *item_entry;
1261 gint xoffset;
1262 gint text_area_width, text_area_height;
1263 gint char_width, text_width;
1264
1265 g_return_if_fail (entry != NULL);
1266 g_return_if_fail (GTK_IS_ENTRY (entry));
1267 g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
1268
1269 item_entry = GTK_ITEM_ENTRY (entry);
1270
1271 if (!entry->text_area)
1272 return;
1273
1274 gdk_window_get_size (entry->text_area, &text_area_width, &text_area_height);
1275
1276 char_width = gdk_char_width (GTK_WIDGET(item_entry)->style->font,(gchar)'X');
1277
1278 entry->scroll_offset = 0 ;
1279
1280 switch(item_entry->justification){
1281
1282 case GTK_JUSTIFY_FILL:
1283 case GTK_JUSTIFY_LEFT:
1284
1285 /* LEFT JUSTIFICATION */
1286
1287 if (GTK_EDITABLE(entry)->current_pos > 0)
1288 xoffset = gdk_text_width (GTK_WIDGET (entry)->style->font, gtk_entry_get_text(entry), GTK_EDITABLE(entry)->current_pos);
1289 else
1290 xoffset = 0;
1291
1292 xoffset -= entry->scroll_offset;
1293 if (xoffset < 0)
1294 entry->scroll_offset += xoffset;
1295 else if (xoffset > text_area_width){
1296 if(item_entry->text_max_size != 0 &&
1297 text_area_width + char_width <= item_entry->text_max_size){
1298
1299 text_width = gdk_text_width (GTK_WIDGET (item_entry)->style->font,
1300 gtk_entry_get_text(entry), strlen(gtk_entry_get_text(entry)));
1301 GTK_WIDGET(item_entry)->allocation.width = text_width +
1302 2 * INNER_BORDER + 1;
1303 gtk_entry_size_allocate(GTK_WIDGET(item_entry),
1304 (GtkAllocation *)(&GTK_WIDGET(item_entry)->allocation));
1305 gtk_widget_queue_draw(GTK_WIDGET(item_entry));
1306 }else{
1307 entry->scroll_offset += (xoffset - text_area_width) + 1;
1308 }
1309 }
1310
1311 break;
1312
1313 case GTK_JUSTIFY_RIGHT:
1314
1315 /* RIGHT JUSTIFICATION FOR NUMBERS */
1316 if(entry->text){
1317
1318 text_width = gdk_text_width (GTK_WIDGET (item_entry)->style->font, gtk_entry_get_text(entry), strlen(gtk_entry_get_text(entry)));
1319
1320 entry->scroll_offset= -(text_area_width - text_width) + 1;
1321 if(entry->scroll_offset > 0){
1322 if(item_entry->text_max_size != 0 &&
1323 text_area_width + char_width <= item_entry->text_max_size){
1324 GTK_WIDGET(item_entry)->allocation.x =
1325 GTK_WIDGET(item_entry)->allocation.x+
1326 GTK_WIDGET(item_entry)->allocation.width-
1327 (text_area_width+char_width);
1328 GTK_WIDGET(item_entry)->allocation.width = text_area_width + char_width;
1329 gtk_entry_size_allocate(GTK_WIDGET(item_entry),
1330 (GtkAllocation *)(&GTK_WIDGET(item_entry)->allocation));
1331 gtk_widget_queue_draw(GTK_WIDGET(item_entry));
1332 }
1333 else
1334 {
1335 entry->scroll_offset= -(text_area_width
1336 - gdk_text_width (GTK_WIDGET (item_entry)->style->font, gtk_entry_get_text(entry), GTK_EDITABLE(entry)->current_pos)) + 1;
1337 if(entry->scroll_offset < 0) entry->scroll_offset = 0;
1338 }
1339 }
1340 }
1341 else
1342 entry->scroll_offset=0;
1343
1344 break;
1345 case GTK_JUSTIFY_CENTER:
1346
1347 if(entry->text){
1348
1349 text_width = gdk_text_width (GTK_WIDGET (item_entry)->style->font, gtk_entry_get_text(entry), strlen(gtk_entry_get_text(entry)));
1350
1351 entry->scroll_offset= -(text_area_width - text_width)/2;
1352 if(entry->scroll_offset > 0){
1353 if(item_entry->text_max_size != 0 &&
1354 text_area_width+char_width<=item_entry->text_max_size){
1355 GTK_WIDGET(item_entry)->allocation.x=GTK_WIDGET(item_entry)->allocation.x+
1356 GTK_WIDGET(item_entry)->allocation.width/2-
1357 (text_area_width+char_width)/2;
1358 GTK_WIDGET(item_entry)->allocation.width=text_area_width+char_width;
1359 gtk_entry_size_allocate(GTK_WIDGET(item_entry),
1360 (GtkAllocation *)(&GTK_WIDGET(item_entry)->allocation));
1361 gtk_widget_queue_draw(GTK_WIDGET(item_entry));
1362 }
1363 else
1364 {
1365 entry->scroll_offset= -(text_area_width
1366 - gdk_text_width (GTK_WIDGET (item_entry)->style->font, gtk_entry_get_text(entry), GTK_EDITABLE(entry)->current_pos)) + 1;
1367 if(entry->scroll_offset < 0) entry->scroll_offset = 0;
1368 }
1369 }
1370 }
1371 else
1372 entry->scroll_offset=0;
1373
1374 break;
1375
1376 }
1377
1378 }
1379
1380 static void
1381 gtk_entry_grow_text (GtkEntry *entry)
1382 {
1383 gint previous_size;
1384 gint i;
1385
1386 g_return_if_fail (entry != NULL);
1387 g_return_if_fail (GTK_IS_ENTRY (entry));
1388 g_return_if_fail (GTK_IS_ITEM_ENTRY (entry));
1389
1390 previous_size = entry->text_size;
1391 if (!entry->text_size)
1392 entry->text_size = 128;
1393 else
1394 entry->text_size *= 2;
1395 entry->text = g_realloc (entry->text, entry->text_size * sizeof(GdkWChar));
1396 entry->char_offset = g_realloc (entry->char_offset,
1397 entry->text_size * sizeof(guint));
1398
1399 if (entry->text_length == 0) /* initial allocation */
1400 {
1401 entry->char_offset[0] = 0;
1402 }
1403
1404 for (i = previous_size; i < entry->text_size; i++)
1405 entry->text[i] = '\0';
1406 }
1407
1408 static void
1409 gtk_entry_insert_text (GtkEditable *editable,
1410 const gchar *new_text,
1411 gint new_text_length,
1412 gint *position)
1413 {
1414 GdkWChar *text;
1415 gint start_pos;
1416 gint end_pos;
1417 gint last_pos;
1418 gint max_length;
1419 gint i;
1420
1421 guchar *new_text_nt;
1422 gint insertion_length;
1423 GdkWChar *insertion_text;
1424
1425 GtkEntry *entry;
1426 GtkWidget *widget;
1427
1428 g_return_if_fail (editable != NULL);
1429 g_return_if_fail (GTK_IS_ENTRY (editable));
1430
1431 entry = GTK_ENTRY (editable);
1432 widget = GTK_WIDGET (editable);
1433
1434 if ((entry->text_length == 0) && (entry->use_wchar == FALSE))
1435 {
1436 if (!GTK_WIDGET_REALIZED (widget))
1437 gtk_widget_ensure_style (widget);
1438 if ((widget->style) && (widget->style->font->type == GDK_FONT_FONTSET))
1439 entry->use_wchar = TRUE;
1440 }
1441
1442 if (new_text_length < 0)
1443 {
1444 new_text_nt = (gchar *)new_text;
1445 new_text_length = strlen (new_text);
1446 if (new_text_length <= 0) return;
1447 }
1448 else if (new_text_length == 0)
1449 {
1450 return;
1451 }
1452 else
1453 {
1454 /* make a null-terminated copy of new_text */
1455 new_text_nt = g_new (gchar, new_text_length + 1);
1456 memcpy (new_text_nt, new_text, new_text_length);
1457 new_text_nt[new_text_length] = 0;
1458 }
1459
1460 /* The algorithms here will work as long as, the text size (a
1461 * multiple of 2), fits into a guint16 but we specify a shorter
1462 * maximum length so that if the user pastes a very long text, there
1463 * is not a long hang from the slow X_LOCALE functions. */
1464
1465 if (entry->text_max_length == 0)
1466 max_length = 2047;
1467 else
1468 max_length = MIN (2047, entry->text_max_length);
1469
1470 /* Convert to wide characters */
1471 insertion_text = g_new (GdkWChar, new_text_length);
1472 if (entry->use_wchar)
1473 insertion_length = gdk_mbstowcs (insertion_text, new_text_nt,
1474 new_text_length);
1475 else
1476 for (insertion_length=0; new_text_nt[insertion_length]; insertion_length++)
1477 insertion_text[insertion_length] = new_text_nt[insertion_length];
1478 if (new_text_nt != (guchar *)new_text)
1479 g_free (new_text_nt);
1480
1481 /* Make sure we do not exceed the maximum size of the entry. */
1482 if (insertion_length + entry->text_length > max_length)
1483 insertion_length = max_length - entry->text_length;
1484
1485 /* Don't insert anything, if there was nothing to insert. */
1486 if (insertion_length <= 0)
1487 {
1488 g_free(insertion_text);
1489 return;
1490 }
1491
1492 /* Make sure we are inserting at integral character position */
1493 start_pos = *position;
1494 if (start_pos < 0)
1495 start_pos = 0;
1496 else if (start_pos > entry->text_length)
1497 start_pos = entry->text_length;
1498
1499 end_pos = start_pos + insertion_length;
1500 last_pos = insertion_length + entry->text_length;
1501
1502 if (editable->selection_start_pos >= *position)
1503 editable->selection_start_pos += insertion_length;
1504 if (editable->selection_end_pos >= *position)
1505 editable->selection_end_pos += insertion_length;
1506
1507 while (last_pos >= entry->text_size)
1508 gtk_entry_grow_text (entry);
1509
1510 text = entry->text;
1511 for (i = last_pos - 1; i >= end_pos; i--)
1512 text[i] = text[i- (end_pos - start_pos)];
1513 for (i = start_pos; i < end_pos; i++)
1514 text[i] = insertion_text[i - start_pos];
1515 g_free (insertion_text);
1516
1517 /* Fix up the the character offsets */
1518
1519 if (GTK_WIDGET_REALIZED (entry))
1520 {
1521 gint offset = 0;
1522
1523 for (i = last_pos; i >= end_pos; i--)
1524 entry->char_offset[i]
1525 = entry->char_offset[i - insertion_length];
1526
1527 for (i=start_pos; i<end_pos; i++)
1528 {
1529 entry->char_offset[i] = entry->char_offset[start_pos] + offset;
1530 if (entry->visible)
1531 {
1532 offset += gdk_char_width_wc (GTK_WIDGET (entry)->style->font,
1533 entry->text[i]);
1534 }
1535 else
1536 {
1537 offset += gdk_char_width (GTK_WIDGET (entry)->style->font, '*');
1538 }
1539 }
1540 for (i = end_pos; i <= last_pos; i++)
1541 entry->char_offset[i] += offset;
1542 }
1543
1544 entry->text_length += insertion_length;
1545 *position = end_pos;
1546
1547 entry->text_mb_dirty = 1;
1548 gtk_entry_queue_draw (entry);
1549 }
1550
1551 static void
1552 gtk_entry_delete_text (GtkEditable *editable,
1553 gint start_pos,
1554 gint end_pos)
1555 {
1556 GdkWChar *text;
1557 gint deletion_length;
1558 gint i;
1559
1560 GtkEntry *entry;
1561
1562 g_return_if_fail (editable != NULL);
1563 g_return_if_fail (GTK_IS_ENTRY (editable));
1564
1565 entry = GTK_ENTRY (editable);
1566
1567 if (end_pos < 0)
1568 end_pos = entry->text_length;
1569
1570 if (editable->selection_start_pos > start_pos)
1571 editable->selection_start_pos -= MIN(end_pos, editable->selection_start_pos) - start_pos;
1572 if (editable->selection_end_pos > start_pos)
1573 editable->selection_end_pos -= MIN(end_pos, editable->selection_end_pos) - start_pos;
1574
1575 if ((start_pos < end_pos) &&
1576 (start_pos >= 0) &&
1577 (end_pos <= entry->text_length))
1578 {
1579 text = entry->text;
1580 deletion_length = end_pos - start_pos;
1581
1582 /* Fix up the character offsets */
1583 if (GTK_WIDGET_REALIZED (entry))
1584 {
1585 gint deletion_width =
1586 entry->char_offset[end_pos] - entry->char_offset[start_pos];
1587
1588 for (i = 0 ; i <= entry->text_length - end_pos; i++)
1589 entry->char_offset[start_pos+i] = entry->char_offset[end_pos+i] - deletion_width;
1590 }
1591
1592 for (i = end_pos; i < entry->text_length; i++)
1593 text[i - deletion_length] = text[i];
1594
1595 for (i = entry->text_length - deletion_length; i < entry->text_length; i++)
1596 text[i] = '\0';
1597
1598 entry->text_length -= deletion_length;
1599 editable->current_pos = start_pos;
1600 }
1601
1602 entry->text_mb_dirty = 1;
1603 gtk_entry_queue_draw (entry);
1604 }
1605
1606 static void
1607 gtk_entry_update_text (GtkEditable *editable,
1608 gint start_pos,
1609 gint end_pos)
1610 {
1611 gtk_entry_queue_draw (GTK_ENTRY(editable));
1612 }
1613
1614 static gchar *
1615 gtk_entry_get_chars (GtkEditable *editable,
1616 gint start_pos,
1617 gint end_pos)
1618 {
1619 GtkEntry *entry;
1620
1621 g_return_val_if_fail (editable != NULL, NULL);
1622 g_return_val_if_fail (GTK_IS_ENTRY (editable), NULL);
1623
1624 entry = GTK_ENTRY (editable);
1625
1626 if (end_pos < 0)
1627 end_pos = entry->text_length;
1628
1629 start_pos = MIN(entry->text_length, start_pos);
1630 end_pos = MIN(entry->text_length, end_pos);
1631
1632 if (start_pos <= end_pos)
1633 {
1634 guchar *mbstr;
1635 if (entry->use_wchar)
1636 {
1637 GdkWChar ch;
1638 if (end_pos >= entry->text_size)
1639 gtk_entry_grow_text(entry);
1640 ch = entry->text[end_pos];
1641 entry->text[end_pos] = 0;
1642 mbstr = gdk_wcstombs (entry->text + start_pos);
1643 entry->text[end_pos] = ch;
1644 return (gchar *)mbstr;
1645 }
1646 else
1647 {
1648 gint i;
1649 mbstr = g_new (gchar, end_pos - start_pos + 1);
1650 for (i=0; i<end_pos-start_pos; i++)
1651 mbstr[i] = entry->text[start_pos + i];
1652 mbstr[i] = 0;
1653 return (gchar *)mbstr;
1654 }
1655 }
1656 else
1657 return NULL;
1658 }
1659
1660 static void
1661 gtk_entry_move_cursor (GtkEditable *editable,
1662 gint x,
1663 gint y)
1664 {
1665 GtkEntry *entry;
1666 entry = GTK_ENTRY (editable);
1667
1668 /* Horizontal motion */
1669 if ((gint)editable->current_pos < -x)
1670 editable->current_pos = 0;
1671 else if (editable->current_pos + x > entry->text_length)
1672 editable->current_pos = entry->text_length;
1673 else
1674 editable->current_pos += x;
1675
1676 /* Ignore vertical motion */
1677 }
1678
1679 static void
1680 gtk_move_forward_character (GtkEntry *entry)
1681 {
1682 gtk_entry_move_cursor (GTK_EDITABLE (entry), 1, 0);
1683 }
1684
1685 static void
1686 gtk_move_backward_character (GtkEntry *entry)
1687 {
1688 gtk_entry_move_cursor (GTK_EDITABLE (entry), -1, 0);
1689 }
1690
1691 static void
1692 gtk_entry_move_word (GtkEditable *editable,
1693 gint n)
1694 {
1695 while (n-- > 0)
1696 gtk_move_forward_word (GTK_ENTRY (editable));
1697 while (n++ < 0)
1698 gtk_move_backward_word (GTK_ENTRY (editable));
1699 }
1700
1701 static void
1702 gtk_move_forward_word (GtkEntry *entry)
1703 {
1704 GtkEditable *editable;
1705 GdkWChar *text;
1706 gint i;
1707
1708 editable = GTK_EDITABLE (entry);
1709
1710 if (entry->text && (editable->current_pos < entry->text_length))
1711 {
1712 text = entry->text;
1713 i = editable->current_pos;
1714
1715 if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i])))
1716 for (; i < entry->text_length; i++)
1717 {
1718 if ((entry->use_wchar) ? gdk_iswalnum (text[i]) : isalnum (text[i]))
1719 break;
1720 }
1721
1722 for (; i < entry->text_length; i++)
1723 {
1724 if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i])))
1725 break;
1726 }
1727
1728 editable->current_pos = i;
1729 }
1730 }
1731
1732 static void
1733 gtk_move_backward_word (GtkEntry *entry)
1734 {
1735 GtkEditable *editable;
1736 GdkWChar *text;
1737 gint i;
1738
1739 editable = GTK_EDITABLE (entry);
1740
1741 if (entry->text && editable->current_pos > 0)
1742 {
1743 text = entry->text;
1744 i = editable->current_pos - 1;
1745 if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i])))
1746 for (; i >= 0; i--)
1747 {
1748 if ((entry->use_wchar) ? gdk_iswalnum (text[i]) : isalnum (text[i]))
1749 break;
1750 }
1751 for (; i >= 0; i--)
1752 {
1753 if ((entry->use_wchar) ? (!gdk_iswalnum (text[i])) : (!isalnum (text[i])))
1754 {
1755 i++;
1756 break;
1757 }
1758 }
1759
1760 if (i < 0)
1761 i = 0;
1762
1763 editable->current_pos = i;
1764 }
1765 }
1766
1767 static void
1768 gtk_entry_move_to_column (GtkEditable *editable, gint column)
1769 {
1770 GtkEntry *entry;
1771
1772 entry = GTK_ENTRY (editable);
1773
1774 if (column < 0 || column > entry->text_length)
1775 editable->current_pos = entry->text_length;
1776 else
1777 editable->current_pos = column;
1778 }
1779
1780 static void
1781 gtk_move_beginning_of_line (GtkEntry *entry)
1782 {
1783 gtk_entry_move_to_column (GTK_EDITABLE (entry), 0);
1784 }
1785
1786 static void
1787 gtk_move_end_of_line (GtkEntry *entry)
1788 {
1789 gtk_entry_move_to_column (GTK_EDITABLE (entry), -1);
1790 }
1791
1792 static void
1793 gtk_entry_kill_char (GtkEditable *editable,
1794 gint direction)
1795 {
1796 if (editable->selection_start_pos != editable->selection_end_pos)
1797 gtk_editable_delete_selection (editable);
1798 else
1799 {
1800 gint old_pos = editable->current_pos;
1801 if (direction >= 0)
1802 {
1803 gtk_entry_move_cursor (editable, 1, 0);
1804 gtk_editable_delete_text (editable, old_pos, editable->current_pos);
1805 }
1806 else
1807 {
1808 gtk_entry_move_cursor (editable, -1, 0);
1809 gtk_editable_delete_text (editable, editable->current_pos, old_pos);
1810 }
1811 }
1812 }
1813
1814 static void
1815 gtk_delete_forward_character (GtkEntry *entry)
1816 {
1817 gtk_entry_kill_char (GTK_EDITABLE (entry), 1);
1818 }
1819
1820 static void
1821 gtk_delete_backward_character (GtkEntry *entry)
1822 {
1823 gtk_entry_kill_char (GTK_EDITABLE (entry), -1);
1824 }
1825
1826 static void
1827 gtk_entry_kill_word (GtkEditable *editable,
1828 gint direction)
1829 {
1830 if (editable->selection_start_pos != editable->selection_end_pos)
1831 gtk_editable_delete_selection (editable);
1832 else
1833 {
1834 gint old_pos = editable->current_pos;
1835 if (direction >= 0)
1836 {
1837 gtk_entry_move_word (editable, 1);
1838 gtk_editable_delete_text (editable, old_pos, editable->current_pos);
1839 }
1840 else
1841 {
1842 gtk_entry_move_word (editable, -1);
1843 gtk_editable_delete_text (editable, editable->current_pos, old_pos);
1844 }
1845 }
1846 }
1847
1848 static void
1849 gtk_delete_forward_word (GtkEntry *entry)
1850 {
1851 gtk_entry_kill_word (GTK_EDITABLE (entry), 1);
1852 }
1853
1854 static void
1855 gtk_delete_backward_word (GtkEntry *entry)
1856 {
1857 gtk_entry_kill_word (GTK_EDITABLE (entry), -1);
1858 }
1859
1860 static void
1861 gtk_entry_kill_line (GtkEditable *editable,
1862 gint direction)
1863 {
1864 gint old_pos = editable->current_pos;
1865 if (direction >= 0)
1866 {
1867 gtk_entry_move_to_column (editable, -1);
1868 gtk_editable_delete_text (editable, old_pos, editable->current_pos);
1869 }
1870 else
1871 {
1872 gtk_entry_move_to_column (editable, 0);
1873 gtk_editable_delete_text (editable, editable->current_pos, old_pos);
1874 }
1875 }
1876
1877 static void
1878 gtk_delete_line (GtkEntry *entry)
1879 {
1880 gtk_entry_move_to_column (GTK_EDITABLE (entry), 0);
1881 gtk_entry_kill_line (GTK_EDITABLE (entry), 1);
1882 }
1883
1884 static void
1885 gtk_delete_to_line_end (GtkEntry *entry)
1886 {
1887 gtk_editable_delete_text (GTK_EDITABLE(entry), GTK_EDITABLE(entry)->current_pos, entry->text_length);
1888 }
1889
1890 static void
1891 gtk_select_word (GtkEntry *entry,
1892 guint32 time)
1893 {
1894 GtkEditable *editable;
1895 gint start_pos;
1896 gint end_pos;
1897
1898 editable = GTK_EDITABLE (entry);
1899
1900 gtk_move_backward_word (entry);
1901 start_pos = editable->current_pos;
1902
1903 gtk_move_forward_word (entry);
1904 end_pos = editable->current_pos;
1905
1906 editable->has_selection = TRUE;
1907 gtk_entry_set_selection (editable, start_pos, end_pos);
1908 gtk_editable_claim_selection (editable, start_pos != end_pos, time);
1909 }
1910
1911 static void
1912 gtk_select_line (GtkEntry *entry,
1913 guint32 time)
1914 {
1915 GtkEditable *editable;
1916
1917 editable = GTK_EDITABLE (entry);
1918
1919 editable->has_selection = TRUE;
1920 gtk_entry_set_selection (editable, 0, entry->text_length);
1921 gtk_editable_claim_selection (editable, entry->text_length != 0, time);
1922
1923 editable->current_pos = editable->selection_end_pos;
1924 }
1925
1926 static void
1927 gtk_entry_set_selection (GtkEditable *editable,
1928 gint start,
1929 gint end)
1930 {
1931 g_return_if_fail (editable != NULL);
1932 g_return_if_fail (GTK_IS_ENTRY (editable));
1933
1934 if (end < 0)
1935 end = GTK_ENTRY (editable)->text_length;
1936
1937 editable->selection_start_pos = start;
1938 editable->selection_end_pos = end;
1939
1940 gtk_entry_queue_draw (GTK_ENTRY (editable));
1941 }
1942
1943 #ifdef USE_XIM
1944 static void
1945 gtk_entry_update_ic_attr (GtkWidget *widget)
1946 {
1947 GtkEditable *editable = (GtkEditable *) widget;
1948 GdkICAttributesType mask = 0;
1949
1950 gdk_ic_get_attr (editable->ic, editable->ic_attr,
1951 GDK_IC_PREEDIT_FOREGROUND |
1952 GDK_IC_PREEDIT_BACKGROUND |
1953 GDK_IC_PREEDIT_FONTSET);
1954
1955 if (editable->ic_attr->preedit_foreground.pixel !=
1956 widget->style->fg[GTK_STATE_NORMAL].pixel)
1957 {
1958 mask |= GDK_IC_PREEDIT_FOREGROUND;
1959 editable->ic_attr->preedit_foreground
1960 = widget->style->fg[GTK_STATE_NORMAL];
1961 }
1962 if (editable->ic_attr->preedit_background.pixel !=
1963 widget->style->base[GTK_STATE_NORMAL].pixel)
1964 {
1965 mask |= GDK_IC_PREEDIT_BACKGROUND;
1966 editable->ic_attr->preedit_background
1967 = widget->style->base[GTK_STATE_NORMAL];
1968 }
1969 if ((gdk_ic_get_style (editable->ic) & GDK_IM_PREEDIT_POSITION) &&
1970 !gdk_font_equal (editable->ic_attr->preedit_fontset,
1971 widget->style->font))
1972 {
1973 mask |= GDK_IC_PREEDIT_FONTSET;
1974 editable->ic_attr->preedit_fontset = widget->style->font;
1975 }
1976
1977 if (mask)
1978 gdk_ic_set_attr (editable->ic, editable->ic_attr, mask);
1979 }
1980 #endif /* USE_XIM */
1981
1982
Dan White's gEDA tree