1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/textctrl.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin, 2005 Mart Raudsepp
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
15 #include "wx/textctrl.h"
21 #include "wx/settings.h"
25 #include "wx/strconv.h"
26 #include "wx/fontutil.h" // for wxNativeFontInfo (GetNativeFontInfo())
28 #include <sys/types.h>
32 #include "wx/gtk/private.h"
34 // ----------------------------------------------------------------------------
36 // ----------------------------------------------------------------------------
39 static void wxGtkOnRemoveTag(GtkTextBuffer
*buffer
,
41 GtkTextIter
* WXUNUSED(start
),
42 GtkTextIter
* WXUNUSED(end
),
46 g_object_get (tag
, "name", &name
, NULL
);
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");
56 // remove all tags starting with the given prefix from the start..end range
58 wxGtkTextRemoveTagsWithPrefix(GtkTextBuffer
*text_buffer
,
63 gulong remove_handler_id
= g_signal_connect
67 G_CALLBACK(wxGtkOnRemoveTag
),
70 gtk_text_buffer_remove_all_tags(text_buffer
, start
, end
);
71 g_signal_handler_disconnect(text_buffer
, remove_handler_id
);
74 static void wxGtkTextApplyTagsFromAttr(GtkWidget
*text
,
75 GtkTextBuffer
*text_buffer
,
76 const wxTextAttr
& attr
,
80 static gchar buf
[1024];
85 wxGtkTextRemoveTagsWithPrefix(text_buffer
, "WXFONT", start
, end
);
87 wxFont
font(attr
.GetFont());
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
),
95 tag
= gtk_text_buffer_create_tag( text_buffer
, buf
,
96 "font-desc", font_description
,
98 gtk_text_buffer_apply_tag (text_buffer
, tag
, start
, end
);
100 if (font
.GetUnderlined())
102 g_snprintf(buf
, sizeof(buf
), "WXFONTUNDERLINE");
103 tag
= gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer
),
106 tag
= gtk_text_buffer_create_tag( text_buffer
, buf
,
107 "underline-set", TRUE
,
108 "underline", PANGO_UNDERLINE_SINGLE
,
110 gtk_text_buffer_apply_tag (text_buffer
, tag
, start
, end
);
114 if (attr
.HasTextColour())
116 wxGtkTextRemoveTagsWithPrefix(text_buffer
, "WXFORECOLOR", start
, end
);
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
),
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
);
129 if (attr
.HasBackgroundColour())
131 wxGtkTextRemoveTagsWithPrefix(text_buffer
, "WXBACKCOLOR", start
, end
);
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
),
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
);
144 if (attr
.HasAlignment())
146 GtkTextIter para_start
, para_end
= *end
;
147 gtk_text_buffer_get_iter_at_line( text_buffer
,
149 gtk_text_iter_get_line(start
) );
150 gtk_text_iter_forward_line(¶_end
);
152 wxGtkTextRemoveTagsWithPrefix(text_buffer
, "WXALIGNMENT", start
, end
);
154 GtkJustification align
;
155 switch (attr
.GetAlignment())
158 align
= GTK_JUSTIFY_LEFT
;
160 case wxTEXT_ALIGNMENT_RIGHT
:
161 align
= GTK_JUSTIFY_RIGHT
;
163 case wxTEXT_ALIGNMENT_CENTER
:
164 align
= GTK_JUSTIFY_CENTER
;
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
;
173 align
= GTK_JUSTIFY_LEFT
;
178 g_snprintf(buf
, sizeof(buf
), "WXALIGNMENT %d", align
);
179 tag
= gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer
),
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
);
187 if (attr
.HasLeftIndent())
189 // Indentation attribute
191 // Clear old indentation tags
192 GtkTextIter para_start
, para_end
= *end
;
193 gtk_text_buffer_get_iter_at_line( text_buffer
,
195 gtk_text_iter_get_line(start
) );
196 gtk_text_iter_forward_line(¶_end
);
198 wxGtkTextRemoveTagsWithPrefix(text_buffer
, "WXINDENT", start
, end
);
200 // Convert indent from 1/10th of a mm into pixels
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;
208 factor
= (float)gdk_screen_width() / gdk_screen_width_mm() / 10;
210 const int indent
= (int)(factor
* attr
.GetLeftIndent());
211 const int subIndent
= (int)(factor
* attr
.GetLeftSubIndent());
219 gsubindent
= -subIndent
;
223 gindent
= -subIndent
;
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
),
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
, ¶_start
, ¶_end
);
241 GtkTextIter para_start
, para_end
= *end
;
242 gtk_text_buffer_get_iter_at_line( text_buffer
,
244 gtk_text_iter_get_line(start
) );
245 gtk_text_iter_forward_line(¶_end
);
247 wxGtkTextRemoveTagsWithPrefix(text_buffer
, "WXTABS", start
, end
);
249 const wxArrayInt
& tabs
= attr
.GetTabs();
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
]);
256 const wxWX2MBbuf buftag
= tagname
.utf8_str();
258 tag
= gtk_text_tag_table_lookup( gtk_text_buffer_get_tag_table( text_buffer
),
262 // Factor to convert from 1/10th of a mm into pixels
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;
270 factor
= (float)gdk_screen_width() / gdk_screen_width_mm() / 10;
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
));
275 tag
= gtk_text_buffer_create_tag( text_buffer
, buftag
,
276 "tabs", tabArray
, NULL
);
277 pango_tab_array_free(tabArray
);
279 gtk_text_buffer_apply_tag (text_buffer
, tag
, ¶_start
, ¶_end
);
283 static void wxGtkTextInsert(GtkWidget
*text
,
284 GtkTextBuffer
*text_buffer
,
285 const wxTextAttr
& attr
,
286 const wxCharBuffer
& buffer
)
290 GtkTextIter iter
, start
;
292 gtk_text_buffer_get_iter_at_mark( text_buffer
, &iter
,
293 gtk_text_buffer_get_insert (text_buffer
) );
294 start_offset
= gtk_text_iter_get_offset (&iter
);
295 gtk_text_buffer_insert( text_buffer
, &iter
, buffer
, strlen(buffer
) );
297 gtk_text_buffer_get_iter_at_offset (text_buffer
, &start
, start_offset
);
299 wxGtkTextApplyTagsFromAttr(text
, text_buffer
, attr
, &start
, &iter
);
302 // Implementation of wxTE_AUTO_URL for wxGTK2 by Mart Raudsepp,
306 au_apply_tag_callback(GtkTextBuffer
*buffer
,
308 GtkTextIter
* WXUNUSED(start
),
309 GtkTextIter
* WXUNUSED(end
),
310 gpointer
WXUNUSED(textctrl
))
312 if(tag
== gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer
), "wxUrl"))
313 g_signal_stop_emission_by_name (buffer
, "apply_tag");
317 //-----------------------------------------------------------------------------
318 // GtkTextCharPredicates for gtk_text_iter_*_find_char
319 //-----------------------------------------------------------------------------
323 pred_whitespace(gunichar ch
, gpointer
WXUNUSED(user_data
))
325 return g_unichar_isspace(ch
);
331 pred_non_whitespace (gunichar ch
, gpointer
WXUNUSED(user_data
))
333 return !g_unichar_isspace(ch
);
339 pred_nonpunct (gunichar ch
, gpointer
WXUNUSED(user_data
))
341 return !g_unichar_ispunct(ch
);
347 pred_nonpunct_or_slash (gunichar ch
, gpointer
WXUNUSED(user_data
))
349 return !g_unichar_ispunct(ch
) || ch
== '/';
353 //-----------------------------------------------------------------------------
354 // Check for links between s and e and correct tags as necessary
355 //-----------------------------------------------------------------------------
357 // This function should be made match better while being efficient at one point.
358 // Most probably with a row of regular expressions.
361 au_check_word( GtkTextIter
*s
, GtkTextIter
*e
)
363 static const char *URIPrefixes
[] =
381 GtkTextIter start
= *s
, end
= *e
;
382 GtkTextBuffer
*buffer
= gtk_text_iter_get_buffer(s
);
384 // Get our special link tag
385 GtkTextTag
*tag
= gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer
), "wxUrl");
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
);
393 gtk_text_iter_backward_find_char( &end
, pred_nonpunct_or_slash
, NULL
, &start
);
394 gtk_text_iter_forward_char(&end
);
396 wxGtkString
text(gtk_text_iter_get_text( &start
, &end
));
397 size_t len
= strlen(text
), prefix_len
;
400 for( n
= 0; n
< WXSIZEOF(URIPrefixes
); ++n
)
402 prefix_len
= strlen(URIPrefixes
[n
]);
403 if((len
> prefix_len
) && !strncasecmp(text
, URIPrefixes
[n
], prefix_len
))
407 if(n
< WXSIZEOF(URIPrefixes
))
409 gulong signal_id
= g_signal_handler_find (buffer
,
410 (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC
),
412 (gpointer
)au_apply_tag_callback
, NULL
);
414 g_signal_handler_block (buffer
, signal_id
);
415 gtk_text_buffer_apply_tag(buffer
, tag
, &start
, &end
);
416 g_signal_handler_unblock (buffer
, signal_id
);
423 au_check_range(GtkTextIter
*s
,
424 GtkTextIter
*range_end
)
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");
431 gtk_text_buffer_remove_tag(buffer
, tag
, s
, range_end
);
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
);
436 while(!gtk_text_iter_equal(&range_start
, range_end
))
438 word_end
= range_start
;
439 gtk_text_iter_forward_find_char(&word_end
, pred_whitespace
, NULL
, range_end
);
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
);
444 range_start
= word_end
;
445 gtk_text_iter_forward_find_char(&range_start
, pred_non_whitespace
, NULL
, range_end
);
450 //-----------------------------------------------------------------------------
451 // "insert-text" for GtkTextBuffer
452 //-----------------------------------------------------------------------------
456 au_insert_text_callback(GtkTextBuffer
* WXUNUSED(buffer
),
462 if (!len
|| !(win
->GetWindowStyleFlag() & wxTE_AUTO_URL
) )
465 GtkTextIter start
= *end
;
466 gtk_text_iter_backward_chars(&start
, g_utf8_strlen(text
, len
));
468 GtkTextIter line_start
= start
;
469 GtkTextIter line_end
= *end
;
470 GtkTextIter words_start
= start
;
471 GtkTextIter words_end
= *end
;
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
);
478 au_check_range(&words_start
, &words_end
);
482 //-----------------------------------------------------------------------------
483 // "delete-range" for GtkTextBuffer
484 //-----------------------------------------------------------------------------
488 au_delete_range_callback(GtkTextBuffer
* WXUNUSED(buffer
),
493 if( !(win
->GetWindowStyleFlag() & wxTE_AUTO_URL
) )
496 GtkTextIter line_start
= *start
, line_end
= *end
;
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
);
503 au_check_range(start
, end
);
508 //-----------------------------------------------------------------------------
510 //-----------------------------------------------------------------------------
514 gtk_text_changed_callback( GtkWidget
* WXUNUSED(widget
), wxTextCtrl
*win
)
516 if ( win
->IgnoreTextUpdate() )
519 if (!win
->m_hasVMT
) return;
521 if ( win
->MarkDirtyOnChange() )
524 win
->SendTextUpdatedEvent();
528 //-----------------------------------------------------------------------------
529 // clipboard events: "copy-clipboard", "cut-clipboard", "paste-clipboard"
530 //-----------------------------------------------------------------------------
532 // common part of the event handlers below
534 handle_text_clipboard_callback( GtkWidget
*widget
, wxTextCtrl
*win
,
535 wxEventType eventType
, const gchar
* signal_name
)
537 wxClipboardTextEvent
event( eventType
, win
->GetId() );
538 event
.SetEventObject( win
);
539 if ( win
->GetEventHandler()->ProcessEvent( event
) )
541 // don't let the default processing to take place if we did something
542 // ourselves in the event handler
543 g_signal_stop_emission_by_name (widget
, signal_name
);
549 gtk_copy_clipboard_callback( GtkWidget
*widget
, wxTextCtrl
*win
)
551 handle_text_clipboard_callback(
552 widget
, win
, wxEVT_COMMAND_TEXT_COPY
, "copy-clipboard" );
556 gtk_cut_clipboard_callback( GtkWidget
*widget
, wxTextCtrl
*win
)
558 handle_text_clipboard_callback(
559 widget
, win
, wxEVT_COMMAND_TEXT_CUT
, "cut-clipboard" );
563 gtk_paste_clipboard_callback( GtkWidget
*widget
, wxTextCtrl
*win
)
565 handle_text_clipboard_callback(
566 widget
, win
, wxEVT_COMMAND_TEXT_PASTE
, "paste-clipboard" );
570 //-----------------------------------------------------------------------------
571 // "expose_event" from scrolled window and textview
572 //-----------------------------------------------------------------------------
576 gtk_text_exposed_callback( GtkWidget
* WXUNUSED(widget
),
577 GdkEventExpose
* WXUNUSED(event
),
578 wxTextCtrl
* WXUNUSED(win
) )
585 //-----------------------------------------------------------------------------
587 //-----------------------------------------------------------------------------
589 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxTextCtrlBase
)
591 BEGIN_EVENT_TABLE(wxTextCtrl
, wxTextCtrlBase
)
592 EVT_CHAR(wxTextCtrl::OnChar
)
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
)
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
)
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
)
617 void wxTextCtrl::Init()
622 m_countUpdatesToIgnore
= 0;
624 SetUpdateFont(false);
628 m_showPositionOnThaw
= NULL
;
629 m_gdkHandCursor
= NULL
;
630 m_gdkXTermCursor
= NULL
;
633 wxTextCtrl::~wxTextCtrl()
636 gdk_cursor_unref(m_gdkHandCursor
);
638 gdk_cursor_unref(m_gdkXTermCursor
);
641 wxTextCtrl::wxTextCtrl( wxWindow
*parent
,
643 const wxString
&value
,
647 const wxValidator
& validator
,
648 const wxString
&name
)
652 Create( parent
, id
, value
, pos
, size
, style
, validator
, name
);
655 bool wxTextCtrl::Create( wxWindow
*parent
,
657 const wxString
&value
,
661 const wxValidator
& validator
,
662 const wxString
&name
)
664 if (!PreCreation( parent
, pos
, size
) ||
665 !CreateBase( parent
, id
, pos
, size
, style
, validator
, name
))
667 wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
671 bool multi_line
= (style
& wxTE_MULTILINE
) != 0;
676 m_text
= gtk_text_view_new();
678 m_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
680 // create "ShowPosition" marker
682 gtk_text_buffer_get_start_iter(m_buffer
, &iter
);
683 gtk_text_buffer_create_mark(m_buffer
, "ShowPosition", &iter
, true);
685 // create scrolled window
686 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
687 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( m_widget
),
688 GTK_POLICY_AUTOMATIC
,
689 style
& wxTE_NO_VSCROLL
691 : GTK_POLICY_AUTOMATIC
);
692 // for ScrollLines/Pages
693 m_scrollBar
[1] = (GtkRange
*)((GtkScrolledWindow
*)m_widget
)->vscrollbar
;
695 // Insert view into scrolled window
696 gtk_container_add( GTK_CONTAINER(m_widget
), m_text
);
700 GtkScrolledWindowSetBorder(m_widget
, style
);
702 gtk_widget_add_events( GTK_WIDGET(m_text
), GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
);
704 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
708 // a single-line text control: no need for scrollbars
710 m_text
= gtk_entry_new();
712 if (style
& wxNO_BORDER
)
713 g_object_set (m_text
, "has-frame", FALSE
, NULL
);
716 m_parent
->DoAddChild( this );
718 m_focusWidget
= m_text
;
724 gtk_widget_show(m_text
);
727 // We want to be notified about text changes.
730 g_signal_connect (m_buffer
, "changed",
731 G_CALLBACK (gtk_text_changed_callback
), this);
735 g_signal_connect (m_text
, "changed",
736 G_CALLBACK (gtk_text_changed_callback
), this);
744 if (style
& wxTE_PASSWORD
)
747 if (style
& wxTE_READONLY
)
750 if (style
& wxTE_PROCESS_ENTER
)
751 GTKSetActivatesDefault();
753 // left justification (alignment) is the default anyhow
754 if ( style
& (wxTE_RIGHT
| wxTE_CENTRE
) )
755 GTKSetJustification();
759 // Handle URLs on multi-line controls with wxTE_AUTO_URL style
760 if (style
& wxTE_AUTO_URL
)
762 GtkTextIter start
, end
;
763 m_gdkHandCursor
= gdk_cursor_new(GDK_HAND2
);
764 m_gdkXTermCursor
= gdk_cursor_new(GDK_XTERM
);
766 // We create our wxUrl tag here for slight efficiency gain - we
767 // don't have to check for the tag existance in callbacks,
768 // hereby it's guaranteed to exist.
769 gtk_text_buffer_create_tag(m_buffer
, "wxUrl",
770 "foreground", "blue",
771 "underline", PANGO_UNDERLINE_SINGLE
,
774 // Check for URLs after each text change
775 g_signal_connect_after (m_buffer
, "insert_text",
776 G_CALLBACK (au_insert_text_callback
), this);
777 g_signal_connect_after (m_buffer
, "delete_range",
778 G_CALLBACK (au_delete_range_callback
), this);
780 // Block all wxUrl tag applying unless we do it ourselves, in which case we
781 // block this callback temporarily. This takes care of gtk+ internal
782 // gtk_text_buffer_insert_range* calls that would copy our URL tag otherwise,
783 // which is undesired because only a part of the URL might be copied.
784 // The insert-text signal emitted inside it will take care of newly formed
785 // or wholly copied URLs.
786 g_signal_connect (m_buffer
, "apply_tag",
787 G_CALLBACK (au_apply_tag_callback
), NULL
);
789 // Check for URLs in the initial string passed to Create
790 gtk_text_buffer_get_start_iter(m_buffer
, &start
);
791 gtk_text_buffer_get_end_iter(m_buffer
, &end
);
792 au_check_range(&start
, &end
);
796 g_signal_connect (m_text
, "copy-clipboard",
797 G_CALLBACK (gtk_copy_clipboard_callback
), this);
798 g_signal_connect (m_text
, "cut-clipboard",
799 G_CALLBACK (gtk_cut_clipboard_callback
), this);
800 g_signal_connect (m_text
, "paste-clipboard",
801 G_CALLBACK (gtk_paste_clipboard_callback
), this);
803 m_cursor
= wxCursor( wxCURSOR_IBEAM
);
808 GtkEditable
*wxTextCtrl::GetEditable() const
810 wxCHECK_MSG( IsSingleLine(), NULL
, "shouldn't be called for multiline" );
812 return GTK_EDITABLE(m_text
);
815 // ----------------------------------------------------------------------------
817 // ----------------------------------------------------------------------------
819 void wxTextCtrl::GTKSetEditable()
821 gboolean editable
= !HasFlag(wxTE_READONLY
);
822 if ( IsSingleLine() )
823 gtk_editable_set_editable(GTK_EDITABLE(m_text
), editable
);
825 gtk_text_view_set_editable(GTK_TEXT_VIEW(m_text
), editable
);
828 void wxTextCtrl::GTKSetVisibility()
830 wxCHECK_RET( IsSingleLine(),
831 "wxTE_PASSWORD is for single line text controls only" );
833 gtk_entry_set_visibility(GTK_ENTRY(m_text
), !HasFlag(wxTE_PASSWORD
));
836 void wxTextCtrl::GTKSetActivatesDefault()
838 wxCHECK_RET( IsSingleLine(),
839 "wxTE_PROCESS_ENTER is for single line text controls only" );
841 gtk_entry_set_activates_default(GTK_ENTRY(m_text
),
842 !HasFlag(wxTE_PROCESS_ENTER
));
845 void wxTextCtrl::GTKSetWrapMode()
847 // no wrapping in single line controls
848 if ( !IsMultiLine() )
851 // translate wx wrapping style to GTK+
853 if ( HasFlag( wxTE_DONTWRAP
) )
854 wrap
= GTK_WRAP_NONE
;
855 else if ( HasFlag( wxTE_CHARWRAP
) )
856 wrap
= GTK_WRAP_CHAR
;
857 else if ( HasFlag( wxTE_WORDWRAP
) )
858 wrap
= GTK_WRAP_WORD
;
859 else // HasFlag(wxTE_BESTWRAP) always true as wxTE_BESTWRAP == 0
861 // GTK_WRAP_WORD_CHAR seems to be new in GTK+ 2.4
863 if ( !gtk_check_version(2,4,0) )
865 wrap
= GTK_WRAP_WORD_CHAR
;
868 #endif // __WXGTK24__
869 wrap
= GTK_WRAP_WORD
;
872 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text
), wrap
);
875 void wxTextCtrl::GTKSetJustification()
879 GtkJustification just
;
880 if ( HasFlag(wxTE_RIGHT
) )
881 just
= GTK_JUSTIFY_RIGHT
;
882 else if ( HasFlag(wxTE_CENTRE
) )
883 just
= GTK_JUSTIFY_CENTER
;
884 else // wxTE_LEFT == 0
885 just
= GTK_JUSTIFY_LEFT
;
887 gtk_text_view_set_justification(GTK_TEXT_VIEW(m_text
), just
);
892 // gtk_entry_set_alignment was introduced in gtk+-2.3.5
893 if (!gtk_check_version(2,4,0))
896 if ( HasFlag(wxTE_RIGHT
) )
898 else if ( HasFlag(wxTE_CENTRE
) )
903 gtk_entry_set_alignment(GTK_ENTRY(m_text
), align
);
905 #endif // __WXGTK24__
910 void wxTextCtrl::SetWindowStyleFlag(long style
)
912 long styleOld
= GetWindowStyleFlag();
914 wxTextCtrlBase::SetWindowStyleFlag(style
);
916 if ( (style
& wxTE_READONLY
) != (styleOld
& wxTE_READONLY
) )
919 if ( (style
& wxTE_PASSWORD
) != (styleOld
& wxTE_PASSWORD
) )
922 if ( (style
& wxTE_PROCESS_ENTER
) != (styleOld
& wxTE_PROCESS_ENTER
) )
923 GTKSetActivatesDefault();
925 static const long flagsWrap
= wxTE_WORDWRAP
| wxTE_CHARWRAP
| wxTE_DONTWRAP
;
926 if ( (style
& flagsWrap
) != (styleOld
& flagsWrap
) )
929 static const long flagsAlign
= wxTE_LEFT
| wxTE_CENTRE
| wxTE_RIGHT
;
930 if ( (style
& flagsAlign
) != (styleOld
& flagsAlign
) )
931 GTKSetJustification();
934 // ----------------------------------------------------------------------------
936 // ----------------------------------------------------------------------------
938 wxString
wxTextCtrl::GetValue() const
940 wxCHECK_MSG( m_text
!= NULL
, wxEmptyString
, wxT("invalid text ctrl") );
945 gtk_text_buffer_get_start_iter( m_buffer
, &start
);
947 gtk_text_buffer_get_end_iter( m_buffer
, &end
);
948 wxGtkString
text(gtk_text_buffer_get_text(m_buffer
, &start
, &end
, true));
950 return wxGTK_CONV_BACK(text
);
954 return wxTextEntry::GetValue();
958 wxFontEncoding
wxTextCtrl::GetTextEncoding() const
960 // GTK+ uses UTF-8 internally, we need to convert to it but from which
963 // first check the default text style (we intentionally don't check the
964 // style for the current position as it doesn't make sense for SetValue())
965 const wxTextAttr
& style
= GetDefaultStyle();
966 wxFontEncoding enc
= style
.HasFontEncoding() ? style
.GetFontEncoding()
967 : wxFONTENCODING_SYSTEM
;
969 // fall back to the controls font if no style
970 if ( enc
== wxFONTENCODING_SYSTEM
&& m_hasFont
)
971 enc
= GetFont().GetEncoding();
976 bool wxTextCtrl::IsEmpty() const
979 return gtk_text_buffer_get_char_count(m_buffer
) == 0;
981 return wxTextEntry::IsEmpty();
984 void wxTextCtrl::DoSetValue( const wxString
&value
, int flags
)
986 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
990 if ( !IsMultiLine() )
992 wxTextEntry::DoSetValue(value
, flags
);
996 wxFontEncoding enc
= m_defaultStyle
.HasFont()
997 ? m_defaultStyle
.GetFont().GetEncoding()
998 : wxFONTENCODING_SYSTEM
;
999 if ( enc
== wxFONTENCODING_SYSTEM
)
1000 enc
= GetTextEncoding();
1002 const wxCharBuffer
buffer(wxGTK_CONV_ENC(value
, enc
));
1005 // see comment in WriteText() as to why we must warn the user about
1007 wxLogWarning(_("Failed to set text in the text control."));
1011 if ( !(flags
& SetValue_SendEvent
) )
1013 EnableTextChangedEvents(false);
1016 gtk_text_buffer_set_text( m_buffer
, buffer
, strlen(buffer
) );
1018 if ( !m_defaultStyle
.IsDefault() )
1020 GtkTextIter start
, end
;
1021 gtk_text_buffer_get_bounds( m_buffer
, &start
, &end
);
1022 wxGtkTextApplyTagsFromAttr(m_widget
, m_buffer
, m_defaultStyle
,
1026 if ( !(flags
& SetValue_SendEvent
) )
1028 EnableTextChangedEvents(true);
1031 // This was added after discussion on the list
1032 SetInsertionPoint(0);
1035 void wxTextCtrl::WriteText( const wxString
&text
)
1037 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1039 // we're changing the text programmatically
1040 DontMarkDirtyOnNextChange();
1042 if ( !IsMultiLine() )
1044 wxTextEntry::WriteText(text
);
1048 // check if we have a specific style for the current position
1049 wxFontEncoding enc
= wxFONTENCODING_SYSTEM
;
1051 if ( GetStyle(GetInsertionPoint(), style
) && style
.HasFontEncoding() )
1053 enc
= style
.GetFontEncoding();
1056 if ( enc
== wxFONTENCODING_SYSTEM
)
1057 enc
= GetTextEncoding();
1059 const wxCharBuffer
buffer(wxGTK_CONV_ENC(text
, enc
));
1062 // we must log an error here as losing the text like this can be a
1063 // serious problem (e.g. imagine the document edited by user being
1064 // empty instead of containing the correct text)
1065 wxLogWarning(_("Failed to insert text in the control."));
1069 // First remove the selection if there is one
1070 // TODO: Is there an easier GTK specific way to do this?
1072 GetSelection(&from
, &to
);
1077 wxGtkTextInsert( m_text
, m_buffer
, m_defaultStyle
, buffer
);
1079 GtkAdjustment
*adj
= gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(m_widget
) );
1080 // Scroll to cursor, but only if scrollbar thumb is at the very bottom
1081 // won't work when frozen, text view is not using m_buffer then
1082 if (!IsFrozen() && wxIsSameDouble(adj
->value
, adj
->upper
- adj
->page_size
))
1084 gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text
),
1085 gtk_text_buffer_get_insert( m_buffer
), 0.0, FALSE
, 0.0, 1.0 );
1089 wxString
wxTextCtrl::GetLineText( long lineNo
) const
1092 if ( IsMultiLine() )
1095 gtk_text_buffer_get_iter_at_line(m_buffer
,&line
,lineNo
);
1097 GtkTextIter end
= line
;
1098 // avoid skipping to the next line end if this one is empty
1099 if ( !gtk_text_iter_ends_line(&line
) )
1100 gtk_text_iter_forward_to_line_end(&end
);
1102 wxGtkString
text(gtk_text_buffer_get_text(m_buffer
, &line
, &end
, true));
1103 result
= wxGTK_CONV_BACK(text
);
1108 result
= GetValue();
1113 void wxTextCtrl::OnDropFiles( wxDropFilesEvent
&WXUNUSED(event
) )
1115 /* If you implement this, don't forget to update the documentation!
1116 * (file docs/latex/wx/text.tex) */
1117 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
1120 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
1122 if ( IsMultiLine() )
1126 if (pos
> GetLastPosition())
1129 gtk_text_buffer_get_iter_at_offset(m_buffer
, &iter
, pos
);
1132 *y
= gtk_text_iter_get_line(&iter
);
1134 *x
= gtk_text_iter_get_line_offset(&iter
);
1136 else // single line control
1138 if ( pos
<= GTK_ENTRY(m_text
)->text_length
)
1147 // index out of bounds
1155 long wxTextCtrl::XYToPosition(long x
, long y
) const
1157 if ( IsSingleLine() )
1161 if (y
>= gtk_text_buffer_get_line_count (m_buffer
))
1164 gtk_text_buffer_get_iter_at_line(m_buffer
, &iter
, y
);
1165 if (x
>= gtk_text_iter_get_chars_in_line (&iter
))
1168 return gtk_text_iter_get_offset(&iter
) + x
;
1171 int wxTextCtrl::GetLineLength(long lineNo
) const
1173 if ( IsMultiLine() )
1175 int last_line
= gtk_text_buffer_get_line_count( m_buffer
) - 1;
1176 if (lineNo
> last_line
)
1180 gtk_text_buffer_get_iter_at_line(m_buffer
, &iter
, lineNo
);
1181 // get_chars_in_line return includes paragraph delimiters, so need to subtract 1 IF it is not the last line
1182 return gtk_text_iter_get_chars_in_line(&iter
) - ((lineNo
== last_line
) ? 0 : 1);
1186 wxString str
= GetLineText (lineNo
);
1187 return (int) str
.length();
1191 int wxTextCtrl::GetNumberOfLines() const
1193 if ( IsMultiLine() )
1195 return gtk_text_buffer_get_line_count( m_buffer
);
1203 void wxTextCtrl::SetInsertionPoint( long pos
)
1205 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1207 if ( IsMultiLine() )
1210 gtk_text_buffer_get_iter_at_offset( m_buffer
, &iter
, pos
);
1211 gtk_text_buffer_place_cursor( m_buffer
, &iter
);
1212 GtkTextMark
* mark
= gtk_text_buffer_get_insert(m_buffer
);
1214 // defer until Thaw, text view is not using m_buffer now
1215 m_showPositionOnThaw
= mark
;
1217 gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(m_text
), mark
);
1221 wxTextEntry::SetInsertionPoint(pos
);
1225 void wxTextCtrl::SetEditable( bool editable
)
1227 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1229 if ( IsMultiLine() )
1231 gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text
), editable
);
1235 wxTextEntry::SetEditable(editable
);
1239 bool wxTextCtrl::Enable( bool enable
)
1241 if (!wxWindowBase::Enable(enable
))
1247 gtk_widget_set_sensitive( m_text
, enable
);
1252 // wxGTK-specific: called recursively by Enable,
1253 // to give widgets an opportunity to correct their colours after they
1254 // have been changed by Enable
1255 void wxTextCtrl::OnEnabled(bool WXUNUSED(enable
))
1257 // If we have a custom background colour, we use this colour in both
1258 // disabled and enabled mode, or we end up with a different colour under the
1260 wxColour oldColour
= GetBackgroundColour();
1263 // Need to set twice or it'll optimize the useful stuff out
1264 if (oldColour
== * wxWHITE
)
1265 SetBackgroundColour(*wxBLACK
);
1267 SetBackgroundColour(*wxWHITE
);
1268 SetBackgroundColour(oldColour
);
1272 void wxTextCtrl::MarkDirty()
1277 void wxTextCtrl::DiscardEdits()
1282 // ----------------------------------------------------------------------------
1284 // ----------------------------------------------------------------------------
1286 void wxTextCtrl::EnableTextChangedEvents(bool enable
)
1290 g_signal_handlers_unblock_by_func(GetTextObject(),
1291 (gpointer
)gtk_text_changed_callback
, this);
1293 else // disable events
1295 g_signal_handlers_block_by_func(GetTextObject(),
1296 (gpointer
)gtk_text_changed_callback
, this);
1300 bool wxTextCtrl::IgnoreTextUpdate()
1302 if ( m_countUpdatesToIgnore
> 0 )
1304 m_countUpdatesToIgnore
--;
1312 bool wxTextCtrl::MarkDirtyOnChange()
1314 if ( m_dontMarkDirty
)
1316 m_dontMarkDirty
= false;
1324 void wxTextCtrl::SetSelection( long from
, long to
)
1326 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1328 if (from
== -1 && to
== -1)
1331 to
= GetValue().length();
1334 if ( IsMultiLine() )
1336 GtkTextIter fromi
, toi
;
1337 gtk_text_buffer_get_iter_at_offset( m_buffer
, &fromi
, from
);
1338 gtk_text_buffer_get_iter_at_offset( m_buffer
, &toi
, to
);
1340 gtk_text_buffer_place_cursor( m_buffer
, &toi
);
1341 gtk_text_buffer_move_mark_by_name( m_buffer
, "selection_bound", &fromi
);
1345 wxTextEntry::SetSelection(from
, to
);
1349 void wxTextCtrl::ShowPosition( long pos
)
1354 gtk_text_buffer_get_iter_at_offset(m_buffer
, &iter
, int(pos
));
1355 GtkTextMark
* mark
= gtk_text_buffer_get_mark(m_buffer
, "ShowPosition");
1356 gtk_text_buffer_move_mark(m_buffer
, mark
, &iter
);
1358 // defer until Thaw, text view is not using m_buffer now
1359 m_showPositionOnThaw
= mark
;
1361 gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(m_text
), mark
);
1365 wxTextCtrlHitTestResult
1366 wxTextCtrl::HitTest(const wxPoint
& pt
, long *pos
) const
1368 if ( !IsMultiLine() )
1371 return wxTE_HT_UNKNOWN
;
1375 gtk_text_view_window_to_buffer_coords
1377 GTK_TEXT_VIEW(m_text
),
1378 GTK_TEXT_WINDOW_TEXT
,
1384 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text
), &iter
, x
, y
);
1386 *pos
= gtk_text_iter_get_offset(&iter
);
1388 return wxTE_HT_ON_TEXT
;
1391 long wxTextCtrl::GetInsertionPoint() const
1393 wxCHECK_MSG( m_text
!= NULL
, 0, wxT("invalid text ctrl") );
1395 if ( IsMultiLine() )
1397 // There is no direct accessor for the cursor, but
1398 // internally, the cursor is the "mark" called
1399 // "insert" in the text view's btree structure.
1401 GtkTextMark
*mark
= gtk_text_buffer_get_insert( m_buffer
);
1403 gtk_text_buffer_get_iter_at_mark( m_buffer
, &cursor
, mark
);
1405 return gtk_text_iter_get_offset( &cursor
);
1409 return wxTextEntry::GetInsertionPoint();
1413 wxTextPos
wxTextCtrl::GetLastPosition() const
1415 wxCHECK_MSG( m_text
!= NULL
, 0, wxT("invalid text ctrl") );
1419 if ( IsMultiLine() )
1422 gtk_text_buffer_get_end_iter( m_buffer
, &end
);
1424 pos
= gtk_text_iter_get_offset( &end
);
1428 pos
= wxTextEntry::GetLastPosition();
1434 void wxTextCtrl::Remove( long from
, long to
)
1436 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1438 if ( IsMultiLine() )
1440 GtkTextIter fromi
, toi
;
1441 gtk_text_buffer_get_iter_at_offset( m_buffer
, &fromi
, from
);
1442 gtk_text_buffer_get_iter_at_offset( m_buffer
, &toi
, to
);
1444 gtk_text_buffer_delete( m_buffer
, &fromi
, &toi
);
1448 wxTextEntry::Remove(from
, to
);
1452 void wxTextCtrl::Cut()
1454 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1456 if ( IsMultiLine() )
1457 g_signal_emit_by_name (m_text
, "cut-clipboard");
1462 void wxTextCtrl::Copy()
1464 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1466 if ( IsMultiLine() )
1467 g_signal_emit_by_name (m_text
, "copy-clipboard");
1469 wxTextEntry::Copy();
1472 void wxTextCtrl::Paste()
1474 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1476 if ( IsMultiLine() )
1477 g_signal_emit_by_name (m_text
, "paste-clipboard");
1479 wxTextEntry::Paste();
1482 // If the return values from and to are the same, there is no
1484 void wxTextCtrl::GetSelection(long* fromOut
, long* toOut
) const
1486 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1488 if ( !IsMultiLine() )
1490 wxTextEntry::GetSelection(fromOut
, toOut
);
1496 GtkTextIter ifrom
, ito
;
1497 if ( gtk_text_buffer_get_selection_bounds(m_buffer
, &ifrom
, &ito
) )
1499 from
= gtk_text_iter_get_offset(&ifrom
);
1500 to
= gtk_text_iter_get_offset(&ito
);
1504 // exchange them to be compatible with wxMSW
1510 else // no selection
1513 to
= GetInsertionPoint();
1523 bool wxTextCtrl::IsEditable() const
1525 wxCHECK_MSG( m_text
!= NULL
, false, wxT("invalid text ctrl") );
1527 if ( IsMultiLine() )
1529 return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text
));
1533 return wxTextEntry::IsEditable();
1537 bool wxTextCtrl::IsModified() const
1542 void wxTextCtrl::OnChar( wxKeyEvent
&key_event
)
1544 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1546 if ( key_event
.GetKeyCode() == WXK_RETURN
)
1548 if ( HasFlag(wxTE_PROCESS_ENTER
) )
1550 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1551 event
.SetEventObject(this);
1552 event
.SetString(GetValue());
1553 if ( GetEventHandler()->ProcessEvent(event
) )
1561 GtkWidget
* wxTextCtrl::GetConnectWidget()
1563 return GTK_WIDGET(m_text
);
1566 GdkWindow
*wxTextCtrl::GTKGetWindow(wxArrayGdkWindows
& WXUNUSED(windows
)) const
1568 if ( IsMultiLine() )
1570 return gtk_text_view_get_window(GTK_TEXT_VIEW(m_text
),
1571 GTK_TEXT_WINDOW_TEXT
);
1575 return GTK_ENTRY(m_text
)->text_area
;
1579 // the font will change for subsequent text insertiongs
1580 bool wxTextCtrl::SetFont( const wxFont
&font
)
1582 wxCHECK_MSG( m_text
!= NULL
, false, wxT("invalid text ctrl") );
1584 if ( !wxTextCtrlBase::SetFont(font
) )
1586 // font didn't change, nothing to do
1590 if ( IsMultiLine() )
1592 SetUpdateFont(true);
1594 m_defaultStyle
.SetFont(font
);
1596 ChangeFontGlobally();
1602 void wxTextCtrl::ChangeFontGlobally()
1604 // this method is very inefficient and hence should be called as rarely as
1607 // TODO: it can be implemented much more efficiently for GTK2
1608 wxASSERT_MSG( IsMultiLine(),
1609 _T("shouldn't be called for single line controls") );
1611 wxString value
= GetValue();
1612 if ( !value
.empty() )
1614 SetUpdateFont(false);
1621 bool wxTextCtrl::SetForegroundColour(const wxColour
& colour
)
1623 if ( !wxControl::SetForegroundColour(colour
) )
1626 // update default fg colour too
1627 m_defaultStyle
.SetTextColour(colour
);
1632 bool wxTextCtrl::SetBackgroundColour( const wxColour
&colour
)
1634 wxCHECK_MSG( m_text
!= NULL
, false, wxT("invalid text ctrl") );
1636 if ( !wxControl::SetBackgroundColour( colour
) )
1639 if (!m_backgroundColour
.Ok())
1642 // change active background color too
1643 m_defaultStyle
.SetBackgroundColour( colour
);
1648 bool wxTextCtrl::SetStyle( long start
, long end
, const wxTextAttr
& style
)
1650 if ( IsMultiLine() )
1652 if ( style
.IsDefault() )
1658 gint l
= gtk_text_buffer_get_char_count( m_buffer
);
1660 wxCHECK_MSG( start
>= 0 && end
<= l
, false,
1661 _T("invalid range in wxTextCtrl::SetStyle") );
1663 GtkTextIter starti
, endi
;
1664 gtk_text_buffer_get_iter_at_offset( m_buffer
, &starti
, start
);
1665 gtk_text_buffer_get_iter_at_offset( m_buffer
, &endi
, end
);
1667 wxGtkTextApplyTagsFromAttr( m_widget
, m_buffer
, style
, &starti
, &endi
);
1671 //else: single line text controls don't support styles
1676 void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle
*style
)
1678 gtk_widget_modify_style(m_text
, style
);
1681 void wxTextCtrl::OnCut(wxCommandEvent
& WXUNUSED(event
))
1686 void wxTextCtrl::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1691 void wxTextCtrl::OnPaste(wxCommandEvent
& WXUNUSED(event
))
1696 void wxTextCtrl::OnUndo(wxCommandEvent
& WXUNUSED(event
))
1701 void wxTextCtrl::OnRedo(wxCommandEvent
& WXUNUSED(event
))
1706 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
1708 event
.Enable( CanCut() );
1711 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
1713 event
.Enable( CanCopy() );
1716 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
1718 event
.Enable( CanPaste() );
1721 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
1723 event
.Enable( CanUndo() );
1726 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
1728 event
.Enable( CanRedo() );
1731 wxSize
wxTextCtrl::DoGetBestSize() const
1733 // FIXME should be different for multi-line controls...
1734 wxSize
ret( wxControl::DoGetBestSize() );
1735 wxSize
best(80, ret
.y
);
1736 CacheBestSize(best
);
1740 // ----------------------------------------------------------------------------
1742 // ----------------------------------------------------------------------------
1744 void wxTextCtrl::Freeze()
1746 wxCHECK_RET(m_text
!= NULL
, wxT("invalid text ctrl"));
1748 if ( HasFlag(wxTE_MULTILINE
) )
1750 if (m_freezeCount
++ == 0)
1752 // freeze textview updates and remove buffer
1753 g_signal_connect (m_text
, "expose_event",
1754 G_CALLBACK (gtk_text_exposed_callback
), this);
1755 g_signal_connect (m_widget
, "expose_event",
1756 G_CALLBACK (gtk_text_exposed_callback
), this);
1757 gtk_widget_set_sensitive(m_widget
, false);
1758 g_object_ref(m_buffer
);
1759 GtkTextBuffer
* buf_new
= gtk_text_buffer_new(NULL
);
1760 GtkTextMark
* mark
= GTK_TEXT_VIEW(m_text
)->first_para_mark
;
1761 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text
), buf_new
);
1762 // gtk_text_view_set_buffer adds its own reference
1763 g_object_unref(buf_new
);
1764 // This mark should be deleted when the buffer is changed,
1765 // but it's not (in GTK+ up to at least 2.10.6).
1766 // Otherwise these anonymous marks start to build up in the buffer,
1767 // and Freeze takes longer and longer each time it is called.
1768 if (GTK_IS_TEXT_MARK(mark
) && !gtk_text_mark_get_deleted(mark
))
1769 gtk_text_buffer_delete_mark(m_buffer
, mark
);
1774 void wxTextCtrl::Thaw()
1776 if ( HasFlag(wxTE_MULTILINE
) )
1778 wxCHECK_RET(m_freezeCount
!= 0, _T("Thaw() without matching Freeze()"));
1780 if (--m_freezeCount
== 0)
1782 // Reattach buffer and thaw textview updates
1783 gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text
), m_buffer
);
1784 g_object_unref(m_buffer
);
1785 gtk_widget_set_sensitive(m_widget
, true);
1786 g_signal_handlers_disconnect_by_func (m_widget
,
1787 (gpointer
) gtk_text_exposed_callback
, this);
1788 g_signal_handlers_disconnect_by_func (m_text
,
1789 (gpointer
) gtk_text_exposed_callback
, this);
1790 if (m_showPositionOnThaw
!= NULL
)
1792 gtk_text_view_scroll_mark_onscreen(
1793 GTK_TEXT_VIEW(m_text
), m_showPositionOnThaw
);
1794 m_showPositionOnThaw
= NULL
;
1800 // ----------------------------------------------------------------------------
1801 // wxTextUrlEvent passing if style & wxTE_AUTO_URL
1802 // ----------------------------------------------------------------------------
1804 // FIXME: when dragging on a link the sample gets an "Unknown event".
1805 // This might be an excessive event from us or a buggy wxMouseEvent::Moving() or
1806 // a buggy sample, or something else
1807 void wxTextCtrl::OnUrlMouseEvent(wxMouseEvent
& event
)
1810 if( !HasFlag(wxTE_AUTO_URL
) )
1814 GtkTextIter start
, end
;
1815 GtkTextTag
*tag
= gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(m_buffer
),
1818 gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(m_text
), GTK_TEXT_WINDOW_WIDGET
,
1819 event
.GetX(), event
.GetY(), &x
, &y
);
1821 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text
), &end
, x
, y
);
1822 if (!gtk_text_iter_has_tag(&end
, tag
))
1824 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text
),
1825 GTK_TEXT_WINDOW_TEXT
), m_gdkXTermCursor
);
1829 gdk_window_set_cursor(gtk_text_view_get_window(GTK_TEXT_VIEW(m_text
),
1830 GTK_TEXT_WINDOW_TEXT
), m_gdkHandCursor
);
1833 if(!gtk_text_iter_begins_tag(&start
, tag
))
1834 gtk_text_iter_backward_to_tag_toggle(&start
, tag
);
1835 if(!gtk_text_iter_ends_tag(&end
, tag
))
1836 gtk_text_iter_forward_to_tag_toggle(&end
, tag
);
1838 // Native context menu is probably not desired on an URL.
1839 // Consider making this dependant on ProcessEvent(wxTextUrlEvent) return value
1840 if(event
.GetEventType() == wxEVT_RIGHT_DOWN
)
1843 wxTextUrlEvent
url_event(m_windowId
, event
,
1844 gtk_text_iter_get_offset(&start
),
1845 gtk_text_iter_get_offset(&end
));
1847 InitCommandEvent(url_event
);
1848 // Is that a good idea? Seems not (pleasure with gtk_text_view_start_selection_drag)
1849 //event.Skip(!GetEventHandler()->ProcessEvent(url_event));
1850 GetEventHandler()->ProcessEvent(url_event
);
1853 bool wxTextCtrl::GTKProcessEvent(wxEvent
& event
) const
1855 bool rc
= wxTextCtrlBase::GTKProcessEvent(event
);
1857 // GtkTextView starts a drag operation when left mouse button is pressed
1858 // and ends it when it is released and if it doesn't get the release event
1859 // the next click on a control results in an assertion failure inside
1860 // gtk_text_view_start_selection_drag() which simply *kills* the program
1861 // without anything we can do about it, so always let GTK+ have this event
1862 return rc
&& (IsSingleLine() || event
.GetEventType() != wxEVT_LEFT_UP
);
1867 wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
1869 return GetDefaultAttributesFromGTKWidget(gtk_entry_new
, true);
1872 #endif // wxUSE_TEXTCTRL