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 #ifdef __GNUG__
  11 #pragma implementation "textctrl.h"
  12 #endif
  13
  14 #include "wx/textctrl.h"
  15 #include "wx/utils.h"
  16 #include <wx/intl.h>
  17
  18 #include <sys/types.h>
  19 #include <sys/stat.h>
  20 #include <ctype.h>
  21
  22 //-----------------------------------------------------------------------------
  23 //  "changed"
  24 //-----------------------------------------------------------------------------
  25
  26 static void gtk_text_changed_callback( GtkWidget *WXUNUSED(widget), wxTextCtrl *win )
  27 {
  28   win->SetModified();
  29
  30   wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->m_windowId );
  31   wxString val( win->GetValue() );
  32   if (!val.IsNull()) event.m_commandString = WXSTRINGCAST val;
  33   event.SetEventObject( win );
  34   win->GetEventHandler()->ProcessEvent( event );
  35 }
  36
  37 //-----------------------------------------------------------------------------
  38 //  wxTextCtrl
  39 //-----------------------------------------------------------------------------
  40
  41 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
  42
  43 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
  44   EVT_CHAR(wxTextCtrl::OnChar)
  45 END_EVENT_TABLE()
  46
  47 wxTextCtrl::wxTextCtrl() : streambuf()
  48 {
  49   if (allocate()) setp(base(),ebuf());
  50
  51   m_modified = FALSE;
  52 }
  53
  54 wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
  55       const wxPoint &pos, const wxSize &size,
  56       int style, const wxValidator& validator, const wxString &name ) : streambuf()
  57 {
  58   if (allocate()) setp(base(),ebuf());
  59
  60   m_modified = FALSE;
  61   Create( parent, id, value, pos, size, style, validator, name );
  62 }
  63
  64 bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
  65       const wxPoint &pos, const wxSize &size,
  66       int style, const wxValidator& validator, const wxString &name )
  67 {
  68   m_needParent = TRUE;
  69
  70   PreCreation( parent, id, pos, size, style, name );
  71
  72   SetValidator( validator );
  73
  74   bool bMultiLine = (style & wxTE_MULTILINE) != 0;
  75   if ( bMultiLine )
  76   {
  77     // a multi-line edit control: create a vertical scrollbar by default and
  78     // horizontal if requested
  79     bool bHasHScrollbar = (style & wxHSCROLL) != 0;
  80
  81     // create our control...
  82     m_text = gtk_text_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
  83
  84     // ... and put into the upper left hand corner of the table
  85     m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
  86     gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
  87                       (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
  88                       (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
  89                        0, 0);
  90
  91     // put the horizontal scrollbar in the lower left hand corner
  92     if (bHasHScrollbar)
  93     {
  94       GtkWidget *hscrollbar = gtk_hscrollbar_new(GTK_TEXT(m_text)->hadj);
  95       gtk_table_attach(GTK_TABLE(m_widget), hscrollbar, 0, 1, 1, 2,
  96                        (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
  97                        GTK_FILL,
  98                        0, 0);
  99       gtk_widget_show(hscrollbar);
 100     }
 101
 102     // finally, put the vertical scrollbar in the upper right corner
 103     GtkWidget *vscrollbar = gtk_vscrollbar_new(GTK_TEXT(m_text)->vadj);
 104     gtk_table_attach(GTK_TABLE(m_widget), vscrollbar, 1, 2, 0, 1,
 105                      GTK_FILL,
 106                      (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
 107                      0, 0);
 108     gtk_widget_show( vscrollbar );
 109   }
 110   else
 111   {
 112     // a single-line text control: no need for scrollbars
 113     m_widget =
 114     m_text = gtk_entry_new();
 115   }
 116
 117   wxSize newSize = size;
 118   if (newSize.x == -1) newSize.x = 80;
 119   if (newSize.y == -1) newSize.y = 26;
 120   SetSize( newSize.x, newSize.y );
 121
 122   m_parent->AddChild( this );
 123
 124   (m_parent->m_insertCallback)( m_parent, this );
 125
 126   PostCreation();
 127
 128   if (bMultiLine)
 129   {
 130     gtk_widget_realize(m_text);
 131     gtk_widget_show(m_text);
 132   }
 133
 134   // we want to be notified about text changes
 135   gtk_signal_connect(GTK_OBJECT(m_text), "changed",
 136                      GTK_SIGNAL_FUNC(gtk_text_changed_callback),
 137                      (gpointer)this);
 138
 139   if (!value.IsNull())
 140   {
 141     gint tmp = 0;
 142     gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &tmp );
 143     SetInsertionPointEnd();
 144   }
 145
 146   if (style & wxTE_READONLY)
 147   {
 148   }
 149   else
 150   {
 151     if (bMultiLine)
 152       gtk_text_set_editable( GTK_TEXT(m_text), 1 );
 153   }
 154
 155   Show( TRUE );
 156
 157   SetBackgroundColour( parent->GetBackgroundColour() );
 158   SetForegroundColour( parent->GetForegroundColour() );
 159
 160   return TRUE;
 161 }
 162
 163 wxString wxTextCtrl::GetValue() const
 164 {
 165   wxCHECK_MSG( m_text != NULL, "", "invalid text ctrl" );
 166
 167   wxString tmp;
 168   if (m_windowStyle & wxTE_MULTILINE)
 169   {
 170     gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 171     char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
 172     tmp = text;
 173     g_free( text );
 174   }
 175   else
 176   {
 177     tmp = gtk_entry_get_text( GTK_ENTRY(m_text) );
 178   }
 179   return tmp;
 180 }
 181
 182 void wxTextCtrl::SetValue( const wxString &value )
 183 {
 184   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 185
 186   wxString tmp = "";
 187   if (!value.IsNull()) tmp = value;
 188   if (m_windowStyle & wxTE_MULTILINE)
 189   {
 190     gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 191     gtk_editable_delete_text( GTK_EDITABLE(m_text), 0, len );
 192     len = 0;
 193     gtk_editable_insert_text( GTK_EDITABLE(m_text), tmp, tmp.Length(), &len );
 194   }
 195   else
 196   {
 197     gtk_entry_set_text( GTK_ENTRY(m_text), tmp );
 198   }
 199 }
 200
 201 void wxTextCtrl::WriteText( const wxString &text )
 202 {
 203   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 204
 205   if (text.IsNull()) return;
 206
 207   if (m_windowStyle & wxTE_MULTILINE)
 208   {
 209     gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 210     gtk_editable_insert_text( GTK_EDITABLE(m_text), text, text.Length(), &len );
 211   }
 212   else
 213   {
 214     gtk_entry_append_text( GTK_ENTRY(m_text), text );
 215   }
 216 }
 217
 218 bool wxTextCtrl::LoadFile( const wxString &file )
 219 {
 220   wxCHECK_MSG( m_text != NULL, FALSE, "invalid text ctrl" );
 221
 222   if (!wxFileExists(file)) return FALSE;
 223
 224   Clear();
 225
 226   FILE *fp = NULL;
 227   struct stat statb;
 228
 229   if ((stat ((char*) (const char*) file, &statb) == -1) || (statb.st_mode & S_IFMT) != S_IFREG ||
 230       !(fp = fopen ((char*) (const char*) file, "r")))
 231   {
 232       return FALSE;
 233   }
 234   else
 235   {
 236     gint len = statb.st_size;
 237     char *text;
 238     if (!(text = (char*)malloc ((unsigned) (len + 1))))
 239     {
 240       fclose (fp);
 241       return FALSE;
 242     }
 243     if (fread (text, sizeof (char), len, fp) != (size_t) len)
 244         {
 245         }
 246     fclose (fp);
 247
 248     text[len] = 0;
 249
 250     if (m_windowStyle & wxTE_MULTILINE)
 251     {
 252       gtk_editable_insert_text( GTK_EDITABLE(m_text), text, 0, &len );
 253     }
 254     else
 255     {
 256       gtk_entry_set_text( GTK_ENTRY(m_text), text );
 257     }
 258
 259     free (text);
 260     m_modified = FALSE;
 261     return TRUE;
 262   }
 263   return FALSE;
 264 }
 265
 266 bool wxTextCtrl::SaveFile( const wxString &file )
 267 {
 268   wxCHECK_MSG( m_text != NULL, FALSE, "invalid text ctrl" );
 269
 270   if (file == "") return FALSE;
 271
 272   FILE *fp;
 273
 274   if (!(fp = fopen ((char*) (const char*) file, "w")))
 275     {
 276       return FALSE;
 277     }
 278   else
 279     {
 280       char *text = NULL;
 281       gint len = 0;
 282
 283       if (m_windowStyle & wxTE_MULTILINE)
 284       {
 285         len = gtk_text_get_length( GTK_TEXT(m_text) );
 286         text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
 287       }
 288       else
 289       {
 290         text = gtk_entry_get_text( GTK_ENTRY(m_text) );
 291       }
 292
 293       if (fwrite (text, sizeof (char), len, fp) != (size_t) len)
 294         {
 295           // Did not write whole file
 296         }
 297
 298       // Make sure newline terminates the file
 299       if (text[len - 1] != '\n')
 300         fputc ('\n', fp);
 301
 302       fclose (fp);
 303
 304       if (m_windowStyle & wxTE_MULTILINE) g_free( text );
 305
 306       m_modified = FALSE;
 307       return TRUE;
 308     }
 309
 310   return TRUE;
 311 }
 312
 313 wxString wxTextCtrl::GetLineText( long lineNo ) const
 314 {
 315   if (m_windowStyle & wxTE_MULTILINE)
 316   {
 317     gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 318     char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
 319
 320     if (text)
 321     {
 322         wxString buf("");
 323         long i;
 324         int currentLine = 0;
 325         for (i = 0; currentLine != lineNo && text[i]; i++ )
 326           if (text[i] == '\n')
 327             currentLine++;
 328         // Now get the text
 329         int j;
 330         for (j = 0; text[i] && text[i] != '\n'; i++, j++ )
 331             buf += text[i];
 332
 333         g_free( text );
 334         return buf;
 335     }
 336     else
 337       return wxEmptyString;
 338   }
 339   else
 340   {
 341     if (lineNo == 0) return GetValue();
 342     return wxEmptyString;
 343   }
 344 }
 345
 346 void wxTextCtrl::OnDropFiles( wxDropFilesEvent &WXUNUSED(event) )
 347 {
 348   wxFAIL_MSG( "wxTextCtrl::OnDropFiles not implemented" );
 349 }
 350
 351 long wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
 352 {
 353   if (!(m_windowStyle & wxTE_MULTILINE))
 354     return 0;
 355   gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 356   char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
 357   if(!text)
 358     return 0;
 359   if( pos >= len)
 360     return pos=len-1;
 361
 362   *x=1;   // Col 1
 363   *y=1;   // Line 1
 364   for (int i = 0; i < pos; i++ )
 365     {
 366       if (text[i] == '\n')
 367         {
 368           (*y)++;
 369           *x=1;
 370         }
 371       else
 372         (*x)++;
 373     }
 374   g_free( text );
 375   return 1;
 376 }
 377
 378 long wxTextCtrl::XYToPosition(long x, long y ) const
 379 {
 380   if (!(m_windowStyle & wxTE_MULTILINE))
 381     return 0;
 382   long pos=0;
 383
 384   for(int i=1;i<y;i++)
 385       pos +=GetLineLength(i);
 386   pos +=x-1; // Pos start with 0
 387   return pos;
 388 }
 389
 390 int wxTextCtrl::GetLineLength(long lineNo) const
 391 {
 392     wxString str = GetLineText (lineNo);
 393     return (int) str.Length();
 394 }
 395
 396 int wxTextCtrl::GetNumberOfLines() const
 397 {
 398   if (m_windowStyle & wxTE_MULTILINE)
 399   {
 400     gint len = gtk_text_get_length( GTK_TEXT(m_text) );
 401     char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len );
 402
 403     if (text)
 404     {
 405         int currentLine = 0;
 406         for (int i = 0; i < len; i++ )
 407           if (text[i] == '\n')
 408             currentLine++;
 409
 410         g_free( text );
 411         return currentLine;
 412     }
 413     else
 414       return 0;
 415   }
 416   else
 417   {
 418     return 1;
 419   }
 420 }
 421
 422 void wxTextCtrl::SetInsertionPoint( long pos )
 423 {
 424   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 425
 426   int tmp = (int) pos;
 427   if (m_windowStyle & wxTE_MULTILINE)
 428     gtk_text_set_point( GTK_TEXT(m_text), tmp );
 429   else
 430     gtk_entry_set_position( GTK_ENTRY(m_text), tmp );
 431 }
 432
 433 void wxTextCtrl::SetInsertionPointEnd()
 434 {
 435   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 436
 437   int pos = 0;
 438   if (m_windowStyle & wxTE_MULTILINE)
 439     pos = gtk_text_get_length( GTK_TEXT(m_text) );
 440   else
 441     pos = GTK_ENTRY(m_text)->text_length;
 442   SetInsertionPoint((pos-1)>0 ? (pos-1):0);
 443 }
 444
 445 void wxTextCtrl::SetEditable( bool editable )
 446 {
 447   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 448
 449   if (m_windowStyle & wxTE_MULTILINE)
 450     gtk_text_set_editable( GTK_TEXT(m_text), editable );
 451   else
 452     gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
 453 }
 454
 455 void wxTextCtrl::SetSelection( long from, long to )
 456 {
 457   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 458
 459   gtk_editable_select_region( GTK_EDITABLE(m_text), (gint)from, (gint)to );
 460 }
 461
 462 void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
 463 {
 464   wxFAIL_MSG( "wxTextCtrl::ShowPosition not implemented" );
 465 }
 466
 467 long wxTextCtrl::GetInsertionPoint() const
 468 {
 469   wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
 470
 471   return (long) GTK_EDITABLE(m_text)->current_pos;
 472 }
 473
 474 long wxTextCtrl::GetLastPosition() const
 475 {
 476   wxCHECK_MSG( m_text != NULL, 0, "invalid text ctrl" );
 477
 478   int pos = 0;
 479   if (m_windowStyle & wxTE_MULTILINE)
 480     pos = gtk_text_get_length( GTK_TEXT(m_text) );
 481   else
 482     pos = GTK_ENTRY(m_text)->text_length;
 483   return (long)pos-1;
 484 }
 485
 486 void wxTextCtrl::Remove( long from, long to )
 487 {
 488   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 489
 490   gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
 491 }
 492
 493 void wxTextCtrl::Replace( long from, long to, const wxString &value )
 494 {
 495   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 496
 497   gtk_editable_delete_text( GTK_EDITABLE(m_text), (gint)from, (gint)to );
 498   if (value.IsNull()) return;
 499   gint pos = (gint)to;
 500   gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.Length(), &pos );
 501 }
 502
 503 void wxTextCtrl::Cut()
 504 {
 505   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 506
 507 #if (GTK_MINOR_VERSION == 1)
 508   gtk_editable_cut_clipboard( GTK_EDITABLE(m_text) );
 509 #else
 510   gtk_editable_cut_clipboard( GTK_EDITABLE(m_text), 0 );
 511 #endif
 512 }
 513
 514 void wxTextCtrl::Copy()
 515 {
 516   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 517
 518 #if (GTK_MINOR_VERSION == 1)
 519   gtk_editable_copy_clipboard( GTK_EDITABLE(m_text) );
 520 #else
 521   gtk_editable_copy_clipboard( GTK_EDITABLE(m_text), 0 );
 522 #endif
 523 }
 524
 525 void wxTextCtrl::Paste()
 526 {
 527   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 528
 529 #if (GTK_MINOR_VERSION == 1)
 530   gtk_editable_paste_clipboard( GTK_EDITABLE(m_text) );
 531 #else
 532   gtk_editable_paste_clipboard( GTK_EDITABLE(m_text), 0 );
 533 #endif
 534 }
 535
 536 void wxTextCtrl::Clear()
 537 {
 538   SetValue( "" );
 539 }
 540
 541 void wxTextCtrl::OnChar( wxKeyEvent &key_event )
 542 {
 543   if ((key_event.KeyCode() == WXK_RETURN) && (m_windowStyle & wxPROCESS_ENTER))
 544   {
 545     wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
 546     event.SetEventObject(this);
 547     if (GetEventHandler()->ProcessEvent(event)) return;
 548   }
 549   else if (key_event.KeyCode() == WXK_TAB)
 550   {
 551     wxNavigationKeyEvent event;
 552     event.SetDirection( key_event.m_shiftDown );
 553     event.SetWindowChange(FALSE);
 554     event.SetEventObject(this);
 555
 556     if (GetEventHandler()->ProcessEvent(event)) return;
 557   }
 558   key_event.Skip();
 559 }
 560
 561 int wxTextCtrl::overflow( int WXUNUSED(c) )
 562 {
 563   int len = pptr() - pbase();
 564   char *txt = new char[len+1];
 565   strncpy(txt, pbase(), len);
 566   txt[len] = '\0';
 567   (*this) << txt;
 568   setp(pbase(), epptr());
 569   delete[] txt;
 570   return EOF;
 571 }
 572
 573 int wxTextCtrl::sync()
 574 {
 575   int len = pptr() - pbase();
 576   char *txt = new char[len+1];
 577   strncpy(txt, pbase(), len);
 578   txt[len] = '\0';
 579   (*this) << txt;
 580   setp(pbase(), epptr());
 581   delete[] txt;
 582   return 0;
 583 }
 584
 585 int wxTextCtrl::underflow()
 586 {
 587   return EOF;
 588 }
 589
 590 wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
 591 {
 592   WriteText(s);
 593   return *this;
 594 }
 595
 596 wxTextCtrl& wxTextCtrl::operator<<(float f)
 597 {
 598   static char buf[100];
 599   sprintf(buf, "%.2f", f);
 600   WriteText(buf);
 601   return *this;
 602 }
 603
 604 wxTextCtrl& wxTextCtrl::operator<<(double d)
 605 {
 606   static char buf[100];
 607   sprintf(buf, "%.2f", d);
 608   WriteText(buf);
 609   return *this;
 610 }
 611
 612 wxTextCtrl& wxTextCtrl::operator<<(int i)
 613 {
 614   static char buf[100];
 615   sprintf(buf, "%i", i);
 616   WriteText(buf);
 617   return *this;
 618 }
 619
 620 wxTextCtrl& wxTextCtrl::operator<<(long i)
 621 {
 622   static char buf[100];
 623   sprintf(buf, "%ld", i);
 624   WriteText(buf);
 625   return *this;
 626 }
 627
 628 wxTextCtrl& wxTextCtrl::operator<<(const char c)
 629 {
 630   char buf[2];
 631
 632   buf[0] = c;
 633   buf[1] = 0;
 634   WriteText(buf);
 635   return *this;
 636 }
 637
 638 GtkWidget* wxTextCtrl::GetConnectWidget()
 639 {
 640   return GTK_WIDGET(m_text);
 641 }
 642
 643 bool wxTextCtrl::IsOwnGtkWindow( GdkWindow *window )
 644 {
 645   if (m_windowStyle & wxTE_MULTILINE)
 646     return (window == GTK_TEXT(m_text)->text_area);
 647   else
 648     return (window == GTK_ENTRY(m_text)->text_area);
 649 }
 650
 651 void wxTextCtrl::SetFont( const wxFont &WXUNUSED(font) )
 652 {
 653   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 654
 655   // doesn't work
 656 }
 657
 658 void wxTextCtrl::SetForegroundColour( const wxColour &WXUNUSED(colour) )
 659 {
 660   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 661
 662   // doesn't work
 663 }
 664
 665 void wxTextCtrl::SetBackgroundColour( const wxColour &colour )
 666 {
 667   wxCHECK_RET( m_text != NULL, "invalid text ctrl" );
 668
 669   wxControl::SetBackgroundColour( colour );
 670
 671   if (!m_backgroundColour.Ok()) return;
 672
 673   if (m_windowStyle & wxTE_MULTILINE)
 674   {
 675     GdkWindow *window = GTK_TEXT(m_text)->text_area;
 676     m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
 677     gdk_window_set_background( window, m_backgroundColour.GetColor() );
 678     gdk_window_clear( window );
 679   }
 680 }
 681
 682 void wxTextCtrl::ApplyWidgetStyle()
 683 {
 684   if (m_windowStyle & wxTE_MULTILINE)
 685   {
 686   }
 687   else
 688   {
 689     SetWidgetStyle();
 690     gtk_widget_set_style( m_text, m_widgetStyle );
 691   }
 692 }
 693