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     ControlHandle fUserPaneRec;  /* handle to the user pane control */
 163     WindowPtr fOwner; /* window containing control */
 164     GrafPtr fDrawingEnvironment; /* grafport where control is drawn */
 165         /* flags */
 166     Boolean fInFocus; /* true while the focus rect is drawn around the control */
 167     Boolean fIsActive; /* true while the control is drawn in the active state */
 168     Boolean fTEActive; /* reflects the activation state of the text edit record */
 169     Boolean fInDialogWindow; /* true if displayed in a dialog window */
 170         /* calculated locations */
 171     Rect fRTextArea; /* area where the text is drawn */
 172     Rect fRFocusOutline;  /* rectangle used to draw the focus box */
 173     Rect fRTextOutline; /* rectangle used to draw the border */
 174     RgnHandle fTextBackgroundRgn; /* background region for the text, erased before calling TEUpdate */
 175         /* our focus advance override routine */
 176     EventHandlerUPP handlerUPP;
 177     EventHandlerRef handlerRef;
 178         bool fMultiline ;
 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, kEventTextInputUnicodeForKeyEvent } };
 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                 Str255 fontName ;
 605                 SInt16 fontSize ;
 606                 Style fontStyle ;
 607
 608                 GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
 609
 610                 TXNTypeAttributes typeAttr[] =
 611                 {
 612             {   kTXNQDFontNameAttribute , kTXNQDFontNameAttributeSize , { (void*) fontName } } ,
 613                     {   kTXNQDFontSizeAttribute , kTXNFontSizeAttributeSize , { (void*) (fontSize << 16) } } ,
 614                     {   kTXNQDFontStyleAttribute , kTXNQDFontStyleAttributeSize , {  (void*) normal } } ,
 615         } ;
 616
 617     OSStatus status = TXNSetTypeAttributes (varsp->fTXNRec, sizeof( typeAttr ) / sizeof(TXNTypeAttributes) , typeAttr,
 618       kTXNStartOffset,
 619       kTXNEndOffset);
 620         /* set the field's background */
 621     tback.bgType = kTXNBackgroundTypeRGB;
 622     tback.bg.color = rgbWhite;
 623     TXNSetBackground( varsp->fTXNRec, &tback);
 624
 625         /* install our focus advance override routine */
 626 #if TARGET_CARBON
 627     varsp->handlerUPP = NewEventHandlerUPP(FocusAdvanceOverride);
 628     err = InstallWindowEventHandler( varsp->fOwner, varsp->handlerUPP,
 629         kMLTEEventCount, gMLTEEvents, tpvars, &varsp->handlerRef );
 630 #endif
 631
 632         /* unlock our storage */
 633     HUnlock((Handle) tpvars);
 634         /* perform final activations and setup for our text field.  Here,
 635         we assume that the window is going to be the 'active' window. */
 636     TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
 637         /* all done */
 638     return noErr;
 639 }
 640
 641
 642
 643
 644 #if !USE_SHARED_LIBRARY
 645 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
 646
 647 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
 648     EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
 649     EVT_CHAR(wxTextCtrl::OnChar)
 650     EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
 651     EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
 652     EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
 653     EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
 654     EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
 655
 656     EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
 657     EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
 658     EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
 659     EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
 660     EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
 661 END_EVENT_TABLE()
 662 #endif
 663
 664 // Text item
 665 wxTextCtrl::wxTextCtrl()
 666 {
 667   m_macTE = NULL ;
 668   m_macTXN = NULL ;
 669   m_macTXNvars = NULL ;
 670   m_macUsesTXN = false ;
 671   m_editable = true ;
 672 }
 673
 674 wxTextCtrl::~wxTextCtrl()
 675 {
 676     if ( m_macUsesTXN )
 677     {
 678         SetControlReference((ControlHandle)m_macControl, 0) ;
 679         TXNDeleteObject((TXNObject)m_macTXN);
 680     #if TARGET_CARBON
 681             /* remove our focus advance override */
 682         ::RemoveEventHandler((**(STPTextPaneVars **) m_macTXNvars).handlerRef);
 683         ::DisposeEventHandlerUPP((**(STPTextPaneVars **) m_macTXNvars).handlerUPP);
 684     #endif
 685         /* delete our private storage */
 686         DisposeHandle((Handle) m_macTXNvars);
 687         /* zero the control reference */
 688     }
 689 }
 690
 691 const short kVerticalMargin = 2 ;
 692 const short kHorizontalMargin = 2 ;
 693
 694 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 695            const wxString& st,
 696            const wxPoint& pos,
 697            const wxSize& size, long style,
 698            const wxValidator& validator,
 699            const wxString& name)
 700 {
 701   m_macTE = NULL ;
 702   m_macTXN = NULL ;
 703   m_macTXNvars = NULL ;
 704   m_macUsesTXN = false ;
 705   m_editable = true ;
 706
 707   m_macUsesTXN = ! (style & wxTE_PASSWORD ) ;
 708
 709   m_macUsesTXN &= (TXNInitTextension != (void*) kUnresolvedCFragSymbolAddress) ;
 710
 711     // base initialization
 712     if ( !CreateBase(parent, id, pos, size, style, validator, name) )
 713         return FALSE;
 714
 715     wxSize mySize = size ;
 716         if ( m_macUsesTXN )
 717         {
 718                 m_macHorizontalBorder = 5 ; // additional pixels around the real control
 719                 m_macVerticalBorder = 3 ;
 720         }
 721         else
 722     {
 723         m_macHorizontalBorder = 5 ; // additional pixels around the real control
 724         m_macVerticalBorder = 5 ;
 725     }
 726
 727
 728     Rect bounds ;
 729     Str255 title ;
 730     /*
 731     if ( mySize.y == -1 )
 732     {
 733         mySize.y = 13 ;
 734         if ( m_windowStyle & wxTE_MULTILINE )
 735             mySize.y *= 5 ;
 736
 737         mySize.y += 2 * m_macVerticalBorder ;
 738     }
 739     */
 740     MacPreControlCreate( parent , id ,  "" , pos , mySize ,style, validator , name , &bounds , title ) ;
 741
 742     if ( m_windowStyle & wxTE_MULTILINE )
 743     {
 744         wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
 745                       wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
 746
 747         m_windowStyle |= wxTE_PROCESS_ENTER;
 748     }
 749
 750
 751     if ( !m_macUsesTXN )
 752     {
 753             m_macControl = ::NewControl( MAC_WXHWND(parent->MacGetRootWindow()) , &bounds , "\p" , true , 0 , 0 , 1,
 754                     (style & wxTE_PASSWORD) ? kControlEditTextPasswordProc : kControlEditTextProc , (long) this ) ;
 755                 long size ;
 756         ::GetControlData((ControlHandle)  m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &((TEHandle) m_macTE) , &size ) ;
 757
 758     }
 759         else
 760         {
 761         short featurSet;
 762
 763         featurSet = kControlSupportsEmbedding | kControlSupportsFocus // | kControlWantsIdle
 764                 | kControlWantsActivate | kControlHandlesTracking | kControlHasSpecialBackground
 765                 | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
 766             /* create the control */
 767         m_macControl = NewControl(MAC_WXHWND(parent->MacGetRootWindow()), &bounds, "\p", true, featurSet, 0, featurSet, kControlUserPaneProc, 0);
 768             /* set up the mUP specific features and data */
 769         mUPOpenControl((ControlHandle) m_macControl, m_windowStyle & wxTE_MULTILINE );
 770         }
 771     MacPostControlCreate() ;
 772
 773     wxString value ;
 774
 775         if( wxApp::s_macDefaultEncodingIsPC )
 776                 value = wxMacMakeMacStringFromPC( st ) ;
 777         else
 778                 value = st ;
 779
 780         if ( !m_macUsesTXN )
 781         {
 782             ::SetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
 783     }
 784     else
 785     {
 786         STPTextPaneVars **tpvars;
 787                 /* set up locals */
 788         tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
 789                 /* set the text in the record */
 790         TXNSetData( (**tpvars).fTXNRec, kTXNTextData,  (void*)value.c_str(), value.Length(),
 791           kTXNStartOffset, kTXNEndOffset);
 792         m_macTXN =  (**tpvars).fTXNRec ;
 793         m_macTXNvars = tpvars ;
 794         m_macUsesTXN = true ;
 795     }
 796
 797   return TRUE;
 798 }
 799
 800 wxString wxTextCtrl::GetValue() const
 801 {
 802     Size actualsize;
 803      if ( !m_macUsesTXN )
 804      {
 805       ::GetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
 806      }
 807      else
 808      {
 809         Handle theText ;
 810         OSStatus err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
 811                 /* all done */
 812         if ( err )
 813         {
 814           actualsize = 0 ;
 815         }
 816         else
 817         {
 818           actualsize = GetHandleSize( theText ) ;
 819           strncpy( wxBuffer , *theText , actualsize ) ;
 820           DisposeHandle( theText ) ;
 821         }
 822      }
 823     wxBuffer[actualsize] = 0 ;
 824     if( wxApp::s_macDefaultEncodingIsPC )
 825         return wxMacMakePCStringFromMac( wxBuffer ) ;
 826     else
 827         return wxString(wxBuffer);
 828 }
 829
 830 void wxTextCtrl::GetSelection(long* from, long* to) const
 831 {
 832   if ( !m_macUsesTXN )
 833   {
 834     *from = (**((TEHandle) m_macTE)).selStart;
 835     *to = (**((TEHandle) m_macTE)).selEnd;
 836    }
 837    else
 838    {
 839         TXNGetSelection(  ((TXNObject) m_macTXN) , (TXNOffset*) from , (TXNOffset*) to ) ;
 840    }
 841 }
 842
 843 void wxTextCtrl::SetValue(const wxString& st)
 844 {
 845     wxString value ;
 846
 847     if( wxApp::s_macDefaultEncodingIsPC )
 848         value = wxMacMakeMacStringFromPC( st ) ;
 849     else
 850         value = st ;
 851   if ( !m_macUsesTXN )
 852   {
 853           ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
 854   }
 855   else
 856   {
 857         TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)value.c_str(), value.Length(),
 858           kTXNStartOffset, kTXNEndOffset);
 859   }
 860     MacRedrawControl() ;
 861 }
 862
 863 // Clipboard operations
 864 void wxTextCtrl::Copy()
 865 {
 866     if (CanCopy())
 867     {
 868       if ( !m_macUsesTXN )
 869       {
 870                 TECopy( ((TEHandle) m_macTE) ) ;
 871                 ClearCurrentScrap();
 872                 TEToScrap() ;
 873                 MacRedrawControl() ;
 874         }
 875         else
 876         {
 877             ClearCurrentScrap();
 878             TXNCopy((TXNObject)m_macTXN);
 879             TXNConvertToPublicScrap();
 880         }
 881     }
 882 }
 883
 884 void wxTextCtrl::Cut()
 885 {
 886     if (CanCut())
 887     {
 888         if ( !m_macUsesTXN )
 889         {
 890                 TECut( ((TEHandle) m_macTE) ) ;
 891                 ClearCurrentScrap();
 892                 TEToScrap() ;
 893                 MacRedrawControl() ;
 894         }
 895         else
 896         {
 897             ClearCurrentScrap();
 898             TXNCut((TXNObject)m_macTXN);
 899             TXNConvertToPublicScrap();
 900         }
 901         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
 902         event.SetString( GetValue() ) ;
 903         event.SetEventObject( this );
 904         GetEventHandler()->ProcessEvent(event);
 905           }
 906 }
 907
 908 void wxTextCtrl::Paste()
 909 {
 910     if (CanPaste())
 911     {
 912         if ( !m_macUsesTXN )
 913         {
 914             TEFromScrap() ;
 915             TEPaste( (TEHandle) m_macTE ) ;
 916             MacRedrawControl() ;
 917         }
 918         else
 919         {
 920             TXNConvertFromPublicScrap();
 921             TXNPaste((TXNObject)m_macTXN);
 922         }
 923         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
 924         event.SetString( GetValue() ) ;
 925         event.SetEventObject( this );
 926         GetEventHandler()->ProcessEvent(event);
 927     }
 928 }
 929
 930 bool wxTextCtrl::CanCopy() const
 931 {
 932     // Can copy if there's a selection
 933     long from, to;
 934     GetSelection(& from, & to);
 935     return (from != to);
 936 }
 937
 938 bool wxTextCtrl::CanCut() const
 939 {
 940     if ( !IsEditable() )
 941     {
 942         return false ;
 943     }
 944     // Can cut if there's a selection
 945     long from, to;
 946     GetSelection(& from, & to);
 947     return (from != to);
 948 }
 949
 950 bool wxTextCtrl::CanPaste() const
 951 {
 952     if (!IsEditable())
 953         return FALSE;
 954
 955     long offset ;
 956 #if TARGET_CARBON
 957     OSStatus err = noErr;
 958     ScrapRef scrapRef;
 959
 960     err = GetCurrentScrap( &scrapRef );
 961     if ( err != noTypeErr && err != memFullErr )
 962     {
 963                 ScrapFlavorFlags        flavorFlags;
 964                 Size                            byteCount;
 965
 966         if (( err = GetScrapFlavorFlags( scrapRef, 'TEXT', &flavorFlags )) == noErr)
 967         {
 968             if (( err = GetScrapFlavorSize( scrapRef, 'TEXT', &byteCount )) == noErr)
 969             {
 970                 return TRUE ;
 971             }
 972         }
 973     }
 974     return FALSE;
 975
 976 #else
 977     if ( GetScrap( NULL , 'TEXT' , &offset ) > 0 )
 978     {
 979         return TRUE ;
 980     }
 981 #endif
 982     return FALSE ;
 983 }
 984
 985 void wxTextCtrl::SetEditable(bool editable)
 986 {
 987     if ( editable != m_editable )
 988     {
 989         m_editable = editable ;
 990     if ( editable )
 991                 UMAActivateControl( (ControlHandle) m_macControl ) ;
 992         else
 993                 UMADeactivateControl((ControlHandle)  m_macControl ) ;
 994     }
 995 }
 996
 997 void wxTextCtrl::SetInsertionPoint(long pos)
 998 {
 999     SetSelection( pos , pos ) ;
1000 }
1001
1002 void wxTextCtrl::SetInsertionPointEnd()
1003 {
1004     long pos = GetLastPosition();
1005     SetInsertionPoint(pos);
1006 }
1007
1008 long wxTextCtrl::GetInsertionPoint() const
1009 {
1010   long begin,end ;
1011   GetSelection( &begin , &end ) ;
1012   return begin ;
1013 }
1014
1015 long wxTextCtrl::GetLastPosition() const
1016 {
1017     if ( !m_macUsesTXN )
1018   {
1019     return (**((TEHandle) m_macTE)).teLength ;
1020   }
1021   else
1022   {
1023     Handle theText ;
1024     long actualsize ;
1025     OSErr err = TXNGetDataEncoded( (TXNObject) m_macTXN, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
1026         /* all done */
1027     if ( err )
1028     {
1029       actualsize = 0 ;
1030     }
1031     else
1032     {
1033       actualsize = GetHandleSize( theText ) ;
1034       DisposeHandle( theText ) ;
1035     }
1036     return actualsize ;
1037   }
1038 }
1039
1040 void wxTextCtrl::Replace(long from, long to, const wxString& value)
1041 {
1042   if ( !m_macUsesTXN )
1043   {
1044             ControlEditTextSelectionRec selection ;
1045
1046             selection.selStart = from ;
1047             selection.selEnd = to ;
1048             ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1049             TESetSelect( from , to  , ((TEHandle) m_macTE) ) ;
1050             TEDelete( ((TEHandle) m_macTE) ) ;
1051                 TEInsert( value , value.Length() , ((TEHandle) m_macTE) ) ;
1052         }
1053         else
1054         {
1055           TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1056           TXNClear( ((TXNObject) m_macTXN) ) ;
1057           TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)value.c_str(), value.Length(),
1058             kTXNUseCurrentSelection, kTXNUseCurrentSelection);
1059         }
1060     Refresh() ;
1061 }
1062
1063 void wxTextCtrl::Remove(long from, long to)
1064 {
1065   if ( !m_macUsesTXN )
1066   {
1067         ControlEditTextSelectionRec selection ;
1068
1069         selection.selStart = from ;
1070         selection.selEnd = to ;
1071         ::SetControlData( (ControlHandle) m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1072         TEDelete( ((TEHandle) m_macTE) ) ;
1073   }
1074   else
1075   {
1076     TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1077     TXNClear( ((TXNObject) m_macTXN) ) ;
1078   }
1079     Refresh() ;
1080 }
1081
1082 void wxTextCtrl::SetSelection(long from, long to)
1083 {
1084
1085   if ( !m_macUsesTXN )
1086   {
1087    ControlEditTextSelectionRec selection ;
1088    selection.selStart = from ;
1089    selection.selEnd = to ;
1090
1091    TESetSelect( selection.selStart , selection.selEnd , ((TEHandle) m_macTE) ) ;
1092    ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
1093   }
1094   else
1095   {
1096         STPTextPaneVars **tpvars;
1097                 /* set up our locals */
1098         tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
1099                 /* and our drawing environment as the operation
1100                 may force a redraw in the text area. */
1101         SetPort((**tpvars).fDrawingEnvironment);
1102                 /* change the selection */
1103         TXNSetSelection( (**tpvars).fTXNRec, from, to);
1104   }
1105 }
1106
1107 bool wxTextCtrl::LoadFile(const wxString& file)
1108 {
1109     if ( wxTextCtrlBase::LoadFile(file) )
1110     {
1111         return TRUE;
1112     }
1113
1114     return FALSE;
1115 }
1116
1117 void wxTextCtrl::WriteText(const wxString& text)
1118 {
1119     wxString value ;
1120         if( wxApp::s_macDefaultEncodingIsPC )
1121                 value = wxMacMakeMacStringFromPC( text ) ;
1122         else
1123                 value = text ;
1124     if ( !m_macUsesTXN )
1125     {
1126                 TEInsert( value , value.Length() , ((TEHandle) m_macTE) ) ;
1127         }
1128         else
1129         {
1130         TXNSetData( ((TXNObject) m_macTXN), kTXNTextData, (void*) (const char*)value, value.Length(),
1131           kTXNUseCurrentSelection, kTXNUseCurrentSelection);
1132         }
1133         MacRedrawControl() ;
1134 }
1135
1136 void wxTextCtrl::AppendText(const wxString& text)
1137 {
1138     SetInsertionPointEnd();
1139     WriteText(text);
1140 }
1141
1142 void wxTextCtrl::Clear()
1143 {
1144     if ( !IsEditable() )
1145     {
1146         return ;
1147     }
1148   if ( !m_macUsesTXN )
1149   {
1150         ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char*) ((const char*)NULL) ) ;
1151   }
1152   else
1153   {
1154             ClearCurrentScrap();
1155             TXNClear((TXNObject)m_macTXN);
1156   }
1157     Refresh() ;
1158 }
1159
1160 bool wxTextCtrl::IsModified() const
1161 {
1162     return TRUE;
1163 }
1164
1165 bool wxTextCtrl::IsEditable() const
1166 {
1167     return IsEnabled() && m_editable ;
1168 }
1169
1170 bool wxTextCtrl::AcceptsFocus() const
1171 {
1172     // we don't want focus if we can't be edited
1173     return /*IsEditable() && */ wxControl::AcceptsFocus();
1174 }
1175
1176 wxSize wxTextCtrl::DoGetBestSize() const
1177 {
1178     int wText = 100 ;
1179
1180     int hText;
1181         if ( m_macUsesTXN )
1182         {
1183             hText = 17 ;
1184         }
1185         else
1186         {
1187             hText = 13 ;
1188         }
1189 /*
1190     int cx, cy;
1191     wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
1192
1193     int wText = DEFAULT_ITEM_WIDTH;
1194
1195     int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
1196
1197     return wxSize(wText, hText);
1198 */
1199     if ( m_windowStyle & wxTE_MULTILINE )
1200     {
1201          hText *= 5 ;
1202     }
1203     hText += 2 * m_macVerticalBorder ;
1204     wText += 2 * m_macHorizontalBorder ;
1205     //else: for single line control everything is ok
1206     return wxSize(wText, hText);
1207 }
1208
1209 // ----------------------------------------------------------------------------
1210 // Undo/redo
1211 // ----------------------------------------------------------------------------
1212
1213 void wxTextCtrl::Undo()
1214 {
1215     if (CanUndo())
1216     {
1217     }
1218 }
1219
1220 void wxTextCtrl::Redo()
1221 {
1222     if (CanRedo())
1223     {
1224     }
1225 }
1226
1227 bool wxTextCtrl::CanUndo() const
1228 {
1229     return FALSE ;
1230 }
1231
1232 bool wxTextCtrl::CanRedo() const
1233 {
1234     return FALSE ;
1235 }
1236
1237 // Makes 'unmodified'
1238 void wxTextCtrl::DiscardEdits()
1239 {
1240     // TODO
1241 }
1242
1243 int wxTextCtrl::GetNumberOfLines() const
1244 {
1245   // TODO change this if possible to reflect real lines
1246   wxString content = GetValue() ;
1247
1248     int count = 1;
1249         for (int i = 0; i < content.Length() ; i++)
1250         {
1251             if (content[i] == '\r') count++;
1252     }
1253
1254     return count;
1255 }
1256
1257 long wxTextCtrl::XYToPosition(long x, long y) const
1258 {
1259     // TODO
1260     return 0;
1261 }
1262
1263 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
1264 {
1265     return FALSE ;
1266 }
1267
1268 void wxTextCtrl::ShowPosition(long pos)
1269 {
1270     // TODO
1271 }
1272
1273 int wxTextCtrl::GetLineLength(long lineNo) const
1274 {
1275   // TODO change this if possible to reflect real lines
1276   wxString content = GetValue() ;
1277
1278         // Find line first
1279         int count = 0;
1280         for (int i = 0; i < content.Length() ; i++)
1281     {
1282         if (count == lineNo)
1283         {
1284             // Count chars in line then
1285             count = 0;
1286                 for (int j = i; j < content.Length(); j++)
1287             {
1288                 count++;
1289                     if (content[j] == '\r') return count;
1290                 }
1291
1292                 return count;
1293             }
1294             if (content[i] == '\r') count++;
1295         }
1296     return 0;
1297 }
1298
1299 wxString wxTextCtrl::GetLineText(long lineNo) const
1300 {
1301   // TODO change this if possible to reflect real lines
1302   wxString content = GetValue() ;
1303
1304         // Find line first
1305         int count = 0;
1306         for (int i = 0; i < content.Length() ; i++)
1307     {
1308         if (count == lineNo)
1309         {
1310             // Add chars in line then
1311             wxString tmp("");
1312
1313                 for (int j = i; j < content.Length(); j++)
1314                 {
1315                     if (content[j] == '\r')
1316                         return tmp;
1317
1318                     tmp += content[j];
1319                 }
1320
1321                 return tmp;
1322             }
1323             if (content[i] == '\r') count++;
1324         }
1325         return "" ;
1326 }
1327
1328 /*
1329  * Text item
1330  */
1331
1332 void wxTextCtrl::Command(wxCommandEvent & event)
1333 {
1334     SetValue (event.GetString());
1335     ProcessCommand (event);
1336 }
1337
1338 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1339 {
1340     // By default, load the first file into the text window.
1341     if (event.GetNumberOfFiles() > 0)
1342     {
1343         LoadFile(event.GetFiles()[0]);
1344     }
1345 }
1346
1347 void wxTextCtrl::OnChar(wxKeyEvent& event)
1348 {
1349     int key = event.GetKeyCode() ;
1350     bool eat_key = false ;
1351
1352     if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
1353         !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
1354 /*        && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
1355         )
1356     {
1357         // eat it
1358         return ;
1359     }
1360     switch ( key )
1361     {
1362         case WXK_RETURN:
1363             if (m_windowStyle & wxPROCESS_ENTER)
1364             {
1365                 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1366                 event.SetEventObject( this );
1367                 event.SetString( GetValue() );
1368                 if ( GetEventHandler()->ProcessEvent(event) )
1369                     return;
1370             }
1371             if ( !(m_windowStyle & wxTE_MULTILINE) )
1372             {
1373                 wxWindow *parent = GetParent();
1374                 while( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL ) {
1375                   parent = parent->GetParent() ;
1376                 }
1377                 if ( parent && parent->GetDefaultItem() )
1378                 {
1379                     wxButton *def = wxDynamicCast(parent->GetDefaultItem(),
1380                                                           wxButton);
1381                     if ( def && def->IsEnabled() )
1382                     {
1383                         wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1384                         event.SetEventObject(def);
1385                         def->Command(event);
1386                         return ;
1387                    }
1388                 }
1389
1390                 // this will make wxWindows eat the ENTER key so that
1391                 // we actually prevent line wrapping in a single line
1392                 // text control
1393                 eat_key = TRUE;
1394             }
1395
1396             break;
1397
1398         case WXK_TAB:
1399             // always produce navigation event - even if we process TAB
1400             // ourselves the fact that we got here means that the user code
1401             // decided to skip processing of this TAB - probably to let it
1402             // do its default job.
1403             {
1404                 wxNavigationKeyEvent eventNav;
1405                 eventNav.SetDirection(!event.ShiftDown());
1406                 eventNav.SetWindowChange(event.ControlDown());
1407                 eventNav.SetEventObject(this);
1408
1409                 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
1410                     return;
1411
1412                 event.Skip() ;
1413                 return;
1414             }
1415             break;
1416     }
1417
1418     EventRecord *ev = (EventRecord*) wxTheApp->MacGetCurrentEvent();
1419     short keychar = short(ev->message & charCodeMask);
1420     if (!eat_key)
1421     {
1422         short keycode = short(ev->message & keyCodeMask) >> 8 ;
1423         ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers );
1424     }
1425     if ( keychar >= 0x20 ||
1426          event.KeyCode() == WXK_RETURN ||
1427          event.KeyCode() == WXK_DELETE ||
1428          event.KeyCode() == WXK_BACK)
1429     {
1430         wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1431         event1.SetString( GetValue() ) ;
1432         event1.SetEventObject( this );
1433         GetEventHandler()->ProcessEvent(event1);
1434     }
1435 }
1436
1437 // ----------------------------------------------------------------------------
1438 // standard handlers for standard edit menu events
1439 // ----------------------------------------------------------------------------
1440
1441 void wxTextCtrl::OnCut(wxCommandEvent& event)
1442 {
1443     Cut();
1444 }
1445
1446 void wxTextCtrl::OnCopy(wxCommandEvent& event)
1447 {
1448     Copy();
1449 }
1450
1451 void wxTextCtrl::OnPaste(wxCommandEvent& event)
1452 {
1453     Paste();
1454 }
1455
1456 void wxTextCtrl::OnUndo(wxCommandEvent& event)
1457 {
1458     Undo();
1459 }
1460
1461 void wxTextCtrl::OnRedo(wxCommandEvent& event)
1462 {
1463     Redo();
1464 }
1465
1466 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1467 {
1468     event.Enable( CanCut() );
1469 }
1470
1471 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1472 {
1473     event.Enable( CanCopy() );
1474 }
1475
1476 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1477 {
1478     event.Enable( CanPaste() );
1479 }
1480
1481 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1482 {
1483     event.Enable( CanUndo() );
1484 }
1485
1486 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1487 {
1488     event.Enable( CanRedo() );
1489 }
1490
1491
1492
1493 #endif
1494     // wxUSE_TEXTCTRL