src/mac/carbon/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 #include <fstream.h>
  27
  28 #include "wx/app.h"
  29 #include "wx/dc.h"
  30 #include "wx/button.h"
  31 #include "wx/toplevel.h"
  32 #include "wx/textctrl.h"
  33 #include "wx/notebook.h"
  34 #include "wx/tabctrl.h"
  35 #include "wx/settings.h"
  36 #include "wx/filefn.h"
  37 #include "wx/utils.h"
  38
  39 #if defined(__BORLANDC__) && !defined(__WIN32__)
  40   #include <alloc.h>
  41 #elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
  42   #include <malloc.h>
  43 #endif
  44
  45 #ifndef __DARWIN__
  46 #include <Scrap.h>
  47 #endif
  48 #include <MacTextEditor.h>
  49 #include "ATSUnicode.h"
  50 #include "TextCommon.h"
  51 #include "TextEncodingConverter.h"
  52 #include "wx/mac/uma.h"
  53
  54 extern wxApp *wxTheApp ;
  55 // CS:We will replace the TextEdit by using the MultiLanguageTextEngine based on the following code written by apple
  56
  57 /*
  58     File: mUPControl.c
  59
  60     Description:
  61         mUPControl implementation.
  62
  63     Copyright:
  64         © Copyright 2000 Apple Computer, Inc. All rights reserved.
  65
  66     Disclaimer:
  67         IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
  68         ("Apple") in consideration of your agreement to the following terms, and your
  69         use, installation, modification or redistribution of this Apple software
  70         constitutes acceptance of these terms.  If you do not agree with these terms,
  71         please do not use, install, modify or redistribute this Apple software.
  72
  73         In consideration of your agreement to abide by the following terms, and subject
  74         to these terms, Apple grants you a personal, non-exclusive license, under AppleÕs
  75         copyrights in this original Apple software (the "Apple Software"), to use,
  76         reproduce, modify and redistribute the Apple Software, with or without
  77         modifications, in source and/or binary forms; provided that if you redistribute
  78         the Apple Software in its entirety and without modifications, you must retain
  79         this notice and the following text and disclaimers in all such redistributions of
  80         the Apple Software.  Neither the name, trademarks, service marks or logos of
  81         Apple Computer, Inc. may be used to endorse or promote products derived from the
  82         Apple Software without specific prior written permission from Apple.  Except as
  83         expressly stated in this notice, no other rights or licenses, express or implied,
  84         are granted by Apple herein, including but not limited to any patent rights that
  85         may be infringed by your derivative works or by other works in which the Apple
  86         Software may be incorporated.
  87
  88         The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
  89         WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
  90         WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  91         PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
  92         COMBINATION WITH YOUR PRODUCTS.
  93
  94         IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
  95         CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  96         GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  97         ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
  98         OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
  99         (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
 100         ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 101
 102     Change History (most recent first):
 103         Fri, Jan 28, 2000 -- created
 104 */
 105
 106 #include "MacTextEditor.h"
 107
 108 /* part codes */
 109
 110 /* kmUPTextPart is the part code we return to indicate the user has clicked
 111     in the text area of our control */
 112 #define kmUPTextPart 1
 113
 114 /* kmUPScrollPart is the part code we return to indicate the user has clicked
 115     in the scroll bar part of the control. */
 116 #define kmUPScrollPart 2
 117
 118
 119 /* routines for using existing user pane controls.
 120     These routines are useful for cases where you would like to use an
 121     existing user pane control in, say, a dialog window as a scrolling
 122     text edit field.*/
 123
 124 /* mUPOpenControl initializes a user pane control so it will be drawn
 125     and will behave as a scrolling text edit field inside of a window.
 126     This routine performs all of the initialization steps necessary,
 127     except it does not create the user pane control itself.  theControl
 128     should refer to a user pane control that you have either created
 129     yourself or extracted from a dialog's control heirarchy using
 130     the GetDialogItemAsControl routine.  */
 131 OSStatus mUPOpenControl(ControlHandle theControl, bool multiline);
 132
 133 /* Utility Routines */
 134
 135 enum {
 136     kShiftKeyCode = 56
 137 };
 138
 139 /* kUserClickedToFocusPart is a part code we pass to the SetKeyboardFocus
 140     routine.  In our focus switching routine this part code is understood
 141     as meaning 'the user has clicked in the control and we need to switch
 142     the current focus to ourselves before we can continue'. */
 143 #define kUserClickedToFocusPart 100
 144
 145
 146 /* kmUPClickScrollDelayTicks is a time measurement in ticks used to
 147     slow the speed of 'auto scrolling' inside of our clickloop routine.
 148     This value prevents the text from wizzzzzing by while the mouse
 149     is being held down inside of the text area. */
 150 #define kmUPClickScrollDelayTicks 3
 151
 152
 153 /* STPTextPaneVars is a structure used for storing the the mUP Control's
 154     internal variables and state information.  A handle to this record is
 155     stored in the pane control's reference value field using the
 156     SetControlReference routine. */
 157
 158 typedef struct {
 159         /* OS records referenced */
 160     TXNObject fTXNRec; /* the txn record */
 161     TXNFrameID fTXNFrame; /* the txn frame ID */
 162         bool fMultiline ;
 163     ControlHandle fUserPaneRec;  /* handle to the user pane control */
 164     WindowPtr fOwner; /* window containing control */
 165     GrafPtr fDrawingEnvironment; /* grafport where control is drawn */
 166         /* flags */
 167     Boolean fInFocus; /* true while the focus rect is drawn around the control */
 168     Boolean fIsActive; /* true while the control is drawn in the active state */
 169     Boolean fTEActive; /* reflects the activation state of the text edit record */
 170     Boolean fInDialogWindow; /* true if displayed in a dialog window */
 171         /* calculated locations */
 172     Rect fRTextArea; /* area where the text is drawn */
 173     Rect fRFocusOutline;  /* rectangle used to draw the focus box */
 174     Rect fRTextOutline; /* rectangle used to draw the border */
 175     RgnHandle fTextBackgroundRgn; /* background region for the text, erased before calling TEUpdate */
 176         /* our focus advance override routine */
 177     EventHandlerUPP handlerUPP;
 178     EventHandlerRef handlerRef;
 179 } STPTextPaneVars;
 180
 181
 182
 183
 184 /* Univerals Procedure Pointer variables used by the
 185     mUP Control.  These variables are set up
 186     the first time that mUPOpenControl is called. */
 187 ControlUserPaneDrawUPP gTPDrawProc = NULL;
 188 ControlUserPaneHitTestUPP gTPHitProc = NULL;
 189 ControlUserPaneTrackingUPP gTPTrackProc = NULL;
 190 ControlUserPaneIdleUPP gTPIdleProc = NULL;
 191 ControlUserPaneKeyDownUPP gTPKeyProc = NULL;
 192 ControlUserPaneActivateUPP gTPActivateProc = NULL;
 193 ControlUserPaneFocusUPP gTPFocusProc = NULL;
 194
 195     /* events handled by our focus advance override routine */
 196 #if TARGET_CARBON
 197 //static const EventTypeSpec gMLTEEvents[] = { { kEventClassTextInput, kEventUnicodeForKeyEvent } };
 198 //#define kMLTEEventCount (sizeof( gMLTEEvents ) / sizeof( EventTypeSpec ))
 199 #endif
 200
 201
 202 /* TPActivatePaneText activates or deactivates the text edit record
 203     according to the value of setActive.  The primary purpose of this
 204     routine is to ensure each call is only made once. */
 205 static void TPActivatePaneText(STPTextPaneVars **tpvars, Boolean setActive) {
 206     STPTextPaneVars *varsp;
 207     varsp = *tpvars;
 208     if (varsp->fTEActive != setActive) {
 209
 210         varsp->fTEActive = setActive;
 211
 212         TXNActivate(varsp->fTXNRec, varsp->fTXNFrame, varsp->fTEActive);
 213
 214         if (varsp->fInFocus)
 215             TXNFocus( varsp->fTXNRec, varsp->fTEActive);
 216     }
 217 }
 218
 219
 220 /* TPFocusPaneText set the focus state for the text record. */
 221 static void TPFocusPaneText(STPTextPaneVars **tpvars, Boolean setFocus) {
 222     STPTextPaneVars *varsp;
 223     varsp = *tpvars;
 224     if (varsp->fInFocus != setFocus) {
 225         varsp->fInFocus = setFocus;
 226         TXNFocus( varsp->fTXNRec, varsp->fInFocus);
 227     }
 228 }
 229
 230
 231 /* TPPaneDrawProc is called to redraw the control and for update events
 232     referring to the control.  This routine erases the text area's background,
 233     and redraws the text.  This routine assumes the scroll bar has been
 234     redrawn by a call to DrawControls. */
 235 static pascal void TPPaneDrawProc(ControlRef theControl, ControlPartCode thePart) {
 236     STPTextPaneVars **tpvars, *varsp;
 237     char state;
 238     Rect bounds;
 239         /* set up our globals */
 240     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 241     if (tpvars != NULL) {
 242         state = HGetState((Handle) tpvars);
 243         HLock((Handle) tpvars);
 244         varsp = *tpvars;
 245
 246             /* save the drawing state */
 247         SetPort((**tpvars).fDrawingEnvironment);
 248             /* verify our boundary */
 249         GetControlBounds(theControl, &bounds);
 250                 if ( ! EqualRect(&bounds, &varsp->fRFocusOutline) ) {
 251                     // scrollbar is on the border, we add one
 252                     Rect oldbounds = varsp->fRFocusOutline ;
 253                     InsetRect( &oldbounds , -1 , -1 ) ;
 254
 255 //                  InvalWindowRect( GetControlOwner( theControl ) , &oldbounds ) ;
 256                         SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
 257                         SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
 258                 SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) ,
 259                     bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
 260             RectRgn(varsp->fTextBackgroundRgn, &varsp->fRTextOutline);
 261                         TXNSetFrameBounds(  varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
 262                             varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
 263         }
 264
 265             /* update the text region */
 266                 RGBColor white = { 65535 , 65535 , 65535 } ;
 267                 RGBBackColor( &white ) ;
 268         EraseRgn(varsp->fTextBackgroundRgn);
 269         TXNDraw(varsp->fTXNRec, NULL);
 270             /* restore the drawing environment */
 271             /* draw the text frame and focus frame (if necessary) */
 272         DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
 273         if ((**tpvars).fIsActive && varsp->fInFocus) DrawThemeFocusRect(&varsp->fRFocusOutline, true);
 274             /* release our globals */
 275         HSetState((Handle) tpvars, state);
 276     }
 277 }
 278
 279
 280 /* TPPaneHitTestProc is called when the control manager would
 281     like to determine what part of the control the mouse resides over.
 282     We also call this routine from our tracking proc to determine how
 283     to handle mouse clicks. */
 284 static pascal ControlPartCode TPPaneHitTestProc(ControlHandle theControl, Point where) {
 285     STPTextPaneVars **tpvars;
 286     ControlPartCode result;
 287     char state;
 288         /* set up our locals and lock down our globals*/
 289     result = 0;
 290     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 291     if (tpvars != NULL) {
 292         state = HGetState((Handle) tpvars);
 293         HLock((Handle) tpvars);
 294             /* find the region where we clicked */
 295         if (PtInRect(where, &(**tpvars).fRTextArea)) {
 296             result = kmUPTextPart;
 297         } else result = 0;
 298             /* release oure globals */
 299         HSetState((Handle) tpvars, state);
 300     }
 301     return result;
 302 }
 303
 304
 305
 306
 307
 308 /* TPPaneTrackingProc is called when the mouse is being held down
 309     over our control.  This routine handles clicks in the text area
 310     and in the scroll bar. */
 311 static pascal ControlPartCode TPPaneTrackingProc(ControlHandle theControl, Point startPt, ControlActionUPP actionProc) {
 312     STPTextPaneVars **tpvars, *varsp;
 313     char state;
 314     ControlPartCode partCodeResult;
 315         /* make sure we have some variables... */
 316     partCodeResult = 0;
 317     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 318     if (tpvars != NULL) {
 319             /* lock 'em down */
 320         state = HGetState((Handle) tpvars);
 321         HLock((Handle) tpvars);
 322         varsp = *tpvars;
 323             /* we don't do any of these functions unless we're in focus */
 324         if ( ! varsp->fInFocus) {
 325             WindowPtr owner;
 326             owner = GetControlOwner(theControl);
 327             ClearKeyboardFocus(owner);
 328             SetKeyboardFocus(owner, theControl, kUserClickedToFocusPart);
 329         }
 330             /* find the location for the click */
 331         switch (TPPaneHitTestProc(theControl, startPt)) {
 332
 333                 /* handle clicks in the text part */
 334             case kmUPTextPart:
 335                 {   SetPort((**tpvars).fDrawingEnvironment);
 336                     TXNClick( varsp->fTXNRec, (const EventRecord*) wxTheApp->MacGetCurrentEvent());
 337                 }
 338                 break;
 339
 340         }
 341
 342         HSetState((Handle) tpvars, state);
 343     }
 344     return partCodeResult;
 345 }
 346
 347
 348 /* TPPaneIdleProc is our user pane idle routine.  When our text field
 349     is active and in focus, we use this routine to set the cursor. */
 350 static pascal void TPPaneIdleProc(ControlHandle theControl) {
 351     STPTextPaneVars **tpvars, *varsp;
 352         /* set up locals */
 353     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 354     if (tpvars != NULL) {
 355             /* if we're not active, then we have nothing to say about the cursor */
 356         if ((**tpvars).fIsActive) {
 357             char state;
 358             Rect bounds;
 359             Point mousep;
 360                 /* lock down the globals */
 361             state = HGetState((Handle) tpvars);
 362             HLock((Handle) tpvars);
 363             varsp = *tpvars;
 364                 /* get the current mouse coordinates (in our window) */
 365             SetPortWindowPort(GetControlOwner(theControl));
 366             GetMouse(&mousep);
 367                 /* there's a 'focus thing' and an 'unfocused thing' */
 368             if (varsp->fInFocus) {
 369                     /* flash the cursor */
 370                 SetPort((**tpvars).fDrawingEnvironment);
 371                 TXNIdle(varsp->fTXNRec);
 372                 /* set the cursor */
 373                 if (PtInRect(mousep, &varsp->fRTextArea)) {
 374                     RgnHandle theRgn;
 375                     RectRgn((theRgn = NewRgn()), &varsp->fRTextArea);
 376                     TXNAdjustCursor(varsp->fTXNRec, theRgn);
 377                     DisposeRgn(theRgn);
 378                  } else SetThemeCursor(kThemeArrowCursor);
 379             } else {
 380                 /* if it's in our bounds, set the cursor */
 381                 GetControlBounds(theControl, &bounds);
 382                 if (PtInRect(mousep, &bounds))
 383                     SetThemeCursor(kThemeArrowCursor);
 384             }
 385
 386             HSetState((Handle) tpvars, state);
 387         }
 388     }
 389 }
 390
 391
 392 /* TPPaneKeyDownProc is called whenever a keydown event is directed
 393     at our control.  Here, we direct the keydown event to the text
 394     edit record and redraw the scroll bar and text field as appropriate. */
 395 static pascal ControlPartCode TPPaneKeyDownProc(ControlHandle theControl,
 396                             SInt16 keyCode, SInt16 charCode, SInt16 modifiers) {
 397     STPTextPaneVars **tpvars;
 398     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 399     if (tpvars != NULL) {
 400         if ((**tpvars).fInFocus) {
 401                 /* turn autoscrolling on and send the key event to text edit */
 402             SetPort((**tpvars).fDrawingEnvironment);
 403             TXNKeyDown( (**tpvars).fTXNRec, (const EventRecord*) wxTheApp->MacGetCurrentEvent());
 404         }
 405     }
 406     return kControlEntireControl;
 407 }
 408
 409
 410 /* TPPaneActivateProc is called when the window containing
 411     the user pane control receives activate events. Here, we redraw
 412     the control and it's text as necessary for the activation state. */
 413 static pascal void TPPaneActivateProc(ControlHandle theControl, Boolean activating) {
 414     Rect bounds;
 415     STPTextPaneVars **tpvars, *varsp;
 416     char state;
 417         /* set up locals */
 418     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 419     if (tpvars != NULL) {
 420         state = HGetState((Handle) tpvars);
 421         HLock((Handle) tpvars);
 422         varsp = *tpvars;
 423             /* de/activate the text edit record */
 424         SetPort((**tpvars).fDrawingEnvironment);
 425             GetControlBounds(theControl, &bounds);
 426             varsp->fIsActive = activating;
 427             TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
 428             /* redraw the frame */
 429         DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
 430         if (varsp->fInFocus) DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fIsActive);
 431         HSetState((Handle) tpvars, state);
 432     }
 433 }
 434
 435
 436 /* TPPaneFocusProc is called when every the focus changes to or
 437     from our control.  Herein, switch the focus appropriately
 438     according to the parameters and redraw the control as
 439     necessary.  */
 440 static pascal ControlPartCode TPPaneFocusProc(ControlHandle theControl, ControlFocusPart action) {
 441     ControlPartCode focusResult;
 442     STPTextPaneVars **tpvars, *varsp;
 443     char state;
 444         /* set up locals */
 445     focusResult = kControlFocusNoPart;
 446     tpvars = (STPTextPaneVars **) GetControlReference(theControl);
 447     if (tpvars != NULL) {
 448         state = HGetState((Handle) tpvars);
 449         HLock((Handle) tpvars);
 450         varsp = *tpvars;
 451             /* if kControlFocusPrevPart and kControlFocusNextPart are received when the user is
 452             tabbing forwards (or shift tabbing backwards) through the items in the dialog,
 453             and kControlFocusNextPart will be received.  When the user clicks in our field
 454             and it is not the current focus, then the constant kUserClickedToFocusPart will
 455             be received.  The constant kControlFocusNoPart will be received when our control
 456             is the current focus and the user clicks in another control.  In your focus routine,
 457             you should respond to these codes as follows:
 458
 459             kControlFocusNoPart - turn off focus and return kControlFocusNoPart.  redraw
 460                 the control and the focus rectangle as necessary.
 461
 462             kControlFocusPrevPart or kControlFocusNextPart - toggle focus on or off
 463                 depending on its current state.  redraw the control and the focus rectangle
 464                 as appropriate for the new focus state.  If the focus state is 'off', return the constant
 465                 kControlFocusNoPart, otherwise return a non-zero part code.
 466             kUserClickedToFocusPart - is a constant defined for this example.  You should
 467                 define your own value for handling click-to-focus type events. */
 468             /* save the drawing state */
 469         SetPort((**tpvars).fDrawingEnvironment);
 470             /* calculate the next highlight state */
 471         switch (action) {
 472             default:
 473             case kControlFocusNoPart:
 474                 TPFocusPaneText(tpvars, false);
 475                 focusResult = kControlFocusNoPart;
 476                 break;
 477             case kUserClickedToFocusPart:
 478                 TPFocusPaneText(tpvars, true);
 479                 focusResult = 1;
 480                 break;
 481             case kControlFocusPrevPart:
 482             case kControlFocusNextPart:
 483                 TPFocusPaneText(tpvars, ( ! varsp->fInFocus));
 484                 focusResult = varsp->fInFocus ? 1 : kControlFocusNoPart;
 485                 break;
 486         }
 487             TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
 488             /* redraw the text fram and focus rectangle to indicate the
 489             new focus state */
 490         DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
 491         DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fIsActive && varsp->fInFocus);
 492             /* done */
 493         HSetState((Handle) tpvars, state);
 494     }
 495     return focusResult;
 496 }
 497
 498 //This our carbon event handler for unicode key downs
 499 #if TARGET_CARBON
 500 static pascal OSStatus FocusAdvanceOverride(EventHandlerCallRef myHandler, EventRef event, void* userData) {
 501     WindowRef window;
 502     STPTextPaneVars **tpvars;
 503     OSStatus err;
 504     unsigned short mUnicodeText;
 505     ByteCount charCounts=0;
 506         /* get our window pointer */
 507     tpvars = (STPTextPaneVars **) userData;
 508     window = (**tpvars).fOwner;
 509         //find out how many bytes are needed
 510     err = GetEventParameter(event, kEventParamTextInputSendText,
 511                 typeUnicodeText, NULL, 0, &charCounts, NULL);
 512     if (err != noErr) goto bail;
 513         /* we're only looking at single characters */
 514     if (charCounts != 2) { err = eventNotHandledErr; goto bail; }
 515         /* get the character */
 516     err = GetEventParameter(event, kEventParamTextInputSendText,
 517                 typeUnicodeText, NULL, sizeof(mUnicodeText),
 518                 &charCounts, (char*) &mUnicodeText);
 519     if (err != noErr) goto bail;
 520         /* if it's not the tab key, forget it... */
 521     if ((mUnicodeText != '\t')) { err = eventNotHandledErr; goto bail; }
 522         /* advance the keyboard focus */
 523     AdvanceKeyboardFocus(window);
 524         /* noErr lets the CEM know we handled the event */
 525     return noErr;
 526 bail:
 527     return eventNotHandledErr;
 528 }
 529 #endif
 530
 531
 532 /* mUPOpenControl initializes a user pane control so it will be drawn
 533         and will behave as a scrolling text edit field inside of a window.
 534         This routine performs all of the initialization steps necessary,
 535         except it does not create the user pane control itself.  theControl
 536         should refer to a user pane control that you have either created
 537         yourself or extracted from a dialog's control heirarchy using
 538         the GetDialogItemAsControl routine.  */
 539 OSStatus mUPOpenControl(ControlHandle theControl, bool multiline)
 540 {
 541         Rect bounds;
 542         WindowRef theWindow;
 543         STPTextPaneVars **tpvars, *varsp;
 544         OSStatus err;
 545         RGBColor rgbWhite = {0xFFFF, 0xFFFF, 0xFFFF};
 546         TXNBackground tback;
 547
 548                 /* set up our globals */
 549         if (gTPDrawProc == NULL) gTPDrawProc = NewControlUserPaneDrawUPP(TPPaneDrawProc);
 550         if (gTPHitProc == NULL) gTPHitProc = NewControlUserPaneHitTestUPP(TPPaneHitTestProc);
 551         if (gTPTrackProc == NULL) gTPTrackProc = NewControlUserPaneTrackingUPP(TPPaneTrackingProc);
 552         if (gTPIdleProc == NULL) gTPIdleProc = NewControlUserPaneIdleUPP(TPPaneIdleProc);
 553         if (gTPKeyProc == NULL) gTPKeyProc = NewControlUserPaneKeyDownUPP(TPPaneKeyDownProc);
 554         if (gTPActivateProc == NULL) gTPActivateProc = NewControlUserPaneActivateUPP(TPPaneActivateProc);
 555         if (gTPFocusProc == NULL) gTPFocusProc = NewControlUserPaneFocusUPP(TPPaneFocusProc);
 556
 557                 /* allocate our private storage */
 558         tpvars = (STPTextPaneVars **) NewHandleClear(sizeof(STPTextPaneVars));
 559         SetControlReference(theControl, (long) tpvars);
 560         HLock((Handle) tpvars);
 561         varsp = *tpvars;
 562                 /* set the initial settings for our private data */
 563     varsp->fMultiline = multiline ;
 564         varsp->fInFocus = false;
 565         varsp->fIsActive = true;
 566         varsp->fTEActive = true; // in order to get a deactivate
 567         varsp->fUserPaneRec = theControl;
 568         theWindow = varsp->fOwner = GetControlOwner(theControl);
 569
 570     varsp->fDrawingEnvironment = (GrafPtr)  GetWindowPort(theWindow);
 571
 572     varsp->fInDialogWindow = ( GetWindowKind(varsp->fOwner) == kDialogWindowKind );
 573         /* set up the user pane procedures */
 574     SetControlData(theControl, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(gTPDrawProc), &gTPDrawProc);
 575     SetControlData(theControl, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(gTPHitProc), &gTPHitProc);
 576     SetControlData(theControl, kControlEntireControl, kControlUserPaneTrackingProcTag, sizeof(gTPTrackProc), &gTPTrackProc);
 577     SetControlData(theControl, kControlEntireControl, kControlUserPaneIdleProcTag, sizeof(gTPIdleProc), &gTPIdleProc);
 578     SetControlData(theControl, kControlEntireControl, kControlUserPaneKeyDownProcTag, sizeof(gTPKeyProc), &gTPKeyProc);
 579     SetControlData(theControl, kControlEntireControl, kControlUserPaneActivateProcTag, sizeof(gTPActivateProc), &gTPActivateProc);
 580     SetControlData(theControl, kControlEntireControl, kControlUserPaneFocusProcTag, sizeof(gTPFocusProc), &gTPFocusProc);
 581         /* calculate the rectangles used by the control */
 582     GetControlBounds(theControl, &bounds);
 583     SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
 584     SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
 585     SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) ,
 586         bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
 587         /* calculate the background region for the text.  In this case, it's kindof
 588         and irregular region because we're setting the scroll bar a little ways inside
 589         of the text area. */
 590     RectRgn((varsp->fTextBackgroundRgn = NewRgn()), &varsp->fRTextOutline);
 591
 592         /* set up the drawing environment */
 593     SetPort(varsp->fDrawingEnvironment);
 594
 595         /* create the new edit field */
 596     TXNNewObject(NULL, varsp->fOwner, &varsp->fRTextArea,
 597           ( multiline ? kTXNWantVScrollBarMask : 0 )
 598                  | kTXNAlwaysWrapAtViewEdgeMask,
 599         kTXNTextEditStyleFrameType,
 600         kTXNTextensionFile,
 601         kTXNSystemDefaultEncoding,
 602         &varsp->fTXNRec, &varsp->fTXNFrame, (TXNObjectRefcon) tpvars);
 603
 604                 /* set the field's font and style */
 605                 TXNTypeAttributes typeAttr[2];
 606     typeAttr[0].tag = kTXNQDFontSizeAttribute;
 607     typeAttr[0].size = kTXNFontSizeAttributeSize;
 608     typeAttr[0].data.dataValue = 10 << 16;
 609
 610     typeAttr[1].tag = kTXNQDFontStyleAttribute;
 611     typeAttr[1].size = kTXNQDFontStyleAttributeSize;
 612     typeAttr[1].data.dataValue = normal ;
 613
 614                 /* this does not seem to get the font id through
 615     typeAttr[2].tag = kTXNQDFontFamilyIDAttribute ; // NameAttribute;
 616     typeAttr[2].size = kTXNQDFontFamilyIDAttributeSize ; // kTXNQDFontNameAttributeSize;
 617     typeAttr[2].data.dataValue = kFontIDTimes ; // (void*) "\pGeneva" ;
 618      */
 619
 620     OSStatus status = TXNSetTypeAttributes (varsp->fTXNRec, sizeof( typeAttr ) / sizeof(TXNTypeAttributes) , typeAttr,
 621       kTXNStartOffset,
 622       kTXNEndOffset);
 623         /* set the field's background */
 624     tback.bgType = kTXNBackgroundTypeRGB;
 625     tback.bg.color = rgbWhite;
 626     TXNSetBackground( varsp->fTXNRec, &tback);
 627
 628         /* install our focus advance override routine */
 629 #if TARGET_CARBON
 630 //      varsp->handlerUPP = NewEventHandlerUPP(FocusAdvanceOverride);
 631 //      err = InstallWindowEventHandler( varsp->fOwner, varsp->handlerUPP,
 632 //              kMLTEEventCount, gMLTEEvents, tpvars, &varsp->handlerRef );
 633 #endif
 634
 635         /* unlock our storage */
 636     HUnlock((Handle) tpvars);
 637         /* perform final activations and setup for our text field.  Here,
 638         we assume that the window is going to be the 'active' window. */
 639     TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
 640         /* all done */
 641     return noErr;
 642 }
 643
 644
 645
 646
 647 #if !USE_SHARED_LIBRARY
 648 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
 649
 650 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
 651     EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
 652     EVT_CHAR(wxTextCtrl::OnChar)
 653     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
 654     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
 655     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
 656     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
 657     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
 658
 659     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
 660     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
 661     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
 662     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
 663     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
 664 END_EVENT_TABLE()
 665 #endif
 666
 667 // Text item
 668 wxTextCtrl::wxTextCtrl()
 669 {
 670   ((TEHandle) m_macTE) = NULL ;
 671   ((TXNObject) m_macTXN) = NULL ;
 672   m_macUsesTXN = false ;
 673   m_editable = true ;
 674 }
 675
 676 wxTextCtrl::~wxTextCtrl()
 677 {
 678     if ( m_macUsesTXN )
 679     {
 680         TXNDeleteObject((TXNObject)m_macTXN);
 681     #if TARGET_CARBON
 682             /* remove our focus advance override */
 683     //    RemoveEventHandler((**tpvars).handlerRef);
 684     //    DisposeEventHandlerUPP((**tpvars).handlerUPP);
 685     #endif
 686         /* delete our private storage */
 687         DisposeHandle((Handle) m_macTXNvars);
 688         /* zero the control reference */
 689         SetControlReference((ControlHandle)m_macControl, 0) ;
 690     }
 691 }
 692
 693 const short kVerticalMargin = 2 ;
 694 const short kHorizontalMargin = 2 ;
 695
 696 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 697            const wxString& st,
 698            const wxPoint& pos,
 699            const wxSize& size, long style,
 700            const wxValidator& validator,
 701            const wxString& name)
 702 {
 703   ((TEHandle) m_macTE) = NULL ;
 704   ((TXNObject) m_macTXN) = NULL ;
 705   m_macUsesTXN = false ;
 706   m_editable = true ;
 707
 708   m_macUsesTXN = ! (style & wxTE_PASSWORD ) ;
 709
 710   m_macUsesTXN &= (TXNInitTextension != (void*) kUnresolvedCFragSymbolAddress) ;
 711
 712     // base initialization
 713     if ( !CreateBase(parent, id, pos, size, style, validator, name) )
 714         return FALSE;
 715
 716     wxSize mySize = size ;
 717         if ( m_macUsesTXN )
 718         {
 719                 m_macHorizontalBorder = 5 ; // additional pixels around the real control
 720                 m_macVerticalBorder = 3 ;
 721         }
 722         else
 723     {
 724         m_macHorizontalBorder = 5 ; // additional pixels around the real control
 725         m_macVerticalBorder = 5 ;
 726     }
 727
 728
 729     Rect bounds ;
 730     Str255 title ;
 731
 732     if ( mySize.y == -1 )
 733     {
 734                 if ( !m_macUsesTXN )
 735             mySize.y = 13 ;
 736         else
 737                         mySize.y = 16 ;
 738
 739         mySize.y += 2 * m_macVerticalBorder ;
 740     }
 741
 742     MacPreControlCreate( parent , id ,  "" , pos , mySize ,style, validator , name , &bounds , title ) ;
 743
 744     if ( m_windowStyle & wxTE_MULTILINE )
 745     {
 746         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
 747                       wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
 748
 749         m_windowStyle |= wxTE_PROCESS_ENTER;
 750     }
 751
 752
 753     if ( !m_macUsesTXN )
 754     {
 755             m_macControl = ::NewControl( MAC_WXHWND(parent->MacGetRootWindow()) , &bounds , "\p" , true , 0 , 0 , 1,
 756                     (style & wxTE_PASSWORD) ? kControlEditTextPasswordProc : kControlEditTextProc , (long) this ) ;
 757                 long size ;
 758         ::GetControlData((ControlHandle)  m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &((TEHandle) m_macTE) , &size ) ;
 759
 760     }
 761         else
 762         {
 763         short featurSet;
 764
 765         featurSet = kControlSupportsEmbedding | kControlSupportsFocus | kControlWantsIdle
 766                 | kControlWantsActivate | kControlHandlesTracking | kControlHasSpecialBackground
 767                 | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
 768             /* create the control */
 769         m_macControl = NewControl(MAC_WXHWND(parent->MacGetRootWindow()), &bounds, "\p", true, featurSet, 0, featurSet, kControlUserPaneProc, 0);
 770             /* set up the mUP specific features and data */
 771         mUPOpenControl((ControlHandle) m_macControl, m_windowStyle & wxTE_MULTILINE );
 772         }
 773     MacPostControlCreate() ;
 774
 775     wxString value ;
 776
 777         if( wxApp::s_macDefaultEncodingIsPC )
 778                 value = wxMacMakeMacStringFromPC( st ) ;
 779         else
 780                 value = st ;
 781
 782         if ( !m_macUsesTXN )
 783         {
 784             ::SetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
 785     }
 786     else
 787     {
 788         STPTextPaneVars **tpvars;
 789                 /* set up locals */
 790         tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
 791                 /* set the text in the record */
 792         TXNSetData( (**tpvars).fTXNRec, kTXNTextData,  (void*)value.c_str(), value.Length(),
 793           kTXNStartOffset, kTXNEndOffset);
 794         m_macTXN =  (**tpvars).fTXNRec ;
 795         m_macTXNvars = tpvars ;
 796         m_macUsesTXN = true ;
 797     }
 798
 799   return TRUE;
 800 }
 801
 802 wxString wxTextCtrl::GetValue() const
 803 {
 804     Size actualsize;
 805      if ( !m_macUsesTXN )
 806      {
 807       ::GetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
 808      }
 809      else
 810      {
 811         Handle theText ;
 812         OSStatus err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
 813                 /* all done */
 814         if ( err )
 815         {
 816           actualsize = 0 ;
 817         }
 818         else
 819         {
 820           actualsize = GetHandleSize( theText ) ;
 821           strncpy( wxBuffer , *theText , actualsize ) ;
 822           DisposeHandle( theText ) ;
 823         }
 824      }
 825     wxBuffer[actualsize] = 0 ;
 826     if( wxApp::s_macDefaultEncodingIsPC )
 827         return wxMacMakePCStringFromMac( wxBuffer ) ;
 828     else
 829         return wxString(wxBuffer);
 830 }
 831
 832 void wxTextCtrl::GetSelection(long* from, long* to) const
 833 {
 834   if ( !m_macUsesTXN )
 835   {
 836     *from = (**((TEHandle) m_macTE)).selStart;
 837     *to = (**((TEHandle) m_macTE)).selEnd;
 838    }
 839    else
 840    {
 841         TXNGetSelection(  ((TXNObject) m_macTXN) , (TXNOffset*) from , (TXNOffset*) to ) ;
 842    }
 843 }
 844
 845 void wxTextCtrl::SetValue(const wxString& st)
 846 {
 847     wxString value ;
 848
 849     if( wxApp::s_macDefaultEncodingIsPC )
 850         value = wxMacMakeMacStringFromPC( st ) ;
 851     else
 852         value = st ;
 853   if ( !m_macUsesTXN )
 854   {
 855           ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
 856   }
 857   else
 858   {
 859         TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)value.c_str(), value.Length(),
 860           kTXNStartOffset, kTXNEndOffset);
 861   }
 862     MacRedrawControl() ;
 863 }
 864
 865 // Clipboard operations
 866 void wxTextCtrl::Copy()
 867 {
 868     if (CanCopy())
 869     {
 870       if ( !m_macUsesTXN )
 871       {
 872                 TECopy( ((TEHandle) m_macTE) ) ;
 873                 ClearCurrentScrap();
 874                 TEToScrap() ;
 875                 MacRedrawControl() ;
 876         }
 877         else
 878         {
 879             ClearCurrentScrap();
 880             TXNCopy((TXNObject)m_macTXN);
 881             TXNConvertToPublicScrap();
 882         }
 883     }
 884 }
 885
 886 void wxTextCtrl::Cut()
 887 {
 888     if (CanCut())
 889     {
 890         if ( !m_macUsesTXN )
 891         {
 892                 TECut( ((TEHandle) m_macTE) ) ;
 893                 ClearCurrentScrap();
 894                 TEToScrap() ;
 895                 MacRedrawControl() ;
 896         }
 897         else
 898         {
 899             ClearCurrentScrap();
 900             TXNCut((TXNObject)m_macTXN);
 901             TXNConvertToPublicScrap();
 902         }
 903         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
 904         event.SetString( GetValue() ) ;
 905         event.SetEventObject( this );
 906         GetEventHandler()->ProcessEvent(event);
 907           }
 908 }
 909
 910 void wxTextCtrl::Paste()
 911 {
 912     if (CanPaste())
 913     {
 914         if ( !m_macUsesTXN )
 915         {
 916             TEFromScrap() ;
 917             TEPaste( (TEHandle) m_macTE ) ;
 918             MacRedrawControl() ;
 919         }
 920         else
 921         {
 922             TXNConvertFromPublicScrap();
 923             TXNPaste((TXNObject)m_macTXN);
 924         }
 925         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
 926         event.SetString( GetValue() ) ;
 927         event.SetEventObject( this );
 928         GetEventHandler()->ProcessEvent(event);
 929     }
 930 }
 931
 932 bool wxTextCtrl::CanCopy() const
 933 {
 934     // Can copy if there's a selection
 935     long from, to;
 936     GetSelection(& from, & to);
 937     return (from != to);
 938 }
 939
 940 bool wxTextCtrl::CanCut() const
 941 {
 942     if ( !IsEditable() )
 943     {
 944         return false ;
 945     }
 946     // Can cut if there's a selection
 947     long from, to;
 948     GetSelection(& from, & to);
 949     return (from != to);
 950 }
 951
 952 bool wxTextCtrl::CanPaste() const
 953 {
 954     if (!IsEditable())
 955         return FALSE;
 956
 957     long offset ;
 958 #if TARGET_CARBON
 959     OSStatus err = noErr;
 960     ScrapRef scrapRef;
 961
 962     err = GetCurrentScrap( &scrapRef );
 963     if ( err != noTypeErr && err != memFullErr )
 964     {
 965                 ScrapFlavorFlags        flavorFlags;
 966                 Size                            byteCount;
 967
 968         if (( err = GetScrapFlavorFlags( scrapRef, 'TEXT', &flavorFlags )) == noErr)
 969         {
 970             if (( err = GetScrapFlavorSize( scrapRef, 'TEXT', &byteCount )) == noErr)
 971             {
 972                 return TRUE ;
 973             }
 974         }
 975     }
 976     return FALSE;
 977
 978 #else
 979     if ( GetScrap( NULL , 'TEXT' , &offset ) > 0 )
 980     {
 981         return TRUE ;
 982     }
 983 #endif
 984     return FALSE ;
 985 }
 986
 987 void wxTextCtrl::SetEditable(bool editable)
 988 {
 989     if ( editable != m_editable )
 990     {
 991         m_editable = editable ;
 992     if ( editable )
 993                 UMAActivateControl( (ControlHandle) m_macControl ) ;
 994         else
 995                 UMADeactivateControl((ControlHandle)  m_macControl ) ;
 996     }
 997 }
 998
 999 void wxTextCtrl::SetInsertionPoint(long pos)
