projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Applied patch [ 1207162 ] wxTextCtrl::SetStyle fix for overlapping calls
[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, wxT(""), 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(wxT(""));
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( wxT("") );
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 #ifdef __WXGTK20__
1900 gint l = gtk_text_buffer_get_char_count( m_buffer );
1901
1902 wxCHECK_MSG( start >= 0 && end <= l, false,
1903 _T("invalid range in wxTextCtrl::SetStyle") );
1904
1905 GtkTextIter starti, endi;
1906 gtk_text_buffer_get_iter_at_offset( m_buffer, &starti, start );
1907 gtk_text_buffer_get_iter_at_offset( m_buffer, &endi, end );
1908
1909 // use the attributes from style which are set in it and fall back
1910 // first to the default style and then to the text control default
1911 // colours for the others
1912 wxTextAttr attr = wxTextAttr::Combine(style, m_defaultStyle, this);
1913
1914 wxGtkTextApplyTagsFromAttr( m_buffer, attr, &starti, &endi );
1915
1916 return true;
1917 #else
1918 // VERY dirty way to do that - removes the required text and re-adds it
1919 // with styling (FIXME)
1920
1921 gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1922
1923 wxCHECK_MSG( start >= 0 && end <= l, false,
1924 _T("invalid range in wxTextCtrl::SetStyle") );
1925
1926 gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1927 char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1928 wxString tmp(text,*wxConvCurrent);
1929 g_free( text );
1930
1931 gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1932 gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1933
1934 #if wxUSE_UNICODE
1935 wxWX2MBbuf buf = tmp.mbc_str();
1936 const char *txt = buf;
1937 size_t txtlen = strlen(buf);
1938 #else
1939 const char *txt = tmp;
1940 size_t txtlen = tmp.length();
1941 #endif
1942
1943 // use the attributes from style which are set in it and fall back
1944 // first to the default style and then to the text control default
1945 // colours for the others
1946 wxGtkTextInsert(m_text,
1947 wxTextAttr::Combine(style, m_defaultStyle, this),
1948 txt,
1949 txtlen);
1950
1951 /* does not seem to help under GTK+ 1.2 !!!
1952 gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1953 SetInsertionPoint( old_pos );
1954 #endif
1955 return true;
1956 }
1957 else // singe line
1958 {
1959 // cannot do this for GTK+'s Entry widget
1960 return false;
1961 }
1962 }
1963
1964 void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
1965 {
1966 gtk_widget_modify_style(m_text, style);
1967 }
1968
1969 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1970 {
1971 Cut();
1972 }
1973
1974 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1975 {
1976 Copy();
1977 }
1978
1979 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1980 {
1981 Paste();
1982 }
1983
1984 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1985 {
1986 Undo();
1987 }
1988
1989 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1990 {
1991 Redo();
1992 }
1993
1994 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1995 {
1996 event.Enable( CanCut() );
1997 }
1998
1999 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2000 {
2001 event.Enable( CanCopy() );
2002 }
2003
2004 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2005 {
2006 event.Enable( CanPaste() );
2007 }
2008
2009 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2010 {
2011 event.Enable( CanUndo() );
2012 }
2013
2014 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2015 {
2016 event.Enable( CanRedo() );
2017 }
2018
2019 void wxTextCtrl::OnInternalIdle()
2020 {
2021 wxCursor cursor = m_cursor;
2022 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2023
2024 if (cursor.Ok())
2025 {
2026 #ifndef __WXGTK20__
2027 GdkWindow *window = (GdkWindow*) NULL;
2028 if (HasFlag(wxTE_MULTILINE))
2029 window = GTK_TEXT(m_text)->text_area;
2030 else
2031 window = GTK_ENTRY(m_text)->text_area;
2032
2033 if (window)
2034 gdk_window_set_cursor( window, cursor.GetCursor() );
2035
2036 if (!g_globalCursor.Ok())
2037 cursor = *wxSTANDARD_CURSOR;
2038
2039 window = m_widget->window;
2040 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2041 gdk_window_set_cursor( window, cursor.GetCursor() );
2042 #endif
2043 }
2044
2045 if (g_delayedFocus == this)
2046 {
2047 if (GTK_WIDGET_REALIZED(m_widget))
2048 {
2049 gtk_widget_grab_focus( m_widget );
2050 g_delayedFocus = NULL;
2051 }
2052 }
2053
2054 if (wxUpdateUIEvent::CanUpdate(this))
2055 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2056 }
2057
2058 wxSize wxTextCtrl::DoGetBestSize() const
2059 {
2060 // FIXME should be different for multi-line controls...
2061 wxSize ret( wxControl::DoGetBestSize() );
2062 wxSize best(80, ret.y);
2063 CacheBestSize(best);
2064 return best;
2065 }
2066
2067 // ----------------------------------------------------------------------------
2068 // freeze/thaw
2069 // ----------------------------------------------------------------------------
2070
2071 void wxTextCtrl::Freeze()
2072 {
2073 if ( HasFlag(wxTE_MULTILINE) )
2074 {
2075 #ifdef __WXGTK20__
2076 if ( !m_frozenness++ )
2077 {
2078 // freeze textview updates and remove buffer
2079 g_signal_connect( G_OBJECT(m_text), "expose_event",
2080 GTK_SIGNAL_FUNC(gtk_text_exposed_callback), (gpointer)this);
2081 g_signal_connect( G_OBJECT(m_widget), "expose_event",
2082 GTK_SIGNAL_FUNC(gtk_text_exposed_callback), (gpointer)this);
2083 gtk_widget_set_sensitive(m_widget, false);
2084 g_object_ref(m_buffer);
2085 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), gtk_text_buffer_new(NULL));
2086 }
2087 #else
2088 gtk_text_freeze(GTK_TEXT(m_text));
2089 #endif
2090 }
2091 }
2092
2093 void wxTextCtrl::Thaw()
2094 {
2095 if ( HasFlag(wxTE_MULTILINE) )
2096 {
2097 #ifdef __WXGTK20__
2098 wxASSERT_MSG( m_frozenness > 0, _T("Thaw() without matching Freeze()") );
2099
2100 if ( !--m_frozenness )
2101 {
2102 // Reattach buffer and thaw textview updates
2103 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), m_buffer);
2104 g_object_unref(m_buffer);
2105 gtk_widget_set_sensitive(m_widget, true);
2106 g_signal_handlers_disconnect_by_func(m_widget, (gpointer)gtk_text_exposed_callback, this);
2107 g_signal_handlers_disconnect_by_func(m_text, (gpointer)gtk_text_exposed_callback, this);
2108 }
2109 #else
2110 GTK_TEXT(m_text)->vadj->value = 0.0;
2111
2112 gtk_text_thaw(GTK_TEXT(m_text));
2113 #endif
2114 }
2115 }
2116
2117 // ----------------------------------------------------------------------------
2118 // wxTextUrlEvent passing if style & wxTE_AUTO_URL
2119 // ----------------------------------------------------------------------------
2120
2121 #ifdef __WXGTK20__
2122
2123 // FIXME: when dragging on a link the sample gets an "Unknown event".
2124 // This might be an excessive event from us or a buggy wxMouseEvent::Moving() or
2125 // a buggy sample, or something else
2126 void wxTextCtrl::OnUrlMouseEvent(wxMouseEvent& event)
2127 {
2128 event.Skip();
2129 if(!(m_windowStyle & wxTE_AUTO_URL))
2130 return;
2131
2132 gint x, y;
2133 GtkTextIter start, end;
2134 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(m_buffer),
2135 "wxUrl");
2136
2137 gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(m_text), GTK_TEXT_WINDOW_WIDGET,
2138 event.GetX(), event.GetY(), &x, &y);
2139
2140 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &end, x, y);
2141 if (!gtk_text_iter_has_tag(&end, tag))
2142 {
2143 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
2144 GTK_TEXT_WINDOW_TEXT), m_gdkXTermCursor);
2145 return;
2146 }
2147
2148 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
2149 GTK_TEXT_WINDOW_TEXT), m_gdkHandCursor);
2150
2151 start = end;
2152 if(!gtk_text_iter_begins_tag(&start, tag))
2153 gtk_text_iter_backward_to_tag_toggle(&start, tag);
2154 if(!gtk_text_iter_ends_tag(&end, tag))
2155 gtk_text_iter_forward_to_tag_toggle(&end, tag);
2156
2157 // Native context menu is probably not desired on an URL.
2158 // Consider making this dependant on ProcessEvent(wxTextUrlEvent) return value
2159 if(event.GetEventType() == wxEVT_RIGHT_DOWN)
2160 event.Skip(false);
2161
2162 wxTextUrlEvent url_event(m_windowId, event,
2163 gtk_text_iter_get_offset(&start),
2164 gtk_text_iter_get_offset(&end));
2165
2166 InitCommandEvent(url_event);
2167 // Is that a good idea? Seems not (pleasure with gtk_text_view_start_selection_drag)
2168 //event.Skip(!GetEventHandler()->ProcessEvent(url_event));
2169 GetEventHandler()->ProcessEvent(url_event);
2170 }
2171 #endif // gtk2
2172
2173 // ----------------------------------------------------------------------------
2174 // scrolling
2175 // ----------------------------------------------------------------------------
2176
2177 GtkAdjustment *wxTextCtrl::GetVAdj() const
2178 {
2179 if ( !IsMultiLine() )
2180 return NULL;
2181
2182 #ifdef __WXGTK20__
2183 return gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(m_widget));
2184 #else
2185 return GTK_TEXT(m_text)->vadj;
2186 #endif
2187 }
2188
2189 bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff)
2190 {
2191 float value = adj->value + diff;
2192
2193 if ( value < 0 )
2194 value = 0;
2195
2196 float upper = adj->upper - adj->page_size;
2197 if ( value > upper )
2198 value = upper;
2199
2200 // did we noticeably change the scroll position?
2201 if ( fabs(adj->value - value) < 0.2 )
2202 {
2203 // well, this is what Robert does in wxScrollBar, so it must be good...
2204 return false;
2205 }
2206
2207 adj->value = value;
2208
2209 #ifdef __WXGTK20__
2210 gtk_adjustment_value_changed(GTK_ADJUSTMENT(adj));
2211 #else
2212 gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
2213 #endif
2214
2215 return true;
2216 }
2217
2218 bool wxTextCtrl::ScrollLines(int lines)
2219 {
2220 GtkAdjustment *adj = GetVAdj();
2221 if ( !adj )
2222 return false;
2223
2224 #ifdef __WXGTK20__
2225 int diff = (int)ceil(lines*adj->step_increment);
2226 #else
2227 // this is hardcoded to 10 in GTK+ 1.2 (great idea)
2228 int diff = 10*lines;
2229 #endif
2230
2231 return DoScroll(adj, diff);
2232 }
2233
2234 bool wxTextCtrl::ScrollPages(int pages)
2235 {
2236 GtkAdjustment *adj = GetVAdj();
2237 if ( !adj )
2238 return false;
2239
2240 return DoScroll(adj, (int)ceil(pages*adj->page_increment));
2241 }
2242
2243
2244 // static
2245 wxVisualAttributes
2246 wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
2247 {
2248 return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true);
2249 }
wxWidgets (Impactor)