]> git.saurik.com Git - wxWidgets.git/blame - src/gtk/textctrl.cpp
implement wxLocale::GetInfo() using CFLocale (modified patch 1760939)
[wxWidgets.git] / src / gtk / textctrl.cpp
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
8e13c1ec 2// Name: src/gtk/textctrl.cpp
c801d85f
KB
3// Purpose:
4// Author: Robert Roebling
f96aa4d9 5// Id: $Id$
9fa72bd2 6// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin, 2005 Mart Raudsepp
65571936 7// Licence: wxWindows licence
c801d85f
KB
8/////////////////////////////////////////////////////////////////////////////
9
14f355c2
VS
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
28fcfbfe
VZ
13#if wxUSE_TEXTCTRL
14
c801d85f 15#include "wx/textctrl.h"
88a7a4e1
WS
16
17#ifndef WX_PRECOMP
18 #include "wx/intl.h"
e4db172a 19 #include "wx/log.h"
de6185e2 20 #include "wx/utils.h"
9eddec69 21 #include "wx/settings.h"
18680f86 22 #include "wx/math.h"
88a7a4e1
WS
23#endif
24
fab591c5 25#include "wx/strconv.h"
cc3da3f8 26#include "wx/fontutil.h" // for wxNativeFontInfo (GetNativeFontInfo())
c801d85f 27
a81258be
RR
28#include <sys/types.h>
29#include <sys/stat.h>
30#include <ctype.h>
31
9e691f46 32#include "wx/gtk/private.h"
b292e2f5 33
eda40bfc
VZ
34// ----------------------------------------------------------------------------
35// helpers
36// ----------------------------------------------------------------------------
37
418cf02e
JS
38extern "C" {
39static void wxGtkOnRemoveTag(GtkTextBuffer *buffer,
40 GtkTextTag *tag,
e4161a2a
VZ
41 GtkTextIter * WXUNUSED(start),
42 GtkTextIter * WXUNUSED(end),
50aee613 43 char *prefix)
418cf02e
JS
44{
45 gchar *name;
46 g_object_get (tag, "name", &name, NULL);
47
50aee613
MR
48 if (!name || strncmp(name, prefix, strlen(prefix)))
49 // anonymous tag or not starting with prefix - don't remove
9fa72bd2 50 g_signal_stop_emission_by_name (buffer, "remove_tag");
418cf02e
JS
51
52 g_free(name);
53}
54}
55
7b377ed9
VZ
56// remove all tags starting with the given prefix from the start..end range
57static void
58wxGtkTextRemoveTagsWithPrefix(GtkTextBuffer *text_buffer,
59 const char *prefix,
60 GtkTextIter *start,
61 GtkTextIter *end)
62{
63 gulong remove_handler_id = g_signal_connect
64 (
65 text_buffer,
66 "remove_tag",
67 G_CALLBACK(wxGtkOnRemoveTag),
68 gpointer(prefix)
69 );
70 gtk_text_buffer_remove_all_tags(text_buffer, start, end);
71 g_signal_handler_disconnect(text_buffer, remove_handler_id);
72}
73
ae6a64b6
MR
74static void wxGtkTextApplyTagsFromAttr(GtkWidget *text,
75 GtkTextBuffer *text_buffer,
25497324
KH
76 const wxTextAttr& attr,
77 GtkTextIter *start,
78 GtkTextIter *end)
79{
80 static gchar buf[1024];
81 GtkTextTag *tag;
82
83 if (attr.HasFont())
84 {
7b377ed9
VZ
85 wxGtkTextRemoveTagsWithPrefix(text_buffer, "WXFONT", start, end);
86
44cc96a8
JS
87 wxFont font(attr.GetFont());
88
89 PangoFontDescription *font_description = font.GetNativeFontInfo()->description;
e808cf8a
PC
90 wxGtkString font_string(pango_font_description_to_string(font_description));
91 g_snprintf(buf, sizeof(buf), "WXFONT %s", font_string.c_str());
25497324
KH
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 "font-desc", font_description,
97 NULL );
98 gtk_text_buffer_apply_tag (text_buffer, tag, start, end);
18634476 99
44cc96a8 100 if (font.GetUnderlined())
18634476
VZ
101 {
102 g_snprintf(buf, sizeof(buf), "WXFONTUNDERLINE");
103 tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
104 buf );
105 if (!tag)
106 tag = gtk_text_buffer_create_tag( text_buffer, buf,
107 "underline-set", TRUE,
108 "underline", PANGO_UNDERLINE_SINGLE,
109 NULL );
110 gtk_text_buffer_apply_tag (text_buffer, tag, start, end);
111 }
25497324
KH
112 }
113
114 if (attr.HasTextColour())
115 {
7b377ed9
VZ
116 wxGtkTextRemoveTagsWithPrefix(text_buffer, "WXFORECOLOR", start, end);
117
c6685317 118 const GdkColor *colFg = attr.GetTextColour().GetColor();
25497324
KH
119 g_snprintf(buf, sizeof(buf), "WXFORECOLOR %d %d %d",
120 colFg->red, colFg->green, colFg->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 "foreground-gdk", colFg, NULL );
126 gtk_text_buffer_apply_tag (text_buffer, tag, start, end);
127 }
128
129 if (attr.HasBackgroundColour())
130 {
7b377ed9
VZ
131 wxGtkTextRemoveTagsWithPrefix(text_buffer, "WXBACKCOLOR", start, end);
132
c6685317 133 const GdkColor *colBg = attr.GetBackgroundColour().GetColor();
25497324
KH
134 g_snprintf(buf, sizeof(buf), "WXBACKCOLOR %d %d %d",
135 colBg->red, colBg->green, colBg->blue);
136 tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
137 buf );
138 if (!tag)
139 tag = gtk_text_buffer_create_tag( text_buffer, buf,
140 "background-gdk", colBg, NULL );
141 gtk_text_buffer_apply_tag (text_buffer, tag, start, end);
142 }
50aee613
MR
143
144 if (attr.HasAlignment())
145 {
146 GtkTextIter para_start, para_end = *end;
147 gtk_text_buffer_get_iter_at_line( text_buffer,
148 &para_start,
149 gtk_text_iter_get_line(start) );
150 gtk_text_iter_forward_line(&para_end);
151
7b377ed9 152 wxGtkTextRemoveTagsWithPrefix(text_buffer, "WXALIGNMENT", start, end);
50aee613
MR
153
154 GtkJustification align;
155 switch (attr.GetAlignment())
156 {
157 default:
158 align = GTK_JUSTIFY_LEFT;
159 break;
160 case wxTEXT_ALIGNMENT_RIGHT:
161 align = GTK_JUSTIFY_RIGHT;
162 break;
163 case wxTEXT_ALIGNMENT_CENTER:
164 align = GTK_JUSTIFY_CENTER;
165 break;
b4e0dd39
MR
166// gtk+ doesn't support justify before gtk+-2.11.0 with pango-1.17 being available
167// (but if new enough pango isn't available it's a mere gtk warning)
168#if GTK_CHECK_VERSION(2,11,0)
beed4c4b 169 case wxTEXT_ALIGNMENT_JUSTIFIED:
b4e0dd39 170 if (!gtk_check_version(2,11,0))
beed4c4b 171 align = GTK_JUSTIFY_FILL;
b4e0dd39
MR
172 else
173 align = GTK_JUSTIFY_LEFT;
beed4c4b 174 break;
b4e0dd39 175#endif
50aee613
MR
176 }
177
178 g_snprintf(buf, sizeof(buf), "WXALIGNMENT %d", align);
179 tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
180 buf );
181 if (!tag)
182 tag = gtk_text_buffer_create_tag( text_buffer, buf,
183 "justification", align, NULL );
184 gtk_text_buffer_apply_tag( text_buffer, tag, &para_start, &para_end );
185 }
ae6a64b6
MR
186
187 if (attr.HasLeftIndent())
188 {
189 // Indentation attribute
190
191 // Clear old indentation tags
192 GtkTextIter para_start, para_end = *end;
193 gtk_text_buffer_get_iter_at_line( text_buffer,
194 &para_start,
195 gtk_text_iter_get_line(start) );
196 gtk_text_iter_forward_line(&para_end);
197
7b377ed9 198 wxGtkTextRemoveTagsWithPrefix(text_buffer, "WXINDENT", start, end);
ae6a64b6
MR
199
200 // Convert indent from 1/10th of a mm into pixels
201 float factor;
202#if GTK_CHECK_VERSION(2,2,0)
203 if (!gtk_check_version(2,2,0))
204 factor = (float)gdk_screen_get_width(gtk_widget_get_screen(text)) /
205 gdk_screen_get_width_mm(gtk_widget_get_screen(text)) / 10;
206 else
207#endif
208 factor = (float)gdk_screen_width() / gdk_screen_width_mm() / 10;
209
210 const int indent = (int)(factor * attr.GetLeftIndent());
211 const int subIndent = (int)(factor * attr.GetLeftSubIndent());
212
213 gint gindent;
214 gint gsubindent;
215
216 if (subIndent >= 0)
217 {
218 gindent = indent;
219 gsubindent = -subIndent;
220 }
221 else
222 {
223 gindent = -subIndent;
224 gsubindent = indent;
225 }
226
227 g_snprintf(buf, sizeof(buf), "WXINDENT %d %d", gindent, gsubindent);
228 tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
229 buf );
230 if (!tag)
231 tag = gtk_text_buffer_create_tag( text_buffer, buf,
232 "left-margin", gindent, "indent", gsubindent, NULL );
233 gtk_text_buffer_apply_tag (text_buffer, tag, &para_start, &para_end);
234 }
235
236 if (attr.HasTabs())
237 {
238 // Set tab stops
239
240 // Clear old tabs
241 GtkTextIter para_start, para_end = *end;
242 gtk_text_buffer_get_iter_at_line( text_buffer,
243 &para_start,
244 gtk_text_iter_get_line(start) );
245 gtk_text_iter_forward_line(&para_end);
246
7b377ed9 247 wxGtkTextRemoveTagsWithPrefix(text_buffer, "WXTABS", start, end);
ae6a64b6
MR
248
249 const wxArrayInt& tabs = attr.GetTabs();
250
251 wxString tagname = _T("WXTABS");
252 g_snprintf(buf, sizeof(buf), "WXTABS");
253 for (size_t i = 0; i < tabs.GetCount(); i++)
254 tagname += wxString::Format(_T(" %d"), tabs[i]);
255
74ab5f5b 256 const wxWX2MBbuf buftag = tagname.utf8_str();
ae6a64b6
MR
257
258 tag = gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer ),
74ab5f5b 259 buftag );
ae6a64b6
MR
260 if (!tag)
261 {
262 // Factor to convert from 1/10th of a mm into pixels
263 float factor;
264#if GTK_CHECK_VERSION(2,2,0)
265 if (!gtk_check_version(2,2,0))
266 factor = (float)gdk_screen_get_width(gtk_widget_get_screen(text)) /
267 gdk_screen_get_width_mm(gtk_widget_get_screen(text)) / 10;
268 else
269#endif
270 factor = (float)gdk_screen_width() / gdk_screen_width_mm() / 10;
271
272 PangoTabArray* tabArray = pango_tab_array_new(tabs.GetCount(), TRUE);
273 for (size_t i = 0; i < tabs.GetCount(); i++)
274 pango_tab_array_set_tab(tabArray, i, PANGO_TAB_LEFT, (gint)(tabs[i] * factor));
74ab5f5b 275 tag = gtk_text_buffer_create_tag( text_buffer, buftag,
ae6a64b6
MR
276 "tabs", tabArray, NULL );
277 pango_tab_array_free(tabArray);
278 }
279 gtk_text_buffer_apply_tag (text_buffer, tag, &para_start, &para_end);
280 }
25497324
KH
281}
282
cc3da3f8
RR
283static void wxGtkTextInsert(GtkWidget *text,
284 GtkTextBuffer *text_buffer,
285 const wxTextAttr& attr,
fbfb8bcc 286 const wxCharBuffer& buffer)
cc3da3f8
RR
287
288{
25497324
KH
289 gint start_offset;
290 GtkTextIter iter, start;
cc3da3f8 291
a61bbf87
JS
292 gtk_text_buffer_get_iter_at_mark( text_buffer, &iter,
293 gtk_text_buffer_get_insert (text_buffer) );
25497324
KH
294 start_offset = gtk_text_iter_get_offset (&iter);
295 gtk_text_buffer_insert( text_buffer, &iter, buffer, strlen(buffer) );
296
297 gtk_text_buffer_get_iter_at_offset (text_buffer, &start, start_offset);
a61bbf87 298
ae6a64b6 299 wxGtkTextApplyTagsFromAttr(text, text_buffer, attr, &start, &iter);
cc3da3f8 300}
eda40bfc 301
9440c3d0
KH
302// Implementation of wxTE_AUTO_URL for wxGTK2 by Mart Raudsepp,
303
865bb325 304extern "C" {
9440c3d0
KH
305static void
306au_apply_tag_callback(GtkTextBuffer *buffer,
307 GtkTextTag *tag,
e4161a2a
VZ
308 GtkTextIter * WXUNUSED(start),
309 GtkTextIter * WXUNUSED(end),
310 gpointer WXUNUSED(textctrl))
9440c3d0
KH
311{
312 if(tag == gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl"))
9fa72bd2 313 g_signal_stop_emission_by_name (buffer, "apply_tag");
9440c3d0 314}
865bb325 315}
9440c3d0
KH
316
317//-----------------------------------------------------------------------------
318// GtkTextCharPredicates for gtk_text_iter_*_find_char
319//-----------------------------------------------------------------------------
320
865bb325 321extern "C" {
9440c3d0 322static gboolean
e4161a2a 323pred_whitespace(gunichar ch, gpointer WXUNUSED(user_data))
9440c3d0
KH
324{
325 return g_unichar_isspace(ch);
326}
865bb325 327}
9440c3d0 328
865bb325 329extern "C" {
9440c3d0 330static gboolean
e4161a2a 331pred_non_whitespace (gunichar ch, gpointer WXUNUSED(user_data))
9440c3d0
KH
332{
333 return !g_unichar_isspace(ch);
334}
865bb325 335}
9440c3d0 336
865bb325 337extern "C" {
9440c3d0 338static gboolean
e4161a2a 339pred_nonpunct (gunichar ch, gpointer WXUNUSED(user_data))
9440c3d0
KH
340{
341 return !g_unichar_ispunct(ch);
342}
865bb325 343}
9440c3d0 344
865bb325 345extern "C" {
9440c3d0 346static gboolean
e4161a2a 347pred_nonpunct_or_slash (gunichar ch, gpointer WXUNUSED(user_data))
9440c3d0
KH
348{
349 return !g_unichar_ispunct(ch) || ch == '/';
350}
865bb325 351}
9440c3d0
KH
352
353//-----------------------------------------------------------------------------
354// Check for links between s and e and correct tags as necessary
355//-----------------------------------------------------------------------------
356
357// This function should be made match better while being efficient at one point.
358// Most probably with a row of regular expressions.
865bb325 359extern "C" {
9440c3d0
KH
360static void
361au_check_word( GtkTextIter *s, GtkTextIter *e )
362{
363 static const char *URIPrefixes[] =
364 {
365 "http://",
366 "ftp://",
367 "www.",
368 "ftp.",
369 "mailto://",
370 "https://",
371 "file://",
372 "nntp://",
373 "news://",
374 "telnet://",
375 "mms://",
376 "gopher://",
377 "prospero://",
378 "wais://",
379 };
380
381 GtkTextIter start = *s, end = *e;
382 GtkTextBuffer *buffer = gtk_text_iter_get_buffer(s);
418cf02e 383
9440c3d0
KH
384 // Get our special link tag
385 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl");
386
387 // Get rid of punctuation from beginning and end.
388 // Might want to move this to au_check_range if an improved link checking doesn't
389 // use some intelligent punctuation checking itself (beware of undesired iter modifications).
390 if(g_unichar_ispunct( gtk_text_iter_get_char( &start ) ) )
391 gtk_text_iter_forward_find_char( &start, pred_nonpunct, NULL, e );
392
393 gtk_text_iter_backward_find_char( &end, pred_nonpunct_or_slash, NULL, &start );
394 gtk_text_iter_forward_char(&end);
395
9ce97705 396 wxGtkString text(gtk_text_iter_get_text( &start, &end ));
9440c3d0
KH
397 size_t len = strlen(text), prefix_len;
398 size_t n;
399
400 for( n = 0; n < WXSIZEOF(URIPrefixes); ++n )
401 {
402 prefix_len = strlen(URIPrefixes[n]);
403 if((len > prefix_len) && !strncasecmp(text, URIPrefixes[n], prefix_len))
404 break;
405 }
406
407 if(n < WXSIZEOF(URIPrefixes))
408 {
9fa72bd2
MR
409 gulong signal_id = g_signal_handler_find (buffer,
410 (GSignalMatchType) (G_SIGNAL_MATCH_FUNC),
411 0, 0, NULL,
412 (gpointer)au_apply_tag_callback, NULL);
9440c3d0 413
9fa72bd2 414 g_signal_handler_block (buffer, signal_id);
9440c3d0 415 gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
9fa72bd2 416 g_signal_handler_unblock (buffer, signal_id);
9440c3d0
KH
417 }
418}
865bb325 419}
9440c3d0 420
865bb325 421extern "C" {
9440c3d0
KH
422static void
423au_check_range(GtkTextIter *s,
424 GtkTextIter *range_end)
425{
426 GtkTextIter range_start = *s;
427 GtkTextIter word_end;
428 GtkTextBuffer *buffer = gtk_text_iter_get_buffer(s);
429 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "wxUrl");
430
431 gtk_text_buffer_remove_tag(buffer, tag, s, range_end);
432
433 if(g_unichar_isspace(gtk_text_iter_get_char(&range_start)))
434 gtk_text_iter_forward_find_char(&range_start, pred_non_whitespace, NULL, range_end);
435
436 while(!gtk_text_iter_equal(&range_start, range_end))
437 {
438 word_end = range_start;
439 gtk_text_iter_forward_find_char(&word_end, pred_whitespace, NULL, range_end);
440
441 // Now we should have a word delimited by range_start and word_end, correct link tags
442 au_check_word(&range_start, &word_end);
443
444 range_start = word_end;
445 gtk_text_iter_forward_find_char(&range_start, pred_non_whitespace, NULL, range_end);
446 }
447}
865bb325 448}
9440c3d0
KH
449
450//-----------------------------------------------------------------------------
451// "insert-text" for GtkTextBuffer
452//-----------------------------------------------------------------------------
453
865bb325 454extern "C" {
9440c3d0 455static void
e4161a2a 456au_insert_text_callback(GtkTextBuffer * WXUNUSED(buffer),
9440c3d0
KH
457 GtkTextIter *end,
458 gchar *text,
459 gint len,
460 wxTextCtrl *win)
461{
462 if (!len || !(win->GetWindowStyleFlag() & wxTE_AUTO_URL) )
463 return;
464
465 GtkTextIter start = *end;
466 gtk_text_iter_backward_chars(&start, g_utf8_strlen(text, len));
467
468 GtkTextIter line_start = start;
469 GtkTextIter line_end = *end;
470 GtkTextIter words_start = start;
471 GtkTextIter words_end = *end;
472
473 gtk_text_iter_set_line(&line_start, gtk_text_iter_get_line(&start));
474 gtk_text_iter_forward_to_line_end(&line_end);
475 gtk_text_iter_backward_find_char(&words_start, pred_whitespace, NULL, &line_start);
476 gtk_text_iter_forward_find_char(&words_end, pred_whitespace, NULL, &line_end);
477
478 au_check_range(&words_start, &words_end);
479}
865bb325 480}
9440c3d0
KH
481
482//-----------------------------------------------------------------------------
483// "delete-range" for GtkTextBuffer
484//-----------------------------------------------------------------------------
485
865bb325 486extern "C" {
9440c3d0 487static void
e4161a2a 488au_delete_range_callback(GtkTextBuffer * WXUNUSED(buffer),
9440c3d0
KH
489 GtkTextIter *start,
490 GtkTextIter *end,
491 wxTextCtrl *win)
492{
493 if( !(win->GetWindowStyleFlag() & wxTE_AUTO_URL) )
494 return;
495
496 GtkTextIter line_start = *start, line_end = *end;
497
498 gtk_text_iter_set_line(&line_start, gtk_text_iter_get_line(start));
499 gtk_text_iter_forward_to_line_end(&line_end);
500 gtk_text_iter_backward_find_char(start, pred_whitespace, NULL, &line_start);
501 gtk_text_iter_forward_find_char(end, pred_whitespace, NULL, &line_end);
502
503 au_check_range(start, end);
504}
865bb325 505}
9440c3d0
KH
506
507
c801d85f 508//-----------------------------------------------------------------------------
2f2aa628 509// "changed"
c801d85f
KB
510//-----------------------------------------------------------------------------
511
865bb325 512extern "C" {
805dd538 513static void
e4161a2a 514gtk_text_changed_callback( GtkWidget * WXUNUSED(widget), wxTextCtrl *win )
484e45bf 515{
ce2f50e3
VZ
516 if ( win->IgnoreTextUpdate() )
517 return;
518
a2053b27 519 if (!win->m_hasVMT) return;
805dd538 520
6964cbba
VZ
521 if ( win->MarkDirtyOnChange() )
522 win->MarkDirty();
a8bf1826 523
ee2ec18e 524 win->SendTextUpdatedEvent();
6de97a3b 525}
865bb325 526}
112892b9 527
c85f2eb1
VZ
528//-----------------------------------------------------------------------------
529// clipboard events: "copy-clipboard", "cut-clipboard", "paste-clipboard"
530//-----------------------------------------------------------------------------
531
532// common part of the event handlers below
533static void
534handle_text_clipboard_callback( GtkWidget *widget, wxTextCtrl *win,
9eddec69 535 wxEventType eventType, const gchar * signal_name)
c85f2eb1
VZ
536{
537 wxClipboardTextEvent event( eventType, win->GetId() );
538 event.SetEventObject( win );
539 if ( win->GetEventHandler()->ProcessEvent( event ) )
540 {
541 // don't let the default processing to take place if we did something
542 // ourselves in the event handler
9eddec69 543 g_signal_stop_emission_by_name (widget, signal_name);
c85f2eb1
VZ
544 }
545}
546
547extern "C" {
548static void
549gtk_copy_clipboard_callback( GtkWidget *widget, wxTextCtrl *win )
550{
9eddec69
WS
551 handle_text_clipboard_callback(
552 widget, win, wxEVT_COMMAND_TEXT_COPY, "copy-clipboard" );
c85f2eb1
VZ
553}
554
555static void
556gtk_cut_clipboard_callback( GtkWidget *widget, wxTextCtrl *win )
557{
9eddec69
WS
558 handle_text_clipboard_callback(
559 widget, win, wxEVT_COMMAND_TEXT_CUT, "cut-clipboard" );
c85f2eb1
VZ
560}
561
562static void
563gtk_paste_clipboard_callback( GtkWidget *widget, wxTextCtrl *win )
564{
9eddec69
WS
565 handle_text_clipboard_callback(
566 widget, win, wxEVT_COMMAND_TEXT_PASTE, "paste-clipboard" );
c85f2eb1
VZ
567}
568}
569
41b81aed
RR
570//-----------------------------------------------------------------------------
571// "expose_event" from scrolled window and textview
572//-----------------------------------------------------------------------------
573
865bb325 574extern "C" {
41b81aed 575static gboolean
e4161a2a
VZ
576gtk_text_exposed_callback( GtkWidget * WXUNUSED(widget),
577 GdkEventExpose * WXUNUSED(event),
578 wxTextCtrl * WXUNUSED(win) )
41b81aed
RR
579{
580 return TRUE;
581}
865bb325 582}
1c35b54e 583
1c35b54e 584
2f2aa628
RR
585//-----------------------------------------------------------------------------
586// wxTextCtrl
587//-----------------------------------------------------------------------------
588
9d112688 589IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxTextCtrlBase)
2f2aa628 590
9d112688 591BEGIN_EVENT_TABLE(wxTextCtrl, wxTextCtrlBase)
2830bf19 592 EVT_CHAR(wxTextCtrl::OnChar)
e702ff0f
JS
593
594 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
595 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
596 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
597 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
598 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
599
600 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
601 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
602 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
603 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
604 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
9440c3d0 605
9440c3d0
KH
606 // wxTE_AUTO_URL wxTextUrl support. Currently only creates
607 // wxTextUrlEvent in the same cases as wxMSW, more can be added here.
608 EVT_MOTION (wxTextCtrl::OnUrlMouseEvent)
609 EVT_LEFT_DOWN (wxTextCtrl::OnUrlMouseEvent)
610 EVT_LEFT_UP (wxTextCtrl::OnUrlMouseEvent)
611 EVT_LEFT_DCLICK (wxTextCtrl::OnUrlMouseEvent)
612 EVT_RIGHT_DOWN (wxTextCtrl::OnUrlMouseEvent)
613 EVT_RIGHT_UP (wxTextCtrl::OnUrlMouseEvent)
614 EVT_RIGHT_DCLICK(wxTextCtrl::OnUrlMouseEvent)
c801d85f
KB
615END_EVENT_TABLE()
616
01041145 617void wxTextCtrl::Init()
f5abe911 618{
6964cbba 619 m_dontMarkDirty =
7d8268a1 620 m_modified = false;
6964cbba 621
f6519b40
VZ
622 m_countUpdatesToIgnore = 0;
623
7d8268a1 624 SetUpdateFont(false);
6964cbba 625
85396430 626 m_text = NULL;
5a3ef194
PC
627 m_freezeCount = 0;
628 m_showPositionOnThaw = NULL;
9440c3d0
KH
629 m_gdkHandCursor = NULL;
630 m_gdkXTermCursor = NULL;
9440c3d0
KH
631}
632
633wxTextCtrl::~wxTextCtrl()
634{
9440c3d0
KH
635 if(m_gdkHandCursor)
636 gdk_cursor_unref(m_gdkHandCursor);
637 if(m_gdkXTermCursor)
638 gdk_cursor_unref(m_gdkXTermCursor);
f5abe911 639}
13289f04 640
13111b2a
VZ
641wxTextCtrl::wxTextCtrl( wxWindow *parent,
642 wxWindowID id,
643 const wxString &value,
644 const wxPoint &pos,
645 const wxSize &size,
646 long style,
647 const wxValidator& validator,
648 const wxString &name )
f5abe911 649{
01041145
VZ
650 Init();
651
f5abe911
RR
652 Create( parent, id, value, pos, size, style, validator, name );
653}
c801d85f 654
13111b2a
VZ
655bool wxTextCtrl::Create( wxWindow *parent,
656 wxWindowID id,
657 const wxString &value,
658 const wxPoint &pos,
659 const wxSize &size,
660 long style,
661 const wxValidator& validator,
662 const wxString &name )
c801d85f 663{
4dcaf11a
RR
664 if (!PreCreation( parent, pos, size ) ||
665 !CreateBase( parent, id, pos, size, style, validator, name ))
666 {
223d09f6 667 wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
7d8268a1 668 return false;
4dcaf11a 669 }
6de97a3b 670
2830bf19 671 bool multi_line = (style & wxTE_MULTILINE) != 0;
a8bf1826 672
ab46dc18 673 if (multi_line)
2830bf19 674 {
fab591c5
RR
675 // Create view
676 m_text = gtk_text_view_new();
a8bf1826 677
41b81aed 678 m_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
a8bf1826 679
5a3ef194
PC
680 // create "ShowPosition" marker
681 GtkTextIter iter;
682 gtk_text_buffer_get_start_iter(m_buffer, &iter);
683 gtk_text_buffer_create_mark(m_buffer, "ShowPosition", &iter, true);
684
fab591c5
RR
685 // create scrolled window
686 m_widget = gtk_scrolled_window_new( NULL, NULL );
687 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( m_widget ),
09b86e69
VZ
688 GTK_POLICY_AUTOMATIC,
689 style & wxTE_NO_VSCROLL
690 ? GTK_POLICY_NEVER
691 : GTK_POLICY_AUTOMATIC );
add7cadd
PC
692 // for ScrollLines/Pages
693 m_scrollBar[1] = (GtkRange*)((GtkScrolledWindow*)m_widget)->vscrollbar;
a8bf1826 694
fab591c5
RR
695 // Insert view into scrolled window
696 gtk_container_add( GTK_CONTAINER(m_widget), m_text );
a8bf1826 697
927637fd 698 GTKSetWrapMode();
805dd538 699
6493aaca 700 GtkScrolledWindowSetBorder(m_widget, style);
7d8268a1 701
e327fddf
KH
702 gtk_widget_add_events( GTK_WIDGET(m_text), GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK );
703
055e633d 704 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2830bf19
RR
705 }
706 else
707 {
fab591c5 708 // a single-line text control: no need for scrollbars
2830bf19 709 m_widget =
1c35b54e 710 m_text = gtk_entry_new();
44c5573d 711
02a6e358 712 if (style & wxNO_BORDER)
7d1fea10 713 g_object_set (m_text, "has-frame", FALSE, NULL);
2830bf19 714 }
484e45bf 715
db434467 716 m_parent->DoAddChild( this );
eda40bfc 717
76fcf0f2 718 m_focusWidget = m_text;
db434467 719
abdeb9e7 720 PostCreation(size);
484e45bf 721
2830bf19 722 if (multi_line)
0c131a5a 723 {
2830bf19 724 gtk_widget_show(m_text);
0c131a5a 725 }
13289f04 726
4a3f5ad0
RR
727 // We want to be notified about text changes.
728 if (multi_line)
729 {
730 g_signal_connect (m_buffer, "changed",
731 G_CALLBACK (gtk_text_changed_callback), this);
732 }
733 else
734 {
735 g_signal_connect (m_text, "changed",
736 G_CALLBACK (gtk_text_changed_callback), this);
737 }
738
7d8268a1 739 if (!value.empty())
2830bf19 740 {
fab591c5 741 SetValue( value );
2830bf19 742 }
484e45bf 743
2830bf19 744 if (style & wxTE_PASSWORD)
927637fd 745 GTKSetVisibility();
8bbe427f 746
2830bf19 747 if (style & wxTE_READONLY)
927637fd 748 GTKSetEditable();
98a8daf4 749
927637fd
VZ
750 // left justification (alignment) is the default anyhow
751 if ( style & (wxTE_RIGHT | wxTE_CENTRE) )
752 GTKSetJustification();
7d8268a1 753
fab591c5
RR
754 if (multi_line)
755 {
4a3f5ad0 756 // Handle URLs on multi-line controls with wxTE_AUTO_URL style
9440c3d0
KH
757 if (style & wxTE_AUTO_URL)
758 {
759 GtkTextIter start, end;
760 m_gdkHandCursor = gdk_cursor_new(GDK_HAND2);
761 m_gdkXTermCursor = gdk_cursor_new(GDK_XTERM);
762
763 // We create our wxUrl tag here for slight efficiency gain - we
764 // don't have to check for the tag existance in callbacks,
765 // hereby it's guaranteed to exist.
766 gtk_text_buffer_create_tag(m_buffer, "wxUrl",
767 "foreground", "blue",
768 "underline", PANGO_UNDERLINE_SINGLE,
769 NULL);
770
771 // Check for URLs after each text change
9fa72bd2
MR
772 g_signal_connect_after (m_buffer, "insert_text",
773 G_CALLBACK (au_insert_text_callback), this);
774 g_signal_connect_after (m_buffer, "delete_range",
775 G_CALLBACK (au_delete_range_callback), this);
9440c3d0
KH
776
777 // Block all wxUrl tag applying unless we do it ourselves, in which case we
778 // block this callback temporarily. This takes care of gtk+ internal
779 // gtk_text_buffer_insert_range* calls that would copy our URL tag otherwise,
780 // which is undesired because only a part of the URL might be copied.
781 // The insert-text signal emitted inside it will take care of newly formed
782 // or wholly copied URLs.
9fa72bd2
MR
783 g_signal_connect (m_buffer, "apply_tag",
784 G_CALLBACK (au_apply_tag_callback), NULL);
9440c3d0
KH
785
786 // Check for URLs in the initial string passed to Create
787 gtk_text_buffer_get_start_iter(m_buffer, &start);
788 gtk_text_buffer_get_end_iter(m_buffer, &end);
789 au_check_range(&start, &end);
790 }
fab591c5 791 }
0ec1179b 792
c85f2eb1
VZ
793 g_signal_connect (m_text, "copy-clipboard",
794 G_CALLBACK (gtk_copy_clipboard_callback), this);
795 g_signal_connect (m_text, "cut-clipboard",
796 G_CALLBACK (gtk_cut_clipboard_callback), this);
797 g_signal_connect (m_text, "paste-clipboard",
798 G_CALLBACK (gtk_paste_clipboard_callback), this);
799
65045edd 800 m_cursor = wxCursor( wxCURSOR_IBEAM );
13111b2a 801
7d8268a1 802 return true;
2830bf19 803}
484e45bf 804
0ec1179b
VZ
805GtkEditable *wxTextCtrl::GetEditable() const
806{
807 wxCHECK_MSG( IsSingleLine(), NULL, "shouldn't be called for multiline" );
808
809 return GTK_EDITABLE(m_text);
810}
811
927637fd
VZ
812// ----------------------------------------------------------------------------
813// flags handling
814// ----------------------------------------------------------------------------
815
816void wxTextCtrl::GTKSetEditable()
817{
818 gboolean editable = !HasFlag(wxTE_READONLY);
819 if ( IsSingleLine() )
820 gtk_editable_set_editable(GTK_EDITABLE(m_text), editable);
821 else
822 gtk_text_view_set_editable(GTK_TEXT_VIEW(m_text), editable);
823}
824
825void wxTextCtrl::GTKSetVisibility()
826{
827 // VZ: shouldn't we assert if wxTE_PASSWORD is set for multiline control?
828 if ( IsSingleLine() )
829 gtk_entry_set_visibility(GTK_ENTRY(m_text), !HasFlag(wxTE_PASSWORD));
830}
831
832void wxTextCtrl::GTKSetWrapMode()
833{
834 // no wrapping in single line controls
835 if ( !IsMultiLine() )
836 return;
837
838 // translate wx wrapping style to GTK+
839 GtkWrapMode wrap;
840 if ( HasFlag( wxTE_DONTWRAP ) )
841 wrap = GTK_WRAP_NONE;
842 else if ( HasFlag( wxTE_CHARWRAP ) )
843 wrap = GTK_WRAP_CHAR;
844 else if ( HasFlag( wxTE_WORDWRAP ) )
845 wrap = GTK_WRAP_WORD;
846 else // HasFlag(wxTE_BESTWRAP) always true as wxTE_BESTWRAP == 0
847 {
848 // GTK_WRAP_WORD_CHAR seems to be new in GTK+ 2.4
849#ifdef __WXGTK24__
850 if ( !gtk_check_version(2,4,0) )
851 {
852 wrap = GTK_WRAP_WORD_CHAR;
853 }
854 else
855#endif // __WXGTK24__
856 wrap = GTK_WRAP_WORD;
857 }
858
859 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), wrap );
860}
861
862void wxTextCtrl::GTKSetJustification()
863{
864 if ( IsMultiLine() )
865 {
866 GtkJustification just;
867 if ( HasFlag(wxTE_RIGHT) )
868 just = GTK_JUSTIFY_RIGHT;
869 else if ( HasFlag(wxTE_CENTRE) )
870 just = GTK_JUSTIFY_CENTER;
871 else // wxTE_LEFT == 0
872 just = GTK_JUSTIFY_LEFT;
873
41e2aad5 874 gtk_text_view_set_justification(GTK_TEXT_VIEW(m_text), just);
927637fd
VZ
875 }
876 else // single line
877 {
878#ifdef __WXGTK24__
879 // gtk_entry_set_alignment was introduced in gtk+-2.3.5
880 if (!gtk_check_version(2,4,0))
881 {
882 gfloat align;
883 if ( HasFlag(wxTE_RIGHT) )
884 align = 1.0;
885 else if ( HasFlag(wxTE_CENTRE) )
886 align = 0.5;
887 else // single line
888 align = 0.0;
889
890 gtk_entry_set_alignment(GTK_ENTRY(m_text), align);
891 }
892#endif // __WXGTK24__
893 }
894
895}
896
897void wxTextCtrl::SetWindowStyleFlag(long style)
898{
899 long styleOld = GetWindowStyleFlag();
900
901 wxTextCtrlBase::SetWindowStyleFlag(style);
902
903 if ( (style & wxTE_READONLY) != (styleOld & wxTE_READONLY) )
904 GTKSetEditable();
905
906 if ( (style & wxTE_PASSWORD) != (styleOld & wxTE_PASSWORD) )
907 GTKSetVisibility();
908
909 static const long flagsWrap = wxTE_WORDWRAP | wxTE_CHARWRAP | wxTE_DONTWRAP;
910 if ( (style & flagsWrap) != (styleOld & flagsWrap) )
911 GTKSetWrapMode();
912
913 static const long flagsAlign = wxTE_LEFT | wxTE_CENTRE | wxTE_RIGHT;
914 if ( (style & flagsAlign) != (styleOld & flagsAlign) )
915 GTKSetJustification();
916}
917
918// ----------------------------------------------------------------------------
919// control value
920// ----------------------------------------------------------------------------
921
03f38c58 922wxString wxTextCtrl::GetValue() const
c801d85f 923{
902725ee 924 wxCHECK_MSG( m_text != NULL, wxEmptyString, wxT("invalid text ctrl") );
8bbe427f 925
75812722 926 if ( IsMultiLine() )
2830bf19 927 {
fab591c5 928 GtkTextIter start;
41b81aed 929 gtk_text_buffer_get_start_iter( m_buffer, &start );
fab591c5 930 GtkTextIter end;
41b81aed 931 gtk_text_buffer_get_end_iter( m_buffer, &end );
e808cf8a 932 wxGtkString text(gtk_text_buffer_get_text(m_buffer, &start, &end, true));
5b87f8bf 933
6256849f 934 return wxGTK_CONV_BACK(text);
2830bf19 935 }
0ec1179b 936 else // single line
2830bf19 937 {
0ec1179b 938 return wxTextEntry::GetValue();
2830bf19 939 }
6de97a3b 940}
c801d85f 941
0d91b234
VZ
942wxFontEncoding wxTextCtrl::GetTextEncoding() const
943{
944 // GTK+ uses UTF-8 internally, we need to convert to it but from which
945 // encoding?
946
947 // first check the default text style (we intentionally don't check the
948 // style for the current position as it doesn't make sense for SetValue())
949 const wxTextAttr& style = GetDefaultStyle();
44cc96a8 950 wxFontEncoding enc = style.HasFontEncoding() ? style.GetFontEncoding()
0d91b234
VZ
951 : wxFONTENCODING_SYSTEM;
952
953 // fall back to the controls font if no style
954 if ( enc == wxFONTENCODING_SYSTEM && m_hasFont )
955 enc = GetFont().GetEncoding();
956
957 return enc;
958}
959
28fdd8db
VZ
960bool wxTextCtrl::IsEmpty() const
961{
962 if ( IsMultiLine() )
14be4734 963 return gtk_text_buffer_get_char_count(m_buffer) == 0;
28fdd8db 964
0ec1179b 965 return wxTextEntry::IsEmpty();
28fdd8db
VZ
966}
967
f6519b40 968void wxTextCtrl::DoSetValue( const wxString &value, int flags )
c801d85f 969{
223d09f6 970 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 971
6964cbba 972 m_modified = false;
6964cbba 973
0ec1179b
VZ
974 if ( !IsMultiLine() )
975 {
976 wxTextEntry::DoSetValue(value, flags);
977 return;
978 }
979
785d8330
VZ
980 wxFontEncoding enc = m_defaultStyle.HasFont()
981 ? m_defaultStyle.GetFont().GetEncoding()
982 : wxFONTENCODING_SYSTEM;
983 if ( enc == wxFONTENCODING_SYSTEM )
984 enc = GetTextEncoding();
985
986 const wxCharBuffer buffer(wxGTK_CONV_ENC(value, enc));
7e0fff42 987 if ( !buffer )
2830bf19 988 {
7e0fff42
VZ
989 // see comment in WriteText() as to why we must warn the user about
990 // this
991 wxLogWarning(_("Failed to set text in the text control."));
992 return;
993 }
418cf02e 994
86e37f69
VZ
995 if ( !(flags & SetValue_SendEvent) )
996 {
0ec1179b 997 EnableTextChangedEvents(false);
86e37f69
VZ
998 }
999
0ec1179b
VZ
1000 gtk_text_buffer_set_text( m_buffer, buffer, strlen(buffer) );
1001
1002 if ( !m_defaultStyle.IsDefault() )
2830bf19 1003 {
0ec1179b
VZ
1004 GtkTextIter start, end;
1005 gtk_text_buffer_get_bounds( m_buffer, &start, &end );
1006 wxGtkTextApplyTagsFromAttr(m_widget, m_buffer, m_defaultStyle,
1007 &start, &end);
2830bf19 1008 }
86e37f69
VZ
1009
1010 if ( !(flags & SetValue_SendEvent) )
1011 {
0ec1179b 1012 EnableTextChangedEvents(true);
86e37f69 1013 }
0ec1179b 1014
929bd94e 1015 // This was added after discussion on the list
f6bcfd97 1016 SetInsertionPoint(0);
6de97a3b 1017}
c801d85f
KB
1018
1019void wxTextCtrl::WriteText( const wxString &text )
1020{
223d09f6 1021 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 1022
0ec1179b
VZ
1023 // we're changing the text programmatically
1024 DontMarkDirtyOnNextChange();
1025
1026 if ( !IsMultiLine() )
1027 {
1028 wxTextEntry::WriteText(text);
17665a2b 1029 return;
0ec1179b 1030 }
484e45bf 1031
0d91b234
VZ
1032 // check if we have a specific style for the current position
1033 wxFontEncoding enc = wxFONTENCODING_SYSTEM;
1034 wxTextAttr style;
44cc96a8 1035 if ( GetStyle(GetInsertionPoint(), style) && style.HasFontEncoding() )
0d91b234 1036 {
44cc96a8 1037 enc = style.GetFontEncoding();
0d91b234
VZ
1038 }
1039
1040 if ( enc == wxFONTENCODING_SYSTEM )
1041 enc = GetTextEncoding();
1042
1043 const wxCharBuffer buffer(wxGTK_CONV_ENC(text, enc));
a3669332
VZ
1044 if ( !buffer )
1045 {
0d91b234
VZ
1046 // we must log an error here as losing the text like this can be a
1047 // serious problem (e.g. imagine the document edited by user being
1048 // empty instead of containing the correct text)
1049 wxLogWarning(_("Failed to insert text in the control."));
a3669332
VZ
1050 return;
1051 }
1052
0ec1179b
VZ
1053 // First remove the selection if there is one
1054 // TODO: Is there an easier GTK specific way to do this?
1055 long from, to;
1056 GetSelection(&from, &to);
1057 if (from != to)
1058 Remove(from, to);
ea5449ae 1059
0ec1179b
VZ
1060 // Insert the text
1061 wxGtkTextInsert( m_text, m_buffer, m_defaultStyle, buffer );
a8bf1826 1062
0ec1179b
VZ
1063 GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(m_widget) );
1064 // Scroll to cursor, but only if scrollbar thumb is at the very bottom
1065 // won't work when frozen, text view is not using m_buffer then
1066 if (!IsFrozen() && wxIsSameDouble(adj->value, adj->upper - adj->page_size))
2830bf19 1067 {
0ec1179b
VZ
1068 gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text),
1069 gtk_text_buffer_get_insert( m_buffer ), 0.0, FALSE, 0.0, 1.0 );
2830bf19 1070 }
6de97a3b 1071}
c801d85f 1072
ba3f6b44
RR
1073wxString wxTextCtrl::GetLineText( long lineNo ) const
1074{
e808cf8a 1075 wxString result;
75812722 1076 if ( IsMultiLine() )
a6e21573 1077 {
905f2110 1078 GtkTextIter line;
41b81aed 1079 gtk_text_buffer_get_iter_at_line(m_buffer,&line,lineNo);
5440a04f 1080
8c6785f0 1081 GtkTextIter end = line;
5440a04f
VZ
1082 // avoid skipping to the next line end if this one is empty
1083 if ( !gtk_text_iter_ends_line(&line) )
1084 gtk_text_iter_forward_to_line_end(&end);
1085
e808cf8a
PC
1086 wxGtkString text(gtk_text_buffer_get_text(m_buffer, &line, &end, true));
1087 result = wxGTK_CONV_BACK(text);
a6e21573 1088 }
ba3f6b44 1089 else
a81258be 1090 {
e808cf8a
PC
1091 if (lineNo == 0)
1092 result = GetValue();
a81258be 1093 }
e808cf8a 1094 return result;
6de97a3b 1095}
c801d85f 1096
a81258be
RR
1097void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
1098{
ac0d36b5
HH
1099 /* If you implement this, don't forget to update the documentation!
1100 * (file docs/latex/wx/text.tex) */
223d09f6 1101 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
a81258be 1102}
112892b9 1103
0efe5ba7 1104bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
c801d85f 1105{
75812722 1106 if ( IsMultiLine() )
805dd538 1107 {
f29a481a 1108 GtkTextIter iter;
01207937
MR
1109
1110 if (pos > GetLastPosition())
1111 return false;
1112
f29a481a 1113 gtk_text_buffer_get_iter_at_offset(m_buffer, &iter, pos);
f29a481a 1114
50259962
MR
1115 if ( y )
1116 *y = gtk_text_iter_get_line(&iter);
1117 if ( x )
1118 *x = gtk_text_iter_get_line_offset(&iter);
805dd538 1119 }
96385642
VZ
1120 else // single line control
1121 {
2829d9e3 1122 if ( pos <= GTK_ENTRY(m_text)->text_length )
96385642 1123 {
50259962
MR
1124 if ( y )
1125 *y = 0;
1126 if ( x )
1127 *x = pos;
96385642
VZ
1128 }
1129 else
1130 {
1131 // index out of bounds
7d8268a1 1132 return false;
96385642 1133 }
8bbe427f 1134 }
96385642 1135
7d8268a1 1136 return true;
6de97a3b 1137}
c801d85f 1138
e3ca08dd 1139long wxTextCtrl::XYToPosition(long x, long y ) const
c801d85f 1140{
75812722
VZ
1141 if ( IsSingleLine() )
1142 return 0;
805dd538 1143
f29a481a 1144 GtkTextIter iter;
21d23b88
MR
1145 if (y >= gtk_text_buffer_get_line_count (m_buffer))
1146 return -1;
1147
1148 gtk_text_buffer_get_iter_at_line(m_buffer, &iter, y);
1149 if (x >= gtk_text_iter_get_chars_in_line (&iter))
1150 return -1;
1151
1152 return gtk_text_iter_get_offset(&iter) + x;
6de97a3b 1153}
c801d85f 1154
a81258be 1155int wxTextCtrl::GetLineLength(long lineNo) const
c801d85f 1156{
75812722 1157 if ( IsMultiLine() )
f29a481a
MR
1158 {
1159 int last_line = gtk_text_buffer_get_line_count( m_buffer ) - 1;
1160 if (lineNo > last_line)
1161 return -1;
1162
1163 GtkTextIter iter;
1164 gtk_text_buffer_get_iter_at_line(m_buffer, &iter, lineNo);
1165 // get_chars_in_line return includes paragraph delimiters, so need to subtract 1 IF it is not the last line
1166 return gtk_text_iter_get_chars_in_line(&iter) - ((lineNo == last_line) ? 0 : 1);
1167 }
1168 else
f29a481a
MR
1169 {
1170 wxString str = GetLineText (lineNo);
8e13c1ec 1171 return (int) str.length();
f29a481a 1172 }
6de97a3b 1173}
c801d85f 1174
a81258be 1175int wxTextCtrl::GetNumberOfLines() const
c801d85f 1176{
75812722 1177 if ( IsMultiLine() )
e894be20 1178 {
c68dea66 1179 return gtk_text_buffer_get_line_count( m_buffer );
e894be20
VZ
1180 }
1181 else // single line
1182 {
96385642 1183 return 1;
e894be20 1184 }
6de97a3b 1185}
c801d85f 1186
debe6624 1187void wxTextCtrl::SetInsertionPoint( long pos )
c801d85f 1188{
223d09f6 1189 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
3358d36e 1190
74c5a810 1191 if ( IsMultiLine() )
291a8f20 1192 {
fab591c5 1193 GtkTextIter iter;
41b81aed
RR
1194 gtk_text_buffer_get_iter_at_offset( m_buffer, &iter, pos );
1195 gtk_text_buffer_place_cursor( m_buffer, &iter );
5a3ef194
PC
1196 GtkTextMark* mark = gtk_text_buffer_get_insert(m_buffer);
1197 if (IsFrozen())
1198 // defer until Thaw, text view is not using m_buffer now
1199 m_showPositionOnThaw = mark;
1200 else
1201 gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(m_text), mark);
ac0d36b5 1202 }
0ec1179b 1203 else // single line
291a8f20 1204 {
0ec1179b 1205 wxTextEntry::SetInsertionPoint(pos);
291a8f20 1206 }
6de97a3b 1207}
c801d85f 1208
debe6624 1209void wxTextCtrl::SetEditable( bool editable )
c801d85f 1210{
223d09f6 1211 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 1212
75812722 1213 if ( IsMultiLine() )
fab591c5 1214 {
fab591c5 1215 gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text), editable );
fab591c5 1216 }
0ec1179b 1217 else // single line
fab591c5 1218 {
0ec1179b 1219 wxTextEntry::SetEditable(editable);
fab591c5 1220 }
6de97a3b 1221}
c801d85f 1222
68df5777
RR
1223bool wxTextCtrl::Enable( bool enable )
1224{
1225 if (!wxWindowBase::Enable(enable))
1226 {
1227 // nothing to do
7d8268a1 1228 return false;
68df5777 1229 }
f6bcfd97 1230
81c882b6 1231 gtk_widget_set_sensitive( m_text, enable );
68df5777 1232
7d8268a1 1233 return true;
68df5777
RR
1234}
1235
fdca68a6 1236// wxGTK-specific: called recursively by Enable,
47a8a4d5 1237// to give widgets an opportunity to correct their colours after they
fdca68a6 1238// have been changed by Enable
e4161a2a 1239void wxTextCtrl::OnEnabled(bool WXUNUSED(enable))
fdca68a6
JS
1240{
1241 // If we have a custom background colour, we use this colour in both
1242 // disabled and enabled mode, or we end up with a different colour under the
1243 // text.
1244 wxColour oldColour = GetBackgroundColour();
1245 if (oldColour.Ok())
1246 {
1247 // Need to set twice or it'll optimize the useful stuff out
1248 if (oldColour == * wxWHITE)
1249 SetBackgroundColour(*wxBLACK);
1250 else
1251 SetBackgroundColour(*wxWHITE);
1252 SetBackgroundColour(oldColour);
1253 }
1254}
1255
3a9fa0d6
VZ
1256void wxTextCtrl::MarkDirty()
1257{
7d8268a1 1258 m_modified = true;
3a9fa0d6
VZ
1259}
1260
0efe5ba7
VZ
1261void wxTextCtrl::DiscardEdits()
1262{
7d8268a1 1263 m_modified = false;
0efe5ba7
VZ
1264}
1265
ce2f50e3 1266// ----------------------------------------------------------------------------
0ec1179b 1267// event handling
ce2f50e3
VZ
1268// ----------------------------------------------------------------------------
1269
0ec1179b
VZ
1270void wxTextCtrl::EnableTextChangedEvents(bool enable)
1271{
1272 if ( enable )
1273 {
1274 g_signal_handlers_unblock_by_func(GetTextObject(),
1275 (gpointer)gtk_text_changed_callback, this);
1276 }
1277 else // disable events
1278 {
1279 g_signal_handlers_block_by_func(GetTextObject(),
1280 (gpointer)gtk_text_changed_callback, this);
1281 }
1282}
1283
ce2f50e3
VZ
1284bool wxTextCtrl::IgnoreTextUpdate()
1285{
f6519b40 1286 if ( m_countUpdatesToIgnore > 0 )
ce2f50e3 1287 {
f6519b40 1288 m_countUpdatesToIgnore--;
ce2f50e3 1289
7d8268a1 1290 return true;
ce2f50e3
VZ
1291 }
1292
7d8268a1 1293 return false;
ce2f50e3
VZ
1294}
1295
6964cbba
VZ
1296bool wxTextCtrl::MarkDirtyOnChange()
1297{
1298 if ( m_dontMarkDirty )
1299 {
1300 m_dontMarkDirty = false;
1301
1302 return false;
1303 }
1304
1305 return true;
1306}
1307
debe6624 1308void wxTextCtrl::SetSelection( long from, long to )
c801d85f 1309{
223d09f6 1310 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 1311
2b5f62a0
VZ
1312 if (from == -1 && to == -1)
1313 {
1314 from = 0;
8e13c1ec 1315 to = GetValue().length();
2b5f62a0
VZ
1316 }
1317
75812722 1318 if ( IsMultiLine() )
fab591c5 1319 {
739e366a 1320 GtkTextIter fromi, toi;
41b81aed
RR
1321 gtk_text_buffer_get_iter_at_offset( m_buffer, &fromi, from );
1322 gtk_text_buffer_get_iter_at_offset( m_buffer, &toi, to );
739e366a 1323
41b81aed
RR
1324 gtk_text_buffer_place_cursor( m_buffer, &toi );
1325 gtk_text_buffer_move_mark_by_name( m_buffer, "selection_bound", &fromi );
fab591c5 1326 }
0ec1179b 1327 else // single line
fab591c5 1328 {
0ec1179b 1329 wxTextEntry::SetSelection(from, to);
fab591c5 1330 }
6de97a3b 1331}
c801d85f 1332
afbe906a 1333void wxTextCtrl::ShowPosition( long pos )
c801d85f 1334{
5a3ef194 1335 if (IsMultiLine())
afbe906a 1336 {
71aba833 1337 GtkTextIter iter;
5a3ef194
PC
1338 gtk_text_buffer_get_iter_at_offset(m_buffer, &iter, int(pos));
1339 GtkTextMark* mark = gtk_text_buffer_get_mark(m_buffer, "ShowPosition");
1340 gtk_text_buffer_move_mark(m_buffer, mark, &iter);
1341 if (IsFrozen())
1342 // defer until Thaw, text view is not using m_buffer now
1343 m_showPositionOnThaw = mark;
1344 else
1345 gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(m_text), mark);
afbe906a 1346 }
6de97a3b 1347}
c801d85f 1348
692c9b86
VZ
1349wxTextCtrlHitTestResult
1350wxTextCtrl::HitTest(const wxPoint& pt, long *pos) const
1351{
1352 if ( !IsMultiLine() )
1353 {
1354 // not supported
1355 return wxTE_HT_UNKNOWN;
1356 }
1357
1358 int x, y;
1359 gtk_text_view_window_to_buffer_coords
1360 (
1361 GTK_TEXT_VIEW(m_text),
1362 GTK_TEXT_WINDOW_TEXT,
1363 pt.x, pt.y,
1364 &x, &y
1365 );
1366
1367 GtkTextIter iter;
1368 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &iter, x, y);
1369 if ( pos )
1370 *pos = gtk_text_iter_get_offset(&iter);
1371
1372 return wxTE_HT_ON_TEXT;
1373}
1374
03f38c58 1375long wxTextCtrl::GetInsertionPoint() const
c801d85f 1376{
223d09f6 1377 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
8bbe427f 1378
75812722 1379 if ( IsMultiLine() )
fab591c5 1380 {
fab591c5
RR
1381 // There is no direct accessor for the cursor, but
1382 // internally, the cursor is the "mark" called
1383 // "insert" in the text view's btree structure.
a8bf1826 1384
41b81aed 1385 GtkTextMark *mark = gtk_text_buffer_get_insert( m_buffer );
fab591c5 1386 GtkTextIter cursor;
41b81aed 1387 gtk_text_buffer_get_iter_at_mark( m_buffer, &cursor, mark );
a8bf1826 1388
fab591c5
RR
1389 return gtk_text_iter_get_offset( &cursor );
1390 }
1391 else
fab591c5 1392 {
0ec1179b 1393 return wxTextEntry::GetInsertionPoint();
fab591c5 1394 }
6de97a3b 1395}
c801d85f 1396
7d8268a1 1397wxTextPos wxTextCtrl::GetLastPosition() const
c801d85f 1398{
223d09f6 1399 wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
8bbe427f 1400
2830bf19 1401 int pos = 0;
a8bf1826 1402
75812722 1403 if ( IsMultiLine() )
fab591c5 1404 {
fab591c5 1405 GtkTextIter end;
41b81aed 1406 gtk_text_buffer_get_end_iter( m_buffer, &end );
a8bf1826 1407
fab591c5 1408 pos = gtk_text_iter_get_offset( &end );
fab591c5 1409 }
0ec1179b 1410 else // single line
fab591c5 1411 {
0ec1179b 1412 pos = wxTextEntry::GetLastPosition();
fab591c5 1413 }
805dd538 1414
ac0d36b5 1415 return (long)pos;
6de97a3b 1416}
c801d85f 1417
debe6624 1418void wxTextCtrl::Remove( long from, long to )
c801d85f 1419{
223d09f6 1420 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 1421
75812722 1422 if ( IsMultiLine() )
581ee8a9 1423 {
581ee8a9 1424 GtkTextIter fromi, toi;
41b81aed
RR
1425 gtk_text_buffer_get_iter_at_offset( m_buffer, &fromi, from );
1426 gtk_text_buffer_get_iter_at_offset( m_buffer, &toi, to );
581ee8a9 1427
41b81aed 1428 gtk_text_buffer_delete( m_buffer, &fromi, &toi );
581ee8a9
VZ
1429 }
1430 else // single line
2df7be7f 1431 {
0ec1179b 1432 wxTextEntry::Remove(from, to);
2df7be7f 1433 }
6de97a3b 1434}
c801d85f 1435
03f38c58 1436void wxTextCtrl::Cut()
c801d85f 1437{
223d09f6 1438 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 1439
75812722 1440 if ( IsMultiLine() )
9fa72bd2 1441 g_signal_emit_by_name (m_text, "cut-clipboard");
bbde2e29 1442 else
0ec1179b 1443 wxTextEntry::Cut();
6de97a3b 1444}
c801d85f 1445
03f38c58 1446void wxTextCtrl::Copy()
c801d85f 1447{
223d09f6 1448 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 1449
75812722 1450 if ( IsMultiLine() )
9fa72bd2 1451 g_signal_emit_by_name (m_text, "copy-clipboard");
bbde2e29 1452 else
0ec1179b 1453 wxTextEntry::Copy();
6de97a3b 1454}
c801d85f 1455
03f38c58 1456void wxTextCtrl::Paste()
c801d85f 1457{
223d09f6 1458 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
8bbe427f 1459
75812722 1460 if ( IsMultiLine() )
9fa72bd2 1461 g_signal_emit_by_name (m_text, "paste-clipboard");
bbde2e29 1462 else
0ec1179b 1463 wxTextEntry::Paste();
ca8b28f2
JS
1464}
1465
1466// If the return values from and to are the same, there is no
1467// selection.
2d4cc5b6 1468void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
ca8b28f2 1469{
223d09f6 1470 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
bb69661b 1471
0ec1179b
VZ
1472 if ( !IsMultiLine() )
1473 {
1474 wxTextEntry::GetSelection(fromOut, toOut);
1475 return;
1476 }
1477
1478 gint from, to;
1479
1480 GtkTextIter ifrom, ito;
1481 if ( gtk_text_buffer_get_selection_bounds(m_buffer, &ifrom, &ito) )
1482 {
1483 from = gtk_text_iter_get_offset(&ifrom);
1484 to = gtk_text_iter_get_offset(&ito);
1485
1486 if ( from > to )
1487 {
1488 // exchange them to be compatible with wxMSW
1489 gint tmp = from;
1490 from = to;
1491 to = tmp;
1492 }
1493 }
1494 else // no selection
1495 {
1496 from =
1497 to = GetInsertionPoint();
1498 }
bb69661b 1499
2d4cc5b6
VZ
1500 if ( fromOut )
1501 *fromOut = from;
1502 if ( toOut )
1503 *toOut = to;
ca8b28f2
JS
1504}
1505
5b87f8bf 1506
ca8b28f2
JS
1507bool wxTextCtrl::IsEditable() const
1508{
7d8268a1 1509 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
05060eeb 1510
75812722 1511 if ( IsMultiLine() )
fdd55287
VZ
1512 {
1513 return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text));
1514 }
1515 else
1516 {
0ec1179b 1517 return wxTextEntry::IsEditable();
fdd55287 1518 }
ca8b28f2
JS
1519}
1520
0efe5ba7
VZ
1521bool wxTextCtrl::IsModified() const
1522{
1523 return m_modified;
1524}
1525
903f689b 1526void wxTextCtrl::OnChar( wxKeyEvent &key_event )
c801d85f 1527{
223d09f6 1528 wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
805dd538 1529
75812722 1530 if ( key_event.GetKeyCode() == WXK_RETURN )
da048e3d 1531 {
75812722
VZ
1532 if ( HasFlag(wxTE_PROCESS_ENTER) )
1533 {
1534 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1535 event.SetEventObject(this);
1536 event.SetString(GetValue());
1537 if ( GetEventHandler()->ProcessEvent(event) )
1538 return;
1539 }
a8bf1826 1540
75812722
VZ
1541 // FIXME: this is not the right place to do it, wxDialog::OnCharHook()
1542 // probably is
1543 if ( IsSingleLine() )
da048e3d 1544 {
75812722
VZ
1545 // This will invoke the dialog default action, such
1546 // as the clicking the default button.
2b328fc9 1547
75812722
VZ
1548 wxWindow *top_frame = m_parent;
1549 while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1550 top_frame = top_frame->GetParent();
1551
1552 if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
2b328fc9 1553 {
75812722
VZ
1554 GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1555
1556 if (window->default_widget)
1557 {
1558 gtk_widget_activate (window->default_widget);
1559 return;
1560 }
2b328fc9 1561 }
13111b2a 1562 }
da048e3d
RR
1563 }
1564
2830bf19 1565 key_event.Skip();
6de97a3b 1566}
c801d85f 1567
03f38c58 1568GtkWidget* wxTextCtrl::GetConnectWidget()
e3e65dac 1569{
ae0bdb01 1570 return GTK_WIDGET(m_text);
6de97a3b 1571}
e3e65dac 1572
ef5c70f9 1573GdkWindow *wxTextCtrl::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
903f689b 1574{
75812722 1575 if ( IsMultiLine() )
fab591c5 1576 {
ef5c70f9
VZ
1577 return gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
1578 GTK_TEXT_WINDOW_TEXT );
fab591c5 1579 }
ae0bdb01 1580 else
fab591c5 1581 {
ef5c70f9 1582 return GTK_ENTRY(m_text)->text_area;
fab591c5 1583 }
903f689b 1584}
e3e65dac 1585
bb69661b
VZ
1586// the font will change for subsequent text insertiongs
1587bool wxTextCtrl::SetFont( const wxFont &font )
868a2826 1588{
7d8268a1 1589 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
8bbe427f 1590
a66954a6 1591 if ( !wxTextCtrlBase::SetFont(font) )
bb69661b
VZ
1592 {
1593 // font didn't change, nothing to do
7d8268a1 1594 return false;
bb69661b
VZ
1595 }
1596
75812722 1597 if ( IsMultiLine() )
bb69661b 1598 {
7d8268a1 1599 SetUpdateFont(true);
bb69661b 1600
1ff4714d
VZ
1601 m_defaultStyle.SetFont(font);
1602
01041145 1603 ChangeFontGlobally();
bb69661b
VZ
1604 }
1605
7d8268a1 1606 return true;
58614078
RR
1607}
1608
01041145
VZ
1609void wxTextCtrl::ChangeFontGlobally()
1610{
1611 // this method is very inefficient and hence should be called as rarely as
1612 // possible!
c04ec496
VZ
1613 //
1614 // TODO: it can be implemented much more efficiently for GTK2
75812722 1615 wxASSERT_MSG( IsMultiLine(),
22800f32 1616 _T("shouldn't be called for single line controls") );
01041145
VZ
1617
1618 wxString value = GetValue();
7d8268a1 1619 if ( !value.empty() )
01041145 1620 {
7d8268a1 1621 SetUpdateFont(false);
572aeb77 1622
01041145
VZ
1623 Clear();
1624 AppendText(value);
01041145
VZ
1625 }
1626}
1627
17665a2b
VZ
1628bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1629{
1630 if ( !wxControl::SetForegroundColour(colour) )
7d8268a1 1631 return false;
17665a2b
VZ
1632
1633 // update default fg colour too
1634 m_defaultStyle.SetTextColour(colour);
1635
7d8268a1 1636 return true;
17665a2b
VZ
1637}
1638
f03fc89f 1639bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
68dda785 1640{
7d8268a1 1641 wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
a81258be 1642
1f477433 1643 if ( !wxControl::SetBackgroundColour( colour ) )
7d8268a1 1644 return false;
3358d36e 1645
f03fc89f 1646 if (!m_backgroundColour.Ok())
7d8268a1 1647 return false;
8bbe427f 1648
17665a2b
VZ
1649 // change active background color too
1650 m_defaultStyle.SetBackgroundColour( colour );
1651
7d8268a1 1652 return true;
58614078
RR
1653}
1654
eda40bfc 1655bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
17665a2b 1656{
75812722 1657 if ( IsMultiLine() )
17665a2b
VZ
1658 {
1659 if ( style.IsDefault() )
1660 {
1661 // nothing to do
7d8268a1 1662 return true;
17665a2b 1663 }
902725ee 1664
41b81aed 1665 gint l = gtk_text_buffer_get_char_count( m_buffer );
17665a2b 1666
7d8268a1 1667 wxCHECK_MSG( start >= 0 && end <= l, false,
cc3da3f8
RR
1668 _T("invalid range in wxTextCtrl::SetStyle") );
1669
1670 GtkTextIter starti, endi;
41b81aed
RR
1671 gtk_text_buffer_get_iter_at_offset( m_buffer, &starti, start );
1672 gtk_text_buffer_get_iter_at_offset( m_buffer, &endi, end );
cc3da3f8 1673
7b377ed9 1674 wxGtkTextApplyTagsFromAttr( m_widget, m_buffer, style, &starti, &endi );
902725ee 1675
7d8268a1 1676 return true;
17665a2b 1677 }
7b377ed9 1678 //else: single line text controls don't support styles
902725ee 1679
902725ee 1680 return false;
17665a2b
VZ
1681}
1682
f40fdaa3 1683void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
58614078 1684{
f40fdaa3 1685 gtk_widget_modify_style(m_text, style);
68dda785 1686}
f96aa4d9 1687
e702ff0f
JS
1688void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1689{
1690 Cut();
1691}
1692
1693void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1694{
1695 Copy();
1696}
1697
1698void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1699{
1700 Paste();
1701}
1702
1703void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1704{
1705 Undo();
1706}
1707
1708void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1709{
1710 Redo();
1711}
1712
1713void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1714{
1715 event.Enable( CanCut() );
1716}
1717
1718void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1719{
1720 event.Enable( CanCopy() );
1721}
1722
1723void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1724{
1725 event.Enable( CanPaste() );
1726}
1727
1728void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1729{
1730 event.Enable( CanUndo() );
1731}
1732
1733void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1734{
1735 event.Enable( CanRedo() );
1736}
65045edd 1737
f68586e5
VZ
1738wxSize wxTextCtrl::DoGetBestSize() const
1739{
1740 // FIXME should be different for multi-line controls...
0279e844 1741 wxSize ret( wxControl::DoGetBestSize() );
9f884528
RD
1742 wxSize best(80, ret.y);
1743 CacheBestSize(best);
1744 return best;
f68586e5 1745}
0cc7251e 1746
9cd6d737
VZ
1747// ----------------------------------------------------------------------------
1748// freeze/thaw
1749// ----------------------------------------------------------------------------
1750
0cc7251e
VZ
1751void wxTextCtrl::Freeze()
1752{
442a960c
PC
1753 wxCHECK_RET(m_text != NULL, wxT("invalid text ctrl"));
1754
0cc7251e
VZ
1755 if ( HasFlag(wxTE_MULTILINE) )
1756 {
5a3ef194 1757 if (m_freezeCount++ == 0)
41b81aed
RR
1758 {
1759 // freeze textview updates and remove buffer
9fa72bd2
MR
1760 g_signal_connect (m_text, "expose_event",
1761 G_CALLBACK (gtk_text_exposed_callback), this);
1762 g_signal_connect (m_widget, "expose_event",
1763 G_CALLBACK (gtk_text_exposed_callback), this);
41b81aed
RR
1764 gtk_widget_set_sensitive(m_widget, false);
1765 g_object_ref(m_buffer);
45388803 1766 GtkTextBuffer* buf_new = gtk_text_buffer_new(NULL);
442a960c 1767 GtkTextMark* mark = GTK_TEXT_VIEW(m_text)->first_para_mark;
45388803 1768 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), buf_new);
442a960c
PC
1769 // gtk_text_view_set_buffer adds its own reference
1770 g_object_unref(buf_new);
1771 // This mark should be deleted when the buffer is changed,
1772 // but it's not (in GTK+ up to at least 2.10.6).
1773 // Otherwise these anonymous marks start to build up in the buffer,
1774 // and Freeze takes longer and longer each time it is called.
1775 if (GTK_IS_TEXT_MARK(mark) && !gtk_text_mark_get_deleted(mark))
1776 gtk_text_buffer_delete_mark(m_buffer, mark);
0a164d4c 1777 }
41b81aed 1778 }
0cc7251e
VZ
1779}
1780
1781void wxTextCtrl::Thaw()
1782{
1783 if ( HasFlag(wxTE_MULTILINE) )
1784 {
5a3ef194 1785 wxCHECK_RET(m_freezeCount != 0, _T("Thaw() without matching Freeze()"));
41b81aed 1786
5a3ef194 1787 if (--m_freezeCount == 0)
41b81aed
RR
1788 {
1789 // Reattach buffer and thaw textview updates
1790 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), m_buffer);
1791 g_object_unref(m_buffer);
1792 gtk_widget_set_sensitive(m_widget, true);
9fa72bd2
MR
1793 g_signal_handlers_disconnect_by_func (m_widget,
1794 (gpointer) gtk_text_exposed_callback, this);
1795 g_signal_handlers_disconnect_by_func (m_text,
1796 (gpointer) gtk_text_exposed_callback, this);
5a3ef194
PC
1797 if (m_showPositionOnThaw != NULL)
1798 {
1799 gtk_text_view_scroll_mark_onscreen(
1800 GTK_TEXT_VIEW(m_text), m_showPositionOnThaw);
1801 m_showPositionOnThaw = NULL;
1802 }
41b81aed 1803 }
41b81aed 1804 }
0cc7251e 1805}
9cd6d737 1806
9440c3d0
KH
1807// ----------------------------------------------------------------------------
1808// wxTextUrlEvent passing if style & wxTE_AUTO_URL
1809// ----------------------------------------------------------------------------
1810
9440c3d0
KH
1811// FIXME: when dragging on a link the sample gets an "Unknown event".
1812// This might be an excessive event from us or a buggy wxMouseEvent::Moving() or
1813// a buggy sample, or something else
1814void wxTextCtrl::OnUrlMouseEvent(wxMouseEvent& event)
1815{
1816 event.Skip();
75812722 1817 if( !HasFlag(wxTE_AUTO_URL) )
9440c3d0
KH
1818 return;
1819
1820 gint x, y;
1821 GtkTextIter start, end;
1822 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(m_buffer),
1823 "wxUrl");
1824
1825 gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(m_text), GTK_TEXT_WINDOW_WIDGET,
1826 event.GetX(), event.GetY(), &x, &y);
1827
1828 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &end, x, y);
1829 if (!gtk_text_iter_has_tag(&end, tag))
1830 {
1831 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
1832 GTK_TEXT_WINDOW_TEXT), m_gdkXTermCursor);
1833 return;
1834 }
1835
1836 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text),
1837 GTK_TEXT_WINDOW_TEXT), m_gdkHandCursor);
1838
1839 start = end;
1840 if(!gtk_text_iter_begins_tag(&start, tag))
1841 gtk_text_iter_backward_to_tag_toggle(&start, tag);
1842 if(!gtk_text_iter_ends_tag(&end, tag))
1843 gtk_text_iter_forward_to_tag_toggle(&end, tag);
1844
1845 // Native context menu is probably not desired on an URL.
1846 // Consider making this dependant on ProcessEvent(wxTextUrlEvent) return value
1847 if(event.GetEventType() == wxEVT_RIGHT_DOWN)
1848 event.Skip(false);
1849
1850 wxTextUrlEvent url_event(m_windowId, event,
1851 gtk_text_iter_get_offset(&start),
1852 gtk_text_iter_get_offset(&end));
1853
1854 InitCommandEvent(url_event);
1855 // Is that a good idea? Seems not (pleasure with gtk_text_view_start_selection_drag)
1856 //event.Skip(!GetEventHandler()->ProcessEvent(url_event));
1857 GetEventHandler()->ProcessEvent(url_event);
1858}
9440c3d0 1859
8312c461
VZ
1860bool wxTextCtrl::GTKProcessEvent(wxEvent& event) const
1861{
1862 bool rc = wxTextCtrlBase::GTKProcessEvent(event);
1863
1864 // GtkTextView starts a drag operation when left mouse button is pressed
1865 // and ends it when it is released and if it doesn't get the release event
1866 // the next click on a control results in an assertion failure inside
1867 // gtk_text_view_start_selection_drag() which simply *kills* the program
1868 // without anything we can do about it, so always let GTK+ have this event
1869 return rc && (IsSingleLine() || event.GetEventType() != wxEVT_LEFT_UP);
1870}
1871
9d522606
RD
1872// static
1873wxVisualAttributes
1874wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1875{
1876 return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true);
1877}
28fcfbfe
VZ
1878
1879#endif // wxUSE_TEXTCTRL