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