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