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