]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/textctrl.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Trace module initialization and cleanup.
[wxWidgets.git] / src / gtk1 / textctrl.cpp
... / ...
CommitLineData
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
34extern void wxapp_install_idle_handler();
35extern bool g_isIdle;
36
37//-----------------------------------------------------------------------------
38// data
39//-----------------------------------------------------------------------------
40
41extern wxCursor g_globalCursor;
42extern wxWindowGTK *g_delayedFocus;
43
44// ----------------------------------------------------------------------------
45// helpers
46// ----------------------------------------------------------------------------
47
48#ifdef __WXGTK20__
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#else
184extern "C" {
185static 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
209extern "C" {
210static void
211gtk_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
250extern "C" {
251static void
252au_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
267extern "C" {
268static gboolean
269pred_whitespace (gunichar ch, gpointer user_data)
270{
271 return g_unichar_isspace(ch);
272}
273}
274
275extern "C" {
276static gboolean
277pred_non_whitespace (gunichar ch, gpointer user_data)
278{
279 return !g_unichar_isspace(ch);
280}
281}
282
283extern "C" {
284static gboolean
285pred_nonpunct (gunichar ch, gpointer user_data)
286{
287 return !g_unichar_ispunct(ch);
288}
289}
290
291extern "C" {
292static gboolean
293pred_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.
305extern "C" {
306static void
307au_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
367extern "C" {
368static void
369au_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
400extern "C" {
401static void
402au_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
432extern "C" {
433static void
434au_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
460extern "C" {
461static void
462gtk_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__
488extern "C" {
489static gboolean
490gtk_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__
502extern "C" {
503static void
504gtk_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
527extern bool wxIsInsideYield;
528
529extern "C" {
530 typedef void (*GtkDrawCallback)(GtkWidget *widget, GdkRectangle *rect);
531}
532
533static GtkDrawCallback gs_gtk_text_draw = NULL;
534
535extern "C" {
536static 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
554IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
555
556BEGIN_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
582END_EVENT_TABLE()
583
584void 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
598wxTextCtrl::~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
608wxTextCtrl::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
622bool 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
892void 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
918wxString 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
956void 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
1000void 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
1092void wxTextCtrl::AppendText( const wxString &text )
1093{
1094 SetInsertionPointEnd();
1095 WriteText( text );
1096}
1097
1098wxString 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
1144void 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
1151bool 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
1203long 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
1226int 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
1248int 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
1283void 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
1326void 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
1346void 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
1364bool 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
1392void 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
1409void wxTextCtrl::MarkDirty()
1410{
1411 m_modified = true;
1412}
1413
1414void wxTextCtrl::DiscardEdits()
1415{
1416 m_modified = false;
1417}
1418
1419// ----------------------------------------------------------------------------
1420// max text length support
1421// ----------------------------------------------------------------------------
1422
1423void wxTextCtrl::IgnoreNextTextUpdate()
1424{
1425 m_ignoreNextUpdate = true;
1426}
1427
1428bool wxTextCtrl::IgnoreTextUpdate()
1429{
1430 if ( m_ignoreNextUpdate )
1431 {
1432 m_ignoreNextUpdate = false;
1433
1434 return true;
1435 }
1436
1437 return false;
1438}
1439
1440void 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
1474void 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
1513void 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
1538wxTextCtrlHitTestResult
1539wxTextCtrl::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
1566long 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
1590wxTextPos 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
1615void 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
1633void 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
1656void 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
1668void 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
1680void 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
1693void wxTextCtrl::Undo()
1694{
1695 // TODO
1696 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1697}
1698
1699void wxTextCtrl::Redo()
1700{
1701 // TODO
1702 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1703}
1704
1705bool wxTextCtrl::CanUndo() const
1706{
1707 // TODO
1708 //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1709 return false;
1710}
1711
1712bool 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.
1721void 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
1775bool 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
1793bool wxTextCtrl::IsModified() const
1794{
1795 return m_modified;
1796}
1797
1798void wxTextCtrl::Clear()
1799{
1800 SetValue( wxEmptyString );
1801}
1802
1803void 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
1839GtkWidget* wxTextCtrl::GetConnectWidget()
1840{
1841 return GTK_WIDGET(m_text);
1842}
1843
1844bool 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
1861bool 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
1883void 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
1910void wxTextCtrl::UpdateFontIfNeeded()
1911{
1912 if ( m_updateFont )
1913 ChangeFontGlobally();
1914}
1915
1916#endif // GTK+ 1.x
1917
1918bool 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
1929bool 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
1962bool 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
2035void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
2036{
2037 gtk_widget_modify_style(m_text, style);
2038}
2039
2040void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
2041{
2042 Cut();
2043}
2044
2045void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
2046{
2047 Copy();
2048}
2049
2050void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
2051{
2052 Paste();
2053}
2054
2055void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
2056{
2057 Undo();
2058}
2059
2060void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
2061{
2062 Redo();
2063}
2064
2065void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
2066{
2067 event.Enable( CanCut() );
2068}
2069
2070void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
2071{
2072 event.Enable( CanCopy() );
2073}
2074
2075void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
2076{
2077 event.Enable( CanPaste() );
2078}
2079
2080void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
2081{
2082 event.Enable( CanUndo() );
2083}
2084
2085void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
2086{
2087 event.Enable( CanRedo() );
2088}
2089
2090void 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
2129wxSize 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
2142void 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
2164void 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
2197void 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
2248GtkAdjustment *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
2260bool 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
2289bool 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
2305bool 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
2316wxVisualAttributes
2317wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
2318{
2319 return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true);
2320}
wxWidgets (Impactor)