src/mac/textctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        textctrl.cpp
   3 // Purpose:     wxTextCtrl
   4 // Author:      AUTHOR
   5 // Modified by:
   6 // Created:     ??/??/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) AUTHOR
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "textctrl.h"
  14 #endif
  15
  16 #ifdef __UNIX__
  17   #include <sys/types.h>
  18   #include <sys/stat.h>
  19 #else
  20   #include <stat.h>
  21 #endif
  22 #include <fstream.h>
  23
  24 #include "wx/app.h"
  25 #include "wx/dc.h"
  26 #include "wx/button.h"
  27 #include "wx/panel.h"
  28 #include "wx/textctrl.h"
  29 #include "wx/notebook.h"
  30 #include "wx/tabctrl.h"
  31 #include "wx/settings.h"
  32 #include "wx/filefn.h"
  33 #include "wx/utils.h"
  34
  35 #if defined(__BORLANDC__) && !defined(__WIN32__)
  36   #include <alloc.h>
  37 #elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__WXMAC_X__)
  38   #include <malloc.h>
  39 #endif
  40
  41 #include "wx/mac/uma.h"
  42
  43 #if !USE_SHARED_LIBRARY
  44 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
  45
  46 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
  47         EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
  48         EVT_CHAR(wxTextCtrl::OnChar)
  49     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
  50     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
  51     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
  52     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
  53     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
  54
  55     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
  56     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
  57     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
  58     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
  59     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
  60 END_EVENT_TABLE()
  61 #endif
  62
  63 // Text item
  64 wxTextCtrl::wxTextCtrl()
  65 {
  66 }
  67
  68 const short kVerticalMargin = 2 ;
  69 const short kHorizontalMargin = 2 ;
  70
  71 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
  72                    const wxString& st,
  73            const wxPoint& pos,
  74            const wxSize& size, long style,
  75            const wxValidator& validator,
  76            const wxString& name)
  77 {
  78     // base initialization
  79     if ( !CreateBase(parent, id, pos, size, style, validator, name) )
  80         return FALSE;
  81
  82         wxSize mySize = size ;
  83         if ( UMAHasAppearance() )
  84         {
  85                 m_macHorizontalBorder = 5 ; // additional pixels around the real control
  86                 m_macVerticalBorder = 5 ;
  87         }
  88         else
  89         {
  90                 m_macHorizontalBorder = 0 ; // additional pixels around the real control
  91                 m_macVerticalBorder = 0 ;
  92         }
  93
  94
  95         Rect bounds ;
  96         Str255 title ;
  97
  98         if ( mySize.y == -1 )
  99         {
 100                 if ( UMAHasAppearance() )
 101                         mySize.y = 13 ;
 102                 else
 103                         mySize.y = 24 ;
 104
 105                 mySize.y += 2 * m_macVerticalBorder ;
 106         }
 107
 108         MacPreControlCreate( parent , id ,  "" , pos , mySize ,style, validator , name , &bounds , title ) ;
 109
 110     if ( m_windowStyle & wxTE_MULTILINE )
 111     {
 112         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
 113                       wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
 114
 115         m_windowStyle |= wxTE_PROCESS_ENTER;
 116     }
 117
 118
 119         m_macControl = UMANewControl( parent->GetMacRootWindow() , &bounds , "\p" , true , 0 , 0 , 1,
 120                 ( style & wxTE_PASSWORD ) ? kControlEditTextPasswordProc : kControlEditTextProc , (long) this ) ;
 121         MacPostControlCreate() ;
 122
 123         wxString value ;
 124
 125         {
 126                 TEHandle teH ;
 127                 long size ;
 128
 129                 UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 130                 (*teH)->lineHeight = -1 ;
 131         }
 132
 133         if( wxApp::s_macDefaultEncodingIsPC )
 134                 value = wxMacMakeMacStringFromPC( st ) ;
 135         else
 136                 value = st ;
 137         UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
 138
 139   return TRUE;
 140 }
 141
 142 wxString wxTextCtrl::GetValue() const
 143 {
 144         Size actualsize;
 145         UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
 146         wxBuffer[actualsize] = 0 ;
 147         if( wxApp::s_macDefaultEncodingIsPC )
 148                 return wxMacMakePCStringFromMac( wxBuffer ) ;
 149         else
 150         return wxString(wxBuffer);
 151 }
 152
 153 void wxTextCtrl::GetSelection(long* from, long* to) const
 154 {
 155    ControlEditTextSelectionRec selection ;
 156    TEHandle teH ;
 157    long size ;
 158
 159    UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 160
 161     *from = (**teH).selStart;
 162     *to = (**teH).selEnd;
 163 }
 164
 165 void wxTextCtrl::SetValue(const wxString& st)
 166 {
 167         wxString value ;
 168
 169         if( wxApp::s_macDefaultEncodingIsPC )
 170                 value = wxMacMakeMacStringFromPC( st ) ;
 171         else
 172                 value = st ;
 173         UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
 174         WindowRef window = GetMacRootWindow() ;
 175         if ( window )
 176         {
 177                 wxWindow* win = wxFindWinFromMacWindow( window ) ;
 178                 if ( win )
 179                 {
 180                         wxMacDrawingHelper help( win ) ;
 181                         // the mac control manager always assumes to have the origin at 0,0
 182                         SetOrigin( 0 , 0 ) ;
 183
 184                         bool                    hasTabBehind = false ;
 185                         wxWindow* parent = GetParent() ;
 186                         while ( parent )
 187                         {
 188                                 if( parent->MacGetWindowData() )
 189                                 {
 190                                         UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , kThemeBrushDialogBackgroundActive , false ) ;
 191                                         break ;
 192                                 }
 193
 194                                 if( parent->IsKindOf( CLASSINFO( wxNotebook ) ) ||  parent->IsKindOf( CLASSINFO( wxTabCtrl ) ))
 195                                 {
 196                                         if ( ((wxControl*)parent)->GetMacControl() )
 197                                                 SetUpControlBackground( ((wxControl*)parent)->GetMacControl() , -1 , true ) ;
 198                                         break ;
 199                                 }
 200
 201                                 parent = parent->GetParent() ;
 202                         }
 203
 204                         UMADrawControl( m_macControl ) ;
 205                         UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , win->MacGetWindowData()->m_macWindowBackgroundTheme , false ) ;
 206                 }
 207         }
 208 }
 209
 210 // Clipboard operations
 211 void wxTextCtrl::Copy()
 212 {
 213     if (CanCopy())
 214     {
 215                 TEHandle teH ;
 216                 long size ;
 217
 218                  UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 219                 TECopy( teH ) ;
 220 #if TARGET_CARBON
 221                 OSStatus err ;
 222                 err = ClearCurrentScrap( );
 223 #else
 224                 OSErr err ;
 225                 err = ZeroScrap( );
 226 #endif
 227                 TEToScrap() ;
 228         }
 229 }
 230
 231 void wxTextCtrl::Cut()
 232 {
 233     if (CanCut())
 234     {
 235                 TEHandle teH ;
 236                 long size ;
 237
 238                 UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 239                 TECut( teH ) ;
 240 #if TARGET_CARBON
 241                 OSStatus err ;
 242                 err = ClearCurrentScrap( );
 243 #else
 244                 OSErr err ;
 245                 err = ZeroScrap( );
 246 #endif
 247                 TEToScrap() ;
 248                 //      MacInvalidateControl() ;
 249         }
 250 }
 251
 252 void wxTextCtrl::Paste()
 253 {
 254     if (CanPaste())
 255     {
 256                 TEHandle teH ;
 257                 long size ;
 258
 259                 UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 260                 TEFromScrap() ;
 261                 TEPaste( teH ) ;
 262                 WindowRef window = GetMacRootWindow() ;
 263                 if ( window )
 264                 {
 265                         wxWindow* win = wxFindWinFromMacWindow( window ) ;
 266                         if ( win )
 267                         {
 268                                 wxMacDrawingHelper help( win ) ;
 269                                 // the mac control manager always assumes to have the origin at 0,0
 270                                 SetOrigin( 0 , 0 ) ;
 271
 272                                 bool                    hasTabBehind = false ;
 273                                 wxWindow* parent = GetParent() ;
 274                                 while ( parent )
 275                                 {
 276                                         if( parent->MacGetWindowData() )
 277                                         {
 278                                                 UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , kThemeBrushDialogBackgroundActive , false ) ;
 279                                                 break ;
 280                                         }
 281
 282                                         if( parent->IsKindOf( CLASSINFO( wxNotebook ) ) ||  parent->IsKindOf( CLASSINFO( wxTabCtrl ) ))
 283                                         {
 284                                                 if ( ((wxControl*)parent)->GetMacControl() )
 285                                                         SetUpControlBackground( ((wxControl*)parent)->GetMacControl() , -1 , true ) ;
 286                                                 break ;
 287                                         }
 288
 289                                         parent = parent->GetParent() ;
 290                                 }
 291
 292                                 UMADrawControl( m_macControl ) ;
 293                                 UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , win->MacGetWindowData()->m_macWindowBackgroundTheme , false ) ;
 294                         }
 295                 }
 296         }
 297 }
 298
 299 bool wxTextCtrl::CanCopy() const
 300 {
 301     // Can copy if there's a selection
 302     long from, to;
 303     GetSelection(& from, & to);
 304     return (from != to);
 305 }
 306
 307 bool wxTextCtrl::CanCut() const
 308 {
 309     // Can cut if there's a selection
 310     long from, to;
 311     GetSelection(& from, & to);
 312     return (from != to);
 313 }
 314
 315 bool wxTextCtrl::CanPaste() const
 316 {
 317     if (!IsEditable())
 318         return FALSE;
 319
 320         long offset ;
 321 #if TARGET_CARBON
 322         OSStatus err = noErr;
 323         ScrapRef scrapRef;
 324
 325         err = GetCurrentScrap( &scrapRef );
 326         if ( err != noTypeErr && err != memFullErr )
 327         {
 328                 ScrapFlavorFlags        flavorFlags;
 329                 Size                            byteCount;
 330
 331                 if (( err = GetScrapFlavorFlags( scrapRef, 'TEXT', &flavorFlags )) == noErr)
 332                 {
 333                         if (( err = GetScrapFlavorSize( scrapRef, 'TEXT', &byteCount )) == noErr)
 334                         {
 335                                 return TRUE ;
 336                         }
 337                 }
 338         }
 339         return FALSE;
 340
 341 #else
 342         if ( GetScrap( NULL , 'TEXT' , &offset ) > 0 )
 343         {
 344                 return TRUE ;
 345         }
 346 #endif
 347         return FALSE ;
 348 }
 349
 350 void wxTextCtrl::SetEditable(bool editable)
 351 {
 352     if ( editable )
 353         UMAActivateControl( m_macControl ) ;
 354     else
 355         UMADeactivateControl( m_macControl ) ;
 356 }
 357
 358 void wxTextCtrl::SetInsertionPoint(long pos)
 359 {
 360         SetSelection( pos , pos ) ;
 361 }
 362
 363 void wxTextCtrl::SetInsertionPointEnd()
 364 {
 365     long pos = GetLastPosition();
 366     SetInsertionPoint(pos);
 367 }
 368
 369 long wxTextCtrl::GetInsertionPoint() const
 370 {
 371    ControlEditTextSelectionRec selection ;
 372    TEHandle teH ;
 373    long size ;
 374
 375    UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 376 //   UMAGetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection , &size ) ;
 377     return (**teH).selStart ;
 378 }
 379
 380 long wxTextCtrl::GetLastPosition() const
 381 {
 382    ControlEditTextSelectionRec selection ;
 383    TEHandle teH ;
 384    long size ;
 385
 386    UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 387
 388 //   UMAGetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection , &size ) ;
 389     return (**teH).teLength ;
 390 }
 391
 392 void wxTextCtrl::Replace(long from, long to, const wxString& value)
 393 {
 394         TEHandle teH ;
 395         long size ;
 396
 397         ControlEditTextSelectionRec selection ;
 398
 399         selection.selStart = from ;
 400         selection.selEnd = to ;
 401         UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
 402                 UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 403         TESetSelect( from , to  , teH ) ;
 404         TEDelete( teH ) ;
 405                 TEInsert( value , value.Length() , teH ) ;
 406         Refresh() ;
 407 }
 408
 409 void wxTextCtrl::Remove(long from, long to)
 410 {
 411         TEHandle teH ;
 412         long size ;
 413
 414         ControlEditTextSelectionRec selection ;
 415
 416         selection.selStart = from ;
 417         selection.selEnd = to ;
 418         UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
 419         UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 420         TEDelete( teH ) ;
 421         Refresh() ;
 422 }
 423
 424 void wxTextCtrl::SetSelection(long from, long to)
 425 {
 426    ControlEditTextSelectionRec selection ;
 427    TEHandle teH ;
 428    long size ;
 429
 430    UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 431
 432    selection.selStart = from ;
 433    selection.selEnd = to ;
 434
 435    UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
 436    TESetSelect( selection.selStart , selection.selEnd , teH ) ;
 437 }
 438
 439 bool wxTextCtrl::LoadFile(const wxString& file)
 440 {
 441     if ( wxTextCtrlBase::LoadFile(file) )
 442     {
 443         return TRUE;
 444     }
 445
 446     return FALSE;
 447 }
 448
 449 void wxTextCtrl::WriteText(const wxString& text)
 450 {
 451     TEHandle teH ;
 452     long size ;
 453
 454         memcpy( wxBuffer, text , text.Length() ) ;
 455         wxBuffer[text.Length() ] = 0 ;
 456 //    wxMacConvertNewlines( wxBuffer , wxBuffer ) ;
 457
 458     UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
 459
 460                 TEInsert( wxBuffer , strlen( wxBuffer) , teH ) ;
 461                 Refresh() ;
 462 }
 463
 464 void wxTextCtrl::AppendText(const wxString& text)
 465 {
 466     SetInsertionPointEnd();
 467     WriteText(text);
 468 }
 469
 470 void wxTextCtrl::Clear()
 471 {
 472         UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char*) ((const char*)NULL) ) ;
 473         Refresh() ;
 474 }
 475
 476 bool wxTextCtrl::IsModified() const
 477 {
 478     return TRUE;
 479 }
 480
 481 bool wxTextCtrl::IsEditable() const
 482 {
 483     return IsEnabled();
 484 }
 485
 486 bool wxTextCtrl::AcceptsFocus() const
 487 {
 488     // we don't want focus if we can't be edited
 489     return IsEditable() && wxControl::AcceptsFocus();
 490 }
 491
 492 wxSize wxTextCtrl::DoGetBestSize() const
 493 {
 494     int wText = 100 ;
 495
 496     int hText ;
 497                 if ( UMAHasAppearance() )
 498                         hText = 13 ;
 499                 else
 500                         hText = 24 ;
 501         hText += 2 * m_macHorizontalBorder ;
 502 /*
 503     int cx, cy;
 504     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
 505
 506     int wText = DEFAULT_ITEM_WIDTH;
 507
 508     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
 509
 510     return wxSize(wText, hText);
 511 */
 512     if ( m_windowStyle & wxTE_MULTILINE )
 513     {
 514         hText *= wxMin(GetNumberOfLines(), 5);
 515     }
 516     //else: for single line control everything is ok
 517     return wxSize(wText, hText);
 518 }
 519
 520 // ----------------------------------------------------------------------------
 521 // Undo/redo
 522 // ----------------------------------------------------------------------------
 523
 524 void wxTextCtrl::Undo()
 525 {
 526     if (CanUndo())
 527     {
 528     }
 529 }
 530
 531 void wxTextCtrl::Redo()
 532 {
 533     if (CanRedo())
 534     {
 535     }
 536 }
 537
 538 bool wxTextCtrl::CanUndo() const
 539 {
 540     return FALSE ;
 541 }
 542
 543 bool wxTextCtrl::CanRedo() const
 544 {
 545     return FALSE ;
 546 }
 547
 548 // Makes 'unmodified'
 549 void wxTextCtrl::DiscardEdits()
 550 {
 551     // TODO
 552 }
 553
 554 int wxTextCtrl::GetNumberOfLines() const
 555 {
 556     // TODO
 557     return 0;
 558 }
 559
 560 long wxTextCtrl::XYToPosition(long x, long y) const
 561 {
 562     // TODO
 563     return 0;
 564 }
 565
 566 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
 567 {
 568     return FALSE ;
 569 }
 570
 571 void wxTextCtrl::ShowPosition(long pos)
 572 {
 573     // TODO
 574 }
 575
 576 int wxTextCtrl::GetLineLength(long lineNo) const
 577 {
 578     return GetValue().Length();
 579 }
 580
 581 wxString wxTextCtrl::GetLineText(long lineNo) const
 582 {
 583     return GetValue();
 584 }
 585
 586 /*
 587  * Text item
 588  */
 589
 590 void wxTextCtrl::Command(wxCommandEvent & event)
 591 {
 592     SetValue (event.GetString());
 593     ProcessCommand (event);
 594 }
 595
 596 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
 597 {
 598     // By default, load the first file into the text window.
 599     if (event.GetNumberOfFiles() > 0)
 600     {
 601         LoadFile(event.GetFiles()[0]);
 602     }
 603 }
 604
 605 void wxTextCtrl::OnChar(wxKeyEvent& event)
 606 {
 607     switch ( event.KeyCode() )
 608     {
 609         case WXK_RETURN:
 610                 if (m_windowStyle & wxPROCESS_ENTER)
 611                 {
 612                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
 613                 event.SetEventObject( this );
 614                 if ( GetEventHandler()->ProcessEvent(event) )
 615                     return;
 616                 }
 617             if ( !(m_windowStyle & wxTE_MULTILINE) )
 618             {
 619                         wxWindow *parent = GetParent();
 620                         wxPanel *panel = wxDynamicCast(parent, wxPanel);
 621                         while ( parent != NULL && panel == NULL )
 622                         {
 623                                 parent = parent->GetParent() ;
 624                                 panel = wxDynamicCast(parent, wxPanel);
 625                         }
 626                         if ( panel && panel->GetDefaultItem() )
 627                         {
 628                                 wxButton *def = panel->GetDefaultItem() ;
 629                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
 630                                         event.SetEventObject(def);
 631                                         def->Command(event);
 632                         event.Skip() ;
 633                         return ;
 634                         }
 635             }
 636             //else: multiline controls need Enter for themselves
 637
 638             break;
 639
 640         case WXK_TAB:
 641             // always produce navigation event - even if we process TAB
 642             // ourselves the fact that we got here means that the user code
 643             // decided to skip processing of this TAB - probably to let it
 644             // do its default job.
 645             {
 646                 wxNavigationKeyEvent eventNav;
 647                 eventNav.SetDirection(!event.ShiftDown());
 648                 eventNav.SetWindowChange(event.ControlDown());
 649                 eventNav.SetEventObject(this);
 650
 651                 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
 652                     return;
 653                 event.Skip() ;
 654                 return ;
 655             }
 656             break;
 657     }
 658
 659         EventRecord *ev = wxTheApp->MacGetCurrentEvent() ;
 660         short keycode ;
 661         short keychar ;
 662         keychar = short(ev->message & charCodeMask);
 663         keycode = short(ev->message & keyCodeMask) >> 8 ;
 664         UMAHandleControlKey( m_macControl , keycode , keychar , ev->modifiers ) ;
 665         if ( keychar >= 0x20 || event.KeyCode() == WXK_RETURN || event.KeyCode() == WXK_DELETE || event.KeyCode() == WXK_BACK)
 666         {
 667         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
 668         event.SetString( GetValue() ) ;
 669         event.SetEventObject( this );
 670         GetEventHandler()->ProcessEvent(event);
 671         }
 672
 673 }
 674
 675 // ----------------------------------------------------------------------------
 676 // standard handlers for standard edit menu events
 677 // ----------------------------------------------------------------------------
 678
 679 void wxTextCtrl::OnCut(wxCommandEvent& event)
 680 {
 681     Cut();
 682 }
 683
 684 void wxTextCtrl::OnCopy(wxCommandEvent& event)
 685 {
 686     Copy();
 687 }
 688
 689 void wxTextCtrl::OnPaste(wxCommandEvent& event)
 690 {
 691     Paste();
 692 }
 693
 694 void wxTextCtrl::OnUndo(wxCommandEvent& event)
 695 {
 696     Undo();
 697 }
 698
 699 void wxTextCtrl::OnRedo(wxCommandEvent& event)
 700 {
 701     Redo();
 702 }
 703
 704 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
 705 {
 706     event.Enable( CanCut() );
 707 }
 708
 709 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
 710 {
 711     event.Enable( CanCopy() );
 712 }
 713
 714 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
 715 {
 716     event.Enable( CanPaste() );
 717 }
 718
 719 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
 720 {
 721     event.Enable( CanUndo() );
 722 }
 723
 724 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
 725 {
 726     event.Enable( CanRedo() );
 727 }
 728