src/gtk1/textctrl.cpp

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