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


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