src/motif/textctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        textctrl.cpp
   3 // Purpose:     wxTextCtrl
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "textctrl.h"
  22 #endif
  23
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fstream.h>
  27 #include <ctype.h>
  28
  29 #include "wx/textctrl.h"
  30 #include "wx/settings.h"
  31 #include "wx/filefn.h"
  32 #include "wx/utils.h"
  33
  34 #include <Xm/Text.h>
  35
  36 #include "wx/motif/private.h"
  37
  38 // ----------------------------------------------------------------------------
  39 // private functions
  40 // ----------------------------------------------------------------------------
  41
  42 // helper: inserts the new text in the value of the text ctrl and returns the
  43 // result in place
  44 static void MergeChangesIntoString(wxString& value,
  45                                    XmTextVerifyCallbackStruct *textStruct);
  46
  47 // callbacks
  48 static void wxTextWindowChangedProc(Widget w, XtPointer clientData, XtPointer ptr);
  49 static void wxTextWindowModifyProc(Widget w, XtPointer clientData, XmTextVerifyCallbackStruct *cbs);
  50 static void wxTextWindowGainFocusProc(Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs);
  51 static void wxTextWindowLoseFocusProc(Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs);
  52 static void wxTextWindowActivateProc(Widget w, XtPointer clientData, XmAnyCallbackStruct *ptr);
  53
  54 #if !USE_SHARED_LIBRARY
  55     IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
  56
  57     BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
  58         EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
  59         EVT_CHAR(wxTextCtrl::OnChar)
  60
  61     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
  62     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
  63     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
  64     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
  65     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
  66
  67     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
  68     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
  69     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
  70     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
  71     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
  72
  73     END_EVENT_TABLE()
  74 #endif
  75
  76 // ============================================================================
  77 // implementation
  78 // ============================================================================
  79
  80 // ----------------------------------------------------------------------------
  81 // wxTextCtrl
  82 // ----------------------------------------------------------------------------
  83
  84 // Text item
  85 wxTextCtrl::wxTextCtrl()
  86 #ifndef NO_TEXT_WINDOW_STREAM
  87           : streambuf()
  88 #endif
  89 {
  90     m_tempCallbackStruct = (void*) NULL;
  91     m_modified = FALSE;
  92     m_processedDefault = FALSE;
  93 }
  94
  95 bool wxTextCtrl::Create(wxWindow *parent,
  96                         wxWindowID id,
  97                         const wxString& value,
  98                         const wxPoint& pos,
  99                         const wxSize& size,
 100                         long style,
 101                         const wxValidator& validator,
 102                         const wxString& name)
 103 {
 104     m_tempCallbackStruct = (void*) NULL;
 105     m_modified = FALSE;
 106     m_processedDefault = FALSE;
 107     //    m_backgroundColour = parent->GetBackgroundColour();
 108     m_backgroundColour = * wxWHITE;
 109     m_foregroundColour = parent->GetForegroundColour();
 110
 111     SetName(name);
 112     SetValidator(validator);
 113     if (parent)
 114         parent->AddChild(this);
 115
 116     m_windowStyle = style;
 117
 118     if ( id == -1 )
 119         m_windowId = (int)NewControlId();
 120     else
 121         m_windowId = id;
 122
 123     Widget parentWidget = (Widget) parent->GetClientWidget();
 124
 125     bool wantHorizScrolling = ((m_windowStyle & wxHSCROLL) != 0);
 126
 127     // If we don't have horizontal scrollbars, we want word wrap.
 128     bool wantWordWrap = !wantHorizScrolling;
 129
 130     if (m_windowStyle & wxTE_MULTILINE)
 131     {
 132         Arg args[2];
 133         XtSetArg (args[0], XmNscrollHorizontal, wantHorizScrolling ? True : False);
 134         XtSetArg (args[1], XmNwordWrap, wantWordWrap ? True : False);
 135
 136         m_mainWidget = (WXWidget) XmCreateScrolledText(parentWidget,
 137                                                        (char*)name.c_str(),
 138                                                        args, 2);
 139
 140         XtVaSetValues ((Widget) m_mainWidget,
 141                         XmNeditable, ((style & wxTE_READONLY) ? False : True),
 142                         XmNeditMode, XmMULTI_LINE_EDIT,
 143                         NULL);
 144         XtManageChild ((Widget) m_mainWidget);
 145     }
 146     else
 147     {
 148         m_mainWidget = (WXWidget)XtVaCreateManagedWidget
 149                                  (
 150                                   (char*)name.c_str(),
 151                                   xmTextWidgetClass,
 152                                   parentWidget,
 153                                   NULL
 154                                  );
 155
 156         // TODO: Is this relevant? What does it do?
 157         int noCols = 2;
 158         if (!value.IsNull() && (value.Length() > (unsigned int) noCols))
 159             noCols = value.Length();
 160         XtVaSetValues((Widget) m_mainWidget,
 161                       XmNcolumns, noCols,
 162                       NULL);
 163     }
 164
 165     // remove border if asked for
 166     if ( style & wxNO_BORDER )
 167     {
 168         XtVaSetValues((Widget)m_mainWidget,
 169                       XmNshadowThickness, 0,
 170                       NULL);
 171     }
 172
 173     if ( !!value )
 174         XmTextSetString ((Widget) m_mainWidget, (char*)value.c_str());
 175
 176     // install callbacks
 177     XtAddCallback((Widget) m_mainWidget, XmNvalueChangedCallback, (XtCallbackProc)wxTextWindowChangedProc, (XtPointer)this);
 178
 179     XtAddCallback((Widget) m_mainWidget, XmNmodifyVerifyCallback, (XtCallbackProc)wxTextWindowModifyProc, (XtPointer)this);
 180
 181     XtAddCallback((Widget) m_mainWidget, XmNactivateCallback, (XtCallbackProc)wxTextWindowActivateProc, (XtPointer)this);
 182
 183     XtAddCallback((Widget) m_mainWidget, XmNfocusCallback, (XtCallbackProc)wxTextWindowGainFocusProc, (XtPointer)this);
 184
 185     XtAddCallback((Widget) m_mainWidget, XmNlosingFocusCallback, (XtCallbackProc)wxTextWindowLoseFocusProc, (XtPointer)this);
 186
 187     // font
 188     m_windowFont = parent->GetFont();
 189     ChangeFont(FALSE);
 190
 191     SetCanAddEventHandler(TRUE);
 192     AttachWidget (parent, m_mainWidget, (WXWidget) NULL, pos.x, pos.y, size.x, size.y);
 193
 194     ChangeBackgroundColour();
 195
 196     return TRUE;
 197 }
 198
 199 WXWidget wxTextCtrl::GetTopWidget() const
 200 {
 201     return ((m_windowStyle & wxTE_MULTILINE) ? (WXWidget) XtParent((Widget) m_mainWidget) : m_mainWidget);
 202 }
 203
 204 wxString wxTextCtrl::GetValue() const
 205 {
 206     wxString str; // result
 207
 208     if (m_windowStyle & wxTE_PASSWORD)
 209     {
 210         // the value is stored always in m_value because it can't be retrieved
 211         // from the text control
 212         str = m_value;
 213     }
 214     else
 215     {
 216         // just get the string from Motif
 217         char *s = XmTextGetString ((Widget) m_mainWidget);
 218         if ( s )
 219         {
 220             str = s;
 221             XtFree (s);
 222         }
 223         //else: return empty string
 224
 225         if ( m_tempCallbackStruct )
 226         {
 227             // the string in the control isn't yet updated, can't use it as is
 228             MergeChangesIntoString(str, (XmTextVerifyCallbackStruct *)
 229                                    m_tempCallbackStruct);
 230         }
 231     }
 232
 233     return str;
 234 }
 235
 236 void wxTextCtrl::SetValue(const wxString& value)
 237 {
 238     m_inSetValue = TRUE;
 239
 240     XmTextSetString ((Widget) m_mainWidget, (char*)value.c_str());
 241
 242     m_inSetValue = FALSE;
 243 }
 244
 245 // Clipboard operations
 246 void wxTextCtrl::Copy()
 247 {
 248     XmTextCopy((Widget) m_mainWidget, CurrentTime);
 249 }
 250
 251 void wxTextCtrl::Cut()
 252 {
 253     XmTextCut((Widget) m_mainWidget, CurrentTime);
 254 }
 255
 256 void wxTextCtrl::Paste()
 257 {
 258     XmTextPaste((Widget) m_mainWidget);
 259 }
 260
 261 bool wxTextCtrl::CanCopy() const
 262 {
 263     // Can copy if there's a selection
 264     long from, to;
 265     GetSelection(& from, & to);
 266     return (from != to) ;
 267 }
 268
 269 bool wxTextCtrl::CanCut() const
 270 {
 271     // Can cut if there's a selection
 272     long from, to;
 273     GetSelection(& from, & to);
 274     return (from != to) ;
 275 }
 276
 277 bool wxTextCtrl::CanPaste() const
 278 {
 279     return IsEditable() ;
 280 }
 281
 282 // Undo/redo
 283 void wxTextCtrl::Undo()
 284 {
 285     // Not possible in Motif
 286 }
 287
 288 void wxTextCtrl::Redo()
 289 {
 290     // Not possible in Motif
 291 }
 292
 293 bool wxTextCtrl::CanUndo() const
 294 {
 295     // No Undo in Motif
 296     return FALSE;
 297 }
 298
 299 bool wxTextCtrl::CanRedo() const
 300 {
 301     // No Redo in Motif
 302     return FALSE;
 303 }
 304
 305 // If the return values from and to are the same, there is no
 306 // selection.
 307 void wxTextCtrl::GetSelection(long* from, long* to) const
 308 {
 309     XmTextPosition left, right;
 310
 311     XmTextGetSelectionPosition((Widget) m_mainWidget, & left, & right);
 312
 313     *from = (long) left;
 314     *to = (long) right;
 315 }
 316
 317 bool wxTextCtrl::IsEditable() const
 318 {
 319     return (XmTextGetEditable((Widget) m_mainWidget) != 0);
 320 }
 321
 322 void wxTextCtrl::SetEditable(bool editable)
 323 {
 324     XmTextSetEditable((Widget) m_mainWidget, (Boolean) editable);
 325 }
 326
 327 void wxTextCtrl::SetInsertionPoint(long pos)
 328 {
 329     XmTextSetInsertionPosition ((Widget) m_mainWidget, (XmTextPosition) pos);
 330 }
 331
 332 void wxTextCtrl::SetInsertionPointEnd()
 333 {
 334     long pos = GetLastPosition();
 335     SetInsertionPoint(pos);
 336 }
 337
 338 long wxTextCtrl::GetInsertionPoint() const
 339 {
 340     return (long) XmTextGetInsertionPosition ((Widget) m_mainWidget);
 341 }
 342
 343 long wxTextCtrl::GetLastPosition() const
 344 {
 345     return (long) XmTextGetLastPosition ((Widget) m_mainWidget);
 346 }
 347
 348 void wxTextCtrl::Replace(long from, long to, const wxString& value)
 349 {
 350     XmTextReplace ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to,
 351         (char*) (const char*) value);
 352 }
 353
 354 void wxTextCtrl::Remove(long from, long to)
 355 {
 356     XmTextSetSelection ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to,
 357                       (Time) 0);
 358     XmTextRemove ((Widget) m_mainWidget);
 359 }
 360
 361 void wxTextCtrl::SetSelection(long from, long to)
 362 {
 363     XmTextSetSelection ((Widget) m_mainWidget, (XmTextPosition) from, (XmTextPosition) to,
 364                       (Time) 0);
 365 }
 366
 367 bool wxTextCtrl::LoadFile(const wxString& file)
 368 {
 369     if (!wxFileExists(file))
 370         return FALSE;
 371
 372     m_fileName = file;
 373
 374     Clear();
 375
 376     Widget textWidget = (Widget) m_mainWidget;
 377     FILE *fp;
 378
 379     struct stat statb;
 380     if ((stat ((char*) (const char*) file, &statb) == -1) || (statb.st_mode & S_IFMT) != S_IFREG ||
 381         !(fp = fopen ((char*) (const char*) file, "r")))
 382     {
 383         return FALSE;
 384     }
 385     else
 386     {
 387         long len = statb.st_size;
 388         char *text;
 389         if (!(text = XtMalloc ((unsigned) (len + 1))))
 390         {
 391             fclose (fp);
 392             return FALSE;
 393         }
 394         if (fread (text, sizeof (char), len, fp) != (size_t) len)
 395         {
 396         }
 397         fclose (fp);
 398
 399         text[len] = 0;
 400         XmTextSetString (textWidget, text);
 401         //      m_textPosition = len;
 402         XtFree (text);
 403         m_modified = FALSE;
 404         return TRUE;
 405     }
 406 }
 407
 408 // If file is null, try saved file name first
 409 // Returns TRUE if succeeds.
 410 bool wxTextCtrl::SaveFile(const wxString& file)
 411 {
 412     wxString theFile(file);
 413     if (theFile == "")
 414         theFile = m_fileName;
 415     if (theFile == "")
 416         return FALSE;
 417     m_fileName = theFile;
 418
 419     Widget textWidget = (Widget) m_mainWidget;
 420     FILE *fp;
 421
 422     if (!(fp = fopen ((char*) (const char*) theFile, "w")))
 423     {
 424         return FALSE;
 425     }
 426     else
 427     {
 428         char *text = XmTextGetString (textWidget);
 429         long len = XmTextGetLastPosition (textWidget);
 430
 431         if (fwrite (text, sizeof (char), len, fp) != (size_t) len)
 432         {
 433             // Did not write whole file
 434         }
 435         // Make sure newline terminates the file
 436         if (text[len - 1] != '\n')
 437             fputc ('\n', fp);
 438
 439         fclose (fp);
 440         XtFree (text);
 441         m_modified = FALSE;
 442         return TRUE;
 443     }
 444 }
 445
 446 void wxTextCtrl::WriteText(const wxString& text)
 447 {
 448     long textPosition = GetInsertionPoint() + strlen (text);
 449     XmTextInsert ((Widget) m_mainWidget, GetInsertionPoint(), (char*) (const char*) text);
 450     XtVaSetValues ((Widget) m_mainWidget, XmNcursorPosition, textPosition, NULL);
 451     SetInsertionPoint(textPosition);
 452     XmTextShowPosition ((Widget) m_mainWidget, textPosition);
 453     m_modified = TRUE;
 454 }
 455
 456 void wxTextCtrl::AppendText(const wxString& text)
 457 {
 458     long textPosition = GetLastPosition() + strlen(text);
 459     XmTextInsert ((Widget) m_mainWidget, GetLastPosition(), (char*) (const char*) text);
 460     XtVaSetValues ((Widget) m_mainWidget, XmNcursorPosition, textPosition, NULL);
 461     SetInsertionPoint(textPosition);
 462     XmTextShowPosition ((Widget) m_mainWidget, textPosition);
 463     m_modified = TRUE;
 464 }
 465
 466 void wxTextCtrl::Clear()
 467 {
 468     XmTextSetString ((Widget) m_mainWidget, "");
 469     m_modified = FALSE;
 470 }
 471
 472 bool wxTextCtrl::IsModified() const
 473 {
 474     return m_modified;
 475 }
 476
 477 // Makes 'unmodified'
 478 void wxTextCtrl::DiscardEdits()
 479 {
 480     XmTextSetString ((Widget) m_mainWidget, "");
 481     m_modified = FALSE;
 482 }
 483
 484 int wxTextCtrl::GetNumberOfLines() const
 485 {
 486     // HIDEOUSLY inefficient, but we have no choice.
 487     char *s = XmTextGetString ((Widget) m_mainWidget);
 488     if (s)
 489     {
 490         long i = 0;
 491         int currentLine = 0;
 492         bool finished = FALSE;
 493         while (!finished)
 494         {
 495             int ch = s[i];
 496             if (ch == '\n')
 497             {
 498                 currentLine++;
 499                 i++;
 500             }
 501             else if (ch == 0)
 502             {
 503                 finished = TRUE;
 504             }
 505             else
 506                 i++;
 507         }
 508
 509         XtFree (s);
 510         return currentLine;
 511     }
 512     return 0;
 513 }
 514
 515 long wxTextCtrl::XYToPosition(long x, long y) const
 516 {
 517 /* It seems, that there is a bug in some versions of the Motif library,
 518     so the original wxWin-Code doesn't work. */
 519     /*
 520     Widget textWidget = (Widget) handle;
 521     return (long) XmTextXYToPos (textWidget, (Position) x, (Position) y);
 522     */
 523     /* Now a little workaround: */
 524     long r=0;
 525     for (int i=0; i<y; i++) r+=(GetLineLength(i)+1);
 526     return r+x;
 527 }
 528
 529 void wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
 530 {
 531     Position xx, yy;
 532     XmTextPosToXY((Widget) m_mainWidget, pos, &xx, &yy);
 533     *x = xx; *y = yy;
 534 }
 535
 536 void wxTextCtrl::ShowPosition(long pos)
 537 {
 538     XmTextShowPosition ((Widget) m_mainWidget, (XmTextPosition) pos);
 539 }
 540
 541 int wxTextCtrl::GetLineLength(long lineNo) const
 542 {
 543     wxString str = GetLineText (lineNo);
 544     return (int) str.Length();
 545 }
 546
 547 wxString wxTextCtrl::GetLineText(long lineNo) const
 548 {
 549     // HIDEOUSLY inefficient, but we have no choice.
 550     char *s = XmTextGetString ((Widget) m_mainWidget);
 551
 552     if (s)
 553     {
 554         wxString buf("");
 555         long i;
 556         int currentLine = 0;
 557         for (i = 0; currentLine != lineNo && s[i]; i++ )
 558             if (s[i] == '\n')
 559                 currentLine++;
 560             // Now get the text
 561             int j;
 562             for (j = 0; s[i] && s[i] != '\n'; i++, j++ )
 563                 buf += s[i];
 564
 565             XtFree(s);
 566             return buf;
 567     }
 568     else
 569         return wxEmptyString;
 570 }
 571
 572 /*
 573 * Text item
 574 */
 575
 576 void wxTextCtrl::Command(wxCommandEvent & event)
 577 {
 578     SetValue (event.GetString());
 579     ProcessCommand (event);
 580 }
 581
 582 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
 583 {
 584     // By default, load the first file into the text window.
 585     if (event.GetNumberOfFiles() > 0)
 586     {
 587         LoadFile(event.GetFiles()[0]);
 588     }
 589 }
 590
 591 // The streambuf code was partly taken from chapter 3 by Jerry Schwarz of
 592 // AT&T's "C++ Lanuage System Release 3.0 Library Manual" - Stein Somers
 593
 594 //=========================================================================
 595 // Called then the buffer is full (gcc 2.6.3)
 596 // or when "endl" is output (Borland 4.5)
 597 //=========================================================================
 598 // Class declaration using multiple inheritance doesn't work properly for
 599 // Borland. See note in wb_text.h.
 600 #ifndef NO_TEXT_WINDOW_STREAM
 601 int wxTextCtrl::overflow(int c)
 602 {
 603     // Make sure there is a holding area
 604     if ( allocate()==EOF )
 605     {
 606         wxError("Streambuf allocation failed","Internal error");
 607         return EOF;
 608     }
 609
 610     // Verify that there are no characters in get area
 611     if ( gptr() && gptr() < egptr() )
 612     {
 613         wxError("wxTextCtrl::overflow: Who's trespassing my get area?","Internal error");
 614         return EOF;
 615     }
 616
 617     // Reset get area
 618     setg(0,0,0);
 619
 620     // Make sure there is a put area
 621     if ( ! pptr() )
 622     {
 623         /* This doesn't seem to be fatal so comment out error message */
 624         //    wxError("Put area not opened","Internal error");
 625         setp( base(), base() );
 626     }
 627
 628     // Determine how many characters have been inserted but no consumed
 629     int plen = pptr() - pbase();
 630
 631     // Now Jerry relies on the fact that the buffer is at least 2 chars
 632     // long, but the holding area "may be as small as 1" ???
 633     // And we need an additional \0, so let's keep this inefficient but
 634     // safe copy.
 635
 636     // If c!=EOF, it is a character that must also be comsumed
 637     int xtra = c==EOF? 0 : 1;
 638
 639     // Write temporary C-string to wxTextWindow
 640     {
 641         char *txt = new char[plen+xtra+1];
 642         memcpy(txt, pbase(), plen);
 643         txt[plen] = (char)c;     // append c
 644         txt[plen+xtra] = '\0';   // append '\0' or overwrite c
 645         // If the put area already contained \0, output will be truncated there
 646         WriteText(txt);
 647         delete[] txt;
 648     }
 649
 650     // Reset put area
 651     setp(pbase(), epptr());
 652
 653 #if defined(__WATCOMC__)
 654     return __NOT_EOF;
 655 #elif defined(zapeof)     // HP-UX (all cfront based?)
 656     return zapeof(c);
 657 #else
 658     return c!=EOF ? c : 0;  // this should make everybody happy
 659 #endif
 660 }
 661
 662 //=========================================================================
 663 // called then "endl" is output (gcc) or then explicit sync is done (Borland)
 664 //=========================================================================
 665 int wxTextCtrl::sync()
 666 {
 667     // Verify that there are no characters in get area
 668     if ( gptr() && gptr() < egptr() )
 669     {
 670         wxError("Who's trespassing my get area?","Internal error");
 671         return EOF;
 672     }
 673
 674     if ( pptr() && pptr() > pbase() ) return overflow(EOF);
 675
 676     return 0;
 677     /* OLD CODE
 678     int len = pptr() - pbase();
 679     char *txt = new char[len+1];
 680     strncpy(txt, pbase(), len);
 681     txt[len] = '\0';
 682     (*this) << txt;
 683     setp(pbase(), epptr());
 684     delete[] txt;
 685     return 0;
 686     */
 687 }
 688
 689 //=========================================================================
 690 // Should not be called by a "ostream". Used by a "istream"
 691 //=========================================================================
 692 int wxTextCtrl::underflow()
 693 {
 694     return EOF;
 695 }
 696 #endif
 697
 698 wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
 699 {
 700     AppendText(s);
 701     return *this;
 702 }
 703
 704 wxTextCtrl& wxTextCtrl::operator<<(float f)
 705 {
 706     wxString str;
 707     str.Printf("%.2f", f);
 708     AppendText(str);
 709     return *this;
 710 }
 711
 712 wxTextCtrl& wxTextCtrl::operator<<(double d)
 713 {
 714     wxString str;
 715     str.Printf("%.2f", d);
 716     AppendText(str);
 717     return *this;
 718 }
 719
 720 wxTextCtrl& wxTextCtrl::operator<<(int i)
 721 {
 722     wxString str;
 723     str.Printf("%d", i);
 724     AppendText(str);
 725     return *this;
 726 }
 727
 728 wxTextCtrl& wxTextCtrl::operator<<(long i)
 729 {
 730     wxString str;
 731     str.Printf("%ld", i);
 732     AppendText(str);
 733     return *this;
 734 }
 735
 736 wxTextCtrl& wxTextCtrl::operator<<(const char c)
 737 {
 738     char buf[2];
 739
 740     buf[0] = c;
 741     buf[1] = 0;
 742     AppendText(buf);
 743     return *this;
 744 }
 745
 746 void wxTextCtrl::OnChar(wxKeyEvent& event)
 747 {
 748     // Indicates that we should generate a normal command, because
 749     // we're letting default behaviour happen (otherwise it's vetoed
 750     // by virtue of overriding OnChar)
 751     m_processedDefault = TRUE;
 752
 753     if (m_tempCallbackStruct)
 754     {
 755         XmTextVerifyCallbackStruct *textStruct =
 756             (XmTextVerifyCallbackStruct *) m_tempCallbackStruct;
 757         textStruct->doit = True;
 758         if (isascii(event.m_keyCode) && (textStruct->text->length == 1))
 759         {
 760             textStruct->text->ptr[0] = ((event.m_keyCode == WXK_RETURN) ? 10 : event.m_keyCode);
 761         }
 762     }
 763 }
 764
 765 void wxTextCtrl::ChangeFont(bool keepOriginalSize)
 766 {
 767     wxWindow::ChangeFont(keepOriginalSize);
 768 }
 769
 770 void wxTextCtrl::ChangeBackgroundColour()
 771 {
 772     wxWindow::ChangeBackgroundColour();
 773
 774     /* TODO: should scrollbars be affected? Should probably have separate
 775     * function to change them (by default, taken from wxSystemSettings)
 776     */
 777     if (m_windowStyle & wxTE_MULTILINE)
 778     {
 779         Widget parent = XtParent ((Widget) m_mainWidget);
 780         Widget hsb, vsb;
 781
 782         XtVaGetValues (parent,
 783             XmNhorizontalScrollBar, &hsb,
 784             XmNverticalScrollBar, &vsb,
 785             NULL);
 786         wxColour backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE);
 787         if (hsb)
 788             DoChangeBackgroundColour((WXWidget) hsb, backgroundColour, TRUE);
 789         if (vsb)
 790             DoChangeBackgroundColour((WXWidget) vsb, backgroundColour, TRUE);
 791
 792         DoChangeBackgroundColour((WXWidget) parent, m_backgroundColour, TRUE);
 793     }
 794 }
 795
 796 void wxTextCtrl::ChangeForegroundColour()
 797 {
 798     wxWindow::ChangeForegroundColour();
 799
 800     if (m_windowStyle & wxTE_MULTILINE)
 801     {
 802         Widget parent = XtParent ((Widget) m_mainWidget);
 803         Widget hsb, vsb;
 804
 805         XtVaGetValues (parent,
 806             XmNhorizontalScrollBar, &hsb,
 807             XmNverticalScrollBar, &vsb,
 808             NULL);
 809
 810             /* TODO: should scrollbars be affected? Should probably have separate
 811             * function to change them (by default, taken from wxSystemSettings)
 812             if (hsb)
 813             DoChangeForegroundColour((WXWidget) hsb, m_foregroundColour);
 814             if (vsb)
 815             DoChangeForegroundColour((WXWidget) vsb, m_foregroundColour);
 816         */
 817         DoChangeForegroundColour((WXWidget) parent, m_foregroundColour);
 818     }
 819 }
 820
 821 void wxTextCtrl::DoSendEvents(void *wxcbs, long keycode)
 822 {
 823     // we're in process of updating the text control
 824     m_tempCallbackStruct = wxcbs;
 825
 826     XmTextVerifyCallbackStruct *cbs = (XmTextVerifyCallbackStruct *)wxcbs;
 827
 828     wxKeyEvent event (wxEVT_CHAR);
 829     event.SetId(GetId());
 830     event.m_keyCode = keycode;
 831     event.SetEventObject(this);
 832
 833     // Only if wxTextCtrl::OnChar is called will this be set to True (and
 834     // the character passed through)
 835     cbs->doit = False;
 836
 837     GetEventHandler()->ProcessEvent(event);
 838
 839     if ( !InSetValue() && m_processedDefault )
 840     {
 841         // Can generate a command
 842         wxCommandEvent commandEvent(wxEVT_COMMAND_TEXT_UPDATED, GetId());
 843         commandEvent.SetEventObject(this);
 844         ProcessCommand(commandEvent);
 845     }
 846
 847     // do it after the (user) event handlers processed the events because
 848     // otherwise GetValue() would return incorrect (not yet updated value)
 849     m_tempCallbackStruct = NULL;
 850 }
 851
 852 // ----------------------------------------------------------------------------
 853 // helpers and Motif callbacks
 854 // ----------------------------------------------------------------------------
 855
 856 static void MergeChangesIntoString(wxString& value,
 857                                    XmTextVerifyCallbackStruct *cbs)
 858 {
 859     /* _sm_
 860      * At least on my system (SunOS 4.1.3 + Motif 1.2), you need to think of
 861      * every event as a replace event.  cbs->text->ptr gives the replacement
 862      * text, cbs->startPos gives the index of the first char affected by the
 863      * replace, and cbs->endPos gives the index one more than the last char
 864      * affected by the replace (startPos == endPos implies an empty range).
 865      * Hence, a deletion is represented by replacing all input text with a
 866      * blank string ("", *not* NULL!).  A simple insertion that does not
 867      * overwrite any text has startPos == endPos.
 868      */
 869
 870     if ( !value )
 871     {
 872         // easy case: the ol value was empty
 873         value = cbs->text->ptr;
 874     }
 875     else
 876     {
 877         // merge the changes into the value
 878         const char * const passwd = value;
 879         int len = value.length();
 880
 881         len += strlen(cbs->text->ptr) + 1;     // + new text (if any) + NUL
 882         len -= cbs->endPos - cbs->startPos;    // - text from affected region.
 883
 884         char * newS = new char [len];
 885         char * dest = newS,
 886              * insert = cbs->text->ptr;
 887
 888         // Copy (old) text from passwd, up to the start posn of the change.
 889         int i;
 890         const char * p = passwd;
 891         for (i = 0; i < cbs->startPos; ++i)
 892             *dest++ = *p++;
 893
 894         // Copy the text to be inserted).
 895         while (*insert)
 896             *dest++ = *insert++;
 897
 898         // Finally, copy into newS any remaining text from passwd[endPos] on.
 899         for (p = passwd + cbs->endPos; *p; )
 900             *dest++ = *p++;
 901         *dest = 0;
 902
 903         value = newS;
 904
 905         delete[] newS;
 906     }
 907 }
 908
 909 static void
 910 wxTextWindowChangedProc (Widget w, XtPointer clientData, XtPointer ptr)
 911 {
 912     if (!wxGetWindowFromTable(w))
 913         // Widget has been deleted!
 914         return;
 915
 916     wxTextCtrl *tw = (wxTextCtrl *) clientData;
 917     tw->SetModified(TRUE);
 918 }
 919
 920 static void
 921 wxTextWindowModifyProc (Widget w, XtPointer clientData, XmTextVerifyCallbackStruct *cbs)
 922 {
 923     wxTextCtrl *tw = (wxTextCtrl *) clientData;
 924     tw->m_processedDefault = FALSE;
 925
 926     // First, do some stuff if it's a password control: in this case, we need
 927     // to store the string inside the class because GetValue() can't retrieve
 928     // it from the text ctrl. We do *not* do it in other circumstances because
 929     // it would double the amount of memory needed.
 930
 931     if ( tw->GetWindowStyleFlag() & wxTE_PASSWORD )
 932     {
 933         MergeChangesIntoString(tw->m_value, cbs);
 934
 935         if ( cbs->text->length > 0 )
 936         {
 937             int i;
 938             for (i = 0; i < cbs->text->length; ++i)
 939                 cbs->text->ptr[i] = '*';
 940             cbs->text->ptr[i] = '\0';
 941         }
 942     }
 943
 944     // If we're already within an OnChar, return: probably a programmatic
 945     // insertion.
 946     if (tw->m_tempCallbackStruct)
 947         return;
 948
 949     // Check for a backspace
 950     if (cbs->startPos == (cbs->currInsert - 1))
 951     {
 952         tw->DoSendEvents((void *)cbs, WXK_DELETE);
 953
 954         return;
 955     }
 956
 957     // Pasting operation: let it through without calling OnChar
 958     if (cbs->text->length > 1)
 959         return;
 960
 961     // Something other than text
 962     if (cbs->text->ptr == NULL)
 963         return;
 964
 965     // normal key press
 966     char ch = cbs->text->ptr[0];
 967     tw->DoSendEvents((void *)cbs, ch == '\n' ? '\r' : ch);
 968 }
 969
 970 static void
 971 wxTextWindowGainFocusProc (Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs)
 972 {
 973     if (!wxGetWindowFromTable(w))
 974         return;
 975
 976     wxTextCtrl *tw = (wxTextCtrl *) clientData;
 977     wxFocusEvent event(wxEVT_SET_FOCUS, tw->GetId());
 978     event.SetEventObject(tw);
 979     tw->GetEventHandler()->ProcessEvent(event);
 980 }
 981
 982 static void
 983 wxTextWindowLoseFocusProc (Widget w, XtPointer clientData, XmAnyCallbackStruct *cbs)
 984 {
 985     if (!wxGetWindowFromTable(w))
 986         return;
 987
 988     wxTextCtrl *tw = (wxTextCtrl *) clientData;
 989     wxFocusEvent event(wxEVT_KILL_FOCUS, tw->GetId());
 990     event.SetEventObject(tw);
 991     tw->GetEventHandler()->ProcessEvent(event);
 992 }
 993
 994 static void wxTextWindowActivateProc(Widget w, XtPointer clientData,
 995                                      XmAnyCallbackStruct *ptr)
 996 {
 997     if (!wxGetWindowFromTable(w))
 998         return;
 999
1000     wxTextCtrl *tw = (wxTextCtrl *) clientData;
1001
1002     if (tw->InSetValue())
1003         return;
1004
1005     wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER);
1006     event.SetId(tw->GetId());
1007     event.SetEventObject(tw);
1008     tw->ProcessCommand(event);
1009 }
1010
1011 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1012 {
1013     Cut();
1014 }
1015
1016 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1017 {
1018     Copy();
1019 }
1020
1021 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1022 {
1023     Paste();
1024 }
1025
1026 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1027 {
1028     Undo();
1029 }
1030
1031 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1032 {
1033     Redo();
1034 }
1035
1036 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1037 {
1038     event.Enable( CanCut() );
1039 }
1040
1041 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1042 {
1043     event.Enable( CanCopy() );
1044 }
1045
1046 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1047 {
1048     event.Enable( CanPaste() );
1049 }
1050
1051 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1052 {
1053     event.Enable( CanUndo() );
1054 }
1055
1056 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1057 {
1058     event.Enable( CanRedo() );
1059 }