src/mac/textctrl.cpp

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