1 /////////////////////////////////////////////////////////////////////////////
8 // Copyright: (c) AUTHOR
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "textctrl.h"
21 #include <sys/types.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"
39 #if defined(__BORLANDC__) && !defined(__WIN32__)
41 #elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
48 #include <MacTextEditor.h>
49 #include "ATSUnicode.h"
50 #include "TextCommon.h"
51 #include "TextEncodingConverter.h"
52 #include "wx/mac/uma.h"
54 extern wxApp
*wxTheApp
;
55 // CS:We will replace the TextEdit by using the MultiLanguageTextEngine based on the following code written by apple
61 mUPControl implementation.
64 © Copyright 2000 Apple Computer, Inc. All rights reserved.
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.
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.
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.
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.
102 Change History (most recent first):
103 Fri, Jan 28, 2000 -- created
106 #include "MacTextEditor.h"
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
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
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
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
);
133 /* Utility Routines */
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
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
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. */
159 /* OS records referenced */
160 TXNObject fTXNRec
; /* the txn record */
161 TXNFrameID fTXNFrame
; /* the txn frame ID */
163 ControlHandle fUserPaneRec
; /* handle to the user pane control */
164 WindowPtr fOwner
; /* window containing control */
165 GrafPtr fDrawingEnvironment
; /* grafport where control is drawn */
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
;
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
;
195 /* events handled by our focus advance override routine */
197 //static const EventTypeSpec gMLTEEvents[] = { { kEventClassTextInput, kEventUnicodeForKeyEvent } };
198 //#define kMLTEEventCount (sizeof( gMLTEEvents ) / sizeof( EventTypeSpec ))
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
;
208 if (varsp
->fTEActive
!= setActive
) {
210 varsp
->fTEActive
= setActive
;
212 TXNActivate(varsp
->fTXNRec
, varsp
->fTXNFrame
, varsp
->fTEActive
);
215 TXNFocus( varsp
->fTXNRec
, varsp
->fTEActive
);
220 /* TPFocusPaneText set the focus state for the text record. */
221 static void TPFocusPaneText(STPTextPaneVars
**tpvars
, Boolean setFocus
) {
222 STPTextPaneVars
*varsp
;
224 if (varsp
->fInFocus
!= setFocus
) {
225 varsp
->fInFocus
= setFocus
;
226 TXNFocus( varsp
->fTXNRec
, varsp
->fInFocus
);
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
;
239 /* set up our globals */
240 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
241 if (tpvars
!= NULL
) {
242 state
= HGetState((Handle
) tpvars
);
243 HLock((Handle
) tpvars
);
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 ) ;
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
);
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
);
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
;
288 /* set up our locals and lock down our globals*/
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
;
298 /* release oure globals */
299 HSetState((Handle
) tpvars
, state
);
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
;
314 ControlPartCode partCodeResult
;
315 /* make sure we have some variables... */
317 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
318 if (tpvars
!= NULL
) {
320 state
= HGetState((Handle
) tpvars
);
321 HLock((Handle
) tpvars
);
323 /* we don't do any of these functions unless we're in focus */
324 if ( ! varsp
->fInFocus
) {
326 owner
= GetControlOwner(theControl
);
327 ClearKeyboardFocus(owner
);
328 SetKeyboardFocus(owner
, theControl
, kUserClickedToFocusPart
);
330 /* find the location for the click */
331 switch (TPPaneHitTestProc(theControl
, startPt
)) {
333 /* handle clicks in the text part */
335 { SetPort((**tpvars
).fDrawingEnvironment
);
336 TXNClick( varsp
->fTXNRec
, (const EventRecord
*) wxTheApp
->MacGetCurrentEvent());
342 HSetState((Handle
) tpvars
, state
);
344 return partCodeResult
;
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
;
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
) {
360 /* lock down the globals */
361 state
= HGetState((Handle
) tpvars
);
362 HLock((Handle
) tpvars
);
364 /* get the current mouse coordinates (in our window) */
365 SetPortWindowPort(GetControlOwner(theControl
));
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
);
373 if (PtInRect(mousep
, &varsp
->fRTextArea
)) {
375 RectRgn((theRgn
= NewRgn()), &varsp
->fRTextArea
);
376 TXNAdjustCursor(varsp
->fTXNRec
, theRgn
);
378 } else SetThemeCursor(kThemeArrowCursor
);
380 /* if it's in our bounds, set the cursor */
381 GetControlBounds(theControl
, &bounds
);
382 if (PtInRect(mousep
, &bounds
))
383 SetThemeCursor(kThemeArrowCursor
);
386 HSetState((Handle
) tpvars
, state
);
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());
406 return kControlEntireControl
;
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
) {
415 STPTextPaneVars
**tpvars
, *varsp
;
418 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
419 if (tpvars
!= NULL
) {
420 state
= HGetState((Handle
) tpvars
);
421 HLock((Handle
) 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
);
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
440 static pascal ControlPartCode
TPPaneFocusProc(ControlHandle theControl
, ControlFocusPart action
) {
441 ControlPartCode focusResult
;
442 STPTextPaneVars
**tpvars
, *varsp
;
445 focusResult
= kControlFocusNoPart
;
446 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
447 if (tpvars
!= NULL
) {
448 state
= HGetState((Handle
) tpvars
);
449 HLock((Handle
) 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:
459 kControlFocusNoPart - turn off focus and return kControlFocusNoPart. redraw
460 the control and the focus rectangle as necessary.
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 */
473 case kControlFocusNoPart
:
474 TPFocusPaneText(tpvars
, false);
475 focusResult
= kControlFocusNoPart
;
477 case kUserClickedToFocusPart
:
478 TPFocusPaneText(tpvars
, true);
481 case kControlFocusPrevPart
:
482 case kControlFocusNextPart
:
483 TPFocusPaneText(tpvars
, ( ! varsp
->fInFocus
));
484 focusResult
= varsp
->fInFocus
? 1 : kControlFocusNoPart
;
487 TPActivatePaneText(tpvars
, varsp
->fIsActive
&& varsp
->fInFocus
);
488 /* redraw the text fram and focus rectangle to indicate the
490 DrawThemeEditTextFrame(&varsp
->fRTextOutline
, varsp
->fIsActive
? kThemeStateActive
: kThemeStateInactive
);
491 DrawThemeFocusRect(&varsp
->fRFocusOutline
, varsp
->fIsActive
&& varsp
->fInFocus
);
493 HSetState((Handle
) tpvars
, state
);
498 //This our carbon event handler for unicode key downs
500 static pascal OSStatus
FocusAdvanceOverride(EventHandlerCallRef myHandler
, EventRef event
, void* userData
) {
502 STPTextPaneVars
**tpvars
;
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 */
527 return eventNotHandledErr
;
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
)
543 STPTextPaneVars
**tpvars
, *varsp
;
545 RGBColor rgbWhite
= {0xFFFF, 0xFFFF, 0xFFFF};
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
);
557 /* allocate our private storage */
558 tpvars
= (STPTextPaneVars
**) NewHandleClear(sizeof(STPTextPaneVars
));
559 SetControlReference(theControl
, (long) tpvars
);
560 HLock((Handle
) 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
);
570 varsp
->fDrawingEnvironment
= (GrafPtr
) GetWindowPort(theWindow
);
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
590 RectRgn((varsp
->fTextBackgroundRgn
= NewRgn()), &varsp
->fRTextOutline
);
592 /* set up the drawing environment */
593 SetPort(varsp
->fDrawingEnvironment
);
595 /* create the new edit field */
596 TXNNewObject(NULL
, varsp
->fOwner
, &varsp
->fRTextArea
,
597 ( multiline
? kTXNWantVScrollBarMask
: 0 )
598 | kTXNAlwaysWrapAtViewEdgeMask
,
599 kTXNTextEditStyleFrameType
,
601 kTXNSystemDefaultEncoding
,
602 &varsp
->fTXNRec
, &varsp
->fTXNFrame
, (TXNObjectRefcon
) tpvars
);
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;
610 typeAttr
[1].tag
= kTXNQDFontStyleAttribute
;
611 typeAttr
[1].size
= kTXNQDFontStyleAttributeSize
;
612 typeAttr
[1].data
.dataValue
= normal
;
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" ;
620 OSStatus status
= TXNSetTypeAttributes (varsp
->fTXNRec
, sizeof( typeAttr
) / sizeof(TXNTypeAttributes
) , typeAttr
,
623 /* set the field's background */
624 tback
.bgType
= kTXNBackgroundTypeRGB
;
625 tback
.bg
.color
= rgbWhite
;
626 TXNSetBackground( varsp
->fTXNRec
, &tback
);
628 /* install our focus advance override routine */
630 // varsp->handlerUPP = NewEventHandlerUPP(FocusAdvanceOverride);
631 // err = InstallWindowEventHandler( varsp->fOwner, varsp->handlerUPP,
632 // kMLTEEventCount, gMLTEEvents, tpvars, &varsp->handlerRef );
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
);
647 #if !USE_SHARED_LIBRARY
648 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxControl
)
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
)
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
)
668 wxTextCtrl::wxTextCtrl()
670 ((TEHandle
) m_macTE
) = NULL
;
671 ((TXNObject
) m_macTXN
) = NULL
;
672 m_macUsesTXN
= false ;
676 wxTextCtrl::~wxTextCtrl()
680 TXNDeleteObject((TXNObject
)m_macTXN
);
682 /* remove our focus advance override */
683 // RemoveEventHandler((**tpvars).handlerRef);
684 // DisposeEventHandlerUPP((**tpvars).handlerUPP);
686 /* delete our private storage */
687 DisposeHandle((Handle
) m_macTXNvars
);
688 /* zero the control reference */
689 SetControlReference((ControlHandle
)m_macControl
, 0) ;
693 const short kVerticalMargin
= 2 ;
694 const short kHorizontalMargin
= 2 ;
696 bool wxTextCtrl::Create(wxWindow
*parent
, wxWindowID id
,
699 const wxSize
& size
, long style
,
700 const wxValidator
& validator
,
701 const wxString
& name
)
703 ((TEHandle
) m_macTE
) = NULL
;
704 ((TXNObject
) m_macTXN
) = NULL
;
705 m_macUsesTXN
= false ;
708 m_macUsesTXN
= ! (style
& wxTE_PASSWORD
) ;
710 m_macUsesTXN
&= (TXNInitTextension
!= (void*) kUnresolvedCFragSymbolAddress
) ;
712 // base initialization
713 if ( !CreateBase(parent
, id
, pos
, size
, style
, validator
, name
) )
716 wxSize mySize
= size
;
719 m_macHorizontalBorder
= 5 ; // additional pixels around the real control
720 m_macVerticalBorder
= 3 ;
724 m_macHorizontalBorder
= 5 ; // additional pixels around the real control
725 m_macVerticalBorder
= 5 ;
732 if ( mySize
.y
== -1 )
739 mySize
.y
+= 2 * m_macVerticalBorder
;
742 MacPreControlCreate( parent
, id
, "" , pos
, mySize
,style
, validator
, name
, &bounds
, title
) ;
744 if ( m_windowStyle
& wxTE_MULTILINE
)
746 wxASSERT_MSG( !(m_windowStyle
& wxTE_PROCESS_ENTER
),
747 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
749 m_windowStyle
|= wxTE_PROCESS_ENTER
;
755 m_macControl
= ::NewControl( (GrafPtr
) parent
->MacGetRootWindow() , &bounds
, "\p" , true , 0 , 0 , 1,
756 (style
& wxTE_PASSWORD
) ? kControlEditTextPasswordProc
: kControlEditTextProc
, (long) this ) ;
758 ::GetControlData((ControlHandle
) m_macControl
, 0, kControlEditTextTEHandleTag
, sizeof( TEHandle
) , (char*) &((TEHandle
) m_macTE
) , &size
) ;
765 featurSet
= kControlSupportsEmbedding
| kControlSupportsFocus
| kControlWantsIdle
766 | kControlWantsActivate
| kControlHandlesTracking
| kControlHasSpecialBackground
767 | kControlGetsFocusOnClick
| kControlSupportsLiveFeedback
;
768 /* create the control */
769 m_macControl
= NewControl((GrafPtr
) 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
);
773 MacPostControlCreate() ;
777 if( wxApp::s_macDefaultEncodingIsPC
)
778 value
= wxMacMakeMacStringFromPC( st
) ;
784 ::SetControlData( (ControlHandle
) m_macControl
, 0, ( m_windowStyle
& wxTE_PASSWORD
) ? kControlEditTextPasswordTag
: kControlEditTextTextTag
, value
.Length() , (char*) ((const char*)value
) ) ;
788 STPTextPaneVars
**tpvars
;
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 ;
802 wxString
wxTextCtrl::GetValue() const
807 ::GetControlData( (ControlHandle
) m_macControl
, 0, ( m_windowStyle
& wxTE_PASSWORD
) ? kControlEditTextPasswordTag
: kControlEditTextTextTag
, 32767 , wxBuffer
, &actualsize
) ;
812 OSStatus err
= TXNGetDataEncoded( ((TXNObject
) m_macTXN
), kTXNStartOffset
, kTXNEndOffset
, &theText
, kTXNTextData
);
820 actualsize
= GetHandleSize( theText
) ;
821 strncpy( wxBuffer
, *theText
, actualsize
) ;
822 DisposeHandle( theText
) ;
825 wxBuffer
[actualsize
] = 0 ;
826 if( wxApp::s_macDefaultEncodingIsPC
)
827 return wxMacMakePCStringFromMac( wxBuffer
) ;
829 return wxString(wxBuffer
);
832 void wxTextCtrl::GetSelection(long* from
, long* to
) const
836 *from
= (**((TEHandle
) m_macTE
)).selStart
;
837 *to
= (**((TEHandle
) m_macTE
)).selEnd
;
841 TXNGetSelection( ((TXNObject
) m_macTXN
) , (TXNOffset
*) from
, (TXNOffset
*) to
) ;
845 void wxTextCtrl::SetValue(const wxString
& st
)
849 if( wxApp::s_macDefaultEncodingIsPC
)
850 value
= wxMacMakeMacStringFromPC( st
) ;
855 ::SetControlData((ControlHandle
) m_macControl
, 0, ( m_windowStyle
& wxTE_PASSWORD
) ? kControlEditTextPasswordTag
: kControlEditTextTextTag
, value
.Length() , (char*) ((const char*)value
) ) ;
859 TXNSetData( ((TXNObject
) m_macTXN
), kTXNTextData
, (void*)value
.c_str(), value
.Length(),
860 kTXNStartOffset
, kTXNEndOffset
);
865 // Clipboard operations
866 void wxTextCtrl::Copy()
872 TECopy( ((TEHandle
) m_macTE
) ) ;
880 TXNCopy((TXNObject
)m_macTXN
);
881 TXNConvertToPublicScrap();
886 void wxTextCtrl::Cut()
892 TECut( ((TEHandle
) m_macTE
) ) ;
900 TXNCut((TXNObject
)m_macTXN
);
901 TXNConvertToPublicScrap();
903 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, m_windowId
);
904 event
.SetString( GetValue() ) ;
905 event
.SetEventObject( this );
906 GetEventHandler()->ProcessEvent(event
);
910 void wxTextCtrl::Paste()
917 TEPaste( (TEHandle
) m_macTE
) ;
922 TXNConvertFromPublicScrap();
923 TXNPaste((TXNObject
)m_macTXN
);
925 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, m_windowId
);
926 event
.SetString( GetValue() ) ;
927 event
.SetEventObject( this );
928 GetEventHandler()->ProcessEvent(event
);
932 bool wxTextCtrl::CanCopy() const
934 // Can copy if there's a selection
936 GetSelection(& from
, & to
);
940 bool wxTextCtrl::CanCut() const
946 // Can cut if there's a selection
948 GetSelection(& from
, & to
);
952 bool wxTextCtrl::CanPaste() const
959 OSStatus err
= noErr
;
962 err
= GetCurrentScrap( &scrapRef
);
963 if ( err
!= noTypeErr
&& err
!= memFullErr
)
965 ScrapFlavorFlags flavorFlags
;
968 if (( err
= GetScrapFlavorFlags( scrapRef
, 'TEXT', &flavorFlags
)) == noErr
)
970 if (( err
= GetScrapFlavorSize( scrapRef
, 'TEXT', &byteCount
)) == noErr
)
979 if ( GetScrap( NULL
, 'TEXT' , &offset
) > 0 )
987 void wxTextCtrl::SetEditable(bool editable
)
989 if ( editable
!= m_editable
)
991 m_editable
= editable
;
993 UMAActivateControl( (ControlHandle
) m_macControl
) ;
995 UMADeactivateControl((ControlHandle
) m_macControl
) ;
999 void wxTextCtrl::SetInsertionPoint(long pos
)
1001 SetSelection( pos
, pos
) ;
1004 void wxTextCtrl::SetInsertionPointEnd()
1006 long pos
= GetLastPosition();
1007 SetInsertionPoint(pos
);
1010 long wxTextCtrl::GetInsertionPoint() const
1013 GetSelection( &begin
, &end
) ;
1017 long wxTextCtrl::GetLastPosition() const
1019 if ( !m_macUsesTXN
)
1021 return (**((TEHandle
) m_macTE
)).teLength
;
1027 OSErr err
= TXNGetDataEncoded( (TXNObject
) m_macTXN
, kTXNStartOffset
, kTXNEndOffset
, &theText
, kTXNTextData
);
1035 actualsize
= GetHandleSize( theText
) ;
1036 DisposeHandle( theText
) ;
1042 void wxTextCtrl::Replace(long from
, long to
, const wxString
& value
)
1044 if ( !m_macUsesTXN
)
1046 ControlEditTextSelectionRec selection
;
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
) ) ;
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
);
1065 void wxTextCtrl::Remove(long from
, long to
)
1067 if ( !m_macUsesTXN
)
1069 ControlEditTextSelectionRec selection
;
1071 selection
.selStart
= from
;
1072 selection
.selEnd
= to
;
1073 ::SetControlData( (ControlHandle
) m_macControl
, 0, kControlEditTextSelectionTag
, sizeof( selection
) , (char*) &selection
) ;
1074 TEDelete( ((TEHandle
) m_macTE
) ) ;
1078 TXNSetSelection( ((TXNObject
) m_macTXN
) , from
, to
) ;
1079 TXNClear( ((TXNObject
) m_macTXN
) ) ;
1084 void wxTextCtrl::SetSelection(long from
, long to
)
1087 if ( !m_macUsesTXN
)
1089 ControlEditTextSelectionRec selection
;
1090 selection
.selStart
= from
;
1091 selection
.selEnd
= to
;
1093 TESetSelect( selection
.selStart
, selection
.selEnd
, ((TEHandle
) m_macTE
) ) ;
1094 ::SetControlData((ControlHandle
) m_macControl
, 0, kControlEditTextSelectionTag
, sizeof( selection
) , (char*) &selection
) ;
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
);
1109 bool wxTextCtrl::LoadFile(const wxString
& file
)
1111 if ( wxTextCtrlBase::LoadFile(file
) )
1119 void wxTextCtrl::WriteText(const wxString
& text
)
1122 if( wxApp::s_macDefaultEncodingIsPC
)
1123 value
= wxMacMakeMacStringFromPC( text
) ;
1126 if ( !m_macUsesTXN
)
1128 TEInsert( value
, value
.Length() , ((TEHandle
) m_macTE
) ) ;
1132 TXNSetData( ((TXNObject
) m_macTXN
), kTXNTextData
, (const char*)value
, value
.Length(),
1133 kTXNUseCurrentSelection
, kTXNUseCurrentSelection
);
1135 MacRedrawControl() ;
1138 void wxTextCtrl::AppendText(const wxString
& text
)
1140 SetInsertionPointEnd();
1144 void wxTextCtrl::Clear()
1146 if ( !IsEditable() )
1150 if ( !m_macUsesTXN
)
1152 ::SetControlData((ControlHandle
) m_macControl
, 0, ( m_windowStyle
& wxTE_PASSWORD
) ? kControlEditTextPasswordTag
: kControlEditTextTextTag
, 0 , (char*) ((const char*)NULL
) ) ;
1156 ClearCurrentScrap();
1157 TXNClear((TXNObject
)m_macTXN
);
1162 bool wxTextCtrl::IsModified() const
1167 bool wxTextCtrl::IsEditable() const
1169 return IsEnabled() && m_editable
;
1172 bool wxTextCtrl::AcceptsFocus() const
1174 // we don't want focus if we can't be edited
1175 return /*IsEditable() && */ wxControl::AcceptsFocus();
1178 wxSize
wxTextCtrl::DoGetBestSize() const
1183 if ( UMAHasAppearance() )
1187 hText
+= 2 * m_macHorizontalBorder
;
1190 wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
1192 int wText = DEFAULT_ITEM_WIDTH;
1194 int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
1196 return wxSize(wText, hText);
1198 if ( m_windowStyle
& wxTE_MULTILINE
)
1200 hText
*= wxMin(GetNumberOfLines(), 5);
1202 //else: for single line control everything is ok
1203 return wxSize(wText
, hText
);
1206 // ----------------------------------------------------------------------------
1208 // ----------------------------------------------------------------------------
1210 void wxTextCtrl::Undo()
1217 void wxTextCtrl::Redo()
1224 bool wxTextCtrl::CanUndo() const
1229 bool wxTextCtrl::CanRedo() const
1234 // Makes 'unmodified'
1235 void wxTextCtrl::DiscardEdits()
1240 int wxTextCtrl::GetNumberOfLines() const
1242 // TODO change this if possible to reflect real lines
1243 wxString content
= GetValue() ;
1246 for (int i
= 0; i
< content
.Length() ; i
++)
1248 if (content
[i
] == '\r') count
++;
1254 long wxTextCtrl::XYToPosition(long x
, long y
) const
1260 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
1265 void wxTextCtrl::ShowPosition(long pos
)
1270 int wxTextCtrl::GetLineLength(long lineNo
) const
1272 // TODO change this if possible to reflect real lines
1273 wxString content
= GetValue() ;
1277 for (int i
= 0; i
< content
.Length() ; i
++)
1279 if (count
== lineNo
)
1281 // Count chars in line then
1283 for (int j
= i
; j
< content
.Length(); j
++)
1286 if (content
[j
] == '\r') return count
;
1291 if (content
[i
] == '\r') count
++;
1296 wxString
wxTextCtrl::GetLineText(long lineNo
) const
1298 // TODO change this if possible to reflect real lines
1299 wxString content
= GetValue() ;
1303 for (int i
= 0; i
< content
.Length() ; i
++)
1305 if (count
== lineNo
)
1307 // Add chars in line then
1310 for (int j
= i
; j
< content
.Length(); j
++)
1312 if (content
[j
] == '\r')
1320 if (content
[i
] == '\r') count
++;
1328 void wxTextCtrl::Command(wxCommandEvent
& event
)
1330 SetValue (event
.GetString());
1331 ProcessCommand (event
);
1334 void wxTextCtrl::OnDropFiles(wxDropFilesEvent
& event
)
1336 // By default, load the first file into the text window.
1337 if (event
.GetNumberOfFiles() > 0)
1339 LoadFile(event
.GetFiles()[0]);
1343 void wxTextCtrl::OnChar(wxKeyEvent
& event
)
1345 int key
= event
.GetKeyCode() ;
1346 bool eat_key
= false ;
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 */
1359 if (m_windowStyle
& wxPROCESS_ENTER
)
1361 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1362 event
.SetEventObject( this );
1363 event
.SetString( GetValue() );
1364 if ( GetEventHandler()->ProcessEvent(event
) )
1367 if ( !(m_windowStyle
& wxTE_MULTILINE
) )
1369 wxWindow
*parent
= GetParent();
1370 while( parent
&& !parent
->IsTopLevel() && parent
->GetDefaultItem() == NULL
) {
1371 parent
= parent
->GetParent() ;
1373 if ( parent
&& parent
->GetDefaultItem() )
1375 wxButton
*def
= wxDynamicCast(parent
->GetDefaultItem(),
1377 if ( def
&& def
->IsEnabled() )
1379 wxCommandEvent
event(wxEVT_COMMAND_BUTTON_CLICKED
, def
->GetId() );
1380 event
.SetEventObject(def
);
1381 def
->Command(event
);
1386 // this will make wxWindows eat the ENTER key so that
1387 // we actually prevent line wrapping in a single line
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.
1400 wxNavigationKeyEvent eventNav
;
1401 eventNav
.SetDirection(!event
.ShiftDown());
1402 eventNav
.SetWindowChange(event
.ControlDown());
1403 eventNav
.SetEventObject(this);
1405 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav
) )
1414 EventRecord
*ev
= (EventRecord
*) wxTheApp
->MacGetCurrentEvent();
1415 short keychar
= short(ev
->message
& charCodeMask
);
1418 short keycode
= short(ev
->message
& keyCodeMask
) >> 8 ;
1419 ::HandleControlKey( (ControlHandle
) m_macControl
, keycode
, keychar
, ev
->modifiers
);
1421 if ( keychar
>= 0x20 ||
1422 event
.KeyCode() == WXK_RETURN
||
1423 event
.KeyCode() == WXK_DELETE
||
1424 event
.KeyCode() == WXK_BACK
)
1426 wxCommandEvent
event1(wxEVT_COMMAND_TEXT_UPDATED
, m_windowId
);
1427 event1
.SetString( GetValue() ) ;
1428 event1
.SetEventObject( this );
1429 GetEventHandler()->ProcessEvent(event1
);
1433 // ----------------------------------------------------------------------------
1434 // standard handlers for standard edit menu events
1435 // ----------------------------------------------------------------------------
1437 void wxTextCtrl::OnCut(wxCommandEvent
& event
)
1442 void wxTextCtrl::OnCopy(wxCommandEvent
& event
)
1447 void wxTextCtrl::OnPaste(wxCommandEvent
& event
)
1452 void wxTextCtrl::OnUndo(wxCommandEvent
& event
)
1457 void wxTextCtrl::OnRedo(wxCommandEvent
& event
)
1462 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
1464 event
.Enable( CanCut() );
1467 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
1469 event
.Enable( CanCopy() );
1472 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
1474 event
.Enable( CanPaste() );
1477 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
1479 event
.Enable( CanUndo() );
1482 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
1484 event
.Enable( CanRedo() );