src/gtk1/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 #ifdef __WXGTK20__
1161     if (m_windowStyle & wxTE_MULTILINE)
1162         g_signal_emit_by_name(m_text, "cut-clipboard");
1163     else
1164 #endif
1165         gtk_editable_cut_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1166 }
1167
1168 void wxTextCtrl::Copy()
1169 {
1170     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1171
1172 #ifdef __WXGTK20__
1173     if (m_windowStyle & wxTE_MULTILINE)
1174         g_signal_emit_by_name(m_text, "copy-clipboard");
1175     else
1176 #endif
1177         gtk_editable_copy_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1178 }
1179
1180 void wxTextCtrl::Paste()
1181 {
1182     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1183
1184 #ifdef __WXGTK20__
1185     if (m_windowStyle & wxTE_MULTILINE)
1186         g_signal_emit_by_name(m_text, "paste-clipboard");
1187     else
1188 #endif
1189         gtk_editable_paste_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1190 }
1191
1192 // Undo/redo
1193 void wxTextCtrl::Undo()
1194 {
1195     // TODO
1196     wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1197 }
1198
1199 void wxTextCtrl::Redo()
1200 {
1201     // TODO
1202     wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1203 }
1204
1205 bool wxTextCtrl::CanUndo() const
1206 {
1207     // TODO
1208     //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1209     return FALSE;
1210 }
1211
1212 bool wxTextCtrl::CanRedo() const
1213 {
1214     // TODO
1215     //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1216     return FALSE;
1217 }
1218
1219 // If the return values from and to are the same, there is no
1220 // selection.
1221 void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
1222 {
1223     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1224
1225     gint from = -1;
1226     gint to = -1;
1227     bool haveSelection = FALSE;
1228
1229 #ifdef __WXGTK20__
1230      if (m_windowStyle & wxTE_MULTILINE)
1231      {
1232          GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (m_text));
1233          GtkTextIter ifrom, ito;
1234          if ( gtk_text_buffer_get_selection_bounds(buffer, &ifrom, &ito) )
1235          {
1236              haveSelection = TRUE;
1237              from = gtk_text_iter_get_offset(&ifrom);
1238              to = gtk_text_iter_get_offset(&ito);
1239          }
1240      }
1241      else  // not multi-line
1242      {
1243          if ( gtk_editable_get_selection_bounds( GTK_EDITABLE(m_text),
1244                                                  &from, &to) )
1245          {
1246              haveSelection = TRUE;
1247          }
1248      }
1249 #else //  not GTK2
1250      if ( (GTK_EDITABLE(m_text)->has_selection) )
1251      {
1252          haveSelection = TRUE;
1253          from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
1254          to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
1255      }
1256 #endif
1257
1258      if (! haveSelection )
1259           from = to = GetInsertionPoint();
1260
1261      if ( from > to )
1262      {
1263          // exchange them to be compatible with wxMSW
1264          gint tmp = from;
1265          from = to;
1266          to = tmp;
1267      }
1268
1269     if ( fromOut )
1270         *fromOut = from;
1271     if ( toOut )
1272         *toOut = to;
1273 }
1274
1275
1276 bool wxTextCtrl::IsEditable() const
1277 {
1278     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1279
1280 #ifdef __WXGTK20__
1281     if (m_windowStyle & wxTE_MULTILINE)
1282     {
1283         return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text));
1284     }
1285     else
1286     {
1287         return gtk_editable_get_editable(GTK_EDITABLE(m_text));
1288     }
1289 #else
1290     return GTK_EDITABLE(m_text)->editable;
1291 #endif
1292 }
1293
1294 bool wxTextCtrl::IsModified() const
1295 {
1296     return m_modified;
1297 }
1298
1299 void wxTextCtrl::Clear()
1300 {
1301     SetValue( wxT("") );
1302 }
1303
1304 void wxTextCtrl::OnChar( wxKeyEvent &key_event )
1305 {
1306     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1307
1308     if ((key_event.GetKeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1309     {
1310         wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1311         event.SetEventObject(this);
1312         event.SetString(GetValue());
1313         if (GetEventHandler()->ProcessEvent(event)) return;
1314     }
1315
1316     if ((key_event.GetKeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1317     {
1318         // This will invoke the dialog default action, such
1319         // as the clicking the default button.
1320
1321         wxWindow *top_frame = m_parent;
1322         while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1323             top_frame = top_frame->GetParent();
1324
1325         if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1326         {
1327             GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1328
1329             if (window->default_widget)
1330             {
1331                 gtk_widget_activate (window->default_widget);
1332                 return;
1333             }
1334         }
1335     }
1336
1337     key_event.Skip();
1338 }
1339
1340 GtkWidget* wxTextCtrl::GetConnectWidget()
1341 {
1342     return GTK_WIDGET(m_text);
1343 }
1344
1345 bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1346 {
1347     if (m_windowStyle & wxTE_MULTILINE)
1348     {
1349 #ifdef __WXGTK20__
1350         return window == gtk_text_view_get_window( GTK_TEXT_VIEW( m_text ), GTK_TEXT_WINDOW_TEXT );  // pure guesswork
1351 #else
1352         return (window == GTK_TEXT(m_text)->text_area);
1353 #endif
1354     }
1355     else
1356     {
1357         return (window == GTK_ENTRY(m_text)->text_area);
1358     }
1359 }
1360
1361 // the font will change for subsequent text insertiongs
1362 bool wxTextCtrl::SetFont( const wxFont &font )
1363 {
1364     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1365
1366     if ( !wxTextCtrlBase::SetFont(font) )
1367     {
1368         // font didn't change, nothing to do
1369         return FALSE;
1370     }
1371
1372     if ( m_windowStyle & wxTE_MULTILINE )
1373     {
1374         m_updateFont = TRUE;
1375
1376         m_defaultStyle.SetFont(font);
1377
1378         ChangeFontGlobally();
1379     }
1380
1381     return TRUE;
1382 }
1383
1384 void wxTextCtrl::ChangeFontGlobally()
1385 {
1386     // this method is very inefficient and hence should be called as rarely as
1387     // possible!
1388     wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1389                   _T("shouldn't be called for single line controls") );
1390
1391     wxString value = GetValue();
1392     if ( !value.IsEmpty() )
1393     {
1394         m_updateFont = FALSE;
1395
1396         Clear();
1397         AppendText(value);
1398     }
1399 }
1400
1401 void wxTextCtrl::UpdateFontIfNeeded()
1402 {
1403     if ( m_updateFont )
1404         ChangeFontGlobally();
1405 }
1406
1407 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1408 {
1409     if ( !wxControl::SetForegroundColour(colour) )
1410         return FALSE;
1411
1412     // update default fg colour too
1413     m_defaultStyle.SetTextColour(colour);
1414
1415     return TRUE;
1416 }
1417
1418 bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1419 {
1420     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1421
1422     if ( !wxControl::SetBackgroundColour( colour ) )
1423         return FALSE;
1424
1425     if (!m_widget->window)
1426         return FALSE;
1427
1428     if (!m_backgroundColour.Ok())
1429         return FALSE;
1430
1431     if (m_windowStyle & wxTE_MULTILINE)
1432     {
1433 #ifndef __WXGTK20__
1434         GdkWindow *window = GTK_TEXT(m_text)->text_area;
1435         if (!window)
1436             return FALSE;
1437         m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1438         gdk_window_set_background( window, m_backgroundColour.GetColor() );
1439         gdk_window_clear( window );
1440 #endif
1441     }
1442
1443     // change active background color too
1444     m_defaultStyle.SetBackgroundColour( colour );
1445
1446     return TRUE;
1447 }
1448
1449 bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
1450 {
1451     if ( m_windowStyle & wxTE_MULTILINE )
1452     {
1453         if ( style.IsDefault() )
1454         {
1455             // nothing to do
1456             return TRUE;
1457         }
1458 #ifdef __WXGTK20__
1459         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1460         gint l = gtk_text_buffer_get_char_count( text_buffer );
1461
1462         wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1463                      _T("invalid range in wxTextCtrl::SetStyle") );
1464
1465         GtkTextIter starti, endi;
1466         gtk_text_buffer_get_iter_at_offset( text_buffer, &starti, start );
1467         gtk_text_buffer_get_iter_at_offset( text_buffer, &endi, end );
1468
1469         // use the attributes from style which are set in it and fall back
1470         // first to the default style and then to the text control default
1471         // colours for the others
1472         wxTextAttr attr = wxTextAttr::Combine(style, m_defaultStyle, this);
1473
1474         PangoFontDescription *font_description = attr.HasFont()
1475                              ? attr.GetFont().GetNativeFontInfo()->description
1476                              : NULL;
1477
1478         GdkColor *colFg = attr.HasTextColour() ? attr.GetTextColour().GetColor()
1479                                                : NULL;
1480
1481         GdkColor *colBg = attr.HasBackgroundColour()
1482                             ? attr.GetBackgroundColour().GetColor()
1483                             : NULL;
1484
1485         GtkTextTag *tag;
1486         tag = gtk_text_buffer_create_tag( text_buffer, NULL, "font-desc", font_description,
1487                                          "foreground-gdk", colFg,
1488                                          "background-gdk", colBg, NULL );
1489         gtk_text_buffer_apply_tag( text_buffer, tag, &starti, &endi );
1490
1491          return TRUE;
1492 #else
1493         // VERY dirty way to do that - removes the required text and re-adds it
1494         // with styling (FIXME)
1495
1496         gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1497
1498         wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1499                      _T("invalid range in wxTextCtrl::SetStyle") );
1500
1501         gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1502         char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1503         wxString tmp(text,*wxConvCurrent);
1504         g_free( text );
1505
1506         gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1507         gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1508
1509 #if wxUSE_UNICODE
1510         wxWX2MBbuf buf = tmp.mbc_str();
1511         const char *txt = buf;
1512         size_t txtlen = strlen(buf);
1513 #else
1514         const char *txt = tmp;
1515         size_t txtlen = tmp.length();
1516 #endif
1517
1518         // use the attributes from style which are set in it and fall back
1519         // first to the default style and then to the text control default
1520         // colours for the others
1521         wxGtkTextInsert(m_text,
1522                         wxTextAttr::Combine(style, m_defaultStyle, this),
1523                         txt,
1524                         txtlen);
1525
1526         /* does not seem to help under GTK+ 1.2 !!!
1527         gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1528         SetInsertionPoint( old_pos );
1529 #endif
1530         return TRUE;
1531     }
1532     else // singe line
1533     {
1534         // cannot do this for GTK+'s Entry widget
1535         return FALSE;
1536     }
1537 }
1538
1539 void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
1540 {
1541     gtk_widget_modify_style(m_text, style);
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     wxSize best(80, ret.y);
1638     CacheBestSize(best);
1639     return best;
1640 }
1641
1642 // ----------------------------------------------------------------------------
1643 // freeze/thaw
1644 // ----------------------------------------------------------------------------
1645
1646 void wxTextCtrl::Freeze()
1647 {
1648 #ifndef __WXGTK20__
1649     if ( HasFlag(wxTE_MULTILINE) )
1650     {
1651         gtk_text_freeze(GTK_TEXT(m_text));
1652     }
1653 #endif
1654 }
1655
1656 void wxTextCtrl::Thaw()
1657 {
1658 #ifndef __WXGTK20__
1659     if ( HasFlag(wxTE_MULTILINE) )
1660     {
1661         GTK_TEXT(m_text)->vadj->value = 0.0;
1662
1663         gtk_text_thaw(GTK_TEXT(m_text));
1664     }
1665 #endif
1666 }
1667
1668 // ----------------------------------------------------------------------------
1669 // scrolling
1670 // ----------------------------------------------------------------------------
1671
1672 GtkAdjustment *wxTextCtrl::GetVAdj() const
1673 {
1674 #ifdef __WXGTK20__
1675     return NULL;
1676 #else
1677     return HasFlag(wxTE_MULTILINE) ? GTK_TEXT(m_text)->vadj : NULL;
1678 #endif
1679 }
1680
1681 bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff)
1682 {
1683 #ifndef __WXGTK20__
1684     float value = adj->value + diff;
1685
1686     if ( value < 0 )
1687         value = 0;
1688
1689     float upper = adj->upper - adj->page_size;
1690     if ( value > upper )
1691         value = upper;
1692
1693     // did we noticeably change the scroll position?
1694     if ( fabs(adj->value - value) < 0.2 )
1695     {
1696         // well, this is what Robert does in wxScrollBar, so it must be good...
1697         return FALSE;
1698     }
1699
1700     adj->value = value;
1701
1702     gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
1703
1704 #endif
1705     return TRUE;
1706 }
1707
1708 bool wxTextCtrl::ScrollLines(int lines)
1709 {
1710 #ifdef __WXGTK20__
1711     return FALSE;
1712 #else
1713     GtkAdjustment *adj = GetVAdj();
1714     if ( !adj )
1715         return FALSE;
1716
1717     // this is hardcoded to 10 in GTK+ 1.2 (great idea)
1718     static const int KEY_SCROLL_PIXELS = 10;
1719
1720     return DoScroll(adj, lines*KEY_SCROLL_PIXELS);
1721 #endif
1722 }
1723
1724 bool wxTextCtrl::ScrollPages(int pages)
1725 {
1726 #ifdef __WXGTK20__
1727     return FALSE;
1728 #else
1729     GtkAdjustment *adj = GetVAdj();
1730     if ( !adj )
1731         return FALSE;
1732
1733     return DoScroll(adj, (int)ceil(pages*adj->page_increment));
1734 #endif
1735 }
1736
1737
1738 // static
1739 wxVisualAttributes
1740 wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1741 {
1742     return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true);
1743 }