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 #ifdef __WXGTK20__
1061
1062 wxTextCtrlHitTestResult
1063 wxTextCtrl::HitTest(const wxPoint& pt, long *pos) const
1064 {
1065     if ( !IsMultiLine() )
1066     {
1067         // not supported
1068         return wxTE_HT_UNKNOWN;
1069     }
1070
1071     int x, y;
1072     gtk_text_view_window_to_buffer_coords
1073     (
1074         GTK_TEXT_VIEW(m_text),
1075         GTK_TEXT_WINDOW_TEXT,
1076         pt.x, pt.y,
1077         &x, &y
1078     );
1079
1080     GtkTextIter iter;
1081     gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(m_text), &iter, x, y);
1082     if ( pos )
1083         *pos = gtk_text_iter_get_offset(&iter);
1084
1085     return wxTE_HT_ON_TEXT;
1086 }
1087
1088 #endif // __WXGTK20__
1089
1090 long wxTextCtrl::GetInsertionPoint() const
1091 {
1092     wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1093
1094 #ifdef __WXGTK20__
1095     if (m_windowStyle & wxTE_MULTILINE)
1096     {
1097         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1098
1099         // There is no direct accessor for the cursor, but
1100         // internally, the cursor is the "mark" called
1101         // "insert" in the text view's btree structure.
1102
1103         GtkTextMark *mark = gtk_text_buffer_get_insert( text_buffer );
1104         GtkTextIter cursor;
1105         gtk_text_buffer_get_iter_at_mark( text_buffer, &cursor, mark );
1106
1107         return gtk_text_iter_get_offset( &cursor );
1108     }
1109     else
1110 #endif
1111     {
1112     return (long) GET_EDITABLE_POS(m_text);
1113     }
1114 }
1115
1116 long wxTextCtrl::GetLastPosition() const
1117 {
1118     wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") );
1119
1120     int pos = 0;
1121
1122     if (m_windowStyle & wxTE_MULTILINE)
1123     {
1124 #ifdef __WXGTK20__
1125         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1126         GtkTextIter end;
1127         gtk_text_buffer_get_end_iter( text_buffer, &end );
1128
1129         pos = gtk_text_iter_get_offset( &end );
1130 #else
1131         pos = gtk_text_get_length( GTK_TEXT(m_text) );
1132 #endif
1133     }
1134     else
1135     {
1136         pos = GTK_ENTRY(m_text)->text_length;
1137     }
1138
1139     return (long)pos;
1140 }
1141
1142 void wxTextCtrl::Remove( long from, long to )
1143 {
1144     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1145
1146 #ifdef __WXGTK20__
1147     if (m_windowStyle & wxTE_MULTILINE)
1148     {
1149         GtkTextBuffer *
1150             text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1151
1152         GtkTextIter fromi, toi;
1153         gtk_text_buffer_get_iter_at_offset( text_buffer, &fromi, from );
1154         gtk_text_buffer_get_iter_at_offset( text_buffer, &toi, to );
1155
1156         gtk_text_buffer_delete( text_buffer, &fromi, &toi );
1157     }
1158     else // single line
1159 #endif
1160     gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
1161 }
1162
1163 void wxTextCtrl::Replace( long from, long to, const wxString &value )
1164 {
1165     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1166
1167     Remove( from, to );
1168
1169     if (!value.IsEmpty())
1170     {
1171 #ifdef __WXGTK20__
1172         SetInsertionPoint( from );
1173         WriteText( value );
1174 #else // GTK 1.x
1175         gint pos = (gint)from;
1176 #if wxUSE_UNICODE
1177         wxWX2MBbuf buf = value.mbc_str();
1178         gtk_editable_insert_text( GTK_EDITABLE(m_text), buf, strlen(buf), &pos );
1179 #else
1180         gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
1181 #endif // wxUSE_UNICODE
1182 #endif // GTK 1.x/2.x
1183     }
1184 }
1185
1186 void wxTextCtrl::Cut()
1187 {
1188     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1189
1190 #ifdef __WXGTK20__
1191     if (m_windowStyle & wxTE_MULTILINE)
1192         g_signal_emit_by_name(m_text, "cut-clipboard");
1193     else
1194 #endif
1195         gtk_editable_cut_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1196 }
1197
1198 void wxTextCtrl::Copy()
1199 {
1200     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1201
1202 #ifdef __WXGTK20__
1203     if (m_windowStyle & wxTE_MULTILINE)
1204         g_signal_emit_by_name(m_text, "copy-clipboard");
1205     else
1206 #endif
1207         gtk_editable_copy_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1208 }
1209
1210 void wxTextCtrl::Paste()
1211 {
1212     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1213
1214 #ifdef __WXGTK20__
1215     if (m_windowStyle & wxTE_MULTILINE)
1216         g_signal_emit_by_name(m_text, "paste-clipboard");
1217     else
1218 #endif
1219         gtk_editable_paste_clipboard(GTK_EDITABLE(m_text) DUMMY_CLIPBOARD_ARG);
1220 }
1221
1222 // Undo/redo
1223 void wxTextCtrl::Undo()
1224 {
1225     // TODO
1226     wxFAIL_MSG( wxT("wxTextCtrl::Undo not implemented") );
1227 }
1228
1229 void wxTextCtrl::Redo()
1230 {
1231     // TODO
1232     wxFAIL_MSG( wxT("wxTextCtrl::Redo not implemented") );
1233 }
1234
1235 bool wxTextCtrl::CanUndo() const
1236 {
1237     // TODO
1238     //wxFAIL_MSG( wxT("wxTextCtrl::CanUndo not implemented") );
1239     return FALSE;
1240 }
1241
1242 bool wxTextCtrl::CanRedo() const
1243 {
1244     // TODO
1245     //wxFAIL_MSG( wxT("wxTextCtrl::CanRedo not implemented") );
1246     return FALSE;
1247 }
1248
1249 // If the return values from and to are the same, there is no
1250 // selection.
1251 void wxTextCtrl::GetSelection(long* fromOut, long* toOut) const
1252 {
1253     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1254
1255     gint from = -1;
1256     gint to = -1;
1257     bool haveSelection = FALSE;
1258
1259 #ifdef __WXGTK20__
1260      if (m_windowStyle & wxTE_MULTILINE)
1261      {
1262          GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (m_text));
1263          GtkTextIter ifrom, ito;
1264          if ( gtk_text_buffer_get_selection_bounds(buffer, &ifrom, &ito) )
1265          {
1266              haveSelection = TRUE;
1267              from = gtk_text_iter_get_offset(&ifrom);
1268              to = gtk_text_iter_get_offset(&ito);
1269          }
1270      }
1271      else  // not multi-line
1272      {
1273          if ( gtk_editable_get_selection_bounds( GTK_EDITABLE(m_text),
1274                                                  &from, &to) )
1275          {
1276              haveSelection = TRUE;
1277          }
1278      }
1279 #else //  not GTK2
1280      if ( (GTK_EDITABLE(m_text)->has_selection) )
1281      {
1282          haveSelection = TRUE;
1283          from = (long) GTK_EDITABLE(m_text)->selection_start_pos;
1284          to = (long) GTK_EDITABLE(m_text)->selection_end_pos;
1285      }
1286 #endif
1287
1288      if (! haveSelection )
1289           from = to = GetInsertionPoint();
1290
1291      if ( from > to )
1292      {
1293          // exchange them to be compatible with wxMSW
1294          gint tmp = from;
1295          from = to;
1296          to = tmp;
1297      }
1298
1299     if ( fromOut )
1300         *fromOut = from;
1301     if ( toOut )
1302         *toOut = to;
1303 }
1304
1305
1306 bool wxTextCtrl::IsEditable() const
1307 {
1308     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1309
1310 #ifdef __WXGTK20__
1311     if (m_windowStyle & wxTE_MULTILINE)
1312     {
1313         return gtk_text_view_get_editable(GTK_TEXT_VIEW(m_text));
1314     }
1315     else
1316     {
1317         return gtk_editable_get_editable(GTK_EDITABLE(m_text));
1318     }
1319 #else
1320     return GTK_EDITABLE(m_text)->editable;
1321 #endif
1322 }
1323
1324 bool wxTextCtrl::IsModified() const
1325 {
1326     return m_modified;
1327 }
1328
1329 void wxTextCtrl::Clear()
1330 {
1331     SetValue( wxT("") );
1332 }
1333
1334 void wxTextCtrl::OnChar( wxKeyEvent &key_event )
1335 {
1336     wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
1337
1338     if ((key_event.GetKeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
1339     {
1340         wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1341         event.SetEventObject(this);
1342         event.SetString(GetValue());
1343         if (GetEventHandler()->ProcessEvent(event)) return;
1344     }
1345
1346     if ((key_event.GetKeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
1347     {
1348         // This will invoke the dialog default action, such
1349         // as the clicking the default button.
1350
1351         wxWindow *top_frame = m_parent;
1352         while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
1353             top_frame = top_frame->GetParent();
1354
1355         if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
1356         {
1357             GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
1358
1359             if (window->default_widget)
1360             {
1361                 gtk_widget_activate (window->default_widget);
1362                 return;
1363             }
1364         }
1365     }
1366
1367     key_event.Skip();
1368 }
1369
1370 GtkWidget* wxTextCtrl::GetConnectWidget()
1371 {
1372     return GTK_WIDGET(m_text);
1373 }
1374
1375 bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
1376 {
1377     if (m_windowStyle & wxTE_MULTILINE)
1378     {
1379 #ifdef __WXGTK20__
1380         return window == gtk_text_view_get_window( GTK_TEXT_VIEW( m_text ), GTK_TEXT_WINDOW_TEXT );  // pure guesswork
1381 #else
1382         return (window == GTK_TEXT(m_text)->text_area);
1383 #endif
1384     }
1385     else
1386     {
1387         return (window == GTK_ENTRY(m_text)->text_area);
1388     }
1389 }
1390
1391 // the font will change for subsequent text insertiongs
1392 bool wxTextCtrl::SetFont( const wxFont &font )
1393 {
1394     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1395
1396     if ( !wxTextCtrlBase::SetFont(font) )
1397     {
1398         // font didn't change, nothing to do
1399         return FALSE;
1400     }
1401
1402     if ( m_windowStyle & wxTE_MULTILINE )
1403     {
1404         m_updateFont = TRUE;
1405
1406         m_defaultStyle.SetFont(font);
1407
1408         ChangeFontGlobally();
1409     }
1410
1411     return TRUE;
1412 }
1413
1414 void wxTextCtrl::ChangeFontGlobally()
1415 {
1416     // this method is very inefficient and hence should be called as rarely as
1417     // possible!
1418     wxASSERT_MSG( (m_windowStyle & wxTE_MULTILINE) && m_updateFont,
1419                   _T("shouldn't be called for single line controls") );
1420
1421     wxString value = GetValue();
1422     if ( !value.IsEmpty() )
1423     {
1424         m_updateFont = FALSE;
1425
1426         Clear();
1427         AppendText(value);
1428     }
1429 }
1430
1431 void wxTextCtrl::UpdateFontIfNeeded()
1432 {
1433     if ( m_updateFont )
1434         ChangeFontGlobally();
1435 }
1436
1437 bool wxTextCtrl::SetForegroundColour(const wxColour& colour)
1438 {
1439     if ( !wxControl::SetForegroundColour(colour) )
1440         return FALSE;
1441
1442     // update default fg colour too
1443     m_defaultStyle.SetTextColour(colour);
1444
1445     return TRUE;
1446 }
1447
1448 bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
1449 {
1450     wxCHECK_MSG( m_text != NULL, FALSE, wxT("invalid text ctrl") );
1451
1452     if ( !wxControl::SetBackgroundColour( colour ) )
1453         return FALSE;
1454
1455     if (!m_widget->window)
1456         return FALSE;
1457
1458     if (!m_backgroundColour.Ok())
1459         return FALSE;
1460
1461     if (m_windowStyle & wxTE_MULTILINE)
1462     {
1463 #ifndef __WXGTK20__
1464         GdkWindow *window = GTK_TEXT(m_text)->text_area;
1465         if (!window)
1466             return FALSE;
1467         m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
1468         gdk_window_set_background( window, m_backgroundColour.GetColor() );
1469         gdk_window_clear( window );
1470 #endif
1471     }
1472
1473     // change active background color too
1474     m_defaultStyle.SetBackgroundColour( colour );
1475
1476     return TRUE;
1477 }
1478
1479 bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
1480 {
1481     if ( m_windowStyle & wxTE_MULTILINE )
1482     {
1483         if ( style.IsDefault() )
1484         {
1485             // nothing to do
1486             return TRUE;
1487         }
1488 #ifdef __WXGTK20__
1489         GtkTextBuffer *text_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) );
1490         gint l = gtk_text_buffer_get_char_count( text_buffer );
1491
1492         wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1493                      _T("invalid range in wxTextCtrl::SetStyle") );
1494
1495         GtkTextIter starti, endi;
1496         gtk_text_buffer_get_iter_at_offset( text_buffer, &starti, start );
1497         gtk_text_buffer_get_iter_at_offset( text_buffer, &endi, end );
1498
1499         // use the attributes from style which are set in it and fall back
1500         // first to the default style and then to the text control default
1501         // colours for the others
1502         wxTextAttr attr = wxTextAttr::Combine(style, m_defaultStyle, this);
1503
1504         PangoFontDescription *font_description = attr.HasFont()
1505                              ? attr.GetFont().GetNativeFontInfo()->description
1506                              : NULL;
1507
1508         GdkColor *colFg = attr.HasTextColour() ? attr.GetTextColour().GetColor()
1509                                                : NULL;
1510
1511         GdkColor *colBg = attr.HasBackgroundColour()
1512                             ? attr.GetBackgroundColour().GetColor()
1513                             : NULL;
1514
1515         GtkTextTag *tag;
1516         tag = gtk_text_buffer_create_tag( text_buffer, NULL, "font-desc", font_description,
1517                                          "foreground-gdk", colFg,
1518                                          "background-gdk", colBg, NULL );
1519         gtk_text_buffer_apply_tag( text_buffer, tag, &starti, &endi );
1520
1521          return TRUE;
1522 #else
1523         // VERY dirty way to do that - removes the required text and re-adds it
1524         // with styling (FIXME)
1525
1526         gint l = gtk_text_get_length( GTK_TEXT(m_text) );
1527
1528         wxCHECK_MSG( start >= 0 && end <= l, FALSE,
1529                      _T("invalid range in wxTextCtrl::SetStyle") );
1530
1531         gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
1532         char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
1533         wxString tmp(text,*wxConvCurrent);
1534         g_free( text );
1535
1536         gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
1537         gtk_editable_set_position( GTK_EDITABLE(m_text), start );
1538
1539 #if wxUSE_UNICODE
1540         wxWX2MBbuf buf = tmp.mbc_str();
1541         const char *txt = buf;
1542         size_t txtlen = strlen(buf);
1543 #else
1544         const char *txt = tmp;
1545         size_t txtlen = tmp.length();
1546 #endif
1547
1548         // use the attributes from style which are set in it and fall back
1549         // first to the default style and then to the text control default
1550         // colours for the others
1551         wxGtkTextInsert(m_text,
1552                         wxTextAttr::Combine(style, m_defaultStyle, this),
1553                         txt,
1554                         txtlen);
1555
1556         /* does not seem to help under GTK+ 1.2 !!!
1557         gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
1558         SetInsertionPoint( old_pos );
1559 #endif
1560         return TRUE;
1561     }
1562     else // singe line
1563     {
1564         // cannot do this for GTK+'s Entry widget
1565         return FALSE;
1566     }
1567 }
1568
1569 void wxTextCtrl::DoApplyWidgetStyle(GtkRcStyle *style)
1570 {
1571     gtk_widget_modify_style(m_text, style);
1572 }
1573
1574 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1575 {
1576     Cut();
1577 }
1578
1579 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1580 {
1581     Copy();
1582 }
1583
1584 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1585 {
1586     Paste();
1587 }
1588
1589 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1590 {
1591     Undo();
1592 }
1593
1594 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1595 {
1596     Redo();
1597 }
1598
1599 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1600 {
1601     event.Enable( CanCut() );
1602 }
1603
1604 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1605 {
1606     event.Enable( CanCopy() );
1607 }
1608
1609 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1610 {
1611     event.Enable( CanPaste() );
1612 }
1613
1614 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1615 {
1616     event.Enable( CanUndo() );
1617 }
1618
1619 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1620 {
1621     event.Enable( CanRedo() );
1622 }
1623
1624 void wxTextCtrl::OnInternalIdle()
1625 {
1626     wxCursor cursor = m_cursor;
1627     if (g_globalCursor.Ok()) cursor = g_globalCursor;
1628
1629     if (cursor.Ok())
1630     {
1631 #ifndef __WXGTK20__
1632         GdkWindow *window = (GdkWindow*) NULL;
1633         if (HasFlag(wxTE_MULTILINE))
1634             window = GTK_TEXT(m_text)->text_area;
1635         else
1636             window = GTK_ENTRY(m_text)->text_area;
1637
1638         if (window)
1639             gdk_window_set_cursor( window, cursor.GetCursor() );
1640
1641         if (!g_globalCursor.Ok())
1642             cursor = *wxSTANDARD_CURSOR;
1643
1644         window = m_widget->window;
1645         if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
1646             gdk_window_set_cursor( window, cursor.GetCursor() );
1647 #endif
1648     }
1649
1650     if (g_delayedFocus == this)
1651     {
1652         if (GTK_WIDGET_REALIZED(m_widget))
1653         {
1654             gtk_widget_grab_focus( m_widget );
1655             g_delayedFocus = NULL;
1656         }
1657     }
1658
1659     if (wxUpdateUIEvent::CanUpdate(this))
1660         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1661 }
1662
1663 wxSize wxTextCtrl::DoGetBestSize() const
1664 {
1665     // FIXME should be different for multi-line controls...
1666     wxSize ret( wxControl::DoGetBestSize() );
1667     wxSize best(80, ret.y);
1668     CacheBestSize(best);
1669     return best;
1670 }
1671
1672 // ----------------------------------------------------------------------------
1673 // freeze/thaw
1674 // ----------------------------------------------------------------------------
1675
1676 void wxTextCtrl::Freeze()
1677 {
1678 #ifndef __WXGTK20__
1679     if ( HasFlag(wxTE_MULTILINE) )
1680     {
1681         gtk_text_freeze(GTK_TEXT(m_text));
1682     }
1683 #endif
1684 }
1685
1686 void wxTextCtrl::Thaw()
1687 {
1688 #ifndef __WXGTK20__
1689     if ( HasFlag(wxTE_MULTILINE) )
1690     {
1691         GTK_TEXT(m_text)->vadj->value = 0.0;
1692
1693         gtk_text_thaw(GTK_TEXT(m_text));
1694     }
1695 #endif
1696 }
1697
1698 // ----------------------------------------------------------------------------
1699 // scrolling
1700 // ----------------------------------------------------------------------------
1701
1702 GtkAdjustment *wxTextCtrl::GetVAdj() const
1703 {
1704 #ifdef __WXGTK20__
1705     return NULL;
1706 #else
1707     return HasFlag(wxTE_MULTILINE) ? GTK_TEXT(m_text)->vadj : NULL;
1708 #endif
1709 }
1710
1711 bool wxTextCtrl::DoScroll(GtkAdjustment *adj, int diff)
1712 {
1713 #ifndef __WXGTK20__
1714     float value = adj->value + diff;
1715
1716     if ( value < 0 )
1717         value = 0;
1718
1719     float upper = adj->upper - adj->page_size;
1720     if ( value > upper )
1721         value = upper;
1722
1723     // did we noticeably change the scroll position?
1724     if ( fabs(adj->value - value) < 0.2 )
1725     {
1726         // well, this is what Robert does in wxScrollBar, so it must be good...
1727         return FALSE;
1728     }
1729
1730     adj->value = value;
1731
1732     gtk_signal_emit_by_name(GTK_OBJECT(adj), "value_changed");
1733
1734 #endif
1735     return TRUE;
1736 }
1737
1738 bool wxTextCtrl::ScrollLines(int lines)
1739 {
1740 #ifdef __WXGTK20__
1741     return FALSE;
1742 #else
1743     GtkAdjustment *adj = GetVAdj();
1744     if ( !adj )
1745         return FALSE;
1746
1747     // this is hardcoded to 10 in GTK+ 1.2 (great idea)
1748     static const int KEY_SCROLL_PIXELS = 10;
1749
1750     return DoScroll(adj, lines*KEY_SCROLL_PIXELS);
1751 #endif
1752 }
1753
1754 bool wxTextCtrl::ScrollPages(int pages)
1755 {
1756 #ifdef __WXGTK20__
1757     return FALSE;
1758 #else
1759     GtkAdjustment *adj = GetVAdj();
1760     if ( !adj )
1761         return FALSE;
1762
1763     return DoScroll(adj, (int)ceil(pages*adj->page_increment));
1764 #endif
1765 }
1766
1767
1768 // static
1769 wxVisualAttributes
1770 wxTextCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
1771 {
1772     return GetDefaultAttributesFromGTKWidget(gtk_entry_new, true);
1773 }