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