1000 {
1001     SetSelection( pos , pos ) ;
1002 }
1003
1004 void wxTextCtrl::SetInsertionPointEnd()
1005 {
1006     long pos = GetLastPosition();
1007     SetInsertionPoint(pos);
1008 }
1009
1010 long wxTextCtrl::GetInsertionPoint() const
1011 {
1012   long begin,end ;
1013   GetSelection( &begin , &end ) ;
1014   return begin ;
1015 }
1016
1017 long wxTextCtrl::GetLastPosition() const
1018 {
1019     if ( !m_macUsesTXN )
1020   {
1021     return (**((TEHandle) m_macTE)).teLength ;
1022   }
1023   else
1024   {
1025     Handle theText ;
1026     long actualsize ;
1027     OSErr err = TXNGetDataEncoded( (TXNObject) m_macTXN, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
1028         /* all done */
1029     if ( err )
1030     {
1031       actualsize = 0 ;
1032     }
1033     else
1034     {
1035       actualsize = GetHandleSize( theText ) ;
1036       DisposeHandle( theText ) ;
1037     }
1038     return actualsize ;
1039   }
1040 }
1041
1042 void wxTextCtrl::Replace(long from, long to, const wxString& value)
1043 {
1044   if ( !m_macUsesTXN )
1045   {
1046             ControlEditTextSelectionRec selection ;
1047
1048             selection.selStart = from ;
1049             selection.selEnd = to ;
1050             ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1051             TESetSelect( from , to  , ((TEHandle) m_macTE) ) ;
1052             TEDelete( ((TEHandle) m_macTE) ) ;
1053                 TEInsert( value , value.Length() , ((TEHandle) m_macTE) ) ;
1054         }
1055         else
1056         {
1057           TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1058           TXNClear( ((TXNObject) m_macTXN) ) ;
1059           TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)value.c_str(), value.Length(),
1060             kTXNUseCurrentSelection, kTXNUseCurrentSelection);
1061         }
1062     Refresh() ;
1063 }
1064
1065 void wxTextCtrl::Remove(long from, long to)
1066 {
1067   if ( !m_macUsesTXN )
1068   {
1069         ControlEditTextSelectionRec selection ;
1070
1071         selection.selStart = from ;
1072         selection.selEnd = to ;
1073         ::SetControlData( (ControlHandle) m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1074         TEDelete( ((TEHandle) m_macTE) ) ;
1075   }
1076   else
1077   {
1078     TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1079     TXNClear( ((TXNObject) m_macTXN) ) ;
1080   }
1081     Refresh() ;
1082 }
1083
1084 void wxTextCtrl::SetSelection(long from, long to)
1085 {
1086
1087   if ( !m_macUsesTXN )
1088   {
1089    ControlEditTextSelectionRec selection ;
1090    selection.selStart = from ;
1091    selection.selEnd = to ;
1092
1093    TESetSelect( selection.selStart , selection.selEnd , ((TEHandle) m_macTE) ) ;
1094    ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1095   }
1096   else
1097   {
1098         STPTextPaneVars **tpvars;
1099                 /* set up our locals */
1100         tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
1101                 /* and our drawing environment as the operation
1102                 may force a redraw in the text area. */
1103         SetPort((**tpvars).fDrawingEnvironment);
1104                 /* change the selection */
1105         TXNSetSelection( (**tpvars).fTXNRec, from, to);
1106   }
1107 }
1108
1109 bool wxTextCtrl::LoadFile(const wxString& file)
1110 {
1111     if ( wxTextCtrlBase::LoadFile(file) )
1112     {
1113         return TRUE;
1114     }
1115
1116     return FALSE;
1117 }
1118
1119 void wxTextCtrl::WriteText(const wxString& text)
1120 {
1121     wxString value ;
1122         if( wxApp::s_macDefaultEncodingIsPC )
1123                 value = wxMacMakeMacStringFromPC( text ) ;
1124         else
1125                 value = text ;
1126     if ( !m_macUsesTXN )
1127     {
1128                 TEInsert( value , value.Length() , ((TEHandle) m_macTE) ) ;
1129         }
1130         else
1131         {
1132         TXNSetData( ((TXNObject) m_macTXN), kTXNTextData, (void*) (const char*)value, value.Length(),
1133           kTXNUseCurrentSelection, kTXNUseCurrentSelection);
1134         }
1135         MacRedrawControl() ;
1136 }
1137
1138 void wxTextCtrl::AppendText(const wxString& text)
1139 {
1140     SetInsertionPointEnd();
1141     WriteText(text);
1142 }
1143
1144 void wxTextCtrl::Clear()
1145 {
1146     if ( !IsEditable() )
1147     {
1148         return ;
1149     }
1150   if ( !m_macUsesTXN )
1151   {
1152         ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char*) ((const char*)NULL) ) ;
1153   }
1154   else
1155   {
1156             ClearCurrentScrap();
1157             TXNClear((TXNObject)m_macTXN);
1158   }
1159     Refresh() ;
1160 }
1161
1162 bool wxTextCtrl::IsModified() const
1163 {
1164     return TRUE;
1165 }
1166
1167 bool wxTextCtrl::IsEditable() const
1168 {
1169     return IsEnabled() && m_editable ;
1170 }
1171
1172 bool wxTextCtrl::AcceptsFocus() const
1173 {
1174     // we don't want focus if we can't be edited
1175     return /*IsEditable() && */ wxControl::AcceptsFocus();
1176 }
1177
1178 wxSize wxTextCtrl::DoGetBestSize() const
1179 {
1180     int wText = 100 ;
1181
1182     int hText ;
1183         if ( UMAHasAppearance() )
1184             hText = 13 ;
1185         else
1186             hText = 24 ;
1187     hText += 2 * m_macHorizontalBorder ;
1188 /*
1189     int cx, cy;
1190     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
1191
1192     int wText = DEFAULT_ITEM_WIDTH;
1193
1194     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
1195
1196     return wxSize(wText, hText);
1197 */
1198     if ( m_windowStyle & wxTE_MULTILINE )
1199     {
1200         hText *= wxMin(GetNumberOfLines(), 5);
1201     }
1202     //else: for single line control everything is ok
1203     return wxSize(wText, hText);
1204 }
1205
1206 // ----------------------------------------------------------------------------
1207 // Undo/redo
1208 // ----------------------------------------------------------------------------
1209
1210 void wxTextCtrl::Undo()
1211 {
1212     if (CanUndo())
1213     {
1214     }
1215 }
1216
1217 void wxTextCtrl::Redo()
1218 {
1219     if (CanRedo())
1220     {
1221     }
1222 }
1223
1224 bool wxTextCtrl::CanUndo() const
1225 {
1226     return FALSE ;
1227 }
1228
1229 bool wxTextCtrl::CanRedo() const
1230 {
1231     return FALSE ;
1232 }
1233
1234 // Makes 'unmodified'
1235 void wxTextCtrl::DiscardEdits()
1236 {
1237     // TODO
1238 }
1239
1240 int wxTextCtrl::GetNumberOfLines() const
1241 {
1242   // TODO change this if possible to reflect real lines
1243   wxString content = GetValue() ;
1244
1245     int count = 1;
1246         for (int i = 0; i < content.Length() ; i++)
1247         {
1248             if (content[i] == '\r') count++;
1249     }
1250
1251     return count;
1252 }
1253
1254 long wxTextCtrl::XYToPosition(long x, long y) const
1255 {
1256     // TODO
1257     return 0;
1258 }
1259
1260 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
1261 {
1262     return FALSE ;
1263 }
1264
1265 void wxTextCtrl::ShowPosition(long pos)
1266 {
1267     // TODO
1268 }
1269
1270 int wxTextCtrl::GetLineLength(long lineNo) const
1271 {
1272   // TODO change this if possible to reflect real lines
1273   wxString content = GetValue() ;
1274
1275         // Find line first
1276         int count = 0;
1277         for (int i = 0; i < content.Length() ; i++)
1278     {
1279         if (count == lineNo)
1280         {
1281             // Count chars in line then
1282             count = 0;
1283                 for (int j = i; j < content.Length(); j++)
1284             {
1285                 count++;
1286                     if (content[j] == '\r') return count;
1287                 }
1288
1289                 return count;
1290             }
1291             if (content[i] == '\r') count++;
1292         }
1293     return 0;
1294 }
1295
1296 wxString wxTextCtrl::GetLineText(long lineNo) const
1297 {
1298   // TODO change this if possible to reflect real lines
1299   wxString content = GetValue() ;
1300
1301         // Find line first
1302         int count = 0;
1303         for (int i = 0; i < content.Length() ; i++)
1304     {
1305         if (count == lineNo)
1306         {
1307             // Add chars in line then
1308             wxString tmp("");
1309
1310                 for (int j = i; j < content.Length(); j++)
1311                 {
1312                     if (content[j] == '\r')
1313                         return tmp;
1314
1315                     tmp += content[j];
1316                 }
1317
1318                 return tmp;
1319             }
1320             if (content[i] == '\r') count++;
1321         }
1322 }
1323
1324 /*
1325  * Text item
1326  */
1327
1328 void wxTextCtrl::Command(wxCommandEvent & event)
1329 {
1330     SetValue (event.GetString());
1331     ProcessCommand (event);
1332 }
1333
1334 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1335 {
1336     // By default, load the first file into the text window.
1337     if (event.GetNumberOfFiles() > 0)
1338     {
1339         LoadFile(event.GetFiles()[0]);
1340     }
1341 }
1342
1343 void wxTextCtrl::OnChar(wxKeyEvent& event)
1344 {
1345     int key = event.GetKeyCode() ;
1346     bool eat_key = false ;
1347
1348     if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
1349         !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
1350 /*        && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
1351         )
1352     {
1353         // eat it
1354         return ;
1355     }
1356     switch ( key )
1357     {
1358         case WXK_RETURN:
1359             if (m_windowStyle & wxPROCESS_ENTER)
1360             {
1361                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1362                 event.SetEventObject( this );
1363                 event.SetString( GetValue() );
1364                 if ( GetEventHandler()->ProcessEvent(event) )
1365                     return;
1366             }
1367             if ( !(m_windowStyle & wxTE_MULTILINE) )
1368             {
1369                 wxWindow *parent = GetParent();
1370                 while( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL ) {
1371                   parent = parent->GetParent() ;
1372                 }
1373                 if ( parent && parent->GetDefaultItem() )
1374                 {
1375                     wxButton *def = wxDynamicCast(parent->GetDefaultItem(),
1376                                                           wxButton);
1377                     if ( def && def->IsEnabled() )
1378                     {
1379                         wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1380                         event.SetEventObject(def);
1381                         def->Command(event);
1382                         return ;
1383                    }
1384                 }
1385
1386                 // this will make wxWindows eat the ENTER key so that
1387                 // we actually prevent line wrapping in a single line
1388                 // text control
1389                 eat_key = TRUE;
1390             }
1391
1392             break;
1393
1394         case WXK_TAB:
1395             // always produce navigation event - even if we process TAB
1396             // ourselves the fact that we got here means that the user code
1397             // decided to skip processing of this TAB - probably to let it
1398             // do its default job.
1399             {
1400                 wxNavigationKeyEvent eventNav;
1401                 eventNav.SetDirection(!event.ShiftDown());
1402                 eventNav.SetWindowChange(event.ControlDown());
1403                 eventNav.SetEventObject(this);
1404
1405                 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
1406                     return;
1407
1408                 event.Skip() ;
1409                 return;
1410             }
1411             break;
1412     }
1413
1414     EventRecord *ev = (EventRecord*) wxTheApp->MacGetCurrentEvent();
1415     short keychar = short(ev->message & charCodeMask);
1416     if (!eat_key)
1417     {
1418         short keycode = short(ev->message & keyCodeMask) >> 8 ;
1419         ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers );
1420     }
1421     if ( keychar >= 0x20 ||
1422          event.KeyCode() == WXK_RETURN ||
1423          event.KeyCode() == WXK_DELETE ||
1424          event.KeyCode() == WXK_BACK)
1425     {
1426         wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1427         event1.SetString( GetValue() ) ;
1428         event1.SetEventObject( this );
1429         GetEventHandler()->ProcessEvent(event1);
1430     }
1431 }
1432
1433 // ----------------------------------------------------------------------------
1434 // standard handlers for standard edit menu events
1435 // ----------------------------------------------------------------------------
1436
1437 void wxTextCtrl::OnCut(wxCommandEvent& event)
1438 {
1439     Cut();
1440 }
1441
1442 void wxTextCtrl::OnCopy(wxCommandEvent& event)
1443 {
1444     Copy();
1445 }
1446
1447 void wxTextCtrl::OnPaste(wxCommandEvent& event)
1448 {
1449     Paste();
1450 }
1451
1452 void wxTextCtrl::OnUndo(wxCommandEvent& event)
1453 {
1454     Undo();
1455 }
1456
1457 void wxTextCtrl::OnRedo(wxCommandEvent& event)
1458 {
1459     Redo();
1460 }
1461
1462 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1463 {
1464     event.Enable( CanCut() );
1465 }
1466
1467 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1468 {
1469     event.Enable( CanCopy() );
1470 }
1471
1472 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1473 {
1474     event.Enable( CanPaste() );
1475 }
1476
1477 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1478 {
1479     event.Enable( CanUndo() );
1480 }
1481
1482 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1483 {
1484     event.Enable( CanRedo() );
1485 }
1486
1487
1488
1489 #endif
1490     // wxUSE_TEXTCTRL