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