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