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