]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/textctrl.cpp
b927bf2edb1192c0f0d910daece1d8ab0438affc
[wxWidgets.git] / src / mac / carbon / textctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: textctrl.cpp
3 // Purpose: wxTextCtrl
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 1998-01-01
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "textctrl.h"
14 #endif
15
16 #include "wx/defs.h"
17
18 #if wxUSE_TEXTCTRL
19
20 #ifdef __DARWIN__
21 #include <sys/types.h>
22 #include <sys/stat.h>
23 #else
24 #include <stat.h>
25 #endif
26
27 #include "wx/msgdlg.h"
28
29 #if wxUSE_STD_IOSTREAM
30 #if wxUSE_IOSTREAMH
31 #include <fstream.h>
32 #else
33 #include <fstream>
34 #endif
35 #endif
36
37 #include "wx/app.h"
38 #include "wx/dc.h"
39 #include "wx/button.h"
40 #include "wx/toplevel.h"
41 #include "wx/textctrl.h"
42 #include "wx/notebook.h"
43 #include "wx/tabctrl.h"
44 #include "wx/settings.h"
45 #include "wx/filefn.h"
46 #include "wx/utils.h"
47
48 #if defined(__BORLANDC__) && !defined(__WIN32__)
49 #include <alloc.h>
50 #elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
51 #include <malloc.h>
52 #endif
53
54 #ifndef __DARWIN__
55 #include <Scrap.h>
56 #endif
57 #include <MacTextEditor.h>
58 #include <ATSUnicode.h>
59 #include <TextCommon.h>
60 #include <TextEncodingConverter.h>
61 #include "wx/mac/uma.h"
62
63 #define TE_UNLIMITED_LENGTH 0xFFFFFFFFUL
64 #if TARGET_API_MAC_OSX
65 #define wxMAC_USE_MLTE 0
66 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
67 #define wxMAC_USE_MLTE_HIVIEW 1
68 #else
69 #define wxMAC_USE_MLTE_HIVIEW 0
70 #endif
71 #else
72 // there is no unicodetextctrl on classic, and hopefully MLTE works better there
73 #define wxMAC_USE_MLTE 1
74 #define wxMAC_USE_MLTE_HIVIEW 0
75 #endif
76
77 #if wxMAC_USE_MLTE
78
79 TXNFrameOptions FrameOptionsFromWXStyle( long wxStyle )
80 {
81 TXNFrameOptions frameOptions =
82 kTXNDontDrawCaretWhenInactiveMask ;
83 if ( ! ( wxStyle & wxTE_NOHIDESEL ) )
84 frameOptions |= kTXNDontDrawSelectionWhenInactiveMask ;
85
86 if ( wxStyle & wxTE_MULTILINE )
87 {
88 if ( ! ( wxStyle & wxTE_DONTWRAP ) )
89 frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
90 else
91 {
92 frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
93 frameOptions |= kTXNWantHScrollBarMask ;
94 }
95
96 if ( !(wxStyle & wxTE_NO_VSCROLL ) )
97 frameOptions |= kTXNWantVScrollBarMask ;
98 }
99 else
100 frameOptions |= kTXNSingleLineOnlyMask ;
101 return frameOptions ;
102 }
103
104 void AdjustAttributesFromWXStyle( TXNObject txn , long wxStyle , bool visible )
105 {
106 TXNControlTag iControlTags[3] = { kTXNDoFontSubstitution, kTXNWordWrapStateTag };
107 TXNControlData iControlData[3] = { {false}, {kTXNNoAutoWrap} };
108 int toptag = 2 ;
109 #if TARGET_API_MAC_OSX
110 iControlTags[2] = kTXNVisibilityTag ;
111 iControlData[2].uValue = visible ;
112 toptag++ ;
113 #endif
114
115 if ( wxStyle & wxTE_MULTILINE )
116 {
117 if (wxStyle & wxTE_DONTWRAP)
118 iControlData[1].uValue = kTXNNoAutoWrap ;
119 else
120 iControlData[1].uValue = kTXNAutoWrap ;
121
122 }
123 verify_noerr( TXNSetTXNObjectControls( txn, false, toptag,
124 iControlTags, iControlData )) ;
125
126 Str255 fontName ;
127 SInt16 fontSize ;
128 Style fontStyle ;
129
130 GetThemeFont(kThemeSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
131
132 TXNTypeAttributes typeAttr[] =
133 {
134 { kTXNQDFontNameAttribute , kTXNQDFontNameAttributeSize , { (void*) fontName } } ,
135 { kTXNQDFontSizeAttribute , kTXNFontSizeAttributeSize , { (void*) (fontSize << 16) } } ,
136 { kTXNQDFontStyleAttribute , kTXNQDFontStyleAttributeSize , { (void*) normal } } ,
137 } ;
138
139 verify_noerr( TXNSetTypeAttributes (txn, sizeof( typeAttr ) / sizeof(TXNTypeAttributes) , typeAttr,
140 kTXNStartOffset,
141 kTXNEndOffset) );
142
143 }
144
145 #if !wxMAC_USE_MLTE_HIVIEW
146
147 // CS:TODO we still have a problem getting properly at the text events of a control because under Carbon
148 // the MLTE engine registers itself for the key events thus the normal flow never occurs, the only measure for the
149 // moment is to avoid setting the true focus on the control, the proper solution at the end would be to have
150 // an alternate path for carbon key events that routes automatically into the same wx flow of events
151
152 /* part codes */
153
154 /* kmUPTextPart is the part code we return to indicate the user has clicked
155 in the text area of our control */
156 #define kmUPTextPart 1
157
158
159 /* routines for using existing user pane controls.
160 These routines are useful for cases where you would like to use an
161 existing user pane control in, say, a dialog window as a scrolling
162 text edit field.*/
163
164 /* Utility Routines */
165
166 /* kUserClickedToFocusPart is a part code we pass to the SetKeyboardFocus
167 routine. In our focus switching routine this part code is understood
168 as meaning 'the user has clicked in the control and we need to switch
169 the current focus to ourselves before we can continue'. */
170 #define kUserClickedToFocusPart 100
171
172 /* STPTextPaneVars is a structure used for storing the the mUP Control's
173 internal variables and state information. A handle to this record is
174 stored in the pane control's reference value field using the
175 SetControlReference routine. */
176
177 typedef struct {
178 /* OS records referenced */
179 TXNObject fTXNRec; /* the txn record */
180 TXNFrameID fTXNFrame; /* the txn frame ID */
181 ControlRef fUserPaneRec; /* handle to the user pane control */
182 WindowPtr fOwner; /* window containing control */
183 GrafPtr fDrawingEnvironment; /* grafport where control is drawn */
184 /* flags */
185 Boolean fInFocus; /* true while the focus rect is drawn around the control */
186 Boolean fIsActive; /* true while the control is drawn in the active state */
187 Boolean fTXNObjectActive; /* reflects the activation state of the text edit record */
188 Boolean fFocusDrawState; /* true if focus is drawn (default: true) */
189 /* calculated locations */
190 Rect fRBounds; /* control bounds */
191 Rect fRTextArea; /* area where the text is drawn */
192 Rect fRFocusOutline; /* rectangle used to draw the focus box */
193 Rect fRTextOutline; /* rectangle used to draw the border */
194 RgnHandle fRTextOutlineRegion; /* background region for the text, erased before calling TEUpdate */
195 /* our focus advance override routine */
196 EventHandlerUPP handlerUPP;
197 EventHandlerRef handlerRef;
198 bool fNoBorders ;
199 bool fMultiline ;
200 bool fVisible ;
201 } STPTextPaneVars;
202
203 /* mUPOpenControl initializes a user pane control so it will be drawn
204 and will behave as a scrolling text edit field inside of a window.
205 This routine performs all of the initialization steps necessary,
206 except it does not create the user pane control itself. theControl
207 should refer to a user pane control that you have either created
208 yourself or extracted from a dialog's control heirarchy using
209 the GetDialogItemAsControl routine. */
210 OSStatus mUPOpenControl(STPTextPaneVars* &handle, ControlRef theControl, long wxStyle);
211
212
213
214
215 /* Univerals Procedure Pointer variables used by the
216 mUP Control. These variables are set up
217 the first time that mUPOpenControl is called. */
218 ControlUserPaneDrawUPP gTPDrawProc = NULL;
219 ControlUserPaneHitTestUPP gTPHitProc = NULL;
220 ControlUserPaneTrackingUPP gTPTrackProc = NULL;
221 ControlUserPaneIdleUPP gTPIdleProc = NULL;
222 ControlUserPaneKeyDownUPP gTPKeyProc = NULL;
223 ControlUserPaneActivateUPP gTPActivateProc = NULL;
224 ControlUserPaneFocusUPP gTPFocusProc = NULL;
225
226 // one place for calculating all
227 static void TPCalculateBounds(STPTextPaneVars *varsp, const Rect& bounds)
228 {
229 SetRect(&varsp->fRBounds, bounds.left, bounds.top, bounds.right, bounds.bottom);
230 SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
231 // eventually make TextOutline inset 1,1
232 SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
233 if ( !varsp->fNoBorders )
234 {
235 SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) ,
236 bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
237 }
238 else
239 {
240 SetRect(&varsp->fRTextArea, bounds.left , bounds.top ,
241 bounds.right, bounds.bottom);
242 }
243 }
244
245 OSStatus MLTESetObjectVisibility( STPTextPaneVars *varsp, Boolean vis , long wxStyle)
246 {
247 OSStatus err = noErr ;
248 #if TARGET_API_MAC_OSX
249 TXNControlTag iControlTags[1] = { kTXNVisibilityTag };
250 TXNControlData iControlData[1] = {{ vis }};
251 err = ::TXNSetTXNObjectControls( varsp->fTXNRec, false, 1, iControlTags, iControlData );
252 #endif
253 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
254 if ( vis && textctrl )
255 {
256 Rect bounds ;
257 UMAGetControlBoundsInWindowCoords( varsp->fUserPaneRec, &bounds);
258 TPCalculateBounds( varsp , bounds ) ;
259 wxMacWindowClipper cl(textctrl) ;
260 TXNSetFrameBounds( varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
261 varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
262 TXNShowSelection( varsp->fTXNRec, kTXNShowStart);
263 }
264 return err ;
265 }
266
267 // make sure we don't miss changes as carbon events are not available for these under classic
268 static void TPUpdateVisibility(ControlRef theControl) {
269 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
270 if ( textctrl == NULL )
271 return ;
272
273 STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
274
275 Rect bounds ;
276 UMAGetControlBoundsInWindowCoords(theControl, &bounds);
277 if ( textctrl->MacIsReallyShown() != varsp->fVisible )
278 {
279 // invalidate old position
280 // InvalWindowRect( GetControlOwner( theControl ) , &varsp->fRBounds ) ;
281 varsp->fVisible = textctrl->MacIsReallyShown() ;
282 }
283 if ( !EqualRect( &bounds , &varsp->fRBounds ) )
284 {
285 // old position
286 Rect oldBounds = varsp->fRBounds ;
287 TPCalculateBounds( varsp , bounds ) ;
288 // we only recalculate when visible, otherwise scrollbars get drawn at incorrect places
289 if ( varsp->fVisible )
290 {
291 wxMacWindowClipper cl(textctrl) ;
292 TXNSetFrameBounds( varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
293 varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
294 }
295 InvalWindowRect( GetControlOwner( theControl ) , &oldBounds ) ;
296 InvalWindowRect( GetControlOwner( theControl ) , &varsp->fRBounds ) ;
297 }
298 }
299
300 // make correct activations
301 static void TPActivatePaneText(STPTextPaneVars *varsp, Boolean setActive) {
302
303 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
304 if (varsp->fTXNObjectActive != setActive && textctrl->MacIsReallyShown() )
305 {
306 varsp->fTXNObjectActive = setActive;
307 TXNActivate(varsp->fTXNRec, varsp->fTXNFrame, varsp->fTXNObjectActive);
308 if (varsp->fInFocus)
309 TXNFocus( varsp->fTXNRec, varsp->fTXNObjectActive);
310 }
311 }
312
313 // update focus outlines
314 static void TPRedrawFocusOutline(STPTextPaneVars *varsp) {
315
316 /* state changed */
317 if (varsp->fFocusDrawState != (varsp->fIsActive && varsp->fInFocus))
318 {
319 varsp->fFocusDrawState = (varsp->fIsActive && varsp->fInFocus);
320 DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fFocusDrawState);
321 }
322 }
323
324 // update TXN focus state
325 static void TPFocusPaneText(STPTextPaneVars *varsp, Boolean setFocus) {
326 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
327
328 if (varsp->fInFocus != setFocus && textctrl->MacIsReallyShown()) {
329 varsp->fInFocus = setFocus;
330 TXNFocus( varsp->fTXNRec, varsp->fInFocus);
331 }
332 }
333
334 // draw the control
335 static pascal void TPPaneDrawProc(ControlRef theControl, ControlPartCode thePart) {
336 /* set up our globals */
337
338 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
339 if ( textctrl == NULL )
340 return ;
341 TPUpdateVisibility( theControl ) ;
342
343 STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
344 if ( textctrl->MacIsReallyShown() )
345 {
346 wxMacWindowClipper clipper( textctrl ) ;
347 TXNDraw(varsp->fTXNRec, NULL);
348 if ( !varsp->fNoBorders )
349 DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
350 TPRedrawFocusOutline( varsp ) ;
351 }
352
353 }
354
355
356 /* TPPaneHitTestProc is called when the control manager would
357 like to determine what part of the control the mouse resides over.
358 We also call this routine from our tracking proc to determine how
359 to handle mouse clicks. */
360 static pascal ControlPartCode TPPaneHitTestProc(ControlRef theControl, Point where) {
361 ControlPartCode result;
362 /* set up our locals and lock down our globals*/
363 result = 0;
364 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
365 if ( textctrl == NULL )
366 return 0 ;
367 TPUpdateVisibility( theControl ) ;
368 STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
369 if (textctrl->MacIsReallyShown() )
370 {
371 if (PtInRect(where, &varsp->fRBounds))
372 result = kmUPTextPart;
373 else
374 result = 0;
375 }
376 return result;
377 }
378
379
380
381
382
383 /* TPPaneTrackingProc is called when the mouse is being held down
384 over our control. This routine handles clicks in the text area
385 and in the scroll bar. */
386 static pascal ControlPartCode TPPaneTrackingProc(ControlRef theControl, Point startPt, ControlActionUPP actionProc) {
387
388 ControlPartCode partCodeResult;
389 /* make sure we have some variables... */
390 partCodeResult = 0;
391 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
392 if ( textctrl == NULL )
393 return 0;
394 TPUpdateVisibility( theControl ) ;
395 STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
396 if (textctrl->MacIsReallyShown() )
397 {
398 /* we don't do any of these functions unless we're in focus */
399 if ( ! varsp->fInFocus) {
400 WindowPtr owner;
401 owner = GetControlOwner(theControl);
402 ClearKeyboardFocus(owner);
403 SetKeyboardFocus(owner, theControl, kUserClickedToFocusPart);
404 }
405 /* find the location for the click */
406 // for compositing, we must convert these into toplevel window coordinates, because hittesting expects them
407 if ( textctrl->MacGetTopLevelWindow()->MacUsesCompositing() )
408 {
409 int x = 0 , y = 0 ;
410 textctrl->MacClientToRootWindow( &x , &y ) ;
411 startPt.h += x ;
412 startPt.v += y ;
413 }
414
415 switch (TPPaneHitTestProc(theControl, startPt))
416 {
417
418 /* handle clicks in the text part */
419 case kmUPTextPart:
420 {
421 wxMacWindowClipper clipper( textctrl ) ;
422
423 EventRecord rec ;
424 ConvertEventRefToEventRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) ;
425 TXNClick( varsp->fTXNRec, &rec );
426
427 }
428 break;
429
430 }
431 }
432 return partCodeResult;
433 }
434
435
436 /* TPPaneIdleProc is our user pane idle routine. When our text field
437 is active and in focus, we use this routine to set the cursor. */
438 static pascal void TPPaneIdleProc(ControlRef theControl) {
439 /* set up locals */
440 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
441 if ( textctrl == NULL )
442 return ;
443 TPUpdateVisibility( theControl ) ;
444 STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
445 if (textctrl->MacIsReallyShown()) {
446 /* if we're not active, then we have nothing to say about the cursor */
447 if (varsp->fIsActive) {
448 Rect bounds;
449 Point mousep;
450
451 wxMacWindowClipper clipper( textctrl ) ;
452 GetMouse(&mousep);
453 /* there's a 'focus thing' and an 'unfocused thing' */
454 if (varsp->fInFocus) {
455 /* flash the cursor */
456 SetPort(varsp->fDrawingEnvironment);
457 TXNIdle(varsp->fTXNRec);
458 /* set the cursor */
459 if (PtInRect(mousep, &varsp->fRTextArea)) {
460 RgnHandle theRgn;
461 RectRgn((theRgn = NewRgn()), &varsp->fRTextArea);
462 TXNAdjustCursor(varsp->fTXNRec, theRgn);
463 DisposeRgn(theRgn);
464 }
465 else
466 {
467 // SetThemeCursor(kThemeArrowCursor);
468 }
469 } else {
470 /* if it's in our bounds, set the cursor */
471 UMAGetControlBoundsInWindowCoords(theControl, &bounds);
472 if (PtInRect(mousep, &bounds))
473 {
474 // SetThemeCursor(kThemeArrowCursor);
475 }
476 }
477 }
478 }
479 }
480
481
482 /* TPPaneKeyDownProc is called whenever a keydown event is directed
483 at our control. Here, we direct the keydown event to the text
484 edit record and redraw the scroll bar and text field as appropriate. */
485 static pascal ControlPartCode TPPaneKeyDownProc(ControlRef theControl,
486 SInt16 keyCode, SInt16 charCode, SInt16 modifiers) {
487
488 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
489 if ( textctrl == NULL )
490 return 0;
491 TPUpdateVisibility( theControl ) ;
492
493 STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
494 if (varsp->fInFocus)
495 {
496 /* turn autoscrolling on and send the key event to text edit */
497 wxMacWindowClipper clipper( textctrl ) ;
498 EventRecord ev ;
499 memset( &ev , 0 , sizeof( ev ) ) ;
500 ev.what = keyDown ;
501 ev.modifiers = modifiers ;
502 ev.message = (( keyCode << 8 ) & keyCodeMask ) + ( charCode & charCodeMask ) ;
503 TXNKeyDown( varsp->fTXNRec, &ev);
504 }
505 return kControlEntireControl;
506 }
507
508
509 /* TPPaneActivateProc is called when the window containing
510 the user pane control receives activate events. Here, we redraw
511 the control and it's text as necessary for the activation state. */
512 static pascal void TPPaneActivateProc(ControlRef theControl, Boolean activating) {
513 /* set up locals */
514 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
515
516 if ( textctrl == NULL )
517 return ;
518 TPUpdateVisibility( theControl ) ;
519
520 STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
521
522 varsp->fIsActive = activating;
523 wxMacWindowClipper clipper( textctrl ) ;
524 TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);
525 /* redraw the frame */
526 if ( textctrl->MacIsReallyShown() )
527 {
528 if ( !varsp->fNoBorders )
529 DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
530 TPRedrawFocusOutline( varsp ) ;
531 }
532 }
533
534
535 /* TPPaneFocusProc is called when every the focus changes to or
536 from our control. Herein, switch the focus appropriately
537 according to the parameters and redraw the control as
538 necessary. */
539 static pascal ControlPartCode TPPaneFocusProc(ControlRef theControl, ControlFocusPart action) {
540 ControlPartCode focusResult;
541
542 focusResult = kControlFocusNoPart;
543 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
544 if ( textctrl == NULL )
545 return 0;
546 TPUpdateVisibility( theControl ) ;
547 STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
548 /* if kControlFocusPrevPart and kControlFocusNextPart are received when the user is
549 tabbing forwards (or shift tabbing backwards) through the items in the dialog,
550 and kControlFocusNextPart will be received. When the user clicks in our field
551 and it is not the current focus, then the constant kUserClickedToFocusPart will
552 be received. The constant kControlFocusNoPart will be received when our control
553 is the current focus and the user clicks in another control. In your focus routine,
554 you should respond to these codes as follows:
555
556 kControlFocusNoPart - turn off focus and return kControlFocusNoPart. redraw
557 the control and the focus rectangle as necessary.
558
559 kControlFocusPrevPart or kControlFocusNextPart - toggle focus on or off
560 depending on its current state. redraw the control and the focus rectangle
561 as appropriate for the new focus state. If the focus state is 'off', return the constant
562 kControlFocusNoPart, otherwise return a non-zero part code.
563 kUserClickedToFocusPart - is a constant defined for this example. You should
564 define your own value for handling click-to-focus type events. */
565 /* calculate the next highlight state */
566 switch (action) {
567 default:
568 case kControlFocusNoPart:
569 TPFocusPaneText(varsp, false);
570 focusResult = kControlFocusNoPart;
571 break;
572 case kUserClickedToFocusPart:
573 TPFocusPaneText(varsp, true);
574 focusResult = 1;
575 break;
576 case kControlFocusPrevPart:
577 case kControlFocusNextPart:
578 TPFocusPaneText(varsp, ( ! varsp->fInFocus));
579 focusResult = varsp->fInFocus ? 1 : kControlFocusNoPart;
580 break;
581 }
582 TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);
583 /* redraw the text fram and focus rectangle to indicate the
584 new focus state */
585 if ( textctrl->MacIsReallyShown() )
586 {
587 wxMacWindowClipper c( textctrl ) ;
588 if ( !varsp->fNoBorders )
589 DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
590 TPRedrawFocusOutline( varsp ) ;
591 }
592 return focusResult;
593 }
594
595
596 /* mUPOpenControl initializes a user pane control so it will be drawn
597 and will behave as a scrolling text edit field inside of a window.
598 This routine performs all of the initialization steps necessary,
599 except it does not create the user pane control itself. theControl
600 should refer to a user pane control that you have either created
601 yourself or extracted from a dialog's control heirarchy using
602 the GetDialogItemAsControl routine. */
603 OSStatus mUPOpenControl(STPTextPaneVars* &handle, ControlRef theControl, long wxStyle )
604 {
605 Rect bounds;
606 WindowRef theWindow;
607 STPTextPaneVars *varsp;
608 OSStatus err = noErr ;
609
610 /* set up our globals */
611 if (gTPDrawProc == NULL) gTPDrawProc = NewControlUserPaneDrawUPP(TPPaneDrawProc);
612 if (gTPHitProc == NULL) gTPHitProc = NewControlUserPaneHitTestUPP(TPPaneHitTestProc);
613 if (gTPTrackProc == NULL) gTPTrackProc = NewControlUserPaneTrackingUPP(TPPaneTrackingProc);
614 if (gTPIdleProc == NULL) gTPIdleProc = NewControlUserPaneIdleUPP(TPPaneIdleProc);
615 if (gTPKeyProc == NULL) gTPKeyProc = NewControlUserPaneKeyDownUPP(TPPaneKeyDownProc);
616 if (gTPActivateProc == NULL) gTPActivateProc = NewControlUserPaneActivateUPP(TPPaneActivateProc);
617 if (gTPFocusProc == NULL) gTPFocusProc = NewControlUserPaneFocusUPP(TPPaneFocusProc);
618
619 /* allocate our private storage */
620 varsp = (STPTextPaneVars *) malloc(sizeof(STPTextPaneVars));
621 handle = varsp ;
622
623 /* set the initial settings for our private data */
624 varsp->fMultiline = wxStyle & wxTE_MULTILINE ;
625 varsp->fNoBorders = wxStyle & wxNO_BORDER ;
626 varsp->fInFocus = false;
627 varsp->fIsActive = true;
628 varsp->fTXNObjectActive = false;
629 varsp->fFocusDrawState = false ;
630 varsp->fUserPaneRec = theControl;
631 varsp->fVisible = true ;
632
633 theWindow = varsp->fOwner = GetControlOwner(theControl);
634
635 varsp->fDrawingEnvironment = (GrafPtr) GetWindowPort(theWindow);
636
637 /* set up the user pane procedures */
638 SetControlData(theControl, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(gTPDrawProc), &gTPDrawProc);
639 SetControlData(theControl, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(gTPHitProc), &gTPHitProc);
640 SetControlData(theControl, kControlEntireControl, kControlUserPaneTrackingProcTag, sizeof(gTPTrackProc), &gTPTrackProc);
641 SetControlData(theControl, kControlEntireControl, kControlUserPaneIdleProcTag, sizeof(gTPIdleProc), &gTPIdleProc);
642 SetControlData(theControl, kControlEntireControl, kControlUserPaneKeyDownProcTag, sizeof(gTPKeyProc), &gTPKeyProc);
643 SetControlData(theControl, kControlEntireControl, kControlUserPaneActivateProcTag, sizeof(gTPActivateProc), &gTPActivateProc);
644 SetControlData(theControl, kControlEntireControl, kControlUserPaneFocusProcTag, sizeof(gTPFocusProc), &gTPFocusProc);
645
646 /* calculate the rectangles used by the control */
647 UMAGetControlBoundsInWindowCoords(theControl, &bounds);
648 varsp->fRTextOutlineRegion = NewRgn() ;
649 TPCalculateBounds( varsp , bounds ) ;
650
651 /* set up the drawing environment */
652 SetPort(varsp->fDrawingEnvironment);
653
654 /* create the new edit field */
655
656 TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( wxStyle ) ;
657
658 verify_noerr(TXNNewObject(NULL, varsp->fOwner, &varsp->fRTextArea,
659 frameOptions ,
660 kTXNTextEditStyleFrameType,
661 kTXNTextensionFile,
662 kTXNSystemDefaultEncoding,
663 &varsp->fTXNRec, &varsp->fTXNFrame, (TXNObjectRefcon) varsp));
664
665 AdjustAttributesFromWXStyle( varsp->fTXNRec , wxStyle , varsp->fVisible ) ;
666 /* perform final activations and setup for our text field. Here,
667 we assume that the window is going to be the 'active' window. */
668 TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);
669 /* all done */
670 return err;
671 }
672
673 #else
674 struct STPTextPaneVars
675 {
676 } ;
677
678 #endif
679
680 static void SetTXNData( STPTextPaneVars *varsp, TXNObject txn , const wxString& st , TXNOffset start , TXNOffset end )
681 {
682 #if wxUSE_UNICODE
683 #if SIZEOF_WCHAR_T == 2
684 size_t len = st.Len() ;
685 TXNSetData( txn , kTXNUnicodeTextData, (void*)st.wc_str(), len * 2,
686 start, end);
687 #else
688 wxMBConvUTF16BE converter ;
689 ByteCount byteBufferLen = converter.WC2MB( NULL , st.wc_str() , 0 ) ;
690 UniChar *unibuf = (UniChar*) malloc(byteBufferLen) ;
691 converter.WC2MB( (char*) unibuf , st.wc_str() , byteBufferLen ) ;
692 TXNSetData( txn , kTXNUnicodeTextData, (void*)unibuf, byteBufferLen ,
693 start, end);
694 free( unibuf ) ;
695 #endif
696 #else
697 wxCharBuffer text = st.mb_str(wxConvLocal) ;
698 TXNSetData( txn , kTXNTextData, (void*)text.data(), strlen( text ) ,
699 start, end);
700 #endif
701 }
702
703
704 #endif
705
706 #if !USE_SHARED_LIBRARY
707 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
708
709 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
710 EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
711 EVT_CHAR(wxTextCtrl::OnChar)
712 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
713 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
714 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
715 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
716 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
717
718 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
719 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
720 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
721 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
722 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
723 END_EVENT_TABLE()
724 #endif
725
726 // Text item
727 void wxTextCtrl::Init()
728 {
729 m_macTXN = NULL ;
730 m_macTXNvars = NULL ;
731
732 m_editable = true ;
733 m_dirty = false;
734
735 m_maxLength = TE_UNLIMITED_LENGTH ;
736 }
737
738 wxTextCtrl::~wxTextCtrl()
739 {
740 #if wxMAC_USE_MLTE
741 SetControlReference((ControlRef)m_macControl, 0) ;
742 #if !wxMAC_USE_MLTE_HIVIEW
743 TXNDeleteObject((TXNObject)m_macTXN);
744 #endif
745 /* delete our private storage */
746 free(m_macTXNvars);
747 /* zero the control reference */
748 #endif
749 }
750
751
752 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
753 const wxString& str,
754 const wxPoint& pos,
755 const wxSize& size, long style,
756 const wxValidator& validator,
757 const wxString& name)
758 {
759 m_macIsUserPane = FALSE ;
760
761 m_macTXN = NULL ;
762 m_macTXNvars = NULL ;
763 m_editable = true ;
764
765 // base initialization
766 if ( !wxTextCtrlBase::Create(parent, id, pos, size, style & ~(wxHSCROLL|wxVSCROLL), validator, name) )
767 return FALSE;
768
769 wxSize mySize = size ;
770
771 Rect bounds = wxMacGetBoundsForControl( this , pos , size ) ;
772
773 if ( m_windowStyle & wxTE_MULTILINE )
774 {
775 wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
776 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
777
778 m_windowStyle |= wxTE_PROCESS_ENTER;
779 }
780
781 wxString st = str ;
782 wxMacConvertNewlines13To10( &st ) ;
783 #if wxMAC_USE_MLTE
784 {
785 #if wxMAC_USE_MLTE_HIVIEW
786 HIRect hr = { bounds.left , bounds.top , bounds.right - bounds.left , bounds.bottom- bounds.top } ;
787 HIViewRef scrollView = NULL ;
788 TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( style ) ;
789
790 if ( frameOptions & (kTXNWantVScrollBarMask|kTXNWantHScrollBarMask) )
791 {
792 HIScrollViewCreate(( frameOptions & kTXNWantHScrollBarMask ? kHIScrollViewOptionsHorizScroll : 0) |
793 ( frameOptions & kTXNWantVScrollBarMask ? kHIScrollViewOptionsVertScroll: 0 ) , &scrollView ) ;
794
795 HIViewSetFrame( scrollView, &hr );
796 HIViewSetVisible( scrollView, true );
797 }
798 HIViewRef textView ;
799 HITextViewCreate( NULL , 0, frameOptions , (ControlRef*) &textView ) ;
800 m_macTXN = HITextViewGetTXNObject( textView) ;
801 AdjustAttributesFromWXStyle( (TXNObject) m_macTXN , style , true ) ;
802 HIViewSetVisible( (ControlRef) textView , true ) ;
803 if ( scrollView )
804 {
805 HIViewAddSubview( scrollView , textView ) ;
806 m_macControl = (WXWidget) scrollView ;
807 }
808 else
809 {
810 m_macControl = (WXWidget) textView ;
811 }
812 #else
813 short featurSet;
814
815 featurSet = kControlSupportsEmbedding | kControlSupportsFocus | kControlWantsIdle
816 | kControlWantsActivate | kControlHandlesTracking | kControlHasSpecialBackground
817 | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
818 /* create the control */
819 m_macControl = (WXWidget) ::NewControl(MAC_WXHWND(parent->MacGetTopLevelWindowRef()), &bounds, "\p", true , featurSet, 0, featurSet, kControlUserPaneProc, (long) this );
820 /* set up the mUP specific features and data */
821 wxMacWindowClipper c(this) ;
822 STPTextPaneVars *varsp ;
823 mUPOpenControl( varsp, (ControlRef) m_macControl, m_windowStyle );
824 m_macTXNvars = varsp ;
825 m_macTXN = varsp->fTXNRec ;
826 #endif
827
828 if ( style & wxTE_PASSWORD )
829 {
830 UniChar c = 0xA5 ;
831 verify_noerr(TXNEchoMode( (TXNObject) m_macTXN , c , 0 , true )) ;
832 }
833 }
834 MacPostControlCreate(pos,size) ;
835
836 #if !wxMAC_USE_MLTE_HIVIEW
837 if ( MacIsReallyShown() )
838 MLTESetObjectVisibility( (STPTextPaneVars*) m_macTXNvars, true , GetWindowStyle() ) ;
839 #endif
840
841 {
842 wxMacWindowClipper clipper( this ) ;
843 #if !wxMAC_USE_MLTE_HIVIEW
844 TPUpdateVisibility( (ControlRef) m_macControl ) ;
845 #endif
846 SetTXNData( (STPTextPaneVars *)m_macTXNvars , (TXNObject) m_macTXN , st , kTXNStartOffset, kTXNEndOffset ) ;
847
848 TXNSetSelection( (TXNObject) m_macTXN, 0, 0);
849 TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
850 }
851
852 // in case MLTE is catching events before we get the chance to do so, we'd have to reintroduce the tlw-handler in front :
853 // parent->MacGetTopLevelWindow()->MacInstallTopLevelWindowEventHandler() ;
854
855 SetBackgroundColour( *wxWHITE ) ;
856
857 TXNBackground tback;
858 tback.bgType = kTXNBackgroundTypeRGB;
859 tback.bg.color = MAC_WXCOLORREF( GetBackgroundColour().GetPixel() );
860 TXNSetBackground( (TXNObject) m_macTXN , &tback);
861
862 if ( m_windowStyle & wxTE_READONLY)
863 {
864 SetEditable( false ) ;
865 }
866 #else
867 wxMacCFStringHolder cf(st , m_font.GetEncoding()) ;
868 CreateEditUnicodeTextControl( MAC_WXHWND(parent->MacGetTopLevelWindowRef()), &bounds , cf , style & wxTE_PASSWORD , NULL , (ControlRef*) &m_macControl ) ;
869 MacPostControlCreate(pos,size) ;
870 #endif
871
872
873 return TRUE;
874 }
875
876 void wxTextCtrl::MacVisibilityChanged()
877 {
878 #if wxMAC_USE_MLTE && !wxMAC_USE_MLTE_HIVIEW
879 MLTESetObjectVisibility((STPTextPaneVars*) m_macTXNvars , MacIsReallyShown() , GetWindowStyle() ) ;
880 if ( !MacIsReallyShown() )
881 InvalWindowRect( GetControlOwner( (ControlHandle) m_macControl ) , &((STPTextPaneVars *)m_macTXNvars)->fRBounds ) ;
882 #endif
883 }
884
885 void wxTextCtrl::MacEnabledStateChanged()
886 {
887 }
888
889
890 wxString wxTextCtrl::GetValue() const
891 {
892 wxString result ;
893 #if wxMAC_USE_MLTE
894 OSStatus err ;
895 Size actualSize = 0;
896 {
897 #if wxUSE_UNICODE
898 Handle theText ;
899 err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNUnicodeTextData );
900 // all done
901 if ( err )
902 {
903 actualSize = 0 ;
904 }
905 else
906 {
907 actualSize = GetHandleSize( theText ) / sizeof( UniChar) ;
908 if ( actualSize > 0 )
909 {
910 wxChar *ptr = NULL ;
911 #if SIZEOF_WCHAR_T == 2
912 ptr = new wxChar[actualSize + 1 ] ;
913 wxStrncpy( ptr , (wxChar*) *theText , actualSize ) ;
914
915 #else
916 SetHandleSize( theText , ( actualSize + 1 ) * sizeof( UniChar ) ) ;
917 HLock( theText ) ;
918 (((UniChar*)*theText)[actualSize]) = 0 ;
919 wxMBConvUTF16BE converter ;
920 size_t noChars = converter.MB2WC( NULL , (const char*)*theText , 0 ) ;
921 ptr = new wxChar[noChars + 1] ;
922
923 noChars = converter.MB2WC( ptr , (const char*)*theText , noChars ) ;
924 ptr[noChars] = 0 ;
925 HUnlock( theText ) ;
926 #endif
927 ptr[actualSize] = 0 ;
928 result = wxString( ptr ) ;
929 delete[] ptr ;
930 }
931 DisposeHandle( theText ) ;
932 }
933 #else
934 Handle theText ;
935 err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
936 // all done
937 if ( err )
938 {
939 actualSize = 0 ;
940 }
941 else
942 {
943 actualSize = GetHandleSize( theText ) ;
944 if ( actualSize > 0 )
945 {
946 HLock( theText ) ;
947 result = wxString( *theText , wxConvLocal , actualSize ) ;
948 HUnlock( theText ) ;
949 }
950 DisposeHandle( theText ) ;
951 }
952 #endif
953 }
954 #else
955 CFStringRef value = NULL ;
956 Size actualSize = 0 ;
957
958 verify_noerr( GetControlData( (ControlRef) m_macControl , 0, GetWindowStyle() & wxTE_PASSWORD ?
959 kControlEditTextPasswordCFStringTag : kControlEditTextCFStringTag,
960 sizeof(CFStringRef), &value, &actualSize ) );
961 if ( value )
962 {
963 wxMacCFStringHolder cf(value) ;
964 result = cf.AsString() ;
965 }
966 #endif
967 wxMacConvertNewlines10To13( &result ) ;
968 return result ;
969 }
970
971 void wxTextCtrl::GetSelection(long* from, long* to) const
972 {
973 #if wxMAC_USE_MLTE
974 TXNGetSelection( (TXNObject) m_macTXN , (TXNOffset*) from , (TXNOffset*) to ) ;
975 #else
976 ControlEditTextSelectionRec sel ;
977 Size actualSize ;
978 verify_noerr( GetControlData( (ControlRef) m_macControl , 0, kControlEditTextSelectionTag,
979 sizeof(ControlEditTextSelectionRec), &sel, &actualSize ) );
980 if ( from ) *from = sel.selStart ;
981 if ( to ) *to = sel.selEnd ;
982 #endif
983 }
984
985 void wxTextCtrl::SetValue(const wxString& str)
986 {
987 // optimize redraws
988 if ( GetValue() == str )
989 return ;
990
991 wxString st = str ;
992 wxMacConvertNewlines13To10( &st ) ;
993 #if wxMAC_USE_MLTE
994 {
995 wxMacWindowClipper c( this ) ;
996 bool formerEditable = m_editable ;
997 if ( !formerEditable )
998 SetEditable(true) ;
999
1000 #if !wxMAC_USE_MLTE_HIVIEW
1001 // otherwise scrolling might have problems ?
1002 TPUpdateVisibility( ( (STPTextPaneVars *)m_macTXNvars)->fUserPaneRec ) ;
1003 #endif
1004 SetTXNData( (STPTextPaneVars *)m_macTXNvars , (TXNObject) m_macTXN , st , kTXNStartOffset, kTXNEndOffset ) ;
1005 TXNSetSelection( (TXNObject) m_macTXN, 0, 0);
1006 TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
1007 if ( !formerEditable )
1008 SetEditable(formerEditable) ;
1009 }
1010 #else
1011 wxMacCFStringHolder cf(st , m_font.GetEncoding() ) ;
1012 CFStringRef value = cf ;
1013 verify_noerr( SetControlData( (ControlRef) m_macControl , 0, GetWindowStyle() & wxTE_PASSWORD ?
1014 kControlEditTextPasswordCFStringTag : kControlEditTextCFStringTag,
1015 sizeof(CFStringRef), &value ) );
1016 #endif
1017 }
1018
1019 void wxTextCtrl::SetMaxLength(unsigned long len)
1020 {
1021 m_maxLength = len ;
1022 }
1023
1024 bool wxTextCtrl::SetFont( const wxFont& font )
1025 {
1026 if ( !wxTextCtrlBase::SetFont( font ) )
1027 return FALSE ;
1028
1029 #if wxMAC_USE_MLTE
1030 wxMacWindowClipper c( this ) ;
1031 bool formerEditable = m_editable ;
1032 if ( !formerEditable )
1033 SetEditable(true) ;
1034
1035 TXNTypeAttributes typeAttr[4] ;
1036 Str255 fontName = "\pMonaco" ;
1037 SInt16 fontSize = 12 ;
1038 Style fontStyle = normal ;
1039 int attrCounter = 0 ;
1040
1041 wxMacStringToPascal( font.GetFaceName() , fontName ) ;
1042 fontSize = font.MacGetFontSize() ;
1043 fontStyle = font.MacGetFontStyle() ;
1044
1045 typeAttr[attrCounter].tag = kTXNQDFontNameAttribute ;
1046 typeAttr[attrCounter].size = kTXNQDFontNameAttributeSize ;
1047 typeAttr[attrCounter].data.dataPtr = (void*) fontName ;
1048 typeAttr[attrCounter+1].tag = kTXNQDFontSizeAttribute ;
1049 typeAttr[attrCounter+1].size = kTXNFontSizeAttributeSize ;
1050 typeAttr[attrCounter+1].data.dataValue = (fontSize << 16) ;
1051 typeAttr[attrCounter+2].tag = kTXNQDFontStyleAttribute ;
1052 typeAttr[attrCounter+2].size = kTXNQDFontStyleAttributeSize ;
1053 typeAttr[attrCounter+2].data.dataValue = fontStyle ;
1054 attrCounter += 3 ;
1055 /*
1056 typeAttr[attrCounter].tag = kTXNQDFontColorAttribute ;
1057 typeAttr[attrCounter].size = kTXNQDFontColorAttributeSize ;
1058 typeAttr[attrCounter].data.dataPtr = (void*) &color ;
1059 color = MAC_WXCOLORREF(GetForegroundColour().GetPixel()) ;
1060 attrCounter += 1 ;
1061 */
1062 verify_noerr( TXNSetTypeAttributes ((TXNObject)m_macTXN, attrCounter , typeAttr, kTXNStartOffset,kTXNEndOffset) );
1063
1064 if ( !formerEditable )
1065 SetEditable(formerEditable) ;
1066 #endif
1067 return true ;
1068 }
1069
1070 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
1071 {
1072 #if wxMAC_USE_MLTE
1073 bool formerEditable = m_editable ;
1074 if ( !formerEditable )
1075 SetEditable(true) ;
1076 TXNTypeAttributes typeAttr[4] ;
1077 Str255 fontName = "\pMonaco" ;
1078 SInt16 fontSize = 12 ;
1079 Style fontStyle = normal ;
1080 RGBColor color ;
1081 int attrCounter = 0 ;
1082 if ( style.HasFont() )
1083 {
1084 const wxFont &font = style.GetFont() ;
1085 wxMacStringToPascal( font.GetFaceName() , fontName ) ;
1086 fontSize = font.GetPointSize() ;
1087 if ( font.GetUnderlined() )
1088 fontStyle |= underline ;
1089 if ( font.GetWeight() == wxBOLD )
1090 fontStyle |= bold ;
1091 if ( font.GetStyle() == wxITALIC )
1092 fontStyle |= italic ;
1093
1094 typeAttr[attrCounter].tag = kTXNQDFontNameAttribute ;
1095 typeAttr[attrCounter].size = kTXNQDFontNameAttributeSize ;
1096 typeAttr[attrCounter].data.dataPtr = (void*) fontName ;
1097 typeAttr[attrCounter+1].tag = kTXNQDFontSizeAttribute ;
1098 typeAttr[attrCounter+1].size = kTXNFontSizeAttributeSize ;
1099 typeAttr[attrCounter+1].data.dataValue = (fontSize << 16) ;
1100 typeAttr[attrCounter+2].tag = kTXNQDFontStyleAttribute ;
1101 typeAttr[attrCounter+2].size = kTXNQDFontStyleAttributeSize ;
1102 typeAttr[attrCounter+2].data.dataValue = fontStyle ;
1103 attrCounter += 3 ;
1104
1105 }
1106 if ( style.HasTextColour() )
1107 {
1108 typeAttr[attrCounter].tag = kTXNQDFontColorAttribute ;
1109 typeAttr[attrCounter].size = kTXNQDFontColorAttributeSize ;
1110 typeAttr[attrCounter].data.dataPtr = (void*) &color ;
1111 color = MAC_WXCOLORREF(style.GetTextColour().GetPixel()) ;
1112 attrCounter += 1 ;
1113 }
1114
1115 if ( attrCounter > 0 )
1116 {
1117 verify_noerr( TXNSetTypeAttributes ((TXNObject)m_macTXN, attrCounter , typeAttr, start,end) );
1118 }
1119 if ( !formerEditable )
1120 SetEditable(formerEditable) ;
1121 #endif
1122 return TRUE ;
1123 }
1124
1125 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
1126 {
1127 wxTextCtrlBase::SetDefaultStyle( style ) ;
1128 SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
1129 return TRUE ;
1130 }
1131
1132 // Clipboard operations
1133 void wxTextCtrl::Copy()
1134 {
1135 if (CanCopy())
1136 {
1137 #if wxMAC_USE_MLTE
1138 ClearCurrentScrap();
1139 TXNCopy((TXNObject)m_macTXN);
1140 TXNConvertToPublicScrap();
1141 #endif
1142 }
1143 }
1144
1145 void wxTextCtrl::Cut()
1146 {
1147 if (CanCut())
1148 {
1149 #if wxMAC_USE_MLTE
1150 ClearCurrentScrap();
1151 TXNCut((TXNObject)m_macTXN);
1152 TXNConvertToPublicScrap();
1153 #endif
1154 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1155 event.SetString( GetValue() ) ;
1156 event.SetEventObject( this );
1157 GetEventHandler()->ProcessEvent(event);
1158 }
1159 }
1160
1161 void wxTextCtrl::Paste()
1162 {
1163 if (CanPaste())
1164 {
1165 #if wxMAC_USE_MLTE
1166 TXNConvertFromPublicScrap();
1167 TXNPaste((TXNObject)m_macTXN);
1168 SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
1169 #endif
1170 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1171 event.SetString( GetValue() ) ;
1172 event.SetEventObject( this );
1173 GetEventHandler()->ProcessEvent(event);
1174 }
1175 }
1176
1177 bool wxTextCtrl::CanCopy() const
1178 {
1179 // Can copy if there's a selection
1180 long from, to;
1181 GetSelection(& from, & to);
1182 return (from != to);
1183 }
1184
1185 bool wxTextCtrl::CanCut() const
1186 {
1187 if ( !IsEditable() )
1188 {
1189 return false ;
1190 }
1191 // Can cut if there's a selection
1192 long from, to;
1193 GetSelection(& from, & to);
1194 return (from != to);
1195 }
1196
1197 bool wxTextCtrl::CanPaste() const
1198 {
1199 if (!IsEditable())
1200 return FALSE;
1201
1202 #if wxMAC_USE_MLTE
1203 return TXNIsScrapPastable() ;
1204 #else
1205 return true ;
1206 #endif
1207 }
1208
1209 void wxTextCtrl::SetEditable(bool editable)
1210 {
1211 if ( editable != m_editable )
1212 {
1213 m_editable = editable ;
1214 #if wxMAC_USE_MLTE
1215 TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1216 TXNControlData data[] = { { editable ? kTXNReadWrite : kTXNReadOnly } } ;
1217 TXNSetTXNObjectControls( (TXNObject) m_macTXN , false , sizeof(tag) / sizeof (TXNControlTag) , tag , data ) ;
1218 #endif
1219 }
1220 }
1221
1222 void wxTextCtrl::SetInsertionPoint(long pos)
1223 {
1224 SetSelection( pos , pos ) ;
1225 }
1226
1227 void wxTextCtrl::SetInsertionPointEnd()
1228 {
1229 long pos = GetLastPosition();
1230 SetInsertionPoint(pos);
1231 }
1232
1233 long wxTextCtrl::GetInsertionPoint() const
1234 {
1235 long begin,end ;
1236 GetSelection( &begin , &end ) ;
1237 return begin ;
1238 }
1239
1240 long wxTextCtrl::GetLastPosition() const
1241 {
1242 Handle theText ;
1243 long actualsize = 0 ;
1244 #if wxMAC_USE_MLTE
1245 OSErr err = TXNGetDataEncoded( (TXNObject) m_macTXN, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
1246 /* all done */
1247 if ( err )
1248 {
1249 actualsize = 0 ;
1250 }
1251 else
1252 {
1253 actualsize = GetHandleSize( theText ) ;
1254 DisposeHandle( theText ) ;
1255 }
1256 #endif
1257 return actualsize ;
1258 }
1259
1260 void wxTextCtrl::Replace(long from, long to, const wxString& str)
1261 {
1262 #if wxMAC_USE_MLTE
1263 wxString value = str ;
1264 wxMacConvertNewlines13To10( &value ) ;
1265
1266 bool formerEditable = m_editable ;
1267 if ( !formerEditable )
1268 SetEditable(true) ;
1269 TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1270 TXNClear( ((TXNObject) m_macTXN) ) ;
1271 SetTXNData( (STPTextPaneVars *)m_macTXNvars , (TXNObject) m_macTXN , str , kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
1272 if ( !formerEditable )
1273 SetEditable( formerEditable ) ;
1274
1275 Refresh() ;
1276 #endif
1277 }
1278
1279 void wxTextCtrl::Remove(long from, long to)
1280 {
1281 #if wxMAC_USE_MLTE
1282 bool formerEditable = m_editable ;
1283 if ( !formerEditable )
1284 SetEditable(true) ;
1285 TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
1286 TXNClear( ((TXNObject) m_macTXN) ) ;
1287 if ( !formerEditable )
1288 SetEditable( formerEditable ) ;
1289
1290 Refresh() ;
1291 #endif
1292 }
1293
1294 void wxTextCtrl::SetSelection(long from, long to)
1295 {
1296 #if wxMAC_USE_MLTE
1297 /* change the selection */
1298 if ((from == -1) && (to == -1))
1299 TXNSelectAll((TXNObject) m_macTXN);
1300 else
1301 TXNSetSelection( (TXNObject) m_macTXN, from, to);
1302 TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
1303 #else
1304 ControlEditTextSelectionRec sel ;
1305 sel.selStart = from ;
1306 sel.selEnd = to ;
1307 verify_noerr( SetControlData( (ControlRef) m_macControl , 0, kControlEditTextSelectionTag,
1308 sizeof(ControlEditTextSelectionRec), &sel ) );
1309
1310 #endif
1311 }
1312
1313 bool wxTextCtrl::LoadFile(const wxString& file)
1314 {
1315 if ( wxTextCtrlBase::LoadFile(file) )
1316 {
1317 return TRUE;
1318 }
1319
1320 return FALSE;
1321 }
1322
1323 void wxTextCtrl::WriteText(const wxString& str)
1324 {
1325 wxString st = str ;
1326 wxMacConvertNewlines13To10( &st ) ;
1327 #if wxMAC_USE_MLTE
1328 bool formerEditable = m_editable ;
1329 if ( !formerEditable )
1330 SetEditable(true) ;
1331 {
1332 wxMacWindowStateSaver( this ) ;
1333 long start , end , dummy ;
1334 GetSelection( &start , &dummy ) ;
1335 SetTXNData( (STPTextPaneVars *)m_macTXNvars , (TXNObject) m_macTXN , st , kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
1336 GetSelection( &dummy , &end ) ;
1337 SetStyle( start , end , GetDefaultStyle() ) ;
1338 }
1339 if ( !formerEditable )
1340 SetEditable( formerEditable ) ;
1341
1342 MacRedrawControl() ;
1343 #else
1344 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
1345 wxMacCFStringHolder cf(st , m_font.GetEncoding() ) ;
1346 CFStringRef value = cf ;
1347 SetControlData( (ControlRef) m_macControl , 0, kControlEditTextInsertCFStringRefTag,
1348 sizeof(CFStringRef), &value );
1349 #else
1350 wxString val = GetValue() ;
1351 long start , end ;
1352 GetSelection( &start , &end ) ;
1353 val.Remove( start, end - start ) ;
1354 val.insert( start , str ) ;
1355 SetValue( val ) ;
1356 #endif
1357 #endif
1358 }
1359
1360 void wxTextCtrl::AppendText(const wxString& text)
1361 {
1362 SetInsertionPointEnd();
1363 WriteText(text);
1364 }
1365
1366 void wxTextCtrl::Clear()
1367 {
1368 #if wxMAC_USE_MLTE
1369 bool formerEditable = m_editable ;
1370 if ( !formerEditable )
1371 SetEditable(true) ;
1372 TXNSetSelection( (TXNObject)m_macTXN , kTXNStartOffset , kTXNEndOffset ) ;
1373 TXNClear((TXNObject)m_macTXN);
1374
1375 if ( !formerEditable )
1376 SetEditable( formerEditable ) ;
1377
1378 Refresh() ;
1379 #else
1380 SetValue(wxEmptyString) ;
1381 #endif
1382 }
1383
1384 bool wxTextCtrl::IsModified() const
1385 {
1386 return m_dirty;
1387 }
1388
1389 bool wxTextCtrl::IsEditable() const
1390 {
1391 return IsEnabled() && m_editable ;
1392 }
1393
1394 bool wxTextCtrl::AcceptsFocus() const
1395 {
1396 // we don't want focus if we can't be edited
1397 return /*IsEditable() && */ wxControl::AcceptsFocus();
1398 }
1399
1400 wxSize wxTextCtrl::DoGetBestSize() const
1401 {
1402 int wText = 100 ;
1403
1404 int hText;
1405
1406 switch( m_windowVariant )
1407 {
1408 case wxWINDOW_VARIANT_NORMAL :
1409 hText = 22 ;
1410 break ;
1411 case wxWINDOW_VARIANT_SMALL :
1412 hText = 19 ;
1413 break ;
1414 case wxWINDOW_VARIANT_MINI :
1415 hText= 15 ;
1416 break ;
1417 default :
1418 hText = 22 ;
1419 break ;
1420 }
1421
1422 if ( m_windowStyle & wxTE_MULTILINE )
1423 {
1424 hText *= 5 ;
1425 }
1426
1427 return wxSize(wText, hText);
1428 }
1429
1430 // ----------------------------------------------------------------------------
1431 // Undo/redo
1432 // ----------------------------------------------------------------------------
1433
1434 void wxTextCtrl::Undo()
1435 {
1436 if (CanUndo())
1437 {
1438 #if wxMAC_USE_MLTE
1439 TXNUndo((TXNObject)m_macTXN);
1440 #endif
1441 }
1442 }
1443
1444 void wxTextCtrl::Redo()
1445 {
1446 if (CanRedo())
1447 {
1448 #if wxMAC_USE_MLTE
1449 TXNRedo((TXNObject)m_macTXN);
1450 #endif
1451 }
1452 }
1453
1454 bool wxTextCtrl::CanUndo() const
1455 {
1456 if ( !IsEditable() )
1457 {
1458 return false ;
1459 }
1460 #if wxMAC_USE_MLTE
1461 return TXNCanUndo((TXNObject)m_macTXN,NULL);
1462 #else
1463 return false ;
1464 #endif
1465 }
1466
1467 bool wxTextCtrl::CanRedo() const
1468 {
1469 if ( !IsEditable() )
1470 {
1471 return false ;
1472 }
1473 #if wxMAC_USE_MLTE
1474 return TXNCanRedo((TXNObject)m_macTXN,NULL);
1475 #else
1476 return false ;
1477 #endif
1478 }
1479
1480 // Makes modifie or unmodified
1481 void wxTextCtrl::MarkDirty()
1482 {
1483 m_dirty = true;
1484 }
1485
1486 void wxTextCtrl::DiscardEdits()
1487 {
1488 m_dirty = false;
1489 }
1490
1491 int wxTextCtrl::GetNumberOfLines() const
1492 {
1493 ItemCount lines = 0 ;
1494 #if wxMAC_USE_MLTE
1495 TXNGetLineCount((TXNObject)m_macTXN, &lines ) ;
1496 #endif
1497 return lines ;
1498 }
1499
1500 long wxTextCtrl::XYToPosition(long x, long y) const
1501 {
1502 #if wxMAC_USE_MLTE
1503 Point curpt ;
1504
1505 long lastpos = GetLastPosition() ;
1506
1507 // TODO find a better implementation : while we can get the
1508 // line metrics of a certain line, we don't get its starting
1509 // position, so it would probably be rather a binary search
1510 // for the start position
1511 long xpos = 0 ;
1512 long ypos = 0 ;
1513 int lastHeight = 0 ;
1514
1515 ItemCount n ;
1516 for ( n = 0 ; n <= (ItemCount) lastpos ; ++n )
1517 {
1518 if ( y == ypos && x == xpos )
1519 return n ;
1520
1521 TXNOffsetToPoint( (TXNObject) m_macTXN, n , &curpt);
1522
1523 if ( curpt.v > lastHeight )
1524 {
1525 xpos = 0 ;
1526 if ( n > 0 )
1527 ++ypos ;
1528 lastHeight = curpt.v ;
1529 }
1530 else
1531 ++xpos ;
1532 }
1533 #endif
1534 return 0;
1535 }
1536
1537 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
1538 {
1539 #if wxMAC_USE_MLTE
1540 Point curpt ;
1541
1542 long lastpos = GetLastPosition() ;
1543
1544 if ( y ) *y = 0 ;
1545 if ( x ) *x = 0 ;
1546
1547 if ( pos <= lastpos )
1548 {
1549 // TODO find a better implementation : while we can get the
1550 // line metrics of a certain line, we don't get its starting
1551 // position, so it would probably be rather a binary search
1552 // for the start position
1553 long xpos = 0 ;
1554 long ypos = 0 ;
1555 int lastHeight = 0 ;
1556
1557 ItemCount n ;
1558 for ( n = 0 ; n <= (ItemCount) pos ; ++n )
1559 {
1560 TXNOffsetToPoint( (TXNObject) m_macTXN, n , &curpt);
1561
1562 if ( curpt.v > lastHeight )
1563 {
1564 xpos = 0 ;
1565 if ( n > 0 )
1566 ++ypos ;
1567 lastHeight = curpt.v ;
1568 }
1569 else
1570 ++xpos ;
1571 }
1572 if ( y ) *y = ypos ;
1573 if ( x ) *x = xpos ;
1574 }
1575 #else
1576 if ( y ) *y = 0 ;
1577 if ( x ) *x = 0 ;
1578 #endif
1579 return FALSE ;
1580 }
1581
1582 void wxTextCtrl::ShowPosition(long pos)
1583 {
1584 #if wxMAC_USE_MLTE
1585 #if TARGET_RT_MAC_MACHO && defined(AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER)
1586 {
1587 Point current ;
1588 Point desired ;
1589 TXNOffset selstart , selend ;
1590 TXNGetSelection( (TXNObject) m_macTXN , &selstart , &selend) ;
1591 TXNOffsetToPoint( (TXNObject) m_macTXN, selstart , &current);
1592 TXNOffsetToPoint( (TXNObject) m_macTXN, pos , &desired);
1593 //TODO use HIPoints for 10.3 and above
1594 if ( (UInt32) TXNScroll != (UInt32) kUnresolvedCFragSymbolAddress )
1595 {
1596 OSErr theErr = noErr;
1597 SInt32 dv = desired.v - current.v ;
1598 SInt32 dh = desired.h - current.h ;
1599 TXNShowSelection( (TXNObject) m_macTXN , true ) ;
1600 theErr = TXNScroll( (TXNObject) m_macTXN, kTXNScrollUnitsInPixels , kTXNScrollUnitsInPixels , &dv , &dh );
1601 wxASSERT_MSG( theErr == noErr, _T("TXNScroll returned an error!") );
1602 }
1603 }
1604 #endif
1605 #endif
1606 }
1607
1608 int wxTextCtrl::GetLineLength(long lineNo) const
1609 {
1610 #if wxMAC_USE_MLTE
1611 Point curpt ;
1612 if ( lineNo < GetNumberOfLines() )
1613 {
1614 // TODO find a better implementation : while we can get the
1615 // line metrics of a certain line, we don't get its starting
1616 // position, so it would probably be rather a binary search
1617 // for the start position
1618 long xpos = 0 ;
1619 long ypos = 0 ;
1620 int lastHeight = 0 ;
1621 long lastpos = GetLastPosition() ;
1622
1623 ItemCount n ;
1624 for ( n = 0 ; n <= (ItemCount) lastpos ; ++n )
1625 {
1626 TXNOffsetToPoint( (TXNObject) m_macTXN, n , &curpt);
1627
1628 if ( curpt.v > lastHeight )
1629 {
1630 if ( ypos == lineNo )
1631 return xpos ;
1632
1633 xpos = 0 ;
1634 if ( n > 0 )
1635 ++ypos ;
1636 lastHeight = curpt.v ;
1637 }
1638 else
1639 ++xpos ;
1640 }
1641 }
1642 #endif
1643 return 0;
1644 }
1645
1646 wxString wxTextCtrl::GetLineText(long lineNo) const
1647 {
1648 Point curpt ;
1649 wxString line ;
1650 #if wxMAC_USE_MLTE
1651 wxString content = GetValue() ;
1652
1653 if ( lineNo < GetNumberOfLines() )
1654 {
1655 // TODO find a better implementation : while we can get the
1656 // line metrics of a certain line, we don't get its starting
1657 // position, so it would probably be rather a binary search
1658 // for the start position
1659 long xpos = 0 ;
1660 long ypos = 0 ;
1661 int lastHeight = 0 ;
1662 long lastpos = GetLastPosition() ;
1663
1664 ItemCount n ;
1665 for ( n = 0 ; n <= (ItemCount)lastpos ; ++n )
1666 {
1667 TXNOffsetToPoint( (TXNObject) m_macTXN, n , &curpt);
1668
1669 if ( curpt.v > lastHeight )
1670 {
1671 if ( ypos == lineNo )
1672 return line ;
1673
1674 xpos = 0 ;
1675 if ( n > 0 )
1676 ++ypos ;
1677 lastHeight = curpt.v ;
1678 }
1679 else
1680 {
1681 if ( ypos == lineNo )
1682 line += content[n] ;
1683 ++xpos ;
1684 }
1685 }
1686 }
1687 #endif
1688 return line ;
1689 }
1690
1691 /*
1692 * Text item
1693 */
1694
1695 void wxTextCtrl::Command(wxCommandEvent & event)
1696 {
1697 SetValue (event.GetString());
1698 ProcessCommand (event);
1699 }
1700
1701 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
1702 {
1703 // By default, load the first file into the text window.
1704 if (event.GetNumberOfFiles() > 0)
1705 {
1706 LoadFile(event.GetFiles()[0]);
1707 }
1708 }
1709
1710 void wxTextCtrl::OnChar(wxKeyEvent& event)
1711 {
1712 int key = event.GetKeyCode() ;
1713 bool eat_key = false ;
1714
1715 if ( key == 'c' && event.MetaDown() )
1716 {
1717 if ( CanCopy() )
1718 Copy() ;
1719 return ;
1720 }
1721
1722 if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
1723 !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
1724 /* && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
1725 )
1726 {
1727 // eat it
1728 return ;
1729 }
1730
1731 // assume that any key not processed yet is going to modify the control
1732 m_dirty = true;
1733
1734 if ( key == 'v' && event.MetaDown() )
1735 {
1736 if ( CanPaste() )
1737 Paste() ;
1738 return ;
1739 }
1740 if ( key == 'x' && event.MetaDown() )
1741 {
1742 if ( CanCut() )
1743 Cut() ;
1744 return ;
1745 }
1746 switch ( key )
1747 {
1748 case WXK_RETURN:
1749 if (m_windowStyle & wxPROCESS_ENTER)
1750 {
1751 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
1752 event.SetEventObject( this );
1753 event.SetString( GetValue() );
1754 if ( GetEventHandler()->ProcessEvent(event) )
1755 return;
1756 }
1757 if ( !(m_windowStyle & wxTE_MULTILINE) )
1758 {
1759 wxWindow *parent = GetParent();
1760 while( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL ) {
1761 parent = parent->GetParent() ;
1762 }
1763 if ( parent && parent->GetDefaultItem() )
1764 {
1765 wxButton *def = wxDynamicCast(parent->GetDefaultItem(),
1766 wxButton);
1767 if ( def && def->IsEnabled() )
1768 {
1769 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
1770 event.SetEventObject(def);
1771 def->Command(event);
1772 return ;
1773 }
1774 }
1775
1776 // this will make wxWindows eat the ENTER key so that
1777 // we actually prevent line wrapping in a single line
1778 // text control
1779 eat_key = TRUE;
1780 }
1781
1782 break;
1783
1784 case WXK_TAB:
1785 // always produce navigation event - even if we process TAB
1786 // ourselves the fact that we got here means that the user code
1787 // decided to skip processing of this TAB - probably to let it
1788 // do its default job.
1789 {
1790 wxNavigationKeyEvent eventNav;
1791 eventNav.SetDirection(!event.ShiftDown());
1792 eventNav.SetWindowChange(event.ControlDown());
1793 eventNav.SetEventObject(this);
1794
1795 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
1796 return;
1797
1798 event.Skip() ;
1799 return;
1800 }
1801 break;
1802 }
1803
1804 if (!eat_key)
1805 {
1806 // perform keystroke handling
1807 if ( wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL )
1808 CallNextEventHandler((EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() , (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
1809 else
1810 {
1811 EventRecord rec ;
1812 if ( wxMacConvertEventToRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) )
1813 {
1814 EventRecord *ev = &rec ;
1815 short keycode ;
1816 short keychar ;
1817 keychar = short(ev->message & charCodeMask);
1818 keycode = short(ev->message & keyCodeMask) >> 8 ;
1819
1820 ::HandleControlKey( (ControlRef) m_macControl , keycode , keychar , ev->modifiers ) ;
1821 }
1822 }
1823 }
1824 if ( ( key >= 0x20 && key < WXK_START ) ||
1825 key == WXK_RETURN ||
1826 key == WXK_DELETE ||
1827 key == WXK_BACK)
1828 {
1829 wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1830 event1.SetString( GetValue() ) ;
1831 event1.SetEventObject( this );
1832 wxPostEvent(GetEventHandler(),event1);
1833 }
1834 }
1835
1836 // ----------------------------------------------------------------------------
1837 // standard handlers for standard edit menu events
1838 // ----------------------------------------------------------------------------
1839
1840 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1841 {
1842 Cut();
1843 }
1844
1845 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1846 {
1847 Copy();
1848 }
1849
1850 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1851 {
1852 Paste();
1853 }
1854
1855 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1856 {
1857 Undo();
1858 }
1859
1860 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1861 {
1862 Redo();
1863 }
1864
1865 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1866 {
1867 event.Enable( CanCut() );
1868 }
1869
1870 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1871 {
1872 event.Enable( CanCopy() );
1873 }
1874
1875 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1876 {
1877 event.Enable( CanPaste() );
1878 }
1879
1880 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1881 {
1882 event.Enable( CanUndo() );
1883 }
1884
1885 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1886 {
1887 event.Enable( CanRedo() );
1888 }
1889
1890 bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
1891 {
1892 return true ;
1893 }
1894
1895 // user pane implementation
1896
1897 void wxTextCtrl::MacControlUserPaneDrawProc(wxInt16 part)
1898 {
1899 }
1900
1901 wxInt16 wxTextCtrl::MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y)
1902 {
1903 return kControlNoPart ;
1904 }
1905
1906 wxInt16 wxTextCtrl::MacControlUserPaneTrackingProc(wxInt16 x, wxInt16 y, void* actionProc)
1907 {
1908 return kControlNoPart ;
1909 }
1910
1911 void wxTextCtrl::MacControlUserPaneIdleProc()
1912 {
1913 }
1914
1915 wxInt16 wxTextCtrl::MacControlUserPaneKeyDownProc(wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers)
1916 {
1917 return kControlNoPart ;
1918 }
1919
1920 void wxTextCtrl::MacControlUserPaneActivateProc(bool activating)
1921 {
1922 }
1923
1924 wxInt16 wxTextCtrl::MacControlUserPaneFocusProc(wxInt16 action)
1925 {
1926 return kControlNoPart ;
1927 }
1928
1929 void wxTextCtrl::MacControlUserPaneBackgroundProc(void* info)
1930 {
1931 }
1932
1933 #endif
1934 // wxUSE_TEXTCTRL