src/mac/carbon/textctrl.cpp

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