projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
WinCE friendly wxCheckListBox sample.
[wxWidgets.git] / src / gtk / textctrl.cpp
0 / 1715 (  0%)
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: textctrl.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin, 2005 Mart Raudsepp
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/math.h"
18#include "wx/settings.h"
19#include "wx/panel.h"
20#include "wx/strconv.h"
21#include "wx/fontutil.h" // for wxNativeFontInfo (GetNativeFontInfo())
22
23#include <sys/types.h>
24#include <sys/stat.h>
25#include <ctype.h>
26#include "wx/math.h"
27
28#include "wx/gtk/private.h"
29#include <gdk/gdkkeysyms.h>
30
31//-----------------------------------------------------------------------------
32// idle system
33//-----------------------------------------------------------------------------
34
35extern void wxapp_install_idle_handler();
36extern bool g_isIdle;
37
38//-----------------------------------------------------------------------------
39// data
40//-----------------------------------------------------------------------------
41
42extern wxCursor g_globalCursor;
43extern wxWindowGTK *g_delayedFocus;
44
45// ----------------------------------------------------------------------------
46// helpers
47// ----------------------------------------------------------------------------
48
49extern "C" {
50static 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
67extern "C" {
68static 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
163extern "C" {
164static void wxGtkTextInsert(GtkWidget *text,
165 GtkTextBuffer *text_buffer,
166 const wxTextAttr& attr,
167 const 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
184// ----------------------------------------------------------------------------
185// "insert_text" for GtkEntry
186// ----------------------------------------------------------------------------
187
188extern "C" {
189static void
190gtk_insert_text_callback(GtkEditable *editable,
191 const gchar *new_text,
192 gint new_text_length,
193 gint *position,
194 wxTextCtrl *win)
195{
196 if (g_isIdle)
197 wxapp_install_idle_handler();
198
199 // we should only be called if we have a max len limit at all
200 GtkEntry *entry = GTK_ENTRY (editable);
201
202 wxCHECK_RET( entry->text_max_length, _T("shouldn't be called") );
203
204 // check that we don't overflow the max length limit
205 //
206 // FIXME: this doesn't work when we paste a string which is going to be
207 // truncated
208 if ( entry->text_length == entry->text_max_length )
209 {
210 // we don't need to run the base class version at all
211 g_signal_stop_emission_by_name (editable, "insert_text");
212
213 // remember that the next changed signal is to be ignored to avoid
214 // generating a dummy wxEVT_COMMAND_TEXT_UPDATED event
215 win->IgnoreNextTextUpdate();
216
217 // and generate the correct one ourselves
218 wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, win->GetId());
219 event.SetEventObject(win);
220 event.SetString(win->GetValue());
221 win->GetEventHandler()->ProcessEvent( event );
222 }
223}
224}
225
226// Implementation of wxTE_AUTO_URL for wxGTK2 by Mart Raudsepp,
227
228extern "C" {
229static void
230au_apply_tag_callback(GtkTextBuffer *buffer,
231 GtkTextTag *tag,
232 GtkTextIter *start,
233 GtkTextIter *end,
234 gpointer textctrl)
235{
236 if(tag == gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl"))
237 g_signal_stop_emission_by_name (buffer, "apply_tag");
238}
239}
240
241//-----------------------------------------------------------------------------
242// GtkTextCharPredicates for gtk_text_iter_*_find_char
243//-----------------------------------------------------------------------------
244
245extern "C" {
246static gboolean
247pred_whitespace (gunichar ch, gpointer user_data)
248{
249 return g_unichar_isspace(ch);
250}
251}
252
253extern "C" {
254static gboolean
255pred_non_whitespace (gunichar ch, gpointer user_data)
256{
257 return !g_unichar_isspace(ch);
258}
259}
260
261extern "C" {
262static gboolean
263pred_nonpunct (gunichar ch, gpointer user_data)
264{
265 return !g_unichar_ispunct(ch);
266}
267}
268
269extern "C" {
270static gboolean
271pred_nonpunct_or_slash (gunichar ch, gpointer user_data)
272{
273 return !g_unichar_ispunct(ch) || ch == '/';
274}
275}
276
277//-----------------------------------------------------------------------------
278// Check for links between s and e and correct tags as necessary
279//-----------------------------------------------------------------------------
280
281// This function should be made match better while being efficient at one point.
282// Most probably with a row of regular expressions.
283extern "C" {
284static void
285au_check_word( GtkTextIter *s, GtkTextIter *e )
286{
287 static const char *URIPrefixes[] =
288 {
289 "http://",
290 "ftp://",
291 "www.",
292 "ftp.",
293 "mailto://",
294 "https://",
295 "file://",
296 "nntp://",
297 "news://",
298 "telnet://",
299 "mms://",
300 "gopher://",
301 "prospero://",
302 "wais://",
303 };
304
305 GtkTextIter start = *s, end = *e;
306 GtkTextBuffer *buffer = gtk_text_iter_get_buffer(s);
307
308 // Get our special link tag
309 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl");
310
311 // Get rid of punctuation from beginning and end.
312 // Might want to move this to au_check_range if an improved link checking doesn't
313 // use some intelligent punctuation checking itself (beware of undesired iter modifications).
314 if(g_unichar_ispunct( gtk_text_iter_get_char( &start ) ) )
315 gtk_text_iter_forward_find_char( &start, pred_nonpunct, NULL, e );
316
317 gtk_text_iter_backward_find_char( &end, pred_nonpunct_or_slash, NULL, &start );
318 gtk_text_iter_forward_char(&end);
319
320 gchar* text = gtk_text_iter_get_text( &start, &end );
321 size_t len = strlen(text), prefix_len;
322 size_t n;
323
324 for( n = 0; n < WXSIZEOF(URIPrefixes); ++n )
325 {
326 prefix_len = strlen(URIPrefixes[n]);
327 if((len > prefix_len) && !strncasecmp(text, URIPrefixes[n], prefix_len))
328 break;
329 }
330
331 if(n < WXSIZEOF(URIPrefixes))
332 {
333 gulong signal_id = g_signal_handler_find (buffer,
334 (GSignalMatchType) (G_SIGNAL_MATCH_FUNC),
335 0, 0, NULL,
336 (gpointer)au_apply_tag_callback, NULL);
337
338 g_signal_handler_block (buffer, signal_id);
339 gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
340 g_signal_handler_unblock (buffer, signal_id);
341 }
342}
343}
344
345extern "C" {
346static void
347au_check_range(GtkTextIter *s,
348 GtkTextIter *range_end)
349{
350 GtkTextIter range_start = *s;
351 GtkTextIter word_end;
352 GtkTextBuffer *buffer = gtk_text_iter_get_buffer(s);
353 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl");
354
355 gtk_text_buffer_remove_tag(buffer, tag, s, range_end);
356
357 if(g_unichar_isspace(gtk_text_iter_get_char(&range_start)))
358 gtk_text_iter_forward_find_char(&range_start, pred_non_whitespace, NULL, range_end);
359
360 while(!gtk_text_iter_equal(&range_start, range_end))
361 {
362 word_end = range_start;
363 gtk_text_iter_forward_find_char(&word_end, pred_whitespace, NULL, range_end);
364
365 // Now we should have a word delimited by range_start and word_end, correct link tags
366 au_check_word(&range_start, &word_end);
367
368 range_start = word_end;
369 gtk_text_iter_forward_find_char(&range_start, pred_non_whitespace, NULL, range_end);
370 }
371}
372}
373
374//-----------------------------------------------------------------------------
375// "insert-text" for GtkTextBuffer
376//-----------------------------------------------------------------------------
377
378extern "C" {
379static void
380au_insert_text_callback(GtkTextBuffer *buffer,
381 GtkTextIter *end,
382 gchar *text,
383 gint len,
384 wxTextCtrl *win)
385{
386 if (!len || !(win->GetWindowStyleFlag() & wxTE_AUTO_URL) )
387 return;
388
389 GtkTextIter start = *end;
390 gtk_text_iter_backward_chars(&start, g_utf8_strlen(text, len));
391
392 GtkTextIter line_start = start;
393 GtkTextIter line_end = *end;
394 GtkTextIter words_start = start;
395 GtkTextIter words_end = *end;
396
397 gtk_text_iter_set_line(&line_start, gtk_text_iter_get_line(&start));
398 gtk_text_iter_forward_to_line_end(&line_end);
399 gtk_text_iter_backward_find_char(&words_start, pred_whitespace, NULL, &line_start);
400 gtk_text_iter_forward_find_char(&words_end, pred_whitespace, NULL, &line_end);
401
402 au_check_range(&words_start, &words_end);
403}
404}
405
406//-----------------------------------------------------------------------------
407// "delete-range" for GtkTextBuffer
408//-----------------------------------------------------------------------------
409
410extern "C" {
411static void
412au_delete_range_callback(GtkTextBuffer *buffer,
413 GtkTextIter *start,
414 GtkTextIter *end,
415 wxTextCtrl *win)
416{
417 if( !(win->GetWindowStyleFlag() & wxTE_AUTO_URL) )
418 return;
419
420 GtkTextIter line_start = *start, line_end = *end;
421
422 gtk_text_iter_set_line(&line_start, gtk_text_iter_get_line(start));
423 gtk_text_iter_forward_to_line_end(&line_end);
424 gtk_text_iter_backward_find_char(start, pred_whitespace, NULL, &line_start);
425 gtk_text_iter_forward_find_char(end, pred_whitespace, NULL, &line_end);
426
427 au_check_range(start, end);
428}
429}
430
431
432//-----------------------------------------------------------------------------
433// "changed"
434//-----------------------------------------------------------------------------
435
436extern "C" {
437static void
438gtk_text_changed_callback( GtkWidget *widget, wxTextCtrl *win )
439{
440 if ( win->IgnoreTextUpdate() )
441 return;
442
443 if (!win->m_hasVMT) return;
444
445 if (g_isIdle)
446 wxapp_install_idle_handler();
447
448 win->SetModified();
449
450 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
451 event.SetEventObject( win );
452 win->GetEventHandler()->ProcessEvent( event );
453}
454}
455
456//-----------------------------------------------------------------------------
457// "expose_event" from scrolled window and textview
458//-----------------------------------------------------------------------------
459
460extern "C" {
461static gboolean
462gtk_text_exposed_callback( GtkWidget *widget, GdkEventExpose *event, wxTextCtrl *win )
463{
464 return TRUE;
465}
466}
467
468
469//-----------------------------------------------------------------------------
470// wxTextCtrl
471//-----------------------------------------------------------------------------
472
473IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
474
475BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
476 EVT_CHAR(wxTextCtrl::OnChar)
477
478 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
479 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
480 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
481 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
482 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
483
484 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
485 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
486 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
487 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
488 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
489
490 // wxTE_AUTO_URL wxTextUrl support. Currently only creates
491 // wxTextUrlEvent in the same cases as wxMSW, more can be added here.
492 EVT_MOTION (wxTextCtrl::OnUrlMouseEvent)
493 EVT_LEFT_DOWN (wxTextCtrl::OnUrlMouseEvent)
494 EVT_LEFT_UP (wxTextCtrl::OnUrlMouseEvent)
495 EVT_LEFT_DCLICK (wxTextCtrl::OnUrlMouseEvent)
496 EVT_RIGHT_DOWN (wxTextCtrl::OnUrlMouseEvent)
497 EVT_RIGHT_UP (wxTextCtrl::OnUrlMouseEvent)
498 EVT_RIGHT_DCLICK(wxTextCtrl::OnUrlMouseEvent)
499END_EVENT_TABLE()
500
501void wxTextCtrl::Init()
502{
503 m_ignoreNextUpdate =
504 m_modified = false;
505 SetUpdateFont(false);
506 m_text =
507 m_vScrollbar = (GtkWidget *)NULL;
508 m_frozenness = 0;
509 m_gdkHandCursor = NULL;
510 m_gdkXTermCursor = NULL;
511}
512
513wxTextCtrl::~wxTextCtrl()
514{
515 if(m_gdkHandCursor)
516 gdk_cursor_unref(m_gdkHandCursor);
517 if(m_gdkXTermCursor)
518 gdk_cursor_unref(m_gdkXTermCursor);
519}
520
521wxTextCtrl::wxTextCtrl( wxWindow *parent,
522 wxWindowID id,
523 const wxString &value,
524 const wxPoint &pos,
525 const wxSize &size,
526 long style,
527 const wxValidator& validator,
528 const wxString &name )
529{
530 Init();
531
532 Create( parent, id, value, pos, size, style, validator, name );
533}
534
535bool wxTextCtrl::Create( wxWindow *parent,
536 wxWindowID id,
537 const wxString &value,
538 const wxPoint &pos,
539 const wxSize &size,
540 long style,
541 const wxValidator& validator,
542 const wxString &name )
543{
544 m_needParent = true;
545 m_acceptsFocus = true;
546
547 if (!PreCreation( parent, pos, size ) ||
548 !CreateBase( parent, id, pos, size, style, validator, name ))
549 {
550 wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
551 return false;
552 }
553
554
555 m_vScrollbarVisible = false;
556
557 bool multi_line = (style & wxTE_MULTILINE) != 0;
558
559 if (multi_line)
560 {
561 // Create view
562 m_text = gtk_text_view_new();
563
564 m_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
565
566 // create scrolled window
567 m_widget = gtk_scrolled_window_new( NULL, NULL );
568 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( m_widget ),
569 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
570
571 // Insert view into scrolled window
572 gtk_container_add( GTK_CONTAINER(m_widget), m_text );
573
574 // translate wx wrapping style to GTK+
575 GtkWrapMode wrap;
576 if ( HasFlag( wxTE_DONTWRAP ) )
577 wrap = GTK_WRAP_NONE;
578 else if ( HasFlag( wxTE_CHARWRAP ) )
579 wrap = GTK_WRAP_CHAR;
580 else if ( HasFlag( wxTE_WORDWRAP ) )
581 wrap = GTK_WRAP_WORD;
582 else // HasFlag(wxTE_BESTWRAP) always true as wxTE_BESTWRAP == 0
583 {
584 // GTK_WRAP_WORD_CHAR seems to be new in GTK+ 2.4
585#ifdef __WXGTK24__
586 if ( !gtk_check_version(2,4,0) )
587 {
588 wrap = GTK_WRAP_WORD_CHAR;
589 }
590 else
591#endif
592 wrap = GTK_WRAP_WORD;
593 }
594
595 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), wrap );
596
597 if (!HasFlag(wxNO_BORDER))
598 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(m_widget), GTK_SHADOW_IN );
599
600 gtk_widget_add_events( GTK_WIDGET(m_text), GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK );
601
602 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
603 }
604 else
605 {
606 // a single-line text control: no need for scrollbars
607 m_widget =
608 m_text = gtk_entry_new();
609
610 if (style & wxNO_BORDER)
611 g_object_set( GTK_ENTRY(m_text), "has-frame", FALSE, NULL );
612 }
613
614 m_parent->DoAddChild( this );
615
616 m_focusWidget = m_text;
617
618 PostCreation(size);
619
620 if (multi_line)
621 {
622 gtk_widget_show(m_text);
623 SetVScrollAdjustment(gtk_scrolled_window_get_vadjustment((GtkScrolledWindow*)m_widget));
624 }
625
626 if (!value.empty())
627 {
628 SetValue( value );
629 }
630
631 if (style & wxTE_PASSWORD)
632 {
633 if (!multi_line)
634 gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
635 }
636
637 if (style & wxTE_READONLY)
638 {
639 if (!multi_line)
640 gtk_editable_set_editable( GTK_EDITABLE(m_text), FALSE );
641 else
642 gtk_text_view_set_editable( GTK_TEXT_VIEW( m_text), FALSE);
643 }
644
645 if (multi_line)
646 {
647 if (style & wxTE_RIGHT)
648 gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text), GTK_JUSTIFY_RIGHT );
649 else if (style & wxTE_CENTRE)
650 gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text), GTK_JUSTIFY_CENTER );
651 // Left justify (alignment) is the default and we don't need to apply GTK_JUSTIFY_LEFT
652 }
653 else
654 {
655#ifdef __WXGTK24__
656 // gtk_entry_set_alignment was introduced in gtk+-2.3.5
657 if (!gtk_check_version(2,4,0))
658 {
659 if (style & wxTE_RIGHT)
660 gtk_entry_set_alignment( GTK_ENTRY(m_text), 1.0 );
661 else if (style & wxTE_CENTRE)
662 gtk_entry_set_alignment( GTK_ENTRY(m_text), 0.5 );
663 }
664#endif
665 }
666
667 // We want to be notified about text changes.
668 if (multi_line)
669 {
670 g_signal_connect (m_buffer, "changed",
671 G_CALLBACK (gtk_text_changed_callback), this);
672
673 // .. and handle URLs on multi-line controls with wxTE_AUTO_URL style
674 if (style & wxTE_AUTO_URL)
675 {
676 GtkTextIter start, end;
677 m_gdkHandCursor = gdk_cursor_new(GDK_HAND2);
678 m_gdkXTermCursor = gdk_cursor_new(GDK_XTERM);
679
680 // We create our wxUrl tag here for slight efficiency gain - we
681 // don't have to check for the tag existance in callbacks,
682 // hereby it's guaranteed to exist.
683 gtk_text_buffer_create_tag(m_buffer, "wxUrl",
684 "foreground", "blue",
685 "underline", PANGO_UNDERLINE_SINGLE,
686 NULL);
687
688 // Check for URLs after each text change
689 g_signal_connect_after (m_buffer, "insert_text",
690 G_CALLBACK (au_insert_text_callback), this);
691 g_signal_connect_after (m_buffer, "delete_range",
692 G_CALLBACK (au_delete_range_callback), this);
693
694 // Block all wxUrl tag applying unless we do it ourselves, in which case we
695 // block this callback temporarily. This takes care of gtk+ internal
696 // gtk_text_buffer_insert_range* calls that would copy our URL tag otherwise,
697 // which is undesired because only a part of the URL might be copied.
698 // The insert-text signal emitted inside it will take care of newly formed
699 // or wholly copied URLs.
700 g_signal_connect (m_buffer, "apply_tag",
701 G_CALLBACK (au_apply_tag_callback), NULL);
702
703 // Check for URLs in the initial string passed to Create
704 gtk_text_buffer_get_start_iter(m_buffer, &start);
705 gtk_text_buffer_get_end_iter(m_buffer, &end);
706 au_check_range(&start, &end);
707 }
708 }
709 else
710 {
711 g_signal_connect (m_text, "changed",
712 G_CALLBACK (gtk_text_changed_callback), this);
713 }
714
715 m_cursor = wxCursor( wxCURSOR_IBEAM );
716
717 wxTextAttr attrDef(GetForegroundColour(), GetBackgroundColour(), GetFont());
718 SetDefaultStyle( attrDef );
719
720 return true;
721}
722
723
724void wxTextCtrl::CalculateScrollbar()
725{
726}
727
728wxString wxTextCtrl::GetValue() const
729{
730 wxCHECK_MSG( m_text != NULL, wxEmptyString, wxT("invalid text ctrl") );
731
732 wxString tmp;
733 if (m_windowStyle & wxTE_MULTILINE)
734 {
735 GtkTextIter start;
736 gtk_text_buffer_get_start_iter( m_buffer, &start );
737 GtkTextIter end;
738 gtk_text_buffer_get_end_iter( m_buffer, &end );
739 gchar *text = gtk_text_buffer_get_text( m_buffer, &start, &end, TRUE );
740
741#if wxUSE_UNICODE
742 wxWCharBuffer buffer( wxConvUTF8.cMB2WX( text ) );
743#else
744 wxCharBuffer buffer( wxConvLocal.cWC2WX( wxConvUTF8.cMB2WC( text ) ) );
745#endif
746 if ( buffer )
747 tmp = buffer;
748
749 g_free( text );
750 }
751 else
752 {
753 tmp = wxGTK_CONV_BACK( gtk_entry_get_text( GTK_ENTRY(m_text) ) );
754 }
755
756 return tmp;
757}
758
759void wxTextCtrl::SetValue( const wxString &value )
760{
761 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
762
763 if (m_windowStyle & wxTE_MULTILINE)
764 {
765#if wxUSE_UNICODE
766 wxCharBuffer buffer( wxConvUTF8.cWX2MB( value) );
767#else
768 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( value ) ) );
769#endif
770 if (gtk_text_buffer_get_char_count(m_buffer) != 0)
771 IgnoreNextTextUpdate();
772
773 if ( !buffer )
774 {
775 // what else can we do? at least don't crash...
776 return;
777 }
778
779 gtk_text_buffer_set_text( m_buffer, buffer, strlen(buffer) );
780 }
781 else
782 {
783 gtk_entry_set_text( GTK_ENTRY(m_text), wxGTK_CONV( value ) );
784 }
785
786 // GRG, Jun/2000: Changed this after a lot of discussion in
787 // the lists. wxWidgets 2.2 will have a set of flags to
788 // customize this behaviour.
789 SetInsertionPoint(0);
790
791 m_modified = false;
792}
793
794void wxTextCtrl::WriteText( const wxString &text )
795{
796 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
797
798 if ( text.empty() )
799 return;
800
801 // gtk_text_changed_callback() will set m_modified to true but m_modified
802 // shouldn't be changed by the program writing to the text control itself,
803 // so save the old value and restore when we're done
804 bool oldModified = m_modified;
805
806 if ( m_windowStyle & wxTE_MULTILINE )
807 {
808#if wxUSE_UNICODE
809 wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
810#else
811 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
812#endif
813 if ( !buffer )
814 {
815 // what else can we do? at least don't crash...
816 return;
817 }
818
819 // TODO: Call whatever is needed to delete the selection.
820 wxGtkTextInsert( m_text, m_buffer, m_defaultStyle, buffer );
821
822 GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(m_widget) );
823 // Scroll to cursor, but only if scrollbar thumb is at the very bottom
824 if ( wxIsSameDouble(adj->value, adj->upper - adj->page_size) )
825 {
826 gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text),
827 gtk_text_buffer_get_insert( m_buffer ), 0.0, FALSE, 0.0, 1.0 );
828 }
829 }
830 else // single line
831 {
832 // First remove the selection if there is one
833 gtk_editable_delete_selection( GTK_EDITABLE(m_text) );
834
835 // This moves the cursor pos to behind the inserted text.
836 gint len = gtk_editable_get_position(GTK_EDITABLE(m_text));
837
838#if wxUSE_UNICODE
839 wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
840#else
841 wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
842#endif
843 if ( !buffer )
844 {
845 // what else can we do? at least don't crash...
846 return;
847 }
848
849 gtk_editable_insert_text( GTK_EDITABLE(m_text), buffer, strlen(buffer), &len );
850
851 // Bring entry's cursor uptodate.
852 gtk_editable_set_position( GTK_EDITABLE(m_text), len );
853 }
854
855 m_modified = oldModified;
856}
857
858void wxTextCtrl::AppendText( const wxString &text )
859{
860 SetInsertionPointEnd();
861 WriteText( text );
862}
863
864wxString wxTextCtrl::GetLineText( long lineNo ) const
865{
866 if (m_windowStyle & wxTE_MULTILINE)
867 {
868 GtkTextIter line;
869 gtk_text_buffer_get_iter_at_line(m_buffer,&line,lineNo);
870 GtkTextIter end = line;
871 gtk_text_iter_forward_to_line_end(&end);
872 gchar *text = gtk_text_buffer_get_text(m_buffer,&line,&end,TRUE);
873 wxString result(wxGTK_CONV_BACK(text));
874 g_free(text);
875 return result;
876 }
877 else
878 {
879 if (lineNo == 0) return GetValue();
880 return wxEmptyString;
881 }
882}
883
884void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
885{
886 /* If you implement this, don't forget to update the documentation!
887 * (file docs/latex/wx/text.tex) */
888 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
889}
890
891bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
892{
893 if ( m_windowStyle & wxTE_MULTILINE )
894 {
895 GtkTextIter iter;
896 gtk_text_buffer_get_iter_at_offset(m_buffer, &iter, pos);
897 if (gtk_text_iter_is_end(&iter))
898 return false;
899
900 *y = gtk_text_iter_get_line(&iter);
901 *x = gtk_text_iter_get_line_offset(&iter);
902 }
903 else // single line control
904 {
905 if ( pos <= GTK_ENTRY(m_text)->text_length )
906 {
907 *y = 0;
908 *x = pos;
909 }
910 else
911 {
912 // index out of bounds
913 return false;
914 }
915 }
916
917 return true;
918}
919
920long wxTextCtrl::XYToPosition(long x, long y ) const
921{
922 if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
923
924 GtkTextIter iter;
925 if (y >= gtk_text_buffer_get_line_count (m_buffer))
926 return -1;
927
928 gtk_text_buffer_get_iter_at_line(m_buffer, &iter, y);
929 if (x >= gtk_text_iter_get_chars_in_line (&iter))
930 return -1;
931
932 return gtk_text_iter_get_offset(&iter) + x;
933}
934
935int wxTextCtrl::GetLineLength(long lineNo) const
936{
937 if (m_windowStyle & wxTE_MULTILINE)
938 {
939 int last_line = gtk_text_buffer_get_line_count( m_buffer ) - 1;
940 if (lineNo > last_line)
941 return -1;
942
943 GtkTextIter iter;
944 gtk_text_buffer_get_iter_at_line(m_buffer, &iter, lineNo);
945 // get_chars_in_line return includes paragraph delimiters, so need to subtract 1 IF it is not the last line
946 return gtk_text_iter_get_chars_in_line(&iter) - ((lineNo == last_line) ? 0 : 1);
947 }
948 else
949 {
950 wxString str = GetLineText (lineNo);
951 return (int) str.Length();
952 }
953}
954
955int wxTextCtrl::GetNumberOfLines() const
956{
957 if (m_windowStyle & wxTE_MULTILINE)
958 return gtk_text_buffer_get_line_count( m_buffer );
959 else
960 return 1;
961}
962
963void wxTextCtrl::SetInsertionPoint( long pos )
964{
965 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
966
967 if ( IsMultiLine() )
968 {
969 GtkTextIter iter;
970 gtk_text_buffer_get_iter_at_offset( m_buffer, &iter, pos );
971 gtk_text_buffer_place_cursor( m_buffer, &iter );
972 gtk_text_view_scroll_mark_onscreen
973 (
974 GTK_TEXT_VIEW(m_text),
975 gtk_text_buffer_get_insert( m_buffer )
976 );
977 }
978 else
979 {
980 // FIXME: Is the editable's cursor really uptodate without double set_position in GTK2?
981 gtk_editable_set_position(GTK_EDITABLE(m_text), int(pos));
982 }
983}
984
985void wxTextCtrl::SetInsertionPointEnd()
986{
987 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
988
989 if (m_windowStyle & wxTE_MULTILINE)
990 {
991 GtkTextIter end;
992 gtk_text_buffer_get_end_iter( m_buffer, &end );
993 gtk_text_buffer_place_cursor( m_buffer, &end );
994 }
995 else
996 {
997 gtk_editable_set_position( GTK_EDITABLE(m_text), -1 );
998 }
999}
1000
1001void wxTextCtrl::SetEditable( bool editable )
1002{
1003 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1004
1005 if (m_windowStyle & wxTE_MULTILINE)
1006 {
1007 gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text), editable );
1008 }
1009 else
1010 {
1011 gtk_editable_set_editable( GTK_EDITABLE(m_text), editable );
1012 }
1013}
1014
1015bool wxTextCtrl::Enable( bool enable )
1016{
1017 if (!wxWindowBase::Enable(enable))
1018 {
1019 // nothing to do
1020 return false;
1021 }
1022
1023 if (m_windowStyle & wxTE_MULTILINE)
1024 {
1025 SetEditable( enable );
1026 }
1027 else
1028 {
1029 gtk_widget_set_sensitive( m_text, enable );
1030 }
1031
1032 return true;
1033}
1034
1035// wxGTK-specific: called recursively by Enable,
1036// to give widgets an oppprtunity to correct their colours after they
1037// have been changed by Enable
1038void wxTextCtrl::OnParentEnable( bool enable )
1039{
1040 // If we have a custom background colour, we use this colour in both
1041 // disabled and enabled mode, or we end up with a different colour under the
1042 // text.
1043 wxColour oldColour = GetBackgroundColour();
1044 if (oldColour.Ok())
1045 {
1046 // Need to set twice or it'll optimize the useful stuff out
1047 if (oldColour == * wxWHITE)
1048 SetBackgroundColour(*wxBLACK);
1049 else
1050 SetBackgroundColour(*wxWHITE);
1051 SetBackgroundColour(oldColour);
1052 }
1053}
1054
1055void wxTextCtrl::MarkDirty()
1056{
1057 m_modified = true;
1058}
1059
1060void wxTextCtrl::DiscardEdits()
1061{
1062 m_modified = false;
1063}
1064
1065// ----------------------------------------------------------------------------
1066// max text length support
1067// ----------------------------------------------------------------------------
1068
1069void wxTextCtrl::IgnoreNextTextUpdate()
1070{
1071 m_ignoreNextUpdate = true;
1072}
1073
1074bool wxTextCtrl::IgnoreTextUpdate()
1075{
1076 if ( m_ignoreNextUpdate )
1077 {
1078 m_ignoreNextUpdate = false;
1079
1080 return true;
1081 }
1082
1083 return false;
1084}
1085
1086void wxTextCtrl::SetMaxLength(unsigned long len)
1087{
1088 if ( !HasFlag(wxTE_MULTILINE) )
1089 {
1090 gtk_entry_set_max_length(GTK_ENTRY(m_text), len);
1091
1092 // there is a bug in GTK+ 1.2.x: "changed" signal is emitted even if
1093 // we had tried to enter more text than allowed by max text length and
1094 // the text wasn't really changed
1095 //
1096 // to detect this and generate TEXT_MAXLEN event instead of
1097 // TEXT_CHANGED one in this case we also catch "insert_text" signal
1098 //
1099 // when max len is set to 0 we disconnect our handler as it means that
1100 // we shouldn't check anything any more
1101 if ( len )
1102 {
1103 g_signal_connect (m_text, "insert_text",
1104 G_CALLBACK (gtk_insert_text_callback), this);
1105 }
1106 else // no checking
1107 {
1108 g_signal_handlers_disconnect_by_func (m_text,
1109 (gpointer) gtk_insert_text_callback, this);
1110 }
1111 }
1112}
1113
1114void wxTextCtrl::SetSelection( long from, long to )
1115{
1116 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1117
1118 if (from == -1 && to == -1)
1119 {
1120 from = 0;
1121 to = GetValue().Length();
1122 }
1123
1124 if (m_windowStyle & wxTE_MULTILINE)
1125 {
1126 GtkTextIter fromi, toi;
1127 gtk_text_buffer_get_iter_at_offset( m_buffer, &fromi, from );
1128 gtk_text_buffer_get_iter_at_offset( m_buffer, &toi, to );
1129
1130 gtk_text_buffer_place_cursor( m_buffer, &toi );
1131 gtk_text_buffer_move_mark_by_name( m_buffer, "selection_bound", &fromi );
1132 }
1133 else
1134 {
1135 gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1136 }
1137}
1138
1139void wxTextCtrl::ShowPosition( long pos )
1140{
1141 if (m_windowStyle & wxTE_MULTILINE)
1142 {
1143 GtkTextIter iter;
1144 gtk_text_buffer_get_start_iter( m_buffer, &iter );
1145 gtk_text_iter_set_offset( &iter, pos );
1146 GtkTextMark *mark = gtk_text_buffer_create_mark( m_buffer, NULL, &iter, TRUE );
1147 gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text), mark, 0.0, FALSE, 0.0, 0.0 );
1148 }
1149}
1150
1151wxTextCtrlHitTestResult
1152wxTextCtrl::HitTest(const wxPoint& pt, long *pos) const
1153{
1154 if ( !IsMultiLine() )
1155 {
1156 // not supported
1157 return wxTE_HT_UNKNOWN;
1158 }
1159
1160 int x, y;
1161 gtk_text_view_window_to_buffer_coords
1162 (
1163 GTK_TEXT_VIEW(m_text),
1164 GTK_TEXT_WINDOW_TEXT,
1165 pt.x, pt.y,
1166 &x, &y
1167 );
1168
1169 GtkTextIter iter;
1170 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &iter, x, y);
1171 if ( pos )
1172 *pos = gtk_text_iter_get_offset(&iter);
1173
1174 return wxTE_HT_ON_TEXT;
1175}
1176
1177long wxTextCtrl::GetInsertionPoint() const
1178{
1179 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1180
1181 if (m_windowStyle & wxTE_MULTILINE)
1182 {
1183 // There is no direct accessor for the cursor, but
1184 // internally, the cursor is the "mark" called
1185 // "insert" in the text view's btree structure.
1186
1187 GtkTextMark *mark = gtk_text_buffer_get_insert( m_buffer );
1188 GtkTextIter cursor;
1189 gtk_text_buffer_get_iter_at_mark( m_buffer, &cursor, mark );
1190
1191 return gtk_text_iter_get_offset( &cursor );
1192 }
1193 else
1194 {
1195 return (long) gtk_editable_get_position(GTK_EDITABLE(m_text));
1196 }
1197}
1198
1199wxTextPos wxTextCtrl::GetLastPosition() const
1200{
1201 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1202
1203 int pos = 0;
1204
1205 if (m_windowStyle & wxTE_MULTILINE)
1206 {
1207 GtkTextIter end;
1208 gtk_text_buffer_get_end_iter( m_buffer, &end );
1209
1210 pos = gtk_text_iter_get_offset( &end );
1211 }
1212 else
1213 {
1214 pos = GTK_ENTRY(m_text)->text_length;
1215 }
1216
1217 return (long)pos;
1218}
1219
1220void wxTextCtrl::Remove( long from, long to )
1221{
1222 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1223
1224 if (m_windowStyle & wxTE_MULTILINE)
1225 {
1226 GtkTextIter fromi, toi;
1227 gtk_text_buffer_get_iter_at_offset( m_buffer, &fromi, from );
1228 gtk_text_buffer_get_iter_at_offset( m_buffer, &toi, to );
1229
1230 gtk_text_buffer_delete( m_buffer, &fromi, &toi );
1231 }
1232 else // single line
1233 gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1234}
1235
1236void wxTextCtrl::Replace( long from, long to, const wxString &value )
1237{
1238 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1239
1240 Remove( from, to );
1241
1242 if (!value.empty())
1243 {
1244 SetInsertionPoint( from );
1245 WriteText( value );
1246 }
1247}
1248
1249void wxTextCtrl::Cut()
1250{
1251 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1252
1253 if (m_windowStyle & wxTE_MULTILINE)
1254 g_signal_emit_by_name (m_text, "cut-clipboard");
1255 else
1256 gtk_editable_cut_clipboard(GTK_EDITABLE(m_text));
1257}
1258
1259void wxTextCtrl::Copy()
1260{
1261 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1262
1263 if (m_windowStyle & wxTE_MULTILINE)
1264 g_signal_emit_by_name (m_text, "copy-clipboard");
1265 else
1266 gtk_editable_copy_clipboard(GTK_EDITABLE(m_text));
1267}
1268
1269void wxTextCtrl::Paste()
1270{
1271 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1272
1273 if (m_windowStyle & wxTE_MULTILINE)
1274 g_signal_emit_by_name (m_text, "paste-clipboard");
1275 else
1276 gtk_editable_paste_clipboard(GTK_EDITABLE(m_text));
1277}
1278
1279// Undo/redo
1280void wxTextCtrl::Undo()
1281{
1282 // TODO
1283 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1284}
1285
1286void wxTextCtrl::Redo()
1287{
1288 // TODO
1289 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1290}
1291
1292bool wxTextCtrl::CanUndo() const
1293{
1294 // TODO
1295 //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1296 return false;
1297}
1298
1299bool wxTextCtrl::CanRedo() const
1300{
1301 // TODO
1302 //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1303 return false;
1304}
1305
1306// If the return values from and to are the same, there is no
1307// selection.
1308void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
1309{
1310 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1311
1312 gint from = -1;
1313 gint to = -1;
1314 bool haveSelection = false;
1315
1316 if (m_windowStyle & wxTE_MULTILINE)
1317 {
1318 GtkTextIter ifrom, ito;
1319 if ( gtk_text_buffer_get_selection_bounds(m_buffer, &ifrom, &ito) )
1320 {
1321 haveSelection = true;
1322 from = gtk_text_iter_get_offset(&ifrom);
1323 to = gtk_text_iter_get_offset(&ito);
1324 }
1325 }
1326 else // not multi-line
1327 {
1328 if ( gtk_editable_get_selection_bounds( GTK_EDITABLE(m_text),
1329 &from, &to) )
1330 {
1331 haveSelection = true;
1332 }
1333 }
1334
1335 if (! haveSelection )
1336 from = to = GetInsertionPoint();
1337
1338 if ( from > to )
1339 {
1340 // exchange them to be compatible with wxMSW
1341 gint tmp = from;
1342 from = to;
1343 to = tmp;
1344 }
1345
1346 if ( fromOut )
1347 *fromOut = from;
1348 if ( toOut )
1349 *toOut = to;
1350}
1351
1352
1353bool wxTextCtrl::IsEditable() const
1354{
1355 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
1356
1357 if (m_windowStyle & wxTE_MULTILINE)
1358 {
1359 return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text));
1360 }
1361 else
1362 {
1363 return gtk_editable_get_editable(GTK_EDITABLE(m_text));
1364 }
1365}
1366
1367bool wxTextCtrl::IsModified() const
1368{
1369 return m_modified;
1370}
1371
1372void wxTextCtrl::Clear()
1373{
1374 SetValue( wxEmptyString );
1375}
1376
1377void wxTextCtrl::OnChar( wxKeyEvent &key_event )
1378{
1379 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1380
1381 if ((key_event.GetKeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1382 {
1383 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1384 event.SetEventObject(this);
1385 event.SetString(GetValue());
1386 if (GetEventHandler()->ProcessEvent(event)) return;
1387 }
1388
1389 if ((key_event.GetKeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1390 {
1391 // This will invoke the dialog default action, such
1392 // as the clicking the default button.
1393
1394 wxWindow *top_frame = m_parent;
1395 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1396 top_frame = top_frame->GetParent();
1397
1398 if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1399 {
1400 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1401
1402 if (window->default_widget)
1403 {
1404 gtk_widget_activate (window->default_widget);
1405 return;
1406 }
1407 }
1408 }
1409
1410 key_event.Skip();
1411}
1412
1413GtkWidget* wxTextCtrl::GetConnectWidget()
1414{
1415 return GTK_WIDGET(m_text);
1416}
1417
1418bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1419{
1420 if (m_windowStyle & wxTE_MULTILINE)
1421 {
1422 return window == gtk_text_view_get_window( GTK_TEXT_VIEW( m_text ), GTK_TEXT_WINDOW_TEXT ); // pure guesswork
1423 }
1424 else
1425 {
1426 return (window == GTK_ENTRY(m_text)->text_area);
1427 }
1428}
1429
1430// the font will change for subsequent text insertiongs
1431bool wxTextCtrl::SetFont( const wxFont &font )
1432{
1433 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
1434
1435 if ( !wxTextCtrlBase::SetFont(font) )
1436 {
1437 // font didn't change, nothing to do
1438 return false;
1439 }
1440
1441 if ( m_windowStyle & wxTE_MULTILINE )
1442 {
1443 SetUpdateFont(true);
1444
1445 m_defaultStyle.SetFont(font);
1446
1447 ChangeFontGlobally();
1448 }
1449
1450 return true;
1451}
1452
1453void wxTextCtrl::ChangeFontGlobally()
1454{
1455 // this method is very inefficient and hence should be called as rarely as
1456 // possible!
1457 //
1458 // TODO: it can be implemented much more efficiently for GTK2
1459 wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE),
1460 _T("shouldn't be called for single line controls") );
1461
1462 wxString value = GetValue();
1463 if ( !value.empty() )
1464 {
1465 SetUpdateFont(false);
1466
1467 Clear();
1468 AppendText(value);
1469 }
1470}
1471
1472bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1473{
1474 if ( !wxControl::SetForegroundColour(colour) )
1475 return false;
1476
1477 // update default fg colour too
1478 m_defaultStyle.SetTextColour(colour);
1479
1480 return true;
1481}
1482
1483bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1484{
1485 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
1486
1487 if ( !wxControl::SetBackgroundColour( colour ) )
1488 return false;
1489
1490 if (!m_backgroundColour.Ok())
1491 return false;
1492
1493 // change active background color too
1494 m_defaultStyle.SetBackgroundColour( colour );
1495
1496 return true;
1497}
1498
1499bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
1500{
1501 if ( m_windowStyle & wxTE_MULTILINE )
1502 {
1503 if ( style.IsDefault() )
1504 {
1505 // nothing to do
1506 return true;
1507 }
1508
1509 gint l = gtk_text_buffer_get_char_count( m_buffer );
1510
1511 wxCHECK_MSG( start >= 0 && end <= l, false,
1512 _T("invalid range in wxTextCtrl::SetStyle") );
1513
1514 GtkTextIter starti, endi;
1515 gtk_text_buffer_get_iter_at_offset( m_buffer, &starti, start );
1516 gtk_text_buffer_get_iter_at_offset( m_buffer, &endi, end );
1517
1518 // use the attributes from style which are set in it and fall back
1519 // first to the default style and then to the text control default
1520 // colours for the others
1521 wxTextAttr attr = wxTextAttr::Combine(style, m_defaultStyle, this);
1522
1523 wxGtkTextApplyTagsFromAttr( m_buffer, attr, &starti, &endi );
1524
1525 return true;
1526 }
1527
1528 // else single line
1529 // cannot do this for GTK+'s Entry widget
1530 return false;
1531}
1532
1533void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
1534{
1535 gtk_widget_modify_style(m_text, style);
1536}
1537
1538void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1539{
1540 Cut();
1541}
1542
1543void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1544{
1545 Copy();
1546}
1547
1548void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1549{
1550 Paste();
1551}
1552
1553void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1554{
1555 Undo();
1556}
1557
1558void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1559{
1560 Redo();
1561}
1562
1563void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1564{
1565 event.Enable( CanCut() );
1566}
1567
1568void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1569{
1570 event.Enable( CanCopy() );
1571}
1572
1573void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1574{
1575 event.Enable( CanPaste() );
1576}
1577
1578void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1579{
1580 event.Enable( CanUndo() );
1581}
1582
1583void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1584{
1585 event.Enable( CanRedo() );
1586}
1587
1588void wxTextCtrl::OnInternalIdle()
1589{
1590 wxCursor cursor = m_cursor;
1591 if (g_globalCursor.Ok()) cursor = g_globalCursor;
1592
1593 if (g_delayedFocus == this)
1594 {
1595 if (GTK_WIDGET_REALIZED(m_widget))
1596 {
1597 gtk_widget_grab_focus( m_widget );
1598 g_delayedFocus = NULL;
1599 }
1600 }
1601
1602 if (wxUpdateUIEvent::CanUpdate(this))
1603 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1604}
1605
1606wxSize wxTextCtrl::DoGetBestSize() const
1607{
1608 // FIXME should be different for multi-line controls...
1609 wxSize ret( wxControl::DoGetBestSize() );
1610 wxSize best(80, ret.y);
1611 CacheBestSize(best);
1612 return best;
1613}
1614
1615// ----------------------------------------------------------------------------
1616// freeze/thaw
1617// ----------------------------------------------------------------------------
1618
1619void wxTextCtrl::Freeze()
1620{
1621 if ( HasFlag(wxTE_MULTILINE) )
1622 {
1623 if ( !m_frozenness++ )
1624 {
1625 // freeze textview updates and remove buffer
1626 g_signal_connect (m_text, "expose_event",
1627 G_CALLBACK (gtk_text_exposed_callback), this);
1628 g_signal_connect (m_widget, "expose_event",
1629 G_CALLBACK (gtk_text_exposed_callback), this);
1630 gtk_widget_set_sensitive(m_widget, false);
1631 g_object_ref(m_buffer);
1632 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), gtk_text_buffer_new(NULL));
1633 }
1634 }
1635}
1636
1637void wxTextCtrl::Thaw()
1638{
1639 if ( HasFlag(wxTE_MULTILINE) )
1640 {
1641 wxASSERT_MSG( m_frozenness > 0, _T("Thaw() without matching Freeze()") );
1642
1643 if ( !--m_frozenness )
1644 {
1645 // Reattach buffer and thaw textview updates
1646 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), m_buffer);
1647 g_object_unref(m_buffer);
1648 gtk_widget_set_sensitive(m_widget, true);
1649 g_signal_handlers_disconnect_by_func (m_widget,
1650 (gpointer) gtk_text_exposed_callback, this);
1651 g_signal_handlers_disconnect_by_func (m_text,
1652 (gpointer) gtk_text_exposed_callback, this);
1653 }
1654 }
1655}
1656
1657// ----------------------------------------------------------------------------
1658// wxTextUrlEvent passing if style & wxTE_AUTO_URL
1659// ----------------------------------------------------------------------------
1660
1661// FIXME: when dragging on a link the sample gets an "Unknown event".
1662// This might be an excessive event from us or a buggy wxMouseEvent::Moving() or
1663// a buggy sample, or something else
1664void wxTextCtrl::OnUrlMouseEvent(wxMouseEvent& event)
1665{
1666 event.Skip();
1667 if(!(m_windowStyle & wxTE_AUTO_URL))
1668 return;
1669
1670 gint x, y;
1671 GtkTextIter start, end;
1672 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(m_buffer),
1673 "wxUrl");
1674
1675 gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(m_text), GTK_TEXT_WINDOW_WIDGET,
1676 event.GetX(), event.GetY(), &x, &y);
1677
1678 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &end, x, y);
1679 if (!gtk_text_iter_has_tag(&end, tag))
1680 {
1681 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
1682 GTK_TEXT_WINDOW_TEXT), m_gdkXTermCursor);
1683 return;
1684 }
1685
1686 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
1687 GTK_TEXT_WINDOW_TEXT), m_gdkHandCursor);
1688
1689 start = end;
1690 if(!gtk_text_iter_begins_tag(&start, tag))
1691 gtk_text_iter_backward_to_tag_toggle(&start, tag);
1692 if(!gtk_text_iter_ends_tag(&end, tag))
1693 gtk_text_iter_forward_to_tag_toggle(&end, tag);
1694
1695 // Native context menu is probably not desired on an URL.
1696 // Consider making this dependant on ProcessEvent(wxTextUrlEvent) return value
1697 if(event.GetEventType() == wxEVT_RIGHT_DOWN)
1698 event.Skip(false);
1699
1700 wxTextUrlEvent url_event(m_windowId, event,
1701 gtk_text_iter_get_offset(&start),
1702 gtk_text_iter_get_offset(&end));
1703
1704 InitCommandEvent(url_event);
1705 // Is that a good idea? Seems not (pleasure with gtk_text_view_start_selection_drag)
1706 //event.Skip(!GetEventHandler()->ProcessEvent(url_event));
1707 GetEventHandler()->ProcessEvent(url_event);
1708}
1709
1710// static
1711wxVisualAttributes
1712wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1713{
1714 return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true);
1715}
wxWidgets (Impactor)