X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/fdd55287d874bf890f08abbebd18702f17466381..82a16d7e5e5c83e95a4caa7314de2dbfbd1debdc:/src/gtk1/textctrl.cpp?ds=sidebyside diff --git a/src/gtk1/textctrl.cpp b/src/gtk1/textctrl.cpp index d612b6a9c2..023debbdb1 100644 --- a/src/gtk1/textctrl.cpp +++ b/src/gtk1/textctrl.cpp @@ -7,10 +7,13 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "textctrl.h" #endif +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + #include "wx/textctrl.h" #include "wx/utils.h" #include "wx/intl.h" @@ -65,28 +68,16 @@ static void wxGtkTextInsert(GtkWidget *text, ? attr.GetBackgroundColour().GetColor() : NULL; - GtkTextIter start, end; - GtkTextMark *mark; - // iterators are invalidated by any mutation that affects 'indexable' buffer contents, - // so we save current position in a mark - // we need a mark of left gravity, so we cannot use - // mark = gtk_text_buffer_get_insert (text_buffer) - - gtk_text_buffer_get_iter_at_mark( text_buffer, &start, - gtk_text_buffer_get_insert (text_buffer) ); - mark = gtk_text_buffer_create_mark( text_buffer, NULL, &start, TRUE/*left gravity*/ ); - - gtk_text_buffer_insert_at_cursor( text_buffer, buffer, strlen(buffer) ); - - gtk_text_buffer_get_iter_at_mark( text_buffer, &end, - gtk_text_buffer_get_insert (text_buffer) ); - gtk_text_buffer_get_iter_at_mark( text_buffer, &start, mark ); - GtkTextTag *tag; tag = gtk_text_buffer_create_tag( text_buffer, NULL, "font-desc", font_description, "foreground-gdk", colFg, "background-gdk", colBg, NULL ); - gtk_text_buffer_apply_tag( text_buffer, tag, &start, &end ); + + GtkTextIter iter; + gtk_text_buffer_get_iter_at_mark( text_buffer, &iter, + gtk_text_buffer_get_insert (text_buffer) ); + + gtk_text_buffer_insert_with_tags( text_buffer, &iter, buffer, strlen(buffer), tag, NULL ); } #else static void wxGtkTextInsert(GtkWidget *text, @@ -164,7 +155,9 @@ gtk_text_changed_callback( GtkWidget *widget, wxTextCtrl *win ) wxapp_install_idle_handler(); win->SetModified(); +#ifndef __WXGTK20__ win->UpdateFontIfNeeded(); +#endif // !__WXGTK20__ wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() ); event.SetEventObject( win ); @@ -248,7 +241,7 @@ void wxTextCtrl::Init() { m_ignoreNextUpdate = m_modified = FALSE; - m_updateFont = FALSE; + SetUpdateFont(FALSE); m_text = m_vScrollbar = (GtkWidget *)NULL; } @@ -312,13 +305,15 @@ bool wxTextCtrl::Create( wxWindow *parent, gtk_container_add( GTK_CONTAINER(m_widget), m_text ); // Global settings which can be overridden by tags, I guess. - if (HasFlag( wxHSCROLL )) + if (HasFlag( wxHSCROLL ) || HasFlag( wxTE_DONTWRAP )) gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), GTK_WRAP_NONE ); else gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), GTK_WRAP_WORD ); if (!HasFlag(wxNO_BORDER)) gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(m_widget), GTK_SHADOW_IN ); + + GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); #else // create our control ... m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); @@ -355,18 +350,7 @@ bool wxTextCtrl::Create( wxWindow *parent, m_focusWidget = m_text; - PostCreation(); - - SetFont( parent->GetFont() ); - - wxSize size_best( DoGetBestSize() ); - wxSize new_size( size ); - if (new_size.x == -1) - new_size.x = size_best.x; - if (new_size.y == -1) - new_size.y = size_best.y; - if ((new_size.x != size.x) || (new_size.y != size.y)) - SetSize( new_size.x, new_size.y ); + PostCreation(size); if (multi_line) gtk_widget_show(m_text); @@ -433,16 +417,36 @@ bool wxTextCtrl::Create( wxWindow *parent, #ifdef __WXGTK20__ else gtk_text_view_set_editable( GTK_TEXT_VIEW( m_text), FALSE); - } #else } else { if (multi_line) gtk_text_set_editable( GTK_TEXT(m_text), 1 ); - } #endif + } +#ifdef __WXGTK20__ + if (multi_line) + { + if (style & wxTE_RIGHT) + gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text), GTK_JUSTIFY_RIGHT ); + else if (style & wxTE_CENTRE) + gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text), GTK_JUSTIFY_CENTER ); + // Left justify (alignment) is the default and we don't need to apply GTK_JUSTIFY_LEFT + } + // gtk_entry_set_alignment was introduced in gtk+-2.3.5 +#if GTK_CHECK_VERSION(2, 3, 5) + else + { + if (style & wxTE_RIGHT) + gtk_entry_set_alignment( GTK_ENTRY(m_text), 1.0 ); + else if (style & wxTE_CENTRE) + gtk_entry_set_alignment( GTK_ENTRY(m_text), 0.5 ); + } +#endif // gtk+-2.3.5 +#endif // __WXGTK20__ + // We want to be notified about text changes. #ifdef __WXGTK20__ if (multi_line) @@ -452,28 +456,21 @@ bool wxTextCtrl::Create( wxWindow *parent, } else #endif + { - gtk_signal_connect( GTK_OBJECT(m_text), "changed", - GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this); + gtk_signal_connect( GTK_OBJECT(m_text), "changed", + GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this); } - // we don't set a valid background colour, because the window - // manager should use a default one - m_backgroundColour = wxColour(); - - wxColour colFg = parent->GetForegroundColour(); - SetForegroundColour( colFg ); - m_cursor = wxCursor( wxCURSOR_IBEAM ); - wxTextAttr attrDef( colFg, m_backgroundColour, parent->GetFont() ); + wxTextAttr attrDef(GetForegroundColour(), GetBackgroundColour(), GetFont()); SetDefaultStyle( attrDef ); - Show( TRUE ); - return TRUE; } + void wxTextCtrl::CalculateScrollbar() { #ifndef __WXGTK20__ @@ -515,13 +512,14 @@ wxString wxTextCtrl::GetValue() const GtkTextIter end; gtk_text_buffer_get_end_iter( text_buffer, &end ); gchar *text = gtk_text_buffer_get_text( text_buffer, &start, &end, TRUE ); - + #if wxUSE_UNICODE wxWCharBuffer buffer( wxConvUTF8.cMB2WX( text ) ); #else wxCharBuffer buffer( wxConvLocal.cWC2WX( wxConvUTF8.cMB2WC( text ) ) ); #endif - tmp = buffer; + if ( buffer ) + tmp = buffer; g_free( text ); #else @@ -553,6 +551,9 @@ void wxTextCtrl::SetValue( const wxString &value ) wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( value ) ) ); #endif GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) ); + if (gtk_text_buffer_get_char_count(text_buffer) != 0) + IgnoreNextTextUpdate(); + gtk_text_buffer_set_text( text_buffer, buffer, strlen(buffer) ); #else @@ -568,7 +569,7 @@ void wxTextCtrl::SetValue( const wxString &value ) } // GRG, Jun/2000: Changed this after a lot of discussion in - // the lists. wxWindows 2.2 will have a set of flags to + // the lists. wxWidgets 2.2 will have a set of flags to // customize this behaviour. SetInsertionPoint(0); @@ -582,6 +583,11 @@ void wxTextCtrl::WriteText( const wxString &text ) if ( text.empty() ) return; + // gtk_text_changed_callback() will set m_modified to true but m_modified + // shouldn't be changed by the program writing to the text control itself, + // so save the old value and restore when we're done + bool oldModified = m_modified; + if ( m_windowStyle & wxTE_MULTILINE ) { #ifdef __WXGTK20__ @@ -591,15 +597,24 @@ void wxTextCtrl::WriteText( const wxString &text ) #else wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) ); #endif + if ( !buffer ) + { + // what else can we do? at least don't crash... + return; + } + GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) ); - + // TODO: Call whatever is needed to delete the selection. wxGtkTextInsert( m_text, text_buffer, m_defaultStyle, buffer ); - // Scroll to cursor. - GtkTextIter iter; - gtk_text_buffer_get_iter_at_mark( text_buffer, &iter, gtk_text_buffer_get_insert( text_buffer ) ); - gtk_text_view_scroll_to_iter( GTK_TEXT_VIEW(m_text), &iter, 0.0, FALSE, 0.0, 1.0 ); + GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(m_widget) ); + // Scroll to cursor, but only if scrollbar thumb is at the very bottom + if ( adj->value == adj->upper - adj->page_size ) + { + gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text), + gtk_text_buffer_get_insert( text_buffer ), 0.0, FALSE, 0.0, 1.0 ); + } #else // GTK 1.x // After cursor movements, gtk_text_get_point() is wrong by one. gtk_text_set_point( GTK_TEXT(m_text), GET_EDITABLE_POS(m_text) ); @@ -610,6 +625,13 @@ void wxTextCtrl::WriteText( const wxString &text ) gtk_editable_delete_selection( GTK_EDITABLE(m_text) ); wxGtkTextInsert(m_text, m_defaultStyle, text.c_str(), text.Len()); + // we called wxGtkTextInsert with correct font, no need to do anything + // in UpdateFontIfNeeded() any longer + if ( !text.empty() ) + { + SetUpdateFont(FALSE); + } + // Bring editable's cursor back uptodate. SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) )); #endif // GTK 1.x/2.0 @@ -639,7 +661,7 @@ void wxTextCtrl::WriteText( const wxString &text ) gtk_entry_set_position( GTK_ENTRY(m_text), len ); } - m_modified = TRUE; + m_modified = oldModified; } void wxTextCtrl::AppendText( const wxString &text ) @@ -673,10 +695,21 @@ wxString wxTextCtrl::GetLineText( long lineNo ) const return buf; } else -#endif { return wxEmptyString; } +#else + GtkTextBuffer *text_buffer; + text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(m_text)); + GtkTextIter line; + gtk_text_buffer_get_iter_at_line(text_buffer,&line,lineNo); + GtkTextIter end; + gtk_text_buffer_get_end_iter(text_buffer,&end ); + gchar *text = gtk_text_buffer_get_text(text_buffer,&line,&end,TRUE); + wxString result(wxGTK_CONV_BACK(text)); + g_free(text); + return result.BeforeFirst(wxT('\n')); +#endif } else { @@ -792,14 +825,19 @@ void wxTextCtrl::SetInsertionPoint( long pos ) { wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") ); - if (m_windowStyle & wxTE_MULTILINE) + if ( IsMultiLine() ) { #ifdef __WXGTK20__ GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) ); GtkTextIter iter; gtk_text_buffer_get_iter_at_offset( text_buffer, &iter, pos ); gtk_text_buffer_place_cursor( text_buffer, &iter ); -#else + gtk_text_view_scroll_mark_onscreen + ( + GTK_TEXT_VIEW(m_text), + gtk_text_buffer_get_insert( text_buffer ) + ); +#else // GTK+ 1.x gtk_signal_disconnect_by_func( GTK_OBJECT(m_text), GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this); @@ -816,7 +854,7 @@ void wxTextCtrl::SetInsertionPoint( long pos ) // bring editable's cursor uptodate. Bug in GTK. SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) )); -#endif +#endif // GTK+ 2/1 } else { @@ -911,6 +949,11 @@ void wxTextCtrl::OnParentEnable( bool enable ) } } +void wxTextCtrl::MarkDirty() +{ + m_modified = TRUE; +} + void wxTextCtrl::DiscardEdits() { m_modified = FALSE; @@ -1014,9 +1057,16 @@ void wxTextCtrl::SetSelection( long from, long to ) void wxTextCtrl::ShowPosition( long pos ) { -#ifndef __WXGTK20__ if (m_windowStyle & wxTE_MULTILINE) { +#ifdef __WXGTK20__ + GtkTextBuffer *buf = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) ); + GtkTextIter iter; + gtk_text_buffer_get_start_iter( buf, &iter ); + gtk_text_iter_set_offset( &iter, pos ); + GtkTextMark *mark = gtk_text_buffer_create_mark( buf, NULL, &iter, TRUE ); + gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text), mark, 0.0, FALSE, 0.0, 0.0 ); +#else // GTK 1.x GtkAdjustment *vp = GTK_TEXT(m_text)->vadj; float totalLines = (float) GetNumberOfLines(); long posX; @@ -1025,10 +1075,40 @@ void wxTextCtrl::ShowPosition( long pos ) float posLine = (float) posY; float p = (posLine/totalLines)*(vp->upper - vp->lower) + vp->lower; gtk_adjustment_set_value(GTK_TEXT(m_text)->vadj, p); +#endif // GTK 1.x/2.x } -#endif } +#ifdef __WXGTK20__ + +wxTextCtrlHitTestResult +wxTextCtrl::HitTest(const wxPoint& pt, long *pos) const +{ + if ( !IsMultiLine() ) + { + // not supported + return wxTE_HT_UNKNOWN; + } + + int x, y; + gtk_text_view_window_to_buffer_coords + ( + GTK_TEXT_VIEW(m_text), + GTK_TEXT_WINDOW_TEXT, + pt.x, pt.y, + &x, &y + ); + + GtkTextIter iter; + gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &iter, x, y); + if ( pos ) + *pos = gtk_text_iter_get_offset(&iter); + + return wxTE_HT_ON_TEXT; +} + +#endif // __WXGTK20__ + long wxTextCtrl::GetInsertionPoint() const { wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") ); @@ -1129,27 +1209,36 @@ void wxTextCtrl::Cut() { wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") ); -#ifndef __WXGTK20__ - gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG ); +#ifdef __WXGTK20__ + if (m_windowStyle & wxTE_MULTILINE) + g_signal_emit_by_name(m_text, "cut-clipboard"); + else #endif + gtk_editable_cut_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG); } void wxTextCtrl::Copy() { wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") ); -#ifndef __WXGTK20__ - gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG ); +#ifdef __WXGTK20__ + if (m_windowStyle & wxTE_MULTILINE) + g_signal_emit_by_name(m_text, "copy-clipboard"); + else #endif + gtk_editable_copy_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG); } void wxTextCtrl::Paste() { wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") ); -#ifndef __WXGTK20__ - gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG ); +#ifdef __WXGTK20__ + if (m_windowStyle & wxTE_MULTILINE) + g_signal_emit_by_name(m_text, "paste-clipboard"); + else #endif + gtk_editable_paste_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG); } // Undo/redo @@ -1185,36 +1274,49 @@ void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const { wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") ); - gint from, to; -#ifdef __WXGTK20__ - GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (m_text)); - GtkTextIter ifrom, ito; - if (!gtk_text_buffer_get_selection_bounds(buffer, &ifrom, &ito)) -#else - if ( !(GTK_EDITABLE(m_text)->has_selection) ) -#endif - { - from = - to = GetInsertionPoint(); - } - else // got selection - { + gint from = -1; + gint to = -1; + bool haveSelection = FALSE; + #ifdef __WXGTK20__ - from = gtk_text_iter_get_offset(&ifrom); - to = gtk_text_iter_get_offset(&ito); -#else - from = (long) GTK_EDITABLE(m_text)->selection_start_pos; - to = (long) GTK_EDITABLE(m_text)->selection_end_pos; + if (m_windowStyle & wxTE_MULTILINE) + { + GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (m_text)); + GtkTextIter ifrom, ito; + if ( gtk_text_buffer_get_selection_bounds(buffer, &ifrom, &ito) ) + { + haveSelection = TRUE; + from = gtk_text_iter_get_offset(&ifrom); + to = gtk_text_iter_get_offset(&ito); + } + } + else // not multi-line + { + if ( gtk_editable_get_selection_bounds( GTK_EDITABLE(m_text), + &from, &to) ) + { + haveSelection = TRUE; + } + } +#else // not GTK2 + if ( (GTK_EDITABLE(m_text)->has_selection) ) + { + haveSelection = TRUE; + from = (long) GTK_EDITABLE(m_text)->selection_start_pos; + to = (long) GTK_EDITABLE(m_text)->selection_end_pos; + } #endif - if ( from > to ) - { - // exchange them to be compatible with wxMSW - gint tmp = from; - from = to; - to = tmp; - } - } + if (! haveSelection ) + from = to = GetInsertionPoint(); + + if ( from > to ) + { + // exchange them to be compatible with wxMSW + gint tmp = from; + from = to; + to = tmp; + } if ( fromOut ) *fromOut = from; @@ -1222,6 +1324,7 @@ void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const *toOut = to; } + bool wxTextCtrl::IsEditable() const { wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") ); @@ -1320,7 +1423,7 @@ bool wxTextCtrl::SetFont( const wxFont &font ) if ( m_windowStyle & wxTE_MULTILINE ) { - m_updateFont = TRUE; + SetUpdateFont(TRUE); m_defaultStyle.SetFont(font); @@ -1334,25 +1437,37 @@ void wxTextCtrl::ChangeFontGlobally() { // this method is very inefficient and hence should be called as rarely as // possible! + // + // TODO: it can be implemented much more efficiently for GTK2 +#ifndef __WXGTK20__ wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont, + _T("shouldn't be called for single line controls") ); +#else + wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE), + _T("shouldn't be called for single line controls") ); +#endif wxString value = GetValue(); if ( !value.IsEmpty() ) { - m_updateFont = FALSE; + SetUpdateFont(FALSE); Clear(); AppendText(value); } } +#ifndef __WXGTK20__ + void wxTextCtrl::UpdateFontIfNeeded() { if ( m_updateFont ) ChangeFontGlobally(); } +#endif // GTK+ 1.x + bool wxTextCtrl::SetForegroundColour(const wxColour& colour) { if ( !wxControl::SetForegroundColour(colour) ) @@ -1371,16 +1486,10 @@ bool wxTextCtrl::SetBackgroundColour( const wxColour &colour ) if ( !wxControl::SetBackgroundColour( colour ) ) return FALSE; +#ifndef __WXGTK20__ if (!m_widget->window) return FALSE; - - wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE ); - if (sysbg.Red() == colour.Red() && - sysbg.Green() == colour.Green() && - sysbg.Blue() == colour.Blue()) - { - return FALSE; // FIXME or TRUE? - } +#endif if (!m_backgroundColour.Ok()) return FALSE; @@ -1449,7 +1558,7 @@ bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style ) #else // VERY dirty way to do that - removes the required text and re-adds it // with styling (FIXME) - + gint l = gtk_text_get_length( GTK_TEXT(m_text) ); wxCHECK_MSG( start >= 0 && end <= l, FALSE, @@ -1493,17 +1602,9 @@ bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style ) } } -void wxTextCtrl::ApplyWidgetStyle() +void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style) { - if (m_windowStyle & wxTE_MULTILINE) - { - // how ? - } - else - { - SetWidgetStyle(); - gtk_widget_set_style( m_text, m_widgetStyle ); - } + gtk_widget_modify_style(m_text, style); } void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event)) @@ -1591,14 +1692,17 @@ void wxTextCtrl::OnInternalIdle() } } - UpdateWindowUI(); + if (wxUpdateUIEvent::CanUpdate(this)) + UpdateWindowUI(wxUPDATE_UI_FROMIDLE); } wxSize wxTextCtrl::DoGetBestSize() const { // FIXME should be different for multi-line controls... wxSize ret( wxControl::DoGetBestSize() ); - return wxSize(80, ret.y); + wxSize best(80, ret.y); + CacheBestSize(best); + return best; } // ---------------------------------------------------------------------------- @@ -1633,16 +1737,18 @@ void wxTextCtrl::Thaw() GtkAdjustment *wxTextCtrl::GetVAdj() const { + if ( !IsMultiLine() ) + return NULL; + #ifdef __WXGTK20__ - return NULL; + return gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(m_widget)); #else - return HasFlag(wxTE_MULTILINE) ? GTK_TEXT(m_text)->vadj : NULL; + return GTK_TEXT(m_text)->vadj; #endif } bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff) { -#ifndef __WXGTK20__ float value = adj->value + diff; if ( value < 0 ) @@ -1661,38 +1767,44 @@ bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff) adj->value = value; +#ifdef __WXGTK20__ + gtk_adjustment_value_changed(GTK_ADJUSTMENT(adj)); +#else gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed"); - #endif + return TRUE; } bool wxTextCtrl::ScrollLines(int lines) { -#ifdef __WXGTK20__ - return FALSE; -#else GtkAdjustment *adj = GetVAdj(); if ( !adj ) return FALSE; +#ifdef __WXGTK20__ + int diff = (int)ceil(lines*adj->step_increment); +#else // this is hardcoded to 10 in GTK+ 1.2 (great idea) - static const int KEY_SCROLL_PIXELS = 10; - - return DoScroll(adj, lines*KEY_SCROLL_PIXELS); + int diff = 10*lines; #endif + + return DoScroll(adj, diff); } bool wxTextCtrl::ScrollPages(int pages) { -#ifdef __WXGTK20__ - return FALSE; -#else GtkAdjustment *adj = GetVAdj(); if ( !adj ) return FALSE; return DoScroll(adj, (int)ceil(pages*adj->page_increment)); -#endif } + +// static +wxVisualAttributes +wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) +{ + return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true); +}