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