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     wxMacConvertNewlines13To10( &st ) ;
 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     wxMacConvertNewlines10To13( &result ) ;
 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     wxMacConvertNewlines13To10( &st ) ;
 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     wxMacConvertNewlines13To10( &value ) ;
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     wxMacConvertNewlines13To10( &st ) ;
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 ( !m_macUsesTXN )
1320     {
1321         ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char*) ((const char*)NULL) ) ;
1322     }
1323     else
1324     {
1325         TXNSetSelection( (TXNObject)m_macTXN , kTXNStartOffset , kTXNEndOffset ) ;
1326         TXNClear((TXNObject)m_macTXN);
1327     }
1328     Refresh() ;
1329 }
1330
1331 bool wxTextCtrl::IsModified() const
1332 {
1333     return m_dirty;
1334 }
1335
1336 bool wxTextCtrl::IsEditable() const
1337 {
1338     return IsEnabled() && m_editable ;
1339 }
1340
1341 bool wxTextCtrl::AcceptsFocus() const
1342 {
1343     // we don't want focus if we can't be edited
1344     return /*IsEditable() && */ wxControl::AcceptsFocus();
1345 }
1346
1347 wxSize wxTextCtrl::DoGetBestSize() const
1348 {
1349     int wText = 100 ;
1350
1351     int hText;
1352     if ( m_macUsesTXN )
1353     {
1354         hText = 17 ;
1355     }
1356     else
1357     {
1358         hText = 13 ;
1359     }
1360 /*
1361     int cx, cy;
1362     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
1363
1364     int wText = DEFAULT_ITEM_WIDTH;
1365
1366     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
1367
1368     return wxSize(wText, hText);
1369 */
1370     if ( m_windowStyle & wxTE_MULTILINE )
1371     {
1372          hText *= 5 ;
1373     }
1374     hText += 2 * m_macVerticalBorder ;
1375     wText += 2 * m_macHorizontalBorder ;
1376     //else: for single line control everything is ok
1377     return wxSize(wText, hText);
1378 }
1379
1380 // ----------------------------------------------------------------------------
1381 // Undo/redo
1382 // ----------------------------------------------------------------------------
1383
1384 void wxTextCtrl::Undo()
1385 {
1386     if (CanUndo())
1387     {
1388         if ( m_macUsesTXN )
1389         {
1390             TXNUndo((TXNObject)m_macTXN);
1391         }
1392     }
1393 }
1394
1395 void wxTextCtrl::Redo()
1396 {
1397     if (CanRedo())
1398     {
1399         if ( m_macUsesTXN )
1400         {
1401             TXNRedo((TXNObject)m_macTXN);
1402         }
1403     }
1404 }
1405
1406 bool wxTextCtrl::CanUndo() const
1407 {
1408     if ( !IsEditable() )
1409     {
1410         return false ;
1411     }
1412     if ( m_macUsesTXN )
1413     {
1414         return TXNCanUndo((TXNObject)m_macTXN,NULL);
1415     }
1416     return FALSE ;
1417 }
1418
1419 bool wxTextCtrl::CanRedo() const
1420 {
1421     if ( !IsEditable() )
1422     {
1423         return false ;
1424     }
1425     if ( m_macUsesTXN )
1426     {
1427         return TXNCanRedo((TXNObject)m_macTXN,NULL);
1428     }
1429     return FALSE ;
1430 }
1431
1432 // Makes modifie or unmodified
1433 void wxTextCtrl::MarkDirty()
1434 {
1435     m_dirty = true;
1436 }
1437
1438 void wxTextCtrl::DiscardEdits()
1439 {
1440     m_dirty = false;
1441 }
1442
1443 int wxTextCtrl::GetNumberOfLines() const
1444 {
1445     // TODO change this if possible to reflect real lines
1446     wxString content = GetValue() ;
1447
1448     int count = 1;
1449     for (size_t i = 0; i < content.Length() ; i++)
1450     {
1451         if (content[i] == '\r') count++;
1452     }
1453
1454     return count;
1455 }
1456
1457 long wxTextCtrl::XYToPosition(long x, long y) const
1458 {
1459     // TODO
1460     return 0;
1461 }
1462
1463 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
1464 {
1465     return FALSE ;
1466 }
1467
1468 void wxTextCtrl::ShowPosition(long pos)
1469 {
1470     // TODO
1471 }
1472
1473 int wxTextCtrl::GetLineLength(long lineNo) const
1474 {
1475     // TODO change this if possible to reflect real lines
1476     wxString content = GetValue() ;
1477
1478     // Find line first
1479     int count = 0;
1480     for (size_t i = 0; i < content.Length() ; i++)
1481     {
1482         if (count == lineNo)
1483         {
1484             // Count chars in line then
1485             count = 0;
1486             for (size_t j = i; j < content.Length(); j++)
1487             {
1488                 count++;
1489                 if (content[j] == '\n') return count;
1490             }
1491
1492             return count;
1493         }
1494         if (content[i] == '\n') count++;
1495     }
1496     return 0;
1497 }
1498
1499 wxString wxTextCtrl::GetLineText(long lineNo) const
1500 {
1501     // TODO change this if possible to reflect real lines
1502     wxString content = GetValue() ;
1503
1504     // Find line first
1505     int count = 0;
1506     for (size_t i = 0; i < content.Length() ; i++)
1507     {
1508         if (count == lineNo)
1509         {
1510             // Add chars in line then
1511             wxString tmp;
1512
1513             for (size_t j = i; j < content.Length(); j++)
1514             {
1515                 if (content[j] == '\n')
1516                     return tmp;
1517
1518                 tmp += content[j];
1519             }
1520
1521             return tmp;
1522         }
1523         if (content[i] == '\n') count++;
1524     }
1525     return wxEmptyString ;
1526 }
1527
1528 /*
1529  * Text item
1530  */
1531
1532 void wxTextCtrl::Command(wxCommandEvent & event)
1533 {
1534     SetValue (event.GetString());
1535     ProcessCommand (event);
1536 }
1537
1538 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1539 {
1540     // By default, load the first file into the text window.
1541     if (event.GetNumberOfFiles() > 0)
1542     {
1543         LoadFile(event.GetFiles()[0]);
1544     }
1545 }
1546
1547 void wxTextCtrl::OnChar(wxKeyEvent& event)
1548 {
1549     int key = event.GetKeyCode() ;
1550     bool eat_key = false ;
1551
1552     if ( key == 'c' && event.MetaDown() )
1553     {
1554         if ( CanCopy() )
1555             Copy() ;
1556         return ;
1557     }
1558
1559     if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
1560         !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
1561 /*        && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
1562         )
1563     {
1564         // eat it
1565         return ;
1566     }
1567
1568     // assume that any key not processed yet is going to modify the control
1569     m_dirty = true;
1570
1571     if ( key == 'v' && event.MetaDown() )
1572     {
1573         if ( CanPaste() )
1574             Paste() ;
1575         return ;
1576     }
1577     if ( key == 'x' && event.MetaDown() )
1578     {
1579         if ( CanCut() )
1580             Cut() ;
1581         return ;
1582     }
1583     switch ( key )
1584     {
1585         case WXK_RETURN:
1586             if (m_windowStyle & wxPROCESS_ENTER)
1587             {
1588                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1589                 event.SetEventObject( this );
1590                 event.SetString( GetValue() );
1591                 if ( GetEventHandler()->ProcessEvent(event) )
1592                     return;
1593             }
1594             if ( !(m_windowStyle & wxTE_MULTILINE) )
1595             {
1596                 wxWindow *parent = GetParent();
1597                 while( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL ) {
1598                   parent = parent->GetParent() ;
1599                 }
1600                 if ( parent && parent->GetDefaultItem() )
1601                 {
1602                     wxButton *def = wxDynamicCast(parent->GetDefaultItem(),
1603                                                           wxButton);
1604                     if ( def && def->IsEnabled() )
1605                     {
1606                         wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1607                         event.SetEventObject(def);
1608                         def->Command(event);
1609                         return ;
1610                    }
1611                 }
1612
1613                 // this will make wxWindows eat the ENTER key so that
1614                 // we actually prevent line wrapping in a single line
1615                 // text control
1616                 eat_key = TRUE;
1617             }
1618
1619             break;
1620
1621         case WXK_TAB:
1622             // always produce navigation event - even if we process TAB
1623             // ourselves the fact that we got here means that the user code
1624             // decided to skip processing of this TAB - probably to let it
1625             // do its default job.
1626             {
1627                 wxNavigationKeyEvent eventNav;
1628                 eventNav.SetDirection(!event.ShiftDown());
1629                 eventNav.SetWindowChange(event.ControlDown());
1630                 eventNav.SetEventObject(this);
1631
1632                 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
1633                     return;
1634
1635                 event.Skip() ;
1636                 return;
1637             }
1638             break;
1639     }
1640
1641     if (!eat_key)
1642     {
1643         // perform keystroke handling
1644 #if TARGET_CARBON
1645         if ( m_macUsesTXN && wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL )
1646             CallNextEventHandler((EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() , (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
1647         else
1648         {
1649             EventRecord rec ;
1650             if ( wxMacConvertEventToRecord(  (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) )
1651             {
1652                 EventRecord *ev = &rec ;
1653                 short keycode ;
1654                 short keychar ;
1655                 keychar = short(ev->message & charCodeMask);
1656                 keycode = short(ev->message & keyCodeMask) >> 8 ;
1657
1658                 ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers ) ;
1659             }
1660         }
1661 #else
1662         EventRecord *ev = (EventRecord*) wxTheApp->MacGetCurrentEvent() ;
1663         short keycode ;
1664         short keychar ;
1665         keychar = short(ev->message & charCodeMask);
1666         keycode = short(ev->message & keyCodeMask) >> 8 ;
1667
1668         ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers ) ;
1669 #endif
1670     }
1671     if ( ( key >= 0x20 && key < WXK_START ) ||
1672          key == WXK_RETURN ||
1673          key == WXK_DELETE ||
1674          key == WXK_BACK)
1675     {
1676         wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1677         event1.SetString( GetValue() ) ;
1678         event1.SetEventObject( this );
1679         wxPostEvent(GetEventHandler(),event1);
1680     }
1681 }
1682
1683 void  wxTextCtrl::MacSuperShown( bool show )
1684 {
1685     bool former = m_macControlIsShown ;
1686     wxControl::MacSuperShown( show ) ;
1687     if ( (former != m_macControlIsShown) && m_macUsesTXN )
1688     {
1689         if ( m_macControlIsShown )
1690             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1691                 (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom,(**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1692         else
1693             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1694                (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1695     }
1696 }
1697
1698 bool  wxTextCtrl::Show(bool show)
1699 {
1700     bool former = m_macControlIsShown ;
1701
1702     bool retval = wxControl::Show( show ) ;
1703
1704     if ( former != m_macControlIsShown && m_macUsesTXN )
1705     {
1706         if ( m_macControlIsShown )
1707             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1708                 (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom,(**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1709         else
1710             TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left,
1711                (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
1712     }
1713
1714     return retval ;
1715 }
1716
1717 // ----------------------------------------------------------------------------
1718 // standard handlers for standard edit menu events
1719 // ----------------------------------------------------------------------------
1720
1721 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1722 {
1723     Cut();
1724 }
1725
1726 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1727 {
1728     Copy();
1729 }
1730
1731 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1732 {
1733     Paste();
1734 }
1735
1736 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1737 {
1738     Undo();
1739 }
1740
1741 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1742 {
1743     Redo();
1744 }
1745
1746 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1747 {
1748     event.Enable( CanCut() );
1749 }
1750
1751 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1752 {
1753     event.Enable( CanCopy() );
1754 }
1755
1756 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1757 {
1758     event.Enable( CanPaste() );
1759 }
1760
1761 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1762 {
1763     event.Enable( CanUndo() );
1764 }
1765
1766 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1767 {
1768     event.Enable( CanRedo() );
1769 }
1770
1771 bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
1772 {
1773     if ( m_macUsesTXN )
1774         return true ;
1775     else
1776         return wxWindow::MacSetupCursor( pt ) ;
1777 }
1778
1779 #endif
1780     // wxUSE_TEXTCTRL