1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
11 #pragma implementation "textctrl.h"
14 #include "wx/textctrl.h"
18 #include "wx/settings.h"
20 #include "wx/strconv.h"
21 #include "wx/fontutil.h" // for wxNativeFontInfo (GetNativeFontInfo())
23 #include <sys/types.h>
26 #include <math.h> // for fabs
28 #include "wx/gtk/private.h"
29 #include <gdk/gdkkeysyms.h>
31 //-----------------------------------------------------------------------------
33 //-----------------------------------------------------------------------------
35 extern void wxapp_install_idle_handler();
38 //-----------------------------------------------------------------------------
40 //-----------------------------------------------------------------------------
42 extern bool g_blockEventsOnDrag
;
43 extern wxCursor g_globalCursor
;
44 extern wxWindowGTK
*g_delayedFocus
;
46 // ----------------------------------------------------------------------------
48 // ----------------------------------------------------------------------------
51 static void wxGtkTextInsert(GtkWidget
*text
,
52 GtkTextBuffer
*text_buffer
,
53 const wxTextAttr
& attr
,
57 PangoFontDescription
*font_description
= attr
.HasFont()
58 ? attr
.GetFont().GetNativeFontInfo()->description
61 GdkColor
*colFg
= attr
.HasTextColour() ? attr
.GetTextColour().GetColor()
64 GdkColor
*colBg
= attr
.HasBackgroundColour()
65 ? attr
.GetBackgroundColour().GetColor()
68 GtkTextIter start
, end
;
70 // iterators are invalidated by any mutation that affects 'indexable' buffer contents,
71 // so we save current position in a mark
72 // we need a mark of left gravity, so we cannot use
73 // mark = gtk_text_buffer_get_insert (text_buffer)
75 gtk_text_buffer_get_iter_at_mark( text_buffer
, &start
,
76 gtk_text_buffer_get_insert (text_buffer
) );
77 mark
= gtk_text_buffer_create_mark( text_buffer
, NULL
, &start
, TRUE
/*left gravity*/ );
79 gtk_text_buffer_insert_at_cursor( text_buffer
, buffer
, strlen(buffer
) );
81 gtk_text_buffer_get_iter_at_mark( text_buffer
, &end
,
82 gtk_text_buffer_get_insert (text_buffer
) );
83 gtk_text_buffer_get_iter_at_mark( text_buffer
, &start
, mark
);
86 tag
= gtk_text_buffer_create_tag( text_buffer
, NULL
, "font-desc", font_description
,
87 "foreground-gdk", colFg
,
88 "background-gdk", colBg
, NULL
);
89 gtk_text_buffer_apply_tag( text_buffer
, tag
, &start
, &end
);
92 static void wxGtkTextInsert(GtkWidget
*text
,
93 const wxTextAttr
& attr
,
97 GdkFont
*font
= attr
.HasFont() ? attr
.GetFont().GetInternalFont()
100 GdkColor
*colFg
= attr
.HasTextColour() ? attr
.GetTextColour().GetColor()
103 GdkColor
*colBg
= attr
.HasBackgroundColour()
104 ? attr
.GetBackgroundColour().GetColor()
107 gtk_text_insert( GTK_TEXT(text
), font
, colFg
, colBg
, txt
, len
);
111 // ----------------------------------------------------------------------------
112 // "insert_text" for GtkEntry
113 // ----------------------------------------------------------------------------
116 gtk_insert_text_callback(GtkEditable
*editable
,
117 const gchar
*new_text
,
118 gint new_text_length
,
123 wxapp_install_idle_handler();
125 // we should only be called if we have a max len limit at all
126 GtkEntry
*entry
= GTK_ENTRY (editable
);
128 wxCHECK_RET( entry
->text_max_length
, _T("shouldn't be called") );
130 // check that we don't overflow the max length limit
132 // FIXME: this doesn't work when we paste a string which is going to be
134 if ( entry
->text_length
== entry
->text_max_length
)
136 // we don't need to run the base class version at all
137 gtk_signal_emit_stop_by_name(GTK_OBJECT(editable
), "insert_text");
139 // remember that the next changed signal is to be ignored to avoid
140 // generating a dummy wxEVT_COMMAND_TEXT_UPDATED event
141 win
->IgnoreNextTextUpdate();
143 // and generate the correct one ourselves
144 wxCommandEvent
event(wxEVT_COMMAND_TEXT_MAXLEN
, win
->GetId());
145 event
.SetEventObject(win
);
146 event
.SetString(win
->GetValue());
147 win
->GetEventHandler()->ProcessEvent( event
);
151 //-----------------------------------------------------------------------------
153 //-----------------------------------------------------------------------------
156 gtk_text_changed_callback( GtkWidget
*widget
, wxTextCtrl
*win
)
158 if ( win
->IgnoreTextUpdate() )
161 if (!win
->m_hasVMT
) return;
164 wxapp_install_idle_handler();
167 win
->UpdateFontIfNeeded();
169 wxCommandEvent
event( wxEVT_COMMAND_TEXT_UPDATED
, win
->GetId() );
170 event
.SetEventObject( win
);
171 event
.SetString( win
->GetValue() );
172 win
->GetEventHandler()->ProcessEvent( event
);
175 //-----------------------------------------------------------------------------
176 // "changed" from vertical scrollbar
177 //-----------------------------------------------------------------------------
181 gtk_scrollbar_changed_callback( GtkWidget
*WXUNUSED(widget
), wxTextCtrl
*win
)
183 if (!win
->m_hasVMT
) return;
186 wxapp_install_idle_handler();
188 win
->CalculateScrollbar();
192 // ----------------------------------------------------------------------------
193 // redraw callback for multiline text
194 // ----------------------------------------------------------------------------
198 // redrawing a GtkText from inside a wxYield() call results in crashes (the
199 // text sample shows it in its "Add lines" command which shows wxProgressDialog
200 // which implicitly calls wxYield()) so we override GtkText::draw() and simply
201 // don't do anything if we're inside wxYield()
203 extern bool wxIsInsideYield
;
206 typedef void (*GtkDrawCallback
)(GtkWidget
*widget
, GdkRectangle
*rect
);
209 static GtkDrawCallback gs_gtk_text_draw
= NULL
;
212 void wxgtk_text_draw( GtkWidget
*widget
, GdkRectangle
*rect
)
214 if ( !wxIsInsideYield
)
216 wxCHECK_RET( gs_gtk_text_draw
!= wxgtk_text_draw
,
217 _T("infinite recursion in wxgtk_text_draw aborted") );
219 gs_gtk_text_draw(widget
, rect
);
223 #endif // __WXGTK20__
225 //-----------------------------------------------------------------------------
227 //-----------------------------------------------------------------------------
229 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
,wxControl
)
231 BEGIN_EVENT_TABLE(wxTextCtrl
, wxControl
)
232 EVT_CHAR(wxTextCtrl::OnChar
)
234 EVT_MENU(wxID_CUT
, wxTextCtrl::OnCut
)
235 EVT_MENU(wxID_COPY
, wxTextCtrl::OnCopy
)
236 EVT_MENU(wxID_PASTE
, wxTextCtrl::OnPaste
)
237 EVT_MENU(wxID_UNDO
, wxTextCtrl::OnUndo
)
238 EVT_MENU(wxID_REDO
, wxTextCtrl::OnRedo
)
240 EVT_UPDATE_UI(wxID_CUT
, wxTextCtrl::OnUpdateCut
)
241 EVT_UPDATE_UI(wxID_COPY
, wxTextCtrl::OnUpdateCopy
)
242 EVT_UPDATE_UI(wxID_PASTE
, wxTextCtrl::OnUpdatePaste
)
243 EVT_UPDATE_UI(wxID_UNDO
, wxTextCtrl::OnUpdateUndo
)
244 EVT_UPDATE_UI(wxID_REDO
, wxTextCtrl::OnUpdateRedo
)
247 void wxTextCtrl::Init()
251 m_updateFont
= FALSE
;
253 m_vScrollbar
= (GtkWidget
*)NULL
;
256 wxTextCtrl::wxTextCtrl( wxWindow
*parent
,
258 const wxString
&value
,
262 const wxValidator
& validator
,
263 const wxString
&name
)
267 Create( parent
, id
, value
, pos
, size
, style
, validator
, name
);
270 bool wxTextCtrl::Create( wxWindow
*parent
,
272 const wxString
&value
,
276 const wxValidator
& validator
,
277 const wxString
&name
)
280 m_acceptsFocus
= TRUE
;
282 if (!PreCreation( parent
, pos
, size
) ||
283 !CreateBase( parent
, id
, pos
, size
, style
, validator
, name
))
285 wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
290 m_vScrollbarVisible
= FALSE
;
292 bool multi_line
= (style
& wxTE_MULTILINE
) != 0;
295 GtkTextBuffer
*buffer
= NULL
;
302 m_text
= gtk_text_view_new();
304 buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
306 // create scrolled window
307 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
308 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( m_widget
),
309 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
311 // Insert view into scrolled window
312 gtk_container_add( GTK_CONTAINER(m_widget
), m_text
);
314 // Global settings which can be overridden by tags, I guess.
315 if (HasFlag( wxHSCROLL
))
316 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text
), GTK_WRAP_NONE
);
318 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text
), GTK_WRAP_WORD
);
320 if (!HasFlag(wxNO_BORDER
))
321 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(m_widget
), GTK_SHADOW_IN
);
323 // create our control ...
324 m_text
= gtk_text_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
326 // ... and put into the upper left hand corner of the table
327 bool bHasHScrollbar
= FALSE
;
328 m_widget
= gtk_table_new(bHasHScrollbar
? 2 : 1, 2, FALSE
);
329 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
330 gtk_table_attach( GTK_TABLE(m_widget
), m_text
, 0, 1, 0, 1,
331 (GtkAttachOptions
)(GTK_FILL
| GTK_EXPAND
| GTK_SHRINK
),
332 (GtkAttachOptions
)(GTK_FILL
| GTK_EXPAND
| GTK_SHRINK
),
336 gtk_text_set_word_wrap( GTK_TEXT(m_text
), TRUE
);
338 // finally, put the vertical scrollbar in the upper right corner
339 m_vScrollbar
= gtk_vscrollbar_new( GTK_TEXT(m_text
)->vadj
);
340 GTK_WIDGET_UNSET_FLAGS( m_vScrollbar
, GTK_CAN_FOCUS
);
341 gtk_table_attach(GTK_TABLE(m_widget
), m_vScrollbar
, 1, 2, 0, 1,
343 (GtkAttachOptions
)(GTK_EXPAND
| GTK_FILL
| GTK_SHRINK
),
349 // a single-line text control: no need for scrollbars
351 m_text
= gtk_entry_new();
354 m_parent
->DoAddChild( this );
356 m_focusWidget
= m_text
;
360 SetFont( parent
->GetFont() );
362 wxSize
size_best( DoGetBestSize() );
363 wxSize
new_size( size
);
364 if (new_size
.x
== -1)
365 new_size
.x
= size_best
.x
;
366 if (new_size
.y
== -1)
367 new_size
.y
= size_best
.y
;
368 if ((new_size
.x
!= size
.x
) || (new_size
.y
!= size
.y
))
369 SetSize( new_size
.x
, new_size
.y
);
372 gtk_widget_show(m_text
);
377 gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text
)->vadj
), "changed",
378 (GtkSignalFunc
) gtk_scrollbar_changed_callback
, (gpointer
) this );
380 // only initialize gs_gtk_text_draw once, starting from the next the
381 // klass::draw will already be wxgtk_text_draw
382 if ( !gs_gtk_text_draw
)
385 draw
= GTK_WIDGET_CLASS(GTK_OBJECT(m_text
)->klass
)->draw
;
387 gs_gtk_text_draw
= draw
;
389 draw
= wxgtk_text_draw
;
394 if (!value
.IsEmpty())
400 #if !GTK_CHECK_VERSION(1, 2, 0)
401 // if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
402 // gtk_editable_insert_text()
403 gtk_widget_realize(m_text
);
408 wxWX2MBbuf val
= value
.mbc_str();
409 gtk_editable_insert_text( GTK_EDITABLE(m_text
), val
, strlen(val
), &tmp
);
411 gtk_editable_insert_text( GTK_EDITABLE(m_text
), value
, value
.Length(), &tmp
);
416 // Bring editable's cursor uptodate. Bug in GTK.
417 SET_EDITABLE_POS(m_text
, gtk_text_get_point( GTK_TEXT(m_text
) ));
423 if (style
& wxTE_PASSWORD
)
426 gtk_entry_set_visibility( GTK_ENTRY(m_text
), FALSE
);
429 if (style
& wxTE_READONLY
)
432 gtk_entry_set_editable( GTK_ENTRY(m_text
), FALSE
);
435 gtk_text_view_set_editable( GTK_TEXT_VIEW( m_text
), FALSE
);
442 gtk_text_set_editable( GTK_TEXT(m_text
), 1 );
446 // We want to be notified about text changes.
450 g_signal_connect( G_OBJECT(buffer
), "changed",
451 GTK_SIGNAL_FUNC(gtk_text_changed_callback
), (gpointer
)this);
456 gtk_signal_connect( GTK_OBJECT(m_text
), "changed",
457 GTK_SIGNAL_FUNC(gtk_text_changed_callback
), (gpointer
)this);
460 // we don't set a valid background colour, because the window
461 // manager should use a default one
462 m_backgroundColour
= wxColour();
464 wxColour colFg
= parent
->GetForegroundColour();
465 SetForegroundColour( colFg
);
467 m_cursor
= wxCursor( wxCURSOR_IBEAM
);
469 wxTextAttr
attrDef( colFg
, m_backgroundColour
, parent
->GetFont() );
470 SetDefaultStyle( attrDef
);
477 void wxTextCtrl::CalculateScrollbar()
480 if ((m_windowStyle
& wxTE_MULTILINE
) == 0) return;
482 GtkAdjustment
*adj
= GTK_TEXT(m_text
)->vadj
;
484 if (adj
->upper
- adj
->page_size
< 0.8)
486 if (m_vScrollbarVisible
)
488 gtk_widget_hide( m_vScrollbar
);
489 m_vScrollbarVisible
= FALSE
;
494 if (!m_vScrollbarVisible
)
496 gtk_widget_show( m_vScrollbar
);
497 m_vScrollbarVisible
= TRUE
;
503 wxString
wxTextCtrl::GetValue() const
505 wxCHECK_MSG( m_text
!= NULL
, wxT(""), wxT("invalid text ctrl") );
508 if (m_windowStyle
& wxTE_MULTILINE
)
511 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
514 gtk_text_buffer_get_start_iter( text_buffer
, &start
);
516 gtk_text_buffer_get_end_iter( text_buffer
, &end
);
517 gchar
*text
= gtk_text_buffer_get_text( text_buffer
, &start
, &end
, TRUE
);
520 wxWCharBuffer
buffer( wxConvUTF8
.cMB2WX( text
) );
522 wxCharBuffer
buffer( wxConvLocal
.cWC2WX( wxConvUTF8
.cMB2WC( text
) ) );
528 gint len
= gtk_text_get_length( GTK_TEXT(m_text
) );
529 char *text
= gtk_editable_get_chars( GTK_EDITABLE(m_text
), 0, len
);
536 tmp
= wxGTK_CONV_BACK( gtk_entry_get_text( GTK_ENTRY(m_text
) ) );
542 void wxTextCtrl::SetValue( const wxString
&value
)
544 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
546 if (m_windowStyle
& wxTE_MULTILINE
)
551 wxCharBuffer
buffer( wxConvUTF8
.cWX2MB( value
) );
553 wxCharBuffer
buffer( wxConvUTF8
.cWC2MB( wxConvLocal
.cWX2WC( value
) ) );
555 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
556 gtk_text_buffer_set_text( text_buffer
, buffer
, strlen(buffer
) );
559 gint len
= gtk_text_get_length( GTK_TEXT(m_text
) );
560 gtk_editable_delete_text( GTK_EDITABLE(m_text
), 0, len
);
562 gtk_editable_insert_text( GTK_EDITABLE(m_text
), value
.mbc_str(), value
.Length(), &len
);
567 gtk_entry_set_text( GTK_ENTRY(m_text
), wxGTK_CONV( value
) );
570 // GRG, Jun/2000: Changed this after a lot of discussion in
571 // the lists. wxWindows 2.2 will have a set of flags to
572 // customize this behaviour.
573 SetInsertionPoint(0);
578 void wxTextCtrl::WriteText( const wxString
&text
)
580 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
585 if ( m_windowStyle
& wxTE_MULTILINE
)
590 wxCharBuffer
buffer( wxConvUTF8
.cWX2MB( text
) );
592 wxCharBuffer
buffer( wxConvUTF8
.cWC2MB( wxConvLocal
.cWX2WC( text
) ) );
594 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
596 // TODO: Call whatever is needed to delete the selection.
597 wxGtkTextInsert( m_text
, text_buffer
, m_defaultStyle
, buffer
);
601 gtk_text_buffer_get_iter_at_mark( text_buffer
, &iter
, gtk_text_buffer_get_insert( text_buffer
) );
602 gtk_text_view_scroll_to_iter( GTK_TEXT_VIEW(m_text
), &iter
, 0.0, FALSE
, 0.0, 1.0 );
604 // After cursor movements, gtk_text_get_point() is wrong by one.
605 gtk_text_set_point( GTK_TEXT(m_text
), GET_EDITABLE_POS(m_text
) );
607 // always use m_defaultStyle, even if it is empty as otherwise
608 // resetting the style and appending some more text wouldn't work: if
609 // we don't specify the style explicitly, the old style would be used
610 gtk_editable_delete_selection( GTK_EDITABLE(m_text
) );
611 wxGtkTextInsert(m_text
, m_defaultStyle
, text
.c_str(), text
.Len());
613 // Bring editable's cursor back uptodate.
614 SET_EDITABLE_POS(m_text
, gtk_text_get_point( GTK_TEXT(m_text
) ));
615 #endif // GTK 1.x/2.0
619 // First remove the selection if there is one
620 gtk_editable_delete_selection( GTK_EDITABLE(m_text
) );
622 // This moves the cursor pos to behind the inserted text.
623 gint len
= GET_EDITABLE_POS(m_text
);
628 wxCharBuffer
buffer( wxConvUTF8
.cWX2MB( text
) );
630 wxCharBuffer
buffer( wxConvUTF8
.cWC2MB( wxConvLocal
.cWX2WC( text
) ) );
632 gtk_editable_insert_text( GTK_EDITABLE(m_text
), buffer
, strlen(buffer
), &len
);
635 gtk_editable_insert_text( GTK_EDITABLE(m_text
), text
.c_str(), text
.Len(), &len
);
638 // Bring entry's cursor uptodate.
639 gtk_entry_set_position( GTK_ENTRY(m_text
), len
);
645 void wxTextCtrl::AppendText( const wxString
&text
)
647 SetInsertionPointEnd();
651 wxString
wxTextCtrl::GetLineText( long lineNo
) const
653 if (m_windowStyle
& wxTE_MULTILINE
)
656 gint len
= gtk_text_get_length( GTK_TEXT(m_text
) );
657 char *text
= gtk_editable_get_chars( GTK_EDITABLE(m_text
), 0, len
);
661 wxString
buf(wxT(""));
664 for (i
= 0; currentLine
!= lineNo
&& text
[i
]; i
++ )
669 for (j
= 0; text
[i
] && text
[i
] != '\n'; i
++, j
++ )
678 return wxEmptyString
;
683 if (lineNo
== 0) return GetValue();
684 return wxEmptyString
;
688 void wxTextCtrl::OnDropFiles( wxDropFilesEvent
&WXUNUSED(event
) )
690 /* If you implement this, don't forget to update the documentation!
691 * (file docs/latex/wx/text.tex) */
692 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
695 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
697 if ( m_windowStyle
& wxTE_MULTILINE
)
699 wxString text
= GetValue();
701 // cast to prevent warning. But pos really should've been unsigned.
702 if( (unsigned long)pos
> text
.Len() )
708 const wxChar
* stop
= text
.c_str() + pos
;
709 for ( const wxChar
*p
= text
.c_str(); p
< stop
; p
++ )
720 else // single line control
722 if ( pos
<= GTK_ENTRY(m_text
)->text_length
)
729 // index out of bounds
737 long wxTextCtrl::XYToPosition(long x
, long y
) const
739 if (!(m_windowStyle
& wxTE_MULTILINE
)) return 0;
742 for( int i
=0; i
<y
; i
++ ) pos
+= GetLineLength(i
) + 1; // one for '\n'
748 int wxTextCtrl::GetLineLength(long lineNo
) const
750 wxString str
= GetLineText (lineNo
);
751 return (int) str
.Length();
754 int wxTextCtrl::GetNumberOfLines() const
756 if (m_windowStyle
& wxTE_MULTILINE
)
759 GtkTextBuffer
*buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
761 return gtk_text_buffer_get_line_count( buffer
);
763 gint len
= gtk_text_get_length( GTK_TEXT(m_text
) );
764 char *text
= gtk_editable_get_chars( GTK_EDITABLE(m_text
), 0, len
);
769 for (int i
= 0; i
< len
; i
++ )
776 // currentLine is 0 based, add 1 to get number of lines
777 return currentLine
+ 1;
791 void wxTextCtrl::SetInsertionPoint( long pos
)
793 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
795 if (m_windowStyle
& wxTE_MULTILINE
)
798 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
800 gtk_text_buffer_get_iter_at_offset( text_buffer
, &iter
, pos
);
801 gtk_text_buffer_place_cursor( text_buffer
, &iter
);
803 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text
),
804 GTK_SIGNAL_FUNC(gtk_text_changed_callback
), (gpointer
)this);
806 /* we fake a set_point by inserting and deleting. as the user
807 isn't supposed to get to know about this non-sense, we
808 disconnect so that no events are sent to the user program. */
810 gint tmp
= (gint
)pos
;
811 gtk_editable_insert_text( GTK_EDITABLE(m_text
), " ", 1, &tmp
);
812 gtk_editable_delete_text( GTK_EDITABLE(m_text
), tmp
-1, tmp
);
814 gtk_signal_connect( GTK_OBJECT(m_text
), "changed",
815 GTK_SIGNAL_FUNC(gtk_text_changed_callback
), (gpointer
)this);
817 // bring editable's cursor uptodate. Bug in GTK.
818 SET_EDITABLE_POS(m_text
, gtk_text_get_point( GTK_TEXT(m_text
) ));
823 gtk_entry_set_position( GTK_ENTRY(m_text
), (int)pos
);
825 // Bring editable's cursor uptodate. Bug in GTK.
826 SET_EDITABLE_POS(m_text
, (guint32
)pos
);
830 void wxTextCtrl::SetInsertionPointEnd()
832 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
834 if (m_windowStyle
& wxTE_MULTILINE
)
837 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
839 gtk_text_buffer_get_end_iter( text_buffer
, &end
);
840 gtk_text_buffer_place_cursor( text_buffer
, &end
);
842 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text
)));
847 gtk_entry_set_position( GTK_ENTRY(m_text
), -1 );
851 void wxTextCtrl::SetEditable( bool editable
)
853 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
855 if (m_windowStyle
& wxTE_MULTILINE
)
858 gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text
), editable
);
860 gtk_text_set_editable( GTK_TEXT(m_text
), editable
);
865 gtk_entry_set_editable( GTK_ENTRY(m_text
), editable
);
869 bool wxTextCtrl::Enable( bool enable
)
871 if (!wxWindowBase::Enable(enable
))
877 if (m_windowStyle
& wxTE_MULTILINE
)
880 SetEditable( enable
);
882 gtk_text_set_editable( GTK_TEXT(m_text
), enable
);
883 OnParentEnable(enable
);
888 gtk_widget_set_sensitive( m_text
, enable
);
894 // wxGTK-specific: called recursively by Enable,
895 // to give widgets an oppprtunity to correct their colours after they
896 // have been changed by Enable
897 void wxTextCtrl::OnParentEnable( bool enable
)
899 // If we have a custom background colour, we use this colour in both
900 // disabled and enabled mode, or we end up with a different colour under the
902 wxColour oldColour
= GetBackgroundColour();
905 // Need to set twice or it'll optimize the useful stuff out
906 if (oldColour
== * wxWHITE
)
907 SetBackgroundColour(*wxBLACK
);
909 SetBackgroundColour(*wxWHITE
);
910 SetBackgroundColour(oldColour
);
914 void wxTextCtrl::DiscardEdits()
919 // ----------------------------------------------------------------------------
920 // max text length support
921 // ----------------------------------------------------------------------------
923 void wxTextCtrl::IgnoreNextTextUpdate()
925 m_ignoreNextUpdate
= TRUE
;
928 bool wxTextCtrl::IgnoreTextUpdate()
930 if ( m_ignoreNextUpdate
)
932 m_ignoreNextUpdate
= FALSE
;
940 void wxTextCtrl::SetMaxLength(unsigned long len
)
942 if ( !HasFlag(wxTE_MULTILINE
) )
944 gtk_entry_set_max_length(GTK_ENTRY(m_text
), len
);
946 // there is a bug in GTK+ 1.2.x: "changed" signal is emitted even if
947 // we had tried to enter more text than allowed by max text length and
948 // the text wasn't really changed
950 // to detect this and generate TEXT_MAXLEN event instead of
951 // TEXT_CHANGED one in this case we also catch "insert_text" signal
953 // when max len is set to 0 we disconnect our handler as it means that
954 // we shouldn't check anything any more
957 gtk_signal_connect( GTK_OBJECT(m_text
),
959 GTK_SIGNAL_FUNC(gtk_insert_text_callback
),
964 gtk_signal_disconnect_by_func
967 GTK_SIGNAL_FUNC(gtk_insert_text_callback
),
974 void wxTextCtrl::SetSelection( long from
, long to
)
976 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
978 if (from
== -1 && to
== -1)
981 to
= GetValue().Length();
985 if ( (m_windowStyle
& wxTE_MULTILINE
) &&
986 !GTK_TEXT(m_text
)->line_start_cache
)
988 // tell the programmer that it didn't work
989 wxLogDebug(_T("Can't call SetSelection() before realizing the control"));
994 if (m_windowStyle
& wxTE_MULTILINE
)
997 GtkTextBuffer
*buf
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
999 GtkTextIter fromi
, toi
;
1000 gtk_text_buffer_get_iter_at_offset( buf
, &fromi
, from
);
1001 gtk_text_buffer_get_iter_at_offset( buf
, &toi
, to
);
1003 gtk_text_buffer_place_cursor( buf
, &toi
);
1004 gtk_text_buffer_move_mark_by_name( buf
, "selection_bound", &fromi
);
1006 gtk_editable_select_region( GTK_EDITABLE(m_text
), (gint
)from
, (gint
)to
);
1011 gtk_editable_select_region( GTK_EDITABLE(m_text
), (gint
)from
, (gint
)to
);
1015 void wxTextCtrl::ShowPosition( long pos
)
1018 if (m_windowStyle
& wxTE_MULTILINE
)
1020 GtkAdjustment
*vp
= GTK_TEXT(m_text
)->vadj
;
1021 float totalLines
= (float) GetNumberOfLines();
1024 PositionToXY(pos
, &posX
, &posY
);
1025 float posLine
= (float) posY
;
1026 float p
= (posLine
/totalLines
)*(vp
->upper
- vp
->lower
) + vp
->lower
;
1027 gtk_adjustment_set_value(GTK_TEXT(m_text
)->vadj
, p
);
1032 long wxTextCtrl::GetInsertionPoint() const
1034 wxCHECK_MSG( m_text
!= NULL
, 0, wxT("invalid text ctrl") );
1037 if (m_windowStyle
& wxTE_MULTILINE
)
1039 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1041 // There is no direct accessor for the cursor, but
1042 // internally, the cursor is the "mark" called
1043 // "insert" in the text view's btree structure.
1045 GtkTextMark
*mark
= gtk_text_buffer_get_insert( text_buffer
);
1047 gtk_text_buffer_get_iter_at_mark( text_buffer
, &cursor
, mark
);
1049 return gtk_text_iter_get_offset( &cursor
);
1054 return (long) GET_EDITABLE_POS(m_text
);
1058 long wxTextCtrl::GetLastPosition() const
1060 wxCHECK_MSG( m_text
!= NULL
, 0, wxT("invalid text ctrl") );
1064 if (m_windowStyle
& wxTE_MULTILINE
)
1067 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1069 gtk_text_buffer_get_end_iter( text_buffer
, &end
);
1071 pos
= gtk_text_iter_get_offset( &end
);
1073 pos
= gtk_text_get_length( GTK_TEXT(m_text
) );
1078 pos
= GTK_ENTRY(m_text
)->text_length
;
1084 void wxTextCtrl::Remove( long from
, long to
)
1086 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1089 if (m_windowStyle
& wxTE_MULTILINE
)
1092 text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1094 GtkTextIter fromi
, toi
;
1095 gtk_text_buffer_get_iter_at_offset( text_buffer
, &fromi
, from
);
1096 gtk_text_buffer_get_iter_at_offset( text_buffer
, &toi
, to
);
1098 gtk_text_buffer_delete( text_buffer
, &fromi
, &toi
);
1102 gtk_editable_delete_text( GTK_EDITABLE(m_text
), (gint
)from
, (gint
)to
);
1105 void wxTextCtrl::Replace( long from
, long to
, const wxString
&value
)
1107 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1111 if (!value
.IsEmpty())
1114 SetInsertionPoint( from
);
1117 gint pos
= (gint
)from
;
1119 wxWX2MBbuf buf
= value
.mbc_str();
1120 gtk_editable_insert_text( GTK_EDITABLE(m_text
), buf
, strlen(buf
), &pos
);
1122 gtk_editable_insert_text( GTK_EDITABLE(m_text
), value
, value
.Length(), &pos
);
1123 #endif // wxUSE_UNICODE
1124 #endif // GTK 1.x/2.x
1128 void wxTextCtrl::Cut()
1130 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1133 gtk_editable_cut_clipboard( GTK_EDITABLE(m_text
) DUMMY_CLIPBOARD_ARG
);
1137 void wxTextCtrl::Copy()
1139 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1142 gtk_editable_copy_clipboard( GTK_EDITABLE(m_text
) DUMMY_CLIPBOARD_ARG
);
1146 void wxTextCtrl::Paste()
1148 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1151 gtk_editable_paste_clipboard( GTK_EDITABLE(m_text
) DUMMY_CLIPBOARD_ARG
);
1156 void wxTextCtrl::Undo()
1159 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1162 void wxTextCtrl::Redo()
1165 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1168 bool wxTextCtrl::CanUndo() const
1171 //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1175 bool wxTextCtrl::CanRedo() const
1178 //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1182 // If the return values from and to are the same, there is no
1184 void wxTextCtrl::GetSelection(long* fromOut
, long* toOut
) const
1186 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1190 GtkTextBuffer
*buffer
= gtk_text_view_get_buffer (GTK_TEXT_VIEW (m_text
));
1191 GtkTextIter ifrom
, ito
;
1192 if (!gtk_text_buffer_get_selection_bounds(buffer
, &ifrom
, &ito
))
1194 if ( !(GTK_EDITABLE(m_text
)->has_selection
) )
1198 to
= GetInsertionPoint();
1200 else // got selection
1203 from
= gtk_text_iter_get_offset(&ifrom
);
1204 to
= gtk_text_iter_get_offset(&ito
);
1206 from
= (long) GTK_EDITABLE(m_text
)->selection_start_pos
;
1207 to
= (long) GTK_EDITABLE(m_text
)->selection_end_pos
;
1212 // exchange them to be compatible with wxMSW
1225 bool wxTextCtrl::IsEditable() const
1227 wxCHECK_MSG( m_text
!= NULL
, FALSE
, wxT("invalid text ctrl") );
1230 if (m_windowStyle
& wxTE_MULTILINE
)
1232 return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text
));
1236 return gtk_editable_get_editable(GTK_EDITABLE(m_text
));
1239 return GTK_EDITABLE(m_text
)->editable
;
1243 bool wxTextCtrl::IsModified() const
1248 void wxTextCtrl::Clear()
1250 SetValue( wxT("") );
1253 void wxTextCtrl::OnChar( wxKeyEvent
&key_event
)
1255 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1257 if ((key_event
.GetKeyCode() == WXK_RETURN
) && (m_windowStyle
& wxPROCESS_ENTER
))
1259 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1260 event
.SetEventObject(this);
1261 event
.SetString(GetValue());
1262 if (GetEventHandler()->ProcessEvent(event
)) return;
1265 if ((key_event
.GetKeyCode() == WXK_RETURN
) && !(m_windowStyle
& wxTE_MULTILINE
))
1267 // This will invoke the dialog default action, such
1268 // as the clicking the default button.
1270 wxWindow
*top_frame
= m_parent
;
1271 while (top_frame
->GetParent() && !(top_frame
->IsTopLevel()))
1272 top_frame
= top_frame
->GetParent();
1274 if (top_frame
&& GTK_IS_WINDOW(top_frame
->m_widget
))
1276 GtkWindow
*window
= GTK_WINDOW(top_frame
->m_widget
);
1278 if (window
->default_widget
)
1280 gtk_widget_activate (window
->default_widget
);
1289 GtkWidget
* wxTextCtrl::GetConnectWidget()
1291 return GTK_WIDGET(m_text
);
1294 bool wxTextCtrl::IsOwnGtkWindow( GdkWindow
*window
)
1296 if (m_windowStyle
& wxTE_MULTILINE
)
1299 return window
== gtk_text_view_get_window( GTK_TEXT_VIEW( m_text
), GTK_TEXT_WINDOW_TEXT
); // pure guesswork
1301 return (window
== GTK_TEXT(m_text
)->text_area
);
1306 return (window
== GTK_ENTRY(m_text
)->text_area
);
1310 // the font will change for subsequent text insertiongs
1311 bool wxTextCtrl::SetFont( const wxFont
&font
)
1313 wxCHECK_MSG( m_text
!= NULL
, FALSE
, wxT("invalid text ctrl") );
1315 if ( !wxTextCtrlBase::SetFont(font
) )
1317 // font didn't change, nothing to do
1321 if ( m_windowStyle
& wxTE_MULTILINE
)
1323 m_updateFont
= TRUE
;
1325 m_defaultStyle
.SetFont(font
);
1327 ChangeFontGlobally();
1333 void wxTextCtrl::ChangeFontGlobally()
1335 // this method is very inefficient and hence should be called as rarely as
1337 wxASSERT_MSG( (m_windowStyle
& wxTE_MULTILINE
) && m_updateFont
,
1338 _T("shouldn't be called for single line controls") );
1340 wxString value
= GetValue();
1341 if ( !value
.IsEmpty() )
1343 m_updateFont
= FALSE
;
1350 void wxTextCtrl::UpdateFontIfNeeded()
1353 ChangeFontGlobally();
1356 bool wxTextCtrl::SetForegroundColour(const wxColour
& colour
)
1358 if ( !wxControl::SetForegroundColour(colour
) )
1361 // update default fg colour too
1362 m_defaultStyle
.SetTextColour(colour
);
1367 bool wxTextCtrl::SetBackgroundColour( const wxColour
&colour
)
1369 wxCHECK_MSG( m_text
!= NULL
, FALSE
, wxT("invalid text ctrl") );
1371 if ( !wxControl::SetBackgroundColour( colour
) )
1374 if (!m_widget
->window
)
1377 wxColour sysbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE
);
1378 if (sysbg
.Red() == colour
.Red() &&
1379 sysbg
.Green() == colour
.Green() &&
1380 sysbg
.Blue() == colour
.Blue())
1382 return FALSE
; // FIXME or TRUE?
1385 if (!m_backgroundColour
.Ok())
1388 if (m_windowStyle
& wxTE_MULTILINE
)
1391 GdkWindow
*window
= GTK_TEXT(m_text
)->text_area
;
1394 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( window
) );
1395 gdk_window_set_background( window
, m_backgroundColour
.GetColor() );
1396 gdk_window_clear( window
);
1400 // change active background color too
1401 m_defaultStyle
.SetBackgroundColour( colour
);
1406 bool wxTextCtrl::SetStyle( long start
, long end
, const wxTextAttr
& style
)
1408 if ( m_windowStyle
& wxTE_MULTILINE
)
1410 if ( style
.IsDefault() )
1416 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1417 gint l
= gtk_text_buffer_get_char_count( text_buffer
);
1419 wxCHECK_MSG( start
>= 0 && end
<= l
, FALSE
,
1420 _T("invalid range in wxTextCtrl::SetStyle") );
1422 GtkTextIter starti
, endi
;
1423 gtk_text_buffer_get_iter_at_offset( text_buffer
, &starti
, start
);
1424 gtk_text_buffer_get_iter_at_offset( text_buffer
, &endi
, end
);
1426 // use the attributes from style which are set in it and fall back
1427 // first to the default style and then to the text control default
1428 // colours for the others
1429 wxTextAttr attr
= wxTextAttr::Combine(style
, m_defaultStyle
, this);
1431 PangoFontDescription
*font_description
= attr
.HasFont()
1432 ? attr
.GetFont().GetNativeFontInfo()->description
1435 GdkColor
*colFg
= attr
.HasTextColour() ? attr
.GetTextColour().GetColor()
1438 GdkColor
*colBg
= attr
.HasBackgroundColour()
1439 ? attr
.GetBackgroundColour().GetColor()
1443 tag
= gtk_text_buffer_create_tag( text_buffer
, NULL
, "font-desc", font_description
,
1444 "foreground-gdk", colFg
,
1445 "background-gdk", colBg
, NULL
);
1446 gtk_text_buffer_apply_tag( text_buffer
, tag
, &starti
, &endi
);
1450 // VERY dirty way to do that - removes the required text and re-adds it
1451 // with styling (FIXME)
1453 gint l
= gtk_text_get_length( GTK_TEXT(m_text
) );
1455 wxCHECK_MSG( start
>= 0 && end
<= l
, FALSE
,
1456 _T("invalid range in wxTextCtrl::SetStyle") );
1458 gint old_pos
= gtk_editable_get_position( GTK_EDITABLE(m_text
) );
1459 char *text
= gtk_editable_get_chars( GTK_EDITABLE(m_text
), start
, end
);
1460 wxString
tmp(text
,*wxConvCurrent
);
1463 gtk_editable_delete_text( GTK_EDITABLE(m_text
), start
, end
);
1464 gtk_editable_set_position( GTK_EDITABLE(m_text
), start
);
1467 wxWX2MBbuf buf
= tmp
.mbc_str();
1468 const char *txt
= buf
;
1469 size_t txtlen
= strlen(buf
);
1471 const char *txt
= tmp
;
1472 size_t txtlen
= tmp
.length();
1475 // use the attributes from style which are set in it and fall back
1476 // first to the default style and then to the text control default
1477 // colours for the others
1478 wxGtkTextInsert(m_text
,
1479 wxTextAttr::Combine(style
, m_defaultStyle
, this),
1483 /* does not seem to help under GTK+ 1.2 !!!
1484 gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1485 SetInsertionPoint( old_pos
);
1491 // cannot do this for GTK+'s Entry widget
1496 void wxTextCtrl::ApplyWidgetStyle()
1498 if (m_windowStyle
& wxTE_MULTILINE
)
1505 gtk_widget_set_style( m_text
, m_widgetStyle
);
1509 void wxTextCtrl::OnCut(wxCommandEvent
& WXUNUSED(event
))
1514 void wxTextCtrl::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1519 void wxTextCtrl::OnPaste(wxCommandEvent
& WXUNUSED(event
))
1524 void wxTextCtrl::OnUndo(wxCommandEvent
& WXUNUSED(event
))
1529 void wxTextCtrl::OnRedo(wxCommandEvent
& WXUNUSED(event
))
1534 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
1536 event
.Enable( CanCut() );
1539 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
1541 event
.Enable( CanCopy() );
1544 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
1546 event
.Enable( CanPaste() );
1549 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
1551 event
.Enable( CanUndo() );
1554 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
1556 event
.Enable( CanRedo() );
1559 void wxTextCtrl::OnInternalIdle()
1561 wxCursor cursor
= m_cursor
;
1562 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
1567 GdkWindow
*window
= (GdkWindow
*) NULL
;
1568 if (HasFlag(wxTE_MULTILINE
))
1569 window
= GTK_TEXT(m_text
)->text_area
;
1571 window
= GTK_ENTRY(m_text
)->text_area
;
1574 gdk_window_set_cursor( window
, cursor
.GetCursor() );
1576 if (!g_globalCursor
.Ok())
1577 cursor
= *wxSTANDARD_CURSOR
;
1579 window
= m_widget
->window
;
1580 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
1581 gdk_window_set_cursor( window
, cursor
.GetCursor() );
1585 if (g_delayedFocus
== this)
1587 if (GTK_WIDGET_REALIZED(m_widget
))
1589 gtk_widget_grab_focus( m_widget
);
1590 g_delayedFocus
= NULL
;
1597 wxSize
wxTextCtrl::DoGetBestSize() const
1599 // FIXME should be different for multi-line controls...
1600 wxSize
ret( wxControl::DoGetBestSize() );
1601 return wxSize(80, ret
.y
);
1604 // ----------------------------------------------------------------------------
1606 // ----------------------------------------------------------------------------
1608 void wxTextCtrl::Freeze()
1611 if ( HasFlag(wxTE_MULTILINE
) )
1613 gtk_text_freeze(GTK_TEXT(m_text
));
1618 void wxTextCtrl::Thaw()
1621 if ( HasFlag(wxTE_MULTILINE
) )
1623 GTK_TEXT(m_text
)->vadj
->value
= 0.0;
1625 gtk_text_thaw(GTK_TEXT(m_text
));
1630 // ----------------------------------------------------------------------------
1632 // ----------------------------------------------------------------------------
1634 GtkAdjustment
*wxTextCtrl::GetVAdj() const
1639 return HasFlag(wxTE_MULTILINE
) ? GTK_TEXT(m_text
)->vadj
: NULL
;
1643 bool wxTextCtrl::DoScroll(GtkAdjustment
*adj
, int diff
)
1646 float value
= adj
->value
+ diff
;
1651 float upper
= adj
->upper
- adj
->page_size
;
1652 if ( value
> upper
)
1655 // did we noticeably change the scroll position?
1656 if ( fabs(adj
->value
- value
) < 0.2 )
1658 // well, this is what Robert does in wxScrollBar, so it must be good...
1664 gtk_signal_emit_by_name(GTK_OBJECT(adj
), "value_changed");
1670 bool wxTextCtrl::ScrollLines(int lines
)
1675 GtkAdjustment
*adj
= GetVAdj();
1679 // this is hardcoded to 10 in GTK+ 1.2 (great idea)
1680 static const int KEY_SCROLL_PIXELS
= 10;
1682 return DoScroll(adj
, lines
*KEY_SCROLL_PIXELS
);
1686 bool wxTextCtrl::ScrollPages(int pages
)
1691 GtkAdjustment
*adj
= GetVAdj();
1695 return DoScroll(adj
, (int)ceil(pages
*adj
->page_increment
));