1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
11 #pragma implementation "textctrl.h"
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
17 #include "wx/textctrl.h"
21 #include "wx/settings.h"
23 #include "wx/strconv.h"
24 #include "wx/fontutil.h" // for wxNativeFontInfo (GetNativeFontInfo())
26 #include <sys/types.h>
29 #include <math.h> // for fabs
31 #include "wx/gtk/private.h"
32 #include <gdk/gdkkeysyms.h>
34 //-----------------------------------------------------------------------------
36 //-----------------------------------------------------------------------------
38 extern void wxapp_install_idle_handler();
41 //-----------------------------------------------------------------------------
43 //-----------------------------------------------------------------------------
45 extern bool g_blockEventsOnDrag
;
46 extern wxCursor g_globalCursor
;
47 extern wxWindowGTK
*g_delayedFocus
;
49 // ----------------------------------------------------------------------------
51 // ----------------------------------------------------------------------------
54 static void wxGtkTextInsert(GtkWidget
*text
,
55 GtkTextBuffer
*text_buffer
,
56 const wxTextAttr
& attr
,
60 PangoFontDescription
*font_description
= attr
.HasFont()
61 ? attr
.GetFont().GetNativeFontInfo()->description
64 GdkColor
*colFg
= attr
.HasTextColour() ? attr
.GetTextColour().GetColor()
67 GdkColor
*colBg
= attr
.HasBackgroundColour()
68 ? attr
.GetBackgroundColour().GetColor()
72 tag
= gtk_text_buffer_create_tag( text_buffer
, NULL
, "font-desc", font_description
,
73 "foreground-gdk", colFg
,
74 "background-gdk", colBg
, NULL
);
77 gtk_text_buffer_get_iter_at_mark( text_buffer
, &iter
,
78 gtk_text_buffer_get_insert (text_buffer
) );
80 gtk_text_buffer_insert_with_tags( text_buffer
, &iter
, buffer
, strlen(buffer
), tag
, NULL
);
83 static void wxGtkTextInsert(GtkWidget
*text
,
84 const wxTextAttr
& attr
,
88 GdkFont
*font
= attr
.HasFont() ? attr
.GetFont().GetInternalFont()
91 GdkColor
*colFg
= attr
.HasTextColour() ? attr
.GetTextColour().GetColor()
94 GdkColor
*colBg
= attr
.HasBackgroundColour()
95 ? attr
.GetBackgroundColour().GetColor()
98 gtk_text_insert( GTK_TEXT(text
), font
, colFg
, colBg
, txt
, len
);
102 // ----------------------------------------------------------------------------
103 // "insert_text" for GtkEntry
104 // ----------------------------------------------------------------------------
107 gtk_insert_text_callback(GtkEditable
*editable
,
108 const gchar
*new_text
,
109 gint new_text_length
,
114 wxapp_install_idle_handler();
116 // we should only be called if we have a max len limit at all
117 GtkEntry
*entry
= GTK_ENTRY (editable
);
119 wxCHECK_RET( entry
->text_max_length
, _T("shouldn't be called") );
121 // check that we don't overflow the max length limit
123 // FIXME: this doesn't work when we paste a string which is going to be
125 if ( entry
->text_length
== entry
->text_max_length
)
127 // we don't need to run the base class version at all
128 gtk_signal_emit_stop_by_name(GTK_OBJECT(editable
), "insert_text");
130 // remember that the next changed signal is to be ignored to avoid
131 // generating a dummy wxEVT_COMMAND_TEXT_UPDATED event
132 win
->IgnoreNextTextUpdate();
134 // and generate the correct one ourselves
135 wxCommandEvent
event(wxEVT_COMMAND_TEXT_MAXLEN
, win
->GetId());
136 event
.SetEventObject(win
);
137 event
.SetString(win
->GetValue());
138 win
->GetEventHandler()->ProcessEvent( event
);
142 //-----------------------------------------------------------------------------
144 //-----------------------------------------------------------------------------
147 gtk_text_changed_callback( GtkWidget
*widget
, wxTextCtrl
*win
)
149 if ( win
->IgnoreTextUpdate() )
152 if (!win
->m_hasVMT
) return;
155 wxapp_install_idle_handler();
159 win
->UpdateFontIfNeeded();
160 #endif // !__WXGTK20__
162 wxCommandEvent
event( wxEVT_COMMAND_TEXT_UPDATED
, win
->GetId() );
163 event
.SetEventObject( win
);
164 event
.SetString( win
->GetValue() );
165 win
->GetEventHandler()->ProcessEvent( event
);
168 //-----------------------------------------------------------------------------
169 // "changed" from vertical scrollbar
170 //-----------------------------------------------------------------------------
174 gtk_scrollbar_changed_callback( GtkWidget
*WXUNUSED(widget
), wxTextCtrl
*win
)
176 if (!win
->m_hasVMT
) return;
179 wxapp_install_idle_handler();
181 win
->CalculateScrollbar();
185 // ----------------------------------------------------------------------------
186 // redraw callback for multiline text
187 // ----------------------------------------------------------------------------
191 // redrawing a GtkText from inside a wxYield() call results in crashes (the
192 // text sample shows it in its "Add lines" command which shows wxProgressDialog
193 // which implicitly calls wxYield()) so we override GtkText::draw() and simply
194 // don't do anything if we're inside wxYield()
196 extern bool wxIsInsideYield
;
199 typedef void (*GtkDrawCallback
)(GtkWidget
*widget
, GdkRectangle
*rect
);
202 static GtkDrawCallback gs_gtk_text_draw
= NULL
;
205 void wxgtk_text_draw( GtkWidget
*widget
, GdkRectangle
*rect
)
207 if ( !wxIsInsideYield
)
209 wxCHECK_RET( gs_gtk_text_draw
!= wxgtk_text_draw
,
210 _T("infinite recursion in wxgtk_text_draw aborted") );
212 gs_gtk_text_draw(widget
, rect
);
216 #endif // __WXGTK20__
218 //-----------------------------------------------------------------------------
220 //-----------------------------------------------------------------------------
222 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
,wxControl
)
224 BEGIN_EVENT_TABLE(wxTextCtrl
, wxControl
)
225 EVT_CHAR(wxTextCtrl::OnChar
)
227 EVT_MENU(wxID_CUT
, wxTextCtrl::OnCut
)
228 EVT_MENU(wxID_COPY
, wxTextCtrl::OnCopy
)
229 EVT_MENU(wxID_PASTE
, wxTextCtrl::OnPaste
)
230 EVT_MENU(wxID_UNDO
, wxTextCtrl::OnUndo
)
231 EVT_MENU(wxID_REDO
, wxTextCtrl::OnRedo
)
233 EVT_UPDATE_UI(wxID_CUT
, wxTextCtrl::OnUpdateCut
)
234 EVT_UPDATE_UI(wxID_COPY
, wxTextCtrl::OnUpdateCopy
)
235 EVT_UPDATE_UI(wxID_PASTE
, wxTextCtrl::OnUpdatePaste
)
236 EVT_UPDATE_UI(wxID_UNDO
, wxTextCtrl::OnUpdateUndo
)
237 EVT_UPDATE_UI(wxID_REDO
, wxTextCtrl::OnUpdateRedo
)
240 void wxTextCtrl::Init()
244 SetUpdateFont(FALSE
);
246 m_vScrollbar
= (GtkWidget
*)NULL
;
249 wxTextCtrl::wxTextCtrl( wxWindow
*parent
,
251 const wxString
&value
,
255 const wxValidator
& validator
,
256 const wxString
&name
)
260 Create( parent
, id
, value
, pos
, size
, style
, validator
, name
);
263 bool wxTextCtrl::Create( wxWindow
*parent
,
265 const wxString
&value
,
269 const wxValidator
& validator
,
270 const wxString
&name
)
273 m_acceptsFocus
= TRUE
;
275 if (!PreCreation( parent
, pos
, size
) ||
276 !CreateBase( parent
, id
, pos
, size
, style
, validator
, name
))
278 wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
283 m_vScrollbarVisible
= FALSE
;
285 bool multi_line
= (style
& wxTE_MULTILINE
) != 0;
288 GtkTextBuffer
*buffer
= NULL
;
295 m_text
= gtk_text_view_new();
297 buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
299 // create scrolled window
300 m_widget
= gtk_scrolled_window_new( NULL
, NULL
);
301 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( m_widget
),
302 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
304 // Insert view into scrolled window
305 gtk_container_add( GTK_CONTAINER(m_widget
), m_text
);
307 // Global settings which can be overridden by tags, I guess.
308 if (HasFlag( wxHSCROLL
) || HasFlag( wxTE_DONTWRAP
))
309 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text
), GTK_WRAP_NONE
);
311 gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text
), GTK_WRAP_WORD
);
313 if (!HasFlag(wxNO_BORDER
))
314 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(m_widget
), GTK_SHADOW_IN
);
316 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
318 // create our control ...
319 m_text
= gtk_text_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
321 // ... and put into the upper left hand corner of the table
322 bool bHasHScrollbar
= FALSE
;
323 m_widget
= gtk_table_new(bHasHScrollbar
? 2 : 1, 2, FALSE
);
324 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
325 gtk_table_attach( GTK_TABLE(m_widget
), m_text
, 0, 1, 0, 1,
326 (GtkAttachOptions
)(GTK_FILL
| GTK_EXPAND
| GTK_SHRINK
),
327 (GtkAttachOptions
)(GTK_FILL
| GTK_EXPAND
| GTK_SHRINK
),
331 gtk_text_set_word_wrap( GTK_TEXT(m_text
), TRUE
);
333 // finally, put the vertical scrollbar in the upper right corner
334 m_vScrollbar
= gtk_vscrollbar_new( GTK_TEXT(m_text
)->vadj
);
335 GTK_WIDGET_UNSET_FLAGS( m_vScrollbar
, GTK_CAN_FOCUS
);
336 gtk_table_attach(GTK_TABLE(m_widget
), m_vScrollbar
, 1, 2, 0, 1,
338 (GtkAttachOptions
)(GTK_EXPAND
| GTK_FILL
| GTK_SHRINK
),
344 // a single-line text control: no need for scrollbars
346 m_text
= gtk_entry_new();
349 m_parent
->DoAddChild( this );
351 m_focusWidget
= m_text
;
356 gtk_widget_show(m_text
);
361 gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text
)->vadj
), "changed",
362 (GtkSignalFunc
) gtk_scrollbar_changed_callback
, (gpointer
) this );
364 // only initialize gs_gtk_text_draw once, starting from the next the
365 // klass::draw will already be wxgtk_text_draw
366 if ( !gs_gtk_text_draw
)
369 draw
= GTK_WIDGET_CLASS(GTK_OBJECT(m_text
)->klass
)->draw
;
371 gs_gtk_text_draw
= draw
;
373 draw
= wxgtk_text_draw
;
378 if (!value
.IsEmpty())
384 #if !GTK_CHECK_VERSION(1, 2, 0)
385 // if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
386 // gtk_editable_insert_text()
387 gtk_widget_realize(m_text
);
392 wxWX2MBbuf val
= value
.mbc_str();
393 gtk_editable_insert_text( GTK_EDITABLE(m_text
), val
, strlen(val
), &tmp
);
395 gtk_editable_insert_text( GTK_EDITABLE(m_text
), value
, value
.Length(), &tmp
);
400 // Bring editable's cursor uptodate. Bug in GTK.
401 SET_EDITABLE_POS(m_text
, gtk_text_get_point( GTK_TEXT(m_text
) ));
407 if (style
& wxTE_PASSWORD
)
410 gtk_entry_set_visibility( GTK_ENTRY(m_text
), FALSE
);
413 if (style
& wxTE_READONLY
)
416 gtk_entry_set_editable( GTK_ENTRY(m_text
), FALSE
);
419 gtk_text_view_set_editable( GTK_TEXT_VIEW( m_text
), FALSE
);
425 gtk_text_set_editable( GTK_TEXT(m_text
), 1 );
432 if (style
& wxTE_RIGHT
)
433 gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text
), GTK_JUSTIFY_RIGHT
);
434 else if (style
& wxTE_CENTRE
)
435 gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text
), GTK_JUSTIFY_CENTER
);
436 // Left justify (alignment) is the default and we don't need to apply GTK_JUSTIFY_LEFT
438 // gtk_entry_set_alignment was introduced in gtk+-2.3.5
439 #if GTK_CHECK_VERSION(2, 3, 5)
442 if (style
& wxTE_RIGHT
)
443 gtk_entry_set_alignment( GTK_ENTRY(m_text
), 1.0 );
444 else if (style
& wxTE_CENTRE
)
445 gtk_entry_set_alignment( GTK_ENTRY(m_text
), 0.5 );
448 #endif // __WXGTK20__
450 // We want to be notified about text changes.
454 g_signal_connect( G_OBJECT(buffer
), "changed",
455 GTK_SIGNAL_FUNC(gtk_text_changed_callback
), (gpointer
)this);
461 gtk_signal_connect( GTK_OBJECT(m_text
), "changed",
462 GTK_SIGNAL_FUNC(gtk_text_changed_callback
), (gpointer
)this);
465 m_cursor
= wxCursor( wxCURSOR_IBEAM
);
467 wxTextAttr
attrDef(GetForegroundColour(), GetBackgroundColour(), GetFont());
468 SetDefaultStyle( attrDef
);
474 void wxTextCtrl::CalculateScrollbar()
477 if ((m_windowStyle
& wxTE_MULTILINE
) == 0) return;
479 GtkAdjustment
*adj
= GTK_TEXT(m_text
)->vadj
;
481 if (adj
->upper
- adj
->page_size
< 0.8)
483 if (m_vScrollbarVisible
)
485 gtk_widget_hide( m_vScrollbar
);
486 m_vScrollbarVisible
= FALSE
;
491 if (!m_vScrollbarVisible
)
493 gtk_widget_show( m_vScrollbar
);
494 m_vScrollbarVisible
= TRUE
;
500 wxString
wxTextCtrl::GetValue() const
502 wxCHECK_MSG( m_text
!= NULL
, wxT(""), wxT("invalid text ctrl") );
505 if (m_windowStyle
& wxTE_MULTILINE
)
508 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
511 gtk_text_buffer_get_start_iter( text_buffer
, &start
);
513 gtk_text_buffer_get_end_iter( text_buffer
, &end
);
514 gchar
*text
= gtk_text_buffer_get_text( text_buffer
, &start
, &end
, TRUE
);
517 wxWCharBuffer
buffer( wxConvUTF8
.cMB2WX( text
) );
519 wxCharBuffer
buffer( wxConvLocal
.cWC2WX( wxConvUTF8
.cMB2WC( text
) ) );
525 gint len
= gtk_text_get_length( GTK_TEXT(m_text
) );
526 char *text
= gtk_editable_get_chars( GTK_EDITABLE(m_text
), 0, len
);
533 tmp
= wxGTK_CONV_BACK( gtk_entry_get_text( GTK_ENTRY(m_text
) ) );
539 void wxTextCtrl::SetValue( const wxString
&value
)
541 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
543 if (m_windowStyle
& wxTE_MULTILINE
)
548 wxCharBuffer
buffer( wxConvUTF8
.cWX2MB( value
) );
550 wxCharBuffer
buffer( wxConvUTF8
.cWC2MB( wxConvLocal
.cWX2WC( value
) ) );
552 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
553 gtk_text_buffer_set_text( text_buffer
, buffer
, strlen(buffer
) );
556 gint len
= gtk_text_get_length( GTK_TEXT(m_text
) );
557 gtk_editable_delete_text( GTK_EDITABLE(m_text
), 0, len
);
559 gtk_editable_insert_text( GTK_EDITABLE(m_text
), value
.mbc_str(), value
.Length(), &len
);
564 gtk_entry_set_text( GTK_ENTRY(m_text
), wxGTK_CONV( value
) );
567 // GRG, Jun/2000: Changed this after a lot of discussion in
568 // the lists. wxWidgets 2.2 will have a set of flags to
569 // customize this behaviour.
570 SetInsertionPoint(0);
575 void wxTextCtrl::WriteText( const wxString
&text
)
577 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
582 // gtk_text_changed_callback() will set m_modified to true but m_modified
583 // shouldn't be changed by the program writing to the text control itself,
584 // so save the old value and restore when we're done
585 bool oldModified
= m_modified
;
587 if ( m_windowStyle
& wxTE_MULTILINE
)
592 wxCharBuffer
buffer( wxConvUTF8
.cWX2MB( text
) );
594 wxCharBuffer
buffer( wxConvUTF8
.cWC2MB( wxConvLocal
.cWX2WC( text
) ) );
596 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
598 // TODO: Call whatever is needed to delete the selection.
599 wxGtkTextInsert( m_text
, text_buffer
, m_defaultStyle
, buffer
);
601 GtkAdjustment
*adj
= gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(m_widget
) );
602 // Scroll to cursor, but only if scrollbar thumb is at the very bottom
603 if ( adj
->value
== adj
->upper
- adj
->page_size
)
605 gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text
),
606 gtk_text_buffer_get_insert( text_buffer
), 0.0, FALSE
, 0.0, 1.0 );
609 // After cursor movements, gtk_text_get_point() is wrong by one.
610 gtk_text_set_point( GTK_TEXT(m_text
), GET_EDITABLE_POS(m_text
) );
612 // always use m_defaultStyle, even if it is empty as otherwise
613 // resetting the style and appending some more text wouldn't work: if
614 // we don't specify the style explicitly, the old style would be used
615 gtk_editable_delete_selection( GTK_EDITABLE(m_text
) );
616 wxGtkTextInsert(m_text
, m_defaultStyle
, text
.c_str(), text
.Len());
618 // we called wxGtkTextInsert with correct font, no need to do anything
619 // in UpdateFontIfNeeded() any longer
622 SetUpdateFont(FALSE
);
625 // Bring editable's cursor back uptodate.
626 SET_EDITABLE_POS(m_text
, gtk_text_get_point( GTK_TEXT(m_text
) ));
627 #endif // GTK 1.x/2.0
631 // First remove the selection if there is one
632 gtk_editable_delete_selection( GTK_EDITABLE(m_text
) );
634 // This moves the cursor pos to behind the inserted text.
635 gint len
= GET_EDITABLE_POS(m_text
);
640 wxCharBuffer
buffer( wxConvUTF8
.cWX2MB( text
) );
642 wxCharBuffer
buffer( wxConvUTF8
.cWC2MB( wxConvLocal
.cWX2WC( text
) ) );
644 gtk_editable_insert_text( GTK_EDITABLE(m_text
), buffer
, strlen(buffer
), &len
);
647 gtk_editable_insert_text( GTK_EDITABLE(m_text
), text
.c_str(), text
.Len(), &len
);
650 // Bring entry's cursor uptodate.
651 gtk_entry_set_position( GTK_ENTRY(m_text
), len
);
654 m_modified
= oldModified
;
657 void wxTextCtrl::AppendText( const wxString
&text
)
659 SetInsertionPointEnd();
663 wxString
wxTextCtrl::GetLineText( long lineNo
) const
665 if (m_windowStyle
& wxTE_MULTILINE
)
668 gint len
= gtk_text_get_length( GTK_TEXT(m_text
) );
669 char *text
= gtk_editable_get_chars( GTK_EDITABLE(m_text
), 0, len
);
673 wxString
buf(wxT(""));
676 for (i
= 0; currentLine
!= lineNo
&& text
[i
]; i
++ )
681 for (j
= 0; text
[i
] && text
[i
] != '\n'; i
++, j
++ )
689 return wxEmptyString
;
692 GtkTextBuffer
*text_buffer
;
693 text_buffer
= gtk_text_view_get_buffer(GTK_TEXT_VIEW(m_text
));
695 gtk_text_buffer_get_iter_at_line(text_buffer
,&line
,lineNo
);
697 gtk_text_buffer_get_end_iter(text_buffer
,&end
);
698 gchar
*text
= gtk_text_buffer_get_text(text_buffer
,&line
,&end
,TRUE
);
699 wxString
result(wxGTK_CONV_BACK(text
));
701 return result
.BeforeFirst(wxT('\n'));
706 if (lineNo
== 0) return GetValue();
707 return wxEmptyString
;
711 void wxTextCtrl::OnDropFiles( wxDropFilesEvent
&WXUNUSED(event
) )
713 /* If you implement this, don't forget to update the documentation!
714 * (file docs/latex/wx/text.tex) */
715 wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
718 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
720 if ( m_windowStyle
& wxTE_MULTILINE
)
722 wxString text
= GetValue();
724 // cast to prevent warning. But pos really should've been unsigned.
725 if( (unsigned long)pos
> text
.Len() )
731 const wxChar
* stop
= text
.c_str() + pos
;
732 for ( const wxChar
*p
= text
.c_str(); p
< stop
; p
++ )
743 else // single line control
745 if ( pos
<= GTK_ENTRY(m_text
)->text_length
)
752 // index out of bounds
760 long wxTextCtrl::XYToPosition(long x
, long y
) const
762 if (!(m_windowStyle
& wxTE_MULTILINE
)) return 0;
765 for( int i
=0; i
<y
; i
++ ) pos
+= GetLineLength(i
) + 1; // one for '\n'
771 int wxTextCtrl::GetLineLength(long lineNo
) const
773 wxString str
= GetLineText (lineNo
);
774 return (int) str
.Length();
777 int wxTextCtrl::GetNumberOfLines() const
779 if (m_windowStyle
& wxTE_MULTILINE
)
782 GtkTextBuffer
*buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
784 return gtk_text_buffer_get_line_count( buffer
);
786 gint len
= gtk_text_get_length( GTK_TEXT(m_text
) );
787 char *text
= gtk_editable_get_chars( GTK_EDITABLE(m_text
), 0, len
);
792 for (int i
= 0; i
< len
; i
++ )
799 // currentLine is 0 based, add 1 to get number of lines
800 return currentLine
+ 1;
814 void wxTextCtrl::SetInsertionPoint( long pos
)
816 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
818 if (m_windowStyle
& wxTE_MULTILINE
)
821 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
823 gtk_text_buffer_get_iter_at_offset( text_buffer
, &iter
, pos
);
824 gtk_text_buffer_place_cursor( text_buffer
, &iter
);
826 gtk_signal_disconnect_by_func( GTK_OBJECT(m_text
),
827 GTK_SIGNAL_FUNC(gtk_text_changed_callback
), (gpointer
)this);
829 /* we fake a set_point by inserting and deleting. as the user
830 isn't supposed to get to know about this non-sense, we
831 disconnect so that no events are sent to the user program. */
833 gint tmp
= (gint
)pos
;
834 gtk_editable_insert_text( GTK_EDITABLE(m_text
), " ", 1, &tmp
);
835 gtk_editable_delete_text( GTK_EDITABLE(m_text
), tmp
-1, tmp
);
837 gtk_signal_connect( GTK_OBJECT(m_text
), "changed",
838 GTK_SIGNAL_FUNC(gtk_text_changed_callback
), (gpointer
)this);
840 // bring editable's cursor uptodate. Bug in GTK.
841 SET_EDITABLE_POS(m_text
, gtk_text_get_point( GTK_TEXT(m_text
) ));
846 gtk_entry_set_position( GTK_ENTRY(m_text
), (int)pos
);
848 // Bring editable's cursor uptodate. Bug in GTK.
849 SET_EDITABLE_POS(m_text
, (guint32
)pos
);
853 void wxTextCtrl::SetInsertionPointEnd()
855 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
857 if (m_windowStyle
& wxTE_MULTILINE
)
860 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
862 gtk_text_buffer_get_end_iter( text_buffer
, &end
);
863 gtk_text_buffer_place_cursor( text_buffer
, &end
);
865 SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text
)));
870 gtk_entry_set_position( GTK_ENTRY(m_text
), -1 );
874 void wxTextCtrl::SetEditable( bool editable
)
876 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
878 if (m_windowStyle
& wxTE_MULTILINE
)
881 gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text
), editable
);
883 gtk_text_set_editable( GTK_TEXT(m_text
), editable
);
888 gtk_entry_set_editable( GTK_ENTRY(m_text
), editable
);
892 bool wxTextCtrl::Enable( bool enable
)
894 if (!wxWindowBase::Enable(enable
))
900 if (m_windowStyle
& wxTE_MULTILINE
)
903 SetEditable( enable
);
905 gtk_text_set_editable( GTK_TEXT(m_text
), enable
);
906 OnParentEnable(enable
);
911 gtk_widget_set_sensitive( m_text
, enable
);
917 // wxGTK-specific: called recursively by Enable,
918 // to give widgets an oppprtunity to correct their colours after they
919 // have been changed by Enable
920 void wxTextCtrl::OnParentEnable( bool enable
)
922 // If we have a custom background colour, we use this colour in both
923 // disabled and enabled mode, or we end up with a different colour under the
925 wxColour oldColour
= GetBackgroundColour();
928 // Need to set twice or it'll optimize the useful stuff out
929 if (oldColour
== * wxWHITE
)
930 SetBackgroundColour(*wxBLACK
);
932 SetBackgroundColour(*wxWHITE
);
933 SetBackgroundColour(oldColour
);
937 void wxTextCtrl::MarkDirty()
942 void wxTextCtrl::DiscardEdits()
947 // ----------------------------------------------------------------------------
948 // max text length support
949 // ----------------------------------------------------------------------------
951 void wxTextCtrl::IgnoreNextTextUpdate()
953 m_ignoreNextUpdate
= TRUE
;
956 bool wxTextCtrl::IgnoreTextUpdate()
958 if ( m_ignoreNextUpdate
)
960 m_ignoreNextUpdate
= FALSE
;
968 void wxTextCtrl::SetMaxLength(unsigned long len
)
970 if ( !HasFlag(wxTE_MULTILINE
) )
972 gtk_entry_set_max_length(GTK_ENTRY(m_text
), len
);
974 // there is a bug in GTK+ 1.2.x: "changed" signal is emitted even if
975 // we had tried to enter more text than allowed by max text length and
976 // the text wasn't really changed
978 // to detect this and generate TEXT_MAXLEN event instead of
979 // TEXT_CHANGED one in this case we also catch "insert_text" signal
981 // when max len is set to 0 we disconnect our handler as it means that
982 // we shouldn't check anything any more
985 gtk_signal_connect( GTK_OBJECT(m_text
),
987 GTK_SIGNAL_FUNC(gtk_insert_text_callback
),
992 gtk_signal_disconnect_by_func
995 GTK_SIGNAL_FUNC(gtk_insert_text_callback
),
1002 void wxTextCtrl::SetSelection( long from
, long to
)
1004 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1006 if (from
== -1 && to
== -1)
1009 to
= GetValue().Length();
1013 if ( (m_windowStyle
& wxTE_MULTILINE
) &&
1014 !GTK_TEXT(m_text
)->line_start_cache
)
1016 // tell the programmer that it didn't work
1017 wxLogDebug(_T("Can't call SetSelection() before realizing the control"));
1022 if (m_windowStyle
& wxTE_MULTILINE
)
1025 GtkTextBuffer
*buf
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1027 GtkTextIter fromi
, toi
;
1028 gtk_text_buffer_get_iter_at_offset( buf
, &fromi
, from
);
1029 gtk_text_buffer_get_iter_at_offset( buf
, &toi
, to
);
1031 gtk_text_buffer_place_cursor( buf
, &toi
);
1032 gtk_text_buffer_move_mark_by_name( buf
, "selection_bound", &fromi
);
1034 gtk_editable_select_region( GTK_EDITABLE(m_text
), (gint
)from
, (gint
)to
);
1039 gtk_editable_select_region( GTK_EDITABLE(m_text
), (gint
)from
, (gint
)to
);
1043 void wxTextCtrl::ShowPosition( long pos
)
1045 if (m_windowStyle
& wxTE_MULTILINE
)
1048 GtkTextBuffer
*buf
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1050 gtk_text_buffer_get_start_iter( buf
, &iter
);
1051 gtk_text_iter_set_offset( &iter
, pos
);
1052 GtkTextMark
*mark
= gtk_text_buffer_create_mark( buf
, NULL
, &iter
, TRUE
);
1053 gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text
), mark
, 0.0, FALSE
, 0.0, 0.0 );
1055 GtkAdjustment
*vp
= GTK_TEXT(m_text
)->vadj
;
1056 float totalLines
= (float) GetNumberOfLines();
1059 PositionToXY(pos
, &posX
, &posY
);
1060 float posLine
= (float) posY
;
1061 float p
= (posLine
/totalLines
)*(vp
->upper
- vp
->lower
) + vp
->lower
;
1062 gtk_adjustment_set_value(GTK_TEXT(m_text
)->vadj
, p
);
1063 #endif // GTK 1.x/2.x
1069 wxTextCtrlHitTestResult
1070 wxTextCtrl::HitTest(const wxPoint
& pt
, long *pos
) const
1072 if ( !IsMultiLine() )
1075 return wxTE_HT_UNKNOWN
;
1079 gtk_text_view_window_to_buffer_coords
1081 GTK_TEXT_VIEW(m_text
),
1082 GTK_TEXT_WINDOW_TEXT
,
1088 gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text
), &iter
, x
, y
);
1090 *pos
= gtk_text_iter_get_offset(&iter
);
1092 return wxTE_HT_ON_TEXT
;
1095 #endif // __WXGTK20__
1097 long wxTextCtrl::GetInsertionPoint() const
1099 wxCHECK_MSG( m_text
!= NULL
, 0, wxT("invalid text ctrl") );
1102 if (m_windowStyle
& wxTE_MULTILINE
)
1104 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1106 // There is no direct accessor for the cursor, but
1107 // internally, the cursor is the "mark" called
1108 // "insert" in the text view's btree structure.
1110 GtkTextMark
*mark
= gtk_text_buffer_get_insert( text_buffer
);
1112 gtk_text_buffer_get_iter_at_mark( text_buffer
, &cursor
, mark
);
1114 return gtk_text_iter_get_offset( &cursor
);
1119 return (long) GET_EDITABLE_POS(m_text
);
1123 long wxTextCtrl::GetLastPosition() const
1125 wxCHECK_MSG( m_text
!= NULL
, 0, wxT("invalid text ctrl") );
1129 if (m_windowStyle
& wxTE_MULTILINE
)
1132 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1134 gtk_text_buffer_get_end_iter( text_buffer
, &end
);
1136 pos
= gtk_text_iter_get_offset( &end
);
1138 pos
= gtk_text_get_length( GTK_TEXT(m_text
) );
1143 pos
= GTK_ENTRY(m_text
)->text_length
;
1149 void wxTextCtrl::Remove( long from
, long to
)
1151 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1154 if (m_windowStyle
& wxTE_MULTILINE
)
1157 text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1159 GtkTextIter fromi
, toi
;
1160 gtk_text_buffer_get_iter_at_offset( text_buffer
, &fromi
, from
);
1161 gtk_text_buffer_get_iter_at_offset( text_buffer
, &toi
, to
);
1163 gtk_text_buffer_delete( text_buffer
, &fromi
, &toi
);
1167 gtk_editable_delete_text( GTK_EDITABLE(m_text
), (gint
)from
, (gint
)to
);
1170 void wxTextCtrl::Replace( long from
, long to
, const wxString
&value
)
1172 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1176 if (!value
.IsEmpty())
1179 SetInsertionPoint( from
);
1182 gint pos
= (gint
)from
;
1184 wxWX2MBbuf buf
= value
.mbc_str();
1185 gtk_editable_insert_text( GTK_EDITABLE(m_text
), buf
, strlen(buf
), &pos
);
1187 gtk_editable_insert_text( GTK_EDITABLE(m_text
), value
, value
.Length(), &pos
);
1188 #endif // wxUSE_UNICODE
1189 #endif // GTK 1.x/2.x
1193 void wxTextCtrl::Cut()
1195 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1198 if (m_windowStyle
& wxTE_MULTILINE
)
1199 g_signal_emit_by_name(m_text
, "cut-clipboard");
1202 gtk_editable_cut_clipboard(GTK_EDITABLE(m_text
) DUMMY_CLIPBOARD_ARG
);
1205 void wxTextCtrl::Copy()
1207 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1210 if (m_windowStyle
& wxTE_MULTILINE
)
1211 g_signal_emit_by_name(m_text
, "copy-clipboard");
1214 gtk_editable_copy_clipboard(GTK_EDITABLE(m_text
) DUMMY_CLIPBOARD_ARG
);
1217 void wxTextCtrl::Paste()
1219 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1222 if (m_windowStyle
& wxTE_MULTILINE
)
1223 g_signal_emit_by_name(m_text
, "paste-clipboard");
1226 gtk_editable_paste_clipboard(GTK_EDITABLE(m_text
) DUMMY_CLIPBOARD_ARG
);
1230 void wxTextCtrl::Undo()
1233 wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1236 void wxTextCtrl::Redo()
1239 wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1242 bool wxTextCtrl::CanUndo() const
1245 //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1249 bool wxTextCtrl::CanRedo() const
1252 //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1256 // If the return values from and to are the same, there is no
1258 void wxTextCtrl::GetSelection(long* fromOut
, long* toOut
) const
1260 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1264 bool haveSelection
= FALSE
;
1267 if (m_windowStyle
& wxTE_MULTILINE
)
1269 GtkTextBuffer
*buffer
= gtk_text_view_get_buffer (GTK_TEXT_VIEW (m_text
));
1270 GtkTextIter ifrom
, ito
;
1271 if ( gtk_text_buffer_get_selection_bounds(buffer
, &ifrom
, &ito
) )
1273 haveSelection
= TRUE
;
1274 from
= gtk_text_iter_get_offset(&ifrom
);
1275 to
= gtk_text_iter_get_offset(&ito
);
1278 else // not multi-line
1280 if ( gtk_editable_get_selection_bounds( GTK_EDITABLE(m_text
),
1283 haveSelection
= TRUE
;
1287 if ( (GTK_EDITABLE(m_text
)->has_selection
) )
1289 haveSelection
= TRUE
;
1290 from
= (long) GTK_EDITABLE(m_text
)->selection_start_pos
;
1291 to
= (long) GTK_EDITABLE(m_text
)->selection_end_pos
;
1295 if (! haveSelection
)
1296 from
= to
= GetInsertionPoint();
1300 // exchange them to be compatible with wxMSW
1313 bool wxTextCtrl::IsEditable() const
1315 wxCHECK_MSG( m_text
!= NULL
, FALSE
, wxT("invalid text ctrl") );
1318 if (m_windowStyle
& wxTE_MULTILINE
)
1320 return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text
));
1324 return gtk_editable_get_editable(GTK_EDITABLE(m_text
));
1327 return GTK_EDITABLE(m_text
)->editable
;
1331 bool wxTextCtrl::IsModified() const
1336 void wxTextCtrl::Clear()
1338 SetValue( wxT("") );
1341 void wxTextCtrl::OnChar( wxKeyEvent
&key_event
)
1343 wxCHECK_RET( m_text
!= NULL
, wxT("invalid text ctrl") );
1345 if ((key_event
.GetKeyCode() == WXK_RETURN
) && (m_windowStyle
& wxPROCESS_ENTER
))
1347 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1348 event
.SetEventObject(this);
1349 event
.SetString(GetValue());
1350 if (GetEventHandler()->ProcessEvent(event
)) return;
1353 if ((key_event
.GetKeyCode() == WXK_RETURN
) && !(m_windowStyle
& wxTE_MULTILINE
))
1355 // This will invoke the dialog default action, such
1356 // as the clicking the default button.
1358 wxWindow
*top_frame
= m_parent
;
1359 while (top_frame
->GetParent() && !(top_frame
->IsTopLevel()))
1360 top_frame
= top_frame
->GetParent();
1362 if (top_frame
&& GTK_IS_WINDOW(top_frame
->m_widget
))
1364 GtkWindow
*window
= GTK_WINDOW(top_frame
->m_widget
);
1366 if (window
->default_widget
)
1368 gtk_widget_activate (window
->default_widget
);
1377 GtkWidget
* wxTextCtrl::GetConnectWidget()
1379 return GTK_WIDGET(m_text
);
1382 bool wxTextCtrl::IsOwnGtkWindow( GdkWindow
*window
)
1384 if (m_windowStyle
& wxTE_MULTILINE
)
1387 return window
== gtk_text_view_get_window( GTK_TEXT_VIEW( m_text
), GTK_TEXT_WINDOW_TEXT
); // pure guesswork
1389 return (window
== GTK_TEXT(m_text
)->text_area
);
1394 return (window
== GTK_ENTRY(m_text
)->text_area
);
1398 // the font will change for subsequent text insertiongs
1399 bool wxTextCtrl::SetFont( const wxFont
&font
)
1401 wxCHECK_MSG( m_text
!= NULL
, FALSE
, wxT("invalid text ctrl") );
1403 if ( !wxTextCtrlBase::SetFont(font
) )
1405 // font didn't change, nothing to do
1409 if ( m_windowStyle
& wxTE_MULTILINE
)
1411 SetUpdateFont(TRUE
);
1413 m_defaultStyle
.SetFont(font
);
1415 ChangeFontGlobally();
1421 void wxTextCtrl::ChangeFontGlobally()
1423 // this method is very inefficient and hence should be called as rarely as
1426 // TODO: it can be implemented much more efficiently for GTK2
1427 wxASSERT_MSG( (m_windowStyle
& wxTE_MULTILINE
)
1432 _T("shouldn't be called for single line controls") );
1434 wxString value
= GetValue();
1435 if ( !value
.IsEmpty() )
1437 SetUpdateFont(FALSE
);
1446 void wxTextCtrl::UpdateFontIfNeeded()
1449 ChangeFontGlobally();
1454 bool wxTextCtrl::SetForegroundColour(const wxColour
& colour
)
1456 if ( !wxControl::SetForegroundColour(colour
) )
1459 // update default fg colour too
1460 m_defaultStyle
.SetTextColour(colour
);
1465 bool wxTextCtrl::SetBackgroundColour( const wxColour
&colour
)
1467 wxCHECK_MSG( m_text
!= NULL
, FALSE
, wxT("invalid text ctrl") );
1469 if ( !wxControl::SetBackgroundColour( colour
) )
1472 if (!m_widget
->window
)
1475 if (!m_backgroundColour
.Ok())
1478 if (m_windowStyle
& wxTE_MULTILINE
)
1481 GdkWindow
*window
= GTK_TEXT(m_text
)->text_area
;
1484 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( window
) );
1485 gdk_window_set_background( window
, m_backgroundColour
.GetColor() );
1486 gdk_window_clear( window
);
1490 // change active background color too
1491 m_defaultStyle
.SetBackgroundColour( colour
);
1496 bool wxTextCtrl::SetStyle( long start
, long end
, const wxTextAttr
& style
)
1498 if ( m_windowStyle
& wxTE_MULTILINE
)
1500 if ( style
.IsDefault() )
1506 GtkTextBuffer
*text_buffer
= gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text
) );
1507 gint l
= gtk_text_buffer_get_char_count( text_buffer
);
1509 wxCHECK_MSG( start
>= 0 && end
<= l
, FALSE
,
1510 _T("invalid range in wxTextCtrl::SetStyle") );
1512 GtkTextIter starti
, endi
;
1513 gtk_text_buffer_get_iter_at_offset( text_buffer
, &starti
, start
);
1514 gtk_text_buffer_get_iter_at_offset( text_buffer
, &endi
, end
);
1516 // use the attributes from style which are set in it and fall back
1517 // first to the default style and then to the text control default
1518 // colours for the others
1519 wxTextAttr attr
= wxTextAttr::Combine(style
, m_defaultStyle
, this);
1521 PangoFontDescription
*font_description
= attr
.HasFont()
1522 ? attr
.GetFont().GetNativeFontInfo()->description
1525 GdkColor
*colFg
= attr
.HasTextColour() ? attr
.GetTextColour().GetColor()
1528 GdkColor
*colBg
= attr
.HasBackgroundColour()
1529 ? attr
.GetBackgroundColour().GetColor()
1533 tag
= gtk_text_buffer_create_tag( text_buffer
, NULL
, "font-desc", font_description
,
1534 "foreground-gdk", colFg
,
1535 "background-gdk", colBg
, NULL
);
1536 gtk_text_buffer_apply_tag( text_buffer
, tag
, &starti
, &endi
);
1540 // VERY dirty way to do that - removes the required text and re-adds it
1541 // with styling (FIXME)
1543 gint l
= gtk_text_get_length( GTK_TEXT(m_text
) );
1545 wxCHECK_MSG( start
>= 0 && end
<= l
, FALSE
,
1546 _T("invalid range in wxTextCtrl::SetStyle") );
1548 gint old_pos
= gtk_editable_get_position( GTK_EDITABLE(m_text
) );
1549 char *text
= gtk_editable_get_chars( GTK_EDITABLE(m_text
), start
, end
);
1550 wxString
tmp(text
,*wxConvCurrent
);
1553 gtk_editable_delete_text( GTK_EDITABLE(m_text
), start
, end
);
1554 gtk_editable_set_position( GTK_EDITABLE(m_text
), start
);
1557 wxWX2MBbuf buf
= tmp
.mbc_str();
1558 const char *txt
= buf
;
1559 size_t txtlen
= strlen(buf
);
1561 const char *txt
= tmp
;
1562 size_t txtlen
= tmp
.length();
1565 // use the attributes from style which are set in it and fall back
1566 // first to the default style and then to the text control default
1567 // colours for the others
1568 wxGtkTextInsert(m_text
,
1569 wxTextAttr::Combine(style
, m_defaultStyle
, this),
1573 /* does not seem to help under GTK+ 1.2 !!!
1574 gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1575 SetInsertionPoint( old_pos
);
1581 // cannot do this for GTK+'s Entry widget
1586 void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle
*style
)
1588 gtk_widget_modify_style(m_text
, style
);
1591 void wxTextCtrl::OnCut(wxCommandEvent
& WXUNUSED(event
))
1596 void wxTextCtrl::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1601 void wxTextCtrl::OnPaste(wxCommandEvent
& WXUNUSED(event
))
1606 void wxTextCtrl::OnUndo(wxCommandEvent
& WXUNUSED(event
))
1611 void wxTextCtrl::OnRedo(wxCommandEvent
& WXUNUSED(event
))
1616 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
1618 event
.Enable( CanCut() );
1621 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
1623 event
.Enable( CanCopy() );
1626 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
1628 event
.Enable( CanPaste() );
1631 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
1633 event
.Enable( CanUndo() );
1636 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
1638 event
.Enable( CanRedo() );
1641 void wxTextCtrl::OnInternalIdle()
1643 wxCursor cursor
= m_cursor
;
1644 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
1649 GdkWindow
*window
= (GdkWindow
*) NULL
;
1650 if (HasFlag(wxTE_MULTILINE
))
1651 window
= GTK_TEXT(m_text
)->text_area
;
1653 window
= GTK_ENTRY(m_text
)->text_area
;
1656 gdk_window_set_cursor( window
, cursor
.GetCursor() );
1658 if (!g_globalCursor
.Ok())
1659 cursor
= *wxSTANDARD_CURSOR
;
1661 window
= m_widget
->window
;
1662 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
1663 gdk_window_set_cursor( window
, cursor
.GetCursor() );
1667 if (g_delayedFocus
== this)
1669 if (GTK_WIDGET_REALIZED(m_widget
))
1671 gtk_widget_grab_focus( m_widget
);
1672 g_delayedFocus
= NULL
;
1676 if (wxUpdateUIEvent::CanUpdate(this))
1677 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1680 wxSize
wxTextCtrl::DoGetBestSize() const
1682 // FIXME should be different for multi-line controls...
1683 wxSize
ret( wxControl::DoGetBestSize() );
1684 wxSize
best(80, ret
.y
);
1685 CacheBestSize(best
);
1689 // ----------------------------------------------------------------------------
1691 // ----------------------------------------------------------------------------
1693 void wxTextCtrl::Freeze()
1696 if ( HasFlag(wxTE_MULTILINE
) )
1698 gtk_text_freeze(GTK_TEXT(m_text
));
1703 void wxTextCtrl::Thaw()
1706 if ( HasFlag(wxTE_MULTILINE
) )
1708 GTK_TEXT(m_text
)->vadj
->value
= 0.0;
1710 gtk_text_thaw(GTK_TEXT(m_text
));
1715 // ----------------------------------------------------------------------------
1717 // ----------------------------------------------------------------------------
1719 GtkAdjustment
*wxTextCtrl::GetVAdj() const
1721 if ( !IsMultiLine() )
1725 return gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(m_widget
));
1727 return GTK_TEXT(m_text
)->vadj
;
1731 bool wxTextCtrl::DoScroll(GtkAdjustment
*adj
, int diff
)
1733 float value
= adj
->value
+ diff
;
1738 float upper
= adj
->upper
- adj
->page_size
;
1739 if ( value
> upper
)
1742 // did we noticeably change the scroll position?
1743 if ( fabs(adj
->value
- value
) < 0.2 )
1745 // well, this is what Robert does in wxScrollBar, so it must be good...
1752 gtk_adjustment_value_changed(GTK_ADJUSTMENT(adj
));
1754 gtk_signal_emit_by_name(GTK_OBJECT(adj
), "value_changed");
1760 bool wxTextCtrl::ScrollLines(int lines
)
1762 GtkAdjustment
*adj
= GetVAdj();
1767 int diff
= (int)ceil(lines
*adj
->step_increment
);
1769 // this is hardcoded to 10 in GTK+ 1.2 (great idea)
1770 int diff
= 10*lines
;
1773 return DoScroll(adj
, diff
);
1776 bool wxTextCtrl::ScrollPages(int pages
)
1778 GtkAdjustment
*adj
= GetVAdj();
1782 return DoScroll(adj
, (int)ceil(pages
*adj
->page_increment
));
1788 wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
1790 return GetDefaultAttributesFromGTKWidget(gtk_entry_new
, true);