src/gtk/textctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        textctrl.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Vadim Zeitlin
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  11 #pragma implementation "textctrl.h"
  12 #endif
  13
  14 // For compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #include "wx/textctrl.h"
  18 #include "wx/utils.h"
  19 #include "wx/intl.h"
  20 #include "wx/log.h"
  21 #include "wx/settings.h"
  22 #include "wx/panel.h"
  23 #include "wx/strconv.h"
  24 #include "wx/fontutil.h"        // for wxNativeFontInfo (GetNativeFontInfo())
  25
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <ctype.h>
  29 #include <math.h>               // for fabs
  30
  31 #include "wx/gtk/private.h"
  32 #include <gdk/gdkkeysyms.h>
  33
  34 //-----------------------------------------------------------------------------
  35 // idle system
  36 //-----------------------------------------------------------------------------
  37
  38 extern void wxapp_install_idle_handler();
  39 extern bool g_isIdle;
  40
  41 //-----------------------------------------------------------------------------
  42 // data
  43 //-----------------------------------------------------------------------------
  44
  45 extern bool       g_blockEventsOnDrag;
  46 extern wxCursor   g_globalCursor;
  47 extern wxWindowGTK *g_delayedFocus;
  48
  49 // ----------------------------------------------------------------------------
  50 // helpers
  51 // ----------------------------------------------------------------------------
  52
  53 #ifdef __WXGTK20__
  54 static void wxGtkTextInsert(GtkWidget *text,
  55                             GtkTextBuffer *text_buffer,
  56                             const wxTextAttr& attr,
  57                             wxCharBuffer buffer)
  58
  59 {
  60     PangoFontDescription *font_description = attr.HasFont()
  61                          ? attr.GetFont().GetNativeFontInfo()->description
  62                          : NULL;
  63
  64     GdkColor *colFg = attr.HasTextColour() ? attr.GetTextColour().GetColor()
  65                                            : NULL;
  66
  67     GdkColor *colBg = attr.HasBackgroundColour()
  68                         ? attr.GetBackgroundColour().GetColor()
  69                         : NULL;
  70
  71     GtkTextTag *tag;
  72     tag = gtk_text_buffer_create_tag( text_buffer, NULL, "font-desc", font_description,
  73                                      "foreground-gdk", colFg,
  74                                      "background-gdk", colBg, NULL );
  75
  76     GtkTextIter iter;
  77     gtk_text_buffer_get_iter_at_mark( text_buffer, &iter,
  78                                      gtk_text_buffer_get_insert (text_buffer) );
  79
  80     gtk_text_buffer_insert_with_tags( text_buffer, &iter, buffer, strlen(buffer), tag, NULL );
  81 }
  82 #else
  83 static void wxGtkTextInsert(GtkWidget *text,
  84                             const wxTextAttr& attr,
  85                             const char *txt,
  86                             size_t len)
  87 {
  88     GdkFont *font = attr.HasFont() ? attr.GetFont().GetInternalFont()
  89                                    : NULL;
  90
  91     GdkColor *colFg = attr.HasTextColour() ? attr.GetTextColour().GetColor()
  92                                            : NULL;
  93
  94     GdkColor *colBg = attr.HasBackgroundColour()
  95                         ? attr.GetBackgroundColour().GetColor()
  96                         : NULL;
  97
  98     gtk_text_insert( GTK_TEXT(text), font, colFg, colBg, txt, len );
  99 }
 100 #endif // GTK 1.x
 101
 102 // ----------------------------------------------------------------------------
 103 // "insert_text" for GtkEntry
 104 // ----------------------------------------------------------------------------
 105
 106 static void
 107 gtk_insert_text_callback(GtkEditable *editable,
 108                          const gchar *new_text,
 109                          gint new_text_length,
 110                          gint *position,
 111                          wxTextCtrl *win)
 112 {
 113     if (g_isIdle)
 114         wxapp_install_idle_handler();
 115
 116     // we should only be called if we have a max len limit at all
 117     GtkEntry *entry = GTK_ENTRY (editable);
 118
 119     wxCHECK_RET( entry->text_max_length, _T("shouldn't be called") );
 120
 121     // check that we don't overflow the max length limit
 122     //
 123     // FIXME: this doesn't work when we paste a string which is going to be
 124     //        truncated
 125     if ( entry->text_length == entry->text_max_length )
 126     {
 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");
 129
 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();
 133
 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 );
 139     }
 140 }
 141
 142 //-----------------------------------------------------------------------------
 143 //  "changed"
 144 //-----------------------------------------------------------------------------
 145
 146 static void
 147 gtk_text_changed_callback( GtkWidget *widget, wxTextCtrl *win )
 148 {
 149     if ( win->IgnoreTextUpdate() )
 150         return;
 151
 152     if (!win->m_hasVMT) return;
 153
 154     if (g_isIdle)
 155         wxapp_install_idle_handler();
 156
 157     win->SetModified();
 158     win->UpdateFontIfNeeded();
 159
 160     wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
 161     event.SetEventObject( win );
 162     event.SetString( win->GetValue() );
 163     win->GetEventHandler()->ProcessEvent( event );
 164 }
 165
 166 //-----------------------------------------------------------------------------
 167 // "changed" from vertical scrollbar
 168 //-----------------------------------------------------------------------------
 169
 170 #ifndef __WXGTK20__
 171 static void
 172 gtk_scrollbar_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
 173 {
 174     if (!win->m_hasVMT) return;
 175
 176     if (g_isIdle)
 177         wxapp_install_idle_handler();
 178
 179     win->CalculateScrollbar();
 180 }
 181 #endif
 182
 183 // ----------------------------------------------------------------------------
 184 // redraw callback for multiline text
 185 // ----------------------------------------------------------------------------
 186
 187 #ifndef __WXGTK20__
 188
 189 // redrawing a GtkText from inside a wxYield() call results in crashes (the
 190 // text sample shows it in its "Add lines" command which shows wxProgressDialog
 191 // which implicitly calls wxYield()) so we override GtkText::draw() and simply
 192 // don't do anything if we're inside wxYield()
 193
 194 extern bool wxIsInsideYield;
 195
 196 extern "C" {
 197     typedef void (*GtkDrawCallback)(GtkWidget *widget, GdkRectangle *rect);
 198 }
 199
 200 static GtkDrawCallback gs_gtk_text_draw = NULL;
 201
 202 extern "C"
 203 void wxgtk_text_draw( GtkWidget *widget, GdkRectangle *rect)
 204 {
 205     if ( !wxIsInsideYield )
 206     {
 207         wxCHECK_RET( gs_gtk_text_draw != wxgtk_text_draw,
 208                      _T("infinite recursion in wxgtk_text_draw aborted") );
 209
 210         gs_gtk_text_draw(widget, rect);
 211     }
 212 }
 213
 214 #endif // __WXGTK20__
 215
 216 //-----------------------------------------------------------------------------
 217 //  wxTextCtrl
 218 //-----------------------------------------------------------------------------
 219
 220 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
 221
 222 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
 223     EVT_CHAR(wxTextCtrl::OnChar)
 224
 225     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
 226     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
 227     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
 228     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
 229     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
 230
 231     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
 232     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
 233     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
 234     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
 235     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
 236 END_EVENT_TABLE()
 237
 238 void wxTextCtrl::Init()
 239 {
 240     m_ignoreNextUpdate =
 241     m_modified = FALSE;
 242     m_updateFont = FALSE;
 243     m_text =
 244     m_vScrollbar = (GtkWidget *)NULL;
 245 }
 246
 247 wxTextCtrl::wxTextCtrl( wxWindow *parent,
 248                         wxWindowID id,
 249                         const wxString &value,
 250                         const wxPoint &pos,
 251                         const wxSize &size,
 252                         long style,
 253                         const wxValidator& validator,
 254                         const wxString &name )
 255 {
 256     Init();
 257
 258     Create( parent, id, value, pos, size, style, validator, name );
 259 }
 260
 261 bool wxTextCtrl::Create( wxWindow *parent,
 262                          wxWindowID id,
 263                          const wxString &value,
 264                          const wxPoint &pos,
 265                          const wxSize &size,
 266                          long style,
 267                          const wxValidator& validator,
 268                          const wxString &name )
 269 {
 270     m_needParent = TRUE;
 271     m_acceptsFocus = TRUE;
 272
 273     if (!PreCreation( parent, pos, size ) ||
 274         !CreateBase( parent, id, pos, size, style, validator, name ))
 275     {
 276         wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
 277         return FALSE;
 278     }
 279
 280
 281     m_vScrollbarVisible = FALSE;
 282
 283     bool multi_line = (style & wxTE_MULTILINE) != 0;
 284
 285 #ifdef __WXGTK20__
 286     GtkTextBuffer *buffer = NULL;
 287 #endif
 288
 289     if (multi_line)
 290     {
 291 #ifdef __WXGTK20__
 292         // Create view
 293         m_text = gtk_text_view_new();
 294
 295         buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
 296
 297         // create scrolled window
 298         m_widget = gtk_scrolled_window_new( NULL, NULL );
 299         gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( m_widget ),
 300                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
 301
 302         // Insert view into scrolled window
 303         gtk_container_add( GTK_CONTAINER(m_widget), m_text );
 304
 305         // Global settings which can be overridden by tags, I guess.
 306         if (HasFlag( wxHSCROLL ) || HasFlag( wxTE_DONTWRAP ))
 307             gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), GTK_WRAP_NONE );
 308         else
 309             gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( m_text ), GTK_WRAP_WORD );
 310
 311         if (!HasFlag(wxNO_BORDER))
 312             gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(m_widget), GTK_SHADOW_IN );
 313
 314         GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 315 #else
 316         // create our control ...
 317         m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
 318
 319         // ... and put into the upper left hand corner of the table
 320         bool bHasHScrollbar = FALSE;
 321         m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
 322         GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 323         gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
 324                       (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
 325                       (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
 326                        0, 0);
 327
 328         // always wrap words
 329         gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
 330
 331         // finally, put the vertical scrollbar in the upper right corner
 332         m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
 333         GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
 334         gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
 335                      GTK_FILL,
 336                      (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
 337                      0, 0);
 338 #endif
 339     }
 340     else
 341     {
 342         // a single-line text control: no need for scrollbars
 343         m_widget =
 344         m_text = gtk_entry_new();
 345     }
 346
 347     m_parent->DoAddChild( this );
 348
 349     m_focusWidget = m_text;
 350
 351     PostCreation(size);
 352
 353     if (multi_line)
 354         gtk_widget_show(m_text);
 355
 356 #ifndef __WXGTK20__
 357     if (multi_line)
 358     {
 359         gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
 360           (GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
 361
 362         // only initialize gs_gtk_text_draw once, starting from the next the
 363         // klass::draw will already be wxgtk_text_draw
 364         if ( !gs_gtk_text_draw )
 365         {
 366             GtkDrawCallback&
 367                 draw = GTK_WIDGET_CLASS(GTK_OBJECT(m_text)->klass)->draw;
 368
 369             gs_gtk_text_draw = draw;
 370
 371             draw = wxgtk_text_draw;
 372         }
 373     }
 374 #endif // GTK+ 1.x
 375
 376     if (!value.IsEmpty())
 377     {
 378 #ifdef __WXGTK20__
 379         SetValue( value );
 380 #else
 381
 382 #if !GTK_CHECK_VERSION(1, 2, 0)
 383         // if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
 384         // gtk_editable_insert_text()
 385         gtk_widget_realize(m_text);
 386 #endif // GTK 1.0
 387
 388         gint tmp = 0;
 389 #if wxUSE_UNICODE
 390         wxWX2MBbuf val = value.mbc_str();
 391         gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp );
 392 #else
 393         gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
 394 #endif
 395
 396         if (multi_line)
 397         {
 398             // Bring editable's cursor uptodate. Bug in GTK.
 399             SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
 400         }
 401
 402 #endif
 403     }
 404
 405     if (style & wxTE_PASSWORD)
 406     {
 407         if (!multi_line)
 408             gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
 409     }
 410
 411     if (style & wxTE_READONLY)
 412     {
 413         if (!multi_line)
 414             gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
 415 #ifdef __WXGTK20__
 416         else
 417             gtk_text_view_set_editable( GTK_TEXT_VIEW( m_text), FALSE);
 418 #else
 419     }
 420     else
 421     {
 422         if (multi_line)
 423             gtk_text_set_editable( GTK_TEXT(m_text), 1 );
 424 #endif
 425     }
 426
 427 #ifdef __WXGTK20__
 428     if (multi_line)
 429     {
 430         if (style & wxTE_RIGHT)
 431             gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text), GTK_JUSTIFY_RIGHT );
 432         else if (style & wxTE_CENTRE)
 433             gtk_text_view_set_justification( GTK_TEXT_VIEW(m_text), GTK_JUSTIFY_CENTER );
 434         // Left justify (alignment) is the default and we don't need to apply GTK_JUSTIFY_LEFT
 435     }
 436     // gtk_entry_set_alignment was introduced in gtk+-2.3.5
 437 #if GTK_CHECK_VERSION(2, 3, 5)
 438     else
 439     {
 440         if (style & wxTE_RIGHT)
 441             gtk_entry_set_alignment( GTK_ENTRY(m_text), 1.0 );
 442         else if (style & wxTE_CENTRE)
 443             gtk_entry_set_alignment( GTK_ENTRY(m_text), 0.5 );
 444     }
 445 #endif // gtk+-2.3.5
 446 #endif // __WXGTK20__
 447
 448     // We want to be notified about text changes.
 449 #ifdef __WXGTK20__
 450     if (multi_line)
 451     {
 452         g_signal_connect( G_OBJECT(buffer), "changed",
 453             GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
 454     }
 455     else
 456 #endif
 457
 458     {
 459         gtk_signal_connect( GTK_OBJECT(m_text), "changed",
 460             GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
 461     }
 462
 463     m_cursor = wxCursor( wxCURSOR_IBEAM );
 464
 465     wxTextAttr attrDef(GetForegroundColour(), GetBackgroundColour(), GetFont());
 466     SetDefaultStyle( attrDef );
 467
 468     return TRUE;
 469 }
 470
 471
 472 void wxTextCtrl::CalculateScrollbar()
 473 {
 474 #ifndef __WXGTK20__
 475     if ((m_windowStyle & wxTE_MULTILINE) == 0) return;
 476
 477     GtkAdjustment *adj = GTK_TEXT(m_text)->vadj;
 478
 479     if (adj->upper - adj->page_size < 0.8)
 480     {
 481         if (m_vScrollbarVisible)
 482         {
 483             gtk_widget_hide( m_vScrollbar );
 484             m_vScrollbarVisible = FALSE;
 485         }
 486     }
 487     else
 488     {
 489         if (!m_vScrollbarVisible)
 490         {
 491             gtk_widget_show( m_vScrollbar );
 492             m_vScrollbarVisible = TRUE;
 493         }
 494     }
 495 #endif
 496 }
 497
 498 wxString wxTextCtrl::GetValue() const
 499 {
 500     wxCHECK_MSG( m_text != NULL, wxT(""), wxT("invalid text ctrl") );
 501
 502     wxString tmp;
 503     if (m_windowStyle & wxTE_MULTILINE)
 504     {
 505 #ifdef __WXGTK20__
 506         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
 507
 508         GtkTextIter start;
 509         gtk_text_buffer_get_start_iter( text_buffer, &start );
 510         GtkTextIter end;
 511         gtk_text_buffer_get_end_iter( text_buffer, &end );
 512         gchar *text = gtk_text_buffer_get_text( text_buffer, &start, &end, TRUE );
 513
 514 #if wxUSE_UNICODE
 515         wxWCharBuffer buffer( wxConvUTF8.cMB2WX( text ) );
 516 #else
 517         wxCharBuffer buffer( wxConvLocal.cWC2WX( wxConvUTF8.cMB2WC( text ) ) );
 518 #endif
 519         tmp = buffer;
 520
 521         g_free( text );
 522 #else
 523         gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 524         char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
 525         tmp = text;
 526         g_free( text );
 527 #endif
 528     }
 529     else
 530     {
 531         tmp = wxGTK_CONV_BACK( gtk_entry_get_text( GTK_ENTRY(m_text) ) );
 532     }
 533
 534     return tmp;
 535 }
 536
 537 void wxTextCtrl::SetValue( const wxString &value )
 538 {
 539     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 540
 541     if (m_windowStyle & wxTE_MULTILINE)
 542     {
 543 #ifdef __WXGTK20__
 544
 545 #if wxUSE_UNICODE
 546         wxCharBuffer buffer( wxConvUTF8.cWX2MB( value) );
 547 #else
 548         wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( value ) ) );
 549 #endif
 550         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
 551         gtk_text_buffer_set_text( text_buffer, buffer, strlen(buffer) );
 552
 553 #else
 554         gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 555         gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
 556         len = 0;
 557         gtk_editable_insert_text( GTK_EDITABLE(m_text), value.mbc_str(), value.Length(), &len );
 558 #endif
 559     }
 560     else
 561     {
 562         gtk_entry_set_text( GTK_ENTRY(m_text), wxGTK_CONV( value ) );
 563     }
 564
 565     // GRG, Jun/2000: Changed this after a lot of discussion in
 566     //   the lists. wxWidgets 2.2 will have a set of flags to
 567     //   customize this behaviour.
 568     SetInsertionPoint(0);
 569
 570     m_modified = FALSE;
 571 }
 572
 573 void wxTextCtrl::WriteText( const wxString &text )
 574 {
 575     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 576
 577     if ( text.empty() )
 578         return;
 579
 580     if ( m_windowStyle & wxTE_MULTILINE )
 581     {
 582 #ifdef __WXGTK20__
 583
 584 #if wxUSE_UNICODE
 585         wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
 586 #else
 587         wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
 588 #endif
 589         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
 590
 591         // TODO: Call whatever is needed to delete the selection.
 592         wxGtkTextInsert( m_text, text_buffer, m_defaultStyle, buffer );
 593
 594         GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(m_widget) );
 595         // Scroll to cursor, but only if scrollbar thumb is at the very bottom
 596         if ( adj->value == adj->upper - adj->page_size )
 597         {
 598             gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text),
 599                     gtk_text_buffer_get_insert( text_buffer ), 0.0, FALSE, 0.0, 1.0 );
 600         }
 601 #else // GTK 1.x
 602         // After cursor movements, gtk_text_get_point() is wrong by one.
 603         gtk_text_set_point( GTK_TEXT(m_text), GET_EDITABLE_POS(m_text) );
 604
 605         // always use m_defaultStyle, even if it is empty as otherwise
 606         // resetting the style and appending some more text wouldn't work: if
 607         // we don't specify the style explicitly, the old style would be used
 608         gtk_editable_delete_selection( GTK_EDITABLE(m_text) );
 609         wxGtkTextInsert(m_text, m_defaultStyle, text.c_str(), text.Len());
 610
 611         // we called wxGtkTextInsert with correct font, no need to do anything
 612         // in UpdateFontIfNeeded() any longer
 613         if ( !text.empty() )
 614         {
 615             m_updateFont = FALSE;
 616         }
 617
 618         // Bring editable's cursor back uptodate.
 619         SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
 620 #endif // GTK 1.x/2.0
 621     }
 622     else // single line
 623     {
 624         // First remove the selection if there is one
 625         gtk_editable_delete_selection( GTK_EDITABLE(m_text) );
 626
 627         // This moves the cursor pos to behind the inserted text.
 628         gint len = GET_EDITABLE_POS(m_text);
 629
 630 #ifdef __WXGTK20__
 631
 632 #if wxUSE_UNICODE
 633         wxCharBuffer buffer( wxConvUTF8.cWX2MB( text ) );
 634 #else
 635         wxCharBuffer buffer( wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) ) );
 636 #endif
 637         gtk_editable_insert_text( GTK_EDITABLE(m_text), buffer, strlen(buffer), &len );
 638
 639 #else
 640         gtk_editable_insert_text( GTK_EDITABLE(m_text), text.c_str(), text.Len(), &len );
 641 #endif
 642
 643         // Bring entry's cursor uptodate.
 644         gtk_entry_set_position( GTK_ENTRY(m_text), len );
 645     }
 646
 647     m_modified = TRUE;
 648 }
 649
 650 void wxTextCtrl::AppendText( const wxString &text )
 651 {
 652     SetInsertionPointEnd();
 653     WriteText( text );
 654 }
 655
 656 wxString wxTextCtrl::GetLineText( long lineNo ) const
 657 {
 658     if (m_windowStyle & wxTE_MULTILINE)
 659     {
 660 #ifndef __WXGTK20__
 661         gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 662         char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
 663
 664         if (text)
 665         {
 666             wxString buf(wxT(""));
 667             long i;
 668             int currentLine = 0;
 669             for (i = 0; currentLine != lineNo && text[i]; i++ )
 670                 if (text[i] == '\n')
 671             currentLine++;
 672             // Now get the text
 673             int j;
 674             for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
 675                 buf += text[i];
 676
 677             g_free( text );
 678             return buf;
 679         }
 680         else
 681         {
 682             return wxEmptyString;
 683         }
 684 #else
 685         GtkTextBuffer *text_buffer;
 686         text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(m_text));
 687         GtkTextIter line;
 688         gtk_text_buffer_get_iter_at_line(text_buffer,&line,lineNo);
 689         GtkTextIter end;
 690         gtk_text_buffer_get_end_iter(text_buffer,&end );
 691         gchar *text = gtk_text_buffer_get_text(text_buffer,&line,&end,TRUE);
 692         wxString result(wxGTK_CONV_BACK(text));
 693         g_free(text);
 694         return result.BeforeFirst(wxT('\n'));
 695 #endif
 696     }
 697     else
 698     {
 699         if (lineNo == 0) return GetValue();
 700         return wxEmptyString;
 701     }
 702 }
 703
 704 void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
 705 {
 706   /* If you implement this, don't forget to update the documentation!
 707    * (file docs/latex/wx/text.tex) */
 708     wxFAIL_MSG( wxT("wxTextCtrl::OnDropFiles not implemented") );
 709 }
 710
 711 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
 712 {
 713     if ( m_windowStyle & wxTE_MULTILINE )
 714     {
 715         wxString text = GetValue();
 716
 717         // cast to prevent warning. But pos really should've been unsigned.
 718         if( (unsigned long)pos > text.Len()  )
 719             return FALSE;
 720
 721         *x=0;   // First Col
 722         *y=0;   // First Line
 723
 724         const wxChar* stop = text.c_str() + pos;
 725         for ( const wxChar *p = text.c_str(); p < stop; p++ )
 726         {
 727             if (*p == wxT('\n'))
 728             {
 729                 (*y)++;
 730                 *x=0;
 731             }
 732             else
 733                 (*x)++;
 734         }
 735     }
 736     else // single line control
 737     {
 738         if ( pos <= GTK_ENTRY(m_text)->text_length )
 739         {
 740             *y = 0;
 741             *x = pos;
 742         }
 743         else
 744         {
 745             // index out of bounds
 746             return FALSE;
 747         }
 748     }
 749
 750     return TRUE;
 751 }
 752
 753 long wxTextCtrl::XYToPosition(long x, long y ) const
 754 {
 755     if (!(m_windowStyle & wxTE_MULTILINE)) return 0;
 756
 757     long pos=0;
 758     for( int i=0; i<y; i++ ) pos += GetLineLength(i) + 1; // one for '\n'
 759
 760     pos += x;
 761     return pos;
 762 }
 763
 764 int wxTextCtrl::GetLineLength(long lineNo) const
 765 {
 766     wxString str = GetLineText (lineNo);
 767     return (int) str.Length();
 768 }
 769
 770 int wxTextCtrl::GetNumberOfLines() const
 771 {
 772     if (m_windowStyle & wxTE_MULTILINE)
 773     {
 774 #ifdef __WXGTK20__
 775         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
 776
 777         return gtk_text_buffer_get_line_count( buffer );
 778 #else
 779         gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 780         char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
 781
 782         if (text)
 783         {
 784             int currentLine = 0;
 785             for (int i = 0; i < len; i++ )
 786             {
 787                 if (text[i] == '\n')
 788                     currentLine++;
 789             }
 790             g_free( text );
 791
 792             // currentLine is 0 based, add 1 to get number of lines
 793             return currentLine + 1;
 794         }
 795         else
 796         {
 797             return 0;
 798         }
 799 #endif
 800     }
 801     else
 802     {
 803         return 1;
 804     }
 805 }
 806
 807 void wxTextCtrl::SetInsertionPoint( long pos )
 808 {
 809     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 810
 811     if (m_windowStyle & wxTE_MULTILINE)
 812     {
 813 #ifdef __WXGTK20__
 814         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
 815         GtkTextIter iter;
 816         gtk_text_buffer_get_iter_at_offset( text_buffer, &iter, pos );
 817         gtk_text_buffer_place_cursor( text_buffer, &iter );
 818 #else
 819         gtk_signal_disconnect_by_func( GTK_OBJECT(m_text),
 820           GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
 821
 822         /* we fake a set_point by inserting and deleting. as the user
 823            isn't supposed to get to know about this non-sense, we
 824            disconnect so that no events are sent to the user program. */
 825
 826         gint tmp = (gint)pos;
 827         gtk_editable_insert_text( GTK_EDITABLE(m_text), " ", 1, &tmp );
 828         gtk_editable_delete_text( GTK_EDITABLE(m_text), tmp-1, tmp );
 829
 830         gtk_signal_connect( GTK_OBJECT(m_text), "changed",
 831           GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
 832
 833         // bring editable's cursor uptodate. Bug in GTK.
 834         SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
 835 #endif
 836     }
 837     else
 838     {
 839         gtk_entry_set_position( GTK_ENTRY(m_text), (int)pos );
 840
 841         // Bring editable's cursor uptodate. Bug in GTK.
 842         SET_EDITABLE_POS(m_text, (guint32)pos);
 843     }
 844 }
 845
 846 void wxTextCtrl::SetInsertionPointEnd()
 847 {
 848     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 849
 850     if (m_windowStyle & wxTE_MULTILINE)
 851     {
 852 #ifdef __WXGTK20__
 853         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
 854         GtkTextIter end;
 855         gtk_text_buffer_get_end_iter( text_buffer, &end );
 856         gtk_text_buffer_place_cursor( text_buffer, &end );
 857 #else
 858         SetInsertionPoint(gtk_text_get_length(GTK_TEXT(m_text)));
 859 #endif
 860     }
 861     else
 862     {
 863         gtk_entry_set_position( GTK_ENTRY(m_text), -1 );
 864     }
 865 }
 866
 867 void wxTextCtrl::SetEditable( bool editable )
 868 {
 869     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 870
 871     if (m_windowStyle & wxTE_MULTILINE)
 872     {
 873 #ifdef __WXGTK20__
 874         gtk_text_view_set_editable( GTK_TEXT_VIEW(m_text), editable );
 875 #else
 876         gtk_text_set_editable( GTK_TEXT(m_text), editable );
 877 #endif
 878     }
 879     else
 880     {
 881         gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
 882     }
 883 }
 884
 885 bool wxTextCtrl::Enable( bool enable )
 886 {
 887     if (!wxWindowBase::Enable(enable))
 888     {
 889         // nothing to do
 890         return FALSE;
 891     }
 892
 893     if (m_windowStyle & wxTE_MULTILINE)
 894     {
 895 #ifdef __WXGTK20__
 896         SetEditable( enable );
 897 #else
 898         gtk_text_set_editable( GTK_TEXT(m_text), enable );
 899         OnParentEnable(enable);
 900 #endif
 901     }
 902     else
 903     {
 904         gtk_widget_set_sensitive( m_text, enable );
 905     }
 906
 907     return TRUE;
 908 }
 909
 910 // wxGTK-specific: called recursively by Enable,
 911 // to give widgets an oppprtunity to correct their colours after they
 912 // have been changed by Enable
 913 void wxTextCtrl::OnParentEnable( bool enable )
 914 {
 915     // If we have a custom background colour, we use this colour in both
 916     // disabled and enabled mode, or we end up with a different colour under the
 917     // text.
 918     wxColour oldColour = GetBackgroundColour();
 919     if (oldColour.Ok())
 920     {
 921         // Need to set twice or it'll optimize the useful stuff out
 922         if (oldColour == * wxWHITE)
 923             SetBackgroundColour(*wxBLACK);
 924         else
 925             SetBackgroundColour(*wxWHITE);
 926         SetBackgroundColour(oldColour);
 927     }
 928 }
 929
 930 void wxTextCtrl::MarkDirty()
 931 {
 932     m_modified = TRUE;
 933 }
 934
 935 void wxTextCtrl::DiscardEdits()
 936 {
 937     m_modified = FALSE;
 938 }
 939
 940 // ----------------------------------------------------------------------------
 941 // max text length support
 942 // ----------------------------------------------------------------------------
 943
 944 void wxTextCtrl::IgnoreNextTextUpdate()
 945 {
 946     m_ignoreNextUpdate = TRUE;
 947 }
 948
 949 bool wxTextCtrl::IgnoreTextUpdate()
 950 {
 951     if ( m_ignoreNextUpdate )
 952     {
 953         m_ignoreNextUpdate = FALSE;
 954
 955         return TRUE;
 956     }
 957
 958     return FALSE;
 959 }
 960
 961 void wxTextCtrl::SetMaxLength(unsigned long len)
 962 {
 963     if ( !HasFlag(wxTE_MULTILINE) )
 964     {
 965         gtk_entry_set_max_length(GTK_ENTRY(m_text), len);
 966
 967         // there is a bug in GTK+ 1.2.x: "changed" signal is emitted even if
 968         // we had tried to enter more text than allowed by max text length and
 969         // the text wasn't really changed
 970         //
 971         // to detect this and generate TEXT_MAXLEN event instead of
 972         // TEXT_CHANGED one in this case we also catch "insert_text" signal
 973         //
 974         // when max len is set to 0 we disconnect our handler as it means that
 975         // we shouldn't check anything any more
 976         if ( len )
 977         {
 978             gtk_signal_connect( GTK_OBJECT(m_text),
 979                                 "insert_text",
 980                                 GTK_SIGNAL_FUNC(gtk_insert_text_callback),
 981                                 (gpointer)this);
 982         }
 983         else // no checking
 984         {
 985             gtk_signal_disconnect_by_func
 986             (
 987                 GTK_OBJECT(m_text),
 988                 GTK_SIGNAL_FUNC(gtk_insert_text_callback),
 989                 (gpointer)this
 990             );
 991         }
 992     }
 993 }
 994
 995 void wxTextCtrl::SetSelection( long from, long to )
 996 {
 997     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
 998
 999     if (from == -1 && to == -1)
1000     {
1001         from = 0;
1002         to = GetValue().Length();
1003     }
1004
1005 #ifndef __WXGTK20__
1006     if ( (m_windowStyle & wxTE_MULTILINE) &&
1007          !GTK_TEXT(m_text)->line_start_cache )
1008     {
1009         // tell the programmer that it didn't work
1010         wxLogDebug(_T("Can't call SetSelection() before realizing the control"));
1011         return;
1012     }
1013 #endif
1014
1015     if (m_windowStyle & wxTE_MULTILINE)
1016     {
1017 #ifdef __WXGTK20__
1018         GtkTextBuffer *buf = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1019
1020         GtkTextIter fromi, toi;
1021         gtk_text_buffer_get_iter_at_offset( buf, &fromi, from );
1022         gtk_text_buffer_get_iter_at_offset( buf, &toi, to );
1023
1024         gtk_text_buffer_place_cursor( buf, &toi );
1025         gtk_text_buffer_move_mark_by_name( buf, "selection_bound", &fromi );
1026 #else
1027         gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1028 #endif
1029     }
1030     else
1031     {
1032         gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1033     }
1034 }
1035
1036 void wxTextCtrl::ShowPosition( long pos )
1037 {
1038     if (m_windowStyle & wxTE_MULTILINE)
1039     {
1040 #ifdef __WXGTK20__
1041         GtkTextBuffer *buf = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1042         GtkTextIter iter;
1043         gtk_text_buffer_get_start_iter( buf, &iter );
1044         gtk_text_iter_set_offset( &iter, pos );
1045         GtkTextMark *mark = gtk_text_buffer_create_mark( buf, NULL, &iter, TRUE );
1046         gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text), mark, 0.0, FALSE, 0.0, 0.0 );
1047 #else // GTK 1.x
1048         GtkAdjustment *vp = GTK_TEXT(m_text)->vadj;
1049         float totalLines =  (float) GetNumberOfLines();
1050         long posX;
1051         long posY;
1052         PositionToXY(pos, &posX, &posY);
1053         float posLine = (float) posY;
1054         float p = (posLine/totalLines)*(vp->upper - vp->lower) + vp->lower;
1055         gtk_adjustment_set_value(GTK_TEXT(m_text)->vadj, p);
1056 #endif // GTK 1.x/2.x
1057     }
1058 }
1059
1060 long wxTextCtrl::GetInsertionPoint() const
1061 {
1062     wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1063
1064 #ifdef __WXGTK20__
1065     if (m_windowStyle & wxTE_MULTILINE)
1066     {
1067         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1068
1069         // There is no direct accessor for the cursor, but
1070         // internally, the cursor is the "mark" called
1071         // "insert" in the text view's btree structure.
1072
1073         GtkTextMark *mark = gtk_text_buffer_get_insert( text_buffer );
1074         GtkTextIter cursor;
1075         gtk_text_buffer_get_iter_at_mark( text_buffer, &cursor, mark );
1076
1077         return gtk_text_iter_get_offset( &cursor );
1078     }
1079     else
1080 #endif
1081     {
1082     return (long) GET_EDITABLE_POS(m_text);
1083     }
1084 }
1085
1086 long wxTextCtrl::GetLastPosition() const
1087 {
1088     wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1089
1090     int pos = 0;
1091
1092     if (m_windowStyle & wxTE_MULTILINE)
1093     {
1094 #ifdef __WXGTK20__
1095         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1096         GtkTextIter end;
1097         gtk_text_buffer_get_end_iter( text_buffer, &end );
1098
1099         pos = gtk_text_iter_get_offset( &end );
1100 #else
1101         pos = gtk_text_get_length( GTK_TEXT(m_text) );
1102 #endif
1103     }
1104     else
1105     {
1106         pos = GTK_ENTRY(m_text)->text_length;
1107     }
1108
1109     return (long)pos;
1110 }
1111
1112 void wxTextCtrl::Remove( long from, long to )
1113 {
1114     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1115
1116 #ifdef __WXGTK20__
1117     if (m_windowStyle & wxTE_MULTILINE)
1118     {
1119         GtkTextBuffer *
1120             text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1121
1122         GtkTextIter fromi, toi;
1123         gtk_text_buffer_get_iter_at_offset( text_buffer, &fromi, from );
1124         gtk_text_buffer_get_iter_at_offset( text_buffer, &toi, to );
1125
1126         gtk_text_buffer_delete( text_buffer, &fromi, &toi );
1127     }
1128     else // single line
1129 #endif
1130     gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1131 }
1132
1133 void wxTextCtrl::Replace( long from, long to, const wxString &value )
1134 {
1135     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1136
1137     Remove( from, to );
1138
1139     if (!value.IsEmpty())
1140     {
1141 #ifdef __WXGTK20__
1142         SetInsertionPoint( from );
1143         WriteText( value );
1144 #else // GTK 1.x
1145         gint pos = (gint)from;
1146 #if wxUSE_UNICODE
1147         wxWX2MBbuf buf = value.mbc_str();
1148         gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &pos );
1149 #else
1150         gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
1151 #endif // wxUSE_UNICODE
1152 #endif // GTK 1.x/2.x
1153     }
1154 }
1155
1156 void wxTextCtrl::Cut()
1157 {
1158     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1159
1160 #ifndef __WXGTK20__
1161     gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1162 #endif
1163 }
1164
1165 void wxTextCtrl::Copy()
1166 {
1167     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1168
1169 #ifndef __WXGTK20__
1170     gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1171 #endif
1172 }
1173
1174 void wxTextCtrl::Paste()
1175 {
1176     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1177
1178 #ifndef __WXGTK20__
1179     gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG );
1180 #endif
1181 }
1182
1183 // Undo/redo
1184 void wxTextCtrl::Undo()
1185 {
1186     // TODO
1187     wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1188 }
1189
1190 void wxTextCtrl::Redo()
1191 {
1192     // TODO
1193     wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1194 }
1195
1196 bool wxTextCtrl::CanUndo() const
1197 {
1198     // TODO
1199     //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1200     return FALSE;
1201 }
1202
1203 bool wxTextCtrl::CanRedo() const
1204 {
1205     // TODO
1206     //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1207     return FALSE;
1208 }
1209
1210 // If the return values from and to are the same, there is no
1211 // selection.
1212 void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
1213 {
1214     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1215
1216     gint from = -1;
1217     gint to = -1;
1218     bool haveSelection = FALSE;
1219
1220 #ifdef __WXGTK20__
1221      if (m_windowStyle & wxTE_MULTILINE)
1222      {
1223          GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (m_text));
1224          GtkTextIter ifrom, ito;
1225          if ( gtk_text_buffer_get_selection_bounds(buffer, &ifrom, &ito) )
1226          {
1227              haveSelection = TRUE;
1228              from = gtk_text_iter_get_offset(&ifrom);
1229              to = gtk_text_iter_get_offset(&ito);
1230          }
1231      }
1232      else  // not multi-line
1233      {
1234          if ( gtk_editable_get_selection_bounds( GTK_EDITABLE(m_text),
1235                                                  &from, &to) )
1236          {
1237              haveSelection = TRUE;
1238          }
1239      }
1240 #else //  not GTK2
1241      if ( (GTK_EDITABLE(m_text)->has_selection) )
1242      {
1243          haveSelection = TRUE;
1244          from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
1245          to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
1246      }
1247 #endif
1248
1249      if (! haveSelection )
1250           from = to = GetInsertionPoint();
1251
1252      if ( from > to )
1253      {
1254          // exchange them to be compatible with wxMSW
1255          gint tmp = from;
1256          from = to;
1257          to = tmp;
1258      }
1259
1260     if ( fromOut )
1261         *fromOut = from;
1262     if ( toOut )
1263         *toOut = to;
1264 }
1265
1266
1267 bool wxTextCtrl::IsEditable() const
1268 {
1269     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1270
1271 #ifdef __WXGTK20__
1272     if (m_windowStyle & wxTE_MULTILINE)
1273     {
1274         return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text));
1275     }
1276     else
1277     {
1278         return gtk_editable_get_editable(GTK_EDITABLE(m_text));
1279     }
1280 #else
1281     return GTK_EDITABLE(m_text)->editable;
1282 #endif
1283 }
1284
1285 bool wxTextCtrl::IsModified() const
1286 {
1287     return m_modified;
1288 }
1289
1290 void wxTextCtrl::Clear()
1291 {
1292     SetValue( wxT("") );
1293 }
1294
1295 void wxTextCtrl::OnChar( wxKeyEvent &key_event )
1296 {
1297     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1298
1299     if ((key_event.GetKeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1300     {
1301         wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1302         event.SetEventObject(this);
1303         event.SetString(GetValue());
1304         if (GetEventHandler()->ProcessEvent(event)) return;
1305     }
1306
1307     if ((key_event.GetKeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1308     {
1309         // This will invoke the dialog default action, such
1310         // as the clicking the default button.
1311
1312         wxWindow *top_frame = m_parent;
1313         while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1314             top_frame = top_frame->GetParent();
1315
1316         if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1317         {
1318             GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1319
1320             if (window->default_widget)
1321             {
1322                 gtk_widget_activate (window->default_widget);
1323                 return;
1324             }
1325         }
1326     }
1327
1328     key_event.Skip();
1329 }
1330
1331 GtkWidget* wxTextCtrl::GetConnectWidget()
1332 {
1333     return GTK_WIDGET(m_text);
1334 }
1335
1336 bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1337 {
1338     if (m_windowStyle & wxTE_MULTILINE)
1339     {
1340 #ifdef __WXGTK20__
1341         return window == gtk_text_view_get_window( GTK_TEXT_VIEW( m_text ), GTK_TEXT_WINDOW_TEXT );  // pure guesswork
1342 #else
1343         return (window == GTK_TEXT(m_text)->text_area);
1344 #endif
1345     }
1346     else
1347     {
1348         return (window == GTK_ENTRY(m_text)->text_area);
1349     }
1350 }
1351
1352 // the font will change for subsequent text insertiongs
1353 bool wxTextCtrl::SetFont( const wxFont &font )
1354 {
1355     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1356
1357     if ( !wxTextCtrlBase::SetFont(font) )
1358     {
1359         // font didn't change, nothing to do
1360         return FALSE;
1361     }
1362
1363     if ( m_windowStyle & wxTE_MULTILINE )
1364     {
1365         m_updateFont = TRUE;
1366
1367         m_defaultStyle.SetFont(font);
1368
1369         ChangeFontGlobally();
1370     }
1371
1372     return TRUE;
1373 }
1374
1375 void wxTextCtrl::ChangeFontGlobally()
1376 {
1377     // this method is very inefficient and hence should be called as rarely as
1378     // possible!
1379     wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1380                   _T("shouldn't be called for single line controls") );
1381
1382     wxString value = GetValue();
1383     if ( !value.IsEmpty() )
1384     {
1385         m_updateFont = FALSE;
1386
1387         Clear();
1388         AppendText(value);
1389     }
1390 }
1391
1392 void wxTextCtrl::UpdateFontIfNeeded()
1393 {
1394     if ( m_updateFont )
1395         ChangeFontGlobally();
1396 }
1397
1398 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1399 {
1400     if ( !wxControl::SetForegroundColour(colour) )
1401         return FALSE;
1402
1403     // update default fg colour too
1404     m_defaultStyle.SetTextColour(colour);
1405
1406     return TRUE;
1407 }
1408
1409 bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1410 {
1411     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1412
1413     if ( !wxControl::SetBackgroundColour( colour ) )
1414         return FALSE;
1415
1416     if (!m_widget->window)
1417         return FALSE;
1418
1419     wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
1420     if (sysbg.Red() == colour.Red() &&
1421         sysbg.Green() == colour.Green() &&
1422         sysbg.Blue() == colour.Blue())
1423     {
1424         return FALSE; // FIXME or TRUE?
1425     }
1426
1427     if (!m_backgroundColour.Ok())
1428         return FALSE;
1429
1430     if (m_windowStyle & wxTE_MULTILINE)
1431     {
1432 #ifndef __WXGTK20__
1433         GdkWindow *window = GTK_TEXT(m_text)->text_area;
1434         if (!window)
1435             return FALSE;
1436         m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1437         gdk_window_set_background( window, m_backgroundColour.GetColor() );
1438         gdk_window_clear( window );
1439 #endif
1440     }
1441
1442     // change active background color too
1443     m_defaultStyle.SetBackgroundColour( colour );
1444
1445     return TRUE;
1446 }
1447
1448 bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
1449 {
1450     if ( m_windowStyle & wxTE_MULTILINE )
1451     {
1452         if ( style.IsDefault() )
1453         {
1454             // nothing to do
1455             return TRUE;
1456         }
1457 #ifdef __WXGTK20__
1458         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1459         gint l = gtk_text_buffer_get_char_count( text_buffer );
1460
1461         wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1462                      _T("invalid range in wxTextCtrl::SetStyle") );
1463
1464         GtkTextIter starti, endi;
1465         gtk_text_buffer_get_iter_at_offset( text_buffer, &starti, start );
1466         gtk_text_buffer_get_iter_at_offset( text_buffer, &endi, end );
1467
1468         // use the attributes from style which are set in it and fall back
1469         // first to the default style and then to the text control default
1470         // colours for the others
1471         wxTextAttr attr = wxTextAttr::Combine(style, m_defaultStyle, this);
1472
1473         PangoFontDescription *font_description = attr.HasFont()
1474                              ? attr.GetFont().GetNativeFontInfo()->description
1475                              : NULL;
1476
1477         GdkColor *colFg = attr.HasTextColour() ? attr.GetTextColour().GetColor()
1478                                                : NULL;
1479
1480         GdkColor *colBg = attr.HasBackgroundColour()
1481                             ? attr.GetBackgroundColour().GetColor()
1482                             : NULL;
1483
1484         GtkTextTag *tag;
1485         tag = gtk_text_buffer_create_tag( text_buffer, NULL, "font-desc", font_description,
1486                                          "foreground-gdk", colFg,
1487                                          "background-gdk", colBg, NULL );
1488         gtk_text_buffer_apply_tag( text_buffer, tag, &starti, &endi );
1489
1490          return TRUE;
1491 #else
1492         // VERY dirty way to do that - removes the required text and re-adds it
1493         // with styling (FIXME)
1494
1495         gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1496
1497         wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1498                      _T("invalid range in wxTextCtrl::SetStyle") );
1499
1500         gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1501         char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1502         wxString tmp(text,*wxConvCurrent);
1503         g_free( text );
1504
1505         gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1506         gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1507
1508 #if wxUSE_UNICODE
1509         wxWX2MBbuf buf = tmp.mbc_str();
1510         const char *txt = buf;
1511         size_t txtlen = strlen(buf);
1512 #else
1513         const char *txt = tmp;
1514         size_t txtlen = tmp.length();
1515 #endif
1516
1517         // use the attributes from style which are set in it and fall back
1518         // first to the default style and then to the text control default
1519         // colours for the others
1520         wxGtkTextInsert(m_text,
1521                         wxTextAttr::Combine(style, m_defaultStyle, this),
1522                         txt,
1523                         txtlen);
1524
1525         /* does not seem to help under GTK+ 1.2 !!!
1526         gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1527         SetInsertionPoint( old_pos );
1528 #endif
1529         return TRUE;
1530     }
1531     else // singe line
1532     {
1533         // cannot do this for GTK+'s Entry widget
1534         return FALSE;
1535     }
1536 }
1537
1538 void wxTextCtrl::ApplyWidgetStyle()
1539 {
1540     SetWidgetStyle();
1541     gtk_widget_set_style( m_text, m_widgetStyle );
1542 }
1543
1544 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1545 {
1546     Cut();
1547 }
1548
1549 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1550 {
1551     Copy();
1552 }
1553
1554 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1555 {
1556     Paste();
1557 }
1558
1559 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1560 {
1561     Undo();
1562 }
1563
1564 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1565 {
1566     Redo();
1567 }
1568
1569 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1570 {
1571     event.Enable( CanCut() );
1572 }
1573
1574 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1575 {
1576     event.Enable( CanCopy() );
1577 }
1578
1579 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1580 {
1581     event.Enable( CanPaste() );
1582 }
1583
1584 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1585 {
1586     event.Enable( CanUndo() );
1587 }
1588
1589 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1590 {
1591     event.Enable( CanRedo() );
1592 }
1593
1594 void wxTextCtrl::OnInternalIdle()
1595 {
1596     wxCursor cursor = m_cursor;
1597     if (g_globalCursor.Ok()) cursor = g_globalCursor;
1598
1599     if (cursor.Ok())
1600     {
1601 #ifndef __WXGTK20__
1602         GdkWindow *window = (GdkWindow*) NULL;
1603         if (HasFlag(wxTE_MULTILINE))
1604             window = GTK_TEXT(m_text)->text_area;
1605         else
1606             window = GTK_ENTRY(m_text)->text_area;
1607
1608         if (window)
1609             gdk_window_set_cursor( window, cursor.GetCursor() );
1610
1611         if (!g_globalCursor.Ok())
1612             cursor = *wxSTANDARD_CURSOR;
1613
1614         window = m_widget->window;
1615         if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
1616             gdk_window_set_cursor( window, cursor.GetCursor() );
1617 #endif
1618     }
1619
1620     if (g_delayedFocus == this)
1621     {
1622         if (GTK_WIDGET_REALIZED(m_widget))
1623         {
1624             gtk_widget_grab_focus( m_widget );
1625             g_delayedFocus = NULL;
1626         }
1627     }
1628
1629     if (wxUpdateUIEvent::CanUpdate(this))
1630         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1631 }
1632
1633 wxSize wxTextCtrl::DoGetBestSize() const
1634 {
1635     // FIXME should be different for multi-line controls...
1636     wxSize ret( wxControl::DoGetBestSize() );
1637     return wxSize(80, ret.y);
1638 }
1639
1640 // ----------------------------------------------------------------------------
1641 // freeze/thaw
1642 // ----------------------------------------------------------------------------
1643
1644 void wxTextCtrl::Freeze()
1645 {
1646 #ifndef __WXGTK20__
1647     if ( HasFlag(wxTE_MULTILINE) )
1648     {
1649         gtk_text_freeze(GTK_TEXT(m_text));
1650     }
1651 #endif
1652 }
1653
1654 void wxTextCtrl::Thaw()
1655 {
1656 #ifndef __WXGTK20__
1657     if ( HasFlag(wxTE_MULTILINE) )
1658     {
1659         GTK_TEXT(m_text)->vadj->value = 0.0;
1660
1661         gtk_text_thaw(GTK_TEXT(m_text));
1662     }
1663 #endif
1664 }
1665
1666 // ----------------------------------------------------------------------------
1667 // scrolling
1668 // ----------------------------------------------------------------------------
1669
1670 GtkAdjustment *wxTextCtrl::GetVAdj() const
1671 {
1672 #ifdef __WXGTK20__
1673     return NULL;
1674 #else
1675     return HasFlag(wxTE_MULTILINE) ? GTK_TEXT(m_text)->vadj : NULL;
1676 #endif
1677 }
1678
1679 bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff)
1680 {
1681 #ifndef __WXGTK20__
1682     float value = adj->value + diff;
1683
1684     if ( value < 0 )
1685         value = 0;
1686
1687     float upper = adj->upper - adj->page_size;
1688     if ( value > upper )
1689         value = upper;
1690
1691     // did we noticeably change the scroll position?
1692     if ( fabs(adj->value - value) < 0.2 )
1693     {
1694         // well, this is what Robert does in wxScrollBar, so it must be good...
1695         return FALSE;
1696     }
1697
1698     adj->value = value;
1699
1700     gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
1701
1702 #endif
1703     return TRUE;
1704 }
1705
1706 bool wxTextCtrl::ScrollLines(int lines)
1707 {
1708 #ifdef __WXGTK20__
1709     return FALSE;
1710 #else
1711     GtkAdjustment *adj = GetVAdj();
1712     if ( !adj )
1713         return FALSE;
1714
1715     // this is hardcoded to 10 in GTK+ 1.2 (great idea)
1716     static const int KEY_SCROLL_PIXELS = 10;
1717
1718     return DoScroll(adj, lines*KEY_SCROLL_PIXELS);
1719 #endif
1720 }
1721
1722 bool wxTextCtrl::ScrollPages(int pages)
1723 {
1724 #ifdef __WXGTK20__
1725     return FALSE;
1726 #else
1727     GtkAdjustment *adj = GetVAdj();
1728     if ( !adj )
1729         return FALSE;
1730
1731     return DoScroll(adj, (int)ceil(pages*adj->page_increment));
1732 #endif
1733 }
1734
1735
1736 // static
1737 wxVisualAttributes
1738 wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1739 {
1740     return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true);
1741 }