src/mac/classic/textctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        textctrl.cpp
   3 // Purpose:     wxTextCtrl
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     1998-01-01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "textctrl.h"
  14 #endif
  15
  16 #include "wx/defs.h"
  17
  18 #if wxUSE_TEXTCTRL
  19
  20 #ifdef __DARWIN__
  21   #include <sys/types.h>
  22   #include <sys/stat.h>
  23 #else
  24   #include <stat.h>
  25 #endif
  26
  27 #include "wx/msgdlg.h"
  28
  29 #if wxUSE_STD_IOSTREAM
  30     #if wxUSE_IOSTREAMH
  31         #include <fstream.h>
  32     #else
  33         #include <fstream>
  34     #endif
  35 #endif
  36
  37 #include "wx/app.h"
  38 #include "wx/dc.h"
  39 #include "wx/button.h"
  40 #include "wx/toplevel.h"
  41 #include "wx/textctrl.h"
  42 #include "wx/notebook.h"
  43 #include "wx/tabctrl.h"
  44 #include "wx/settings.h"
  45 #include "wx/filefn.h"
  46 #include "wx/utils.h"
  47
  48 #if defined(__BORLANDC__) && !defined(__WIN32__)
  49   #include <alloc.h>
  50 #elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
  51   #include <malloc.h>
  52 #endif
  53
  54 #ifndef __DARWIN__
  55 #include <Scrap.h>
  56 #endif
  57 #include <MacTextEditor.h>
  58 #include <ATSUnicode.h>
  59 #include <TextCommon.h>
  60 #include <TextEncodingConverter.h>
  61 #include "wx/mac/uma.h"
  62
  63 #define TE_UNLIMITED_LENGTH 0xFFFFFFFFUL
  64
  65 extern wxControl *wxFindControlFromMacControl(ControlHandle inControl ) ;
  66
  67 // CS:TODO we still have a problem getting properly at the text events of a control because under Carbon
  68 // the MLTE engine registers itself for the key events thus the normal flow never occurs, the only measure for the
  69 // moment is to avoid setting the true focus on the control, the proper solution at the end would be to have
  70 // an alternate path for carbon key events that routes automatically into the same wx flow of events
  71
  72 /* part codes */
  73
  74 /* kmUPTextPart is the part code we return to indicate the user has clicked
  75     in the text area of our control */
  76 #define kmUPTextPart 1
  77
  78 /* kmUPScrollPart is the part code we return to indicate the user has clicked
  79     in the scroll bar part of the control. */
  80 #define kmUPScrollPart 2
  81
  82
  83 /* routines for using existing user pane controls.
  84     These routines are useful for cases where you would like to use an
  85     existing user pane control in, say, a dialog window as a scrolling
  86     text edit field.*/
  87
  88 /* mUPOpenControl initializes a user pane control so it will be drawn
  89     and will behave as a scrolling text edit field inside of a window.
  90     This routine performs all of the initialization steps necessary,
  91     except it does not create the user pane control itself.  theControl
  92     should refer to a user pane control that you have either created
  93     yourself or extracted from a dialog's control heirarchy using
  94     the GetDialogItemAsControl routine.  */
  95 OSStatus mUPOpenControl(ControlHandle theControl, long wxStyle);
  96
  97 /* Utility Routines */
  98
  99 enum {
 100     kShiftKeyCode = 56
 101 };
 102
 103 /* kUserClickedToFocusPart is a part code we pass to the SetKeyboardFocus
 104     routine.  In our focus switching routine this part code is understood
 105     as meaning 'the user has clicked in the control and we need to switch
 106     the current focus to ourselves before we can continue'. */
 107 #define kUserClickedToFocusPart 100
 108
 109
 110 /* kmUPClickScrollDelayTicks is a time measurement in ticks used to
 111     slow the speed of 'auto scrolling' inside of our clickloop routine.
 112     This value prevents the text from wizzzzzing by while the mouse
 113     is being held down inside of the text area. */
 114 #define kmUPClickScrollDelayTicks 3
 115
 116
 117 /* STPTextPaneVars is a structure used for storing the the mUP Control's
 118     internal variables and state information.  A handle to this record is
 119     stored in the pane control's reference value field using the
 120     SetControlReference routine. */
 121
 122 typedef struct {
 123         /* OS records referenced */
 124     TXNObject fTXNRec; /* the txn record */
 125     TXNFrameID fTXNFrame; /* the txn frame ID */
 126     ControlHandle fUserPaneRec;  /* handle to the user pane control */
 127     WindowPtr fOwner; /* window containing control */
 128     GrafPtr fDrawingEnvironment; /* grafport where control is drawn */
 129         /* flags */
 130     Boolean fInFocus; /* true while the focus rect is drawn around the control */
 131     Boolean fIsActive; /* true while the control is drawn in the active state */
 132     Boolean fTEActive; /* reflects the activation state of the text edit record */
 133     Boolean fInDialogWindow; /* true if displayed in a dialog window */
 134         /* calculated locations */
 135     Rect fRTextArea; /* area where the text is drawn */
 136     Rect fRFocusOutline;  /* rectangle used to draw the focus box */
 137     Rect fRTextOutline; /* rectangle used to draw the border */
 138     RgnHandle fTextBackgroundRgn; /* background region for the text, erased before calling TEUpdate */
 139         /* our focus advance override routine */
 140     EventHandlerUPP handlerUPP;
 141     EventHandlerRef handlerRef;
 142     bool fMultiline ;
 143 } STPTextPaneVars;
 144
 145
 146
 147
 148 /* Univerals Procedure Pointer variables used by the
 149     mUP Control.  These variables are set up
 150     the first time that mUPOpenControl is called. */
 151 ControlUserPaneDrawUPP gTPDrawProc = NULL;
 152 ControlUserPaneHitTestUPP gTPHitProc = NULL;
 153 ControlUserPaneTrackingUPP gTPTrackProc = NULL;
 154 ControlUserPaneIdleUPP gTPIdleProc = NULL;
 155 ControlUserPaneKeyDownUPP gTPKeyProc = NULL;
 156 ControlUserPaneActivateUPP gTPActivateProc = NULL;
 157 ControlUserPaneFocusUPP gTPFocusProc = NULL;
 158
 159 /* TPActivatePaneText activates or deactivates the text edit record
 160     according to the value of setActive.  The primary purpose of this
 161     routine is to ensure each call is only made once. */
 162 static void TPActivatePaneText(STPTextPaneVars **tpvars, Boolean setActive) {
 163     STPTextPaneVars *varsp;
 164     varsp = *tpvars;
 165     if (varsp->fTEActive != setActive) {
 166
 167         varsp->fTEActive = setActive;
 168
 169         TXNActivate(varsp->fTXNRec, varsp->fTXNFrame, varsp->fTEActive);
 170
 171         if (varsp->fInFocus)
 172             TXNFocus( varsp->fTXNRec, varsp->fTEActive);
 173     }
 174 }
 175
 176
 177 /* TPFocusPaneText set the focus state for the text record. */
 178 static void TPFocusPaneText(STPTextPaneVars **tpvars, Boolean setFocus) {
 179     STPTextPaneVars *varsp;
 180     varsp = *tpvars;
 181     if (varsp->fInFocus != setFocus) {
 182         varsp->fInFocus = setFocus;
 183         TXNFocus( varsp->fTXNRec, varsp->fInFocus);
 184     }
 185 }
 186
 187
 188 /* TPPaneDrawProc is called to redraw the control and for update events
 189     referring to the control.  This routine erases the text area's background,
 190     and redraws the text.  This routine assumes the scroll bar has been
 191     redrawn by a call to DrawControls. */
 192 static pascal void TPPaneDrawProc(ControlRef theControl, ControlPartCode thePart) {
 193     STPTextPaneVars **tpvars, *varsp;
 194     char state;
 195     Rect bounds;
 196         /* set up our globals */
 197
 198     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 199     if (tpvars != NULL) {
 200         state = HGetState((Handle) tpvars);
 201         HLock((Handle) tpvars);
 202         varsp = *tpvars;
 203
 204             /* save the drawing state */
 205         SetPort((**tpvars).fDrawingEnvironment);
 206            /* verify our boundary */
 207         GetControlBounds(theControl, &bounds);
 208
 209         wxMacWindowClipper clipper( wxFindControlFromMacControl(theControl ) ) ;
 210         if ( ! EqualRect(&bounds, &varsp->fRFocusOutline) ) {
 211             // scrollbar is on the border, we add one
 212             Rect oldbounds = varsp->fRFocusOutline ;
 213             InsetRect( &oldbounds , -1 , -1 ) ;
 214
 215             if ( IsControlVisible( theControl ) )
 216                 InvalWindowRect( GetControlOwner( theControl ) , &oldbounds ) ;
 217             SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
 218             SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
 219             SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) ,
 220                 bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
 221             RectRgn(varsp->fTextBackgroundRgn, &varsp->fRTextOutline);
 222             if ( IsControlVisible( theControl ) )
 223                 TXNSetFrameBounds(  varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
 224                     varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
 225             else
 226                 TXNSetFrameBounds(  varsp->fTXNRec, varsp->fRTextArea.top + 30000 , varsp->fRTextArea.left + 30000 ,
 227                     varsp->fRTextArea.bottom + 30000 , varsp->fRTextArea.right + 30000 , varsp->fTXNFrame);
 228
 229         }
 230
 231         if ( IsControlVisible( theControl ) )
 232         {
 233             /* update the text region */
 234             RGBColor white = { 65535 , 65535 , 65535 } ;
 235             RGBBackColor( &white ) ;
 236             EraseRgn(varsp->fTextBackgroundRgn);
 237             TXNDraw(varsp->fTXNRec, NULL);
 238                 /* restore the drawing environment */
 239                 /* draw the text frame and focus frame (if necessary) */
 240             DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
 241             if ((**tpvars).fIsActive && varsp->fInFocus)
 242                 DrawThemeFocusRect(&varsp->fRFocusOutline, true);
 243                 /* release our globals */
 244             HSetState((Handle) tpvars, state);
 245         }
 246     }
 247 }
 248
 249
 250 /* TPPaneHitTestProc is called when the control manager would
 251     like to determine what part of the control the mouse resides over.
 252     We also call this routine from our tracking proc to determine how
 253     to handle mouse clicks. */
 254 static pascal ControlPartCode TPPaneHitTestProc(ControlHandle theControl, Point where) {
 255     STPTextPaneVars **tpvars;
 256     ControlPartCode result;
 257     char state;
 258         /* set up our locals and lock down our globals*/
 259     result = 0;
 260     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 261     if (tpvars != NULL && IsControlVisible( theControl) ) {
 262         state = HGetState((Handle) tpvars);
 263         HLock((Handle) tpvars);
 264             /* find the region where we clicked */
 265         if (PtInRect(where, &(**tpvars).fRTextArea)) {
 266             result = kmUPTextPart;
 267         } else result = 0;
 268             /* release oure globals */
 269         HSetState((Handle) tpvars, state);
 270     }
 271     return result;
 272 }
 273
 274
 275
 276
 277
 278 /* TPPaneTrackingProc is called when the mouse is being held down
 279     over our control.  This routine handles clicks in the text area
 280     and in the scroll bar. */
 281 static pascal ControlPartCode TPPaneTrackingProc(ControlHandle theControl, Point startPt, ControlActionUPP actionProc) {
 282     STPTextPaneVars **tpvars, *varsp;
 283     char state;
 284     ControlPartCode partCodeResult;
 285         /* make sure we have some variables... */
 286     partCodeResult = 0;
 287     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 288     if (tpvars != NULL && IsControlVisible( theControl ) ) {
 289             /* lock 'em down */
 290         state = HGetState((Handle) tpvars);
 291         HLock((Handle) tpvars);
 292         varsp = *tpvars;
 293             /* we don't do any of these functions unless we're in focus */
 294         if ( ! varsp->fInFocus) {
 295             WindowPtr owner;
 296             owner = GetControlOwner(theControl);
 297             ClearKeyboardFocus(owner);
 298             SetKeyboardFocus(owner, theControl, kUserClickedToFocusPart);
 299         }
 300             /* find the location for the click */
 301         switch (TPPaneHitTestProc(theControl, startPt)) {
 302
 303                 /* handle clicks in the text part */
 304             case kmUPTextPart:
 305                 {   SetPort((**tpvars).fDrawingEnvironment);
 306                     wxMacWindowClipper clipper( wxFindControlFromMacControl(theControl ) ) ;
 307 #if !TARGET_CARBON
 308                     TXNClick( varsp->fTXNRec, (const EventRecord*) wxTheApp->MacGetCurrentEvent());
 309 #else
 310                     EventRecord rec ;
 311                     ConvertEventRefToEventRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) ;
 312                     TXNClick( varsp->fTXNRec, &rec );
 313 #endif
 314                 }
 315                 break;
 316
 317         }
 318
 319         HSetState((Handle) tpvars, state);
 320     }
 321     return partCodeResult;
 322 }
 323
 324
 325 /* TPPaneIdleProc is our user pane idle routine.  When our text field
 326     is active and in focus, we use this routine to set the cursor. */
 327 static pascal void TPPaneIdleProc(ControlHandle theControl) {
 328     STPTextPaneVars **tpvars, *varsp;
 329         /* set up locals */
 330     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 331     if (tpvars != NULL && IsControlVisible( theControl ) ) {
 332             /* if we're not active, then we have nothing to say about the cursor */
 333         if ((**tpvars).fIsActive) {
 334             char state;
 335             Rect bounds;
 336             Point mousep;
 337                 /* lock down the globals */
 338             state = HGetState((Handle) tpvars);
 339             HLock((Handle) tpvars);
 340             varsp = *tpvars;
 341                 /* get the current mouse coordinates (in our window) */
 342             SetPortWindowPort(GetControlOwner(theControl));
 343             wxMacWindowClipper clipper( wxFindControlFromMacControl(theControl ) ) ;
 344             GetMouse(&mousep);
 345                 /* there's a 'focus thing' and an 'unfocused thing' */
 346             if (varsp->fInFocus) {
 347                     /* flash the cursor */
 348                 SetPort((**tpvars).fDrawingEnvironment);
 349                 TXNIdle(varsp->fTXNRec);
 350                 /* set the cursor */
 351                 if (PtInRect(mousep, &varsp->fRTextArea)) {
 352                     RgnHandle theRgn;
 353                     RectRgn((theRgn = NewRgn()), &varsp->fRTextArea);
 354                     TXNAdjustCursor(varsp->fTXNRec, theRgn);
 355                     DisposeRgn(theRgn);
 356                  }
 357                  else
 358                  {
 359                  // SetThemeCursor(kThemeArrowCursor);
 360                  }
 361             } else {
 362                 /* if it's in our bounds, set the cursor */
 363                 GetControlBounds(theControl, &bounds);
 364                 if (PtInRect(mousep, &bounds))
 365                 {
 366                 //    SetThemeCursor(kThemeArrowCursor);
 367                 }
 368             }
 369
 370             HSetState((Handle) tpvars, state);
 371         }
 372     }
 373 }
 374
 375
 376 /* TPPaneKeyDownProc is called whenever a keydown event is directed
 377     at our control.  Here, we direct the keydown event to the text
 378     edit record and redraw the scroll bar and text field as appropriate. */
 379 static pascal ControlPartCode TPPaneKeyDownProc(ControlHandle theControl,
 380                             SInt16 keyCode, SInt16 charCode, SInt16 modifiers) {
 381     STPTextPaneVars **tpvars;
 382     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 383     if (tpvars != NULL) {
 384         if ((**tpvars).fInFocus) {
 385                 /* turn autoscrolling on and send the key event to text edit */
 386             SetPort((**tpvars).fDrawingEnvironment);
 387             wxMacWindowClipper clipper( wxFindControlFromMacControl(theControl ) ) ;
 388             EventRecord ev ;
 389             memset( &ev , 0 , sizeof( ev ) ) ;
 390             ev.what = keyDown ;
 391             ev.modifiers = modifiers ;
 392             ev.message = (( keyCode << 8 ) & keyCodeMask ) + ( charCode & charCodeMask ) ;
 393             TXNKeyDown( (**tpvars).fTXNRec, &ev);
 394         }
 395     }
 396     return kControlEntireControl;
 397 }
 398
 399
 400 /* TPPaneActivateProc is called when the window containing
 401     the user pane control receives activate events. Here, we redraw
 402     the control and it's text as necessary for the activation state. */
 403 static pascal void TPPaneActivateProc(ControlHandle theControl, Boolean activating) {
 404     Rect bounds;
 405     STPTextPaneVars **tpvars, *varsp;
 406     char state;
 407         /* set up locals */
 408     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 409     if (tpvars != NULL) {
 410         state = HGetState((Handle) tpvars);
 411         HLock((Handle) tpvars);
 412         varsp = *tpvars;
 413             /* de/activate the text edit record */
 414         SetPort((**tpvars).fDrawingEnvironment);
 415         wxMacWindowClipper clipper( wxFindControlFromMacControl(theControl ) ) ;
 416         GetControlBounds(theControl, &bounds);
 417         varsp->fIsActive = activating;
 418         TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
 419             /* redraw the frame */
 420         if ( IsControlVisible( theControl ) )
 421         {
 422             DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
 423             if (varsp->fInFocus)
 424                 DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fIsActive);
 425         }
 426         HSetState((Handle) tpvars, state);
 427     }
 428 }
 429
 430
 431 /* TPPaneFocusProc is called when every the focus changes to or
 432     from our control.  Herein, switch the focus appropriately
 433     according to the parameters and redraw the control as
 434     necessary.  */
 435 static pascal ControlPartCode TPPaneFocusProc(ControlHandle theControl, ControlFocusPart action) {
 436     ControlPartCode focusResult;
 437     STPTextPaneVars **tpvars, *varsp;
 438     char state;
 439         /* set up locals */
 440     focusResult = kControlFocusNoPart;
 441     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 442     if (tpvars != NULL ) {
 443         state = HGetState((Handle) tpvars);
 444         HLock((Handle) tpvars);
 445         varsp = *tpvars;
 446             /* if kControlFocusPrevPart and kControlFocusNextPart are received when the user is
 447             tabbing forwards (or shift tabbing backwards) through the items in the dialog,
 448             and kControlFocusNextPart will be received.  When the user clicks in our field
 449             and it is not the current focus, then the constant kUserClickedToFocusPart will
 450             be received.  The constant kControlFocusNoPart will be received when our control
 451             is the current focus and the user clicks in another control.  In your focus routine,
 452             you should respond to these codes as follows:
 453
 454             kControlFocusNoPart - turn off focus and return kControlFocusNoPart.  redraw
 455                 the control and the focus rectangle as necessary.
 456
 457             kControlFocusPrevPart or kControlFocusNextPart - toggle focus on or off
 458                 depending on its current state.  redraw the control and the focus rectangle
 459                 as appropriate for the new focus state.  If the focus state is 'off', return the constant
 460                 kControlFocusNoPart, otherwise return a non-zero part code.
 461             kUserClickedToFocusPart - is a constant defined for this example.  You should
 462                 define your own value for handling click-to-focus type events. */
 463              /* calculate the next highlight state */
 464         switch (action) {
 465             default:
 466             case kControlFocusNoPart:
 467                 TPFocusPaneText(tpvars, false);
 468                 focusResult = kControlFocusNoPart;
 469                 break;
 470             case kUserClickedToFocusPart:
 471                 TPFocusPaneText(tpvars, true);
 472                 focusResult = 1;
 473                 break;
 474             case kControlFocusPrevPart:
 475             case kControlFocusNextPart:
 476                 TPFocusPaneText(tpvars, ( ! varsp->fInFocus));
 477                 focusResult = varsp->fInFocus ? 1 : kControlFocusNoPart;
 478                 break;
 479         }
 480         TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
 481         /* redraw the text fram and focus rectangle to indicate the
 482         new focus state */
 483         if ( IsControlVisible( theControl ) )
 484         {
 485            /* save the drawing state */
 486             SetPort((**tpvars).fDrawingEnvironment);
 487             wxMacWindowClipper clipper( wxFindControlFromMacControl(theControl ) ) ;
 488             DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
 489             DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fIsActive && varsp->fInFocus);
 490         }
 491             /* done */
 492         HSetState((Handle) tpvars, state);
 493     }
 494     return focusResult;
 495 }
 496
 497
 498 /* mUPOpenControl initializes a user pane control so it will be drawn
 499     and will behave as a scrolling text edit field inside of a window.
 500     This routine performs all of the initialization steps necessary,
 501     except it does not create the user pane control itself.  theControl
 502     should refer to a user pane control that you have either created
 503     yourself or extracted from a dialog's control heirarchy using
 504     the GetDialogItemAsControl routine.  */
 505 OSStatus mUPOpenControl(ControlHandle theControl, long wxStyle )
 506 {
 507     Rect bounds;
 508     WindowRef theWindow;
 509     STPTextPaneVars **tpvars, *varsp;
 510     OSStatus err = noErr ;
 511     RGBColor rgbWhite = {0xFFFF, 0xFFFF, 0xFFFF};
 512     TXNBackground tback;
 513
 514         /* set up our globals */
 515     if (gTPDrawProc == NULL) gTPDrawProc = NewControlUserPaneDrawUPP(TPPaneDrawProc);
 516     if (gTPHitProc == NULL) gTPHitProc = NewControlUserPaneHitTestUPP(TPPaneHitTestProc);
 517     if (gTPTrackProc == NULL) gTPTrackProc = NewControlUserPaneTrackingUPP(TPPaneTrackingProc);
 518     if (gTPIdleProc == NULL) gTPIdleProc = NewControlUserPaneIdleUPP(TPPaneIdleProc);
 519     if (gTPKeyProc == NULL) gTPKeyProc = NewControlUserPaneKeyDownUPP(TPPaneKeyDownProc);
 520     if (gTPActivateProc == NULL) gTPActivateProc = NewControlUserPaneActivateUPP(TPPaneActivateProc);
 521     if (gTPFocusProc == NULL) gTPFocusProc = NewControlUserPaneFocusUPP(TPPaneFocusProc);
 522
 523         /* allocate our private storage */
 524     tpvars = (STPTextPaneVars **) NewHandleClear(sizeof(STPTextPaneVars));
 525     SetControlReference(theControl, (long) tpvars);
 526     HLock((Handle) tpvars);
 527     varsp = *tpvars;
 528         /* set the initial settings for our private data */
 529     varsp->fMultiline = wxStyle & wxTE_MULTILINE ;
 530     varsp->fInFocus = false;
 531     varsp->fIsActive = true;
 532     varsp->fTEActive = true; // in order to get a deactivate
 533     varsp->fUserPaneRec = theControl;
 534     theWindow = varsp->fOwner = GetControlOwner(theControl);
 535
 536     varsp->fDrawingEnvironment = (GrafPtr)  GetWindowPort(theWindow);
 537
 538     varsp->fInDialogWindow = ( GetWindowKind(varsp->fOwner) == kDialogWindowKind );
 539         /* set up the user pane procedures */
 540     SetControlData(theControl, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(gTPDrawProc), &gTPDrawProc);
 541     SetControlData(theControl, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(gTPHitProc), &gTPHitProc);
 542     SetControlData(theControl, kControlEntireControl, kControlUserPaneTrackingProcTag, sizeof(gTPTrackProc), &gTPTrackProc);
 543     SetControlData(theControl, kControlEntireControl, kControlUserPaneIdleProcTag, sizeof(gTPIdleProc), &gTPIdleProc);
 544     SetControlData(theControl, kControlEntireControl, kControlUserPaneKeyDownProcTag, sizeof(gTPKeyProc), &gTPKeyProc);
 545     SetControlData(theControl, kControlEntireControl, kControlUserPaneActivateProcTag, sizeof(gTPActivateProc), &gTPActivateProc);
 546     SetControlData(theControl, kControlEntireControl, kControlUserPaneFocusProcTag, sizeof(gTPFocusProc), &gTPFocusProc);
 547         /* calculate the rectangles used by the control */
 548     GetControlBounds(theControl, &bounds);
 549     SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
 550     SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
 551     SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) ,
 552         bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
 553         /* calculate the background region for the text.  In this case, it's kindof
 554         and irregular region because we're setting the scroll bar a little ways inside
 555         of the text area. */
 556     RectRgn((varsp->fTextBackgroundRgn = NewRgn()), &varsp->fRTextOutline);
 557
 558         /* set up the drawing environment */
 559     SetPort(varsp->fDrawingEnvironment);
 560
 561         /* create the new edit field */
 562
 563     TXNFrameOptions frameOptions =
 564         kTXNDontDrawCaretWhenInactiveMask ;
 565     if ( ! ( wxStyle & wxTE_NOHIDESEL ) )
 566         frameOptions |= kTXNDontDrawSelectionWhenInactiveMask ;
 567
 568     if ( wxStyle & wxTE_MULTILINE )
 569     {
 570         if ( ! ( wxStyle & wxTE_DONTWRAP ) )
 571             frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
 572         else
 573         {
 574             frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
 575             frameOptions |= kTXNWantHScrollBarMask ;
 576         }
 577
 578         if ( !(wxStyle & wxTE_NO_VSCROLL ) )
 579             frameOptions |= kTXNWantVScrollBarMask ;
 580     }
 581     else
 582         frameOptions |= kTXNSingleLineOnlyMask ;
 583
 584     if ( wxStyle & wxTE_READONLY )
 585         frameOptions |= kTXNReadOnlyMask ;
 586
 587     TXNNewObject(NULL, varsp->fOwner, &varsp->fRTextArea,
 588         frameOptions ,
 589         kTXNTextEditStyleFrameType,
 590         kTXNTextensionFile,
 591         kTXNSystemDefaultEncoding,
 592         &varsp->fTXNRec, &varsp->fTXNFrame, (TXNObjectRefcon) tpvars);
 593
 594     if ( !IsControlVisible( theControl ) )
 595         TXNSetFrameBounds(  varsp->fTXNRec, varsp->fRTextArea.top + 30000 , varsp->fRTextArea.left + 30000 ,
 596             varsp->fRTextArea.bottom + 30000 , varsp->fRTextArea.right + 30000 , varsp->fTXNFrame);
 597
 598
 599     if ( (wxStyle & wxTE_MULTILINE) && (wxStyle & wxTE_DONTWRAP) )
 600     {
 601         TXNControlTag tag = kTXNWordWrapStateTag ;
 602         TXNControlData dat ;
 603         dat.uValue = kTXNNoAutoWrap ;
 604         TXNSetTXNObjectControls( varsp->fTXNRec , false , 1 , &tag , &dat ) ;
 605     }
 606         Str255 fontName ;
 607         SInt16 fontSize ;
 608         Style fontStyle ;
 609
 610         GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
 611
 612         TXNTypeAttributes typeAttr[] =
 613         {
 614             {   kTXNQDFontNameAttribute , kTXNQDFontNameAttributeSize , { (void*) fontName } } ,
 615             {   kTXNQDFontSizeAttribute , kTXNFontSizeAttributeSize , { (void*) (fontSize << 16) } } ,
 616             {   kTXNQDFontStyleAttribute , kTXNQDFontStyleAttributeSize , {  (void*) normal } } ,
 617         } ;
 618
 619     err = TXNSetTypeAttributes (varsp->fTXNRec, sizeof( typeAttr ) / sizeof(TXNTypeAttributes) , typeAttr,
 620           kTXNStartOffset,
 621           kTXNEndOffset);
 622         /* set the field's background */
 623
 624     tback.bgType = kTXNBackgroundTypeRGB;
 625     tback.bg.color = rgbWhite;
 626     TXNSetBackground( varsp->fTXNRec, &tback);
 627
 628         /* unlock our storage */
 629     HUnlock((Handle) tpvars);
 630         /* perform final activations and setup for our text field.  Here,
 631         we assume that the window is going to be the 'active' window. */
 632     TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
 633         /* all done */
 634     return err;
 635 }
 636
 637
 638
 639
 640 #if !USE_SHARED_LIBRARY
 641 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
 642
 643 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
 644     EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
 645     EVT_CHAR(wxTextCtrl::OnChar)
 646     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
 647     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
 648     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
 649     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
 650     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
 651
 652     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
 653     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
 654     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
 655     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
 656     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
 657 END_EVENT_TABLE()
 658 #endif
 659
 660 static void SetTXNData( TXNObject txn , const wxString& st , TXNOffset start , TXNOffset end )
 661 {
 662 #if wxUSE_UNICODE
 663 #if SIZEOF_WCHAR_T == 2
 664     size_t len = st.Len() ;
 665     TXNSetData( txn , kTXNUnicodeTextData,  (void*)st.wc_str(), len * 2,
 666       start, end);
 667 #else
 668     wxMBConvUTF16BE converter ;
 669     ByteCount byteBufferLen = converter.WC2MB( NULL , st.wc_str() , 0 ) ;
 670     UniChar *unibuf = (UniChar*) malloc(byteBufferLen) ;
 671     converter.WC2MB( (char*) unibuf , st.wc_str() , byteBufferLen ) ;
 672     TXNSetData( txn , kTXNUnicodeTextData,  (void*)unibuf, byteBufferLen ,
 673       start, end);
 674     free( unibuf ) ;
 675 #endif
 676 #else
 677     wxCharBuffer text =  st.mb_str(wxConvLocal)  ;
 678     TXNSetData( txn , kTXNTextData,  (void*)text.data(), strlen( text ) ,
 679       start, end);
 680 #endif
 681 }
 682
 683 // Text item
 684 void wxTextCtrl::Init()
 685 {
 686   m_macTE = NULL ;
 687   m_macTXN = NULL ;
 688   m_macTXNvars = NULL ;
 689   m_macUsesTXN = false ;
 690
 691   m_editable = true ;
 692   m_dirty = false;
 693
 694   m_maxLength = TE_UNLIMITED_LENGTH ;
 695 }
 696
 697 wxTextCtrl::~wxTextCtrl()
 698 {
 699     if ( m_macUsesTXN )
 700     {
 701         SetControlReference((ControlHandle)m_macControl, 0) ;
 702         TXNDeleteObject((TXNObject)m_macTXN);
 703         /* delete our private storage */
 704         DisposeHandle((Handle) m_macTXNvars);
 705         /* zero the control reference */
 706     }
 707 }
 708
 709 const short kVerticalMargin = 2 ;
 710 const short kHorizontalMargin = 2 ;
 711
 712 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 713            const wxString& str,
 714            const wxPoint& pos,
 715            const wxSize& size, long style,
 716            const wxValidator& validator,
 717            const wxString& name)
 718 {
 719     m_macTE = NULL ;
 720     m_macTXN = NULL ;
 721     m_macTXNvars = NULL ;
 722     m_macUsesTXN = false ;
 723     m_editable = true ;
 724
 725     m_macUsesTXN = ! (style & wxTE_PASSWORD ) ;
 726
 727     m_macUsesTXN &= (TXNInitTextension != (void*) kUnresolvedCFragSymbolAddress) ;
 728
 729     // base initialization
 730     if ( !wxTextCtrlBase::Create(parent, id, pos, size, style & ~(wxHSCROLL|wxVSCROLL), validator, name) )
 731         return false;
 732
 733     wxSize mySize = size ;
 734     if ( m_macUsesTXN )
 735     {
 736         m_macHorizontalBorder = 5 ; // additional pixels around the real control
 737         m_macVerticalBorder = 3 ;
 738     }
 739     else
 740     {
 741         m_macHorizontalBorder = 5 ; // additional pixels around the real control
 742         m_macVerticalBorder = 5 ;
 743     }
 744
 745
 746     Rect bounds ;
 747     Str255 title ;
 748     /*
 749     if ( mySize.y == -1 )
 750     {
 751         mySize.y = 13 ;
 752         if ( m_windowStyle & wxTE_MULTILINE )
 753             mySize.y *= 5 ;
 754
 755         mySize.y += 2 * m_macVerticalBorder ;
 756     }
 757     */
 758     MacPreControlCreate( parent , id ,  wxEmptyString , pos , mySize ,style, validator , name , &bounds , title ) ;
 759
 760     if ( m_windowStyle & wxTE_MULTILINE )
 761     {
 762         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
 763                       wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
 764
 765         m_windowStyle |= wxTE_PROCESS_ENTER;
 766     }
 767
 768     if ( m_windowStyle & wxTE_READONLY)
 769     {
 770         m_editable = false ;
 771     }
 772
 773     wxString st = str ;
 774     wxMacConvertNewlines13To10( &st ) ;
 775     if ( !m_macUsesTXN )
 776     {
 777         m_macControl = (WXWidget) ::NewControl( MAC_WXHWND(parent->MacGetRootWindow()) , &bounds , "\p" , false , 0 , 0 , 1,
 778             (style & wxTE_PASSWORD) ? kControlEditTextPasswordProc : kControlEditTextProc , (long) this ) ;
 779         long size ;
 780         ::GetControlData((ControlHandle)  m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*)((TEHandle *)&m_macTE) , &size ) ;
 781
 782     }
 783     else
 784     {
 785         short featurSet;
 786
 787         featurSet = kControlSupportsEmbedding | kControlSupportsFocus  | kControlWantsIdle
 788                 | kControlWantsActivate | kControlHandlesTracking | kControlHasSpecialBackground
 789                 | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
 790             /* create the control */
 791         m_macControl = (WXWidget) ::NewControl(MAC_WXHWND(parent->MacGetRootWindow()), &bounds, "\p", false , featurSet, 0, featurSet, kControlUserPaneProc, 0);
 792             /* set up the mUP specific features and data */
 793         mUPOpenControl((ControlHandle) m_macControl, m_windowStyle );
 794     }
 795     MacPostControlCreate() ;
 796
 797     if ( !m_macUsesTXN )
 798     {
 799         wxCharBuffer text = st.mb_str(wxConvLocal) ;
 800         ::SetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , strlen(text) , text ) ;
 801     }
 802     else
 803     {
 804         STPTextPaneVars **tpvars;
 805             /* set up locals */
 806         tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
 807             /* set the text in the record */
 808         m_macTXN =  (**tpvars).fTXNRec ;
 809         SetTXNData( (TXNObject) m_macTXN , st , kTXNStartOffset, kTXNEndOffset ) ;
 810         m_macTXNvars = tpvars ;
 811         m_macUsesTXN = true ;
 812         TXNSetSelection( (TXNObject) m_macTXN, 0, 0);
 813         TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
 814     }
 815
 816     return true;
 817 }
 818
 819 wxString wxTextCtrl::GetValue() const
 820 {
 821     Size actualSize = 0;
 822     wxString result ;
 823     OSStatus err ;
 824     if ( !m_macUsesTXN )
 825     {
 826         err = ::GetControlDataSize((ControlHandle) m_macControl, 0,
 827             ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag, &actualSize ) ;
 828
 829         if ( err )
 830             return wxEmptyString ;
 831
 832         if ( actualSize > 0 )
 833         {
 834             wxCharBuffer buf(actualSize) ;
 835             ::GetControlData( (ControlHandle) m_macControl, 0,
 836                 ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag,
 837                 actualSize , buf.data() , &actualSize ) ;
 838             result = wxString( buf , wxConvLocal) ;
 839         }
 840     }
 841     else
 842     {
 843 #if wxUSE_UNICODE
 844         Handle theText ;
 845         err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNUnicodeTextData );
 846         // all done
 847         if ( err )
 848         {
 849             actualSize = 0 ;
 850         }
 851         else
 852         {
 853             actualSize = GetHandleSize( theText ) / sizeof( UniChar) ;
 854             if ( actualSize > 0 )
 855             {
 856                 wxChar *ptr = result.GetWriteBuf(actualSize*sizeof(wxChar)) ;
 857 #if SIZEOF_WCHAR_T == 2
 858                 wxStrncpy( ptr , (wxChar*) *theText , actualSize ) ;
 859 #else
 860                 wxMBConvUTF16BE converter ;
 861                 HLock( theText ) ;
 862                 converter.MB2WC( ptr , (const char*)*theText , actualSize ) ;
 863                 HUnlock( theText ) ;
 864 #endif
 865                 ptr[actualSize] = 0 ;
 866                 result.UngetWriteBuf( actualSize *sizeof(wxChar) ) ;
 867             }
 868             DisposeHandle( theText ) ;
 869         }
 870 #else
 871         Handle theText ;
 872         err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
 873         // all done
 874         if ( err )
 875         {
 876             actualSize = 0 ;
 877         }
 878         else
 879         {
 880             actualSize = GetHandleSize( theText ) ;
 881             if ( actualSize > 0 )
 882             {
 883                 HLock( theText ) ;
 884                 result = wxString( *theText , wxConvLocal , actualSize ) ;
 885                 HUnlock( theText ) ;
 886             }
 887             DisposeHandle( theText ) ;
 888         }
 889 #endif
 890     }
 891     wxMacConvertNewlines10To13( &result ) ;
 892     return result ;
 893 }
 894
 895 void wxTextCtrl::GetSelection(long* from, long* to) const
 896 {
 897   if ( !m_macUsesTXN )
 898   {
 899     *from = (**((TEHandle) m_macTE)).selStart;
 900     *to = (**((TEHandle) m_macTE)).selEnd;
 901    }
 902    else
 903    {
 904         TXNGetSelection( (TXNObject) m_macTXN , (TXNOffset*) from , (TXNOffset*) to ) ;
 905    }
 906 }
 907
 908 void wxTextCtrl::SetValue(const wxString& str)
 909 {
 910     wxString st = str ;
 911     wxMacConvertNewlines13To10( &st ) ;
 912     if ( !m_macUsesTXN )
 913     {
 914         wxCharBuffer text =  st.mb_str(wxConvLocal) ;
 915         ::SetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , strlen(text) , text ) ;
 916     }
 917     else
 918     {
 919         bool formerEditable = m_editable ;
 920         if ( !formerEditable )
 921             SetEditable(true) ;
 922         SetTXNData( (TXNObject) m_macTXN , st , kTXNStartOffset, kTXNEndOffset ) ;
 923         TXNSetSelection( (TXNObject) m_macTXN, 0, 0);
 924         TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
 925         if ( !formerEditable )
 926             SetEditable(formerEditable) ;
 927     }
 928     MacRedrawControl() ;
 929 }
 930
 931 void wxTextCtrl::SetMaxLength(unsigned long len)
 932 {
 933     m_maxLength = len ;
 934 }
 935
 936 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
 937 {
 938     if ( m_macUsesTXN )
 939     {
 940         bool formerEditable = m_editable ;
 941         if ( !formerEditable )
 942             SetEditable(true) ;
 943         TXNTypeAttributes typeAttr[4] ;
 944         Str255 fontName = "\pMonaco" ;
 945         SInt16 fontSize = 12 ;
 946         Style fontStyle = normal ;
 947         RGBColor color ;
 948         int attrCounter = 0 ;
 949         if ( style.HasFont() )
 950         {
 951             const wxFont &font = style.GetFont() ;
 952             wxMacStringToPascal( font.GetFaceName() , fontName ) ;
 953             fontSize = font.GetPointSize() ;
 954             if ( font.GetUnderlined() )
 955                 fontStyle |= underline ;
 956             if ( font.GetWeight() == wxBOLD )
 957                 fontStyle |= bold ;
 958             if ( font.GetStyle() == wxITALIC )
 959                 fontStyle |= italic ;
 960
 961             typeAttr[attrCounter].tag = kTXNQDFontNameAttribute ;
 962             typeAttr[attrCounter].size = kTXNQDFontNameAttributeSize ;
 963             typeAttr[attrCounter].data.dataPtr = (void*) fontName ;
 964             typeAttr[attrCounter+1].tag = kTXNQDFontSizeAttribute ;
 965             typeAttr[attrCounter+1].size = kTXNFontSizeAttributeSize ;
 966             typeAttr[attrCounter+1].data.dataValue =  (fontSize << 16) ;
 967             typeAttr[attrCounter+2].tag = kTXNQDFontStyleAttribute ;
 968             typeAttr[attrCounter+2].size = kTXNQDFontStyleAttributeSize ;
 969             typeAttr[attrCounter+2].data.dataValue = fontStyle ;
 970             attrCounter += 3 ;
 971
 972         }
 973         if ( style.HasTextColour() )
 974         {
 975             typeAttr[attrCounter].tag = kTXNQDFontColorAttribute ;
 976             typeAttr[attrCounter].size = kTXNQDFontColorAttributeSize ;
 977             typeAttr[attrCounter].data.dataPtr = (void*) &color ;
 978             color = MAC_WXCOLORREF(style.GetTextColour().GetPixel()) ;
 979             attrCounter += 1 ;
 980         }
 981
 982         if ( attrCounter > 0 )
 983         {
 984 #ifdef __WXDEBUG__
 985             OSStatus status =
 986 #endif // __WXDEBUG__
 987                 TXNSetTypeAttributes ((TXNObject)m_macTXN, attrCounter , typeAttr, start,end);
 988             wxASSERT_MSG( status == noErr , wxT("Couldn't set text attributes") ) ;
 989         }
 990         if ( !formerEditable )
 991             SetEditable(formerEditable) ;
 992     }
 993     return true ;
 994 }
 995
 996 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
 997 {
 998     wxTextCtrlBase::SetDefaultStyle( style ) ;
 999     SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
1000     return true ;
1001 }
1002
1003 // Clipboard operations
1004 void wxTextCtrl::Copy()
1005 {
1006     if (CanCopy())
1007     {
1008       if ( !m_macUsesTXN )
1009       {
1010             TECopy( ((TEHandle) m_macTE) ) ;
1011             ClearCurrentScrap();
1012             TEToScrap() ;
1013             MacRedrawControl() ;
1014         }
1015         else
1016         {
1017             ClearCurrentScrap();
1018             TXNCopy((TXNObject)m_macTXN);
1019             TXNConvertToPublicScrap();
1020         }
1021     }
1022 }
1023
1024 void wxTextCtrl::Cut()
1025 {
1026     if (CanCut())
1027     {
1028         if ( !m_macUsesTXN )
1029         {
1030             TECut( ((TEHandle) m_macTE) ) ;
1031             ClearCurrentScrap();
1032             TEToScrap() ;
1033             MacRedrawControl() ;
1034         }
1035         else
1036         {
1037             ClearCurrentScrap();
1038             TXNCut((TXNObject)m_macTXN);
1039             TXNConvertToPublicScrap();
1040         }
1041         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1042         event.SetEventObject( this );
1043         GetEventHandler()->ProcessEvent(event);
1044       }
1045 }
1046
1047 void wxTextCtrl::Paste()
1048 {
1049     if (CanPaste())
1050     {
1051         if ( !m_macUsesTXN )
1052         {
1053             TEFromScrap() ;
1054             TEPaste( (TEHandle) m_macTE ) ;
1055             MacRedrawControl() ;
1056         }
1057         else
1058         {
1059             TXNConvertFromPublicScrap();
1060             TXNPaste((TXNObject)m_macTXN);
1061             SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
1062         }
1063         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1064         event.SetEventObject( this );
1065         GetEventHandler()->ProcessEvent(event);
1066     }
1067 }
1068
1069 bool wxTextCtrl::CanCopy() const
1070 {
1071     // Can copy if there's a selection
1072     long from, to;
1073     GetSelection(& from, & to);
1074     return (from != to);
1075 }
1076
1077 bool wxTextCtrl::CanCut() const
1078 {
1079     if ( !IsEditable() )
1080     {
1081         return false ;
1082     }
1083     // Can cut if there's a selection
1084     long from, to;
1085     GetSelection(& from, & to);
1086     return (from != to);
1087 }
1088
1089 bool wxTextCtrl::CanPaste() const
1090 {
1091     if (!IsEditable())
1092         return false;
1093
1094 #if TARGET_CARBON
1095     OSStatus err = noErr;
1096     ScrapRef scrapRef;
1097
1098     err = GetCurrentScrap( &scrapRef );
1099     if ( err != noTypeErr && err != memFullErr )
1100     {
1101         ScrapFlavorFlags    flavorFlags;
1102         Size                byteCount;
1103
1104         if (( err = GetScrapFlavorFlags( scrapRef, 'TEXT', &flavorFlags )) == noErr)
1105         {
1106             if (( err = GetScrapFlavorSize( scrapRef, 'TEXT', &byteCount )) == noErr)
1107             {
1108                 return true ;
1109             }
1110         }
1111     }
1112     return false;
1113
1114 #else
1115     long offset ;
1116     if ( GetScrap( NULL , 'TEXT' , &offset ) > 0 )
1117     {
1118         return true ;
1119     }
1120 #endif
1121     return false ;
1122 }
1123
1124 void wxTextCtrl::SetEditable(bool editable)
1125 {
1126     if ( editable != m_editable )
1127     {
1128         m_editable = editable ;
1129         if ( !m_macUsesTXN )
1130         {
1131             if ( editable )
1132                 UMAActivateControl( (ControlHandle) m_macControl ) ;
1133             else
1134                 UMADeactivateControl((ControlHandle)  m_macControl ) ;
1135         }
1136         else
1137         {
1138             TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1139             TXNControlData data[] = { { editable ? kTXNReadWrite : kTXNReadOnly } } ;
1140             TXNSetTXNObjectControls( (TXNObject) m_macTXN , false , sizeof(tag) / sizeof (TXNControlTag) , tag , data ) ;
1141         }
1142     }
1143 }
1144
1145 void wxTextCtrl::SetInsertionPoint(long pos)
1146 {
1147     SetSelection( pos , pos ) ;
1148 }
1149
1150 void wxTextCtrl::SetInsertionPointEnd()
1151 {
1152     wxTextPos pos = GetLastPosition();
1153     SetInsertionPoint(pos);
1154 }
1155
1156 long wxTextCtrl::GetInsertionPoint() const
1157 {
1158     long begin,end ;
1159     GetSelection( &begin , &end ) ;
1160     return begin ;
1161 }
1162
1163 wxTextPos wxTextCtrl::GetLastPosition() const
1164 {
1165     if ( !m_macUsesTXN )
1166     {
1167         return (**((TEHandle) m_macTE)).teLength ;
1168     }
1169     else
1170     {
1171         Handle theText ;
1172         long actualsize ;
1173         OSErr err = TXNGetDataEncoded( (TXNObject) m_macTXN, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
1174         /* all done */
1175         if ( err )
1176         {
1177             actualsize = 0 ;
1178         }
1179         else
1180         {
1181             actualsize = GetHandleSize( theText ) ;
1182             DisposeHandle( theText ) ;
1183         }
1184         return actualsize ;
1185     }
1186 }
1187
1188 void wxTextCtrl::Replace(long from, long to, const wxString& str)
1189 {
1190     wxString value = str ;
1191     wxMacConvertNewlines13To10( &value ) ;
1192     if ( !m_macUsesTXN )
1193     {
1194         ControlEditTextSelectionRec selection ;
1195
1196         selection.selStart = from ;
1197         selection.selEnd = to ;
1198         ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1199         TESetSelect( from , to  , ((TEHandle) m_macTE) ) ;
1200         TEDelete( ((TEHandle) m_macTE) ) ;
1201         TEInsert( value , value.Length() , ((TEHandle) m_macTE) ) ;
1202     }
1203     else
1204     {
1205         bool formerEditable = m_editable ;
1206         if ( !formerEditable )
1207             SetEditable(true) ;
1208         TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1209         TXNClear( ((TXNObject) m_macTXN) ) ;
1210         SetTXNData( (TXNObject) m_macTXN , str , kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
1211         if ( !formerEditable )
1212             SetEditable( formerEditable ) ;
1213     }
1214     Refresh() ;
1215 }
1216
1217 void wxTextCtrl::Remove(long from, long to)
1218 {
1219     if ( !m_macUsesTXN )
1220     {
1221         ControlEditTextSelectionRec selection ;
1222
1223         selection.selStart = from ;
1224         selection.selEnd = to ;
1225         ::SetControlData( (ControlHandle) m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1226         TEDelete( ((TEHandle) m_macTE) ) ;
1227     }
1228     else
1229     {
1230         bool formerEditable = m_editable ;
1231         if ( !formerEditable )
1232             SetEditable(true) ;
1233         TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1234         TXNClear( ((TXNObject) m_macTXN) ) ;
1235         if ( !formerEditable )
1236             SetEditable( formerEditable ) ;
1237     }
1238     Refresh() ;
1239 }
1240
1241 void wxTextCtrl::SetSelection(long from, long to)
1242 {
1243     if ( !m_macUsesTXN )
1244     {
1245         ControlEditTextSelectionRec selection ;
1246         if ((from == -1) && (to == -1))
1247         {
1248             selection.selStart = 0 ;
1249             selection.selEnd = 32767 ;
1250         }
1251         else
1252         {
1253             selection.selStart = from ;
1254             selection.selEnd = to ;
1255         }
1256
1257         TESetSelect( selection.selStart , selection.selEnd , ((TEHandle) m_macTE) ) ;
1258         ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1259     }
1260     else
1261     {
1262         STPTextPaneVars **tpvars;
1263         /* set up our locals */
1264         tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
1265         /* and our drawing environment as the operation
1266         may force a redraw in the text area. */
1267         SetPort((**tpvars).fDrawingEnvironment);
1268         /* change the selection */
1269         if ((from == -1) && (to == -1))
1270             TXNSelectAll((TXNObject) m_macTXN);
1271         else
1272             TXNSetSelection( (**tpvars).fTXNRec, from, to);
1273         TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
1274     }
1275 }
1276
1277 bool wxTextCtrl::LoadFile(const wxString& file)
1278 {
1279     if ( wxTextCtrlBase::LoadFile(file) )
1280     {
1281         return true;
1282     }
1283
1284     return false;
1285 }
1286
1287 void wxTextCtrl::WriteText(const wxString& str)
1288 {
1289     wxString st = str ;
1290     wxMacConvertNewlines13To10( &st ) ;
1291     if ( !m_macUsesTXN )
1292     {
1293         wxCharBuffer text =  st.mb_str(wxConvLocal) ;
1294         TEInsert( text , strlen(text) , ((TEHandle) m_macTE) ) ;
1295     }
1296     else
1297     {
1298         bool formerEditable = m_editable ;
1299         if ( !formerEditable )
1300             SetEditable(true) ;
1301         long start , end , dummy ;
1302         GetSelection( &start , &dummy ) ;
1303         SetTXNData( (TXNObject) m_macTXN , st , kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
1304         GetSelection( &dummy , &end ) ;
1305         SetStyle( start , end , GetDefaultStyle() ) ;
1306         if ( !formerEditable )
1307             SetEditable( formerEditable ) ;
1308     }
1309     MacRedrawControl() ;
1310 }
1311
1312 void wxTextCtrl::AppendText(const wxString& text)
1313 {
1314     SetInsertionPointEnd();
1315     WriteText(text);
1316 }
1317
1318 void wxTextCtrl::Clear()
1319 {
1320     if ( !m_macUsesTXN )
1321     {
1322         ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char*) ((const char*)NULL) ) ;
1323     }
1324     else
1325     {
1326         TXNSetSelection( (TXNObject)m_macTXN , kTXNStartOffset , kTXNEndOffset ) ;
1327         TXNClear((TXNObject)m_macTXN);
1328     }
1329     Refresh() ;
1330 }
1331
1332 bool wxTextCtrl::IsModified() const
1333 {
1334     return m_dirty;
1335 }
1336
1337 bool wxTextCtrl::IsEditable() const
1338 {
1339     return IsEnabled() && m_editable ;
1340 }
1341
1342 bool wxTextCtrl::AcceptsFocus() const
1343 {
1344     // we don't want focus if we can't be edited
1345     return /*IsEditable() && */ wxControl::AcceptsFocus();
1346 }
1347
1348 wxSize wxTextCtrl::DoGetBestSize() const
1349 {
1350     int wText = 100 ;
1351
1352     int hText;
1353     if ( m_macUsesTXN )
1354     {
1355         hText = 17 ;
1356     }
1357     else
1358     {
1359         hText = 13 ;
1360     }
1361 /*
1362     int cx, cy;
1363     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
1364
1365     int wText = DEFAULT_ITEM_WIDTH;
1366
1367     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
1368
1369     return wxSize(wText, hText);
1370 */
1371     if ( m_windowStyle & wxTE_MULTILINE )
1372     {
1373          hText *= 5 ;
1374     }
1375     hText += 2 * m_macVerticalBorder ;
1376     wText += 2 * m_macHorizontalBorder ;
1377     //else: for single line control everything is ok
1378     return wxSize(wText, hText);
1379 }
1380
1381 // ----------------------------------------------------------------------------
1382 // Undo/redo
1383 // ----------------------------------------------------------------------------
1384
1385 void wxTextCtrl::Undo()
1386 {
1387     if (CanUndo())
1388     {
1389         if ( m_macUsesTXN )
1390         {
1391             TXNUndo((TXNObject)m_macTXN);
1392         }
1393     }
1394 }
1395
1396 void wxTextCtrl::Redo()
1397 {
1398     if (CanRedo())
1399     {
1400         if ( m_macUsesTXN )
1401         {
1402             TXNRedo((TXNObject)m_macTXN);
1403         }
1404     }
1405 }
1406
1407 bool wxTextCtrl::CanUndo() const
1408 {
1409     if ( !IsEditable() )
1410     {
1411         return false ;
1412     }
1413     if ( m_macUsesTXN )
1414     {
1415         return TXNCanUndo((TXNObject)m_macTXN,NULL);
1416     }
1417     return false ;
1418 }
1419
1420 bool wxTextCtrl::CanRedo() const
1421 {
1422     if ( !IsEditable() )
1423     {
1424         return false ;
1425     }
1426     if ( m_macUsesTXN )
1427     {
1428         return TXNCanRedo((TXNObject)m_macTXN,NULL);
1429     }
1430     return false ;
1431 }
1432
1433 // Makes modifie or unmodified
1434 void wxTextCtrl::MarkDirty()
1435 {
1436     m_dirty = true;
1437 }
1438
1439 void wxTextCtrl::DiscardEdits()
1440 {
1441     m_dirty = false;
1442 }
1443
1444 int wxTextCtrl::GetNumberOfLines() const
1445 {
1446     if ( m_macUsesTXN )
1447     {
1448         ItemCount lines ;
1449         TXNGetLineCount((TXNObject)m_macTXN, &lines ) ;
1450         return lines ;
1451     }
1452     else
1453     {
1454         wxString content = GetValue() ;
1455
1456         int count = 1;
1457         for (size_t i = 0; i < content.Length() ; i++)
1458         {
1459             if (content[i] == '\r') count++;
1460         }
1461         return count;
1462     }
1463 }
1464
1465 long wxTextCtrl::XYToPosition(long x, long y) const
1466 {
1467     // TODO
1468     return 0;
1469 }
1470
1471 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
1472 {
1473     return false ;
1474 }
1475
1476 void wxTextCtrl::ShowPosition(long pos)
1477 {
1478 #if TARGET_RT_MAC_MACHO && defined(AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER)
1479     if ( m_macUsesTXN )
1480     {
1481         Point current ;
1482         Point desired ;
1483         TXNOffset selstart , selend ;
1484         TXNGetSelection(  (TXNObject) m_macTXN , &selstart , &selend) ;
1485         TXNOffsetToPoint( (TXNObject) m_macTXN,  selstart , &current);
1486         TXNOffsetToPoint( (TXNObject) m_macTXN,  pos , &desired);
1487         //TODO use HIPoints for 10.3 and above
1488         if ( (UInt32) TXNScroll != (UInt32) kUnresolvedCFragSymbolAddress )
1489         {
1490             OSErr theErr = noErr;
1491             SInt32 dv = desired.v - current.v ;
1492             SInt32 dh = desired.h - current.h ;
1493             TXNShowSelection(  (TXNObject) m_macTXN , true ) ;
1494             theErr = TXNScroll( (TXNObject) m_macTXN, kTXNScrollUnitsInPixels , kTXNScrollUnitsInPixels , &dv , &dh );
1495             wxASSERT_MSG( theErr == noErr, _T("TXNScroll returned an error!") );
1496         }
1497     }
1498 #endif
1499 }
1500
1501 int wxTextCtrl::GetLineLength(long lineNo) const
1502 {
1503     // TODO change this if possible to reflect real lines
1504     wxString content = GetValue() ;
1505
1506     // Find line first
1507     int count = 0;
1508     for (size_t i = 0; i < content.Length() ; i++)
1509     {
1510         if (count == lineNo)
1511         {
1512             // Count chars in line then
1513             count = 0;
1514             for (size_t j = i; j < content.Length(); j++)
1515             {
1516                 count++;
1517                 if (content[j] == '\n') return count;
1518             }
1519
1520             return count;
1521         }
1522         if (content[i] == '\n') count++;
1523     }
1524     return 0;
1525 }
1526
1527 wxString wxTextCtrl::GetLineText(long lineNo) const
1528 {
1529     // TODO change this if possible to reflect real lines
1530     wxString content = GetValue() ;
1531
1532     // Find line first
1533     int count = 0;
1534     for (size_t i = 0; i < content.Length() ; i++)
1535     {
1536         if (count == lineNo)
1537         {
1538             // Add chars in line then
1539             wxString tmp;
1540
1541             for (size_t j = i; j < content.Length(); j++)
1542             {
1543                 if (content[j] == '\n')
1544                     return tmp;
1545
1546                 tmp += content[j];
1547             }
1548
1549             return tmp;
1550         }
1551         if (content[i] == '\n') count++;
1552     }
1553     return wxEmptyString ;
1554 }
1555
1556 /*
1557  * Text item
1558  */
1559
1560 void wxTextCtrl::Command(wxCommandEvent & event)
1561 {
1562     SetValue (event.GetString());
1563     ProcessCommand (event);
1564 }
1565
1566 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1567 {
1568     // By default, load the first file into the text window.
1569     if (event.GetNumberOfFiles() > 0)
1570     {
1571         LoadFile(event.GetFiles()[0]);
1572     }
1573 }
1574
1575 void wxTextCtrl::OnChar(wxKeyEvent& event)
1576 {
1577     int key = event.GetKeyCode() ;
1578     bool eat_key = false ;
1579
1580     if ( key == 'c' && event.MetaDown() )
1581     {
1582         if ( CanCopy() )
1583             Copy() ;
1584         return ;
1585     }
1586
1587     if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
1588         !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
1589 /*        && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
1590         )
1591     {
1592         // eat it
1593         return ;
1594     }
1595
1596     // assume that any key not processed yet is going to modify the control
1597     m_dirty = true;
1598
1599     if ( key == 'v' && event.MetaDown() )
1600     {
1601         if ( CanPaste() )
1602             Paste() ;
1603         return ;
1604     }
1605     if ( key == 'x' && event.MetaDown() )
1606     {
1607         if ( CanCut() )
1608             Cut() ;
1609         return ;
1610     }
1611     switch ( key )
1612     {
1613         case WXK_RETURN:
1614             if (m_windowStyle & wxPROCESS_ENTER)
1615             {
1616                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1617                 event.SetEventObject( this );
1618                 event.SetString( GetValue() );
1619                 if ( GetEventHandler()->ProcessEvent(event) )
1620                     return;
1621             }
1622             if ( !(m_windowStyle & wxTE_MULTILINE) )
1623             {
1624                 wxWindow *parent = GetParent();
1625                 while( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL ) {
1626                   parent = parent->GetParent() ;
1627                 }
1628                 if ( parent && parent->GetDefaultItem() )
1629                 {
1630                     wxButton *def = wxDynamicCast(parent->GetDefaultItem(),
1631                                                           wxButton);
1632                     if ( def && def->IsEnabled() )
1633                     {
1634                         wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1635                         event.SetEventObject(def);
1636                         def->Command(event);
1637                         return ;
1638                    }
1639                 }
1640
1641                 // this will make wxWidgets eat the ENTER key so that
1642                 // we actually prevent line wrapping in a single line
1643                 // text control
1644                 eat_key = true;
1645             }
1646
1647             break;
1648
1649         case WXK_TAB:
1650             if ( !(m_windowStyle & wxTE_PROCESS_TAB))
1651             {
1652                 int flags = 0;
1653                 if (!event.ShiftDown())
1654                     flags |= wxNavigationKeyEvent::IsForward ;
1655                 if (event.ControlDown())
1656                     flags |= wxNavigationKeyEvent::WinChange ;
1657                 Navigate(flags);
1658                 return;
1659             }
1660             else
1661             {
1662                 // This is necessary (don't know why) or the tab will not
1663                 // be inserted.
1664                 WriteText(wxT("\t"));
1665             }
1666             break;
1667     }
1668
1669     if (!eat_key)
1670     {
1671         // perform keystroke handling
1672 #if TARGET_CARBON
1673         if ( m_macUsesTXN && wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL )
1674             CallNextEventHandler((EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() , (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
1675         else
1676         {
1677             EventRecord rec ;
1678             if ( wxMacConvertEventToRecord(  (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) )
1679             {
1680                 EventRecord *ev = &rec ;
1681                 short keycode ;
1682                 short keychar ;
1683                 keychar = short(ev->message & charCodeMask);
1684                 keycode = short(ev->message & keyCodeMask) >> 8 ;
1685
1686                 ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers ) ;
1687             }
1688         }
1689 #else
1690         EventRecord *ev = (EventRecord*) wxTheApp->MacGetCurrentEvent() ;
1691         short keycode ;
1692         short keychar ;
1693         keychar = short(ev->message & charCodeMask);
1694         keycode = short(ev->message & keyCodeMask) >> 8 ;
1695
1696         ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers ) ;
1697 #endif
1698     }
1699     if ( ( key >= 0x20 && key < WXK_START ) ||
1700          key == WXK_RETURN ||
1701          key == WXK_DELETE ||
1702          key == WXK_BACK)
1703     {
1704         wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1705         event1.SetEventObject( this );
1706         wxPostEvent(GetEventHandler(),event1);
1707     }
1708 }
1709
1710 void  wxTextCtrl::MacSuperShown( bool show )
1711 {
1712     bool former = m_macControlIsShown ;
1713     wxControl::MacSuperShown( show ) ;
1714     if ( (former != m_macControlIsShown) && m_macUsesTXN )
1715     {
1716         if ( m_macControlIsShown )
1717             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1718                 (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom,(**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1719         else
1720             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1721                (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1722     }
1723 }
1724
1725 bool  wxTextCtrl::Show(bool show)
1726 {
1727     bool former = m_macControlIsShown ;
1728
1729     bool retval = wxControl::Show( show ) ;
1730
1731     if ( former != m_macControlIsShown && m_macUsesTXN )
1732     {
1733         if ( m_macControlIsShown )
1734             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1735                 (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom,(**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1736         else
1737             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1738                (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1739     }
1740
1741     return retval ;
1742 }
1743
1744 // ----------------------------------------------------------------------------
1745 // standard handlers for standard edit menu events
1746 // ----------------------------------------------------------------------------
1747
1748 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1749 {
1750     Cut();
1751 }
1752
1753 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1754 {
1755     Copy();
1756 }
1757
1758 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1759 {
1760     Paste();
1761 }
1762
1763 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1764 {
1765     Undo();
1766 }
1767
1768 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1769 {
1770     Redo();
1771 }
1772
1773 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1774 {
1775     event.Enable( CanCut() );
1776 }
1777
1778 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1779 {
1780     event.Enable( CanCopy() );
1781 }
1782
1783 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1784 {
1785     event.Enable( CanPaste() );
1786 }
1787
1788 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1789 {
1790     event.Enable( CanUndo() );
1791 }
1792
1793 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1794 {
1795     event.Enable( CanRedo() );
1796 }
1797
1798 bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
1799 {
1800     if ( m_macUsesTXN )
1801         return true ;
1802     else
1803         return wxWindow::MacSetupCursor( pt ) ;
1804 }
1805
1806 #endif
1807     // wxUSE_TEXTCTRL