projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Source cleaning inspired by and included in patch '[ 1215450 ] cleanup: unreachable...
[wxWidgets.git] / src / gtk1 / textctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: textctrl.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
11 #pragma implementation "textctrl.h"
12 #endif
13
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
16
17 #include "wx/textctrl.h"
18 #include "wx/utils.h"
19 #include "wx/intl.h"
20 #include "wx/log.h"
21 #include "wx/settings.h"
22 #include "wx/panel.h"
23 #include "wx/strconv.h"
24 #include "wx/fontutil.h" // for wxNativeFontInfo (GetNativeFontInfo())
25
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <ctype.h>
29 #include "wx/math.h"
30
31 #include "wx/gtk/private.h"
32 #include <gdk/gdkkeysyms.h>
33
34 //-----------------------------------------------------------------------------
35 // idle system
36 //-----------------------------------------------------------------------------
37
38 extern void wxapp_install_idle_handler();
39 extern bool g_isIdle;
40
41 //-----------------------------------------------------------------------------
42 // data
43 //-----------------------------------------------------------------------------
44
45 extern bool g_blockEventsOnDrag;
46 extern wxCursor g_globalCursor;
47 extern wxWindowGTK *g_delayedFocus;
48
49 // ----------------------------------------------------------------------------
50 // helpers
51 // ----------------------------------------------------------------------------
52
53 #ifdef __WXGTK20__
54 extern "C" {
55 static void wxGtkOnRemoveTag(GtkTextBuffer *buffer,
56 GtkTextTag *tag,
57 GtkTextIter *start,
58 GtkTextIter *end,
59 gpointer user_data)
60 {
61 gchar *name;
62 g_object_get (tag, "name", &name, NULL);
63
64 if (!name || strncmp(name, "WX", 2)) // anonymous tag or not starting with "WX"
65 g_signal_stop_emission_by_name(buffer, "remove_tag");
66
67 g_free(name);
68 }
69 }
70
71 extern "C" {
72 static void wxGtkTextApplyTagsFromAttr(GtkTextBuffer *text_buffer,
73 const wxTextAttr& attr,
74 GtkTextIter *start,
75 GtkTextIter *end)
76 {
77 static gchar buf[1024];
78 GtkTextTag *tag;
79
80 gulong remove_handler_id = g_signal_connect( text_buffer, "remove_tag",
81 G_CALLBACK(wxGtkOnRemoveTag), NULL);
82 gtk_text_buffer_remove_all_tags(text_buffer, start, end);
83 g_signal_handler_disconnect( text_buffer, remove_handler_id );
84
85 if (attr.HasFont())
86 {
87 char *font_string;
88 PangoFontDescription *font_description = attr.GetFont().GetNativeFontInfo()->description;
89 font_string = pango_font_description_to_string(font_description);
90 g_snprintf(buf, sizeof(buf), "WXFONT %s", font_string);
91 tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
92 buf );
93 if (!tag)
94 tag = gtk_text_buffer_create_tag( text_buffer, buf,
95 "font-desc", font_description,
96 NULL );
97 gtk_text_buffer_apply_tag (text_buffer, tag, start, end);
98 g_free (font_string);
99 }
100
101 if (attr.HasTextColour())
102 {
103 GdkColor *colFg = attr.GetTextColour().GetColor();
104 g_snprintf(buf, sizeof(buf), "WXFORECOLOR %d %d %d",
105 colFg->red, colFg->green, colFg->blue);
106 tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
107 buf );
108 if (!tag)
109 tag = gtk_text_buffer_create_tag( text_buffer, buf,
110 "foreground-gdk", colFg, NULL );
111 gtk_text_buffer_apply_tag (text_buffer, tag, start, end);
112 }
113
114 if (attr.HasBackgroundColour())
115 {
116 GdkColor *colBg = attr.GetBackgroundColour().GetColor();
117 g_snprintf(buf, sizeof(buf), "WXBACKCOLOR %d %d %d",
118 colBg->red, colBg->green, colBg->blue);
119 tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
120 buf );
121 if (!tag)
122 tag = gtk_text_buffer_create_tag( text_buffer, buf,
123 "background-gdk", colBg, NULL );
124 gtk_text_buffer_apply_tag (text_buffer, tag, start, end);
125 }
126 }
127 }
128
129 extern "C" {
130 static void wxGtkTextInsert(GtkWidget *text,
131 GtkTextBuffer *text_buffer,
132 const wxTextAttr& attr,
133 wxCharBuffer buffer)
134
135 {
136 gint start_offset;
137 GtkTextIter iter, start;
138
139 gtk_text_buffer_get_iter_at_mark( text_buffer, &iter,
140 gtk_text_buffer_get_insert (text_buffer) );
141 start_offset = gtk_text_iter_get_offset (&iter);
142 gtk_text_buffer_insert( text_buffer, &iter, buffer, strlen(buffer) );
143
144 gtk_text_buffer_get_iter_at_offset (text_buffer, &start, start_offset);
145
146 wxGtkTextApplyTagsFromAttr(text_buffer, attr, &start, &iter);
147 }
148 }
149 #else
150 extern "C" {
151 static void wxGtkTextInsert(GtkWidget *text,
152 const wxTextAttr& attr,
153 const char *txt,
154 size_t len)
155 {
156 GdkFont *font = attr.HasFont() ? attr.GetFont().GetInternalFont()
157 : NULL;
158
159 GdkColor *colFg = attr.HasTextColour() ? attr.GetTextColour().GetColor()
160 : NULL;
161
162 GdkColor *colBg = attr.HasBackgroundColour()
163 ? attr.GetBackgroundColour().GetColor()
164 : NULL;
165
166 gtk_text_insert( GTK_TEXT(text), font, colFg, colBg, txt, len );
167 }
168 }
169 #endif // GTK 1.x
170
171 // ----------------------------------------------------------------------------
172 // "insert_text" for GtkEntry
173 // ----------------------------------------------------------------------------
174
175 extern "C" {
176 static void
177 gtk_insert_text_callback(GtkEditable *editable,
178 const gchar *new_text,
179 gint new_text_length,
180 gint *position,
181 wxTextCtrl *win)
182 {
183 if (g_isIdle)
184 wxapp_install_idle_handler();
185
186 // we should only be called if we have a max len limit at all
187 GtkEntry *entry = GTK_ENTRY (editable);
188
189 wxCHECK_RET( entry->text_max_length, _T("shouldn't be called") );
190
191 // check that we don't overflow the max length limit
192 //
193 // FIXME: this doesn't work when we paste a string which is going to be
194 // truncated
195 if ( entry->text_length == entry->text_max_length )
196 {
197 // we don't need to run the base class version at all
198 gtk_signal_emit_stop_by_name(GTK_OBJECT(editable), "insert_text");
199
200 // remember that the next changed signal is to be ignored to avoid
201 // generating a dummy wxEVT_COMMAND_TEXT_UPDATED event
202 win->IgnoreNextTextUpdate();
203
204 // and generate the correct one ourselves
205 wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, win->GetId());
206 event.SetEventObject(win);
207 event.SetString(win->GetValue());
208 win->GetEventHandler()->ProcessEvent( event );
209 }
210 }
211 }
212
213 #ifdef __WXGTK20__
214 // Implementation of wxTE_AUTO_URL for wxGTK2 by Mart Raudsepp,
215
216 extern "C" {
217 static void
218 au_apply_tag_callback(GtkTextBuffer *buffer,
219 GtkTextTag *tag,
220 GtkTextIter *start,
221 GtkTextIter *end,
222 gpointer textctrl)
223 {
224 if(tag == gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl"))
225 g_signal_stop_emission_by_name(buffer, "apply_tag");
226 }
227 }
228
229 //-----------------------------------------------------------------------------
230 // GtkTextCharPredicates for gtk_text_iter_*_find_char
231 //-----------------------------------------------------------------------------
232
233 extern "C" {
234 static gboolean
235 pred_whitespace (gunichar ch, gpointer user_data)
236 {
237 return g_unichar_isspace(ch);
238 }
239 }
240
241 extern "C" {
242 static gboolean
243 pred_non_whitespace (gunichar ch, gpointer user_data)
244 {
245 return !g_unichar_isspace(ch);
246 }
247 }
248
249 extern "C" {
250 static gboolean
251 pred_nonpunct (gunichar ch, gpointer user_data)
252 {
253 return !g_unichar_ispunct(ch);
254 }
255 }
256
257 extern "C" {
258 static gboolean
259 pred_nonpunct_or_slash (gunichar ch, gpointer user_data)
260 {
261 return !g_unichar_ispunct(ch) || ch == '/';
262 }
263 }
264
265 //-----------------------------------------------------------------------------
266 // Check for links between s and e and correct tags as necessary
267 //-----------------------------------------------------------------------------
268
269 // This function should be made match better while being efficient at one point.
270 // Most probably with a row of regular expressions.
271 extern "C" {
272 static void
273 au_check_word( GtkTextIter *s, GtkTextIter *e )
274 {
275 static const char *URIPrefixes[] =
276 {
277 "http://",
278 "ftp://",
279 "www.",
280 "ftp.",
281 "mailto://",
282 "https://",
283 "file://",
284 "nntp://",
285 "news://",
286 "telnet://",
287 "mms://",
288 "gopher://",
289 "prospero://",
290 "wais://",
291 };
292
293 GtkTextIter start = *s, end = *e;
294 GtkTextBuffer *buffer = gtk_text_iter_get_buffer(s);
295
296 // Get our special link tag
297 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl");
298
299 // Get rid of punctuation from beginning and end.
300 // Might want to move this to au_check_range if an improved link checking doesn't
301 // use some intelligent punctuation checking itself (beware of undesired iter modifications).
302 if(g_unichar_ispunct( gtk_text_iter_get_char( &start ) ) )
303 gtk_text_iter_forward_find_char( &start, pred_nonpunct, NULL, e );
304
305 gtk_text_iter_backward_find_char( &end, pred_nonpunct_or_slash, NULL, &start );
306 gtk_text_iter_forward_char(&end);
307
308 gchar* text = gtk_text_iter_get_text( &start, &end );
309 size_t len = strlen(text), prefix_len;
310 size_t n;
311
312 for( n = 0; n < WXSIZEOF(URIPrefixes); ++n )
313 {
314 prefix_len = strlen(URIPrefixes[n]);
315 if((len > prefix_len) && !strncasecmp(text, URIPrefixes[n], prefix_len))
316 break;
317 }
318
319 if(n < WXSIZEOF(URIPrefixes))
320 {
321 gulong signal_id = g_signal_handler_find(buffer,
322 (GSignalMatchType) (G_SIGNAL_MATCH_FUNC),
323 0, 0, NULL,
324 (gpointer)au_apply_tag_callback, NULL);
325
326 g_signal_handler_block(buffer, signal_id);
327 gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
328 g_signal_handler_unblock(buffer, signal_id);
329 }
330 }
331 }
332
333 extern "C" {
334 static void
335 au_check_range(GtkTextIter *s,
336 GtkTextIter *range_end)
337 {
338 GtkTextIter range_start = *s;
339 GtkTextIter word_end;
340 GtkTextBuffer *buffer = gtk_text_iter_get_buffer(s);
341 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl");
342
343 gtk_text_buffer_remove_tag(buffer, tag, s, range_end);
344
345 if(g_unichar_isspace(gtk_text_iter_get_char(&range_start)))
346 gtk_text_iter_forward_find_char(&range_start, pred_non_whitespace, NULL, range_end);
347
348 while(!gtk_text_iter_equal(&range_start, range_end))
349 {
350 word_end = range_start;
351 gtk_text_iter_forward_find_char(&word_end, pred_whitespace, NULL, range_end);
352
353 // Now we should have a word delimited by range_start and word_end, correct link tags
354 au_check_word(&range_start, &word_end);
355
356 range_start = word_end;
357 gtk_text_iter_forward_find_char(&range_start, pred_non_whitespace, NULL, range_end);
358 }
359 }
360 }
361
362 //-----------------------------------------------------------------------------
363 // "insert-text" for GtkTextBuffer
364 //-----------------------------------------------------------------------------
365
366 extern "C" {
367 static void
368 au_insert_text_callback(GtkTextBuffer *buffer,
369 GtkTextIter *end,
370 gchar *text,
371 gint len,
372 wxTextCtrl *win)
373 {
374 if (!len || !(win->GetWindowStyleFlag() & wxTE_AUTO_URL) )
375 return;
376
377 GtkTextIter start = *end;
378 gtk_text_iter_backward_chars(&start, g_utf8_strlen(text, len));
379
380 GtkTextIter line_start = start;
381 GtkTextIter line_end = *end;
382 GtkTextIter words_start = start;
383 GtkTextIter words_end = *end;
384
385 gtk_text_iter_set_line(&line_start, gtk_text_iter_get_line(&start));
386 gtk_text_iter_forward_to_line_end(&line_end);
387 gtk_text_iter_backward_find_char(&words_start, pred_whitespace, NULL, &line_start);
388 gtk_text_iter_forward_find_char(&words_end, pred_whitespace, NULL, &line_end);
389
390 au_check_range(&words_start, &words_end);
391 }
392 }
393
394 //-----------------------------------------------------------------------------
395 // "delete-range" for GtkTextBuffer
396 //-----------------------------------------------------------------------------
397
398 extern "C" {
399 static void
400 au_delete_range_callback(GtkTextBuffer *buffer,
401 GtkTextIter *start,
402 GtkTextIter *end,
403 wxTextCtrl *win)
404 {
405 if( !(win->GetWindowStyleFlag() & wxTE_AUTO_URL) )
406 return;
407
408 GtkTextIter line_start = *start, line_end = *end;
409
410 gtk_text_iter_set_line(&line_start, gtk_text_iter_get_line(start));
411 gtk_text_iter_forward_to_line_end(&line_end);
412 gtk_text_iter_backward_find_char(start, pred_whitespace, NULL, &line_start);
413 gtk_text_iter_forward_find_char(end, pred_whitespace, NULL, &line_end);
414
415 au_check_range(start, end);
416 }
417 }
418
419
420 #endif
421
422 //-----------------------------------------------------------------------------
423 // "changed"
424 //-----------------------------------------------------------------------------
425
426 extern "C" {
427 static void
428 gtk_text_changed_callback( GtkWidget *widget, wxTextCtrl *win )
429 {
430 if ( win->IgnoreTextUpdate() )
431 return;
432
433 if (!win->m_hasVMT) return;
434
435 if (g_isIdle)
436 wxapp_install_idle_handler();
437
438 win->SetModified();
439 #ifndef __WXGTK20__
440 win->UpdateFontIfNeeded();
441 #endif // !__WXGTK20__
442
443 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
444 event.SetEventObject( win );
445 win->GetEventHandler()->ProcessEvent( event );
446 }
447 }
448
449 //-----------------------------------------------------------------------------
450 // "expose_event" from scrolled window and textview
451 //-----------------------------------------------------------------------------
452
453 #ifdef __WXGTK20__
454 extern "C" {
455 static gboolean
456 gtk_text_exposed_callback( GtkWidget *widget, GdkEventExpose *event, wxTextCtrl *win )
457 {
458 return TRUE;
459 }
460 }
461 #endif
462
463 //-----------------------------------------------------------------------------
464 // "changed" from vertical scrollbar
465 //-----------------------------------------------------------------------------
466
467 #ifndef __WXGTK20__
468 extern "C" {
469 static void
470 gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
471 {
472 if (!win->m_hasVMT) return;
473
474 if (g_isIdle)
475 wxapp_install_idle_handler();
476
477 win->CalculateScrollbar();
478 }
479 }
480 #endif
481
482 // ----------------------------------------------------------------------------
483 // redraw callback for multiline text
484 // ----------------------------------------------------------------------------
485
486 #ifndef __WXGTK20__
487
488 // redrawing a GtkText from inside a wxYield() call results in crashes (the
489 // text sample shows it in its "Add lines" command which shows wxProgressDialog
490 // which implicitly calls wxYield()) so we override GtkText::draw() and simply
491 // don't do anything if we're inside wxYield()
492
493 extern bool wxIsInsideYield;
494
495 extern "C" {
496 typedef void (*GtkDrawCallback)(GtkWidget *widget, GdkRectangle *rect);
497 }
498
499 static GtkDrawCallback gs_gtk_text_draw = NULL;
500
501 extern "C" {
502 static void wxgtk_text_draw( GtkWidget *widget, GdkRectangle *rect)
503 {
504 if ( !wxIsInsideYield )
505 {
506 wxCHECK_RET( gs_gtk_text_draw != wxgtk_text_draw,
507 _T("infinite recursion in wxgtk_text_draw aborted") );
508
509 gs_gtk_text_draw(widget, rect);
510 }
511 }
512 }
513
514 #endif // __WXGTK20__
515
516 //-----------------------------------------------------------------------------
517 // wxTextCtrl
518 //-----------------------------------------------------------------------------
519
520 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
521
522 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
523 EVT_CHAR(wxTextCtrl::OnChar)
524
525 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
526 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
527 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
528 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
529 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
530
531 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
532 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
533 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
534 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
535 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
536
537 #ifdef __WXGTK20__
538 // wxTE_AUTO_URL wxTextUrl support. Currently only creates
539 // wxTextUrlEvent in the same cases as wxMSW, more can be added here.
540 EVT_MOTION (wxTextCtrl::OnUrlMouseEvent)
541 EVT_LEFT_DOWN (wxTextCtrl::OnUrlMouseEvent)
542 EVT_LEFT_UP (wxTextCtrl::OnUrlMouseEvent)
543 EVT_LEFT_DCLICK (wxTextCtrl::OnUrlMouseEvent)
544 EVT_RIGHT_DOWN (wxTextCtrl::OnUrlMouseEvent)
545 EVT_RIGHT_UP (wxTextCtrl::OnUrlMouseEvent)
546 EVT_RIGHT_DCLICK(wxTextCtrl::OnUrlMouseEvent)
547 #endif
548 END_EVENT_TABLE()
549
550 void wxTextCtrl::Init()
551 {
552 m_ignoreNextUpdate =
553 m_modified = false;
554 SetUpdateFont(false);
555 m_text =
556 m_vScrollbar = (GtkWidget *)NULL;
557 #ifdef __WXGTK20__
558 m_frozenness = 0;
559 m_gdkHandCursor = NULL;
560 m_gdkXTermCursor = NULL;
561 #endif
562 }
563
564 wxTextCtrl::~wxTextCtrl()
565 {
566 #ifdef __WXGTK20__
567 if(m_gdkHandCursor)
568 gdk_cursor_unref(m_gdkHandCursor);
569 if(m_gdkXTermCursor)
570 gdk_cursor_unref(m_gdkXTermCursor);
571 #endif
572 }
573
574 wxTextCtrl::wxTextCtrl( wxWindow *parent,
575 wxWindowID id,
576 const wxString &value,
577 const wxPoint &pos,
578 const wxSize &size,
579 long style,
580 const wxValidator& validator,
581 const wxString &name )
582 {
583 Init();
584
585 Create( parent, id, value, pos, size, style, validator, name );
586 }
587
588 bool wxTextCtrl::Create( wxWindow *parent,
589 wxWindowID id,
590 const wxString &value,
591 const wxPoint &pos,
592 const wxSize &size,
593 long style,
594 const wxValidator& validator,
595 const wxString &name )
596 {
597 m_needParent = true;
598 m_acceptsFocus = true;
599
600 if (!PreCreation( parent, pos, size ) ||
601 !CreateBase( parent, id, pos, size, style, validator, name ))
602 {
603 wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
604 return false;
605 }
606
607
608 m_vScrollbarVisible = false;
609
610 bool multi_line = (style & wxTE_MULTILINE) != 0;
611
612 if (multi_line)
613 {
614 #ifdef __WXGTK20__
615 // Create view
616 m_text = gtk_text_view_new();
617
618 m_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
619
620 // create scrolled window
621 m_widget = gtk_scrolled_window_new( NULL, NULL );
622 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( m_widget ),
623 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
624
625 // Insert view into scrolled window
626 gtk_container_add( GTK_CONTAINER(m_widget), m_text );
627
628 // translate wx wrapping style to GTK+
629 GtkWrapMode wrap;
630 if ( HasFlag( wxTE_DONTWRAP ) )
631 wrap = GTK_WRAP_NONE;
632 else if ( HasFlag( wxTE_CHARWRAP ) )
633 wrap = GTK_WRAP_CHAR;
634 else if ( HasFlag( wxTE_WORDWRAP ) )
635 wrap = GTK_WRAP_WORD;
636 else // HasFlag(wxTE_BESTWRAP) always true as wxTE_BESTWRAP == 0
637 {
638 // GTK_WRAP_WORD_CHAR seems to be new in GTK+ 2.4
639 #ifdef __WXGTK24__
640 if ( !gtk_check_version(2,4,0) )
641 {
642 wrap = GTK_WRAP_WORD_CHAR;
643 }
644 else
645 #endif
646 wrap = GTK_WRAP_WORD;
647 }
648
649 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), wrap );
650
651 if (!HasFlag(wxNO_BORDER))
652 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(m_widget), GTK_SHADOW_IN );
653
654 gtk_widget_add_events( GTK_WIDGET(m_text), GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK );
655
656 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
657 #else // GTK+ 1
658 // create our control ...
659 m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
660
661 // ... and put into the upper left hand corner of the table
662 bool bHasHScrollbar = false;
663 m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
664 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
665 gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
666 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
667 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
668 0, 0);
669
670 // always wrap words
671 gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
672
673 // finally, put the vertical scrollbar in the upper right corner
674 m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
675 GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
676 gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
677 GTK_FILL,
678 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
679 0, 0);
680 #endif // GTK+ 2/1
681 }
682 else
683 {
684 // a single-line text control: no need for scrollbars
685 m_widget =
686 m_text = gtk_entry_new();
687
688 #ifdef __WXGTK20__
689 if (style & wxNO_BORDER)
690 g_object_set( GTK_ENTRY(m_text), "has-frame", FALSE, NULL );
691 #endif
692 }
693
694 m_parent->DoAddChild( this );
695
696 m_focusWidget = m_text;
697
698 PostCreation(size);
699
700 if (multi_line)
701 gtk_widget_show(m_text);
702
703 #ifndef __WXGTK20__
704 if (multi_line)
705 {
706 gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
707 (GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
708
709 // only initialize gs_gtk_text_draw once, starting from the next the
710 // klass::draw will already be wxgtk_text_draw
711 if ( !gs_gtk_text_draw )
712 {
713 GtkDrawCallback&
714 draw = GTK_WIDGET_CLASS(GTK_OBJECT(m_text)->klass)->draw;
715
716 gs_gtk_text_draw = draw;
717
718 draw = wxgtk_text_draw;
719 }
720 }
721 #endif // GTK+ 1.x
722
723 if (!value.empty())
724 {
725 #ifdef __WXGTK20__
726 SetValue( value );
727 #else
728
729 #if !GTK_CHECK_VERSION(1, 2, 0)
730 // if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
731 // gtk_editable_insert_text()
732 gtk_widget_realize(m_text);
733 #endif // GTK 1.0
734
735 gint tmp = 0;
736 #if wxUSE_UNICODE
737 wxWX2MBbuf val = value.mbc_str();
738 gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp );
739 #else
740 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
741 #endif
742
743 if (multi_line)
744 {
745 // Bring editable's cursor uptodate. Bug in GTK.
746 SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
747 }
748
749 #endif
750 }
751
752 if (style & wxTE_PASSWORD)
753 {
754 if (!multi_line)
755 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
756 }
757
758 if (style & wxTE_READONLY)
759 {
760 if (!multi_line)
761 gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
762 #ifdef __WXGTK20__
763 else
764 gtk_text_view_set_editable( GTK_TEXT_VIEW( m_text), FALSE);
765 #else
766 }
767 else
768 {
769 if (multi_line)
770 gtk_text_set_editable( GTK_TEXT(m_text), 1 );
771 #endif
772 }
773
774 #ifdef __WXGTK20__
775 if (multi_line)
776 {
777 if (style & wxTE_RIGHT)
778 gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text), GTK_JUSTIFY_RIGHT );
779 else if (style & wxTE_CENTRE)
780 gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text), GTK_JUSTIFY_CENTER );
781 // Left justify (alignment) is the default and we don't need to apply GTK_JUSTIFY_LEFT
782 }
783 else
784 {
785 #ifdef __WXGTK24__
786 // gtk_entry_set_alignment was introduced in gtk+-2.3.5
787 if (!gtk_check_version(2,4,0))
788 {
789 if (style & wxTE_RIGHT)
790 gtk_entry_set_alignment( GTK_ENTRY(m_text), 1.0 );
791 else if (style & wxTE_CENTRE)
792 gtk_entry_set_alignment( GTK_ENTRY(m_text), 0.5 );
793 }
794 #endif
795 }
796 #endif // __WXGTK20__
797
798 // We want to be notified about text changes.
799 #ifdef __WXGTK20__
800 if (multi_line)
801 {
802 g_signal_connect( G_OBJECT(m_buffer), "changed",
803 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
804
805 // .. and handle URLs on multi-line controls with wxTE_AUTO_URL style
806 if (style & wxTE_AUTO_URL)
807 {
808 GtkTextIter start, end;
809 m_gdkHandCursor = gdk_cursor_new(GDK_HAND2);
810 m_gdkXTermCursor = gdk_cursor_new(GDK_XTERM);
811
812 // We create our wxUrl tag here for slight efficiency gain - we
813 // don't have to check for the tag existance in callbacks,
814 // hereby it's guaranteed to exist.
815 gtk_text_buffer_create_tag(m_buffer, "wxUrl",
816 "foreground", "blue",
817 "underline", PANGO_UNDERLINE_SINGLE,
818 NULL);
819
820 // Check for URLs after each text change
821 g_signal_connect_after( G_OBJECT(m_buffer), "insert_text",
822 GTK_SIGNAL_FUNC(au_insert_text_callback), (gpointer)this);
823 g_signal_connect_after( G_OBJECT(m_buffer), "delete_range",
824 GTK_SIGNAL_FUNC(au_delete_range_callback), (gpointer)this);
825
826 // Block all wxUrl tag applying unless we do it ourselves, in which case we
827 // block this callback temporarily. This takes care of gtk+ internal
828 // gtk_text_buffer_insert_range* calls that would copy our URL tag otherwise,
829 // which is undesired because only a part of the URL might be copied.
830 // The insert-text signal emitted inside it will take care of newly formed
831 // or wholly copied URLs.
832 g_signal_connect( G_OBJECT(m_buffer), "apply_tag",
833 GTK_SIGNAL_FUNC(au_apply_tag_callback), NULL);
834
835 // Check for URLs in the initial string passed to Create
836 gtk_text_buffer_get_start_iter(m_buffer, &start);
837 gtk_text_buffer_get_end_iter(m_buffer, &end);
838 au_check_range(&start, &end);
839 }
840 }
841 else
842 #endif
843
844 {
845 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
846 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
847 }
848
849 m_cursor = wxCursor( wxCURSOR_IBEAM );
850
851 wxTextAttr attrDef(GetForegroundColour(), GetBackgroundColour(), GetFont());
852 SetDefaultStyle( attrDef );
853
854 return true;
855 }
856
857
858 void wxTextCtrl::CalculateScrollbar()
859 {
860 #ifndef __WXGTK20__
861 if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
862
863 GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
864
865 if (adj->upper - adj->page_size < 0.8)
866 {
867 if (m_vScrollbarVisible)
868 {
869 gtk_widget_hide( m_vScrollbar );
870 m_vScrollbarVisible = false;
871 }
872 }
873 else
874 {
875 if (!m_vScrollbarVisible)
876 {
877 gtk_widget_show( m_vScrollbar );
878 m_vScrollbarVisible = true;
879 }
880 }
881 #endif
882 }
883
884 wxString wxTextCtrl::GetValue() const
885 {
886 wxCHECK_MSG( m_text != NULL, wxEmptyString, wxT("invalid text ctrl") );
887
888 wxString tmp;
889 if (m_windowStyle & wxTE_MULTILINE)
890 {
891 #ifdef __WXGTK20__
892 GtkTextIter start;
893 gtk_text_buffer_get_start_iter( m_buffer, &start );
894 GtkTextIter end;
895 gtk_text_buffer_get_end_iter( m_buffer, &end );
896 gchar *text = gtk_text_buffer_get_text( m_buffer, &start, &end, TRUE );
897
898 #if wxUSE_UNICODE
899 wxWCharBuffer buffer( wxConvUTF8.cMB2WX( text ) );
900 #else
901 wxCharBuffer buffer( wxConvLocal.cWC2WX( wxConvUTF8.cMB2WC( text ) ) );
902 #endif
903 if ( buffer )
904 tmp = buffer;
905
906 g_free( text );
907 #else
908 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
909 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
910 tmp = text;
911 g_free( text );
912 #endif
913 }
914 else
915 {
916 tmp = wxGTK_CONV_BACK( gtk_entry_get_text( GTK_ENTRY(m_text) ) );
917 }
918
919 return tmp;
920 }
921
922 void wxTextCtrl::SetValue( const wxString &value )
923 {
924 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
925
926 if (m_windowStyle & wxTE_MULTILINE)
927 {
928 #ifdef __WXGTK20__
929
930 #if wxUSE_UNICODE
931 wxCharBuffer buffer( wxConvUTF8.cWX2MB( value) );
932 #else
933 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( value ) ) );
934 #endif
935 if (gtk_text_buffer_get_char_count(m_buffer) != 0)
936 IgnoreNextTextUpdate();
937
938 if ( !buffer )
939 {
940 // what else can we do? at least don't crash...
941 return;
942 }
943
944 gtk_text_buffer_set_text( m_buffer, buffer, strlen(buffer) );
945
946 #else
947 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
948 gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
949 len = 0;
950 gtk_editable_insert_text( GTK_EDITABLE(m_text), value.mbc_str(), value.Length(), &len );
951 #endif
952 }
953 else
954 {
955 gtk_entry_set_text( GTK_ENTRY(m_text), wxGTK_CONV( value ) );
956 }
957
958 // GRG, Jun/2000: Changed this after a lot of discussion in
959 // the lists. wxWidgets 2.2 will have a set of flags to
960 // customize this behaviour.
961 SetInsertionPoint(0);
962
963 m_modified = false;
964 }
965
966 void wxTextCtrl::WriteText( const wxString &text )
967 {
968 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
969
970 if ( text.empty() )
971 return;
972
973 // gtk_text_changed_callback() will set m_modified to true but m_modified
974 // shouldn't be changed by the program writing to the text control itself,
975 // so save the old value and restore when we're done
976 bool oldModified = m_modified;
977
978 if ( m_windowStyle & wxTE_MULTILINE )
979 {
980 #ifdef __WXGTK20__
981
982 #if wxUSE_UNICODE
983 wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
984 #else
985 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
986 #endif
987 if ( !buffer )
988 {
989 // what else can we do? at least don't crash...
990 return;
991 }
992
993 // TODO: Call whatever is needed to delete the selection.
994 wxGtkTextInsert( m_text, m_buffer, m_defaultStyle, buffer );
995
996 GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(m_widget) );
997 // Scroll to cursor, but only if scrollbar thumb is at the very bottom
998 if ( adj->value == adj->upper - adj->page_size )
999 {
1000 gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text),
1001 gtk_text_buffer_get_insert( m_buffer ), 0.0, FALSE, 0.0, 1.0 );
1002 }
1003 #else // GTK 1.x
1004 // After cursor movements, gtk_text_get_point() is wrong by one.
1005 gtk_text_set_point( GTK_TEXT(m_text), GET_EDITABLE_POS(m_text) );
1006
1007 // always use m_defaultStyle, even if it is empty as otherwise
1008 // resetting the style and appending some more text wouldn't work: if
1009 // we don't specify the style explicitly, the old style would be used
1010 gtk_editable_delete_selection( GTK_EDITABLE(m_text) );
1011 wxGtkTextInsert(m_text, m_defaultStyle, text.c_str(), text.Len());
1012
1013 // we called wxGtkTextInsert with correct font, no need to do anything
1014 // in UpdateFontIfNeeded() any longer
1015 if ( !text.empty() )
1016 {
1017 SetUpdateFont(false);
1018 }
1019
1020 // Bring editable's cursor back uptodate.
1021 SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
1022 #endif // GTK 1.x/2.0
1023 }
1024 else // single line
1025 {
1026 // First remove the selection if there is one
1027 gtk_editable_delete_selection( GTK_EDITABLE(m_text) );
1028
1029 // This moves the cursor pos to behind the inserted text.
1030 gint len = GET_EDITABLE_POS(m_text);
1031
1032 #ifdef __WXGTK20__
1033
1034 #if wxUSE_UNICODE
1035 wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
1036 #else
1037 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
1038 #endif
1039 if ( !buffer )
1040 {
1041 // what else can we do? at least don't crash...
1042 return;
1043 }
1044
1045 gtk_editable_insert_text( GTK_EDITABLE(m_text), buffer, strlen(buffer), &len );
1046
1047 #else
1048 gtk_editable_insert_text( GTK_EDITABLE(m_text), text.c_str(), text.Len(), &len );
1049 #endif
1050
1051 // Bring entry's cursor uptodate.
1052 gtk_entry_set_position( GTK_ENTRY(m_text), len );
1053 }
1054
1055 m_modified = oldModified;
1056 }
1057
1058 void wxTextCtrl::AppendText( const wxString &text )
1059 {
1060 SetInsertionPointEnd();
1061 WriteText( text );
1062 }
1063
1064 wxString wxTextCtrl::GetLineText( long lineNo ) const
1065 {
1066 if (m_windowStyle & wxTE_MULTILINE)
1067 {
1068 #ifndef __WXGTK20__
1069 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
1070 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
1071
1072 if (text)
1073 {
1074 wxString buf;
1075 long i;
1076 int currentLine = 0;
1077 for (i = 0; currentLine != lineNo && text[i]; i++ )
1078 if (text[i] == '\n')
1079 currentLine++;
1080 // Now get the text
1081 int j;
1082 for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
1083 buf += text[i];
1084
1085 g_free( text );
1086 return buf;
1087 }
1088 else
1089 {
1090 return wxEmptyString;
1091 }
1092 #else
1093 GtkTextIter line;
1094 gtk_text_buffer_get_iter_at_line(m_buffer,&line,lineNo);
1095 GtkTextIter end;
1096 gtk_text_buffer_get_end_iter(m_buffer,&end );
1097 gchar *text = gtk_text_buffer_get_text(m_buffer,&line,&end,TRUE);
1098 wxString result(wxGTK_CONV_BACK(text));
1099 g_free(text);
1100 return result.BeforeFirst(wxT('\n'));
1101 #endif
1102 }
1103 else
1104 {
1105 if (lineNo == 0) return GetValue();
1106 return wxEmptyString;
1107 }
1108 }
1109
1110 void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
1111 {
1112 /* If you implement this, don't forget to update the documentation!
1113 * (file docs/latex/wx/text.tex) */
1114 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
1115 }
1116
1117 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
1118 {
1119 if ( m_windowStyle & wxTE_MULTILINE )
1120 {
1121 wxString text = GetValue();
1122
1123 // cast to prevent warning. But pos really should've been unsigned.
1124 if( (unsigned long)pos > text.Len() )
1125 return false;
1126
1127 *x=0; // First Col
1128 *y=0; // First Line
1129
1130 const wxChar* stop = text.c_str() + pos;
1131 for ( const wxChar *p = text.c_str(); p < stop; p++ )
1132 {
1133 if (*p == wxT('\n'))
1134 {
1135 (*y)++;
1136 *x=0;
1137 }
1138 else
1139 (*x)++;
1140 }
1141 }
1142 else // single line control
1143 {
1144 if ( pos <= GTK_ENTRY(m_text)->text_length )
1145 {
1146 *y = 0;
1147 *x = pos;
1148 }
1149 else
1150 {
1151 // index out of bounds
1152 return false;
1153 }
1154 }
1155
1156 return true;
1157 }
1158
1159 long wxTextCtrl::XYToPosition(long x, long y ) const
1160 {
1161 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
1162
1163 long pos=0;
1164 for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
1165
1166 pos += x;
1167 return pos;
1168 }
1169
1170 int wxTextCtrl::GetLineLength(long lineNo) const
1171 {
1172 wxString str = GetLineText (lineNo);
1173 return (int) str.Length();
1174 }
1175
1176 int wxTextCtrl::GetNumberOfLines() const
1177 {
1178 if (m_windowStyle & wxTE_MULTILINE)
1179 {
1180 #ifdef __WXGTK20__
1181 return gtk_text_buffer_get_line_count( m_buffer );
1182 #else
1183 gint len = gtk_text_get_length( GTK_TEXT(m_text) );
1184 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
1185
1186 if (text)
1187 {
1188 int currentLine = 0;
1189 for (int i = 0; i < len; i++ )
1190 {
1191 if (text[i] == '\n')
1192 currentLine++;
1193 }
1194 g_free( text );
1195
1196 // currentLine is 0 based, add 1 to get number of lines
1197 return currentLine + 1;
1198 }
1199 else
1200 {
1201 return 0;
1202 }
1203 #endif
1204 }
1205 else
1206 {
1207 return 1;
1208 }
1209 }
1210
1211 void wxTextCtrl::SetInsertionPoint( long pos )
1212 {
1213 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1214
1215 if ( IsMultiLine() )
1216 {
1217 #ifdef __WXGTK20__
1218 GtkTextIter iter;
1219 gtk_text_buffer_get_iter_at_offset( m_buffer, &iter, pos );
1220 gtk_text_buffer_place_cursor( m_buffer, &iter );
1221 gtk_text_view_scroll_mark_onscreen
1222 (
1223 GTK_TEXT_VIEW(m_text),
1224 gtk_text_buffer_get_insert( m_buffer )
1225 );
1226 #else // GTK+ 1.x
1227 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
1228 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
1229
1230 /* we fake a set_point by inserting and deleting. as the user
1231 isn't supposed to get to know about this non-sense, we
1232 disconnect so that no events are sent to the user program. */
1233
1234 gint tmp = (gint)pos;
1235 gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
1236 gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
1237
1238 gtk_signal_connect( GTK_OBJECT(m_text), "changed",
1239 GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
1240
1241 // bring editable's cursor uptodate. Bug in GTK.
1242 SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
1243 #endif // GTK+ 2/1
1244 }
1245 else
1246 {
1247 gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
1248
1249 // Bring editable's cursor uptodate. Bug in GTK.
1250 SET_EDITABLE_POS(m_text, (guint32)pos);
1251 }
1252 }
1253
1254 void wxTextCtrl::SetInsertionPointEnd()
1255 {
1256 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1257
1258 if (m_windowStyle & wxTE_MULTILINE)
1259 {
1260 #ifdef __WXGTK20__
1261 GtkTextIter end;
1262 gtk_text_buffer_get_end_iter( m_buffer, &end );
1263 gtk_text_buffer_place_cursor( m_buffer, &end );
1264 #else
1265 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
1266 #endif
1267 }
1268 else
1269 {
1270 gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
1271 }
1272 }
1273
1274 void wxTextCtrl::SetEditable( bool editable )
1275 {
1276 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1277
1278 if (m_windowStyle & wxTE_MULTILINE)
1279 {
1280 #ifdef __WXGTK20__
1281 gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text), editable );
1282 #else
1283 gtk_text_set_editable( GTK_TEXT(m_text), editable );
1284 #endif
1285 }
1286 else
1287 {
1288 gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
1289 }
1290 }
1291
1292 bool wxTextCtrl::Enable( bool enable )
1293 {
1294 if (!wxWindowBase::Enable(enable))
1295 {
1296 // nothing to do
1297 return false;
1298 }
1299
1300 if (m_windowStyle & wxTE_MULTILINE)
1301 {
1302 #ifdef __WXGTK20__
1303 SetEditable( enable );
1304 #else
1305 gtk_text_set_editable( GTK_TEXT(m_text), enable );
1306 OnParentEnable(enable);
1307 #endif
1308 }
1309 else
1310 {
1311 gtk_widget_set_sensitive( m_text, enable );
1312 }
1313
1314 return true;
1315 }
1316
1317 // wxGTK-specific: called recursively by Enable,
1318 // to give widgets an oppprtunity to correct their colours after they
1319 // have been changed by Enable
1320 void wxTextCtrl::OnParentEnable( bool enable )
1321 {
1322 // If we have a custom background colour, we use this colour in both
1323 // disabled and enabled mode, or we end up with a different colour under the
1324 // text.
1325 wxColour oldColour = GetBackgroundColour();
1326 if (oldColour.Ok())
1327 {
1328 // Need to set twice or it'll optimize the useful stuff out
1329 if (oldColour == * wxWHITE)
1330 SetBackgroundColour(*wxBLACK);
1331 else
1332 SetBackgroundColour(*wxWHITE);
1333 SetBackgroundColour(oldColour);
1334 }
1335 }
1336
1337 void wxTextCtrl::MarkDirty()
1338 {
1339 m_modified = true;
1340 }
1341
1342 void wxTextCtrl::DiscardEdits()
1343 {
1344 m_modified = false;
1345 }
1346
1347 // ----------------------------------------------------------------------------
1348 // max text length support
1349 // ----------------------------------------------------------------------------
1350
1351 void wxTextCtrl::IgnoreNextTextUpdate()
1352 {
1353 m_ignoreNextUpdate = true;
1354 }
1355
1356 bool wxTextCtrl::IgnoreTextUpdate()
1357 {
1358 if ( m_ignoreNextUpdate )
1359 {
1360 m_ignoreNextUpdate = false;
1361
1362 return true;
1363 }
1364
1365 return false;
1366 }
1367
1368 void wxTextCtrl::SetMaxLength(unsigned long len)
1369 {
1370 if ( !HasFlag(wxTE_MULTILINE) )
1371 {
1372 gtk_entry_set_max_length(GTK_ENTRY(m_text), len);
1373
1374 // there is a bug in GTK+ 1.2.x: "changed" signal is emitted even if
1375 // we had tried to enter more text than allowed by max text length and
1376 // the text wasn't really changed
1377 //
1378 // to detect this and generate TEXT_MAXLEN event instead of
1379 // TEXT_CHANGED one in this case we also catch "insert_text" signal
1380 //
1381 // when max len is set to 0 we disconnect our handler as it means that
1382 // we shouldn't check anything any more
1383 if ( len )
1384 {
1385 gtk_signal_connect( GTK_OBJECT(m_text),
1386 "insert_text",
1387 GTK_SIGNAL_FUNC(gtk_insert_text_callback),
1388 (gpointer)this);
1389 }
1390 else // no checking
1391 {
1392 gtk_signal_disconnect_by_func
1393 (
1394 GTK_OBJECT(m_text),
1395 GTK_SIGNAL_FUNC(gtk_insert_text_callback),
1396 (gpointer)this
1397 );
1398 }
1399 }
1400 }
1401
1402 void wxTextCtrl::SetSelection( long from, long to )
1403 {
1404 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1405
1406 if (from == -1 && to == -1)
1407 {
1408 from = 0;
1409 to = GetValue().Length();
1410 }
1411
1412 #ifndef __WXGTK20__
1413 if ( (m_windowStyle & wxTE_MULTILINE) &&
1414 !GTK_TEXT(m_text)->line_start_cache )
1415 {
1416 // tell the programmer that it didn't work
1417 wxLogDebug(_T("Can't call SetSelection() before realizing the control"));
1418 return;
1419 }
1420 #endif
1421
1422 if (m_windowStyle & wxTE_MULTILINE)
1423 {
1424 #ifdef __WXGTK20__
1425 GtkTextIter fromi, toi;
1426 gtk_text_buffer_get_iter_at_offset( m_buffer, &fromi, from );
1427 gtk_text_buffer_get_iter_at_offset( m_buffer, &toi, to );
1428
1429 gtk_text_buffer_place_cursor( m_buffer, &toi );
1430 gtk_text_buffer_move_mark_by_name( m_buffer, "selection_bound", &fromi );
1431 #else
1432 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1433 #endif
1434 }
1435 else
1436 {
1437 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1438 }
1439 }
1440
1441 void wxTextCtrl::ShowPosition( long pos )
1442 {
1443 if (m_windowStyle & wxTE_MULTILINE)
1444 {
1445 #ifdef __WXGTK20__
1446 GtkTextIter iter;
1447 gtk_text_buffer_get_start_iter( m_buffer, &iter );
1448 gtk_text_iter_set_offset( &iter, pos );
1449 GtkTextMark *mark = gtk_text_buffer_create_mark( m_buffer, NULL, &iter, TRUE );
1450 gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text), mark, 0.0, FALSE, 0.0, 0.0 );
1451 #else // GTK 1.x
1452 GtkAdjustment *vp = GTK_TEXT(m_text)->vadj;
1453 float totalLines = (float) GetNumberOfLines();
1454 long posX;
1455 long posY;
1456 PositionToXY(pos, &posX, &posY);
1457 float posLine = (float) posY;
1458 float p = (posLine/totalLines)*(vp->upper - vp->lower) + vp->lower;
1459 gtk_adjustment_set_value(GTK_TEXT(m_text)->vadj, p);
1460 #endif // GTK 1.x/2.x
1461 }
1462 }
1463
1464 #ifdef __WXGTK20__
1465
1466 wxTextCtrlHitTestResult
1467 wxTextCtrl::HitTest(const wxPoint& pt, long *pos) const
1468 {
1469 if ( !IsMultiLine() )
1470 {
1471 // not supported
1472 return wxTE_HT_UNKNOWN;
1473 }
1474
1475 int x, y;
1476 gtk_text_view_window_to_buffer_coords
1477 (
1478 GTK_TEXT_VIEW(m_text),
1479 GTK_TEXT_WINDOW_TEXT,
1480 pt.x, pt.y,
1481 &x, &y
1482 );
1483
1484 GtkTextIter iter;
1485 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &iter, x, y);
1486 if ( pos )
1487 *pos = gtk_text_iter_get_offset(&iter);
1488
1489 return wxTE_HT_ON_TEXT;
1490 }
1491
1492 #endif // __WXGTK20__
1493
1494 long wxTextCtrl::GetInsertionPoint() const
1495 {
1496 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1497
1498 #ifdef __WXGTK20__
1499 if (m_windowStyle & wxTE_MULTILINE)
1500 {
1501 // There is no direct accessor for the cursor, but
1502 // internally, the cursor is the "mark" called
1503 // "insert" in the text view's btree structure.
1504
1505 GtkTextMark *mark = gtk_text_buffer_get_insert( m_buffer );
1506 GtkTextIter cursor;
1507 gtk_text_buffer_get_iter_at_mark( m_buffer, &cursor, mark );
1508
1509 return gtk_text_iter_get_offset( &cursor );
1510 }
1511 else
1512 #endif
1513 {
1514 return (long) GET_EDITABLE_POS(m_text);
1515 }
1516 }
1517
1518 wxTextPos wxTextCtrl::GetLastPosition() const
1519 {
1520 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1521
1522 int pos = 0;
1523
1524 if (m_windowStyle & wxTE_MULTILINE)
1525 {
1526 #ifdef __WXGTK20__
1527 GtkTextIter end;
1528 gtk_text_buffer_get_end_iter( m_buffer, &end );
1529
1530 pos = gtk_text_iter_get_offset( &end );
1531 #else
1532 pos = gtk_text_get_length( GTK_TEXT(m_text) );
1533 #endif
1534 }
1535 else
1536 {
1537 pos = GTK_ENTRY(m_text)->text_length;
1538 }
1539
1540 return (long)pos;
1541 }
1542
1543 void wxTextCtrl::Remove( long from, long to )
1544 {
1545 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1546
1547 #ifdef __WXGTK20__
1548 if (m_windowStyle & wxTE_MULTILINE)
1549 {
1550 GtkTextIter fromi, toi;
1551 gtk_text_buffer_get_iter_at_offset( m_buffer, &fromi, from );
1552 gtk_text_buffer_get_iter_at_offset( m_buffer, &toi, to );
1553
1554 gtk_text_buffer_delete( m_buffer, &fromi, &toi );
1555 }
1556 else // single line
1557 #endif
1558 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1559 }
1560
1561 void wxTextCtrl::Replace( long from, long to, const wxString &value )
1562 {
1563 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1564
1565 Remove( from, to );
1566
1567 if (!value.empty())
1568 {
1569 #ifdef __WXGTK20__
1570 SetInsertionPoint( from );
1571 WriteText( value );
1572 #else // GTK 1.x
1573 gint pos = (gint)from;
1574 #if wxUSE_UNICODE
1575 wxWX2MBbuf buf = value.mbc_str();
1576 gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &pos );
1577 #else
1578 gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
1579 #endif // wxUSE_UNICODE
1580 #endif // GTK 1.x/2.x
1581 }
1582 }
1583
1584 void wxTextCtrl::Cut()
1585 {
1586 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1587
1588 #ifdef __WXGTK20__
1589 if (m_windowStyle & wxTE_MULTILINE)
1590 g_signal_emit_by_name(m_text, "cut-clipboard");
1591 else
1592 #endif
1593 gtk_editable_cut_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1594 }
1595
1596 void wxTextCtrl::Copy()
1597 {
1598 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1599
1600 #ifdef __WXGTK20__
1601 if (m_windowStyle & wxTE_MULTILINE)
1602 g_signal_emit_by_name(m_text, "copy-clipboard");
1603 else
1604 #endif
1605 gtk_editable_copy_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1606 }
1607
1608 void wxTextCtrl::Paste()
1609 {
1610 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1611
1612 #ifdef __WXGTK20__
1613 if (m_windowStyle & wxTE_MULTILINE)
1614 g_signal_emit_by_name(m_text, "paste-clipboard");
1615 else
1616 #endif
1617 gtk_editable_paste_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1618 }
1619
1620 // Undo/redo
1621 void wxTextCtrl::Undo()
1622 {
1623 // TODO
1624 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1625 }
1626
1627 void wxTextCtrl::Redo()
1628 {
1629 // TODO
1630 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1631 }
1632
1633 bool wxTextCtrl::CanUndo() const
1634 {
1635 // TODO
1636 //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1637 return false;
1638 }
1639
1640 bool wxTextCtrl::CanRedo() const
1641 {
1642 // TODO
1643 //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1644 return false;
1645 }
1646
1647 // If the return values from and to are the same, there is no
1648 // selection.
1649 void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
1650 {
1651 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1652
1653 gint from = -1;
1654 gint to = -1;
1655 bool haveSelection = false;
1656
1657 #ifdef __WXGTK20__
1658 if (m_windowStyle & wxTE_MULTILINE)
1659 {
1660 GtkTextIter ifrom, ito;
1661 if ( gtk_text_buffer_get_selection_bounds(m_buffer, &ifrom, &ito) )
1662 {
1663 haveSelection = true;
1664 from = gtk_text_iter_get_offset(&ifrom);
1665 to = gtk_text_iter_get_offset(&ito);
1666 }
1667 }
1668 else // not multi-line
1669 {
1670 if ( gtk_editable_get_selection_bounds( GTK_EDITABLE(m_text),
1671 &from, &to) )
1672 {
1673 haveSelection = true;
1674 }
1675 }
1676 #else // not GTK2
1677 if ( (GTK_EDITABLE(m_text)->has_selection) )
1678 {
1679 haveSelection = true;
1680 from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
1681 to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
1682 }
1683 #endif
1684
1685 if (! haveSelection )
1686 from = to = GetInsertionPoint();
1687
1688 if ( from > to )
1689 {
1690 // exchange them to be compatible with wxMSW
1691 gint tmp = from;
1692 from = to;
1693 to = tmp;
1694 }
1695
1696 if ( fromOut )
1697 *fromOut = from;
1698 if ( toOut )
1699 *toOut = to;
1700 }
1701
1702
1703 bool wxTextCtrl::IsEditable() const
1704 {
1705 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
1706
1707 #ifdef __WXGTK20__
1708 if (m_windowStyle & wxTE_MULTILINE)
1709 {
1710 return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text));
1711 }
1712 else
1713 {
1714 return gtk_editable_get_editable(GTK_EDITABLE(m_text));
1715 }
1716 #else
1717 return GTK_EDITABLE(m_text)->editable;
1718 #endif
1719 }
1720
1721 bool wxTextCtrl::IsModified() const
1722 {
1723 return m_modified;
1724 }
1725
1726 void wxTextCtrl::Clear()
1727 {
1728 SetValue( wxEmptyString );
1729 }
1730
1731 void wxTextCtrl::OnChar( wxKeyEvent &key_event )
1732 {
1733 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1734
1735 if ((key_event.GetKeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1736 {
1737 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1738 event.SetEventObject(this);
1739 event.SetString(GetValue());
1740 if (GetEventHandler()->ProcessEvent(event)) return;
1741 }
1742
1743 if ((key_event.GetKeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1744 {
1745 // This will invoke the dialog default action, such
1746 // as the clicking the default button.
1747
1748 wxWindow *top_frame = m_parent;
1749 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1750 top_frame = top_frame->GetParent();
1751
1752 if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1753 {
1754 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1755
1756 if (window->default_widget)
1757 {
1758 gtk_widget_activate (window->default_widget);
1759 return;
1760 }
1761 }
1762 }
1763
1764 key_event.Skip();
1765 }
1766
1767 GtkWidget* wxTextCtrl::GetConnectWidget()
1768 {
1769 return GTK_WIDGET(m_text);
1770 }
1771
1772 bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1773 {
1774 if (m_windowStyle & wxTE_MULTILINE)
1775 {
1776 #ifdef __WXGTK20__
1777 return window == gtk_text_view_get_window( GTK_TEXT_VIEW( m_text ), GTK_TEXT_WINDOW_TEXT ); // pure guesswork
1778 #else
1779 return (window == GTK_TEXT(m_text)->text_area);
1780 #endif
1781 }
1782 else
1783 {
1784 return (window == GTK_ENTRY(m_text)->text_area);
1785 }
1786 }
1787
1788 // the font will change for subsequent text insertiongs
1789 bool wxTextCtrl::SetFont( const wxFont &font )
1790 {
1791 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
1792
1793 if ( !wxTextCtrlBase::SetFont(font) )
1794 {
1795 // font didn't change, nothing to do
1796 return false;
1797 }
1798
1799 if ( m_windowStyle & wxTE_MULTILINE )
1800 {
1801 SetUpdateFont(true);
1802
1803 m_defaultStyle.SetFont(font);
1804
1805 ChangeFontGlobally();
1806 }
1807
1808 return true;
1809 }
1810
1811 void wxTextCtrl::ChangeFontGlobally()
1812 {
1813 // this method is very inefficient and hence should be called as rarely as
1814 // possible!
1815 //
1816 // TODO: it can be implemented much more efficiently for GTK2
1817 #ifndef __WXGTK20__
1818 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1819
1820 _T("shouldn't be called for single line controls") );
1821 #else
1822 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE),
1823 _T("shouldn't be called for single line controls") );
1824 #endif
1825
1826 wxString value = GetValue();
1827 if ( !value.empty() )
1828 {
1829 SetUpdateFont(false);
1830
1831 Clear();
1832 AppendText(value);
1833 }
1834 }
1835
1836 #ifndef __WXGTK20__
1837
1838 void wxTextCtrl::UpdateFontIfNeeded()
1839 {
1840 if ( m_updateFont )
1841 ChangeFontGlobally();
1842 }
1843
1844 #endif // GTK+ 1.x
1845
1846 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1847 {
1848 if ( !wxControl::SetForegroundColour(colour) )
1849 return false;
1850
1851 // update default fg colour too
1852 m_defaultStyle.SetTextColour(colour);
1853
1854 return true;
1855 }
1856
1857 bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1858 {
1859 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
1860
1861 if ( !wxControl::SetBackgroundColour( colour ) )
1862 return false;
1863
1864 #ifndef __WXGTK20__
1865 if (!m_widget->window)
1866 return false;
1867 #endif
1868
1869 if (!m_backgroundColour.Ok())
1870 return false;
1871
1872 if (m_windowStyle & wxTE_MULTILINE)
1873 {
1874 #ifndef __WXGTK20__
1875 GdkWindow *window = GTK_TEXT(m_text)->text_area;
1876 if (!window)
1877 return false;
1878 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1879 gdk_window_set_background( window, m_backgroundColour.GetColor() );
1880 gdk_window_clear( window );
1881 #endif
1882 }
1883
1884 // change active background color too
1885 m_defaultStyle.SetBackgroundColour( colour );
1886
1887 return true;
1888 }
1889
1890 bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
1891 {
1892 if ( m_windowStyle & wxTE_MULTILINE )
1893 {
1894 if ( style.IsDefault() )
1895 {
1896 // nothing to do
1897 return true;
1898 }
1899
1900 #ifdef __WXGTK20__
1901 gint l = gtk_text_buffer_get_char_count( m_buffer );
1902
1903 wxCHECK_MSG( start >= 0 && end <= l, false,
1904 _T("invalid range in wxTextCtrl::SetStyle") );
1905
1906 GtkTextIter starti, endi;
1907 gtk_text_buffer_get_iter_at_offset( m_buffer, &starti, start );
1908 gtk_text_buffer_get_iter_at_offset( m_buffer, &endi, end );
1909
1910 // use the attributes from style which are set in it and fall back
1911 // first to the default style and then to the text control default
1912 // colours for the others
1913 wxTextAttr attr = wxTextAttr::Combine(style, m_defaultStyle, this);
1914
1915 wxGtkTextApplyTagsFromAttr( m_buffer, attr, &starti, &endi );
1916 #else
1917 // VERY dirty way to do that - removes the required text and re-adds it
1918 // with styling (FIXME)
1919
1920 gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1921
1922 wxCHECK_MSG( start >= 0 && end <= l, false,
1923 _T("invalid range in wxTextCtrl::SetStyle") );
1924
1925 gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1926 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1927 wxString tmp(text,*wxConvCurrent);
1928 g_free( text );
1929
1930 gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1931 gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1932
1933 #if wxUSE_UNICODE
1934 wxWX2MBbuf buf = tmp.mbc_str();
1935 const char *txt = buf;
1936 size_t txtlen = strlen(buf);
1937 #else
1938 const char *txt = tmp;
1939 size_t txtlen = tmp.length();
1940 #endif
1941
1942 // use the attributes from style which are set in it and fall back
1943 // first to the default style and then to the text control default
1944 // colours for the others
1945 wxGtkTextInsert(m_text,
1946 wxTextAttr::Combine(style, m_defaultStyle, this),
1947 txt,
1948 txtlen);
1949
1950 /* does not seem to help under GTK+ 1.2 !!!
1951 gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1952 SetInsertionPoint( old_pos );
1953 #endif
1954
1955 return true;
1956 }
1957
1958 // else single line
1959 // cannot do this for GTK+'s Entry widget
1960 return false;
1961 }
1962
1963 void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
1964 {
1965 gtk_widget_modify_style(m_text, style);
1966 }
1967
1968 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1969 {
1970 Cut();
1971 }
1972
1973 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1974 {
1975 Copy();
1976 }
1977
1978 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1979 {
1980 Paste();
1981 }
1982
1983 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1984 {
1985 Undo();
1986 }
1987
1988 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1989 {
1990 Redo();
1991 }
1992
1993 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1994 {
1995 event.Enable( CanCut() );
1996 }
1997
1998 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1999 {
2000 event.Enable( CanCopy() );
2001 }
2002
2003 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2004 {
2005 event.Enable( CanPaste() );
2006 }
2007
2008 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2009 {
2010 event.Enable( CanUndo() );
2011 }
2012
2013 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2014 {
2015 event.Enable( CanRedo() );
2016 }
2017
2018 void wxTextCtrl::OnInternalIdle()
2019 {
2020 wxCursor cursor = m_cursor;
2021 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2022
2023 if (cursor.Ok())
2024 {
2025 #ifndef __WXGTK20__
2026 GdkWindow *window = (GdkWindow*) NULL;
2027 if (HasFlag(wxTE_MULTILINE))
2028 window = GTK_TEXT(m_text)->text_area;
2029 else
2030 window = GTK_ENTRY(m_text)->text_area;
2031
2032 if (window)
2033 gdk_window_set_cursor( window, cursor.GetCursor() );
2034
2035 if (!g_globalCursor.Ok())
2036 cursor = *wxSTANDARD_CURSOR;
2037
2038 window = m_widget->window;
2039 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2040 gdk_window_set_cursor( window, cursor.GetCursor() );
2041 #endif
2042 }
2043
2044 if (g_delayedFocus == this)
2045 {
2046 if (GTK_WIDGET_REALIZED(m_widget))
2047 {
2048 gtk_widget_grab_focus( m_widget );
2049 g_delayedFocus = NULL;
2050 }
2051 }
2052
2053 if (wxUpdateUIEvent::CanUpdate(this))
2054 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2055 }
2056
2057 wxSize wxTextCtrl::DoGetBestSize() const
2058 {
2059 // FIXME should be different for multi-line controls...
2060 wxSize ret( wxControl::DoGetBestSize() );
2061 wxSize best(80, ret.y);
2062 CacheBestSize(best);
2063 return best;
2064 }
2065
2066 // ----------------------------------------------------------------------------
2067 // freeze/thaw
2068 // ----------------------------------------------------------------------------
2069
2070 void wxTextCtrl::Freeze()
2071 {
2072 if ( HasFlag(wxTE_MULTILINE) )
2073 {
2074 #ifdef __WXGTK20__
2075 if ( !m_frozenness++ )
2076 {
2077 // freeze textview updates and remove buffer
2078 g_signal_connect( G_OBJECT(m_text), "expose_event",
2079 GTK_SIGNAL_FUNC(gtk_text_exposed_callback), (gpointer)this);
2080 g_signal_connect( G_OBJECT(m_widget), "expose_event",
2081 GTK_SIGNAL_FUNC(gtk_text_exposed_callback), (gpointer)this);
2082 gtk_widget_set_sensitive(m_widget, false);
2083 g_object_ref(m_buffer);
2084 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), gtk_text_buffer_new(NULL));
2085 }
2086 #else
2087 gtk_text_freeze(GTK_TEXT(m_text));
2088 #endif
2089 }
2090 }
2091
2092 void wxTextCtrl::Thaw()
2093 {
2094 if ( HasFlag(wxTE_MULTILINE) )
2095 {
2096 #ifdef __WXGTK20__
2097 wxASSERT_MSG( m_frozenness > 0, _T("Thaw() without matching Freeze()") );
2098
2099 if ( !--m_frozenness )
2100 {
2101 // Reattach buffer and thaw textview updates
2102 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), m_buffer);
2103 g_object_unref(m_buffer);
2104 gtk_widget_set_sensitive(m_widget, true);
2105 g_signal_handlers_disconnect_by_func(m_widget, (gpointer)gtk_text_exposed_callback, this);
2106 g_signal_handlers_disconnect_by_func(m_text, (gpointer)gtk_text_exposed_callback, this);
2107 }
2108 #else
2109 GTK_TEXT(m_text)->vadj->value = 0.0;
2110
2111 gtk_text_thaw(GTK_TEXT(m_text));
2112 #endif
2113 }
2114 }
2115
2116 // ----------------------------------------------------------------------------
2117 // wxTextUrlEvent passing if style & wxTE_AUTO_URL
2118 // ----------------------------------------------------------------------------
2119
2120 #ifdef __WXGTK20__
2121
2122 // FIXME: when dragging on a link the sample gets an "Unknown event".
2123 // This might be an excessive event from us or a buggy wxMouseEvent::Moving() or
2124 // a buggy sample, or something else
2125 void wxTextCtrl::OnUrlMouseEvent(wxMouseEvent& event)
2126 {
2127 event.Skip();
2128 if(!(m_windowStyle & wxTE_AUTO_URL))
2129 return;
2130
2131 gint x, y;
2132 GtkTextIter start, end;
2133 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(m_buffer),
2134 "wxUrl");
2135
2136 gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(m_text), GTK_TEXT_WINDOW_WIDGET,
2137 event.GetX(), event.GetY(), &x, &y);
2138
2139 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &end, x, y);
2140 if (!gtk_text_iter_has_tag(&end, tag))
2141 {
2142 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
2143 GTK_TEXT_WINDOW_TEXT), m_gdkXTermCursor);
2144 return;
2145 }
2146
2147 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
2148 GTK_TEXT_WINDOW_TEXT), m_gdkHandCursor);
2149
2150 start = end;
2151 if(!gtk_text_iter_begins_tag(&start, tag))
2152 gtk_text_iter_backward_to_tag_toggle(&start, tag);
2153 if(!gtk_text_iter_ends_tag(&end, tag))
2154 gtk_text_iter_forward_to_tag_toggle(&end, tag);
2155
2156 // Native context menu is probably not desired on an URL.
2157 // Consider making this dependant on ProcessEvent(wxTextUrlEvent) return value
2158 if(event.GetEventType() == wxEVT_RIGHT_DOWN)
2159 event.Skip(false);
2160
2161 wxTextUrlEvent url_event(m_windowId, event,
2162 gtk_text_iter_get_offset(&start),
2163 gtk_text_iter_get_offset(&end));
2164
2165 InitCommandEvent(url_event);
2166 // Is that a good idea? Seems not (pleasure with gtk_text_view_start_selection_drag)
2167 //event.Skip(!GetEventHandler()->ProcessEvent(url_event));
2168 GetEventHandler()->ProcessEvent(url_event);
2169 }
2170 #endif // gtk2
2171
2172 // ----------------------------------------------------------------------------
2173 // scrolling
2174 // ----------------------------------------------------------------------------
2175
2176 GtkAdjustment *wxTextCtrl::GetVAdj() const
2177 {
2178 if ( !IsMultiLine() )
2179 return NULL;
2180
2181 #ifdef __WXGTK20__
2182 return gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(m_widget));
2183 #else
2184 return GTK_TEXT(m_text)->vadj;
2185 #endif
2186 }
2187
2188 bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff)
2189 {
2190 float value = adj->value + diff;
2191
2192 if ( value < 0 )
2193 value = 0;
2194
2195 float upper = adj->upper - adj->page_size;
2196 if ( value > upper )
2197 value = upper;
2198
2199 // did we noticeably change the scroll position?
2200 if ( fabs(adj->value - value) < 0.2 )
2201 {
2202 // well, this is what Robert does in wxScrollBar, so it must be good...
2203 return false;
2204 }
2205
2206 adj->value = value;
2207
2208 #ifdef __WXGTK20__
2209 gtk_adjustment_value_changed(GTK_ADJUSTMENT(adj));
2210 #else
2211 gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
2212 #endif
2213
2214 return true;
2215 }
2216
2217 bool wxTextCtrl::ScrollLines(int lines)
2218 {
2219 GtkAdjustment *adj = GetVAdj();
2220 if ( !adj )
2221 return false;
2222
2223 #ifdef __WXGTK20__
2224 int diff = (int)ceil(lines*adj->step_increment);
2225 #else
2226 // this is hardcoded to 10 in GTK+ 1.2 (great idea)
2227 int diff = 10*lines;
2228 #endif
2229
2230 return DoScroll(adj, diff);
2231 }
2232
2233 bool wxTextCtrl::ScrollPages(int pages)
2234 {
2235 GtkAdjustment *adj = GetVAdj();
2236 if ( !adj )
2237 return false;
2238
2239 return DoScroll(adj, (int)ceil(pages*adj->page_increment));
2240 }
2241
2242
2243 // static
2244 wxVisualAttributes
2245 wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
2246 {
2247 return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true);
2248 }
wxWidgets (Impactor)