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 #define TE_UNLIMITED_LENGTH 0xFFFFFFFFUL
56 extern wxApp
*wxTheApp
;
57 extern wxControl
*wxFindControlFromMacControl(ControlHandle inControl
) ;
59 // CS:TODO we still have a problem getting properly at the text events of a control because under Carbon
60 // the MLTE engine registers itself for the key events thus the normal flow never occurs, the only measure for the
61 // moment is to avoid setting the true focus on the control, the proper solution at the end would be to have
62 // an alternate path for carbon key events that routes automatically into the same wx flow of events
64 #include "MacTextEditor.h"
68 /* kmUPTextPart is the part code we return to indicate the user has clicked
69 in the text area of our control */
70 #define kmUPTextPart 1
72 /* kmUPScrollPart is the part code we return to indicate the user has clicked
73 in the scroll bar part of the control. */
74 #define kmUPScrollPart 2
77 /* routines for using existing user pane controls.
78 These routines are useful for cases where you would like to use an
79 existing user pane control in, say, a dialog window as a scrolling
82 /* mUPOpenControl initializes a user pane control so it will be drawn
83 and will behave as a scrolling text edit field inside of a window.
84 This routine performs all of the initialization steps necessary,
85 except it does not create the user pane control itself. theControl
86 should refer to a user pane control that you have either created
87 yourself or extracted from a dialog's control heirarchy using
88 the GetDialogItemAsControl routine. */
89 OSStatus
mUPOpenControl(ControlHandle theControl
, long wxStyle
);
91 /* Utility Routines */
97 /* kUserClickedToFocusPart is a part code we pass to the SetKeyboardFocus
98 routine. In our focus switching routine this part code is understood
99 as meaning 'the user has clicked in the control and we need to switch
100 the current focus to ourselves before we can continue'. */
101 #define kUserClickedToFocusPart 100
104 /* kmUPClickScrollDelayTicks is a time measurement in ticks used to
105 slow the speed of 'auto scrolling' inside of our clickloop routine.
106 This value prevents the text from wizzzzzing by while the mouse
107 is being held down inside of the text area. */
108 #define kmUPClickScrollDelayTicks 3
111 /* STPTextPaneVars is a structure used for storing the the mUP Control's
112 internal variables and state information. A handle to this record is
113 stored in the pane control's reference value field using the
114 SetControlReference routine. */
117 /* OS records referenced */
118 TXNObject fTXNRec
; /* the txn record */
119 TXNFrameID fTXNFrame
; /* the txn frame ID */
120 ControlHandle fUserPaneRec
; /* handle to the user pane control */
121 WindowPtr fOwner
; /* window containing control */
122 GrafPtr fDrawingEnvironment
; /* grafport where control is drawn */
124 Boolean fInFocus
; /* true while the focus rect is drawn around the control */
125 Boolean fIsActive
; /* true while the control is drawn in the active state */
126 Boolean fTEActive
; /* reflects the activation state of the text edit record */
127 Boolean fInDialogWindow
; /* true if displayed in a dialog window */
128 /* calculated locations */
129 Rect fRTextArea
; /* area where the text is drawn */
130 Rect fRFocusOutline
; /* rectangle used to draw the focus box */
131 Rect fRTextOutline
; /* rectangle used to draw the border */
132 RgnHandle fTextBackgroundRgn
; /* background region for the text, erased before calling TEUpdate */
133 /* our focus advance override routine */
134 EventHandlerUPP handlerUPP
;
135 EventHandlerRef handlerRef
;
142 /* Univerals Procedure Pointer variables used by the
143 mUP Control. These variables are set up
144 the first time that mUPOpenControl is called. */
145 ControlUserPaneDrawUPP gTPDrawProc
= NULL
;
146 ControlUserPaneHitTestUPP gTPHitProc
= NULL
;
147 ControlUserPaneTrackingUPP gTPTrackProc
= NULL
;
148 ControlUserPaneIdleUPP gTPIdleProc
= NULL
;
149 ControlUserPaneKeyDownUPP gTPKeyProc
= NULL
;
150 ControlUserPaneActivateUPP gTPActivateProc
= NULL
;
151 ControlUserPaneFocusUPP gTPFocusProc
= NULL
;
153 /* TPActivatePaneText activates or deactivates the text edit record
154 according to the value of setActive. The primary purpose of this
155 routine is to ensure each call is only made once. */
156 static void TPActivatePaneText(STPTextPaneVars
**tpvars
, Boolean setActive
) {
157 STPTextPaneVars
*varsp
;
159 if (varsp
->fTEActive
!= setActive
) {
161 varsp
->fTEActive
= setActive
;
163 TXNActivate(varsp
->fTXNRec
, varsp
->fTXNFrame
, varsp
->fTEActive
);
166 TXNFocus( varsp
->fTXNRec
, varsp
->fTEActive
);
171 /* TPFocusPaneText set the focus state for the text record. */
172 static void TPFocusPaneText(STPTextPaneVars
**tpvars
, Boolean setFocus
) {
173 STPTextPaneVars
*varsp
;
175 if (varsp
->fInFocus
!= setFocus
) {
176 varsp
->fInFocus
= setFocus
;
177 TXNFocus( varsp
->fTXNRec
, varsp
->fInFocus
);
182 /* TPPaneDrawProc is called to redraw the control and for update events
183 referring to the control. This routine erases the text area's background,
184 and redraws the text. This routine assumes the scroll bar has been
185 redrawn by a call to DrawControls. */
186 static pascal void TPPaneDrawProc(ControlRef theControl
, ControlPartCode thePart
) {
187 STPTextPaneVars
**tpvars
, *varsp
;
190 /* set up our globals */
192 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
193 if (tpvars
!= NULL
) {
194 state
= HGetState((Handle
) tpvars
);
195 HLock((Handle
) tpvars
);
198 /* save the drawing state */
199 SetPort((**tpvars
).fDrawingEnvironment
);
200 /* verify our boundary */
201 GetControlBounds(theControl
, &bounds
);
203 wxMacWindowClipper
clipper( wxFindControlFromMacControl(theControl
) ) ;
204 if ( ! EqualRect(&bounds
, &varsp
->fRFocusOutline
) ) {
205 // scrollbar is on the border, we add one
206 Rect oldbounds
= varsp
->fRFocusOutline
;
207 InsetRect( &oldbounds
, -1 , -1 ) ;
209 InvalWindowRect( GetControlOwner( theControl
) , &oldbounds
) ;
210 SetRect(&varsp
->fRFocusOutline
, bounds
.left
, bounds
.top
, bounds
.right
, bounds
.bottom
);
211 SetRect(&varsp
->fRTextOutline
, bounds
.left
, bounds
.top
, bounds
.right
, bounds
.bottom
);
212 SetRect(&varsp
->fRTextArea
, bounds
.left
+ 2 , bounds
.top
+ (varsp
->fMultiline
? 0 : 2) ,
213 bounds
.right
- (varsp
->fMultiline
? 0 : 2), bounds
.bottom
- (varsp
->fMultiline
? 0 : 2));
214 RectRgn(varsp
->fTextBackgroundRgn
, &varsp
->fRTextOutline
);
215 TXNSetFrameBounds( varsp
->fTXNRec
, varsp
->fRTextArea
.top
, varsp
->fRTextArea
.left
,
216 varsp
->fRTextArea
.bottom
, varsp
->fRTextArea
.right
, varsp
->fTXNFrame
);
219 /* update the text region */
220 RGBColor white
= { 65535 , 65535 , 65535 } ;
221 RGBBackColor( &white
) ;
222 EraseRgn(varsp
->fTextBackgroundRgn
);
223 TXNDraw(varsp
->fTXNRec
, NULL
);
224 /* restore the drawing environment */
225 /* draw the text frame and focus frame (if necessary) */
226 DrawThemeEditTextFrame(&varsp
->fRTextOutline
, varsp
->fIsActive
? kThemeStateActive
: kThemeStateInactive
);
227 if ((**tpvars
).fIsActive
&& varsp
->fInFocus
) DrawThemeFocusRect(&varsp
->fRFocusOutline
, true);
228 /* release our globals */
229 HSetState((Handle
) tpvars
, state
);
235 /* TPPaneHitTestProc is called when the control manager would
236 like to determine what part of the control the mouse resides over.
237 We also call this routine from our tracking proc to determine how
238 to handle mouse clicks. */
239 static pascal ControlPartCode
TPPaneHitTestProc(ControlHandle theControl
, Point where
) {
240 STPTextPaneVars
**tpvars
;
241 ControlPartCode result
;
243 /* set up our locals and lock down our globals*/
245 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
246 if (tpvars
!= NULL
) {
247 state
= HGetState((Handle
) tpvars
);
248 HLock((Handle
) tpvars
);
249 /* find the region where we clicked */
250 if (PtInRect(where
, &(**tpvars
).fRTextArea
)) {
251 result
= kmUPTextPart
;
253 /* release oure globals */
254 HSetState((Handle
) tpvars
, state
);
263 /* TPPaneTrackingProc is called when the mouse is being held down
264 over our control. This routine handles clicks in the text area
265 and in the scroll bar. */
266 static pascal ControlPartCode
TPPaneTrackingProc(ControlHandle theControl
, Point startPt
, ControlActionUPP actionProc
) {
267 STPTextPaneVars
**tpvars
, *varsp
;
269 ControlPartCode partCodeResult
;
270 /* make sure we have some variables... */
272 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
273 if (tpvars
!= NULL
) {
275 state
= HGetState((Handle
) tpvars
);
276 HLock((Handle
) tpvars
);
278 /* we don't do any of these functions unless we're in focus */
279 if ( ! varsp
->fInFocus
) {
281 owner
= GetControlOwner(theControl
);
282 ClearKeyboardFocus(owner
);
283 SetKeyboardFocus(owner
, theControl
, kUserClickedToFocusPart
);
285 /* find the location for the click */
286 switch (TPPaneHitTestProc(theControl
, startPt
)) {
288 /* handle clicks in the text part */
290 { SetPort((**tpvars
).fDrawingEnvironment
);
291 wxMacWindowClipper
clipper( wxFindControlFromMacControl(theControl
) ) ;
292 TXNClick( varsp
->fTXNRec
, (const EventRecord
*) wxTheApp
->MacGetCurrentEvent());
298 HSetState((Handle
) tpvars
, state
);
300 return partCodeResult
;
304 /* TPPaneIdleProc is our user pane idle routine. When our text field
305 is active and in focus, we use this routine to set the cursor. */
306 static pascal void TPPaneIdleProc(ControlHandle theControl
) {
307 STPTextPaneVars
**tpvars
, *varsp
;
309 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
310 if (tpvars
!= NULL
) {
311 /* if we're not active, then we have nothing to say about the cursor */
312 if ((**tpvars
).fIsActive
) {
316 /* lock down the globals */
317 state
= HGetState((Handle
) tpvars
);
318 HLock((Handle
) tpvars
);
320 /* get the current mouse coordinates (in our window) */
321 SetPortWindowPort(GetControlOwner(theControl
));
322 wxMacWindowClipper
clipper( wxFindControlFromMacControl(theControl
) ) ;
324 /* there's a 'focus thing' and an 'unfocused thing' */
325 if (varsp
->fInFocus
) {
326 /* flash the cursor */
327 SetPort((**tpvars
).fDrawingEnvironment
);
328 TXNIdle(varsp
->fTXNRec
);
330 if (PtInRect(mousep
, &varsp
->fRTextArea
)) {
332 RectRgn((theRgn
= NewRgn()), &varsp
->fRTextArea
);
333 TXNAdjustCursor(varsp
->fTXNRec
, theRgn
);
335 } else SetThemeCursor(kThemeArrowCursor
);
337 /* if it's in our bounds, set the cursor */
338 GetControlBounds(theControl
, &bounds
);
339 if (PtInRect(mousep
, &bounds
))
340 SetThemeCursor(kThemeArrowCursor
);
343 HSetState((Handle
) tpvars
, state
);
349 /* TPPaneKeyDownProc is called whenever a keydown event is directed
350 at our control. Here, we direct the keydown event to the text
351 edit record and redraw the scroll bar and text field as appropriate. */
352 static pascal ControlPartCode
TPPaneKeyDownProc(ControlHandle theControl
,
353 SInt16 keyCode
, SInt16 charCode
, SInt16 modifiers
) {
354 STPTextPaneVars
**tpvars
;
355 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
356 if (tpvars
!= NULL
) {
357 if ((**tpvars
).fInFocus
) {
358 /* turn autoscrolling on and send the key event to text edit */
359 SetPort((**tpvars
).fDrawingEnvironment
);
360 wxMacWindowClipper
clipper( wxFindControlFromMacControl(theControl
) ) ;
362 memset( &ev
, 0 , sizeof( ev
) ) ;
364 ev
.modifiers
= modifiers
;
365 ev
.message
= (( keyCode
<< 8 ) & keyCodeMask
) + ( charCode
& charCodeMask
) ;
366 TXNKeyDown( (**tpvars
).fTXNRec
, &ev
);
369 return kControlEntireControl
;
373 /* TPPaneActivateProc is called when the window containing
374 the user pane control receives activate events. Here, we redraw
375 the control and it's text as necessary for the activation state. */
376 static pascal void TPPaneActivateProc(ControlHandle theControl
, Boolean activating
) {
378 STPTextPaneVars
**tpvars
, *varsp
;
381 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
382 if (tpvars
!= NULL
) {
383 state
= HGetState((Handle
) tpvars
);
384 HLock((Handle
) tpvars
);
386 /* de/activate the text edit record */
387 SetPort((**tpvars
).fDrawingEnvironment
);
388 wxMacWindowClipper
clipper( wxFindControlFromMacControl(theControl
) ) ;
389 GetControlBounds(theControl
, &bounds
);
390 varsp
->fIsActive
= activating
;
391 TPActivatePaneText(tpvars
, varsp
->fIsActive
&& varsp
->fInFocus
);
392 /* redraw the frame */
393 DrawThemeEditTextFrame(&varsp
->fRTextOutline
, varsp
->fIsActive
? kThemeStateActive
: kThemeStateInactive
);
394 if (varsp
->fInFocus
) DrawThemeFocusRect(&varsp
->fRFocusOutline
, varsp
->fIsActive
);
395 HSetState((Handle
) tpvars
, state
);
400 /* TPPaneFocusProc is called when every the focus changes to or
401 from our control. Herein, switch the focus appropriately
402 according to the parameters and redraw the control as
404 static pascal ControlPartCode
TPPaneFocusProc(ControlHandle theControl
, ControlFocusPart action
) {
405 ControlPartCode focusResult
;
406 STPTextPaneVars
**tpvars
, *varsp
;
409 focusResult
= kControlFocusNoPart
;
410 tpvars
= (STPTextPaneVars
**) GetControlReference(theControl
);
411 if (tpvars
!= NULL
) {
412 state
= HGetState((Handle
) tpvars
);
413 HLock((Handle
) tpvars
);
415 /* if kControlFocusPrevPart and kControlFocusNextPart are received when the user is
416 tabbing forwards (or shift tabbing backwards) through the items in the dialog,
417 and kControlFocusNextPart will be received. When the user clicks in our field
418 and it is not the current focus, then the constant kUserClickedToFocusPart will
419 be received. The constant kControlFocusNoPart will be received when our control
420 is the current focus and the user clicks in another control. In your focus routine,
421 you should respond to these codes as follows:
423 kControlFocusNoPart - turn off focus and return kControlFocusNoPart. redraw
424 the control and the focus rectangle as necessary.
426 kControlFocusPrevPart or kControlFocusNextPart - toggle focus on or off
427 depending on its current state. redraw the control and the focus rectangle
428 as appropriate for the new focus state. If the focus state is 'off', return the constant
429 kControlFocusNoPart, otherwise return a non-zero part code.
430 kUserClickedToFocusPart - is a constant defined for this example. You should
431 define your own value for handling click-to-focus type events. */
432 /* save the drawing state */
433 SetPort((**tpvars
).fDrawingEnvironment
);
434 wxMacWindowClipper
clipper( wxFindControlFromMacControl(theControl
) ) ;
435 /* calculate the next highlight state */
438 case kControlFocusNoPart
:
439 TPFocusPaneText(tpvars
, false);
440 focusResult
= kControlFocusNoPart
;
442 case kUserClickedToFocusPart
:
443 TPFocusPaneText(tpvars
, true);
446 case kControlFocusPrevPart
:
447 case kControlFocusNextPart
:
448 TPFocusPaneText(tpvars
, ( ! varsp
->fInFocus
));
449 focusResult
= varsp
->fInFocus
? 1 : kControlFocusNoPart
;
452 TPActivatePaneText(tpvars
, varsp
->fIsActive
&& varsp
->fInFocus
);
453 /* redraw the text fram and focus rectangle to indicate the
455 DrawThemeEditTextFrame(&varsp
->fRTextOutline
, varsp
->fIsActive
? kThemeStateActive
: kThemeStateInactive
);
456 DrawThemeFocusRect(&varsp
->fRFocusOutline
, varsp
->fIsActive
&& varsp
->fInFocus
);
458 HSetState((Handle
) tpvars
, state
);
464 /* mUPOpenControl initializes a user pane control so it will be drawn
465 and will behave as a scrolling text edit field inside of a window.
466 This routine performs all of the initialization steps necessary,
467 except it does not create the user pane control itself. theControl
468 should refer to a user pane control that you have either created
469 yourself or extracted from a dialog's control heirarchy using
470 the GetDialogItemAsControl routine. */
471 OSStatus
mUPOpenControl(ControlHandle theControl
, long wxStyle
)
475 STPTextPaneVars
**tpvars
, *varsp
;
476 OSStatus err
= noErr
;
477 RGBColor rgbWhite
= {0xFFFF, 0xFFFF, 0xFFFF};
480 /* set up our globals */
481 if (gTPDrawProc
== NULL
) gTPDrawProc
= NewControlUserPaneDrawUPP(TPPaneDrawProc
);
482 if (gTPHitProc
== NULL
) gTPHitProc
= NewControlUserPaneHitTestUPP(TPPaneHitTestProc
);
483 if (gTPTrackProc
== NULL
) gTPTrackProc
= NewControlUserPaneTrackingUPP(TPPaneTrackingProc
);
484 if (gTPIdleProc
== NULL
) gTPIdleProc
= NewControlUserPaneIdleUPP(TPPaneIdleProc
);
485 if (gTPKeyProc
== NULL
) gTPKeyProc
= NewControlUserPaneKeyDownUPP(TPPaneKeyDownProc
);
486 if (gTPActivateProc
== NULL
) gTPActivateProc
= NewControlUserPaneActivateUPP(TPPaneActivateProc
);
487 if (gTPFocusProc
== NULL
) gTPFocusProc
= NewControlUserPaneFocusUPP(TPPaneFocusProc
);
489 /* allocate our private storage */
490 tpvars
= (STPTextPaneVars
**) NewHandleClear(sizeof(STPTextPaneVars
));
491 SetControlReference(theControl
, (long) tpvars
);
492 HLock((Handle
) tpvars
);
494 /* set the initial settings for our private data */
495 varsp
->fMultiline
= wxStyle
& wxTE_MULTILINE
;
496 varsp
->fInFocus
= false;
497 varsp
->fIsActive
= true;
498 varsp
->fTEActive
= true; // in order to get a deactivate
499 varsp
->fUserPaneRec
= theControl
;
500 theWindow
= varsp
->fOwner
= GetControlOwner(theControl
);
502 varsp
->fDrawingEnvironment
= (GrafPtr
) GetWindowPort(theWindow
);
504 varsp
->fInDialogWindow
= ( GetWindowKind(varsp
->fOwner
) == kDialogWindowKind
);
505 /* set up the user pane procedures */
506 SetControlData(theControl
, kControlEntireControl
, kControlUserPaneDrawProcTag
, sizeof(gTPDrawProc
), &gTPDrawProc
);
507 SetControlData(theControl
, kControlEntireControl
, kControlUserPaneHitTestProcTag
, sizeof(gTPHitProc
), &gTPHitProc
);
508 SetControlData(theControl
, kControlEntireControl
, kControlUserPaneTrackingProcTag
, sizeof(gTPTrackProc
), &gTPTrackProc
);
509 SetControlData(theControl
, kControlEntireControl
, kControlUserPaneIdleProcTag
, sizeof(gTPIdleProc
), &gTPIdleProc
);
510 SetControlData(theControl
, kControlEntireControl
, kControlUserPaneKeyDownProcTag
, sizeof(gTPKeyProc
), &gTPKeyProc
);
511 SetControlData(theControl
, kControlEntireControl
, kControlUserPaneActivateProcTag
, sizeof(gTPActivateProc
), &gTPActivateProc
);
512 SetControlData(theControl
, kControlEntireControl
, kControlUserPaneFocusProcTag
, sizeof(gTPFocusProc
), &gTPFocusProc
);
513 /* calculate the rectangles used by the control */
514 GetControlBounds(theControl
, &bounds
);
515 SetRect(&varsp
->fRFocusOutline
, bounds
.left
, bounds
.top
, bounds
.right
, bounds
.bottom
);
516 SetRect(&varsp
->fRTextOutline
, bounds
.left
, bounds
.top
, bounds
.right
, bounds
.bottom
);
517 SetRect(&varsp
->fRTextArea
, bounds
.left
+ 2 , bounds
.top
+ (varsp
->fMultiline
? 0 : 2) ,
518 bounds
.right
- (varsp
->fMultiline
? 0 : 2), bounds
.bottom
- (varsp
->fMultiline
? 0 : 2));
519 /* calculate the background region for the text. In this case, it's kindof
520 and irregular region because we're setting the scroll bar a little ways inside
522 RectRgn((varsp
->fTextBackgroundRgn
= NewRgn()), &varsp
->fRTextOutline
);
524 /* set up the drawing environment */
525 SetPort(varsp
->fDrawingEnvironment
);
527 /* create the new edit field */
529 TXNFrameOptions frameOptions
=
530 kTXNDontDrawCaretWhenInactiveMask
;
531 if ( ! ( wxStyle
& wxTE_NOHIDESEL
) )
532 frameOptions
|= kTXNDontDrawSelectionWhenInactiveMask
;
534 if ( wxStyle
& wxTE_MULTILINE
)
536 if ( ! ( wxStyle
& wxTE_DONTWRAP
) )
537 frameOptions
|= kTXNAlwaysWrapAtViewEdgeMask
;
540 frameOptions
|= kTXNAlwaysWrapAtViewEdgeMask
;
541 frameOptions
|= kTXNWantHScrollBarMask
;
544 if ( !(wxStyle
& wxTE_NO_VSCROLL
) )
545 frameOptions
|= kTXNWantVScrollBarMask
;
548 frameOptions
|= kTXNSingleLineOnlyMask
;
550 if ( wxStyle
& wxTE_READONLY
)
551 frameOptions
|= kTXNReadOnlyMask
;
553 TXNNewObject(NULL
, varsp
->fOwner
, &varsp
->fRTextArea
,
555 kTXNTextEditStyleFrameType
,
557 kTXNSystemDefaultEncoding
,
558 &varsp
->fTXNRec
, &varsp
->fTXNFrame
, (TXNObjectRefcon
) tpvars
);
564 GetThemeFont(kThemeSmallSystemFont
, GetApplicationScript() , fontName
, &fontSize
, &fontStyle
) ;
566 TXNTypeAttributes typeAttr
[] =
568 { kTXNQDFontNameAttribute
, kTXNQDFontNameAttributeSize
, { (void*) fontName
} } ,
569 { kTXNQDFontSizeAttribute
, kTXNFontSizeAttributeSize
, { (void*) (fontSize
<< 16) } } ,
570 { kTXNQDFontStyleAttribute
, kTXNQDFontStyleAttributeSize
, { (void*) normal
} } ,
573 err
= TXNSetTypeAttributes (varsp
->fTXNRec
, sizeof( typeAttr
) / sizeof(TXNTypeAttributes
) , typeAttr
,
576 /* set the field's background */
577 tback
.bgType
= kTXNBackgroundTypeRGB
;
578 tback
.bg
.color
= rgbWhite
;
579 TXNSetBackground( varsp
->fTXNRec
, &tback
);
581 /* unlock our storage */
582 HUnlock((Handle
) tpvars
);
583 /* perform final activations and setup for our text field. Here,
584 we assume that the window is going to be the 'active' window. */
585 TPActivatePaneText(tpvars
, varsp
->fIsActive
&& varsp
->fInFocus
);
593 #if !USE_SHARED_LIBRARY
594 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl
, wxControl
)
596 BEGIN_EVENT_TABLE(wxTextCtrl
, wxControl
)
597 EVT_DROP_FILES(wxTextCtrl::OnDropFiles
)
598 EVT_CHAR(wxTextCtrl::OnChar
)
599 EVT_MENU(wxID_CUT
, wxTextCtrl::OnCut
)
600 EVT_MENU(wxID_COPY
, wxTextCtrl::OnCopy
)
601 EVT_MENU(wxID_PASTE
, wxTextCtrl::OnPaste
)
602 EVT_MENU(wxID_UNDO
, wxTextCtrl::OnUndo
)
603 EVT_MENU(wxID_REDO
, wxTextCtrl::OnRedo
)
605 EVT_UPDATE_UI(wxID_CUT
, wxTextCtrl::OnUpdateCut
)
606 EVT_UPDATE_UI(wxID_COPY
, wxTextCtrl::OnUpdateCopy
)
607 EVT_UPDATE_UI(wxID_PASTE
, wxTextCtrl::OnUpdatePaste
)
608 EVT_UPDATE_UI(wxID_UNDO
, wxTextCtrl::OnUpdateUndo
)
609 EVT_UPDATE_UI(wxID_REDO
, wxTextCtrl::OnUpdateRedo
)
614 wxTextCtrl::wxTextCtrl()
618 m_macTXNvars
= NULL
;
619 m_macUsesTXN
= false ;
621 m_maxLength
= TE_UNLIMITED_LENGTH
;
624 wxTextCtrl::~wxTextCtrl()
628 SetControlReference((ControlHandle
)m_macControl
, 0) ;
629 TXNDeleteObject((TXNObject
)m_macTXN
);
630 /* delete our private storage */
631 DisposeHandle((Handle
) m_macTXNvars
);
632 /* zero the control reference */
636 const short kVerticalMargin
= 2 ;
637 const short kHorizontalMargin
= 2 ;
639 bool wxTextCtrl::Create(wxWindow
*parent
, wxWindowID id
,
642 const wxSize
& size
, long style
,
643 const wxValidator
& validator
,
644 const wxString
& name
)
648 m_macTXNvars
= NULL
;
649 m_macUsesTXN
= false ;
652 m_macUsesTXN
= ! (style
& wxTE_PASSWORD
) ;
654 m_macUsesTXN
&= (TXNInitTextension
!= (void*) kUnresolvedCFragSymbolAddress
) ;
656 // base initialization
657 if ( !CreateBase(parent
, id
, pos
, size
, style
, validator
, name
) )
660 wxSize mySize
= size
;
663 m_macHorizontalBorder
= 5 ; // additional pixels around the real control
664 m_macVerticalBorder
= 3 ;
668 m_macHorizontalBorder
= 5 ; // additional pixels around the real control
669 m_macVerticalBorder
= 5 ;
676 if ( mySize.y == -1 )
679 if ( m_windowStyle & wxTE_MULTILINE )
682 mySize.y += 2 * m_macVerticalBorder ;
685 MacPreControlCreate( parent
, id
, "" , pos
, mySize
,style
, validator
, name
, &bounds
, title
) ;
687 if ( m_windowStyle
& wxTE_MULTILINE
)
689 wxASSERT_MSG( !(m_windowStyle
& wxTE_PROCESS_ENTER
),
690 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
692 m_windowStyle
|= wxTE_PROCESS_ENTER
;
695 if ( m_windowStyle
& wxTE_READONLY
)
702 m_macControl
= ::NewControl( MAC_WXHWND(parent
->MacGetRootWindow()) , &bounds
, "\p" , true , 0 , 0 , 1,
703 (style
& wxTE_PASSWORD
) ? kControlEditTextPasswordProc
: kControlEditTextProc
, (long) this ) ;
705 ::GetControlData((ControlHandle
) m_macControl
, 0, kControlEditTextTEHandleTag
, sizeof( TEHandle
) , (char*) &((TEHandle
) m_macTE
) , &size
) ;
712 featurSet
= kControlSupportsEmbedding
| kControlSupportsFocus
| kControlWantsIdle
713 | kControlWantsActivate
| kControlHandlesTracking
| kControlHasSpecialBackground
714 | kControlGetsFocusOnClick
| kControlSupportsLiveFeedback
;
715 /* create the control */
716 m_macControl
= NewControl(MAC_WXHWND(parent
->MacGetRootWindow()), &bounds
, "\p", true, featurSet
, 0, featurSet
, kControlUserPaneProc
, 0);
717 /* set up the mUP specific features and data */
718 mUPOpenControl((ControlHandle
) m_macControl
, m_windowStyle
);
721 parent
->MacGetTopLevelWindow()->MacInstallEventHandler() ;
724 MacPostControlCreate() ;
728 if( wxApp::s_macDefaultEncodingIsPC
)
729 value
= wxMacMakeMacStringFromPC( st
) ;
735 ::SetControlData( (ControlHandle
) m_macControl
, 0, ( m_windowStyle
& wxTE_PASSWORD
) ? kControlEditTextPasswordTag
: kControlEditTextTextTag
, value
.Length() , (char*) ((const char*)value
) ) ;
739 STPTextPaneVars
**tpvars
;
741 tpvars
= (STPTextPaneVars
**) GetControlReference((ControlHandle
) m_macControl
);
742 /* set the text in the record */
743 TXNSetData( (**tpvars
).fTXNRec
, kTXNTextData
, (void*)value
.c_str(), value
.Length(),
744 kTXNStartOffset
, kTXNEndOffset
);
745 m_macTXN
= (**tpvars
).fTXNRec
;
746 m_macTXNvars
= tpvars
;
747 m_macUsesTXN
= true ;
748 TXNSetSelection( (TXNObject
) m_macTXN
, 0, 0);
749 TXNShowSelection( (TXNObject
) m_macTXN
, kTXNShowStart
);
755 wxString
wxTextCtrl::GetValue() const
761 ::GetControlData( (ControlHandle
) m_macControl
, 0,
762 ( m_windowStyle
& wxTE_PASSWORD
) ? kControlEditTextPasswordTag
: kControlEditTextTextTag
,
763 32767 , wxBuffer
, &actualsize
) ;
768 OSStatus err
= TXNGetDataEncoded( ((TXNObject
) m_macTXN
), kTXNStartOffset
, kTXNEndOffset
, &theText
, kTXNTextData
);
776 actualsize
= GetHandleSize( theText
) ;
778 strncpy( wxBuffer
, *theText
, actualsize
) ;
779 DisposeHandle( theText
) ;
783 wxBuffer
[actualsize
] = 0 ;
787 if( wxApp::s_macDefaultEncodingIsPC
)
788 value
= wxMacMakePCStringFromMac( wxBuffer
) ;
792 value
.Replace( "\r", "\n" );
797 void wxTextCtrl::GetSelection(long* from
, long* to
) const
801 *from
= (**((TEHandle
) m_macTE
)).selStart
;
802 *to
= (**((TEHandle
) m_macTE
)).selEnd
;
806 TXNGetSelection( ((TXNObject
) m_macTXN
) , (TXNOffset
*) from
, (TXNOffset
*) to
) ;
810 void wxTextCtrl::SetValue(const wxString
& st
)
814 if( wxApp::s_macDefaultEncodingIsPC
)
815 value
= wxMacMakeMacStringFromPC( st
) ;
819 value
.Replace( "\n", "\r" );
823 ::SetControlData((ControlHandle
) m_macControl
, 0, ( m_windowStyle
& wxTE_PASSWORD
) ? kControlEditTextPasswordTag
: kControlEditTextTextTag
, value
.Length() , (char*) ((const char*)value
) ) ;
827 bool formerEditable
= IsEditable() ;
829 TXNSetData( ((TXNObject
) m_macTXN
), kTXNTextData
, (void*)value
.c_str(), value
.Length(),
830 kTXNStartOffset
, kTXNEndOffset
);
831 TXNSetSelection( (TXNObject
) m_macTXN
, 0, 0);
832 TXNShowSelection( (TXNObject
) m_macTXN
, kTXNShowStart
);
833 SetEditable(formerEditable
) ;
838 void wxTextCtrl::SetMaxLength(unsigned long len
)
843 bool wxTextCtrl::SetStyle(long start
, long end
, const wxTextAttr
& style
)
847 bool formerEditable
= IsEditable() ;
849 TXNTypeAttributes typeAttr
[4] ;
850 Str255 fontName
= "\pMonaco" ;
851 SInt16 fontSize
= 12 ;
852 Style fontStyle
= normal
;
854 int attrCounter
= 0 ;
855 if ( style
.HasFont() )
857 const wxFont
&font
= style
.GetFont() ;
858 CopyCStringToPascal( font
.GetFaceName().c_str() , fontName
) ;
859 fontSize
= font
.GetPointSize() ;
860 if ( font
.GetUnderlined() )
861 fontStyle
|= underline
;
862 if ( font
.GetWeight() == wxBOLD
)
864 if ( font
.GetStyle() == wxITALIC
)
865 fontStyle
|= italic
;
867 typeAttr
[attrCounter
].tag
= kTXNQDFontNameAttribute
;
868 typeAttr
[attrCounter
].size
= kTXNQDFontNameAttributeSize
;
869 typeAttr
[attrCounter
].data
.dataPtr
= (void*) fontName
;
870 typeAttr
[attrCounter
+1].tag
= kTXNQDFontSizeAttribute
;
871 typeAttr
[attrCounter
+1].size
= kTXNFontSizeAttributeSize
;
872 typeAttr
[attrCounter
+1].data
.dataValue
= (fontSize
<< 16) ;
873 typeAttr
[attrCounter
+2].tag
= kTXNQDFontStyleAttribute
;
874 typeAttr
[attrCounter
+2].size
= kTXNQDFontStyleAttributeSize
;
875 typeAttr
[attrCounter
+2].data
.dataValue
= fontStyle
;
879 if ( style
.HasTextColour() )
881 typeAttr
[attrCounter
].tag
= kTXNQDFontColorAttribute
;
882 typeAttr
[attrCounter
].size
= kTXNQDFontColorAttributeSize
;
883 typeAttr
[attrCounter
].data
.dataPtr
= (void*) &color
;
884 color
= MAC_WXCOLORREF(style
.GetTextColour().GetPixel()) ;
888 if ( attrCounter
> 0 )
890 OSStatus status
= TXNSetTypeAttributes ((TXNObject
)m_macTXN
, attrCounter
, typeAttr
,
893 SetEditable(formerEditable
) ;
898 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr
& style
)
900 wxTextCtrlBase::SetDefaultStyle( style
) ;
901 SetStyle( kTXNUseCurrentSelection
, kTXNUseCurrentSelection
, GetDefaultStyle() ) ;
905 // Clipboard operations
906 void wxTextCtrl::Copy()
912 TECopy( ((TEHandle
) m_macTE
) ) ;
920 TXNCopy((TXNObject
)m_macTXN
);
921 TXNConvertToPublicScrap();
926 void wxTextCtrl::Cut()
932 TECut( ((TEHandle
) m_macTE
) ) ;
940 TXNCut((TXNObject
)m_macTXN
);
941 TXNConvertToPublicScrap();
943 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, m_windowId
);
944 event
.SetString( GetValue() ) ;
945 event
.SetEventObject( this );
946 GetEventHandler()->ProcessEvent(event
);
950 void wxTextCtrl::Paste()
957 TEPaste( (TEHandle
) m_macTE
) ;
962 TXNConvertFromPublicScrap();
963 TXNPaste((TXNObject
)m_macTXN
);
964 SetStyle( kTXNUseCurrentSelection
, kTXNUseCurrentSelection
, GetDefaultStyle() ) ;
966 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, m_windowId
);
967 event
.SetString( GetValue() ) ;
968 event
.SetEventObject( this );
969 GetEventHandler()->ProcessEvent(event
);
973 bool wxTextCtrl::CanCopy() const
975 // Can copy if there's a selection
977 GetSelection(& from
, & to
);
981 bool wxTextCtrl::CanCut() const
987 // Can cut if there's a selection
989 GetSelection(& from
, & to
);
993 bool wxTextCtrl::CanPaste() const
1000 OSStatus err
= noErr
;
1003 err
= GetCurrentScrap( &scrapRef
);
1004 if ( err
!= noTypeErr
&& err
!= memFullErr
)
1006 ScrapFlavorFlags flavorFlags
;
1009 if (( err
= GetScrapFlavorFlags( scrapRef
, 'TEXT', &flavorFlags
)) == noErr
)
1011 if (( err
= GetScrapFlavorSize( scrapRef
, 'TEXT', &byteCount
)) == noErr
)
1020 if ( GetScrap( NULL
, 'TEXT' , &offset
) > 0 )
1028 void wxTextCtrl::SetEditable(bool editable
)
1030 if ( editable
!= m_editable
)
1032 m_editable
= editable
;
1033 if ( !m_macUsesTXN
)
1036 UMAActivateControl( (ControlHandle
) m_macControl
) ;
1038 UMADeactivateControl((ControlHandle
) m_macControl
) ;
1042 TXNControlTag tag
[] = { kTXNIOPrivilegesTag
} ;
1043 TXNControlData data
[] = { editable
? kTXNReadWrite
: kTXNReadOnly
} ;
1044 TXNSetTXNObjectControls( (TXNObject
) m_macTXN
, false , sizeof(tag
) / sizeof (TXNControlTag
) , tag
, data
) ;
1049 void wxTextCtrl::SetInsertionPoint(long pos
)
1051 SetSelection( pos
, pos
) ;
1054 void wxTextCtrl::SetInsertionPointEnd()
1056 long pos
= GetLastPosition();
1057 SetInsertionPoint(pos
);
1060 long wxTextCtrl::GetInsertionPoint() const
1063 GetSelection( &begin
, &end
) ;
1067 long wxTextCtrl::GetLastPosition() const
1069 if ( !m_macUsesTXN
)
1071 return (**((TEHandle
) m_macTE
)).teLength
;
1077 OSErr err
= TXNGetDataEncoded( (TXNObject
) m_macTXN
, kTXNStartOffset
, kTXNEndOffset
, &theText
, kTXNTextData
);
1085 actualsize
= GetHandleSize( theText
) ;
1086 DisposeHandle( theText
) ;
1092 void wxTextCtrl::Replace(long from
, long to
, const wxString
& value
)
1094 if ( !m_macUsesTXN
)
1096 ControlEditTextSelectionRec selection
;
1098 selection
.selStart
= from
;
1099 selection
.selEnd
= to
;
1100 ::SetControlData((ControlHandle
) m_macControl
, 0, kControlEditTextSelectionTag
, sizeof( selection
) , (char*) &selection
) ;
1101 TESetSelect( from
, to
, ((TEHandle
) m_macTE
) ) ;
1102 TEDelete( ((TEHandle
) m_macTE
) ) ;
1103 TEInsert( value
, value
.Length() , ((TEHandle
) m_macTE
) ) ;
1107 bool formerEditable
= IsEditable() ;
1109 TXNSetSelection( ((TXNObject
) m_macTXN
) , from
, to
) ;
1110 TXNClear( ((TXNObject
) m_macTXN
) ) ;
1111 TXNSetData( ((TXNObject
) m_macTXN
), kTXNTextData
, (void*)value
.c_str(), value
.Length(),
1112 kTXNUseCurrentSelection
, kTXNUseCurrentSelection
);
1113 SetEditable( formerEditable
) ;
1118 void wxTextCtrl::Remove(long from
, long to
)
1120 if ( !m_macUsesTXN
)
1122 ControlEditTextSelectionRec selection
;
1124 selection
.selStart
= from
;
1125 selection
.selEnd
= to
;
1126 ::SetControlData( (ControlHandle
) m_macControl
, 0, kControlEditTextSelectionTag
, sizeof( selection
) , (char*) &selection
) ;
1127 TEDelete( ((TEHandle
) m_macTE
) ) ;
1131 bool formerEditable
= IsEditable() ;
1133 TXNSetSelection( ((TXNObject
) m_macTXN
) , from
, to
) ;
1134 TXNClear( ((TXNObject
) m_macTXN
) ) ;
1135 SetEditable( formerEditable
) ;
1140 void wxTextCtrl::SetSelection(long from
, long to
)
1143 if ( !m_macUsesTXN
)
1145 ControlEditTextSelectionRec selection
;
1146 selection
.selStart
= from
;
1147 selection
.selEnd
= to
;
1149 TESetSelect( selection
.selStart
, selection
.selEnd
, ((TEHandle
) m_macTE
) ) ;
1150 ::SetControlData((ControlHandle
) m_macControl
, 0, kControlEditTextSelectionTag
, sizeof( selection
) , (char*) &selection
) ;
1154 STPTextPaneVars
**tpvars
;
1155 /* set up our locals */
1156 tpvars
= (STPTextPaneVars
**) GetControlReference((ControlHandle
) m_macControl
);
1157 /* and our drawing environment as the operation
1158 may force a redraw in the text area. */
1159 SetPort((**tpvars
).fDrawingEnvironment
);
1160 /* change the selection */
1161 TXNSetSelection( (**tpvars
).fTXNRec
, from
, to
);
1162 TXNShowSelection( (TXNObject
) m_macTXN
, kTXNShowStart
);
1166 bool wxTextCtrl::LoadFile(const wxString
& file
)
1168 if ( wxTextCtrlBase::LoadFile(file
) )
1176 void wxTextCtrl::WriteText(const wxString
& text
)
1179 if( wxApp::s_macDefaultEncodingIsPC
)
1180 value
= wxMacMakeMacStringFromPC( text
) ;
1183 if ( !m_macUsesTXN
)
1185 TEInsert( value
, value
.Length() , ((TEHandle
) m_macTE
) ) ;
1189 bool formerEditable
= IsEditable() ;
1191 long start
, end
, dummy
;
1192 GetSelection( &start
, &dummy
) ;
1193 TXNSetData( ((TXNObject
) m_macTXN
), kTXNTextData
, (void*) (const char*)value
, value
.Length(),
1194 kTXNUseCurrentSelection
, kTXNUseCurrentSelection
);
1195 GetSelection( &dummy
, &end
) ;
1196 SetStyle( start
, end
, GetDefaultStyle() ) ;
1197 SetEditable( formerEditable
) ;
1199 MacRedrawControl() ;
1202 void wxTextCtrl::AppendText(const wxString
& text
)
1204 SetInsertionPointEnd();
1208 void wxTextCtrl::Clear()
1210 if ( !IsEditable() )
1214 if ( !m_macUsesTXN
)
1216 ::SetControlData((ControlHandle
) m_macControl
, 0, ( m_windowStyle
& wxTE_PASSWORD
) ? kControlEditTextPasswordTag
: kControlEditTextTextTag
, 0 , (char*) ((const char*)NULL
) ) ;
1220 ClearCurrentScrap();
1221 TXNClear((TXNObject
)m_macTXN
);
1226 bool wxTextCtrl::IsModified() const
1231 bool wxTextCtrl::IsEditable() const
1233 return IsEnabled() && m_editable
;
1236 bool wxTextCtrl::AcceptsFocus() const
1238 // we don't want focus if we can't be edited
1239 return /*IsEditable() && */ wxControl::AcceptsFocus();
1242 wxSize
wxTextCtrl::DoGetBestSize() const
1257 wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
1259 int wText = DEFAULT_ITEM_WIDTH;
1261 int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
1263 return wxSize(wText, hText);
1265 if ( m_windowStyle
& wxTE_MULTILINE
)
1269 hText
+= 2 * m_macVerticalBorder
;
1270 wText
+= 2 * m_macHorizontalBorder
;
1271 //else: for single line control everything is ok
1272 return wxSize(wText
, hText
);
1275 // ----------------------------------------------------------------------------
1277 // ----------------------------------------------------------------------------
1279 void wxTextCtrl::Undo()
1286 void wxTextCtrl::Redo()
1293 bool wxTextCtrl::CanUndo() const
1298 bool wxTextCtrl::CanRedo() const
1303 // Makes 'unmodified'
1304 void wxTextCtrl::DiscardEdits()
1309 int wxTextCtrl::GetNumberOfLines() const
1311 // TODO change this if possible to reflect real lines
1312 wxString content
= GetValue() ;
1315 for (int i
= 0; i
< content
.Length() ; i
++)
1317 if (content
[i
] == '\r') count
++;
1323 long wxTextCtrl::XYToPosition(long x
, long y
) const
1329 bool wxTextCtrl::PositionToXY(long pos
, long *x
, long *y
) const
1334 void wxTextCtrl::ShowPosition(long pos
)
1339 int wxTextCtrl::GetLineLength(long lineNo
) const
1341 // TODO change this if possible to reflect real lines
1342 wxString content
= GetValue() ;
1346 for (int i
= 0; i
< content
.Length() ; i
++)
1348 if (count
== lineNo
)
1350 // Count chars in line then
1352 for (int j
= i
; j
< content
.Length(); j
++)
1355 if (content
[j
] == '\r') return count
;
1360 if (content
[i
] == '\r') count
++;
1365 wxString
wxTextCtrl::GetLineText(long lineNo
) const
1367 // TODO change this if possible to reflect real lines
1368 wxString content
= GetValue() ;
1372 for (int i
= 0; i
< content
.Length() ; i
++)
1374 if (count
== lineNo
)
1376 // Add chars in line then
1379 for (int j
= i
; j
< content
.Length(); j
++)
1381 if (content
[j
] == '\r')
1389 if (content
[i
] == '\r') count
++;
1398 void wxTextCtrl::Command(wxCommandEvent
& event
)
1400 SetValue (event
.GetString());
1401 ProcessCommand (event
);
1404 void wxTextCtrl::OnDropFiles(wxDropFilesEvent
& event
)
1406 // By default, load the first file into the text window.
1407 if (event
.GetNumberOfFiles() > 0)
1409 LoadFile(event
.GetFiles()[0]);
1413 void wxTextCtrl::OnChar(wxKeyEvent
& event
)
1415 int key
= event
.GetKeyCode() ;
1416 bool eat_key
= false ;
1418 if ( key
== 'c' && event
.MetaDown() )
1425 if ( !IsEditable() && key
!= WXK_LEFT
&& key
!= WXK_RIGHT
&& key
!= WXK_DOWN
&& key
!= WXK_UP
&& key
!= WXK_TAB
&&
1426 !( key
== WXK_RETURN
&& ( (m_windowStyle
& wxPROCESS_ENTER
) || (m_windowStyle
& wxTE_MULTILINE
) ) )
1427 /* && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
1433 if ( key
== 'v' && event
.MetaDown() )
1439 if ( key
== 'x' && event
.MetaDown() )
1448 if (m_windowStyle
& wxPROCESS_ENTER
)
1450 wxCommandEvent
event(wxEVT_COMMAND_TEXT_ENTER
, m_windowId
);
1451 event
.SetEventObject( this );
1452 event
.SetString( GetValue() );
1453 if ( GetEventHandler()->ProcessEvent(event
) )
1456 if ( !(m_windowStyle
& wxTE_MULTILINE
) )
1458 wxWindow
*parent
= GetParent();
1459 while( parent
&& !parent
->IsTopLevel() && parent
->GetDefaultItem() == NULL
) {
1460 parent
= parent
->GetParent() ;
1462 if ( parent
&& parent
->GetDefaultItem() )
1464 wxButton
*def
= wxDynamicCast(parent
->GetDefaultItem(),
1466 if ( def
&& def
->IsEnabled() )
1468 wxCommandEvent
event(wxEVT_COMMAND_BUTTON_CLICKED
, def
->GetId() );
1469 event
.SetEventObject(def
);
1470 def
->Command(event
);
1475 // this will make wxWindows eat the ENTER key so that
1476 // we actually prevent line wrapping in a single line
1484 // always produce navigation event - even if we process TAB
1485 // ourselves the fact that we got here means that the user code
1486 // decided to skip processing of this TAB - probably to let it
1487 // do its default job.
1489 wxNavigationKeyEvent eventNav
;
1490 eventNav
.SetDirection(!event
.ShiftDown());
1491 eventNav
.SetWindowChange(event
.ControlDown());
1492 eventNav
.SetEventObject(this);
1494 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav
) )
1508 if ( ( key
>= 0x20 && key
< WXK_START
) ||
1509 key
== WXK_RETURN
||
1510 key
== WXK_DELETE
||
1513 wxCommandEvent
event1(wxEVT_COMMAND_TEXT_UPDATED
, m_windowId
);
1514 event1
.SetString( GetValue() ) ;
1515 event1
.SetEventObject( this );
1516 wxPostEvent(GetEventHandler(),event1
);
1520 void wxTextCtrl::MacSuperShown( bool show
)
1522 bool former
= m_macControlIsShown
;
1523 wxControl::MacSuperShown( show
) ;
1524 if ( (former
!= m_macControlIsShown
) && m_macUsesTXN
)
1526 if ( m_macControlIsShown
)
1527 TXNSetFrameBounds( (TXNObject
) m_macTXN
, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.top
, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.left
,
1528 (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.bottom
,(**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.right
, (**(STPTextPaneVars
**)m_macTXNvars
).fTXNFrame
);
1530 TXNSetFrameBounds( (TXNObject
) m_macTXN
, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.top
+ 30000, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.left
,
1531 (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.bottom
+ 30000, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.right
, (**(STPTextPaneVars
**)m_macTXNvars
).fTXNFrame
);
1535 bool wxTextCtrl::Show(bool show
)
1537 bool former
= m_macControlIsShown
;
1539 bool retval
= wxControl::Show( show
) ;
1541 if ( former
!= m_macControlIsShown
)
1543 if ( m_macControlIsShown
)
1544 TXNSetFrameBounds( (TXNObject
) m_macTXN
, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.top
, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.left
,
1545 (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.bottom
,(**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.right
, (**(STPTextPaneVars
**)m_macTXNvars
).fTXNFrame
);
1547 TXNSetFrameBounds( (TXNObject
) m_macTXN
, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.top
+ 30000, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.left
,
1548 (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.bottom
+ 30000, (**(STPTextPaneVars
**)m_macTXNvars
).fRTextArea
.right
, (**(STPTextPaneVars
**)m_macTXNvars
).fTXNFrame
);
1554 // ----------------------------------------------------------------------------
1555 // standard handlers for standard edit menu events
1556 // ----------------------------------------------------------------------------
1558 void wxTextCtrl::OnCut(wxCommandEvent
& event
)
1563 void wxTextCtrl::OnCopy(wxCommandEvent
& event
)
1568 void wxTextCtrl::OnPaste(wxCommandEvent
& event
)
1573 void wxTextCtrl::OnUndo(wxCommandEvent
& event
)
1578 void wxTextCtrl::OnRedo(wxCommandEvent
& event
)
1583 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent
& event
)
1585 event
.Enable( CanCut() );
1588 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent
& event
)
1590 event
.Enable( CanCopy() );
1593 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent
& event
)
1595 event
.Enable( CanPaste() );
1598 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent
& event
)
1600 event
.Enable( CanUndo() );
1603 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent
& event
)
1605 event
.Enable( CanRedo() );