projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Final and global PRIOR/NEXT change: keep consistency using only PAGE versions, deprec...
[wxWidgets.git] / src / mac / carbon / textctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/mac/carbon/textctrl.cpp
3 // Purpose: wxTextCtrl
4 // Author: Stefan Csomor
5 // Modified by: Ryan Norton (MLTE GetLineLength and GetLineText)
6 // Created: 1998-01-01
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13
14 #if wxUSE_TEXTCTRL
15
16
17 #ifdef __DARWIN__
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #else
21 #include <stat.h>
22 #endif
23
24 #include "wx/msgdlg.h"
25
26 #if wxUSE_STD_IOSTREAM
27 #if wxUSE_IOSTREAMH
28 #include <fstream.h>
29 #else
30 #include <fstream>
31 #endif
32 #endif
33
34 #include "wx/app.h"
35 #include "wx/dc.h"
36 #include "wx/button.h"
37 #include "wx/toplevel.h"
38 #include "wx/textctrl.h"
39 #include "wx/settings.h"
40 #include "wx/filefn.h"
41 #include "wx/utils.h"
42 #include "wx/sysopt.h"
43 #include "wx/menu.h"
44 #include "wx/intl.h"
45
46 #if defined(__BORLANDC__) && !defined(__WIN32__)
47 #include <alloc.h>
48 #elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
49 #include <malloc.h>
50 #endif
51
52 #ifndef __DARWIN__
53 #include <Scrap.h>
54 #endif
55
56 #ifndef __DARWIN__
57 #include <MacTextEditor.h>
58 #include <ATSUnicode.h>
59 #include <TextCommon.h>
60 #include <TextEncodingConverter.h>
61 #endif
62
63 #include "wx/mac/uma.h"
64
65
66 // if this is set to 1 then under OSX 10.2 the 'classic' MLTE implementation will be used
67 // if set to 0 then the unicode textctrl will be used
68 #ifndef wxMAC_AWAYS_USE_MLTE
69 #define wxMAC_AWAYS_USE_MLTE 1
70 #endif
71
72 #ifndef __WXMAC_OSX__
73 enum
74 {
75 kTXNVisibilityTag = 'visb' // set the visibility state of the object
76 };
77 #endif
78
79
80 class wxMacFunctor
81 {
82 public :
83 wxMacFunctor() {}
84 virtual ~wxMacFunctor() {}
85
86 virtual void* operator()() = 0 ;
87
88 static void* CallBackProc( void *param )
89 {
90 wxMacFunctor* f = (wxMacFunctor*) param ;
91 void *result = (*f)() ;
92 return result ;
93 }
94 } ;
95
96 template<typename classtype, typename param1type>
97
98 class wxMacObjectFunctor1 : public wxMacFunctor
99 {
100 typedef void (classtype::*function)( param1type p1 ) ;
101 typedef void (classtype::*ref_function)( const param1type& p1 ) ;
102 public :
103 wxMacObjectFunctor1( classtype *obj , function f , param1type p1 ) :
104 wxMacFunctor()
105 {
106 m_object = obj ;
107 m_function = f ;
108 m_param1 = p1 ;
109 }
110
111 wxMacObjectFunctor1( classtype *obj , ref_function f , param1type p1 ) :
112 wxMacFunctor()
113 {
114 m_object = obj ;
115 m_refFunction = f ;
116 m_param1 = p1 ;
117 }
118
119 ~wxMacObjectFunctor1() {}
120
121 virtual void* operator()()
122 {
123 (m_object->*m_function)( m_param1 ) ;
124 return NULL ;
125 }
126
127 private :
128 classtype* m_object ;
129 param1type m_param1 ;
130 union
131 {
132 function m_function ;
133 ref_function m_refFunction ;
134 } ;
135 } ;
136
137 template<typename classtype, typename param1type>
138 void* wxMacMPRemoteCall( classtype *object , void (classtype::*function)( param1type p1 ) , param1type p1 )
139 {
140 wxMacObjectFunctor1<classtype, param1type> params(object, function, p1) ;
141 void *result =
142 MPRemoteCall( wxMacFunctor::CallBackProc , &params , kMPOwningProcessRemoteContext ) ;
143 return result ;
144 }
145
146 template<typename classtype, typename param1type>
147 void* wxMacMPRemoteCall( classtype *object , void (classtype::*function)( const param1type& p1 ) , param1type p1 )
148 {
149 wxMacObjectFunctor1<classtype,param1type> params(object, function, p1) ;
150 void *result =
151 MPRemoteCall( wxMacFunctor::CallBackProc , &params , kMPOwningProcessRemoteContext ) ;
152 return result ;
153 }
154
155 template<typename classtype, typename param1type>
156 void* wxMacMPRemoteGUICall( classtype *object , void (classtype::*function)( param1type p1 ) , param1type p1 )
157 {
158 wxMutexGuiLeave() ;
159 void *result = wxMacMPRemoteCall( object , function , p1 ) ;
160 wxMutexGuiEnter() ;
161 return result ;
162 }
163
164 template<typename classtype, typename param1type>
165 void* wxMacMPRemoteGUICall( classtype *object , void (classtype::*function)( const param1type& p1 ) , param1type p1 )
166 {
167 wxMutexGuiLeave() ;
168 void *result = wxMacMPRemoteCall( object , function , p1 ) ;
169 wxMutexGuiEnter() ;
170 return result ;
171 }
172
173 // common interface for all implementations
174 class wxMacTextControl : public wxMacControl
175 {
176 public :
177 wxMacTextControl( wxTextCtrl *peer ) ;
178 ~wxMacTextControl() ;
179
180 virtual wxString GetStringValue() const = 0 ;
181 virtual void SetStringValue( const wxString &val ) = 0 ;
182 virtual void SetSelection( long from, long to ) = 0 ;
183 virtual void GetSelection( long* from, long* to ) const = 0 ;
184 virtual void WriteText( const wxString& str ) = 0 ;
185
186 virtual void SetStyle( long start, long end, const wxTextAttr& style ) ;
187 virtual void Copy() ;
188 virtual void Cut() ;
189 virtual void Paste() ;
190 virtual bool CanPaste() const ;
191 virtual void SetEditable( bool editable ) ;
192 virtual wxTextPos GetLastPosition() const ;
193 virtual void Replace( long from, long to, const wxString &str ) ;
194 virtual void Remove( long from, long to ) ;
195
196
197 virtual bool HasOwnContextMenu() const
198 { return false ; }
199
200 virtual bool SetupCursor( const wxPoint& pt )
201 { return false ; }
202
203 virtual void Clear() ;
204 virtual bool CanUndo() const;
205 virtual void Undo() ;
206 virtual bool CanRedo() const;
207 virtual void Redo() ;
208 virtual int GetNumberOfLines() const ;
209 virtual long XYToPosition(long x, long y) const;
210 virtual bool PositionToXY(long pos, long *x, long *y) const ;
211 virtual void ShowPosition(long WXUNUSED(pos)) ;
212 virtual int GetLineLength(long lineNo) const ;
213 virtual wxString GetLineText(long lineNo) const ;
214
215 #ifndef __WXMAC_OSX__
216 virtual void MacControlUserPaneDrawProc(wxInt16 part) = 0 ;
217 virtual wxInt16 MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y) = 0 ;
218 virtual wxInt16 MacControlUserPaneTrackingProc(wxInt16 x, wxInt16 y, void* actionProc) = 0 ;
219 virtual void MacControlUserPaneIdleProc() = 0 ;
220 virtual wxInt16 MacControlUserPaneKeyDownProc(wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers) = 0 ;
221 virtual void MacControlUserPaneActivateProc(bool activating) = 0 ;
222 virtual wxInt16 MacControlUserPaneFocusProc(wxInt16 action) = 0 ;
223 virtual void MacControlUserPaneBackgroundProc(void* info) = 0 ;
224 #endif
225 } ;
226
227 // common parts for implementations based on MLTE
228
229 class wxMacMLTEControl : public wxMacTextControl
230 {
231 public :
232 wxMacMLTEControl( wxTextCtrl *peer ) ;
233
234 virtual wxString GetStringValue() const ;
235 virtual void SetStringValue( const wxString &str ) ;
236
237 static TXNFrameOptions FrameOptionsFromWXStyle( long wxStyle ) ;
238
239 void AdjustCreationAttributes( const wxColour& background, bool visible ) ;
240
241 virtual void SetFont( const wxFont & font, const wxColour& foreground, long windowStyle ) ;
242 virtual void SetBackground( const wxBrush &brush ) ;
243 virtual void SetStyle( long start, long end, const wxTextAttr& style ) ;
244 virtual void Copy() ;
245 virtual void Cut() ;
246 virtual void Paste() ;
247 virtual bool CanPaste() const ;
248 virtual void SetEditable( bool editable ) ;
249 virtual wxTextPos GetLastPosition() const ;
250 virtual void Replace( long from, long to, const wxString &str ) ;
251 virtual void Remove( long from, long to ) ;
252 virtual void GetSelection( long* from, long* to ) const ;
253 virtual void SetSelection( long from, long to ) ;
254
255 virtual void WriteText( const wxString& str ) ;
256
257 virtual bool HasOwnContextMenu() const
258 {
259 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
260 if ( UMAGetSystemVersion() >= 0x1040 )
261 {
262 TXNCommandEventSupportOptions options ;
263 TXNGetCommandEventSupport( m_txn , & options ) ;
264 return options & kTXNSupportEditCommandProcessing ;
265 }
266 #endif
267
268 return false ;
269 }
270
271 virtual void Clear() ;
272
273 virtual bool CanUndo() const ;
274 virtual void Undo() ;
275 virtual bool CanRedo() const;
276 virtual void Redo() ;
277 virtual int GetNumberOfLines() const ;
278 virtual long XYToPosition(long x, long y) const ;
279 virtual bool PositionToXY(long pos, long *x, long *y) const ;
280 virtual void ShowPosition( long pos ) ;
281 virtual int GetLineLength(long lineNo) const ;
282 virtual wxString GetLineText(long lineNo) const ;
283
284 void SetTXNData( const wxString& st , TXNOffset start , TXNOffset end ) ;
285
286 protected :
287 void TXNSetAttribute( const wxTextAttr& style , long from , long to ) ;
288
289 TXNObject m_txn ;
290 } ;
291
292 #if TARGET_API_MAC_OSX
293
294 // implementation available under OSX
295
296 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
297
298 class wxMacMLTEHIViewControl : public wxMacMLTEControl
299 {
300 public :
301 wxMacMLTEHIViewControl( wxTextCtrl *wxPeer,
302 const wxString& str,
303 const wxPoint& pos,
304 const wxSize& size, long style ) ;
305 virtual OSStatus SetFocus( ControlFocusPart focusPart ) ;
306 virtual bool HasFocus() const ;
307 virtual void SetBackground( const wxBrush &brush) ;
308
309 protected :
310 HIViewRef m_scrollView ;
311 HIViewRef m_textView ;
312 };
313
314 #endif
315
316 class wxMacUnicodeTextControl : public wxMacTextControl
317 {
318 public :
319 wxMacUnicodeTextControl( wxTextCtrl *wxPeer,
320 const wxString& str,
321 const wxPoint& pos,
322 const wxSize& size, long style ) ;
323 ~wxMacUnicodeTextControl();
324
325 virtual void VisibilityChanged(bool shown);
326 virtual wxString GetStringValue() const ;
327 virtual void SetStringValue( const wxString &str) ;
328 virtual void Copy();
329 virtual void Cut();
330 virtual void Paste();
331 virtual bool CanPaste() const;
332 virtual void SetEditable(bool editable) ;
333 virtual void GetSelection( long* from, long* to) const ;
334 virtual void SetSelection( long from , long to ) ;
335 virtual void WriteText(const wxString& str) ;
336
337 protected :
338 // contains the tag for the content (is different for password and non-password controls)
339 OSType m_valueTag ;
340 };
341
342 #endif
343
344 // 'classic' MLTE implementation
345
346 class wxMacMLTEClassicControl : public wxMacMLTEControl
347 {
348 public :
349 wxMacMLTEClassicControl( wxTextCtrl *wxPeer,
350 const wxString& str,
351 const wxPoint& pos,
352 const wxSize& size, long style ) ;
353 ~wxMacMLTEClassicControl() ;
354
355 virtual void VisibilityChanged(bool shown) ;
356 virtual void SuperChangedPosition() ;
357
358 virtual void MacControlUserPaneDrawProc(wxInt16 part) ;
359 virtual wxInt16 MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y) ;
360 virtual wxInt16 MacControlUserPaneTrackingProc(wxInt16 x, wxInt16 y, void* actionProc) ;
361 virtual void MacControlUserPaneIdleProc() ;
362 virtual wxInt16 MacControlUserPaneKeyDownProc(wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers) ;
363 virtual void MacControlUserPaneActivateProc(bool activating) ;
364 virtual wxInt16 MacControlUserPaneFocusProc(wxInt16 action) ;
365 virtual void MacControlUserPaneBackgroundProc(void* info) ;
366
367 virtual bool SetupCursor( const wxPoint& WXUNUSED(pt) )
368 {
369 MacControlUserPaneIdleProc();
370 return true;
371 }
372
373 virtual void SetRect( Rect *r ) ;
374
375 protected :
376 OSStatus DoCreate();
377
378 void MacUpdatePosition() ;
379 void MacActivatePaneText(bool setActive) ;
380 void MacFocusPaneText(bool setFocus) ;
381 void MacSetObjectVisibility(bool vis) ;
382
383 private :
384 TXNFrameID m_txnFrameID ;
385 GrafPtr m_txnPort ;
386 WindowRef m_txnWindow ;
387 // bounds of the control as we last did set the txn frames
388 Rect m_txnControlBounds ;
389 Rect m_txnVisBounds ;
390
391 #ifdef __WXMAC_OSX__
392 static pascal void TXNScrollActionProc( ControlRef controlRef , ControlPartCode partCode ) ;
393 static pascal void TXNScrollInfoProc(
394 SInt32 iValue, SInt32 iMaximumValue,
395 TXNScrollBarOrientation iScrollBarOrientation, SInt32 iRefCon ) ;
396
397 ControlRef m_sbHorizontal ;
398 SInt32 m_lastHorizontalValue ;
399 ControlRef m_sbVertical ;
400 SInt32 m_lastVerticalValue ;
401 #endif
402 };
403
404
405 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
406
407 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
408 EVT_ERASE_BACKGROUND( wxTextCtrl::OnEraseBackground )
409 EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
410 EVT_CHAR(wxTextCtrl::OnChar)
411 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
412 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
413 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
414 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
415 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
416 EVT_MENU(wxID_CLEAR, wxTextCtrl::OnDelete)
417 EVT_MENU(wxID_SELECTALL, wxTextCtrl::OnSelectAll)
418
419 EVT_CONTEXT_MENU(wxTextCtrl::OnContextMenu)
420
421 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
422 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
423 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
424 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
425 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
426 EVT_UPDATE_UI(wxID_CLEAR, wxTextCtrl::OnUpdateDelete)
427 EVT_UPDATE_UI(wxID_SELECTALL, wxTextCtrl::OnUpdateSelectAll)
428 END_EVENT_TABLE()
429
430
431 void wxTextCtrl::Init()
432 {
433 m_editable = true ;
434 m_dirty = false;
435
436 m_maxLength = 0;
437 m_privateContextMenu = NULL;
438 }
439
440 wxTextCtrl::~wxTextCtrl()
441 {
442 delete m_privateContextMenu;
443 }
444
445 bool wxTextCtrl::Create( wxWindow *parent,
446 wxWindowID id,
447 const wxString& str,
448 const wxPoint& pos,
449 const wxSize& size,
450 long style,
451 const wxValidator& validator,
452 const wxString& name )
453 {
454 m_macIsUserPane = false ;
455 m_editable = true ;
456
457 if ( ! (style & wxNO_BORDER) )
458 style = (style & ~wxBORDER_MASK) | wxSUNKEN_BORDER ;
459
460 if ( !wxTextCtrlBase::Create( parent, id, pos, size, style & ~(wxHSCROLL | wxVSCROLL), validator, name ) )
461 return false;
462
463 if ( m_windowStyle & wxTE_MULTILINE )
464 {
465 wxASSERT_MSG(
466 !(m_windowStyle & wxTE_PROCESS_ENTER),
467 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
468
469 m_windowStyle |= wxTE_PROCESS_ENTER;
470 style |= wxTE_PROCESS_ENTER ;
471 }
472
473 bool forceMLTE = false ;
474
475 #if wxUSE_SYSTEM_OPTIONS
476 if (wxSystemOptions::HasOption( wxMAC_TEXTCONTROL_USE_MLTE ) && (wxSystemOptions::GetOptionInt( wxMAC_TEXTCONTROL_USE_MLTE ) == 1))
477 {
478 forceMLTE = true ;
479 }
480 #endif
481
482 #ifdef __WXMAC_OSX__
483 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
484 if ( UMAGetSystemVersion() >= 0x1030 && !forceMLTE )
485 {
486 if ( m_windowStyle & wxTE_MULTILINE )
487 m_peer = new wxMacMLTEHIViewControl( this , str , pos , size , style ) ;
488 }
489 #endif
490
491 if ( !m_peer )
492 {
493 if ( !(m_windowStyle & wxTE_MULTILINE) && !forceMLTE )
494 m_peer = new wxMacUnicodeTextControl( this , str , pos , size , style ) ;
495 }
496 #endif
497
498 if ( !m_peer )
499 m_peer = new wxMacMLTEClassicControl( this , str , pos , size , style ) ;
500
501 MacPostControlCreate(pos, size) ;
502
503 // only now the embedding is correct and we can do a positioning update
504
505 MacSuperChangedPosition() ;
506
507 if ( m_windowStyle & wxTE_READONLY)
508 SetEditable( false ) ;
509
510 SetCursor( wxCursor( wxCURSOR_IBEAM ) ) ;
511
512 return true;
513 }
514
515 void wxTextCtrl::MacSuperChangedPosition()
516 {
517 wxWindow::MacSuperChangedPosition() ;
518 GetPeer()->SuperChangedPosition() ;
519 }
520
521 void wxTextCtrl::MacVisibilityChanged()
522 {
523 GetPeer()->VisibilityChanged( MacIsReallyShown() ) ;
524 }
525
526 void wxTextCtrl::MacEnabledStateChanged()
527 {
528 }
529
530 wxString wxTextCtrl::GetValue() const
531 {
532 return GetPeer()->GetStringValue() ;
533 }
534
535 void wxTextCtrl::GetSelection(long* from, long* to) const
536 {
537 GetPeer()->GetSelection( from , to ) ;
538 }
539
540 void wxTextCtrl::SetValue(const wxString& str)
541 {
542 // optimize redraws
543 if ( GetValue() == str )
544 return ;
545
546 GetPeer()->SetStringValue( str ) ;
547
548 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, m_windowId );
549 event.SetString( GetValue() );
550 event.SetEventObject( this );
551 GetEventHandler()->ProcessEvent( event );
552 }
553
554 void wxTextCtrl::SetMaxLength(unsigned long len)
555 {
556 m_maxLength = len ;
557 }
558
559 bool wxTextCtrl::SetFont( const wxFont& font )
560 {
561 if ( !wxTextCtrlBase::SetFont( font ) )
562 return false ;
563
564 GetPeer()->SetFont( font , GetForegroundColour() , GetWindowStyle() ) ;
565
566 return true ;
567 }
568
569 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
570 {
571 GetPeer()->SetStyle( start , end , style ) ;
572
573 return true ;
574 }
575
576 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
577 {
578 wxTextCtrlBase::SetDefaultStyle( style ) ;
579 SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
580
581 return true ;
582 }
583
584 // Clipboard operations
585
586 void wxTextCtrl::Copy()
587 {
588 if (CanCopy())
589 GetPeer()->Copy() ;
590 }
591
592 void wxTextCtrl::Cut()
593 {
594 if (CanCut())
595 {
596 GetPeer()->Cut() ;
597
598 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, m_windowId );
599 event.SetEventObject( this );
600 GetEventHandler()->ProcessEvent( event );
601 }
602 }
603
604 void wxTextCtrl::Paste()
605 {
606 if (CanPaste())
607 {
608 GetPeer()->Paste() ;
609
610 // TODO: eventually we should add setting the default style again
611
612 wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, m_windowId );
613 event.SetEventObject( this );
614 GetEventHandler()->ProcessEvent( event );
615 }
616 }
617
618 bool wxTextCtrl::CanCopy() const
619 {
620 // Can copy if there's a selection
621 long from, to;
622 GetSelection( &from, &to );
623
624 return (from != to);
625 }
626
627 bool wxTextCtrl::CanCut() const
628 {
629 if ( !IsEditable() )
630 return false;
631
632 // Can cut if there's a selection
633 long from, to;
634 GetSelection( &from, &to );
635
636 return (from != to);
637 }
638
639 bool wxTextCtrl::CanPaste() const
640 {
641 if (!IsEditable())
642 return false;
643
644 return GetPeer()->CanPaste() ;
645 }
646
647 void wxTextCtrl::SetEditable(bool editable)
648 {
649 if ( editable != m_editable )
650 {
651 m_editable = editable ;
652 GetPeer()->SetEditable( editable ) ;
653 }
654 }
655
656 void wxTextCtrl::SetInsertionPoint(long pos)
657 {
658 SetSelection( pos , pos ) ;
659 }
660
661 void wxTextCtrl::SetInsertionPointEnd()
662 {
663 wxTextPos pos = GetLastPosition();
664 SetInsertionPoint( pos );
665 }
666
667 long wxTextCtrl::GetInsertionPoint() const
668 {
669 long begin, end ;
670 GetSelection( &begin , &end ) ;
671
672 return begin ;
673 }
674
675 wxTextPos wxTextCtrl::GetLastPosition() const
676 {
677 return GetPeer()->GetLastPosition() ;
678 }
679
680 void wxTextCtrl::Replace(long from, long to, const wxString& str)
681 {
682 GetPeer()->Replace( from , to , str ) ;
683 }
684
685 void wxTextCtrl::Remove(long from, long to)
686 {
687 GetPeer()->Remove( from , to ) ;
688 }
689
690 void wxTextCtrl::SetSelection(long from, long to)
691 {
692 GetPeer()->SetSelection( from , to ) ;
693 }
694
695 bool wxTextCtrl::LoadFile(const wxString& file)
696 {
697 return wxTextCtrlBase::LoadFile( file );
698 }
699
700 void wxTextCtrl::WriteText(const wxString& str)
701 {
702 // TODO: this MPRemoting will be moved into a remoting peer proxy for any command
703 if ( !wxIsMainThread() )
704 {
705 // unfortunately CW 8 is not able to correctly deduce the template types,
706 // so we have to instantiate explicitly
707 wxMacMPRemoteGUICall<wxTextCtrl,wxString>( this , &wxTextCtrl::WriteText , str ) ;
708
709 return ;
710 }
711
712 GetPeer()->WriteText( str ) ;
713 }
714
715 void wxTextCtrl::AppendText(const wxString& text)
716 {
717 SetInsertionPointEnd();
718 WriteText( text );
719 }
720
721 void wxTextCtrl::Clear()
722 {
723 GetPeer()->Clear() ;
724 }
725
726 bool wxTextCtrl::IsModified() const
727 {
728 return m_dirty;
729 }
730
731 bool wxTextCtrl::IsEditable() const
732 {
733 return IsEnabled() && m_editable ;
734 }
735
736 bool wxTextCtrl::AcceptsFocus() const
737 {
738 // we don't want focus if we can't be edited
739 return /*IsEditable() && */ wxControl::AcceptsFocus();
740 }
741
742 wxSize wxTextCtrl::DoGetBestSize() const
743 {
744 int wText, hText;
745
746 // these are the numbers from the HIG:
747 // we reduce them by the borders first
748 wText = 100 ;
749
750 switch ( m_windowVariant )
751 {
752 case wxWINDOW_VARIANT_NORMAL :
753 hText = 22 - 6 ;
754 break ;
755
756 case wxWINDOW_VARIANT_SMALL :
757 hText = 19 - 6 ;
758 break ;
759
760 case wxWINDOW_VARIANT_MINI :
761 hText = 15 - 6 ;
762 break ;
763
764 default :
765 hText = 22 - 6;
766 break ;
767 }
768
769 // as the above numbers have some free space around the text
770 // we get 5 lines like this anyway
771 if ( m_windowStyle & wxTE_MULTILINE )
772 hText *= 5 ;
773
774 if ( !HasFlag(wxNO_BORDER) )
775 hText += 6 ;
776
777 return wxSize(wText, hText);
778 }
779
780 // ----------------------------------------------------------------------------
781 // Undo/redo
782 // ----------------------------------------------------------------------------
783
784 void wxTextCtrl::Undo()
785 {
786 if (CanUndo())
787 GetPeer()->Undo() ;
788 }
789
790 void wxTextCtrl::Redo()
791 {
792 if (CanRedo())
793 GetPeer()->Redo() ;
794 }
795
796 bool wxTextCtrl::CanUndo() const
797 {
798 if ( !IsEditable() )
799 return false ;
800
801 return GetPeer()->CanUndo() ;
802 }
803
804 bool wxTextCtrl::CanRedo() const
805 {
806 if ( !IsEditable() )
807 return false ;
808
809 return GetPeer()->CanRedo() ;
810 }
811
812 void wxTextCtrl::MarkDirty()
813 {
814 m_dirty = true;
815 }
816
817 void wxTextCtrl::DiscardEdits()
818 {
819 m_dirty = false;
820 }
821
822 int wxTextCtrl::GetNumberOfLines() const
823 {
824 return GetPeer()->GetNumberOfLines() ;
825 }
826
827 long wxTextCtrl::XYToPosition(long x, long y) const
828 {
829 return GetPeer()->XYToPosition( x , y ) ;
830 }
831
832 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
833 {
834 return GetPeer()->PositionToXY( pos , x , y ) ;
835 }
836
837 void wxTextCtrl::ShowPosition(long pos)
838 {
839 return GetPeer()->ShowPosition(pos) ;
840 }
841
842 int wxTextCtrl::GetLineLength(long lineNo) const
843 {
844 return GetPeer()->GetLineLength(lineNo) ;
845 }
846
847 wxString wxTextCtrl::GetLineText(long lineNo) const
848 {
849 return GetPeer()->GetLineText(lineNo) ;
850 }
851
852 void wxTextCtrl::Command(wxCommandEvent & event)
853 {
854 SetValue(event.GetString());
855 ProcessCommand(event);
856 }
857
858 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
859 {
860 // By default, load the first file into the text window.
861 if (event.GetNumberOfFiles() > 0)
862 LoadFile( event.GetFiles()[0] );
863 }
864
865 void wxTextCtrl::OnEraseBackground(wxEraseEvent& event)
866 {
867 // all erasing should be done by the real mac control implementation
868 // while this is true for MLTE under classic, the HITextView is somehow
869 // transparent but background erase is not working correctly, so intercept
870 // things while we can...
871 event.Skip() ;
872 }
873
874 void wxTextCtrl::OnChar(wxKeyEvent& event)
875 {
876 int key = event.GetKeyCode() ;
877 bool eat_key = false ;
878
879 if ( key == 'c' && event.MetaDown() )
880 {
881 if ( CanCopy() )
882 Copy() ;
883
884 return ;
885 }
886
887 if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
888 !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
889 // && key != WXK_PAGEUP && key != WXK_PAGEDOWN && key != WXK_HOME && key != WXK_END
890 )
891 {
892 // eat it
893 return ;
894 }
895
896 // Check if we have reached the max # of chars (if it is set), but still
897 // allow navigation and deletion
898 if ( !IsMultiLine() && m_maxLength && GetValue().length() >= m_maxLength &&
899 key != WXK_LEFT && key != WXK_RIGHT && key != WXK_TAB &&
900 key != WXK_BACK && !( key == WXK_RETURN && (m_windowStyle & wxPROCESS_ENTER) )
901 )
902 {
903 // eat it, we don't want to add more than allowed # of characters
904
905 // TODO: generate EVT_TEXT_MAXLEN()
906 return;
907 }
908
909 // assume that any key not processed yet is going to modify the control
910 m_dirty = true;
911
912 if ( key == 'v' && event.MetaDown() )
913 {
914 if ( CanPaste() )
915 Paste() ;
916
917 return ;
918 }
919
920 if ( key == 'x' && event.MetaDown() )
921 {
922 if ( CanCut() )
923 Cut() ;
924
925 return ;
926 }
927
928 switch ( key )
929 {
930 case WXK_RETURN:
931 if (m_windowStyle & wxPROCESS_ENTER)
932 {
933 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
934 event.SetEventObject( this );
935 event.SetString( GetValue() );
936 if ( GetEventHandler()->ProcessEvent(event) )
937 return;
938 }
939
940 if ( !(m_windowStyle & wxTE_MULTILINE) )
941 {
942 wxWindow *parent = GetParent();
943 while ( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL )
944 {
945 parent = parent->GetParent() ;
946 }
947
948 if ( parent && parent->GetDefaultItem() )
949 {
950 wxButton *def = wxDynamicCast(parent->GetDefaultItem(), wxButton);
951 if ( def && def->IsEnabled() )
952 {
953 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
954 event.SetEventObject(def);
955 def->Command(event);
956
957 return ;
958 }
959 }
960
961 // this will make wxWidgets eat the ENTER key so that
962 // we actually prevent line wrapping in a single line text control
963 eat_key = true;
964 }
965 break;
966
967 case WXK_TAB:
968 if ( !(m_windowStyle & wxTE_PROCESS_TAB))
969 {
970 int flags = 0;
971 if (!event.ShiftDown())
972 flags |= wxNavigationKeyEvent::IsForward ;
973 if (event.ControlDown())
974 flags |= wxNavigationKeyEvent::WinChange ;
975 Navigate(flags);
976
977 return;
978 }
979 else
980 {
981 // This is necessary (don't know why);
982 // otherwise the tab will not be inserted.
983 WriteText(wxT("\t"));
984 }
985 break;
986
987 default:
988 break;
989 }
990
991 if (!eat_key)
992 {
993 // perform keystroke handling
994 event.Skip(true) ;
995 }
996
997 if ( ( key >= 0x20 && key < WXK_START ) ||
998 key == WXK_RETURN ||
999 key == WXK_DELETE ||
1000 key == WXK_BACK)
1001 {
1002 wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
1003 event1.SetEventObject( this );
1004 wxPostEvent( GetEventHandler(), event1 );
1005 }
1006 }
1007
1008 // ----------------------------------------------------------------------------
1009 // standard handlers for standard edit menu events
1010 // ----------------------------------------------------------------------------
1011
1012 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
1013 {
1014 Cut();
1015 }
1016
1017 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
1018 {
1019 Copy();
1020 }
1021
1022 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
1023 {
1024 Paste();
1025 }
1026
1027 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
1028 {
1029 Undo();
1030 }
1031
1032 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
1033 {
1034 Redo();
1035 }
1036
1037 void wxTextCtrl::OnDelete(wxCommandEvent& WXUNUSED(event))
1038 {
1039 long from, to;
1040
1041 GetSelection( &from, &to );
1042 if (from != -1 && to != -1)
1043 Remove( from, to );
1044 }
1045
1046 void wxTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
1047 {
1048 SetSelection(-1, -1);
1049 }
1050
1051 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
1052 {
1053 event.Enable( CanCut() );
1054 }
1055
1056 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
1057 {
1058 event.Enable( CanCopy() );
1059 }
1060
1061 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
1062 {
1063 event.Enable( CanPaste() );
1064 }
1065
1066 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
1067 {
1068 event.Enable( CanUndo() );
1069 }
1070
1071 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
1072 {
1073 event.Enable( CanRedo() );
1074 }
1075
1076 void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent& event)
1077 {
1078 long from, to;
1079
1080 GetSelection( &from, &to );
1081 event.Enable( from != -1 && to != -1 && from != to && IsEditable() ) ;
1082 }
1083
1084 void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
1085 {
1086 event.Enable(GetLastPosition() > 0);
1087 }
1088
1089 // CS: Context Menus only work with MLTE implementations or non-multiline HIViews at the moment
1090
1091 void wxTextCtrl::OnContextMenu(wxContextMenuEvent& event)
1092 {
1093 if ( GetPeer()->HasOwnContextMenu() )
1094 {
1095 event.Skip() ;
1096 return ;
1097 }
1098
1099 if (m_privateContextMenu == NULL)
1100 {
1101 m_privateContextMenu = new wxMenu;
1102 m_privateContextMenu->Append(wxID_UNDO, _("&Undo"));
1103 m_privateContextMenu->Append(wxID_REDO, _("&Redo"));
1104 m_privateContextMenu->AppendSeparator();
1105 m_privateContextMenu->Append(wxID_CUT, _("Cu&t"));
1106 m_privateContextMenu->Append(wxID_COPY, _("&Copy"));
1107 m_privateContextMenu->Append(wxID_PASTE, _("&Paste"));
1108 m_privateContextMenu->Append(wxID_CLEAR, _("&Delete"));
1109 m_privateContextMenu->AppendSeparator();
1110 m_privateContextMenu->Append(wxID_SELECTALL, _("Select &All"));
1111 }
1112
1113 if (m_privateContextMenu != NULL)
1114 PopupMenu(m_privateContextMenu);
1115 }
1116
1117 bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
1118 {
1119 if ( !GetPeer()->SetupCursor( pt ) )
1120 return wxWindow::MacSetupCursor( pt ) ;
1121 else
1122 return true ;
1123 }
1124
1125 #if !TARGET_API_MAC_OSX
1126
1127 // user pane implementation
1128
1129 void wxTextCtrl::MacControlUserPaneDrawProc(wxInt16 part)
1130 {
1131 GetPeer()->MacControlUserPaneDrawProc( part ) ;
1132 }
1133
1134 wxInt16 wxTextCtrl::MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y)
1135 {
1136 return GetPeer()->MacControlUserPaneHitTestProc( x , y ) ;
1137 }
1138
1139 wxInt16 wxTextCtrl::MacControlUserPaneTrackingProc(wxInt16 x, wxInt16 y, void* actionProc)
1140 {
1141 return GetPeer()->MacControlUserPaneTrackingProc( x , y , actionProc ) ;
1142 }
1143
1144 void wxTextCtrl::MacControlUserPaneIdleProc()
1145 {
1146 GetPeer()->MacControlUserPaneIdleProc( ) ;
1147 }
1148
1149 wxInt16 wxTextCtrl::MacControlUserPaneKeyDownProc(wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers)
1150 {
1151 return GetPeer()->MacControlUserPaneKeyDownProc( keyCode , charCode , modifiers ) ;
1152 }
1153
1154 void wxTextCtrl::MacControlUserPaneActivateProc(bool activating)
1155 {
1156 GetPeer()->MacControlUserPaneActivateProc( activating ) ;
1157 }
1158
1159 wxInt16 wxTextCtrl::MacControlUserPaneFocusProc(wxInt16 action)
1160 {
1161 return GetPeer()->MacControlUserPaneFocusProc( action ) ;
1162 }
1163
1164 void wxTextCtrl::MacControlUserPaneBackgroundProc(void* info)
1165 {
1166 GetPeer()->MacControlUserPaneBackgroundProc( info ) ;
1167 }
1168
1169 #endif
1170
1171 // ----------------------------------------------------------------------------
1172 // implementation base class
1173 // ----------------------------------------------------------------------------
1174
1175 wxMacTextControl::wxMacTextControl(wxTextCtrl* peer) :
1176 wxMacControl( peer )
1177 {
1178 }
1179
1180 wxMacTextControl::~wxMacTextControl()
1181 {
1182 }
1183
1184 void wxMacTextControl::SetStyle(long start, long end, const wxTextAttr& style)
1185 {
1186 }
1187
1188 void wxMacTextControl::Copy()
1189 {
1190 }
1191
1192 void wxMacTextControl::Cut()
1193 {
1194 }
1195
1196 void wxMacTextControl::Paste()
1197 {
1198 }
1199
1200 bool wxMacTextControl::CanPaste() const
1201 {
1202 return false ;
1203 }
1204
1205 void wxMacTextControl::SetEditable(bool editable)
1206 {
1207 }
1208
1209 wxTextPos wxMacTextControl::GetLastPosition() const
1210 {
1211 return GetStringValue().length() ;
1212 }
1213
1214 void wxMacTextControl::Replace( long from , long to , const wxString &val )
1215 {
1216 SetSelection( from , to ) ;
1217 WriteText( val ) ;
1218 }
1219
1220 void wxMacTextControl::Remove( long from , long to )
1221 {
1222 SetSelection( from , to ) ;
1223 WriteText( wxEmptyString) ;
1224 }
1225
1226 void wxMacTextControl::Clear()
1227 {
1228 SetStringValue( wxEmptyString ) ;
1229 }
1230
1231 bool wxMacTextControl::CanUndo() const
1232 {
1233 return false ;
1234 }
1235
1236 void wxMacTextControl::Undo()
1237 {
1238 }
1239
1240 bool wxMacTextControl::CanRedo() const
1241 {
1242 return false ;
1243 }
1244
1245 void wxMacTextControl::Redo()
1246 {
1247 }
1248
1249 long wxMacTextControl::XYToPosition(long x, long y) const
1250 {
1251 return 0 ;
1252 }
1253
1254 bool wxMacTextControl::PositionToXY(long pos, long *x, long *y) const
1255 {
1256 return false ;
1257 }
1258
1259 void wxMacTextControl::ShowPosition( long WXUNUSED(pos) )
1260 {
1261 }
1262
1263 int wxMacTextControl::GetNumberOfLines() const
1264 {
1265 ItemCount lines = 0 ;
1266 wxString content = GetStringValue() ;
1267 lines = 1;
1268
1269 for (size_t i = 0; i < content.length() ; i++)
1270 {
1271 if (content[i] == '\r')
1272 lines++;
1273 }
1274
1275 return lines ;
1276 }
1277
1278 wxString wxMacTextControl::GetLineText(long lineNo) const
1279 {
1280 // TODO: change this if possible to reflect real lines
1281 wxString content = GetStringValue() ;
1282
1283 // Find line first
1284 int count = 0;
1285 for (size_t i = 0; i < content.length() ; i++)
1286 {
1287 if (count == lineNo)
1288 {
1289 // Add chars in line then
1290 wxString tmp;
1291
1292 for (size_t j = i; j < content.length(); j++)
1293 {
1294 if (content[j] == '\n')
1295 return tmp;
1296
1297 tmp += content[j];
1298 }
1299
1300 return tmp;
1301 }
1302
1303 if (content[i] == '\n')
1304 count++;
1305 }
1306
1307 return wxEmptyString ;
1308 }
1309
1310 int wxMacTextControl::GetLineLength(long lineNo) const
1311 {
1312 // TODO: change this if possible to reflect real lines
1313 wxString content = GetStringValue() ;
1314
1315 // Find line first
1316 int count = 0;
1317 for (size_t i = 0; i < content.length() ; i++)
1318 {
1319 if (count == lineNo)
1320 {
1321 // Count chars in line then
1322 count = 0;
1323 for (size_t j = i; j < content.length(); j++)
1324 {
1325 count++;
1326 if (content[j] == '\n')
1327 return count;
1328 }
1329
1330 return count;
1331 }
1332
1333 if (content[i] == '\n')
1334 count++;
1335 }
1336
1337 return 0 ;
1338 }
1339
1340 // ----------------------------------------------------------------------------
1341 // standard unicode control implementation
1342 // ----------------------------------------------------------------------------
1343
1344 #if TARGET_API_MAC_OSX
1345
1346 wxMacUnicodeTextControl::wxMacUnicodeTextControl( wxTextCtrl *wxPeer,
1347 const wxString& str,
1348 const wxPoint& pos,
1349 const wxSize& size, long style )
1350 : wxMacTextControl( wxPeer )
1351 {
1352 m_font = wxPeer->GetFont() ;
1353 m_windowStyle = style ;
1354 Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
1355 wxString st = str ;
1356 wxMacConvertNewlines10To13( &st ) ;
1357 wxMacCFStringHolder cf(st , m_font.GetEncoding()) ;
1358 CFStringRef cfr = cf ;
1359 Boolean isPassword = ( m_windowStyle & wxTE_PASSWORD ) != 0 ;
1360 m_valueTag = isPassword ? kControlEditTextPasswordCFStringTag : kControlEditTextCFStringTag ;
1361
1362 OSStatus err = CreateEditUnicodeTextControl(
1363 MAC_WXHWND(wxPeer->MacGetTopLevelWindowRef()), &bounds , cfr ,
1364 isPassword , NULL , &m_controlRef ) ;
1365 verify_noerr( err );
1366
1367 if ( !(m_windowStyle & wxTE_MULTILINE) )
1368 SetData<Boolean>( kControlEditTextPart , kControlEditTextSingleLineTag , true ) ;
1369 }
1370
1371 wxMacUnicodeTextControl::~wxMacUnicodeTextControl()
1372 {
1373 }
1374
1375 void wxMacUnicodeTextControl::VisibilityChanged(bool shown)
1376 {
1377 if ( !(m_windowStyle & wxTE_MULTILINE) && shown )
1378 {
1379 // work around a refresh issue insofar as not always the entire content is shown,
1380 // even if this would be possible
1381 ControlEditTextSelectionRec sel ;
1382 CFStringRef value = NULL ;
1383
1384 verify_noerr( GetData<ControlEditTextSelectionRec>( 0, kControlEditTextSelectionTag, &sel ) );
1385 verify_noerr( GetData<CFStringRef>( 0, m_valueTag, &value ) );
1386 verify_noerr( SetData<CFStringRef>( 0, m_valueTag, &value ) );
1387 verify_noerr( SetData<ControlEditTextSelectionRec>( 0, kControlEditTextSelectionTag, &sel ) );
1388
1389 CFRelease( value ) ;
1390 }
1391 }
1392
1393 wxString wxMacUnicodeTextControl::GetStringValue() const
1394 {
1395 wxString result ;
1396 CFStringRef value = GetData<CFStringRef>(0, m_valueTag) ;
1397 if ( value )
1398 {
1399 wxMacCFStringHolder cf(value) ;
1400 result = cf.AsString() ;
1401 }
1402
1403 #if '\n' == 10
1404 wxMacConvertNewlines13To10( &result ) ;
1405 #else
1406 wxMacConvertNewlines10To13( &result ) ;
1407 #endif
1408
1409 return result ;
1410 }
1411
1412 void wxMacUnicodeTextControl::SetStringValue( const wxString &str )
1413 {
1414 wxString st = str ;
1415 wxMacConvertNewlines10To13( &st ) ;
1416 wxMacCFStringHolder cf( st , m_font.GetEncoding() ) ;
1417 verify_noerr( SetData<CFStringRef>( 0, m_valueTag , cf ) ) ;
1418 }
1419
1420 void wxMacUnicodeTextControl::Copy()
1421 {
1422 SendHICommand( kHICommandCopy ) ;
1423 }
1424
1425 void wxMacUnicodeTextControl::Cut()
1426 {
1427 SendHICommand( kHICommandCut ) ;
1428 }
1429
1430 void wxMacUnicodeTextControl::Paste()
1431 {
1432 SendHICommand( kHICommandPaste ) ;
1433 }
1434
1435 bool wxMacUnicodeTextControl::CanPaste() const
1436 {
1437 return true ;
1438 }
1439
1440 void wxMacUnicodeTextControl::SetEditable(bool editable)
1441 {
1442 #if 0 // leads to problem because text cannot be selected anymore
1443 SetData<Boolean>( kControlEditTextPart , kControlEditTextLockedTag , (Boolean) !editable ) ;
1444 #endif
1445 }
1446
1447 void wxMacUnicodeTextControl::GetSelection( long* from, long* to ) const
1448 {
1449 ControlEditTextSelectionRec sel ;
1450 verify_noerr( GetData<ControlEditTextSelectionRec>( 0, kControlEditTextSelectionTag, &sel ) ) ;
1451 if ( from )
1452 *from = sel.selStart ;
1453 if ( to )
1454 *to = sel.selEnd ;
1455 }
1456
1457 void wxMacUnicodeTextControl::SetSelection( long from , long to )
1458 {
1459 ControlEditTextSelectionRec sel ;
1460 if ((from == -1) && (to == -1))
1461 {
1462 from = 0 ;
1463 to = 32767 ; // sel has 16 bit signed values, max is 32767
1464 }
1465
1466 sel.selStart = from ;
1467 sel.selEnd = to ;
1468 SetData<ControlEditTextSelectionRec>( 0, kControlEditTextSelectionTag, &sel ) ;
1469 }
1470
1471 void wxMacUnicodeTextControl::WriteText( const wxString& str )
1472 {
1473 wxString st = str ;
1474 wxMacConvertNewlines10To13( &st ) ;
1475
1476 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
1477 wxMacCFStringHolder cf(st , m_font.GetEncoding() ) ;
1478 CFStringRef value = cf ;
1479 SetData<CFStringRef>( 0, kControlEditTextInsertCFStringRefTag, &value );
1480 #else
1481 wxString val = GetStringValue() ;
1482 long start , end ;
1483 GetSelection( &start , &end ) ;
1484 val.Remove( start , end - start ) ;
1485 val.insert( start , str ) ;
1486 SetStringValue( val ) ;
1487 SetSelection( start + str.length() , start + str.length() ) ;
1488 #endif
1489 }
1490
1491 #endif
1492
1493 // ----------------------------------------------------------------------------
1494 // MLTE control implementation (common part)
1495 // ----------------------------------------------------------------------------
1496
1497 // if MTLE is read only, no changes at all are allowed, not even from
1498 // procedural API, in order to allow changes via API all the same we must undo
1499 // the readonly status while we are executing, this class helps to do so
1500
1501 class wxMacEditHelper
1502 {
1503 public :
1504 wxMacEditHelper( TXNObject txn )
1505 {
1506 TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1507 m_txn = txn ;
1508 TXNGetTXNObjectControls( m_txn , 1 , tag , m_data ) ;
1509 if ( m_data[0].uValue == kTXNReadOnly )
1510 {
1511 TXNControlData data[] = { { kTXNReadWrite } } ;
1512 TXNSetTXNObjectControls( m_txn , false , 1 , tag , data ) ;
1513 }
1514 }
1515
1516 ~wxMacEditHelper()
1517 {
1518 TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1519 if ( m_data[0].uValue == kTXNReadOnly )
1520 TXNSetTXNObjectControls( m_txn , false , 1 , tag , m_data ) ;
1521 }
1522
1523 protected :
1524 TXNObject m_txn ;
1525 TXNControlData m_data[1] ;
1526 } ;
1527
1528 wxMacMLTEControl::wxMacMLTEControl( wxTextCtrl *peer )
1529 : wxMacTextControl( peer )
1530 {
1531 SetNeedsFocusRect( true ) ;
1532 }
1533
1534 wxString wxMacMLTEControl::GetStringValue() const
1535 {
1536 wxString result ;
1537 OSStatus err ;
1538 Size actualSize = 0;
1539
1540 {
1541 #if wxUSE_UNICODE
1542 Handle theText ;
1543 err = TXNGetDataEncoded( m_txn, kTXNStartOffset, kTXNEndOffset, &theText, kTXNUnicodeTextData );
1544
1545 // all done
1546 if ( err != noErr )
1547 {
1548 actualSize = 0 ;
1549 }
1550 else
1551 {
1552 actualSize = GetHandleSize( theText ) / sizeof(UniChar) ;
1553 if ( actualSize > 0 )
1554 {
1555 wxChar *ptr = NULL ;
1556
1557 #if SIZEOF_WCHAR_T == 2
1558 ptr = new wxChar[actualSize + 1] ;
1559 wxStrncpy( ptr , (wxChar*)(*theText) , actualSize ) ;
1560 #else
1561 SetHandleSize( theText, (actualSize + 1) * sizeof(UniChar) ) ;
1562 HLock( theText ) ;
1563 (((UniChar*)*theText)[actualSize]) = 0 ;
1564 wxMBConvUTF16 converter ;
1565 size_t noChars = converter.MB2WC( NULL , (const char*)*theText , 0 ) ;
1566 ptr = new wxChar[noChars + 1] ;
1567
1568 noChars = converter.MB2WC( ptr , (const char*)*theText , noChars ) ;
1569 ptr[noChars] = 0 ;
1570 HUnlock( theText ) ;
1571 #endif
1572
1573 ptr[actualSize] = 0 ;
1574 result = wxString( ptr ) ;
1575 delete [] ptr ;
1576 }
1577
1578 DisposeHandle( theText ) ;
1579 }
1580 #else
1581 Handle theText ;
1582 err = TXNGetDataEncoded( m_txn , kTXNStartOffset, kTXNEndOffset, &theText, kTXNTextData );
1583
1584 // all done
1585 if ( err != noErr )
1586 {
1587 actualSize = 0 ;
1588 }
1589 else
1590 {
1591 actualSize = GetHandleSize( theText ) ;
1592 if ( actualSize > 0 )
1593 {
1594 HLock( theText ) ;
1595 result = wxString( *theText , wxConvLocal , actualSize ) ;
1596 HUnlock( theText ) ;
1597 }
1598
1599 DisposeHandle( theText ) ;
1600 }
1601 #endif
1602 }
1603
1604 #if '\n' == 10
1605 wxMacConvertNewlines13To10( &result ) ;
1606 #else
1607 wxMacConvertNewlines10To13( &result ) ;
1608 #endif
1609
1610 return result ;
1611 }
1612
1613 void wxMacMLTEControl::SetStringValue( const wxString &str )
1614 {
1615 wxString st = str;
1616 wxMacConvertNewlines10To13( &st );
1617
1618 {
1619 wxMacWindowClipper c( m_peer );
1620
1621 {
1622 wxMacEditHelper help( m_txn );
1623 SetTXNData( st, kTXNStartOffset, kTXNEndOffset );
1624 }
1625
1626 TXNSetSelection( m_txn, 0, 0 );
1627 TXNShowSelection( m_txn, kTXNShowStart );
1628 }
1629 }
1630
1631 TXNFrameOptions wxMacMLTEControl::FrameOptionsFromWXStyle( long wxStyle )
1632 {
1633 TXNFrameOptions frameOptions = kTXNDontDrawCaretWhenInactiveMask;
1634
1635 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
1636 frameOptions |= kTXNDoFontSubstitutionMask;
1637 #endif
1638
1639 if ( ! (wxStyle & wxTE_NOHIDESEL) )
1640 frameOptions |= kTXNDontDrawSelectionWhenInactiveMask ;
1641
1642 if ( wxStyle & (wxHSCROLL | wxTE_DONTWRAP) )
1643 frameOptions |= kTXNWantHScrollBarMask ;
1644
1645 if ( wxStyle & wxTE_MULTILINE )
1646 {
1647 frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
1648
1649 if ( !(wxStyle & wxTE_NO_VSCROLL) )
1650 {
1651 frameOptions |= kTXNWantVScrollBarMask ;
1652
1653 // The following code causes drawing problems on 10.4. Perhaps it can be restored for
1654 // older versions of the OS, but I'm not sure it's appropriate to put a grow icon here
1655 // anyways, as AFAIK users can't actually use it to resize the text ctrl.
1656 // if ( frameOptions & kTXNWantHScrollBarMask )
1657 // frameOptions |= kTXNDrawGrowIconMask ;
1658 }
1659 }
1660 else
1661 {
1662 frameOptions |= kTXNSingleLineOnlyMask ;
1663 }
1664
1665 return frameOptions ;
1666 }
1667
1668 void wxMacMLTEControl::AdjustCreationAttributes( const wxColour &background, bool visible )
1669 {
1670 TXNControlTag iControlTags[] =
1671 {
1672 kTXNDoFontSubstitution,
1673 kTXNWordWrapStateTag ,
1674 };
1675 TXNControlData iControlData[] =
1676 {
1677 { true },
1678 { kTXNNoAutoWrap },
1679 };
1680
1681 int toptag = WXSIZEOF( iControlTags ) ;
1682
1683 if ( m_windowStyle & wxTE_MULTILINE )
1684 {
1685 iControlData[1].uValue =
1686 (m_windowStyle & wxTE_DONTWRAP)
1687 ? kTXNNoAutoWrap
1688 : kTXNAutoWrap;
1689 }
1690
1691 OSStatus err = TXNSetTXNObjectControls( m_txn, false, toptag, iControlTags, iControlData ) ;
1692 verify_noerr( err );
1693
1694 // setting the default font:
1695 // under 10.2 this causes a visible caret, therefore we avoid it
1696
1697 if ( UMAGetSystemVersion() >= 0x1030 )
1698 {
1699 Str255 fontName ;
1700 SInt16 fontSize ;
1701 Style fontStyle ;
1702
1703 GetThemeFont( kThemeSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
1704
1705 TXNTypeAttributes typeAttr[] =
1706 {
1707 { kTXNQDFontNameAttribute , kTXNQDFontNameAttributeSize , { (void*) fontName } } ,
1708 { kTXNQDFontSizeAttribute , kTXNFontSizeAttributeSize , { (void*) (fontSize << 16) } } ,
1709 { kTXNQDFontStyleAttribute , kTXNQDFontStyleAttributeSize , { (void*) normal } } ,
1710 } ;
1711
1712 err = TXNSetTypeAttributes(
1713 m_txn, sizeof(typeAttr) / sizeof(TXNTypeAttributes),
1714 typeAttr, kTXNStartOffset, kTXNEndOffset );
1715 verify_noerr( err );
1716 }
1717
1718 if ( m_windowStyle & wxTE_PASSWORD )
1719 {
1720 UniChar c = 0x00A5 ;
1721 err = TXNEchoMode( m_txn , c , 0 , true );
1722 verify_noerr( err );
1723 }
1724
1725 TXNBackground tback;
1726 tback.bgType = kTXNBackgroundTypeRGB;
1727 tback.bg.color = MAC_WXCOLORREF( background.GetPixel() );
1728 TXNSetBackground( m_txn , &tback );
1729
1730 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
1731 if ( UMAGetSystemVersion() >= 0x1040 )
1732 {
1733 TXNCommandEventSupportOptions options ;
1734 if ( TXNGetCommandEventSupport( m_txn, &options ) == noErr )
1735 {
1736 options |=
1737 kTXNSupportEditCommandProcessing
1738 | kTXNSupportEditCommandUpdating
1739 | kTXNSupportSpellCheckCommandProcessing
1740 | kTXNSupportSpellCheckCommandUpdating
1741 | kTXNSupportFontCommandProcessing
1742 | kTXNSupportFontCommandUpdating;
1743
1744 TXNSetCommandEventSupport( m_txn , options ) ;
1745 }
1746 }
1747 #endif
1748 }
1749
1750 void wxMacMLTEControl::SetBackground( const wxBrush &brush )
1751 {
1752 // currently only solid background are supported
1753 TXNBackground tback;
1754
1755 tback.bgType = kTXNBackgroundTypeRGB;
1756 tback.bg.color = MAC_WXCOLORREF( brush.GetColour().GetPixel() );
1757 TXNSetBackground( m_txn , &tback );
1758 }
1759
1760 void wxMacMLTEControl::TXNSetAttribute( const wxTextAttr& style , long from , long to )
1761 {
1762 TXNTypeAttributes typeAttr[4] ;
1763 Str255 fontName = "\pMonaco" ;
1764 SInt16 fontSize = 12 ;
1765 Style fontStyle = normal ;
1766 RGBColor color ;
1767 int attrCount = 0 ;
1768
1769 if ( style.HasFont() )
1770 {
1771 const wxFont &font = style.GetFont() ;
1772 wxMacStringToPascal( font.GetFaceName() , fontName ) ;
1773 fontSize = font.GetPointSize() ;
1774 if ( font.GetUnderlined() )
1775 fontStyle |= underline ;
1776 if ( font.GetWeight() == wxBOLD )
1777 fontStyle |= bold ;
1778 if ( font.GetStyle() == wxITALIC )
1779 fontStyle |= italic ;
1780
1781 typeAttr[attrCount].tag = kTXNQDFontNameAttribute ;
1782 typeAttr[attrCount].size = kTXNQDFontNameAttributeSize ;
1783 typeAttr[attrCount].data.dataPtr = (void*)fontName ;
1784 attrCount++ ;
1785
1786 typeAttr[attrCount].tag = kTXNQDFontSizeAttribute ;
1787 typeAttr[attrCount].size = kTXNFontSizeAttributeSize ;
1788 typeAttr[attrCount].data.dataValue = (fontSize << 16) ;
1789 attrCount++ ;
1790
1791 typeAttr[attrCount].tag = kTXNQDFontStyleAttribute ;
1792 typeAttr[attrCount].size = kTXNQDFontStyleAttributeSize ;
1793 typeAttr[attrCount].data.dataValue = fontStyle ;
1794 attrCount++ ;
1795 }
1796
1797 if ( style.HasTextColour() )
1798 {
1799 color = MAC_WXCOLORREF(style.GetTextColour().GetPixel()) ;
1800
1801 typeAttr[attrCount].tag = kTXNQDFontColorAttribute ;
1802 typeAttr[attrCount].size = kTXNQDFontColorAttributeSize ;
1803 typeAttr[attrCount].data.dataPtr = (void*) &color ;
1804 attrCount++ ;
1805 }
1806
1807 if ( attrCount > 0 )
1808 {
1809 verify_noerr( TXNSetTypeAttributes( m_txn , attrCount , typeAttr, from , to ) );
1810 }
1811 }
1812
1813 void wxMacMLTEControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
1814 {
1815 wxMacEditHelper help( m_txn ) ;
1816 TXNSetAttribute( wxTextAttr( foreground, wxNullColour, font ), kTXNStartOffset, kTXNEndOffset ) ;
1817 }
1818
1819 void wxMacMLTEControl::SetStyle( long start, long end, const wxTextAttr& style )
1820 {
1821 wxMacEditHelper help( m_txn ) ;
1822 TXNSetAttribute( style, start, end ) ;
1823 }
1824
1825 void wxMacMLTEControl::Copy()
1826 {
1827 ClearCurrentScrap();
1828 TXNCopy( m_txn );
1829 TXNConvertToPublicScrap();
1830 }
1831
1832 void wxMacMLTEControl::Cut()
1833 {
1834 ClearCurrentScrap();
1835 TXNCut( m_txn );
1836 TXNConvertToPublicScrap();
1837 }
1838
1839 void wxMacMLTEControl::Paste()
1840 {
1841 TXNConvertFromPublicScrap();
1842 TXNPaste( m_txn );
1843 }
1844
1845 bool wxMacMLTEControl::CanPaste() const
1846 {
1847 return TXNIsScrapPastable() ;
1848 }
1849
1850 void wxMacMLTEControl::SetEditable(bool editable)
1851 {
1852 TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1853 TXNControlData data[] = { { editable ? kTXNReadWrite : kTXNReadOnly } } ;
1854 TXNSetTXNObjectControls( m_txn, false, WXSIZEOF(tag), tag, data ) ;
1855 }
1856
1857 wxTextPos wxMacMLTEControl::GetLastPosition() const
1858 {
1859 wxTextPos actualsize = 0 ;
1860
1861 Handle theText ;
1862 OSErr err = TXNGetDataEncoded( m_txn, kTXNStartOffset, kTXNEndOffset, &theText, kTXNTextData );
1863
1864 // all done
1865 if ( err == noErr )
1866 {
1867 actualsize = GetHandleSize( theText ) ;
1868 DisposeHandle( theText ) ;
1869 }
1870 else
1871 {
1872 actualsize = 0 ;
1873 }
1874
1875 return actualsize ;
1876 }
1877
1878 void wxMacMLTEControl::Replace( long from , long to , const wxString &str )
1879 {
1880 wxString value = str ;
1881 wxMacConvertNewlines10To13( &value ) ;
1882
1883 wxMacEditHelper help( m_txn ) ;
1884 wxMacWindowClipper c( m_peer ) ;
1885
1886 TXNSetSelection( m_txn, from, to ) ;
1887 TXNClear( m_txn ) ;
1888 SetTXNData( value, kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
1889 }
1890
1891 void wxMacMLTEControl::Remove( long from , long to )
1892 {
1893 wxMacWindowClipper c( m_peer ) ;
1894 wxMacEditHelper help( m_txn ) ;
1895 TXNSetSelection( m_txn , from , to ) ;
1896 TXNClear( m_txn ) ;
1897 }
1898
1899 void wxMacMLTEControl::GetSelection( long* from, long* to) const
1900 {
1901 TXNGetSelection( m_txn , (TXNOffset*) from , (TXNOffset*) to ) ;
1902 }
1903
1904 void wxMacMLTEControl::SetSelection( long from , long to )
1905 {
1906 wxMacWindowClipper c( m_peer ) ;
1907
1908 // change the selection
1909 if ((from == -1) && (to == -1))
1910 TXNSelectAll( m_txn );
1911 else
1912 TXNSetSelection( m_txn, from, to );
1913
1914 TXNShowSelection( m_txn, kTXNShowStart );
1915 }
1916
1917 void wxMacMLTEControl::WriteText( const wxString& str )
1918 {
1919 wxString st = str ;
1920 wxMacConvertNewlines10To13( &st ) ;
1921
1922 long start , end , dummy ;
1923
1924 GetSelection( &start , &dummy ) ;
1925 wxMacWindowClipper c( m_peer ) ;
1926
1927 {
1928 wxMacEditHelper helper( m_txn ) ;
1929 SetTXNData( st, kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
1930 }
1931
1932 GetSelection( &dummy, &end ) ;
1933
1934 // TODO: SetStyle( start , end , GetDefaultStyle() ) ;
1935 }
1936
1937 void wxMacMLTEControl::Clear()
1938 {
1939 wxMacWindowClipper c( m_peer ) ;
1940 wxMacEditHelper st( m_txn ) ;
1941 TXNSetSelection( m_txn , kTXNStartOffset , kTXNEndOffset ) ;
1942 TXNClear( m_txn ) ;
1943 }
1944
1945 bool wxMacMLTEControl::CanUndo() const
1946 {
1947 return TXNCanUndo( m_txn , NULL ) ;
1948 }
1949
1950 void wxMacMLTEControl::Undo()
1951 {
1952 TXNUndo( m_txn ) ;
1953 }
1954
1955 bool wxMacMLTEControl::CanRedo() const
1956 {
1957 return TXNCanRedo( m_txn , NULL ) ;
1958 }
1959
1960 void wxMacMLTEControl::Redo()
1961 {
1962 TXNRedo( m_txn ) ;
1963 }
1964
1965 int wxMacMLTEControl::GetNumberOfLines() const
1966 {
1967 ItemCount lines = 0 ;
1968 TXNGetLineCount( m_txn, &lines ) ;
1969
1970 return lines ;
1971 }
1972
1973 long wxMacMLTEControl::XYToPosition(long x, long y) const
1974 {
1975 Point curpt ;
1976 wxTextPos lastpos ;
1977
1978 // TODO: find a better implementation : while we can get the
1979 // line metrics of a certain line, we don't get its starting
1980 // position, so it would probably be rather a binary search
1981 // for the start position
1982 long xpos = 0, ypos = 0 ;
1983 int lastHeight = 0 ;
1984 ItemCount n ;
1985
1986 lastpos = GetLastPosition() ;
1987 for ( n = 0 ; n <= (ItemCount) lastpos ; ++n )
1988 {
1989 if ( y == ypos && x == xpos )
1990 return n ;
1991
1992 TXNOffsetToPoint( m_txn, n, &curpt ) ;
1993
1994 if ( curpt.v > lastHeight )
1995 {
1996 xpos = 0 ;
1997 if ( n > 0 )
1998 ++ypos ;
1999
2000 lastHeight = curpt.v ;
2001 }
2002 else
2003 ++xpos ;
2004 }
2005
2006 return 0 ;
2007 }
2008
2009 bool wxMacMLTEControl::PositionToXY( long pos, long *x, long *y ) const
2010 {
2011 Point curpt ;
2012 wxTextPos lastpos ;
2013
2014 if ( y )
2015 *y = 0 ;
2016 if ( x )
2017 *x = 0 ;
2018
2019 lastpos = GetLastPosition() ;
2020 if ( pos <= lastpos )
2021 {
2022 // TODO: find a better implementation - while we can get the
2023 // line metrics of a certain line, we don't get its starting
2024 // position, so it would probably be rather a binary search
2025 // for the start position
2026 long xpos = 0, ypos = 0 ;
2027 int lastHeight = 0 ;
2028 ItemCount n ;
2029
2030 for ( n = 0 ; n <= (ItemCount) pos ; ++n )
2031 {
2032 TXNOffsetToPoint( m_txn, n, &curpt ) ;
2033
2034 if ( curpt.v > lastHeight )
2035 {
2036 xpos = 0 ;
2037 if ( n > 0 )
2038 ++ypos ;
2039
2040 lastHeight = curpt.v ;
2041 }
2042 else
2043 ++xpos ;
2044 }
2045
2046 if ( y )
2047 *y = ypos ;
2048 if ( x )
2049 *x = xpos ;
2050 }
2051
2052 return false ;
2053 }
2054
2055 void wxMacMLTEControl::ShowPosition( long pos )
2056 {
2057 #if TARGET_RT_MAC_MACHO && defined(AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER)
2058 {
2059 Point current, desired ;
2060 TXNOffset selstart, selend;
2061
2062 TXNGetSelection( m_txn, &selstart, &selend );
2063 TXNOffsetToPoint( m_txn, selstart, &current );
2064 TXNOffsetToPoint( m_txn, pos, &desired );
2065
2066 // TODO: use HIPoints for 10.3 and above
2067 if ( (UInt32)TXNScroll != (UInt32)kUnresolvedCFragSymbolAddress )
2068 {
2069 OSErr theErr = noErr;
2070 SInt32 dv = desired.v - current.v;
2071 SInt32 dh = desired.h - current.h;
2072 TXNShowSelection( m_txn, kTXNShowStart ) ; // NB: should this be kTXNShowStart or kTXNShowEnd ??
2073 theErr = TXNScroll( m_txn, kTXNScrollUnitsInPixels, kTXNScrollUnitsInPixels, &dv, &dh );
2074
2075 // there will be an error returned for classic MLTE implementation when the control is
2076 // invisible, but HITextView works correctly, so we don't assert that one
2077 // wxASSERT_MSG( theErr == noErr, _T("TXNScroll returned an error!") );
2078 }
2079 }
2080 #endif
2081 }
2082
2083 void wxMacMLTEControl::SetTXNData( const wxString& st, TXNOffset start, TXNOffset end )
2084 {
2085 #if wxUSE_UNICODE
2086 #if SIZEOF_WCHAR_T == 2
2087 size_t len = st.Len() ;
2088 TXNSetData( m_txn, kTXNUnicodeTextData, (void*)st.wc_str(), len * 2, start, end );
2089 #else
2090 wxMBConvUTF16 converter ;
2091 ByteCount byteBufferLen = converter.WC2MB( NULL, st.wc_str(), 0 ) ;
2092 UniChar *unibuf = (UniChar*)malloc( byteBufferLen ) ;
2093 converter.WC2MB( (char*)unibuf, st.wc_str(), byteBufferLen ) ;
2094 TXNSetData( m_txn, kTXNUnicodeTextData, (void*)unibuf, byteBufferLen, start, end ) ;
2095 free( unibuf ) ;
2096 #endif
2097 #else
2098 wxCharBuffer text = st.mb_str( wxConvLocal ) ;
2099 TXNSetData( m_txn, kTXNTextData, (void*)text.data(), strlen( text ), start, end ) ;
2100 #endif
2101 }
2102
2103 wxString wxMacMLTEControl::GetLineText(long lineNo) const
2104 {
2105 wxString line ;
2106
2107 if ( lineNo < GetNumberOfLines() )
2108 {
2109 Point firstPoint;
2110 Fixed lineWidth, lineHeight, currentHeight;
2111 long ypos ;
2112
2113 // get the first possible position in the control
2114 TXNOffsetToPoint(m_txn, 0, &firstPoint);
2115
2116 // Iterate through the lines until we reach the one we want,
2117 // adding to our current y pixel point position
2118 ypos = 0 ;
2119 currentHeight = 0;
2120 while (ypos < lineNo)
2121 {
2122 TXNGetLineMetrics(m_txn, ypos++, &lineWidth, &lineHeight);
2123 currentHeight += lineHeight;
2124 }
2125
2126 Point thePoint = { firstPoint.v + (currentHeight >> 16), firstPoint.h + (0) };
2127 TXNOffset theOffset;
2128 TXNPointToOffset(m_txn, thePoint, &theOffset);
2129
2130 wxString content = GetStringValue() ;
2131 Point currentPoint = thePoint;
2132 while (thePoint.v == currentPoint.v && theOffset < content.length())
2133 {
2134 line += content[theOffset];
2135 TXNOffsetToPoint(m_txn, ++theOffset, &currentPoint);
2136 }
2137 }
2138
2139 return line ;
2140 }
2141
2142 int wxMacMLTEControl::GetLineLength(long lineNo) const
2143 {
2144 int theLength = 0;
2145
2146 if ( lineNo < GetNumberOfLines() )
2147 {
2148 Point firstPoint;
2149 Fixed lineWidth, lineHeight, currentHeight;
2150 long ypos;
2151
2152 // get the first possible position in the control
2153 TXNOffsetToPoint(m_txn, 0, &firstPoint);
2154
2155 // Iterate through the lines until we reach the one we want,
2156 // adding to our current y pixel point position
2157 ypos = 0;
2158 currentHeight = 0;
2159 while (ypos < lineNo)
2160 {
2161 TXNGetLineMetrics(m_txn, ypos++, &lineWidth, &lineHeight);
2162 currentHeight += lineHeight;
2163 }
2164
2165 Point thePoint = { firstPoint.v + (currentHeight >> 16), firstPoint.h + (0) };
2166 TXNOffset theOffset;
2167 TXNPointToOffset(m_txn, thePoint, &theOffset);
2168
2169 wxString content = GetStringValue() ;
2170 Point currentPoint = thePoint;
2171 while (thePoint.v == currentPoint.v && theOffset < content.length())
2172 {
2173 ++theLength;
2174 TXNOffsetToPoint(m_txn, ++theOffset, &currentPoint);
2175 }
2176 }
2177
2178 return theLength ;
2179 }
2180
2181 // ----------------------------------------------------------------------------
2182 // MLTE control implementation (classic part)
2183 // ----------------------------------------------------------------------------
2184
2185 // OS X Notes : We still don't have a full replacement for MLTE, so this implementation
2186 // has to live on. We have different problems coming from outdated implementations on the
2187 // various OS X versions. Most deal with the scrollbars: they are not correctly embedded
2188 // while this can be solved on 10.3 by reassigning them the correct place, on 10.2 there is
2189 // no way out, therefore we are using our own implementation and our own scrollbars ....
2190
2191 #ifdef __WXMAC_OSX__
2192
2193 TXNScrollInfoUPP gTXNScrollInfoProc = NULL ;
2194 ControlActionUPP gTXNScrollActionProc = NULL ;
2195
2196 pascal void wxMacMLTEClassicControl::TXNScrollInfoProc(
2197 SInt32 iValue, SInt32 iMaximumValue,
2198 TXNScrollBarOrientation iScrollBarOrientation, SInt32 iRefCon )
2199 {
2200 wxMacMLTEClassicControl* mlte = (wxMacMLTEClassicControl*) iRefCon ;
2201 SInt32 value = wxMax( iValue , 0 ) ;
2202 SInt32 maximum = wxMax( iMaximumValue , 0 ) ;
2203
2204 if ( iScrollBarOrientation == kTXNHorizontal )
2205 {
2206 if ( mlte->m_sbHorizontal )
2207 {
2208 SetControl32BitValue( mlte->m_sbHorizontal , value ) ;
2209 SetControl32BitMaximum( mlte->m_sbHorizontal , maximum ) ;
2210 mlte->m_lastHorizontalValue = value ;
2211 }
2212 }
2213 else if ( iScrollBarOrientation == kTXNVertical )
2214 {
2215 if ( mlte->m_sbVertical )
2216 {
2217 SetControl32BitValue( mlte->m_sbVertical , value ) ;
2218 SetControl32BitMaximum( mlte->m_sbVertical , maximum ) ;
2219 mlte->m_lastVerticalValue = value ;
2220 }
2221 }
2222 }
2223
2224 pascal void wxMacMLTEClassicControl::TXNScrollActionProc( ControlRef controlRef , ControlPartCode partCode )
2225 {
2226 wxMacMLTEClassicControl* mlte = (wxMacMLTEClassicControl*) GetControlReference( controlRef ) ;
2227 if ( mlte == NULL )
2228 return ;
2229
2230 if ( controlRef != mlte->m_sbVertical && controlRef != mlte->m_sbHorizontal )
2231 return ;
2232
2233 OSStatus err ;
2234 bool isHorizontal = ( controlRef == mlte->m_sbHorizontal ) ;
2235
2236 SInt32 minimum = 0 ;
2237 SInt32 maximum = GetControl32BitMaximum( controlRef ) ;
2238 SInt32 value = GetControl32BitValue( controlRef ) ;
2239 SInt32 delta = 0;
2240
2241 switch ( partCode )
2242 {
2243 case kControlDownButtonPart :
2244 delta = 10 ;
2245 break ;
2246
2247 case kControlUpButtonPart :
2248 delta = -10 ;
2249 break ;
2250
2251 case kControlPageDownPart :
2252 delta = GetControlViewSize( controlRef ) ;
2253 break ;
2254
2255 case kControlPageUpPart :
2256 delta = -GetControlViewSize( controlRef ) ;
2257 break ;
2258
2259 case kControlIndicatorPart :
2260 delta = value - (isHorizontal ? mlte->m_lastHorizontalValue : mlte->m_lastVerticalValue) ;
2261 break ;
2262
2263 default :
2264 break ;
2265 }
2266
2267 if ( delta != 0 )
2268 {
2269 SInt32 newValue = value ;
2270
2271 if ( partCode != kControlIndicatorPart )
2272 {
2273 if ( value + delta < minimum )
2274 delta = minimum - value ;
2275 if ( value + delta > maximum )
2276 delta = maximum - value ;
2277
2278 SetControl32BitValue( controlRef , value + delta ) ;
2279 newValue = value + delta ;
2280 }
2281
2282 SInt32 verticalDelta = isHorizontal ? 0 : delta ;
2283 SInt32 horizontalDelta = isHorizontal ? delta : 0 ;
2284
2285 err = TXNScroll(
2286 mlte->m_txn, kTXNScrollUnitsInPixels, kTXNScrollUnitsInPixels,
2287 &verticalDelta, &horizontalDelta );
2288 verify_noerr( err );
2289
2290 if ( isHorizontal )
2291 mlte->m_lastHorizontalValue = newValue ;
2292 else
2293 mlte->m_lastVerticalValue = newValue ;
2294 }
2295 }
2296 #endif
2297
2298 // make correct activations
2299 void wxMacMLTEClassicControl::MacActivatePaneText(bool setActive)
2300 {
2301 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(m_controlRef);
2302
2303 wxMacWindowClipper clipper( textctrl ) ;
2304 TXNActivate( m_txn, m_txnFrameID, setActive );
2305
2306 ControlRef controlFocus = 0 ;
2307 GetKeyboardFocus( m_txnWindow , &controlFocus ) ;
2308 if ( controlFocus == m_controlRef )
2309 TXNFocus( m_txn, setActive );
2310 }
2311
2312 void wxMacMLTEClassicControl::MacFocusPaneText(bool setFocus)
2313 {
2314 TXNFocus( m_txn, setFocus );
2315 }
2316
2317 // guards against inappropriate redraw (hidden objects drawing onto window)
2318
2319 void wxMacMLTEClassicControl::MacSetObjectVisibility(bool vis)
2320 {
2321 ControlRef controlFocus = 0 ;
2322 GetKeyboardFocus( m_txnWindow , &controlFocus ) ;
2323
2324 if ( !vis && (controlFocus == m_controlRef ) )
2325 SetKeyboardFocus( m_txnWindow , m_controlRef , kControlFocusNoPart ) ;
2326
2327 TXNControlTag iControlTags[1] = { kTXNVisibilityTag };
2328 TXNControlData iControlData[1] = { { (UInt32)false } };
2329
2330 verify_noerr( TXNGetTXNObjectControls( m_txn , 1, iControlTags, iControlData ) ) ;
2331
2332 if ( iControlData[0].uValue != vis )
2333 {
2334 iControlData[0].uValue = vis ;
2335 verify_noerr( TXNSetTXNObjectControls( m_txn, false , 1, iControlTags, iControlData ) ) ;
2336 }
2337
2338 // currently, we always clip as partial visibility (overlapped) visibility is also a problem,
2339 // if we run into further problems we might set the FrameBounds to an empty rect here
2340 }
2341
2342 // make sure that the TXNObject is at the right position
2343
2344 void wxMacMLTEClassicControl::MacUpdatePosition()
2345 {
2346 wxTextCtrl* textctrl = (wxTextCtrl*)GetControlReference( m_controlRef );
2347 if ( textctrl == NULL )
2348 return ;
2349
2350 Rect bounds ;
2351 UMAGetControlBoundsInWindowCoords( m_controlRef, &bounds );
2352
2353 wxRect visRect = textctrl->MacGetClippedClientRect() ;
2354 Rect visBounds = { visRect.y , visRect.x , visRect.y + visRect.height , visRect.x + visRect.width } ;
2355 int x , y ;
2356 x = y = 0 ;
2357 textctrl->MacWindowToRootWindow( &x , &y ) ;
2358 OffsetRect( &visBounds , x , y ) ;
2359
2360 if ( !EqualRect( &bounds, &m_txnControlBounds ) || !EqualRect( &visBounds, &m_txnVisBounds ) )
2361 {
2362 m_txnControlBounds = bounds ;
2363 m_txnVisBounds = visBounds ;
2364 wxMacWindowClipper cl( textctrl ) ;
2365
2366 #ifdef __WXMAC_OSX__
2367 bool isCompositing = textctrl->MacGetTopLevelWindow()->MacUsesCompositing() ;
2368 if ( m_sbHorizontal || m_sbVertical )
2369 {
2370 int w = bounds.right - bounds.left ;
2371 int h = bounds.bottom - bounds.top ;
2372
2373 if ( m_sbHorizontal )
2374 {
2375 Rect sbBounds ;
2376
2377 sbBounds.left = -1 ;
2378 sbBounds.top = h - 14 ;
2379 sbBounds.right = w + 1 ;
2380 sbBounds.bottom = h + 1 ;
2381
2382 if ( !isCompositing )
2383 OffsetRect( &sbBounds , m_txnControlBounds.left , m_txnControlBounds.top ) ;
2384
2385 SetControlBounds( m_sbHorizontal , &sbBounds ) ;
2386 SetControlViewSize( m_sbHorizontal , w ) ;
2387 }
2388
2389 if ( m_sbVertical )
2390 {
2391 Rect sbBounds ;
2392
2393 sbBounds.left = w - 14 ;
2394 sbBounds.top = -1 ;
2395 sbBounds.right = w + 1 ;
2396 sbBounds.bottom = m_sbHorizontal ? h - 14 : h + 1 ;
2397
2398 if ( !isCompositing )
2399 OffsetRect( &sbBounds , m_txnControlBounds.left , m_txnControlBounds.top ) ;
2400
2401 SetControlBounds( m_sbVertical , &sbBounds ) ;
2402 SetControlViewSize( m_sbVertical , h ) ;
2403 }
2404 }
2405
2406 Rect oldviewRect ;
2407 TXNLongRect olddestRect ;
2408 TXNGetRectBounds( m_txn , &oldviewRect , &olddestRect , NULL ) ;
2409
2410 Rect viewRect = { m_txnControlBounds.top, m_txnControlBounds.left,
2411 m_txnControlBounds.bottom - ( m_sbHorizontal ? 14 : 0 ) ,
2412 m_txnControlBounds.right - ( m_sbVertical ? 14 : 0 ) } ;
2413 TXNLongRect destRect = { m_txnControlBounds.top, m_txnControlBounds.left,
2414 m_txnControlBounds.bottom - ( m_sbHorizontal ? 14 : 0 ) ,
2415 m_txnControlBounds.right - ( m_sbVertical ? 14 : 0 ) } ;
2416
2417 if ( olddestRect.right >= 10000 )
2418 destRect.right = destRect.left + 32000 ;
2419
2420 if ( olddestRect.bottom >= 0x20000000 )
2421 destRect.bottom = destRect.top + 0x40000000 ;
2422
2423 SectRect( &viewRect , &visBounds , &viewRect ) ;
2424 TXNSetRectBounds( m_txn , &viewRect , &destRect , true ) ;
2425
2426 #if 0
2427 TXNSetFrameBounds(
2428 m_txn,
2429 m_txnControlBounds.top,
2430 m_txnControlBounds.left,
2431 m_txnControlBounds.bottom - (m_sbHorizontal ? 14 : 0),
2432 m_txnControlBounds.right - (m_sbVertical ? 14 : 0),
2433 m_txnFrameID );
2434 #endif
2435 #else
2436
2437 TXNSetFrameBounds(
2438 m_txn, m_txnControlBounds.top, m_txnControlBounds.left,
2439 wxMax( m_txnControlBounds.bottom, m_txnControlBounds.top ),
2440 wxMax( m_txnControlBounds.right, m_txnControlBounds.left ), m_txnFrameID );
2441 #endif
2442
2443 // the SetFrameBounds method under Classic sometimes does not correctly scroll a selection into sight after a
2444 // movement, therefore we have to force it
2445
2446 // this problem has been reported in OSX as well, so we use this here once again
2447
2448 TXNLongRect textRect ;
2449 TXNGetRectBounds( m_txn , NULL , NULL , &textRect ) ;
2450 if ( textRect.left < m_txnControlBounds.left )
2451 TXNShowSelection( m_txn , kTXNShowStart ) ;
2452 }
2453 }
2454
2455 void wxMacMLTEClassicControl::SetRect( Rect *r )
2456 {
2457 wxMacControl::SetRect( r ) ;
2458 MacUpdatePosition() ;
2459 }
2460
2461 void wxMacMLTEClassicControl::MacControlUserPaneDrawProc(wxInt16 thePart)
2462 {
2463 wxTextCtrl* textctrl = (wxTextCtrl*)GetControlReference( m_controlRef );
2464 if ( textctrl == NULL )
2465 return ;
2466
2467 if ( textctrl->MacIsReallyShown() )
2468 {
2469 wxMacWindowClipper clipper( textctrl ) ;
2470 TXNDraw( m_txn , NULL ) ;
2471 }
2472 }
2473
2474 wxInt16 wxMacMLTEClassicControl::MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y)
2475 {
2476 Point where = { y , x } ;
2477 ControlPartCode result = kControlNoPart;
2478
2479 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference( m_controlRef );
2480 if ( (textctrl != NULL) && textctrl->MacIsReallyShown() )
2481 {
2482 if (PtInRect( where, &m_txnControlBounds ))
2483 {
2484 result = kControlEditTextPart ;
2485 }
2486 else
2487 {
2488 // sometimes we get the coords also in control local coordinates, therefore test again
2489 if ( textctrl->MacGetTopLevelWindow()->MacUsesCompositing() )
2490 {
2491 int x = 0 , y = 0 ;
2492 textctrl->MacClientToRootWindow( &x , &y ) ;
2493 where.h += x ;
2494 where.v += y ;
2495 }
2496
2497 if (PtInRect( where, &m_txnControlBounds ))
2498 result = kControlEditTextPart ;
2499 }
2500 }
2501
2502 return result;
2503 }
2504
2505 wxInt16 wxMacMLTEClassicControl::MacControlUserPaneTrackingProc( wxInt16 x, wxInt16 y, void* actionProc )
2506 {
2507 ControlPartCode result = kControlNoPart;
2508
2509 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference( m_controlRef );
2510 if ( (textctrl != NULL) && textctrl->MacIsReallyShown() )
2511 {
2512 Point startPt = { y , x } ;
2513 // for compositing, we must convert these into toplevel window coordinates, because hittesting expects them
2514 if ( textctrl->MacGetTopLevelWindow()->MacUsesCompositing() )
2515 {
2516 int x = 0 , y = 0 ;
2517 textctrl->MacClientToRootWindow( &x , &y ) ;
2518 startPt.h += x ;
2519 startPt.v += y ;
2520 }
2521
2522 switch (MacControlUserPaneHitTestProc( startPt.h , startPt.v ))
2523 {
2524 case kControlEditTextPart :
2525 {
2526 wxMacWindowClipper clipper( textctrl ) ;
2527 EventRecord rec ;
2528
2529 ConvertEventRefToEventRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) ;
2530 TXNClick( m_txn, &rec );
2531 }
2532 break;
2533
2534 default :
2535 break;
2536 }
2537 }
2538
2539 return result;
2540 }
2541
2542 void wxMacMLTEClassicControl::MacControlUserPaneIdleProc()
2543 {
2544 wxTextCtrl* textctrl = (wxTextCtrl*)GetControlReference( m_controlRef );
2545 if ( textctrl == NULL )
2546 return ;
2547
2548 if (textctrl->MacIsReallyShown())
2549 {
2550 if (IsControlActive(m_controlRef))
2551 {
2552 Point mousep;
2553
2554 wxMacWindowClipper clipper( textctrl ) ;
2555 GetMouse(&mousep);
2556
2557 TXNIdle(m_txn);
2558
2559 if (PtInRect(mousep, &m_txnControlBounds))
2560 {
2561 RgnHandle theRgn = NewRgn();
2562 RectRgn(theRgn, &m_txnControlBounds);
2563 TXNAdjustCursor(m_txn, theRgn);
2564 DisposeRgn(theRgn);
2565 }
2566 }
2567 }
2568 }
2569
2570 wxInt16 wxMacMLTEClassicControl::MacControlUserPaneKeyDownProc (wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers)
2571 {
2572 wxTextCtrl* textctrl = (wxTextCtrl*)GetControlReference( m_controlRef );
2573 if ( textctrl == NULL )
2574 return kControlNoPart;
2575
2576 wxMacWindowClipper clipper( textctrl ) ;
2577
2578 EventRecord ev ;
2579 memset( &ev , 0 , sizeof( ev ) ) ;
2580 ev.what = keyDown ;
2581 ev.modifiers = modifiers ;
2582 ev.message = ((keyCode << 8) & keyCodeMask) | (charCode & charCodeMask);
2583 TXNKeyDown( m_txn , &ev );
2584
2585 return kControlEntireControl;
2586 }
2587
2588 void wxMacMLTEClassicControl::MacControlUserPaneActivateProc(bool activating)
2589 {
2590 MacActivatePaneText( activating );
2591 }
2592
2593 wxInt16 wxMacMLTEClassicControl::MacControlUserPaneFocusProc(wxInt16 action)
2594 {
2595 ControlPartCode focusResult = kControlFocusNoPart;
2596
2597 wxTextCtrl* textctrl = (wxTextCtrl*)GetControlReference( m_controlRef );
2598 if ( textctrl == NULL )
2599 return focusResult;
2600
2601 wxMacWindowClipper clipper( textctrl ) ;
2602
2603 ControlRef controlFocus = NULL ;
2604 GetKeyboardFocus( m_txnWindow , &controlFocus ) ;
2605 bool wasFocused = ( controlFocus == m_controlRef ) ;
2606
2607 switch (action)
2608 {
2609 case kControlFocusPrevPart:
2610 case kControlFocusNextPart:
2611 MacFocusPaneText( !wasFocused );
2612 focusResult = (!wasFocused ? (ControlPartCode) kControlEditTextPart : (ControlPartCode) kControlFocusNoPart);
2613 break;
2614
2615 case kControlFocusNoPart:
2616 default:
2617 MacFocusPaneText( false );
2618 focusResult = kControlFocusNoPart;
2619 break;
2620 }
2621
2622 return focusResult;
2623 }
2624
2625 void wxMacMLTEClassicControl::MacControlUserPaneBackgroundProc( void *info )
2626 {
2627 }
2628
2629 wxMacMLTEClassicControl::wxMacMLTEClassicControl( wxTextCtrl *wxPeer,
2630 const wxString& str,
2631 const wxPoint& pos,
2632 const wxSize& size, long style )
2633 : wxMacMLTEControl( wxPeer )
2634 {
2635 m_font = wxPeer->GetFont() ;
2636 m_windowStyle = style ;
2637 Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
2638
2639 short featureSet =
2640 kControlSupportsEmbedding | kControlSupportsFocus | kControlWantsIdle
2641 | kControlWantsActivate | kControlHandlesTracking
2642 // | kControlHasSpecialBackground
2643 | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
2644
2645 OSStatus err = ::CreateUserPaneControl(
2646 MAC_WXHWND(wxPeer->GetParent()->MacGetTopLevelWindowRef()),
2647 &bounds, featureSet, &m_controlRef );
2648 verify_noerr( err );
2649
2650 DoCreate();
2651
2652 AdjustCreationAttributes( *wxWHITE , true ) ;
2653
2654 MacSetObjectVisibility( wxPeer->MacIsReallyShown() ) ;
2655
2656 {
2657 wxString st = str ;
2658 wxMacConvertNewlines10To13( &st ) ;
2659 wxMacWindowClipper clipper( m_peer ) ;
2660 SetTXNData( st , kTXNStartOffset, kTXNEndOffset ) ;
2661 TXNSetSelection( m_txn, 0, 0 ) ;
2662 }
2663 }
2664
2665 wxMacMLTEClassicControl::~wxMacMLTEClassicControl()
2666 {
2667 TXNDeleteObject( m_txn );
2668 m_txn = NULL ;
2669 }
2670
2671 void wxMacMLTEClassicControl::VisibilityChanged(bool shown)
2672 {
2673 MacSetObjectVisibility( shown ) ;
2674 wxMacControl::VisibilityChanged( shown ) ;
2675 }
2676
2677 void wxMacMLTEClassicControl::SuperChangedPosition()
2678 {
2679 MacUpdatePosition() ;
2680 wxMacControl::SuperChangedPosition() ;
2681 }
2682
2683 #ifdef __WXMAC_OSX__
2684
2685 ControlUserPaneDrawUPP gTPDrawProc = NULL;
2686 ControlUserPaneHitTestUPP gTPHitProc = NULL;
2687 ControlUserPaneTrackingUPP gTPTrackProc = NULL;
2688 ControlUserPaneIdleUPP gTPIdleProc = NULL;
2689 ControlUserPaneKeyDownUPP gTPKeyProc = NULL;
2690 ControlUserPaneActivateUPP gTPActivateProc = NULL;
2691 ControlUserPaneFocusUPP gTPFocusProc = NULL;
2692
2693 static pascal void wxMacControlUserPaneDrawProc(ControlRef control, SInt16 part)
2694 {
2695 wxTextCtrl *textCtrl = wxDynamicCast( wxFindControlFromMacControl(control) , wxTextCtrl ) ;
2696 wxMacMLTEClassicControl * win = textCtrl ? (wxMacMLTEClassicControl*)(textCtrl->GetPeer()) : NULL ;
2697 if ( win )
2698 win->MacControlUserPaneDrawProc( part ) ;
2699 }
2700
2701 static pascal ControlPartCode wxMacControlUserPaneHitTestProc(ControlRef control, Point where)
2702 {
2703 wxTextCtrl *textCtrl = wxDynamicCast( wxFindControlFromMacControl(control) , wxTextCtrl ) ;
2704 wxMacMLTEClassicControl * win = textCtrl ? (wxMacMLTEClassicControl*)(textCtrl->GetPeer()) : NULL ;
2705 if ( win )
2706 return win->MacControlUserPaneHitTestProc( where.h , where.v ) ;
2707 else
2708 return kControlNoPart ;
2709 }
2710
2711 static pascal ControlPartCode wxMacControlUserPaneTrackingProc(ControlRef control, Point startPt, ControlActionUPP actionProc)
2712 {
2713 wxTextCtrl *textCtrl = wxDynamicCast( wxFindControlFromMacControl(control) , wxTextCtrl ) ;
2714 wxMacMLTEClassicControl * win = textCtrl ? (wxMacMLTEClassicControl*)(textCtrl->GetPeer()) : NULL ;
2715 if ( win )
2716 return win->MacControlUserPaneTrackingProc( startPt.h , startPt.v , (void*) actionProc ) ;
2717 else
2718 return kControlNoPart ;
2719 }
2720
2721 static pascal void wxMacControlUserPaneIdleProc(ControlRef control)
2722 {
2723 wxTextCtrl *textCtrl = wxDynamicCast( wxFindControlFromMacControl(control) , wxTextCtrl ) ;
2724 wxMacMLTEClassicControl * win = textCtrl ? (wxMacMLTEClassicControl*)(textCtrl->GetPeer()) : NULL ;
2725 if ( win )
2726 win->MacControlUserPaneIdleProc() ;
2727 }
2728
2729 static pascal ControlPartCode wxMacControlUserPaneKeyDownProc(ControlRef control, SInt16 keyCode, SInt16 charCode, SInt16 modifiers)
2730 {
2731 wxTextCtrl *textCtrl = wxDynamicCast( wxFindControlFromMacControl(control) , wxTextCtrl ) ;
2732 wxMacMLTEClassicControl * win = textCtrl ? (wxMacMLTEClassicControl*)(textCtrl->GetPeer()) : NULL ;
2733 if ( win )
2734 return win->MacControlUserPaneKeyDownProc( keyCode, charCode, modifiers ) ;
2735 else
2736 return kControlNoPart ;
2737 }
2738
2739 static pascal void wxMacControlUserPaneActivateProc(ControlRef control, Boolean activating)
2740 {
2741 wxTextCtrl *textCtrl = wxDynamicCast( wxFindControlFromMacControl(control) , wxTextCtrl ) ;
2742 wxMacMLTEClassicControl * win = textCtrl ? (wxMacMLTEClassicControl*)(textCtrl->GetPeer()) : NULL ;
2743 if ( win )
2744 win->MacControlUserPaneActivateProc( activating ) ;
2745 }
2746
2747 static pascal ControlPartCode wxMacControlUserPaneFocusProc(ControlRef control, ControlFocusPart action)
2748 {
2749 wxTextCtrl *textCtrl = wxDynamicCast( wxFindControlFromMacControl(control) , wxTextCtrl ) ;
2750 wxMacMLTEClassicControl * win = textCtrl ? (wxMacMLTEClassicControl*)(textCtrl->GetPeer()) : NULL ;
2751 if ( win )
2752 return win->MacControlUserPaneFocusProc( action ) ;
2753 else
2754 return kControlNoPart ;
2755 }
2756
2757 #if 0
2758 static pascal void wxMacControlUserPaneBackgroundProc(ControlRef control, ControlBackgroundPtr info)
2759 {
2760 wxTextCtrl *textCtrl = wxDynamicCast( wxFindControlFromMacControl(control) , wxTextCtrl ) ;
2761 wxMacMLTEClassicControl * win = textCtrl ? (wxMacMLTEClassicControl*)(textCtrl->GetPeer()) : NULL ;
2762 if ( win )
2763 win->MacControlUserPaneBackgroundProc(info) ;
2764 }
2765 #endif
2766
2767 #endif // __WXMAC_OSX__
2768
2769 // TXNRegisterScrollInfoProc
2770
2771 OSStatus wxMacMLTEClassicControl::DoCreate()
2772 {
2773 Rect bounds;
2774 OSStatus err = noErr ;
2775
2776 // set up our globals
2777 #ifdef __WXMAC_OSX__
2778 if (gTPDrawProc == NULL) gTPDrawProc = NewControlUserPaneDrawUPP(wxMacControlUserPaneDrawProc);
2779 if (gTPHitProc == NULL) gTPHitProc = NewControlUserPaneHitTestUPP(wxMacControlUserPaneHitTestProc);
2780 if (gTPTrackProc == NULL) gTPTrackProc = NewControlUserPaneTrackingUPP(wxMacControlUserPaneTrackingProc);
2781 if (gTPIdleProc == NULL) gTPIdleProc = NewControlUserPaneIdleUPP(wxMacControlUserPaneIdleProc);
2782 if (gTPKeyProc == NULL) gTPKeyProc = NewControlUserPaneKeyDownUPP(wxMacControlUserPaneKeyDownProc);
2783 if (gTPActivateProc == NULL) gTPActivateProc = NewControlUserPaneActivateUPP(wxMacControlUserPaneActivateProc);
2784 if (gTPFocusProc == NULL) gTPFocusProc = NewControlUserPaneFocusUPP(wxMacControlUserPaneFocusProc);
2785
2786 if (gTXNScrollInfoProc == NULL ) gTXNScrollInfoProc = NewTXNScrollInfoUPP(TXNScrollInfoProc) ;
2787 if (gTXNScrollActionProc == NULL ) gTXNScrollActionProc = NewControlActionUPP(TXNScrollActionProc) ;
2788 #endif
2789
2790 // set the initial settings for our private data
2791
2792 m_txnWindow = GetControlOwner(m_controlRef);
2793 m_txnPort = (GrafPtr) GetWindowPort(m_txnWindow);
2794
2795 #ifdef __WXMAC_OSX__
2796 // set up the user pane procedures
2797 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(gTPDrawProc), &gTPDrawProc);
2798 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(gTPHitProc), &gTPHitProc);
2799 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneTrackingProcTag, sizeof(gTPTrackProc), &gTPTrackProc);
2800 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneIdleProcTag, sizeof(gTPIdleProc), &gTPIdleProc);
2801 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneKeyDownProcTag, sizeof(gTPKeyProc), &gTPKeyProc);
2802 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneActivateProcTag, sizeof(gTPActivateProc), &gTPActivateProc);
2803 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneFocusProcTag, sizeof(gTPFocusProc), &gTPFocusProc);
2804 #endif
2805
2806 // calculate the rectangles used by the control
2807 UMAGetControlBoundsInWindowCoords( m_controlRef, &bounds );
2808
2809 m_txnControlBounds = bounds ;
2810 m_txnVisBounds = bounds ;
2811
2812 CGrafPtr origPort ;
2813 GDHandle origDev ;
2814
2815 GetGWorld( &origPort, &origDev ) ;
2816 SetPort( m_txnPort );
2817
2818 // create the new edit field
2819 TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( m_windowStyle );
2820
2821 #ifdef __WXMAC_OSX__
2822 // the scrollbars are not correctly embedded but are inserted at the root:
2823 // this gives us problems as we have erratic redraws even over the structure area
2824
2825 m_sbHorizontal = 0 ;
2826 m_sbVertical = 0 ;
2827 m_lastHorizontalValue = 0 ;
2828 m_lastVerticalValue = 0 ;
2829
2830 Rect sb = { 0 , 0 , 0 , 0 } ;
2831 if ( frameOptions & kTXNWantVScrollBarMask )
2832 {
2833 CreateScrollBarControl( m_txnWindow, &sb, 0, 0, 100, 1, true, gTXNScrollActionProc, &m_sbVertical );
2834 SetControlReference( m_sbVertical, (SInt32)this );
2835 SetControlAction( m_sbVertical, gTXNScrollActionProc );
2836 ShowControl( m_sbVertical );
2837 EmbedControl( m_sbVertical , m_controlRef );
2838 frameOptions &= ~kTXNWantVScrollBarMask;
2839 }
2840
2841 if ( frameOptions & kTXNWantHScrollBarMask )
2842 {
2843 CreateScrollBarControl( m_txnWindow, &sb, 0, 0, 100, 1, true, gTXNScrollActionProc, &m_sbHorizontal );
2844 SetControlReference( m_sbHorizontal, (SInt32)this );
2845 SetControlAction( m_sbHorizontal, gTXNScrollActionProc );
2846 ShowControl( m_sbHorizontal );
2847 EmbedControl( m_sbHorizontal, m_controlRef );
2848 frameOptions &= ~(kTXNWantHScrollBarMask | kTXNDrawGrowIconMask);
2849 }
2850
2851 #endif
2852
2853 err = TXNNewObject(
2854 NULL, m_txnWindow, &bounds, frameOptions,
2855 kTXNTextEditStyleFrameType, kTXNTextensionFile, kTXNSystemDefaultEncoding,
2856 &m_txn, &m_txnFrameID, NULL );
2857 verify_noerr( err );
2858
2859 #if 0
2860 TXNControlTag iControlTags[] = { kTXNUseCarbonEvents };
2861 TXNControlData iControlData[] = { { (UInt32)&cInfo } };
2862 int toptag = WXSIZEOF( iControlTags ) ;
2863 TXNCarbonEventInfo cInfo ;
2864 cInfo.useCarbonEvents = false ;
2865 cInfo.filler = 0 ;
2866 cInfo.flags = 0 ;
2867 cInfo.fDictionary = NULL ;
2868
2869 verify_noerr( TXNSetTXNObjectControls( m_txn, false, toptag, iControlTags, iControlData ) );
2870 #endif
2871
2872 #ifdef __WXMAC_OSX__
2873 TXNRegisterScrollInfoProc( m_txn, gTXNScrollInfoProc, (SInt32)this );
2874 #endif
2875
2876 SetGWorld( origPort , origDev ) ;
2877
2878 return err;
2879 }
2880
2881 // ----------------------------------------------------------------------------
2882 // MLTE control implementation (OSX part)
2883 // ----------------------------------------------------------------------------
2884
2885 #if TARGET_API_MAC_OSX
2886
2887 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
2888
2889 wxMacMLTEHIViewControl::wxMacMLTEHIViewControl( wxTextCtrl *wxPeer,
2890 const wxString& str,
2891 const wxPoint& pos,
2892 const wxSize& size, long style ) : wxMacMLTEControl( wxPeer )
2893 {
2894 m_font = wxPeer->GetFont() ;
2895 m_windowStyle = style ;
2896 Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
2897 wxString st = str ;
2898 wxMacConvertNewlines10To13( &st ) ;
2899
2900 HIRect hr = {
2901 { bounds.left , bounds.top },
2902 { bounds.right - bounds.left, bounds.bottom - bounds.top } } ;
2903
2904 m_scrollView = NULL ;
2905 TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( style ) ;
2906 if ( frameOptions & (kTXNWantVScrollBarMask | kTXNWantHScrollBarMask) )
2907 {
2908 HIScrollViewCreate(
2909 (frameOptions & kTXNWantHScrollBarMask ? kHIScrollViewOptionsHorizScroll : 0)
2910 | (frameOptions & kTXNWantVScrollBarMask ? kHIScrollViewOptionsVertScroll : 0) ,
2911 &m_scrollView ) ;
2912
2913 HIViewSetFrame( m_scrollView, &hr );
2914 HIViewSetVisible( m_scrollView, true );
2915 }
2916
2917 m_textView = NULL ;
2918 HITextViewCreate( NULL , 0, frameOptions , &m_textView ) ;
2919 m_txn = HITextViewGetTXNObject( m_textView ) ;
2920 HIViewSetVisible( m_textView , true ) ;
2921 if ( m_scrollView )
2922 {
2923 HIViewAddSubview( m_scrollView , m_textView ) ;
2924 m_controlRef = m_scrollView ;
2925 wxPeer->MacInstallEventHandler( (WXWidget) m_textView ) ;
2926 }
2927 else
2928 {
2929 HIViewSetFrame( m_textView, &hr );
2930 m_controlRef = m_textView ;
2931 }
2932
2933 AdjustCreationAttributes( *wxWHITE , true ) ;
2934
2935 wxMacWindowClipper c( m_peer ) ;
2936 SetTXNData( st , kTXNStartOffset, kTXNEndOffset ) ;
2937
2938 TXNSetSelection( m_txn, 0, 0 );
2939 TXNShowSelection( m_txn, kTXNShowStart );
2940 }
2941
2942 OSStatus wxMacMLTEHIViewControl::SetFocus( ControlFocusPart focusPart )
2943 {
2944 return SetKeyboardFocus( GetControlOwner( m_textView ), m_textView, focusPart ) ;
2945 }
2946
2947 bool wxMacMLTEHIViewControl::HasFocus() const
2948 {
2949 ControlRef control ;
2950 GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
2951 return control == m_textView ;
2952 }
2953
2954 void wxMacMLTEHIViewControl::SetBackground( const wxBrush &brush )
2955 {
2956 wxMacMLTEControl::SetBackground( brush ) ;
2957
2958 #if 0
2959 CGColorSpaceRef rgbSpace = CGColorSpaceCreateDeviceRGB();
2960 RGBColor col = MAC_WXCOLORREF(brush.GetColour().GetPixel()) ;
2961
2962 float component[4] ;
2963 component[0] = col.red / 65536.0 ;
2964 component[1] = col.green / 65536.0 ;
2965 component[2] = col.blue / 65536.0 ;
2966 component[3] = 1.0 ; // alpha
2967
2968 CGColorRef color = CGColorCreate( rgbSpace , component );
2969 HITextViewSetBackgroundColor( m_textView , color );
2970 CGColorSpaceRelease( rgbSpace );
2971 #endif
2972 }
2973
2974 #endif // MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
2975
2976
2977 #endif
2978
2979 #endif // wxUSE_TEXTCTRL
wxWidgets (Impactor)