src/mac/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 #if wxUSE_STD_IOSTREAM
  28     #if wxUSE_IOSTREAMH
  29         #include <fstream.h>
  30     #else
  31         #include <fstream>
  32     #endif
  33 #endif
  34
  35 #include "wx/app.h"
  36 #include "wx/dc.h"
  37 #include "wx/button.h"
  38 #include "wx/toplevel.h"
  39 #include "wx/textctrl.h"
  40 #include "wx/notebook.h"
  41 #include "wx/tabctrl.h"
  42 #include "wx/settings.h"
  43 #include "wx/filefn.h"
  44 #include "wx/utils.h"
  45
  46 #if defined(__BORLANDC__) && !defined(__WIN32__)
  47   #include <alloc.h>
  48 #elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
  49   #include <malloc.h>
  50 #endif
  51
  52 #ifndef __DARWIN__
  53 #include <Scrap.h>
  54 #endif
  55 #include <MacTextEditor.h>
  56 #include "ATSUnicode.h"
  57 #include "TextCommon.h"
  58 #include "TextEncodingConverter.h"
  59 #include "wx/mac/uma.h"
  60
  61 #define TE_UNLIMITED_LENGTH 0xFFFFFFFFUL
  62
  63 extern wxControl *wxFindControlFromMacControl(ControlHandle inControl ) ;
  64
  65 // CS:TODO we still have a problem getting properly at the text events of a control because under Carbon
  66 // the MLTE engine registers itself for the key events thus the normal flow never occurs, the only measure for the
  67 // moment is to avoid setting the true focus on the control, the proper solution at the end would be to have
  68 // an alternate path for carbon key events that routes automatically into the same wx flow of events
  69
  70 #include "MacTextEditor.h"
  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 // Text item
 661 void wxTextCtrl::Init()
 662 {
 663   m_macTE = NULL ;
 664   m_macTXN = NULL ;
 665   m_macTXNvars = NULL ;
 666   m_macUsesTXN = false ;
 667
 668   m_editable = true ;
 669   m_dirty = false;
 670
 671   m_maxLength = TE_UNLIMITED_LENGTH ;
 672 }
 673
 674 wxTextCtrl::~wxTextCtrl()
 675 {
 676     if ( m_macUsesTXN )
 677     {
 678         SetControlReference((ControlHandle)m_macControl, 0) ;
 679         TXNDeleteObject((TXNObject)m_macTXN);
 680         /* delete our private storage */
 681         DisposeHandle((Handle) m_macTXNvars);
 682         /* zero the control reference */
 683     }
 684 }
 685
 686 const short kVerticalMargin = 2 ;
 687 const short kHorizontalMargin = 2 ;
 688
 689 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 690            const wxString& str,
 691            const wxPoint& pos,
 692            const wxSize& size, long style,
 693            const wxValidator& validator,
 694            const wxString& name)
 695 {
 696     m_macTE = NULL ;
 697     m_macTXN = NULL ;
 698     m_macTXNvars = NULL ;
 699     m_macUsesTXN = false ;
 700     m_editable = true ;
 701
 702     m_macUsesTXN = ! (style & wxTE_PASSWORD ) ;
 703
 704     m_macUsesTXN &= (TXNInitTextension != (void*) kUnresolvedCFragSymbolAddress) ;
 705
 706     // base initialization
 707     if ( !wxTextCtrlBase::Create(parent, id, pos, size, style & ~(wxHSCROLL|wxVSCROLL), validator, name) )
 708         return FALSE;
 709
 710     wxSize mySize = size ;
 711     if ( m_macUsesTXN )
 712     {
 713         m_macHorizontalBorder = 5 ; // additional pixels around the real control
 714         m_macVerticalBorder = 3 ;
 715     }
 716     else
 717     {
 718         m_macHorizontalBorder = 5 ; // additional pixels around the real control
 719         m_macVerticalBorder = 5 ;
 720     }
 721
 722
 723     Rect bounds ;
 724     Str255 title ;
 725     /*
 726     if ( mySize.y == -1 )
 727     {
 728         mySize.y = 13 ;
 729         if ( m_windowStyle & wxTE_MULTILINE )
 730             mySize.y *= 5 ;
 731
 732         mySize.y += 2 * m_macVerticalBorder ;
 733     }
 734     */
 735     MacPreControlCreate( parent , id ,  wxEmptyString , pos , mySize ,style, validator , name , &bounds , title ) ;
 736
 737     if ( m_windowStyle & wxTE_MULTILINE )
 738     {
 739         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
 740                       wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
 741
 742         m_windowStyle |= wxTE_PROCESS_ENTER;
 743     }
 744
 745     if ( m_windowStyle & wxTE_READONLY)
 746     {
 747         m_editable = FALSE ;
 748     }
 749
 750     wxString st = str ;
 751     st.Replace(wxT("\n"), wxT("\r"));
 752     if ( !m_macUsesTXN )
 753     {
 754         m_macControl = ::NewControl( MAC_WXHWND(parent->MacGetRootWindow()) , &bounds , "\p" , false , 0 , 0 , 1,
 755             (style & wxTE_PASSWORD) ? kControlEditTextPasswordProc : kControlEditTextProc , (long) this ) ;
 756         long size ;
 757         ::GetControlData((ControlHandle)  m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*)((TEHandle *)&m_macTE) , &size ) ;
 758
 759     }
 760     else
 761     {
 762         short featurSet;
 763
 764         featurSet = kControlSupportsEmbedding | kControlSupportsFocus  | kControlWantsIdle
 765                 | kControlWantsActivate | kControlHandlesTracking | kControlHasSpecialBackground
 766                 | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
 767             /* create the control */
 768         m_macControl = NewControl(MAC_WXHWND(parent->MacGetRootWindow()), &bounds, "\p", false , featurSet, 0, featurSet, kControlUserPaneProc, 0);
 769             /* set up the mUP specific features and data */
 770         mUPOpenControl((ControlHandle) m_macControl, m_windowStyle );
 771     }
 772     MacPostControlCreate() ;
 773
 774     if ( !m_macUsesTXN )
 775     {
 776         wxCharBuffer text = st.mb_str(wxConvLocal) ;
 777         ::SetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , strlen(text) , text ) ;
 778     }
 779     else
 780     {
 781         STPTextPaneVars **tpvars;
 782             /* set up locals */
 783         tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
 784             /* set the text in the record */
 785         m_macTXN =  (**tpvars).fTXNRec ;
 786 #if wxUSE_UNICODE
 787         TXNSetData( ((TXNObject) m_macTXN) , kTXNUnicodeTextData,  (void*)st.wc_str(), st.Length() * 2,
 788           kTXNStartOffset, kTXNEndOffset);
 789 #else
 790         wxCharBuffer text =  st.mb_str(wxConvLocal)  ;
 791         TXNSetData( ((TXNObject) m_macTXN) , kTXNTextData,  (void*)text.data(), strlen( text ) ,
 792           kTXNStartOffset, kTXNEndOffset);
 793 #endif
 794         m_macTXNvars = tpvars ;
 795         m_macUsesTXN = true ;
 796         TXNSetSelection( (TXNObject) m_macTXN, 0, 0);
 797         TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
 798     }
 799
 800     return TRUE;
 801 }
 802
 803 wxString wxTextCtrl::GetValue() const
 804 {
 805     Size actualSize = 0;
 806     wxString result ;
 807     OSStatus err ;
 808     if ( !m_macUsesTXN )
 809     {
 810         err = ::GetControlDataSize((ControlHandle) m_macControl, 0,
 811             ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag, &actualSize ) ;
 812
 813        if ( err )
 814            return wxEmptyString ;
 815
 816        if ( actualSize > 0 )
 817        {
 818                 wxCharBuffer buf(actualSize) ;
 819             ::GetControlData( (ControlHandle) m_macControl, 0,
 820                 ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag,
 821                 actualSize , buf.data() , &actualSize ) ;
 822             result = wxString( buf , wxConvLocal) ;
 823         }
 824     }
 825     else
 826     {
 827 #if wxUSE_UNICODE
 828         Handle theText ;
 829         err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNUnicodeTextData );
 830         // all done
 831         if ( err )
 832         {
 833             actualSize = 0 ;
 834         }
 835         else
 836         {
 837             actualSize = GetHandleSize( theText ) ;
 838             if ( actualSize > 0 )
 839             {
 840                 wxChar *ptr = result.GetWriteBuf(actualSize*sizeof(wxChar)) ;
 841                 wxStrncpy( ptr , (wxChar*) *theText , actualSize ) ;
 842                 ptr[actualSize] = 0 ;
 843                 result.UngetWriteBuf( actualSize ) ;
 844             }
 845             DisposeHandle( theText ) ;
 846         }
 847 #else
 848         Handle theText ;
 849         err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
 850         // all done
 851         if ( err )
 852         {
 853             actualSize = 0 ;
 854         }
 855         else
 856         {
 857             actualSize = GetHandleSize( theText ) ;
 858             if ( actualSize > 0 )
 859             {
 860                 HLock( theText ) ;
 861                 result = wxString( *theText , wxConvLocal , actualSize ) ;
 862                 HUnlock( theText ) ;
 863             }
 864             DisposeHandle( theText ) ;
 865         }
 866 #endif
 867     }
 868     result.Replace(wxT("\r"),wxT("\n")) ;
 869     return result ;
 870 }
 871
 872 void wxTextCtrl::GetSelection(long* from, long* to) const
 873 {
 874   if ( !m_macUsesTXN )
 875   {
 876     *from = (**((TEHandle) m_macTE)).selStart;
 877     *to = (**((TEHandle) m_macTE)).selEnd;
 878    }
 879    else
 880    {
 881         TXNGetSelection(  ((TXNObject) m_macTXN) , (TXNOffset*) from , (TXNOffset*) to ) ;
 882    }
 883 }
 884
 885 void wxTextCtrl::SetValue(const wxString& str)
 886 {
 887     wxString st = str ;
 888     st.Replace(wxT("\n"), wxT("\r"));
 889     if ( !m_macUsesTXN )
 890     {
 891         wxCharBuffer text =  st.mb_str(wxConvLocal) ;
 892         ::SetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , strlen(text) , text ) ;
 893     }
 894     else
 895     {
 896         bool formerEditable = m_editable ;
 897         if ( !formerEditable )
 898             SetEditable(true) ;
 899 #if wxUSE_UNICODE
 900         TXNSetData( ((TXNObject) m_macTXN), kTXNUnicodeTextData,  (void*)st.wc_str(), st.Length() * 2 ,
 901           kTXNStartOffset, kTXNEndOffset);
 902 #else
 903         wxCharBuffer text =  st.mb_str(wxConvLocal) ;
 904         TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)text.data(), strlen( text ) ,
 905           kTXNStartOffset, kTXNEndOffset);
 906 #endif
 907         TXNSetSelection( (TXNObject) m_macTXN, 0, 0);
 908         TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
 909         if ( !formerEditable )
 910             SetEditable(formerEditable) ;
 911     }
 912     MacRedrawControl() ;
 913 }
 914
 915 void wxTextCtrl::SetMaxLength(unsigned long len)
 916 {
 917     m_maxLength = len ;
 918 }
 919
 920 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
 921 {
 922     if ( m_macUsesTXN )
 923     {
 924         bool formerEditable = m_editable ;
 925         if ( !formerEditable )
 926             SetEditable(true) ;
 927         TXNTypeAttributes typeAttr[4] ;
 928         Str255 fontName = "\pMonaco" ;
 929         SInt16 fontSize = 12 ;
 930         Style fontStyle = normal ;
 931         RGBColor color ;
 932         int attrCounter = 0 ;
 933         if ( style.HasFont() )
 934         {
 935             const wxFont &font = style.GetFont() ;
 936             wxMacStringToPascal( font.GetFaceName() , fontName ) ;
 937             fontSize = font.GetPointSize() ;
 938             if ( font.GetUnderlined() )
 939                 fontStyle |= underline ;
 940             if ( font.GetWeight() == wxBOLD )
 941                 fontStyle |= bold ;
 942             if ( font.GetStyle() == wxITALIC )
 943                 fontStyle |= italic ;
 944
 945             typeAttr[attrCounter].tag = kTXNQDFontNameAttribute ;
 946             typeAttr[attrCounter].size = kTXNQDFontNameAttributeSize ;
 947             typeAttr[attrCounter].data.dataPtr = (void*) fontName ;
 948             typeAttr[attrCounter+1].tag = kTXNQDFontSizeAttribute ;
 949             typeAttr[attrCounter+1].size = kTXNFontSizeAttributeSize ;
 950             typeAttr[attrCounter+1].data.dataValue =  (fontSize << 16) ;
 951             typeAttr[attrCounter+2].tag = kTXNQDFontStyleAttribute ;
 952             typeAttr[attrCounter+2].size = kTXNQDFontStyleAttributeSize ;
 953             typeAttr[attrCounter+2].data.dataValue = fontStyle ;
 954             attrCounter += 3 ;
 955
 956         }
 957         if ( style.HasTextColour() )
 958         {
 959             typeAttr[attrCounter].tag = kTXNQDFontColorAttribute ;
 960             typeAttr[attrCounter].size = kTXNQDFontColorAttributeSize ;
 961             typeAttr[attrCounter].data.dataPtr = (void*) &color ;
 962             color = MAC_WXCOLORREF(style.GetTextColour().GetPixel()) ;
 963             attrCounter += 1 ;
 964         }
 965
 966         if ( attrCounter > 0 )
 967         {
 968 #ifdef __WXDEBUG__
 969             OSStatus status =
 970 #endif // __WXDEBUG__
 971                 TXNSetTypeAttributes ((TXNObject)m_macTXN, attrCounter , typeAttr, start,end);
 972             wxASSERT_MSG( status == noErr , wxT("Couldn't set text attributes") ) ;
 973         }
 974         if ( !formerEditable )
 975             SetEditable(formerEditable) ;
 976     }
 977     return TRUE ;
 978 }
 979
 980 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
 981 {
 982     wxTextCtrlBase::SetDefaultStyle( style ) ;
 983     SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
 984     return TRUE ;
 985 }
 986
 987 // Clipboard operations
 988 void wxTextCtrl::Copy()
 989 {
 990     if (CanCopy())
 991     {
 992       if ( !m_macUsesTXN )
 993       {
 994             TECopy( ((TEHandle) m_macTE) ) ;
 995             ClearCurrentScrap();
 996             TEToScrap() ;
 997             MacRedrawControl() ;
 998         }
 999         else
1000         {
1001             ClearCurrentScrap();
1002             TXNCopy((TXNObject)m_macTXN);
1003             TXNConvertToPublicScrap();
1004         }
1005     }
1006 }
1007
1008 void wxTextCtrl::Cut()
1009 {
1010     if (CanCut())
1011     {
1012         if ( !m_macUsesTXN )
1013         {
1014             TECut( ((TEHandle) m_macTE) ) ;
1015             ClearCurrentScrap();
1016             TEToScrap() ;
1017             MacRedrawControl() ;
1018         }
1019         else
1020         {
1021             ClearCurrentScrap();
1022             TXNCut((TXNObject)m_macTXN);
1023             TXNConvertToPublicScrap();
1024         }
1025         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1026         event.SetString( GetValue() ) ;
1027         event.SetEventObject( this );
1028         GetEventHandler()->ProcessEvent(event);
1029       }
1030 }
1031
1032 void wxTextCtrl::Paste()
1033 {
1034     if (CanPaste())
1035     {
1036         if ( !m_macUsesTXN )
1037         {
1038             TEFromScrap() ;
1039             TEPaste( (TEHandle) m_macTE ) ;
1040             MacRedrawControl() ;
1041         }
1042         else
1043         {
1044             TXNConvertFromPublicScrap();
1045             TXNPaste((TXNObject)m_macTXN);
1046             SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
1047         }
1048         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1049         event.SetString( GetValue() ) ;
1050         event.SetEventObject( this );
1051         GetEventHandler()->ProcessEvent(event);
1052     }
1053 }
1054
1055 bool wxTextCtrl::CanCopy() const
1056 {
1057     // Can copy if there's a selection
1058     long from, to;
1059     GetSelection(& from, & to);
1060     return (from != to);
1061 }
1062
1063 bool wxTextCtrl::CanCut() const
1064 {
1065     if ( !IsEditable() )
1066     {
1067         return false ;
1068     }
1069     // Can cut if there's a selection
1070     long from, to;
1071     GetSelection(& from, & to);
1072     return (from != to);
1073 }
1074
1075 bool wxTextCtrl::CanPaste() const
1076 {
1077     if (!IsEditable())
1078         return FALSE;
1079
1080 #if TARGET_CARBON
1081     OSStatus err = noErr;
1082     ScrapRef scrapRef;
1083
1084     err = GetCurrentScrap( &scrapRef );
1085     if ( err != noTypeErr && err != memFullErr )
1086     {
1087         ScrapFlavorFlags    flavorFlags;
1088         Size                byteCount;
1089
1090         if (( err = GetScrapFlavorFlags( scrapRef, 'TEXT', &flavorFlags )) == noErr)
1091         {
1092             if (( err = GetScrapFlavorSize( scrapRef, 'TEXT', &byteCount )) == noErr)
1093             {
1094                 return TRUE ;
1095             }
1096         }
1097     }
1098     return FALSE;
1099
1100 #else
1101     long offset ;
1102     if ( GetScrap( NULL , 'TEXT' , &offset ) > 0 )
1103     {
1104         return TRUE ;
1105     }
1106 #endif
1107     return FALSE ;
1108 }
1109
1110 void wxTextCtrl::SetEditable(bool editable)
1111 {
1112     if ( editable != m_editable )
1113     {
1114         m_editable = editable ;
1115         if ( !m_macUsesTXN )
1116         {
1117             if ( editable )
1118                 UMAActivateControl( (ControlHandle) m_macControl ) ;
1119             else
1120                 UMADeactivateControl((ControlHandle)  m_macControl ) ;
1121         }
1122         else
1123         {
1124             TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1125             TXNControlData data[] = { { editable ? kTXNReadWrite : kTXNReadOnly } } ;
1126             TXNSetTXNObjectControls( (TXNObject) m_macTXN , false , sizeof(tag) / sizeof (TXNControlTag) , tag , data ) ;
1127         }
1128     }
1129 }
1130
1131 void wxTextCtrl::SetInsertionPoint(long pos)
1132 {
1133     SetSelection( pos , pos ) ;
1134 }
1135
1136 void wxTextCtrl::SetInsertionPointEnd()
1137 {
1138     long pos = GetLastPosition();
1139     SetInsertionPoint(pos);
1140 }
1141
1142 long wxTextCtrl::GetInsertionPoint() const
1143 {
1144     long begin,end ;
1145     GetSelection( &begin , &end ) ;
1146     return begin ;
1147 }
1148
1149 long wxTextCtrl::GetLastPosition() const
1150 {
1151     if ( !m_macUsesTXN )
1152     {
1153         return (**((TEHandle) m_macTE)).teLength ;
1154     }
1155     else
1156     {
1157         Handle theText ;
1158         long actualsize ;
1159         OSErr err = TXNGetDataEncoded( (TXNObject) m_macTXN, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
1160         /* all done */
1161         if ( err )
1162         {
1163             actualsize = 0 ;
1164         }
1165         else
1166         {
1167             actualsize = GetHandleSize( theText ) ;
1168             DisposeHandle( theText ) ;
1169         }
1170         return actualsize ;
1171     }
1172 }
1173
1174 void wxTextCtrl::Replace(long from, long to, const wxString& str)
1175 {
1176     wxString value = str ;
1177     value.Replace(wxT("\n"), wxT("\r"));
1178     if ( !m_macUsesTXN )
1179     {
1180         ControlEditTextSelectionRec selection ;
1181
1182         selection.selStart = from ;
1183         selection.selEnd = to ;
1184         ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1185         TESetSelect( from , to  , ((TEHandle) m_macTE) ) ;
1186         TEDelete( ((TEHandle) m_macTE) ) ;
1187         TEInsert( value , value.Length() , ((TEHandle) m_macTE) ) ;
1188     }
1189     else
1190     {
1191         bool formerEditable = m_editable ;
1192         if ( !formerEditable )
1193             SetEditable(true) ;
1194         TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1195         TXNClear( ((TXNObject) m_macTXN) ) ;
1196 #if wxUSE_UNICODE
1197         TXNSetData( ((TXNObject) m_macTXN), kTXNUnicodeTextData,  (void*)value.wc_str(), value.Length() * 2 ,
1198           kTXNUseCurrentSelection, kTXNUseCurrentSelection);
1199 #else
1200         TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)value.c_str(), value.Length(),
1201             kTXNUseCurrentSelection, kTXNUseCurrentSelection);
1202 #endif
1203         if ( !formerEditable )
1204             SetEditable( formerEditable ) ;
1205     }
1206     Refresh() ;
1207 }
1208
1209 void wxTextCtrl::Remove(long from, long to)
1210 {
1211     if ( !m_macUsesTXN )
1212     {
1213         ControlEditTextSelectionRec selection ;
1214
1215         selection.selStart = from ;
1216         selection.selEnd = to ;
1217         ::SetControlData( (ControlHandle) m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1218         TEDelete( ((TEHandle) m_macTE) ) ;
1219     }
1220     else
1221     {
1222         bool formerEditable = m_editable ;
1223         if ( !formerEditable )
1224             SetEditable(true) ;
1225         TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1226         TXNClear( ((TXNObject) m_macTXN) ) ;
1227         if ( !formerEditable )
1228             SetEditable( formerEditable ) ;
1229     }
1230     Refresh() ;
1231 }
1232
1233 void wxTextCtrl::SetSelection(long from, long to)
1234 {
1235     if ( !m_macUsesTXN )
1236     {
1237         ControlEditTextSelectionRec selection ;
1238         if ((from == -1) && (to == -1))
1239         {
1240                 selection.selStart = 0 ;
1241                 selection.selEnd = 32767 ;
1242         }
1243         else
1244         {
1245                 selection.selStart = from ;
1246                 selection.selEnd = to ;
1247         }
1248
1249         TESetSelect( selection.selStart , selection.selEnd , ((TEHandle) m_macTE) ) ;
1250         ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1251     }
1252     else
1253     {
1254         STPTextPaneVars **tpvars;
1255         /* set up our locals */
1256         tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
1257         /* and our drawing environment as the operation
1258         may force a redraw in the text area. */
1259         SetPort((**tpvars).fDrawingEnvironment);
1260         /* change the selection */
1261         if ((from == -1) && (to == -1))
1262                 TXNSelectAll((TXNObject) m_macTXN);
1263         else
1264                 TXNSetSelection( (**tpvars).fTXNRec, from, to);
1265         TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
1266     }
1267 }
1268
1269 bool wxTextCtrl::LoadFile(const wxString& file)
1270 {
1271     if ( wxTextCtrlBase::LoadFile(file) )
1272     {
1273         return TRUE;
1274     }
1275
1276     return FALSE;
1277 }
1278
1279 void wxTextCtrl::WriteText(const wxString& str)
1280 {
1281     wxString st = str ;
1282     st.Replace(wxT("\n"), wxT("\r"));
1283     if ( !m_macUsesTXN )
1284     {
1285         wxCharBuffer text =  st.mb_str(wxConvLocal) ;
1286         TEInsert( text , strlen(text) , ((TEHandle) m_macTE) ) ;
1287     }
1288     else
1289     {
1290         bool formerEditable = m_editable ;
1291         if ( !formerEditable )
1292             SetEditable(true) ;
1293         long start , end , dummy ;
1294         GetSelection( &start , &dummy ) ;
1295 #if wxUSE_UNICODE
1296         TXNSetData( ((TXNObject) m_macTXN), kTXNUnicodeTextData,  (void*)st.wc_str(), st.Length() * 2 ,
1297           kTXNUseCurrentSelection, kTXNUseCurrentSelection);
1298 #else
1299         wxCharBuffer text =  st.mb_str(wxConvLocal) ;
1300         TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)text.data(), strlen( text ) ,
1301           kTXNUseCurrentSelection, kTXNUseCurrentSelection);
1302 #endif
1303         GetSelection( &dummy , &end ) ;
1304         SetStyle( start , end , GetDefaultStyle() ) ;
1305         if ( !formerEditable )
1306             SetEditable( formerEditable ) ;
1307     }
1308     MacRedrawControl() ;
1309 }
1310
1311 void wxTextCtrl::AppendText(const wxString& text)
1312 {
1313     SetInsertionPointEnd();
1314     WriteText(text);
1315 }
1316
1317 void wxTextCtrl::Clear()
1318 {
1319     if ( !IsEditable() )
1320     {
1321         return ;
1322     }
1323     if ( !m_macUsesTXN )
1324     {
1325         ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char*) ((const char*)NULL) ) ;
1326     }
1327     else
1328     {
1329         TXNSetSelection( (TXNObject)m_macTXN , kTXNStartOffset , kTXNEndOffset ) ;
1330         TXNClear((TXNObject)m_macTXN);
1331     }
1332     Refresh() ;
1333 }
1334
1335 bool wxTextCtrl::IsModified() const
1336 {
1337     return m_dirty;
1338 }
1339
1340 bool wxTextCtrl::IsEditable() const
1341 {
1342     return IsEnabled() && m_editable ;
1343 }
1344
1345 bool wxTextCtrl::AcceptsFocus() const
1346 {
1347     // we don't want focus if we can't be edited
1348     return /*IsEditable() && */ wxControl::AcceptsFocus();
1349 }
1350
1351 wxSize wxTextCtrl::DoGetBestSize() const
1352 {
1353     int wText = 100 ;
1354
1355     int hText;
1356     if ( m_macUsesTXN )
1357     {
1358         hText = 17 ;
1359     }
1360     else
1361     {
1362         hText = 13 ;
1363     }
1364 /*
1365     int cx, cy;
1366     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
1367
1368     int wText = DEFAULT_ITEM_WIDTH;
1369
1370     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
1371
1372     return wxSize(wText, hText);
1373 */
1374     if ( m_windowStyle & wxTE_MULTILINE )
1375     {
1376          hText *= 5 ;
1377     }
1378     hText += 2 * m_macVerticalBorder ;
1379     wText += 2 * m_macHorizontalBorder ;
1380     //else: for single line control everything is ok
1381     return wxSize(wText, hText);
1382 }
1383
1384 // ----------------------------------------------------------------------------
1385 // Undo/redo
1386 // ----------------------------------------------------------------------------
1387
1388 void wxTextCtrl::Undo()
1389 {
1390     if (CanUndo())
1391     {
1392         if ( m_macUsesTXN )
1393         {
1394             TXNUndo((TXNObject)m_macTXN);
1395         }
1396     }
1397 }
1398
1399 void wxTextCtrl::Redo()
1400 {
1401     if (CanRedo())
1402     {
1403         if ( m_macUsesTXN )
1404         {
1405             TXNRedo((TXNObject)m_macTXN);
1406         }
1407     }
1408 }
1409
1410 bool wxTextCtrl::CanUndo() const
1411 {
1412     if ( !IsEditable() )
1413     {
1414         return false ;
1415     }
1416     if ( m_macUsesTXN )
1417     {
1418         return TXNCanUndo((TXNObject)m_macTXN,NULL);
1419     }
1420     return FALSE ;
1421 }
1422
1423 bool wxTextCtrl::CanRedo() const
1424 {
1425     if ( !IsEditable() )
1426     {
1427         return false ;
1428     }
1429     if ( m_macUsesTXN )
1430     {
1431         return TXNCanRedo((TXNObject)m_macTXN,NULL);
1432     }
1433     return FALSE ;
1434 }
1435
1436 // Makes modifie or unmodified
1437 void wxTextCtrl::MarkDirty()
1438 {
1439     m_dirty = true;
1440 }
1441
1442 void wxTextCtrl::DiscardEdits()
1443 {
1444     m_dirty = false;
1445 }
1446
1447 int wxTextCtrl::GetNumberOfLines() const
1448 {
1449     // TODO change this if possible to reflect real lines
1450     wxString content = GetValue() ;
1451
1452     int count = 1;
1453     for (size_t i = 0; i < content.Length() ; i++)
1454     {
1455         if (content[i] == '\r') count++;
1456     }
1457
1458     return count;
1459 }
1460
1461 long wxTextCtrl::XYToPosition(long x, long y) const
1462 {
1463     // TODO
1464     return 0;
1465 }
1466
1467 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
1468 {
1469     return FALSE ;
1470 }
1471
1472 void wxTextCtrl::ShowPosition(long pos)
1473 {
1474     // TODO
1475 }
1476
1477 int wxTextCtrl::GetLineLength(long lineNo) const
1478 {
1479     // TODO change this if possible to reflect real lines
1480     wxString content = GetValue() ;
1481
1482     // Find line first
1483     int count = 0;
1484     for (size_t i = 0; i < content.Length() ; i++)
1485     {
1486         if (count == lineNo)
1487         {
1488             // Count chars in line then
1489             count = 0;
1490             for (size_t j = i; j < content.Length(); j++)
1491             {
1492                 count++;
1493                 if (content[j] == '\n') return count;
1494             }
1495
1496             return count;
1497         }
1498         if (content[i] == '\n') count++;
1499     }
1500     return 0;
1501 }
1502
1503 wxString wxTextCtrl::GetLineText(long lineNo) const
1504 {
1505     // TODO change this if possible to reflect real lines
1506     wxString content = GetValue() ;
1507
1508     // Find line first
1509     int count = 0;
1510     for (size_t i = 0; i < content.Length() ; i++)
1511     {
1512         if (count == lineNo)
1513         {
1514             // Add chars in line then
1515             wxString tmp;
1516
1517             for (size_t j = i; j < content.Length(); j++)
1518             {
1519                 if (content[j] == '\n')
1520                     return tmp;
1521
1522                 tmp += content[j];
1523             }
1524
1525             return tmp;
1526         }
1527         if (content[i] == '\n') count++;
1528     }
1529     return wxEmptyString ;
1530 }
1531
1532 /*
1533  * Text item
1534  */
1535
1536 void wxTextCtrl::Command(wxCommandEvent & event)
1537 {
1538     SetValue (event.GetString());
1539     ProcessCommand (event);
1540 }
1541
1542 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1543 {
1544     // By default, load the first file into the text window.
1545     if (event.GetNumberOfFiles() > 0)
1546     {
1547         LoadFile(event.GetFiles()[0]);
1548     }
1549 }
1550
1551 void wxTextCtrl::OnChar(wxKeyEvent& event)
1552 {
1553     int key = event.GetKeyCode() ;
1554     bool eat_key = false ;
1555
1556     if ( key == 'c' && event.MetaDown() )
1557     {
1558         if ( CanCopy() )
1559             Copy() ;
1560         return ;
1561     }
1562
1563     if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
1564         !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
1565 /*        && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
1566         )
1567     {
1568         // eat it
1569         return ;
1570     }
1571
1572     // assume that any key not processed yet is going to modify the control
1573     m_dirty = true;
1574
1575     if ( key == 'v' && event.MetaDown() )
1576     {
1577         if ( CanPaste() )
1578             Paste() ;
1579         return ;
1580     }
1581     if ( key == 'x' && event.MetaDown() )
1582     {
1583         if ( CanCut() )
1584             Cut() ;
1585         return ;
1586     }
1587     switch ( key )
1588     {
1589         case WXK_RETURN:
1590             if (m_windowStyle & wxPROCESS_ENTER)
1591             {
1592                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1593                 event.SetEventObject( this );
1594                 event.SetString( GetValue() );
1595                 if ( GetEventHandler()->ProcessEvent(event) )
1596                     return;
1597             }
1598             if ( !(m_windowStyle & wxTE_MULTILINE) )
1599             {
1600                 wxWindow *parent = GetParent();
1601                 while( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL ) {
1602                   parent = parent->GetParent() ;
1603                 }
1604                 if ( parent && parent->GetDefaultItem() )
1605                 {
1606                     wxButton *def = wxDynamicCast(parent->GetDefaultItem(),
1607                                                           wxButton);
1608                     if ( def && def->IsEnabled() )
1609                     {
1610                         wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1611                         event.SetEventObject(def);
1612                         def->Command(event);
1613                         return ;
1614                    }
1615                 }
1616
1617                 // this will make wxWindows eat the ENTER key so that
1618                 // we actually prevent line wrapping in a single line
1619                 // text control
1620                 eat_key = TRUE;
1621             }
1622
1623             break;
1624
1625         case WXK_TAB:
1626             // always produce navigation event - even if we process TAB
1627             // ourselves the fact that we got here means that the user code
1628             // decided to skip processing of this TAB - probably to let it
1629             // do its default job.
1630             {
1631                 wxNavigationKeyEvent eventNav;
1632                 eventNav.SetDirection(!event.ShiftDown());
1633                 eventNav.SetWindowChange(event.ControlDown());
1634                 eventNav.SetEventObject(this);
1635
1636                 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
1637                     return;
1638
1639                 event.Skip() ;
1640                 return;
1641             }
1642             break;
1643     }
1644
1645     if (!eat_key)
1646     {
1647         // perform keystroke handling
1648 #if TARGET_CARBON
1649         if ( m_macUsesTXN && wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL )
1650             CallNextEventHandler((EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() , (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
1651         else
1652         {
1653             EventRecord rec ;
1654             if ( wxMacConvertEventToRecord(  (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) )
1655             {
1656                 EventRecord *ev = &rec ;
1657                 short keycode ;
1658                 short keychar ;
1659                 keychar = short(ev->message & charCodeMask);
1660                 keycode = short(ev->message & keyCodeMask) >> 8 ;
1661
1662                 ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers ) ;
1663             }
1664         }
1665 #else
1666         EventRecord *ev = (EventRecord*) wxTheApp->MacGetCurrentEvent() ;
1667         short keycode ;
1668         short keychar ;
1669         keychar = short(ev->message & charCodeMask);
1670         keycode = short(ev->message & keyCodeMask) >> 8 ;
1671
1672         ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers ) ;
1673 #endif
1674     }
1675     if ( ( key >= 0x20 && key < WXK_START ) ||
1676          key == WXK_RETURN ||
1677          key == WXK_DELETE ||
1678          key == WXK_BACK)
1679     {
1680         wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1681         event1.SetString( GetValue() ) ;
1682         event1.SetEventObject( this );
1683         wxPostEvent(GetEventHandler(),event1);
1684     }
1685 }
1686
1687 void  wxTextCtrl::MacSuperShown( bool show )
1688 {
1689     bool former = m_macControlIsShown ;
1690     wxControl::MacSuperShown( show ) ;
1691     if ( (former != m_macControlIsShown) && m_macUsesTXN )
1692     {
1693         if ( m_macControlIsShown )
1694             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1695                 (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom,(**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1696         else
1697             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1698                (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1699     }
1700 }
1701
1702 bool  wxTextCtrl::Show(bool show)
1703 {
1704     bool former = m_macControlIsShown ;
1705
1706     bool retval = wxControl::Show( show ) ;
1707
1708     if ( former != m_macControlIsShown && m_macUsesTXN )
1709     {
1710         if ( m_macControlIsShown )
1711             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1712                 (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom,(**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1713         else
1714             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1715                (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1716     }
1717
1718     return retval ;
1719 }
1720
1721 // ----------------------------------------------------------------------------
1722 // standard handlers for standard edit menu events
1723 // ----------------------------------------------------------------------------
1724
1725 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1726 {
1727     Cut();
1728 }
1729
1730 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1731 {
1732     Copy();
1733 }
1734
1735 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1736 {
1737     Paste();
1738 }
1739
1740 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1741 {
1742     Undo();
1743 }
1744
1745 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1746 {
1747     Redo();
1748 }
1749
1750 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1751 {
1752     event.Enable( CanCut() );
1753 }
1754
1755 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1756 {
1757     event.Enable( CanCopy() );
1758 }
1759
1760 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1761 {
1762     event.Enable( CanPaste() );
1763 }
1764
1765 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1766 {
1767     event.Enable( CanUndo() );
1768 }
1769
1770 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1771 {
1772     event.Enable( CanRedo() );
1773 }
1774
1775 bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
1776 {
1777     if ( m_macUsesTXN )
1778         return true ;
1779     else
1780         return wxWindow::MacSetupCursor( pt ) ;
1781 }
1782
1783 #endif
1784     // wxUSE_TEXTCTRL