]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/textctrl.cpp
projects / wxWidgets.git / blob
? search:


73b7aa5dc07e2a774b4233715a7cb9700d93db7d
[wxWidgets.git] / src / mac / carbon / textctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: textctrl.cpp
3 // Purpose: wxTextCtrl
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 1998-01-01
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "textctrl.h"
14 #endif
15
16 #include "wx/defs.h"
17
18 #if wxUSE_TEXTCTRL
19
20
21 #ifdef __DARWIN__
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #else
25 #include <stat.h>
26 #endif
27
28 #include "wx/msgdlg.h"
29
30 #if wxUSE_STD_IOSTREAM
31 #if wxUSE_IOSTREAMH
32 #include <fstream.h>
33 #else
34 #include <fstream>
35 #endif
36 #endif
37
38 #include "wx/app.h"
39 #include "wx/dc.h"
40 #include "wx/button.h"
41 #include "wx/toplevel.h"
42 #include "wx/textctrl.h"
43 #include "wx/notebook.h"
44 #include "wx/tabctrl.h"
45 #include "wx/settings.h"
46 #include "wx/filefn.h"
47 #include "wx/utils.h"
48
49 #if defined(__BORLANDC__) && !defined(__WIN32__)
50 #include <alloc.h>
51 #elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
52 #include <malloc.h>
53 #endif
54
55 #ifndef __DARWIN__
56 #include <Scrap.h>
57 #endif
58
59 // if this is set to 1 then under OSX 10.2 the 'classic' MLTE implementation will be used
60 // if set to 0 then the unicode textctrl will be used
61 #ifndef wxMAC_AWAYS_USE_MLTE
62 #define wxMAC_AWAYS_USE_MLTE 1
63 #endif
64
65 #include <MacTextEditor.h>
66 #include <ATSUnicode.h>
67 #include <TextCommon.h>
68 #include <TextEncodingConverter.h>
69 #include "wx/mac/uma.h"
70
71 class wxMacFunctor
72 {
73 public :
74 wxMacFunctor(){}
75 virtual ~wxMacFunctor() {}
76 virtual void* operator()() = 0 ;
77 static void* CallBackProc(void *param)
78 {
79 wxMacFunctor* f = (wxMacFunctor*) param ;
80 void *result = (*f)() ;
81 return result ;
82 }
83 } ;
84
85 template<typename classtype,typename param1type>
86 class wxMacObjectFunctor1 : public wxMacFunctor
87 {
88 typedef void (classtype::*function)( param1type p1 ) ;
89 typedef void (classtype::*ref_function)( const param1type& p1 ) ;
90 public :
91 wxMacObjectFunctor1( classtype *obj , function f , param1type p1 ) :
92 wxMacFunctor( )
93 {
94 m_object = obj ;
95 m_function = f ;
96 m_param1 = p1 ;
97 }
98
99 wxMacObjectFunctor1( classtype *obj , ref_function f , param1type p1 ) :
100 wxMacFunctor( )
101 {
102 m_object = obj ;
103 m_refFunction = f ;
104 m_param1 = p1 ;
105 }
106
107 ~wxMacObjectFunctor1() {}
108
109 virtual void* operator()()
110 {
111 (m_object->*m_function)(m_param1) ;
112 return NULL ;
113 }
114 private :
115 classtype* m_object ;
116 param1type m_param1 ;
117 union
118 {
119 function m_function ;
120 ref_function m_refFunction ;
121 } ;
122 } ;
123
124 template<typename classtype, typename param1type>
125 void* wxMacMPRemoteCall( classtype *object , void (classtype::*function)( param1type p1 ) , param1type p1 )
126 {
127 wxMacObjectFunctor1<classtype,param1type> params(object,function,p1) ;
128 void *result =
129 MPRemoteCall( wxMacFunctor::CallBackProc , &params , kMPOwningProcessRemoteContext ) ;
130 return result ;
131 }
132
133 template<typename classtype, typename param1type>
134 void* wxMacMPRemoteCall( classtype *object , void (classtype::*function)( const param1type& p1 ) , param1type p1 )
135 {
136 wxMacObjectFunctor1<classtype,param1type> params(object,function,p1) ;
137 void *result =
138 MPRemoteCall( wxMacFunctor::CallBackProc , &params , kMPOwningProcessRemoteContext ) ;
139 return result ;
140 }
141
142 template<typename classtype, typename param1type>
143 void* wxMacMPRemoteGUICall( classtype *object , void (classtype::*function)( param1type p1 ) , param1type p1 )
144 {
145 wxMutexGuiLeave() ;
146 void *result = wxMacMPRemoteCall( object , function , p1 ) ;
147 wxMutexGuiEnter() ;
148 return result ;
149 }
150
151 template<typename classtype, typename param1type>
152 void* wxMacMPRemoteGUICall( classtype *object , void (classtype::*function)( const param1type& p1 ) , param1type p1 )
153 {
154 wxMutexGuiLeave() ;
155 void *result = wxMacMPRemoteCall( object , function , p1 ) ;
156 wxMutexGuiEnter() ;
157 return result ;
158 }
159 // common interface for all implementations
160 class wxMacTextControl : public wxMacControl
161 {
162 public :
163 wxMacTextControl() ;
164 ~wxMacTextControl() ;
165
166 virtual wxString GetStringValue() const = 0 ;
167 virtual void SetStringValue( const wxString &val ) = 0 ;
168 virtual void SetStyle(long start, long end, const wxTextAttr& style) ;
169 virtual void Copy() ;
170 virtual void Cut() ;
171 virtual void Paste() ;
172 virtual bool CanPaste() const ;
173 virtual void SetEditable(bool editable) ;
174 virtual long GetLastPosition() const ;
175 virtual void Replace( long from , long to , const wxString str ) ;
176 virtual void Remove( long from , long to ) = 0 ;
177 virtual void SetSelection( long from , long to ) = 0 ;
178 virtual void GetSelection( long* from, long* to) const = 0 ;
179 virtual void WriteText(const wxString& str) = 0 ;
180
181 virtual void Clear() ;
182 virtual bool CanUndo() const;
183 virtual void Undo() ;
184 virtual bool CanRedo() const;
185 virtual void Redo() ;
186 virtual int GetNumberOfLines() const ;
187 virtual long XYToPosition(long x, long y) const;
188 virtual bool PositionToXY(long pos, long *x, long *y) const ;
189 virtual void ShowPosition( long WXUNUSED(pos) ) ;
190 virtual int GetLineLength(long lineNo) const ;
191 virtual wxString GetLineText(long lineNo) const ;
192 } ;
193
194 // common parts for implementations based on MLTE
195
196 class wxMacMLTEControl : public wxMacTextControl
197 {
198 public :
199 virtual wxString GetStringValue() const ;
200 virtual void SetStringValue( const wxString &str) ;
201
202 static int ConvertAttribute( const wxTextAttr& style , TXNTypeAttributes attr[] ) ;
203 static TXNFrameOptions FrameOptionsFromWXStyle( long wxStyle ) ;
204 void AdjustCreationAttributes( const wxColour& background , bool visible ) ;
205
206 virtual void SetFont( const wxFont & font , const wxColour& foreground , long windowStyle ) ;
207 virtual void SetStyle(long start, long end, const wxTextAttr& style) ;
208 virtual void Copy() ;
209 virtual void Cut() ;
210 virtual void Paste() ;
211 virtual bool CanPaste() const ;
212 virtual void SetEditable(bool editable) ;
213 virtual long GetLastPosition() const ;
214 virtual void Replace( long from , long to , const wxString str ) ;
215 virtual void Remove( long from , long to ) ;
216 virtual void GetSelection( long* from, long* to) const ;
217 virtual void SetSelection( long from , long to ) ;
218
219 virtual void WriteText(const wxString& str) ;
220 virtual void Clear() ;
221
222 virtual bool CanUndo() const ;
223 virtual void Undo() ;
224 virtual bool CanRedo() const;
225 virtual void Redo() ;
226 virtual int GetNumberOfLines() const ;
227 virtual long XYToPosition(long x, long y) const ;
228 virtual bool PositionToXY(long pos, long *x, long *y) const ;
229 virtual void ShowPosition( long pos ) ;
230 virtual int GetLineLength(long lineNo) const ;
231 virtual wxString GetLineText(long lineNo) const ;
232
233 void SetTXNData( const wxString& st , TXNOffset start , TXNOffset end ) ;
234
235 protected :
236 TXNObject m_txn ;
237 } ;
238
239 #if TARGET_API_MAC_OSX
240
241 // implementation available under OSX
242
243 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
244
245 class wxMacMLTEHIViewControl : public wxMacMLTEControl
246 {
247 public :
248 wxMacMLTEHIViewControl( wxWindow *wxPeer,
249 const wxString& str,
250 const wxPoint& pos,
251 const wxSize& size, long style ) ;
252 virtual OSStatus SetFocus( ControlFocusPart focusPart ) ;
253 virtual bool HasFocus() const ;
254 virtual bool NeedsFocusRect() const ;
255 protected :
256 HIViewRef m_scrollView ;
257 HIViewRef m_textView ;
258 } ;
259
260 #endif
261
262 class wxMacUnicodeTextControl : public wxMacTextControl
263 {
264 public :
265 wxMacUnicodeTextControl( wxWindow *wxPeer,
266 const wxString& str,
267 const wxPoint& pos,
268 const wxSize& size, long style ) ;
269 ~wxMacUnicodeTextControl();
270 virtual void VisibilityChanged(bool shown);
271 virtual wxString GetStringValue() const ;
272 virtual void SetStringValue( const wxString &str) ;
273 virtual void Copy();
274 virtual void Cut();
275 virtual void Paste();
276 virtual bool CanPaste() const;
277 virtual void SetEditable(bool editable) ;
278 virtual void Remove( long from , long to ) ;
279 virtual void GetSelection( long* from, long* to) const ;
280 virtual void SetSelection( long from , long to ) ;
281 virtual void WriteText(const wxString& str) ;
282 protected :
283 // contains the tag for the content (is different for password and non-password controls)
284 OSType m_valueTag ;
285 } ;
286
287 #endif
288
289 // implementation available under classic
290
291 class STPTextPaneVars ;
292
293 class wxMacMLTEClassicControl : public wxMacMLTEControl
294 {
295 public :
296 wxMacMLTEClassicControl( wxWindow *wxPeer,
297 const wxString& str,
298 const wxPoint& pos,
299 const wxSize& size, long style ) ;
300 ~wxMacMLTEClassicControl() ;
301 virtual void VisibilityChanged(bool shown) ;
302 protected :
303 OSStatus DoCreate();
304 public :
305 // hack to make public until we have migrated all procs
306 STPTextPaneVars* m_macTXNvars ;
307 } ;
308
309 #define TE_UNLIMITED_LENGTH 0xFFFFFFFFUL
310
311 #if !USE_SHARED_LIBRARY
312 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
313
314 BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
315 EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
316 EVT_CHAR(wxTextCtrl::OnChar)
317 EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
318 EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
319 EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
320 EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
321 EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
322
323 EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
324 EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
325 EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
326 EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
327 EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
328 END_EVENT_TABLE()
329 #endif
330
331 // Text item
332 void wxTextCtrl::Init()
333 {
334 m_editable = true ;
335 m_dirty = false;
336
337 m_maxLength = TE_UNLIMITED_LENGTH ;
338 }
339
340 wxTextCtrl::~wxTextCtrl()
341 {
342 }
343
344
345 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
346 const wxString& str,
347 const wxPoint& pos,
348 const wxSize& size, long style,
349 const wxValidator& validator,
350 const wxString& name)
351 {
352 m_macIsUserPane = FALSE ;
353 m_editable = true ;
354
355 if ( !HasFlag(wxNO_BORDER) )
356 style |= wxSUNKEN_BORDER ;
357
358 if ( !wxTextCtrlBase::Create(parent, id, pos, size, style & ~(wxHSCROLL|wxVSCROLL), validator, name) )
359 return FALSE;
360
361 wxSize mySize = size ;
362
363 Rect bounds = wxMacGetBoundsForControl( this , pos , size ) ;
364
365 if ( m_windowStyle & wxTE_MULTILINE )
366 {
367 wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
368 wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
369
370 m_windowStyle |= wxTE_PROCESS_ENTER;
371 style |= wxTE_PROCESS_ENTER ;
372 }
373
374 #if TARGET_API_MAC_OSX
375 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
376 if ( UMAGetSystemVersion() >= 0x1030 )
377 {
378 m_peer = new wxMacMLTEHIViewControl( this , str , pos , size , style ) ;
379 }
380 #endif
381 #if !wxMAC_AWAYS_USE_MLTE
382 if ( !m_peer )
383 {
384 m_peer = new wxMacUnicodeTextControl( this , str , pos , size , style ) ;
385 }
386 #endif
387 #endif
388 if ( !m_peer )
389 {
390 // this control draws the border itself
391 if ( !HasFlag(wxNO_BORDER) )
392 m_windowStyle &= ~wxSUNKEN_BORDER ;
393 m_peer = new wxMacMLTEClassicControl( this , str , pos , size , style ) ;
394 }
395
396 MacPostControlCreate(pos,size) ;
397
398 if ( m_windowStyle & wxTE_READONLY)
399 {
400 SetEditable( false ) ;
401 }
402
403
404 return TRUE;
405 }
406
407 void wxTextCtrl::MacVisibilityChanged()
408 {
409 GetPeer()->VisibilityChanged( MacIsReallyShown() ) ;
410 }
411
412 void wxTextCtrl::MacEnabledStateChanged()
413 {
414 }
415
416 wxString wxTextCtrl::GetValue() const
417 {
418 return GetPeer()->GetStringValue() ;
419 }
420
421 void wxTextCtrl::GetSelection(long* from, long* to) const
422 {
423 GetPeer()->GetSelection( from , to ) ;
424 }
425
426 void wxTextCtrl::SetValue(const wxString& str)
427 {
428 // optimize redraws
429 if ( GetValue() == str )
430 return ;
431
432 GetPeer()->SetStringValue(str) ;
433 }
434
435 void wxTextCtrl::SetMaxLength(unsigned long len)
436 {
437 m_maxLength = len ;
438 }
439
440 bool wxTextCtrl::SetFont( const wxFont& font )
441 {
442 if ( !wxTextCtrlBase::SetFont( font ) )
443 return FALSE ;
444
445 GetPeer()->SetFont( font , GetForegroundColour() , GetWindowStyle() ) ;
446 return true ;
447 }
448
449 bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
450 {
451 GetPeer()->SetStyle( start , end , style ) ;
452 return true ;
453 }
454
455 bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
456 {
457 wxTextCtrlBase::SetDefaultStyle( style ) ;
458 SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
459 return TRUE ;
460 }
461
462 // Clipboard operations
463 void wxTextCtrl::Copy()
464 {
465 if (CanCopy())
466 {
467 GetPeer()->Copy() ;
468 }
469 }
470
471 void wxTextCtrl::Cut()
472 {
473 if (CanCut())
474 {
475 GetPeer()->Cut() ;
476
477 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
478 event.SetString( GetValue() ) ;
479 event.SetEventObject( this );
480 GetEventHandler()->ProcessEvent(event);
481 }
482 }
483
484 void wxTextCtrl::Paste()
485 {
486 if (CanPaste())
487 {
488 GetPeer()->Paste() ;
489 // eventually we should add setting the default style again
490
491 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
492 event.SetString( GetValue() ) ;
493 event.SetEventObject( this );
494 GetEventHandler()->ProcessEvent(event);
495 }
496 }
497
498 bool wxTextCtrl::CanCopy() const
499 {
500 // Can copy if there's a selection
501 long from, to;
502 GetSelection(& from, & to);
503 return (from != to);
504 }
505
506 bool wxTextCtrl::CanCut() const
507 {
508 if ( !IsEditable() )
509 {
510 return false ;
511 }
512 // Can cut if there's a selection
513 long from, to;
514 GetSelection(& from, & to);
515 return (from != to);
516 }
517
518 bool wxTextCtrl::CanPaste() const
519 {
520 if (!IsEditable())
521 return FALSE;
522
523 return GetPeer()->CanPaste() ;
524 }
525
526 void wxTextCtrl::SetEditable(bool editable)
527 {
528 if ( editable != m_editable )
529 {
530 m_editable = editable ;
531 GetPeer()->SetEditable( editable ) ;
532 }
533 }
534
535 void wxTextCtrl::SetInsertionPoint(long pos)
536 {
537 SetSelection( pos , pos ) ;
538 }
539
540 void wxTextCtrl::SetInsertionPointEnd()
541 {
542 long pos = GetLastPosition();
543 SetInsertionPoint(pos);
544 }
545
546 long wxTextCtrl::GetInsertionPoint() const
547 {
548 long begin,end ;
549 GetSelection( &begin , &end ) ;
550 return begin ;
551 }
552
553 long wxTextCtrl::GetLastPosition() const
554 {
555 return GetPeer()->GetLastPosition( ) ;
556 }
557
558 void wxTextCtrl::Replace(long from, long to, const wxString& str)
559 {
560 GetPeer()->Replace( from , to , str) ;
561 }
562
563 void wxTextCtrl::Remove(long from, long to)
564 {
565 GetPeer()->Remove( from , to ) ;
566 }
567
568 void wxTextCtrl::SetSelection(long from, long to)
569 {
570 GetPeer()->SetSelection( from , to ) ;
571 }
572
573 bool wxTextCtrl::LoadFile(const wxString& file)
574 {
575 if ( wxTextCtrlBase::LoadFile(file) )
576 {
577 return TRUE;
578 }
579
580 return FALSE;
581 }
582
583 void wxTextCtrl::WriteText(const wxString& str)
584 {
585 // TODO this MPRemoting will be moved into a remoting peer proxy for any command
586 if ( !wxIsMainThread() )
587 {
588 // unfortunately CW 8 is not able to correctly deduce the template types, so we have
589 // to instantiate explicitely
590 wxMacMPRemoteGUICall<wxTextCtrl,wxString>( this , &wxTextCtrl::WriteText , str ) ;
591 return ;
592 }
593 else
594 {
595 GetPeer()->WriteText( str ) ;
596 }
597 }
598
599 void wxTextCtrl::AppendText(const wxString& text)
600 {
601 SetInsertionPointEnd();
602 WriteText(text);
603 }
604
605 void wxTextCtrl::Clear()
606 {
607 GetPeer()->Clear() ;
608 }
609
610 bool wxTextCtrl::IsModified() const
611 {
612 return m_dirty;
613 }
614
615 bool wxTextCtrl::IsEditable() const
616 {
617 return IsEnabled() && m_editable ;
618 }
619
620 bool wxTextCtrl::AcceptsFocus() const
621 {
622 // we don't want focus if we can't be edited
623 return /*IsEditable() && */ wxControl::AcceptsFocus();
624 }
625
626 wxSize wxTextCtrl::DoGetBestSize() const
627 {
628 int wText = 100 ;
629
630 int hText;
631
632 // these are the numbers from the HIG, we reduce them by the borders
633 // first
634
635 switch( m_windowVariant )
636 {
637 case wxWINDOW_VARIANT_NORMAL :
638 hText = 22 - 6 ;
639 break ;
640 case wxWINDOW_VARIANT_SMALL :
641 hText = 19 - 6 ;
642 break ;
643 case wxWINDOW_VARIANT_MINI :
644 hText= 15 - 6 ;
645 break ;
646 default :
647 hText = 22 - 6;
648 break ;
649 }
650
651 // as the above numbers have some free space around the text
652 // we get 5 lines like this anyway
653 if ( m_windowStyle & wxTE_MULTILINE )
654 {
655 hText *= 5 ;
656 }
657
658 if ( !HasFlag(wxNO_BORDER) )
659 hText += 6 ;
660
661 return wxSize(wText, hText);
662 }
663
664 // ----------------------------------------------------------------------------
665 // Undo/redo
666 // ----------------------------------------------------------------------------
667
668 void wxTextCtrl::Undo()
669 {
670 if (CanUndo())
671 {
672 GetPeer()->Undo() ;
673 }
674 }
675
676 void wxTextCtrl::Redo()
677 {
678 if (CanRedo())
679 {
680 GetPeer()->Redo() ;
681 }
682 }
683
684 bool wxTextCtrl::CanUndo() const
685 {
686 if ( !IsEditable() )
687 {
688 return false ;
689 }
690 return GetPeer()->CanUndo() ;
691 }
692
693 bool wxTextCtrl::CanRedo() const
694 {
695 if ( !IsEditable() )
696 {
697 return false ;
698 }
699 return GetPeer()->CanRedo() ;
700 }
701
702 void wxTextCtrl::MarkDirty()
703 {
704 m_dirty = true;
705 }
706
707 void wxTextCtrl::DiscardEdits()
708 {
709 m_dirty = false;
710 }
711
712 int wxTextCtrl::GetNumberOfLines() const
713 {
714 return GetPeer()->GetNumberOfLines() ;
715 }
716
717 long wxTextCtrl::XYToPosition(long x, long y) const
718 {
719 return GetPeer()->XYToPosition( x , y ) ;
720 }
721
722 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
723 {
724 return GetPeer()->PositionToXY(pos , x , y ) ;
725 }
726
727 void wxTextCtrl::ShowPosition(long pos)
728 {
729 return GetPeer()->ShowPosition(pos) ;
730 }
731
732 int wxTextCtrl::GetLineLength(long lineNo) const
733 {
734 return GetPeer()->GetLineLength(lineNo) ;
735 }
736
737 wxString wxTextCtrl::GetLineText(long lineNo) const
738 {
739 return GetPeer()->GetLineText(lineNo) ;
740 }
741
742 /*
743 * Text item
744 */
745
746 void wxTextCtrl::Command(wxCommandEvent & event)
747 {
748 SetValue (event.GetString());
749 ProcessCommand (event);
750 }
751
752 void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
753 {
754 // By default, load the first file into the text window.
755 if (event.GetNumberOfFiles() > 0)
756 {
757 LoadFile(event.GetFiles()[0]);
758 }
759 }
760
761 void wxTextCtrl::OnChar(wxKeyEvent& event)
762 {
763 int key = event.GetKeyCode() ;
764 bool eat_key = false ;
765
766 if ( key == 'c' && event.MetaDown() )
767 {
768 if ( CanCopy() )
769 Copy() ;
770 return ;
771 }
772
773 if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
774 !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
775 /* && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
776 )
777 {
778 // eat it
779 return ;
780 }
781
782 // assume that any key not processed yet is going to modify the control
783 m_dirty = true;
784
785 if ( key == 'v' && event.MetaDown() )
786 {
787 if ( CanPaste() )
788 Paste() ;
789 return ;
790 }
791 if ( key == 'x' && event.MetaDown() )
792 {
793 if ( CanCut() )
794 Cut() ;
795 return ;
796 }
797 switch ( key )
798 {
799 case WXK_RETURN:
800 if (m_windowStyle & wxPROCESS_ENTER)
801 {
802 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
803 event.SetEventObject( this );
804 event.SetString( GetValue() );
805 if ( GetEventHandler()->ProcessEvent(event) )
806 return;
807 }
808 if ( !(m_windowStyle & wxTE_MULTILINE) )
809 {
810 wxWindow *parent = GetParent();
811 while( parent && !parent->IsTopLevel() && parent->GetDefaultItem() == NULL ) {
812 parent = parent->GetParent() ;
813 }
814 if ( parent && parent->GetDefaultItem() )
815 {
816 wxButton *def = wxDynamicCast(parent->GetDefaultItem(),
817 wxButton);
818 if ( def && def->IsEnabled() )
819 {
820 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
821 event.SetEventObject(def);
822 def->Command(event);
823 return ;
824 }
825 }
826
827 // this will make wxWidgets eat the ENTER key so that
828 // we actually prevent line wrapping in a single line
829 // text control
830 eat_key = TRUE;
831 }
832
833 break;
834
835 case WXK_TAB:
836 if ( !(m_windowStyle & wxTE_PROCESS_TAB))
837 {
838 int flags = 0;
839 if (!event.ShiftDown())
840 flags |= wxNavigationKeyEvent::IsForward ;
841 if (event.ControlDown())
842 flags |= wxNavigationKeyEvent::WinChange ;
843 Navigate(flags);
844 return;
845 }
846 else
847 {
848 // This is necessary (don't know why) or the tab will not
849 // be inserted.
850 WriteText(wxT("\t"));
851 }
852
853 break;
854 }
855
856 if (!eat_key)
857 {
858 // perform keystroke handling
859 if ( wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL )
860 CallNextEventHandler((EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() , (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
861 else
862 {
863 EventRecord rec ;
864 if ( wxMacConvertEventToRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) )
865 {
866 EventRecord *ev = &rec ;
867 short keycode ;
868 short keychar ;
869 keychar = short(ev->message & charCodeMask);
870 keycode = short(ev->message & keyCodeMask) >> 8 ;
871
872 m_peer->HandleKey( keycode , keychar , ev->modifiers ) ;
873 }
874 }
875 }
876 if ( ( key >= 0x20 && key < WXK_START ) ||
877 key == WXK_RETURN ||
878 key == WXK_DELETE ||
879 key == WXK_BACK)
880 {
881 wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
882 event1.SetString( GetValue() ) ;
883 event1.SetEventObject( this );
884 wxPostEvent(GetEventHandler(),event1);
885 }
886 }
887
888 // ----------------------------------------------------------------------------
889 // standard handlers for standard edit menu events
890 // ----------------------------------------------------------------------------
891
892 void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
893 {
894 Cut();
895 }
896
897 void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
898 {
899 Copy();
900 }
901
902 void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
903 {
904 Paste();
905 }
906
907 void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
908 {
909 Undo();
910 }
911
912 void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
913 {
914 Redo();
915 }
916
917 void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
918 {
919 event.Enable( CanCut() );
920 }
921
922 void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
923 {
924 event.Enable( CanCopy() );
925 }
926
927 void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
928 {
929 event.Enable( CanPaste() );
930 }
931
932 void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
933 {
934 event.Enable( CanUndo() );
935 }
936
937 void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
938 {
939 event.Enable( CanRedo() );
940 }
941
942 bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
943 {
944 return true ;
945 }
946
947 // user pane implementation
948
949 void wxTextCtrl::MacControlUserPaneDrawProc(wxInt16 part)
950 {
951 }
952
953 wxInt16 wxTextCtrl::MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y)
954 {
955 return kControlNoPart ;
956 }
957
958 wxInt16 wxTextCtrl::MacControlUserPaneTrackingProc(wxInt16 x, wxInt16 y, void* actionProc)
959 {
960 return kControlNoPart ;
961 }
962
963 void wxTextCtrl::MacControlUserPaneIdleProc()
964 {
965 }
966
967 wxInt16 wxTextCtrl::MacControlUserPaneKeyDownProc(wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers)
968 {
969 return kControlNoPart ;
970 }
971
972 void wxTextCtrl::MacControlUserPaneActivateProc(bool activating)
973 {
974 }
975
976 wxInt16 wxTextCtrl::MacControlUserPaneFocusProc(wxInt16 action)
977 {
978 return kControlNoPart ;
979 }
980
981 void wxTextCtrl::MacControlUserPaneBackgroundProc(void* info)
982 {
983 }
984
985 // ----------------------------------------------------------------------------
986 // implementation base class
987 // ----------------------------------------------------------------------------
988
989 wxMacTextControl::wxMacTextControl()
990 {
991 }
992
993 wxMacTextControl::~wxMacTextControl()
994 {
995 }
996
997 void wxMacTextControl::SetStyle(long start, long end, const wxTextAttr& style)
998 {
999 }
1000
1001 void wxMacTextControl::Copy()
1002 {
1003 }
1004
1005 void wxMacTextControl::Cut()
1006 {
1007 }
1008
1009 void wxMacTextControl::Paste()
1010 {
1011 }
1012
1013 bool wxMacTextControl::CanPaste() const
1014 {
1015 return false ;
1016 }
1017
1018 void wxMacTextControl::SetEditable(bool editable)
1019 {
1020 }
1021
1022 long wxMacTextControl::GetLastPosition() const
1023 {
1024 return GetStringValue().Length() ;
1025 }
1026
1027 void wxMacTextControl::Replace( long from , long to , const wxString str )
1028 {
1029 }
1030
1031 void wxMacTextControl::Clear()
1032 {
1033 SetStringValue( wxEmptyString ) ;
1034 }
1035
1036 bool wxMacTextControl::CanUndo() const
1037 {
1038 return false ;
1039 }
1040
1041 void wxMacTextControl::Undo() { }
1042
1043 bool wxMacTextControl::CanRedo() const
1044 {
1045 return false ;
1046 }
1047
1048 void wxMacTextControl::Redo()
1049 {
1050 }
1051
1052 long wxMacTextControl::XYToPosition(long x, long y) const
1053 {
1054 return 0 ;
1055 }
1056
1057 bool wxMacTextControl::PositionToXY(long pos, long *x, long *y) const
1058 {
1059 return false ;
1060 }
1061
1062 void wxMacTextControl::ShowPosition( long WXUNUSED(pos) )
1063 {
1064 }
1065
1066 int wxMacTextControl::GetNumberOfLines() const
1067 {
1068 ItemCount lines = 0 ;
1069 wxString content = GetStringValue() ;
1070 lines = 1;
1071 for (size_t i = 0; i < content.Length() ; i++)
1072 {
1073 if (content[i] == '\r') lines++;
1074 }
1075 return lines ;
1076 }
1077
1078 wxString wxMacTextControl::GetLineText(long lineNo) const
1079 {
1080 // TODO change this if possible to reflect real lines
1081 wxString content = GetStringValue() ;
1082
1083 // Find line first
1084 int count = 0;
1085 for (size_t i = 0; i < content.Length() ; i++)
1086 {
1087 if (count == lineNo)
1088 {
1089 // Add chars in line then
1090 wxString tmp;
1091
1092 for (size_t j = i; j < content.Length(); j++)
1093 {
1094 if (content[j] == '\n')
1095 return tmp;
1096
1097 tmp += content[j];
1098 }
1099
1100 return tmp;
1101 }
1102 if (content[i] == '\n') count++;
1103 }
1104 return wxEmptyString ;
1105 }
1106
1107 int wxMacTextControl::GetLineLength(long lineNo) const
1108 {
1109 // TODO change this if possible to reflect real lines
1110 wxString content = GetStringValue() ;
1111
1112 // Find line first
1113 int count = 0;
1114 for (size_t i = 0; i < content.Length() ; i++)
1115 {
1116 if (count == lineNo)
1117 {
1118 // Count chars in line then
1119 count = 0;
1120 for (size_t j = i; j < content.Length(); j++)
1121 {
1122 count++;
1123 if (content[j] == '\n') return count;
1124 }
1125
1126 return count;
1127 }
1128 if (content[i] == '\n') count++;
1129 }
1130 return 0 ;
1131 }
1132
1133 // ----------------------------------------------------------------------------
1134 // standard unicode control implementation
1135 // ----------------------------------------------------------------------------
1136
1137 #if TARGET_API_MAC_OSX
1138
1139 wxMacUnicodeTextControl::wxMacUnicodeTextControl( wxWindow *wxPeer,
1140 const wxString& str,
1141 const wxPoint& pos,
1142 const wxSize& size, long style )
1143 {
1144 m_font = wxPeer->GetFont() ;
1145 m_windowStyle = style ;
1146 Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
1147 wxString st = str ;
1148 wxMacConvertNewlines13To10( &st ) ;
1149 wxMacCFStringHolder cf(st , m_font.GetEncoding()) ;
1150 CFStringRef cfr = cf ;
1151 Boolean isPassword = ( m_windowStyle & wxTE_PASSWORD ) != 0 ;
1152 m_valueTag = isPassword ? kControlEditTextPasswordCFStringTag : kControlEditTextCFStringTag ;
1153 CreateEditUnicodeTextControl( MAC_WXHWND(wxPeer->MacGetTopLevelWindowRef()), &bounds , cfr , isPassword , NULL , &m_controlRef ) ;
1154
1155 if ( !(m_windowStyle & wxTE_MULTILINE) )
1156 {
1157 SetData<Boolean>( kControlEditTextPart , kControlEditTextSingleLineTag , true ) ;
1158 }
1159 }
1160
1161 wxMacUnicodeTextControl::~wxMacUnicodeTextControl()
1162 {
1163 }
1164
1165 void wxMacUnicodeTextControl::VisibilityChanged(bool shown)
1166 {
1167 if ( !(m_windowStyle & wxTE_MULTILINE) && shown )
1168 {
1169 // work around a refresh issue insofar as not always the entire content is shown even if this would be possible
1170 ControlEditTextSelectionRec sel ;
1171 CFStringRef value = NULL ;
1172
1173 verify_noerr( GetData<ControlEditTextSelectionRec>( 0, kControlEditTextSelectionTag, &sel ) );
1174 verify_noerr( GetData<CFStringRef>( 0, m_valueTag , &value ) );
1175 verify_noerr( SetData<CFStringRef>( 0, m_valueTag, &value ) );
1176 verify_noerr( SetData<ControlEditTextSelectionRec>( 0, kControlEditTextSelectionTag, &sel ) );
1177
1178 CFRelease( value ) ;
1179 }
1180 }
1181 wxString wxMacUnicodeTextControl::GetStringValue() const
1182 {
1183 wxString result ;
1184 CFStringRef value = GetData<CFStringRef>(0,m_valueTag) ;
1185 if ( value )
1186 {
1187 wxMacCFStringHolder cf(value) ;
1188 result = cf.AsString() ;
1189 }
1190 wxMacConvertNewlines10To13( &result ) ;
1191 return result ;
1192 }
1193 void wxMacUnicodeTextControl::SetStringValue( const wxString &str)
1194 {
1195 wxString st = str ;
1196 wxMacConvertNewlines13To10( &st ) ;
1197 wxMacCFStringHolder cf(st , m_font.GetEncoding() ) ;
1198 verify_noerr( SetData<CFStringRef>( 0, m_valueTag , cf ) ) ;
1199 }
1200 void wxMacUnicodeTextControl::Copy()
1201 {
1202 SendHICommand( kHICommandCopy ) ;
1203 }
1204 void wxMacUnicodeTextControl::Cut()
1205 {
1206 SendHICommand( kHICommandCut ) ;
1207 }
1208 void wxMacUnicodeTextControl::Paste()
1209 {
1210 SendHICommand( kHICommandPaste ) ;
1211 }
1212 bool wxMacUnicodeTextControl::CanPaste() const
1213 {
1214 return true ;
1215 }
1216 void wxMacUnicodeTextControl::SetEditable(bool editable)
1217 {
1218 SetData<Boolean>( 0 , kControlEditTextLockedTag , (Boolean) !editable ) ;
1219 }
1220 void wxMacUnicodeTextControl::Remove( long from , long to )
1221 {
1222 }
1223
1224 void wxMacUnicodeTextControl::GetSelection( long* from, long* to) const
1225 {
1226 ControlEditTextSelectionRec sel ;
1227 verify_noerr(GetData<ControlEditTextSelectionRec>( 0, kControlEditTextSelectionTag, &sel ) ) ;
1228 if ( from ) *from = sel.selStart ;
1229 if ( to ) *to = sel.selEnd ;
1230 }
1231
1232 void wxMacUnicodeTextControl::SetSelection( long from , long to )
1233 {
1234 ControlEditTextSelectionRec sel ;
1235 sel.selStart = from ;
1236 sel.selEnd = to ;
1237 SetData<ControlEditTextSelectionRec>( 0 , kControlEditTextSelectionTag, &sel ) ;
1238 }
1239
1240 void wxMacUnicodeTextControl::WriteText(const wxString& str)
1241 {
1242 wxString st = str ;
1243 wxMacConvertNewlines13To10( &st ) ;
1244 #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
1245 wxMacCFStringHolder cf(st , m_font.GetEncoding() ) ;
1246 CFStringRef value = cf ;
1247 SetData<CFStringRef>( 0, kControlEditTextInsertCFStringRefTag, &value );
1248 #else
1249 wxString val = GetStringValue() ;
1250 long start , end ;
1251 GetSelection( &start , &end ) ;
1252 val.Remove( start , end - start ) ;
1253 val.insert( start , str ) ;
1254 SetStringValue( val ) ;
1255 SetInsertionPoint( start + str.Length() ) ;
1256 #endif
1257 }
1258
1259 #endif
1260
1261 // ----------------------------------------------------------------------------
1262 // MLTE control implementation (common part)
1263 // ----------------------------------------------------------------------------
1264
1265 #if TARGET_API_MAC_OSX == 0
1266 // declaration needed because of one line in the code...
1267 static void TPUpdateVisibility(ControlRef theControl) ;
1268 #endif
1269
1270 // if mlte is on read only , no changes at all are allowed, not even from
1271 // procedural API, in order to allow changes via API all the same we must undo
1272 // the readonly status while we are executing, this class helps to do so
1273
1274 class EditHelper
1275 {
1276 public :
1277 EditHelper( TXNObject txn )
1278 {
1279 TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1280 m_txn = txn ;
1281 TXNGetTXNObjectControls( m_txn , 1 , tag , m_data ) ;
1282 if ( m_data[0].uValue == kTXNReadOnly )
1283 {
1284 TXNControlData data[] = { { kTXNReadWrite } } ;
1285 TXNSetTXNObjectControls( m_txn , false , 1 , tag , data ) ;
1286 }
1287 }
1288 ~EditHelper()
1289 {
1290 TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1291 if ( m_data[0].uValue == kTXNReadOnly )
1292 {
1293 TXNSetTXNObjectControls( m_txn , false , 1 , tag , m_data ) ;
1294 }
1295 }
1296 protected :
1297 TXNObject m_txn ;
1298 TXNControlData m_data[1] ;
1299 } ;
1300
1301 wxString wxMacMLTEControl::GetStringValue() const
1302 {
1303 wxString result ;
1304 OSStatus err ;
1305 Size actualSize = 0;
1306 {
1307 #if wxUSE_UNICODE
1308 Handle theText ;
1309 err = TXNGetDataEncoded( m_txn , kTXNStartOffset, kTXNEndOffset, &theText , kTXNUnicodeTextData );
1310 // all done
1311 if ( err )
1312 {
1313 actualSize = 0 ;
1314 }
1315 else
1316 {
1317 actualSize = GetHandleSize( theText ) / sizeof( UniChar) ;
1318 if ( actualSize > 0 )
1319 {
1320 wxChar *ptr = NULL ;
1321 #if SIZEOF_WCHAR_T == 2
1322 ptr = new wxChar[actualSize + 1 ] ;
1323 wxStrncpy( ptr , (wxChar*) *theText , actualSize ) ;
1324
1325 #else
1326 SetHandleSize( theText , ( actualSize + 1 ) * sizeof( UniChar ) ) ;
1327 HLock( theText ) ;
1328 (((UniChar*)*theText)[actualSize]) = 0 ;
1329 wxMBConvUTF16BE converter ;
1330 size_t noChars = converter.MB2WC( NULL , (const char*)*theText , 0 ) ;
1331 ptr = new wxChar[noChars + 1] ;
1332
1333 noChars = converter.MB2WC( ptr , (const char*)*theText , noChars ) ;
1334 ptr[noChars] = 0 ;
1335 HUnlock( theText ) ;
1336 #endif
1337 ptr[actualSize] = 0 ;
1338 result = wxString( ptr ) ;
1339 delete[] ptr ;
1340 }
1341 DisposeHandle( theText ) ;
1342 }
1343 #else
1344 Handle theText ;
1345 err = TXNGetDataEncoded( m_txn , kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
1346 // all done
1347 if ( err )
1348 {
1349 actualSize = 0 ;
1350 }
1351 else
1352 {
1353 actualSize = GetHandleSize( theText ) ;
1354 if ( actualSize > 0 )
1355 {
1356 HLock( theText ) ;
1357 result = wxString( *theText , wxConvLocal , actualSize ) ;
1358 HUnlock( theText ) ;
1359 }
1360 DisposeHandle( theText ) ;
1361 }
1362 #endif
1363 }
1364 wxMacConvertNewlines10To13( &result ) ;
1365 return result ;
1366 }
1367
1368 void wxMacMLTEControl::SetStringValue( const wxString &str)
1369 {
1370 wxString st = str ;
1371 wxMacConvertNewlines13To10( &st ) ;
1372 EditHelper help(m_txn) ;
1373
1374 // wxMacWindowClipper c( this ) ;
1375 #if !TARGET_API_MAC_OSX
1376 // otherwise scrolling might have problems ?
1377 TPUpdateVisibility( m_controlRef ) ;
1378 #endif
1379 SetTXNData( st , kTXNStartOffset, kTXNEndOffset ) ;
1380 TXNSetSelection( m_txn, 0, 0);
1381 TXNShowSelection( m_txn, kTXNShowStart);
1382 }
1383
1384 TXNFrameOptions wxMacMLTEControl::FrameOptionsFromWXStyle( long wxStyle )
1385 {
1386 TXNFrameOptions frameOptions =
1387 kTXNDontDrawCaretWhenInactiveMask ;
1388 if ( ! ( wxStyle & wxTE_NOHIDESEL ) )
1389 frameOptions |= kTXNDontDrawSelectionWhenInactiveMask ;
1390
1391 if ( wxStyle & wxTE_MULTILINE )
1392 {
1393 if ( ! ( wxStyle & wxTE_DONTWRAP ) )
1394 frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
1395 else
1396 {
1397 frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
1398 frameOptions |= kTXNWantHScrollBarMask ;
1399 }
1400
1401 if ( !(wxStyle & wxTE_NO_VSCROLL ) )
1402 frameOptions |= kTXNWantVScrollBarMask ;
1403 }
1404 else
1405 frameOptions |= kTXNSingleLineOnlyMask ;
1406
1407 if ( wxStyle & wxHSCROLL )
1408 frameOptions |= kTXNWantHScrollBarMask ;
1409
1410 return frameOptions ;
1411 }
1412
1413 void wxMacMLTEControl::AdjustCreationAttributes( const wxColour &background, bool visible )
1414 {
1415 TXNControlTag iControlTags[3] = { kTXNDoFontSubstitution, kTXNWordWrapStateTag };
1416 TXNControlData iControlData[3] = { {false}, {kTXNNoAutoWrap} };
1417 int toptag = 2 ;
1418 #if TARGET_API_MAC_OSX
1419 iControlTags[2] = kTXNVisibilityTag ;
1420 iControlData[2].uValue = visible ;
1421 toptag++ ;
1422 #endif
1423
1424 if ( m_windowStyle & wxTE_MULTILINE )
1425 {
1426 if (m_windowStyle & wxTE_DONTWRAP)
1427 iControlData[1].uValue = kTXNNoAutoWrap ;
1428 else
1429 iControlData[1].uValue = kTXNAutoWrap ;
1430
1431 }
1432 verify_noerr( TXNSetTXNObjectControls( m_txn, false, toptag,
1433 iControlTags, iControlData )) ;
1434
1435 // setting the default font
1436
1437 Str255 fontName ;
1438 SInt16 fontSize ;
1439 Style fontStyle ;
1440
1441 GetThemeFont(kThemeSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
1442
1443 TXNTypeAttributes typeAttr[] =
1444 {
1445 { kTXNQDFontNameAttribute , kTXNQDFontNameAttributeSize , { (void*) fontName } } ,
1446 { kTXNQDFontSizeAttribute , kTXNFontSizeAttributeSize , { (void*) (fontSize << 16) } } ,
1447 { kTXNQDFontStyleAttribute , kTXNQDFontStyleAttributeSize , { (void*) normal } } ,
1448 } ;
1449
1450 verify_noerr( TXNSetTypeAttributes (m_txn, sizeof( typeAttr ) / sizeof(TXNTypeAttributes) , typeAttr,
1451 kTXNStartOffset,
1452 kTXNEndOffset) );
1453
1454 if ( m_windowStyle & wxTE_PASSWORD )
1455 {
1456 UniChar c = 0xA5 ;
1457 verify_noerr(TXNEchoMode( m_txn , c , 0 , true )) ;
1458 }
1459
1460 TXNBackground tback;
1461 tback.bgType = kTXNBackgroundTypeRGB;
1462 tback.bg.color = MAC_WXCOLORREF( background.GetPixel() );
1463 TXNSetBackground( m_txn , &tback);
1464 }
1465
1466 int wxMacMLTEControl::ConvertAttribute( const wxTextAttr& style , TXNTypeAttributes typeAttr[] )
1467 {
1468 Str255 fontName = "\pMonaco" ;
1469 SInt16 fontSize = 12 ;
1470 Style fontStyle = normal ;
1471 RGBColor color ;
1472 int attrCounter = 0 ;
1473 if ( style.HasFont() )
1474 {
1475 const wxFont &font = style.GetFont() ;
1476 wxMacStringToPascal( font.GetFaceName() , fontName ) ;
1477 fontSize = font.GetPointSize() ;
1478 if ( font.GetUnderlined() )
1479 fontStyle |= underline ;
1480 if ( font.GetWeight() == wxBOLD )
1481 fontStyle |= bold ;
1482 if ( font.GetStyle() == wxITALIC )
1483 fontStyle |= italic ;
1484
1485 typeAttr[attrCounter].tag = kTXNQDFontNameAttribute ;
1486 typeAttr[attrCounter].size = kTXNQDFontNameAttributeSize ;
1487 typeAttr[attrCounter].data.dataPtr = (void*) fontName ;
1488 typeAttr[attrCounter+1].tag = kTXNQDFontSizeAttribute ;
1489 typeAttr[attrCounter+1].size = kTXNFontSizeAttributeSize ;
1490 typeAttr[attrCounter+1].data.dataValue = (fontSize << 16) ;
1491 typeAttr[attrCounter+2].tag = kTXNQDFontStyleAttribute ;
1492 typeAttr[attrCounter+2].size = kTXNQDFontStyleAttributeSize ;
1493 typeAttr[attrCounter+2].data.dataValue = fontStyle ;
1494 attrCounter += 3 ;
1495
1496 }
1497 if ( style.HasTextColour() )
1498 {
1499 typeAttr[attrCounter].tag = kTXNQDFontColorAttribute ;
1500 typeAttr[attrCounter].size = kTXNQDFontColorAttributeSize ;
1501 typeAttr[attrCounter].data.dataPtr = (void*) &color ;
1502 color = MAC_WXCOLORREF(style.GetTextColour().GetPixel()) ;
1503 attrCounter += 1 ;
1504 }
1505 return attrCounter ;
1506 }
1507
1508 void wxMacMLTEControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
1509 {
1510 EditHelper help(m_txn) ;
1511 wxTextAttr style(wxNullColour,wxNullColour,font) ;
1512 TXNTypeAttributes typeAttr[4] ;
1513 int attrCounter = ConvertAttribute( style , typeAttr ) ;
1514 if ( attrCounter > 0 )
1515 {
1516 verify_noerr( TXNSetTypeAttributes ( m_txn , attrCounter , typeAttr, kTXNStartOffset,kTXNEndOffset) );
1517 }
1518 }
1519 void wxMacMLTEControl::SetStyle(long start, long end, const wxTextAttr& style)
1520 {
1521 EditHelper help(m_txn) ;
1522 TXNTypeAttributes typeAttr[4] ;
1523 int attrCounter = ConvertAttribute( style , typeAttr ) ;
1524 if ( attrCounter > 0 )
1525 {
1526 verify_noerr( TXNSetTypeAttributes ( m_txn , attrCounter , typeAttr, start,end) );
1527 }
1528 }
1529
1530 void wxMacMLTEControl::Copy()
1531 {
1532 ClearCurrentScrap();
1533 TXNCopy(m_txn);
1534 TXNConvertToPublicScrap();
1535 }
1536
1537 void wxMacMLTEControl::Cut()
1538 {
1539 ClearCurrentScrap();
1540 TXNCut(m_txn);
1541 TXNConvertToPublicScrap();
1542 }
1543
1544 void wxMacMLTEControl::Paste()
1545 {
1546 TXNConvertFromPublicScrap();
1547 TXNPaste(m_txn);
1548 }
1549
1550 bool wxMacMLTEControl::CanPaste() const
1551 {
1552 return TXNIsScrapPastable() ;
1553 }
1554
1555 void wxMacMLTEControl::SetEditable(bool editable)
1556 {
1557 TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
1558 TXNControlData data[] = { { editable ? kTXNReadWrite : kTXNReadOnly } } ;
1559 TXNSetTXNObjectControls( m_txn , false , sizeof(tag) / sizeof (TXNControlTag) , tag , data ) ;
1560 }
1561
1562 long wxMacMLTEControl::GetLastPosition() const
1563 {
1564 long actualsize = 0 ;
1565
1566 Handle theText ;
1567 OSErr err = TXNGetDataEncoded( m_txn, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
1568 /* all done */
1569 if ( err )
1570 {
1571 actualsize = 0 ;
1572 }
1573 else
1574 {
1575 actualsize = GetHandleSize( theText ) ;
1576 DisposeHandle( theText ) ;
1577 }
1578
1579 return actualsize ;
1580 }
1581
1582 void wxMacMLTEControl::Replace( long from , long to , const wxString str )
1583 {
1584 wxString value = str ;
1585 wxMacConvertNewlines13To10( &value ) ;
1586
1587 EditHelper help( m_txn ) ;
1588
1589 TXNSetSelection(m_txn , from , to ) ;
1590 TXNClear( m_txn ) ;
1591 SetTXNData( str , kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
1592 }
1593
1594 void wxMacMLTEControl::Remove( long from , long to )
1595 {
1596 EditHelper help( m_txn ) ;
1597
1598 TXNSetSelection(m_txn , from , to ) ;
1599 TXNClear( m_txn ) ;
1600 }
1601
1602 void wxMacMLTEControl::GetSelection( long* from, long* to) const
1603 {
1604 TXNGetSelection( m_txn , (TXNOffset*) from , (TXNOffset*) to ) ;
1605 }
1606
1607 void wxMacMLTEControl::SetSelection( long from , long to )
1608 {
1609 /* change the selection */
1610 if ((from == -1) && (to == -1))
1611 TXNSelectAll(m_txn);
1612 else
1613 TXNSetSelection( m_txn, from, to);
1614 TXNShowSelection( m_txn, kTXNShowStart);
1615 }
1616
1617 void wxMacMLTEControl::WriteText(const wxString& str)
1618 {
1619 EditHelper helper( m_txn ) ;
1620 wxString st = str ;
1621 wxMacConvertNewlines13To10( &st ) ;
1622
1623 long start , end , dummy ;
1624 GetSelection( &start , &dummy ) ;
1625 SetTXNData( st , kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
1626 GetSelection( &dummy , &end ) ;
1627 // TODO SetStyle( start , end , GetDefaultStyle() ) ;
1628 }
1629
1630 void wxMacMLTEControl::Clear()
1631 {
1632 EditHelper st(m_txn) ;
1633 TXNSetSelection( m_txn , kTXNStartOffset , kTXNEndOffset ) ;
1634 TXNClear(m_txn);
1635 }
1636
1637 bool wxMacMLTEControl::CanUndo() const
1638 {
1639 return TXNCanUndo( m_txn , NULL ) ;
1640 }
1641
1642 void wxMacMLTEControl::Undo()
1643 {
1644 TXNUndo( m_txn ) ;
1645 }
1646
1647 bool wxMacMLTEControl::CanRedo() const
1648 {
1649 return TXNCanRedo( m_txn , NULL ) ;
1650 }
1651
1652 void wxMacMLTEControl::Redo()
1653 {
1654 TXNRedo( m_txn ) ;
1655 }
1656
1657 int wxMacMLTEControl::GetNumberOfLines() const
1658 {
1659 ItemCount lines = 0 ;
1660 TXNGetLineCount(m_txn, &lines ) ;
1661 return lines ;
1662 }
1663
1664 long wxMacMLTEControl::XYToPosition(long x, long y) const
1665 {
1666 Point curpt ;
1667
1668 long lastpos = GetLastPosition() ;
1669
1670 // TODO find a better implementation : while we can get the
1671 // line metrics of a certain line, we don't get its starting
1672 // position, so it would probably be rather a binary search
1673 // for the start position
1674 long xpos = 0 ;
1675 long ypos = 0 ;
1676 int lastHeight = 0 ;
1677
1678 ItemCount n ;
1679 for ( n = 0 ; n <= (ItemCount) lastpos ; ++n )
1680 {
1681 if ( y == ypos && x == xpos )
1682 return n ;
1683
1684 TXNOffsetToPoint( m_txn , n , &curpt);
1685
1686 if ( curpt.v > lastHeight )
1687 {
1688 xpos = 0 ;
1689 if ( n > 0 )
1690 ++ypos ;
1691 lastHeight = curpt.v ;
1692 }
1693 else
1694 ++xpos ;
1695 }
1696 return 0 ;
1697 }
1698
1699 bool wxMacMLTEControl::PositionToXY(long pos, long *x, long *y) const
1700 {
1701 Point curpt ;
1702
1703 long lastpos = GetLastPosition() ;
1704
1705 if ( y ) *y = 0 ;
1706 if ( x ) *x = 0 ;
1707
1708 if ( pos <= lastpos )
1709 {
1710 // TODO find a better implementation : while we can get the
1711 // line metrics of a certain line, we don't get its starting
1712 // position, so it would probably be rather a binary search
1713 // for the start position
1714 long xpos = 0 ;
1715 long ypos = 0 ;
1716 int lastHeight = 0 ;
1717
1718 ItemCount n ;
1719 for ( n = 0 ; n <= (ItemCount) pos ; ++n )
1720 {
1721 TXNOffsetToPoint(m_txn , n , &curpt);
1722
1723 if ( curpt.v > lastHeight )
1724 {
1725 xpos = 0 ;
1726 if ( n > 0 )
1727 ++ypos ;
1728 lastHeight = curpt.v ;
1729 }
1730 else
1731 ++xpos ;
1732 }
1733 if ( y ) *y = ypos ;
1734 if ( x ) *x = xpos ;
1735 }
1736
1737 return FALSE ;
1738 }
1739
1740 void wxMacMLTEControl::ShowPosition( long pos )
1741 {
1742 #if TARGET_RT_MAC_MACHO && defined(AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER)
1743 {
1744 Point current ;
1745 Point desired ;
1746 TXNOffset selstart , selend ;
1747 TXNGetSelection( m_txn , &selstart , &selend) ;
1748 TXNOffsetToPoint( m_txn, selstart , &current);
1749 TXNOffsetToPoint( m_txn, pos , &desired);
1750 //TODO use HIPoints for 10.3 and above
1751 if ( (UInt32) TXNScroll != (UInt32) kUnresolvedCFragSymbolAddress )
1752 {
1753 OSErr theErr = noErr;
1754 SInt32 dv = desired.v - current.v ;
1755 SInt32 dh = desired.h - current.h ;
1756 TXNShowSelection( m_txn , true ) ;
1757 theErr = TXNScroll( m_txn, kTXNScrollUnitsInPixels , kTXNScrollUnitsInPixels , &dv , &dh );
1758 wxASSERT_MSG( theErr == noErr, _T("TXNScroll returned an error!") );
1759 }
1760 }
1761 #endif
1762 }
1763
1764 void wxMacMLTEControl::SetTXNData( const wxString& st , TXNOffset start , TXNOffset end )
1765 {
1766 #if wxUSE_UNICODE
1767 #if SIZEOF_WCHAR_T == 2
1768 size_t len = st.Len() ;
1769 TXNSetData( m_txn , kTXNUnicodeTextData, (void*)st.wc_str(), len * 2,
1770 start, end);
1771 #else
1772 wxMBConvUTF16BE converter ;
1773 ByteCount byteBufferLen = converter.WC2MB( NULL , st.wc_str() , 0 ) ;
1774 UniChar *unibuf = (UniChar*) malloc(byteBufferLen) ;
1775 converter.WC2MB( (char*) unibuf , st.wc_str() , byteBufferLen ) ;
1776 TXNSetData( m_txn , kTXNUnicodeTextData, (void*)unibuf, byteBufferLen ,
1777 start, end);
1778 free( unibuf ) ;
1779 #endif
1780 #else
1781 wxCharBuffer text = st.mb_str(wxConvLocal) ;
1782 TXNSetData( m_txn , kTXNTextData, (void*)text.data(), strlen( text ) ,
1783 start, end);
1784 #endif
1785 }
1786
1787
1788 wxString wxMacMLTEControl::GetLineText(long lineNo) const
1789 {
1790 wxString line ;
1791 Point curpt ;
1792 wxString content = GetStringValue() ;
1793
1794 if ( lineNo < GetNumberOfLines() )
1795 {
1796 // TODO find a better implementation : while we can get the
1797 // line metrics of a certain line, we don't get its starting
1798 // position, so it would probably be rather a binary search
1799 // for the start position
1800 long xpos = 0 ;
1801 long ypos = 0 ;
1802 int lastHeight = 0 ;
1803 long lastpos = GetLastPosition() ;
1804
1805 ItemCount n ;
1806 for ( n = 0 ; n <= (ItemCount)lastpos ; ++n )
1807 {
1808 TXNOffsetToPoint( m_txn, n , &curpt);
1809
1810 if ( curpt.v > lastHeight )
1811 {
1812 if ( ypos == lineNo )
1813 return line ;
1814
1815 xpos = 0 ;
1816 if ( n > 0 )
1817 ++ypos ;
1818 lastHeight = curpt.v ;
1819 }
1820 else
1821 {
1822 if ( ypos == lineNo )
1823 line += content[n] ;
1824 ++xpos ;
1825 }
1826 }
1827 }
1828 return line ;
1829 }
1830
1831 int wxMacMLTEControl::GetLineLength(long lineNo) const
1832 {
1833 Point curpt ;
1834 if ( lineNo < GetNumberOfLines() )
1835 {
1836 // TODO find a better implementation : while we can get the
1837 // line metrics of a certain line, we don't get its starting
1838 // position, so it would probably be rather a binary search
1839 // for the start position
1840 long xpos = 0 ;
1841 long ypos = 0 ;
1842 int lastHeight = 0 ;
1843 long lastpos = GetLastPosition() ;
1844
1845 ItemCount n ;
1846 for ( n = 0 ; n <= (ItemCount) lastpos ; ++n )
1847 {
1848 TXNOffsetToPoint( m_txn , n , &curpt);
1849
1850 if ( curpt.v > lastHeight )
1851 {
1852 if ( ypos == lineNo )
1853 return xpos ;
1854
1855 xpos = 0 ;
1856 if ( n > 0 )
1857 ++ypos ;
1858 lastHeight = curpt.v ;
1859 }
1860 else
1861 ++xpos ;
1862 }
1863 }
1864 return 0 ;
1865 }
1866
1867
1868 // ----------------------------------------------------------------------------
1869 // MLTE control implementation (classic part)
1870 // ----------------------------------------------------------------------------
1871
1872 // CS:TODO we still have a problem getting properly at the text events of a control because under Carbon
1873 // the MLTE engine registers itself for the key events thus the normal flow never occurs, the only measure for the
1874 // moment is to avoid setting the true focus on the control, the proper solution at the end would be to have
1875 // an alternate path for carbon key events that routes automatically into the same wx flow of events
1876
1877 /* part codes */
1878
1879 /* kmUPTextPart is the part code we return to indicate the user has clicked
1880 in the text area of our control */
1881 #define kmUPTextPart 1
1882
1883
1884 /* routines for using existing user pane controls.
1885 These routines are useful for cases where you would like to use an
1886 existing user pane control in, say, a dialog window as a scrolling
1887 text edit field.*/
1888
1889 /* Utility Routines */
1890
1891 /* kUserClickedToFocusPart is a part code we pass to the SetKeyboardFocus
1892 routine. In our focus switching routine this part code is understood
1893 as meaning 'the user has clicked in the control and we need to switch
1894 the current focus to ourselves before we can continue'. */
1895 #define kUserClickedToFocusPart 100
1896
1897 /* STPTextPaneVars is a structure used for storing the the mUP Control's
1898 internal variables and state information. A handle to this record is
1899 stored in the pane control's reference value field using the
1900 SetControlReference routine. */
1901
1902 class STPTextPaneVars {
1903 public :
1904 /* OS records referenced */
1905 TXNObject fTXNRec; /* the txn record */
1906 TXNFrameID fTXNFrame; /* the txn frame ID */
1907 ControlRef fUserPaneRec; /* handle to the user pane control */
1908 WindowPtr fOwner; /* window containing control */
1909 GrafPtr fDrawingEnvironment; /* grafport where control is drawn */
1910 /* flags */
1911 Boolean fInFocus; /* true while the focus rect is drawn around the control */
1912 Boolean fIsActive; /* true while the control is drawn in the active state */
1913 Boolean fTXNObjectActive; /* reflects the activation state of the text edit record */
1914 Boolean fFocusDrawState; /* true if focus is drawn (default: true) */
1915 /* calculated locations */
1916 Rect fRBounds; /* control bounds */
1917 Rect fRTextArea; /* area where the text is drawn */
1918 Rect fRFocusOutline; /* rectangle used to draw the focus box */
1919 Rect fRTextOutline; /* rectangle used to draw the border */
1920 RgnHandle fRTextOutlineRegion; /* background region for the text, erased before calling TEUpdate */
1921 /* our focus advance override routine */
1922 EventHandlerUPP handlerUPP;
1923 EventHandlerRef handlerRef;
1924 bool fNoBorders ;
1925 bool fMultiline ;
1926 bool fVisible ;
1927 } ;
1928
1929 /* Univerals Procedure Pointer variables used by the
1930 mUP Control. These variables are set up
1931 the first time that mUPOpenControl is called. */
1932 ControlUserPaneDrawUPP gTPDrawProc = NULL;
1933 ControlUserPaneHitTestUPP gTPHitProc = NULL;
1934 ControlUserPaneTrackingUPP gTPTrackProc = NULL;
1935 ControlUserPaneIdleUPP gTPIdleProc = NULL;
1936 ControlUserPaneKeyDownUPP gTPKeyProc = NULL;
1937 ControlUserPaneActivateUPP gTPActivateProc = NULL;
1938 ControlUserPaneFocusUPP gTPFocusProc = NULL;
1939
1940 // one place for calculating all
1941 static void TPCalculateBounds(STPTextPaneVars *varsp, const Rect& bounds)
1942 {
1943 SetRect(&varsp->fRBounds, bounds.left, bounds.top, bounds.right, bounds.bottom);
1944 SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
1945 // eventually make TextOutline inset 1,1
1946 SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
1947 if ( !varsp->fNoBorders )
1948 {
1949 SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) ,
1950 bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
1951 }
1952 else
1953 {
1954 SetRect(&varsp->fRTextArea, bounds.left , bounds.top ,
1955 bounds.right, bounds.bottom);
1956 }
1957 }
1958
1959 OSStatus MLTESetObjectVisibility( STPTextPaneVars *varsp, Boolean vis , long wxStyle)
1960 {
1961 OSStatus err = noErr ;
1962 #if TARGET_API_MAC_OSX
1963 TXNControlTag iControlTags[1] = { kTXNVisibilityTag };
1964 TXNControlData iControlData[1] = {{ vis }};
1965 err = ::TXNSetTXNObjectControls( varsp->fTXNRec, false, 1, iControlTags, iControlData );
1966 #endif
1967 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
1968 if ( vis && textctrl )
1969 {
1970 Rect bounds ;
1971 UMAGetControlBoundsInWindowCoords( varsp->fUserPaneRec, &bounds);
1972 TPCalculateBounds( varsp , bounds ) ;
1973 wxMacWindowClipper cl(textctrl) ;
1974 TXNSetFrameBounds( varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
1975 varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
1976 TXNShowSelection( varsp->fTXNRec, kTXNShowStart);
1977 }
1978 return err ;
1979 }
1980
1981 // make sure we don't miss changes as carbon events are not available for these under classic
1982 static void TPUpdateVisibility(ControlRef theControl) {
1983 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
1984 if ( textctrl == NULL )
1985 return ;
1986
1987 STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
1988
1989 Rect bounds ;
1990 UMAGetControlBoundsInWindowCoords(theControl, &bounds);
1991 if ( textctrl->MacIsReallyShown() != varsp->fVisible )
1992 {
1993 // invalidate old position
1994 // InvalWindowRect( GetControlOwner( theControl ) , &varsp->fRBounds ) ;
1995 varsp->fVisible = textctrl->MacIsReallyShown() ;
1996 }
1997 if ( !EqualRect( &bounds , &varsp->fRBounds ) )
1998 {
1999 // old position
2000 Rect oldBounds = varsp->fRBounds ;
2001 TPCalculateBounds( varsp , bounds ) ;
2002 // we only recalculate when visible, otherwise scrollbars get drawn at incorrect places
2003 if ( varsp->fVisible )
2004 {
2005 wxMacWindowClipper cl(textctrl) ;
2006 TXNSetFrameBounds( varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
2007 varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
2008 }
2009 InvalWindowRect( GetControlOwner( theControl ) , &oldBounds ) ;
2010 InvalWindowRect( GetControlOwner( theControl ) , &varsp->fRBounds ) ;
2011 }
2012 }
2013
2014 // make correct activations
2015 static void TPActivatePaneText(STPTextPaneVars *varsp, Boolean setActive) {
2016
2017 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
2018 if (varsp->fTXNObjectActive != setActive && textctrl->MacIsReallyShown() )
2019 {
2020 varsp->fTXNObjectActive = setActive;
2021 TXNActivate(varsp->fTXNRec, varsp->fTXNFrame, varsp->fTXNObjectActive);
2022 if (varsp->fInFocus)
2023 TXNFocus( varsp->fTXNRec, varsp->fTXNObjectActive);
2024 }
2025 }
2026
2027 // update focus outlines
2028 static void TPRedrawFocusOutline(STPTextPaneVars *varsp) {
2029
2030 /* state changed */
2031 if (varsp->fFocusDrawState != (varsp->fIsActive && varsp->fInFocus))
2032 {
2033 varsp->fFocusDrawState = (varsp->fIsActive && varsp->fInFocus);
2034 DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fFocusDrawState);
2035 }
2036 }
2037
2038 // update TXN focus state
2039 static void TPFocusPaneText(STPTextPaneVars *varsp, Boolean setFocus) {
2040 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
2041
2042 if (varsp->fInFocus != setFocus && textctrl->MacIsReallyShown()) {
2043 varsp->fInFocus = setFocus;
2044 TXNFocus( varsp->fTXNRec, varsp->fInFocus);
2045 }
2046 }
2047
2048 // draw the control
2049 static pascal void TPPaneDrawProc(ControlRef theControl, ControlPartCode thePart) {
2050 /* set up our globals */
2051
2052 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
2053 if ( textctrl == NULL )
2054 return ;
2055 TPUpdateVisibility( theControl ) ;
2056
2057 STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
2058 if ( textctrl->MacIsReallyShown() )
2059 {
2060 wxMacWindowClipper clipper( textctrl ) ;
2061 TXNDraw(varsp->fTXNRec, NULL);
2062 if ( !varsp->fNoBorders )
2063 DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
2064 TPRedrawFocusOutline( varsp ) ;
2065 }
2066
2067 }
2068
2069
2070 /* TPPaneHitTestProc is called when the control manager would
2071 like to determine what part of the control the mouse resides over.
2072 We also call this routine from our tracking proc to determine how
2073 to handle mouse clicks. */
2074 static pascal ControlPartCode TPPaneHitTestProc(ControlRef theControl, Point where) {
2075 ControlPartCode result;
2076 /* set up our locals and lock down our globals*/
2077 result = 0;
2078 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
2079 if ( textctrl == NULL )
2080 return 0 ;
2081 TPUpdateVisibility( theControl ) ;
2082 STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
2083 if (textctrl->MacIsReallyShown() )
2084 {
2085 if (PtInRect(where, &varsp->fRBounds))
2086 result = kmUPTextPart;
2087 else
2088 {
2089 // sometimes we get the coords also in control local coordinates, therefore test again
2090 if ( textctrl->MacGetTopLevelWindow()->MacUsesCompositing() )
2091 {
2092 int x = 0 , y = 0 ;
2093 textctrl->MacClientToRootWindow( &x , &y ) ;
2094 where.h += x ;
2095 where.v += y ;
2096 }
2097 if (PtInRect(where, &varsp->fRBounds))
2098 result = kmUPTextPart;
2099 else
2100 result = 0;
2101 }
2102 }
2103 return result;
2104 }
2105
2106
2107
2108
2109
2110 /* TPPaneTrackingProc is called when the mouse is being held down
2111 over our control. This routine handles clicks in the text area
2112 and in the scroll bar. */
2113 static pascal ControlPartCode TPPaneTrackingProc(ControlRef theControl, Point startPt, ControlActionUPP actionProc) {
2114
2115 ControlPartCode partCodeResult;
2116 /* make sure we have some variables... */
2117 partCodeResult = 0;
2118 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
2119 if ( textctrl == NULL )
2120 return 0;
2121 TPUpdateVisibility( theControl ) ;
2122 STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
2123 if (textctrl->MacIsReallyShown() )
2124 {
2125 /* we don't do any of these functions unless we're in focus */
2126 if ( ! varsp->fInFocus) {
2127 WindowPtr owner;
2128 owner = GetControlOwner(theControl);
2129 ClearKeyboardFocus(owner);
2130 SetKeyboardFocus(owner, theControl, kUserClickedToFocusPart);
2131 }
2132 /* find the location for the click */
2133 // for compositing, we must convert these into toplevel window coordinates, because hittesting expects them
2134 if ( textctrl->MacGetTopLevelWindow()->MacUsesCompositing() )
2135 {
2136 int x = 0 , y = 0 ;
2137 textctrl->MacClientToRootWindow( &x , &y ) ;
2138 startPt.h += x ;
2139 startPt.v += y ;
2140 }
2141
2142 switch (TPPaneHitTestProc(theControl, startPt))
2143 {
2144
2145 /* handle clicks in the text part */
2146 case kmUPTextPart:
2147 {
2148 wxMacWindowClipper clipper( textctrl ) ;
2149
2150 EventRecord rec ;
2151 ConvertEventRefToEventRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) ;
2152 TXNClick( varsp->fTXNRec, &rec );
2153
2154 }
2155 break;
2156
2157 }
2158 }
2159 return partCodeResult;
2160 }
2161
2162
2163 /* TPPaneIdleProc is our user pane idle routine. When our text field
2164 is active and in focus, we use this routine to set the cursor. */
2165 static pascal void TPPaneIdleProc(ControlRef theControl) {
2166 /* set up locals */
2167 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
2168 if ( textctrl == NULL )
2169 return ;
2170 TPUpdateVisibility( theControl ) ;
2171 STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
2172 if (textctrl->MacIsReallyShown()) {
2173 /* if we're not active, then we have nothing to say about the cursor */
2174 if (varsp->fIsActive) {
2175 Rect bounds;
2176 Point mousep;
2177
2178 wxMacWindowClipper clipper( textctrl ) ;
2179 GetMouse(&mousep);
2180 /* there's a 'focus thing' and an 'unfocused thing' */
2181 if (varsp->fInFocus) {
2182 /* flash the cursor */
2183 SetPort(varsp->fDrawingEnvironment);
2184 TXNIdle(varsp->fTXNRec);
2185 /* set the cursor */
2186 if (PtInRect(mousep, &varsp->fRTextArea)) {
2187 RgnHandle theRgn;
2188 RectRgn((theRgn = NewRgn()), &varsp->fRTextArea);
2189 TXNAdjustCursor(varsp->fTXNRec, theRgn);
2190 DisposeRgn(theRgn);
2191 }
2192 else
2193 {
2194 // SetThemeCursor(kThemeArrowCursor);
2195 }
2196 } else {
2197 /* if it's in our bounds, set the cursor */
2198 UMAGetControlBoundsInWindowCoords(theControl, &bounds);
2199 if (PtInRect(mousep, &bounds))
2200 {
2201 // SetThemeCursor(kThemeArrowCursor);
2202 }
2203 }
2204 }
2205 }
2206 }
2207
2208
2209 /* TPPaneKeyDownProc is called whenever a keydown event is directed
2210 at our control. Here, we direct the keydown event to the text
2211 edit record and redraw the scroll bar and text field as appropriate. */
2212 static pascal ControlPartCode TPPaneKeyDownProc(ControlRef theControl,
2213 SInt16 keyCode, SInt16 charCode, SInt16 modifiers) {
2214
2215 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
2216 if ( textctrl == NULL )
2217 return 0;
2218 TPUpdateVisibility( theControl ) ;
2219
2220 STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
2221 if (varsp->fInFocus)
2222 {
2223 /* turn autoscrolling on and send the key event to text edit */
2224 wxMacWindowClipper clipper( textctrl ) ;
2225 EventRecord ev ;
2226 memset( &ev , 0 , sizeof( ev ) ) ;
2227 ev.what = keyDown ;
2228 ev.modifiers = modifiers ;
2229 ev.message = (( keyCode << 8 ) & keyCodeMask ) + ( charCode & charCodeMask ) ;
2230 TXNKeyDown( varsp->fTXNRec, &ev);
2231 }
2232 return kControlEntireControl;
2233 }
2234
2235
2236 /* TPPaneActivateProc is called when the window containing
2237 the user pane control receives activate events. Here, we redraw
2238 the control and it's text as necessary for the activation state. */
2239 static pascal void TPPaneActivateProc(ControlRef theControl, Boolean activating) {
2240 /* set up locals */
2241 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
2242
2243 if ( textctrl == NULL )
2244 return ;
2245 TPUpdateVisibility( theControl ) ;
2246
2247 STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
2248
2249 varsp->fIsActive = activating;
2250 wxMacWindowClipper clipper( textctrl ) ;
2251 TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);
2252 /* redraw the frame */
2253 if ( textctrl->MacIsReallyShown() )
2254 {
2255 if ( !varsp->fNoBorders )
2256 DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
2257 TPRedrawFocusOutline( varsp ) ;
2258 }
2259 }
2260
2261
2262 /* TPPaneFocusProc is called when every the focus changes to or
2263 from our control. Herein, switch the focus appropriately
2264 according to the parameters and redraw the control as
2265 necessary. */
2266 static pascal ControlPartCode TPPaneFocusProc(ControlRef theControl, ControlFocusPart action) {
2267 ControlPartCode focusResult;
2268
2269 focusResult = kControlFocusNoPart;
2270 wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
2271 if ( textctrl == NULL )
2272 return 0;
2273 TPUpdateVisibility( theControl ) ;
2274 STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
2275 /* if kControlFocusPrevPart and kControlFocusNextPart are received when the user is
2276 tabbing forwards (or shift tabbing backwards) through the items in the dialog,
2277 and kControlFocusNextPart will be received. When the user clicks in our field
2278 and it is not the current focus, then the constant kUserClickedToFocusPart will
2279 be received. The constant kControlFocusNoPart will be received when our control
2280 is the current focus and the user clicks in another control. In your focus routine,
2281 you should respond to these codes as follows:
2282
2283 kControlFocusNoPart - turn off focus and return kControlFocusNoPart. redraw
2284 the control and the focus rectangle as necessary.
2285
2286 kControlFocusPrevPart or kControlFocusNextPart - toggle focus on or off
2287 depending on its current state. redraw the control and the focus rectangle
2288 as appropriate for the new focus state. If the focus state is 'off', return the constant
2289 kControlFocusNoPart, otherwise return a non-zero part code.
2290 kUserClickedToFocusPart - is a constant defined for this example. You should
2291 define your own value for handling click-to-focus type events. */
2292 /* calculate the next highlight state */
2293 switch (action) {
2294 default:
2295 case kControlFocusNoPart:
2296 TPFocusPaneText(varsp, false);
2297 focusResult = kControlFocusNoPart;
2298 break;
2299 case kUserClickedToFocusPart:
2300 TPFocusPaneText(varsp, true);
2301 focusResult = 1;
2302 break;
2303 case kControlFocusPrevPart:
2304 case kControlFocusNextPart:
2305 TPFocusPaneText(varsp, ( ! varsp->fInFocus));
2306 focusResult = varsp->fInFocus ? 1 : kControlFocusNoPart;
2307 break;
2308 }
2309 TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);
2310 /* redraw the text fram and focus rectangle to indicate the
2311 new focus state */
2312 if ( textctrl->MacIsReallyShown() )
2313 {
2314 wxMacWindowClipper c( textctrl ) ;
2315 if ( !varsp->fNoBorders )
2316 DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
2317 TPRedrawFocusOutline( varsp ) ;
2318 }
2319 return focusResult;
2320 }
2321
2322 wxMacMLTEClassicControl::wxMacMLTEClassicControl( wxWindow *wxPeer,
2323 const wxString& str,
2324 const wxPoint& pos,
2325 const wxSize& size, long style )
2326 {
2327 m_font = wxPeer->GetFont() ;
2328 m_windowStyle = style ;
2329 Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
2330 wxString st = str ;
2331 wxMacConvertNewlines13To10( &st ) ;
2332
2333 wxMacConvertNewlines13To10( &st ) ;
2334
2335 short featurSet;
2336
2337 featurSet = kControlSupportsEmbedding | kControlSupportsFocus | kControlWantsIdle
2338 | kControlWantsActivate | kControlHandlesTracking | kControlHasSpecialBackground
2339 | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
2340 /* create the control */
2341
2342 verify_noerr( ::CreateUserPaneControl( MAC_WXHWND(wxPeer->GetParent()->MacGetTopLevelWindowRef()), &bounds, featurSet, &m_controlRef ) );
2343
2344 {
2345 // wxMacWindowClipper c(wxPeer) ;
2346 DoCreate();
2347 }
2348
2349 if ( wxPeer->MacIsReallyShown() )
2350 MLTESetObjectVisibility( (STPTextPaneVars*) m_macTXNvars, true , style ) ;
2351
2352 {
2353 // wxMacWindowClipper clipper( wxPeer ) ;
2354
2355 TPUpdateVisibility( m_controlRef ) ;
2356
2357 SetTXNData( st , kTXNStartOffset, kTXNEndOffset ) ;
2358
2359 TXNSetSelection( m_txn, 0, 0);
2360 TXNShowSelection( m_txn, kTXNShowStart);
2361 }
2362
2363 AdjustCreationAttributes( *wxWHITE , true ) ;
2364 }
2365
2366 wxMacMLTEClassicControl::~wxMacMLTEClassicControl()
2367 {
2368 // SetControlReference(m_controlRef , 0) ;
2369 TXNDeleteObject(m_txn);
2370 free(m_macTXNvars);
2371 }
2372
2373 void wxMacMLTEClassicControl::VisibilityChanged(bool shown)
2374 {
2375 MLTESetObjectVisibility((STPTextPaneVars*) m_macTXNvars , shown , m_windowStyle ) ;
2376 if ( !shown )
2377 InvalWindowRect( GetControlOwner( m_controlRef ) , &((STPTextPaneVars *)m_macTXNvars)->fRBounds ) ;
2378 }
2379
2380 OSStatus wxMacMLTEClassicControl::DoCreate()
2381 {
2382 Rect bounds;
2383 WindowRef theWindow;
2384
2385 OSStatus err = noErr ;
2386
2387 /* set up our globals */
2388 if (gTPDrawProc == NULL) gTPDrawProc = NewControlUserPaneDrawUPP(TPPaneDrawProc);
2389 if (gTPHitProc == NULL) gTPHitProc = NewControlUserPaneHitTestUPP(TPPaneHitTestProc);
2390 if (gTPTrackProc == NULL) gTPTrackProc = NewControlUserPaneTrackingUPP(TPPaneTrackingProc);
2391 if (gTPIdleProc == NULL) gTPIdleProc = NewControlUserPaneIdleUPP(TPPaneIdleProc);
2392 if (gTPKeyProc == NULL) gTPKeyProc = NewControlUserPaneKeyDownUPP(TPPaneKeyDownProc);
2393 if (gTPActivateProc == NULL) gTPActivateProc = NewControlUserPaneActivateUPP(TPPaneActivateProc);
2394 if (gTPFocusProc == NULL) gTPFocusProc = NewControlUserPaneFocusUPP(TPPaneFocusProc);
2395
2396 /* allocate our private storage */
2397 m_macTXNvars = (STPTextPaneVars *) malloc(sizeof(STPTextPaneVars));
2398
2399 /* set the initial settings for our private data */
2400 m_macTXNvars->fMultiline = m_windowStyle & wxTE_MULTILINE ;
2401 m_macTXNvars->fNoBorders = m_windowStyle & wxNO_BORDER ;
2402 m_macTXNvars->fInFocus = false;
2403 m_macTXNvars->fIsActive = true;
2404 m_macTXNvars->fTXNObjectActive = false;
2405 m_macTXNvars->fFocusDrawState = false ;
2406 m_macTXNvars->fUserPaneRec = m_controlRef ;
2407 m_macTXNvars->fVisible = true ;
2408
2409 theWindow = m_macTXNvars->fOwner = GetControlOwner(m_controlRef);
2410
2411 m_macTXNvars->fDrawingEnvironment = (GrafPtr) GetWindowPort(theWindow);
2412
2413 /* set up the user pane procedures */
2414 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(gTPDrawProc), &gTPDrawProc);
2415 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(gTPHitProc), &gTPHitProc);
2416 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneTrackingProcTag, sizeof(gTPTrackProc), &gTPTrackProc);
2417 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneIdleProcTag, sizeof(gTPIdleProc), &gTPIdleProc);
2418 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneKeyDownProcTag, sizeof(gTPKeyProc), &gTPKeyProc);
2419 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneActivateProcTag, sizeof(gTPActivateProc), &gTPActivateProc);
2420 SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneFocusProcTag, sizeof(gTPFocusProc), &gTPFocusProc);
2421
2422 /* calculate the rectangles used by the control */
2423 UMAGetControlBoundsInWindowCoords(m_controlRef, &bounds);
2424 m_macTXNvars->fRTextOutlineRegion = NewRgn() ;
2425 TPCalculateBounds( m_macTXNvars , bounds ) ;
2426
2427 /* set up the drawing environment */
2428 SetPort(m_macTXNvars->fDrawingEnvironment);
2429
2430 /* create the new edit field */
2431
2432 TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( m_windowStyle ) ;
2433
2434 verify_noerr(TXNNewObject(NULL, m_macTXNvars->fOwner, &m_macTXNvars->fRTextArea,
2435 frameOptions ,
2436 kTXNTextEditStyleFrameType,
2437 kTXNTextensionFile,
2438 kTXNSystemDefaultEncoding,
2439 &m_macTXNvars->fTXNRec, &m_macTXNvars->fTXNFrame, (TXNObjectRefcon) m_macTXNvars));
2440 m_txn = m_macTXNvars->fTXNRec ;
2441
2442 /* perform final activations and setup for our text field. Here,
2443 we assume that the window is going to be the 'active' window. */
2444 TPActivatePaneText(m_macTXNvars, m_macTXNvars->fIsActive && m_macTXNvars->fInFocus);
2445 /* all done */
2446 return err;
2447 }
2448
2449 // ----------------------------------------------------------------------------
2450 // MLTE control implementation (OSX part)
2451 // ----------------------------------------------------------------------------
2452
2453 #if TARGET_API_MAC_OSX
2454
2455 wxMacMLTEHIViewControl::wxMacMLTEHIViewControl( wxWindow *wxPeer,
2456 const wxString& str,
2457 const wxPoint& pos,
2458 const wxSize& size, long style )
2459 {
2460 m_font = wxPeer->GetFont() ;
2461 m_windowStyle = style ;
2462 Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
2463 wxString st = str ;
2464 wxMacConvertNewlines13To10( &st ) ;
2465
2466 HIRect hr = { bounds.left , bounds.top , bounds.right - bounds.left , bounds.bottom- bounds.top } ;
2467
2468 m_scrollView = NULL ;
2469 TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( style ) ;
2470 if ( frameOptions & (kTXNWantVScrollBarMask|kTXNWantHScrollBarMask) )
2471 {
2472 HIScrollViewCreate(( frameOptions & kTXNWantHScrollBarMask ? kHIScrollViewOptionsHorizScroll : 0) |
2473 ( frameOptions & kTXNWantVScrollBarMask ? kHIScrollViewOptionsVertScroll: 0 ) , &m_scrollView ) ;
2474
2475 HIViewSetFrame( m_scrollView, &hr );
2476 HIViewSetVisible( m_scrollView, true );
2477 }
2478
2479 m_textView = NULL ;
2480 HITextViewCreate( NULL , 0, frameOptions , &m_textView ) ;
2481 m_txn = HITextViewGetTXNObject( m_textView) ;
2482 HIViewSetVisible( m_textView , true ) ;
2483 if ( m_scrollView )
2484 {
2485 HIViewAddSubview( m_scrollView , m_textView ) ;
2486 m_controlRef = m_scrollView ;
2487 wxPeer->MacInstallEventHandler( (WXWidget) m_textView ) ;
2488 }
2489 else
2490 {
2491 HIViewSetFrame( m_textView, &hr );
2492 m_controlRef = m_textView ;
2493 }
2494
2495
2496 SetTXNData( st , kTXNStartOffset, kTXNEndOffset ) ;
2497
2498 TXNSetSelection( m_txn, 0, 0);
2499 TXNShowSelection( m_txn, kTXNShowStart);
2500
2501 AdjustCreationAttributes( *wxWHITE , true ) ;
2502 }
2503
2504 OSStatus wxMacMLTEHIViewControl::SetFocus( ControlFocusPart focusPart )
2505 {
2506 return SetKeyboardFocus( GetControlOwner( m_textView ) ,
2507 m_textView , focusPart ) ;
2508 }
2509
2510 bool wxMacMLTEHIViewControl::HasFocus() const
2511 {
2512 ControlRef control ;
2513 GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
2514 return control == m_textView ;
2515 }
2516
2517 bool wxMacMLTEHIViewControl::NeedsFocusRect() const
2518 {
2519 return m_windowStyle & wxNO_BORDER ? false : true;
2520 }
2521
2522 #endif
2523
2524 #endif // wxUSE_TEXTCTRL
wxWidgets (Impactor)