src/gtk/textctrl.cpp

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