corrected preproc condition

[wxWidgets.git] / src / mac / carbon / textctrl.cpp

diff --git a/src/mac/carbon/textctrl.cpp b/src/mac/carbon/textctrl.cpp
index f69d2f0e9e3e325a4282f080b901cdff1e026d4e..61f918d55418b1603194ed1704eb07038e836538 100644 (file)
--- a/src/mac/carbon/textctrl.cpp
+++ b/src/mac/carbon/textctrl.cpp
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        textctrl.cpp
 // Purpose:     wxTextCtrl
 /////////////////////////////////////////////////////////////////////////////
 // Name:        textctrl.cpp
 // Purpose:     wxTextCtrl

-// Author:      AUTHOR
+// Author:      Stefan Csomor

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     1998-01-01

 // RCS-ID:      $Id$
 // RCS-ID:      $Id$

-// Copyright:   (c) AUTHOR
+// Copyright:   (c) Stefan Csomor

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -23,7 +23,16 @@
 #else
   #include <stat.h>
 #endif
 #else
   #include <stat.h>
 #endif

-#include <fstream.h>
+
+#include "wx/msgdlg.h"
+
+#if wxUSE_STD_IOSTREAM
+    #if wxUSE_IOSTREAMH
+        #include <fstream.h>
+    #else
+        #include <fstream>
+    #endif
+#endif

 
 #include "wx/app.h"
 #include "wx/dc.h"
 
 #include "wx/app.h"
 #include "wx/dc.h"


@@ -46,65 +55,120 @@
 #include <Scrap.h>
 #endif
 #include <MacTextEditor.h>
 #include <Scrap.h>
 #endif
 #include <MacTextEditor.h>

-#include "ATSUnicode.h"
-#include "TextCommon.h"
-#include "TextEncodingConverter.h"
+#include <ATSUnicode.h>
+#include <TextCommon.h>
+#include <TextEncodingConverter.h>

 #include "wx/mac/uma.h"
 
 #include "wx/mac/uma.h"
 

-extern wxApp *wxTheApp ;
+#define TE_UNLIMITED_LENGTH 0xFFFFFFFFUL
+#if TARGET_API_MAC_OSX
+ #define wxMAC_USE_MLTE 0
+ #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
+ #define wxMAC_USE_MLTE_HIVIEW 1
+ #else
+ #define wxMAC_USE_MLTE_HIVIEW 0
+ #endif
+#else
+ // there is no unicodetextctrl on classic, and hopefully MLTE works better there
+ #define wxMAC_USE_MLTE 1
+ #define wxMAC_USE_MLTE_HIVIEW 0
+#endif
+
+#if wxMAC_USE_MLTE
+
+TXNFrameOptions FrameOptionsFromWXStyle( long wxStyle )
+{
+    TXNFrameOptions frameOptions =
+        kTXNDontDrawCaretWhenInactiveMask ;
+    if ( ! ( wxStyle & wxTE_NOHIDESEL ) )
+        frameOptions |= kTXNDontDrawSelectionWhenInactiveMask ;
+
+    if ( wxStyle & wxTE_MULTILINE )
+    {
+        if ( ! ( wxStyle & wxTE_DONTWRAP ) )
+            frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
+        else
+        {
+            frameOptions |= kTXNAlwaysWrapAtViewEdgeMask ;
+            frameOptions |= kTXNWantHScrollBarMask ;
+        }
+
+        if ( !(wxStyle & wxTE_NO_VSCROLL ) )
+            frameOptions |= kTXNWantVScrollBarMask ;
+    }
+    else
+        frameOptions |= kTXNSingleLineOnlyMask ;
+    return frameOptions ;
+}
+
+void AdjustAttributesFromWXStyle( TXNObject txn , long wxStyle , bool visible )
+{
+    TXNControlTag iControlTags[3] = { kTXNDoFontSubstitution, kTXNWordWrapStateTag };
+    TXNControlData iControlData[3] = { {false}, {kTXNNoAutoWrap} };
+    int toptag = 2 ;
+#if TARGET_API_MAC_OSX
+    iControlTags[2] = kTXNVisibilityTag ;
+    iControlData[2].uValue = visible ;
+    toptag++ ;
+#endif        
+    
+    if ( wxStyle & wxTE_MULTILINE )
+    {
+        if (wxStyle & wxTE_DONTWRAP)
+            iControlData[1].uValue = kTXNNoAutoWrap ;
+        else
+            iControlData[1].uValue = kTXNAutoWrap ;
+        
+    }
+    verify_noerr( TXNSetTXNObjectControls( txn, false, toptag,
+                                        iControlTags, iControlData )) ;
+
+    Str255 fontName ;
+    SInt16 fontSize ;
+    Style fontStyle ;
+
+    GetThemeFont(kThemeSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
+
+    TXNTypeAttributes typeAttr[] =
+    {
+        {   kTXNQDFontNameAttribute , kTXNQDFontNameAttributeSize , { (void*) fontName } } ,
+        {   kTXNQDFontSizeAttribute , kTXNFontSizeAttributeSize , { (void*) (fontSize << 16) } } ,
+        {   kTXNQDFontStyleAttribute , kTXNQDFontStyleAttributeSize , {  (void*) normal } } ,
+    } ;
+
+    verify_noerr( TXNSetTypeAttributes (txn, sizeof( typeAttr ) / sizeof(TXNTypeAttributes) , typeAttr,
+          kTXNStartOffset,
+          kTXNEndOffset) );
+
+}
+
+#if !wxMAC_USE_MLTE_HIVIEW

 
 // CS:TODO we still have a problem getting properly at the text events of a control because under Carbon
 // the MLTE engine registers itself for the key events thus the normal flow never occurs, the only measure for the
 // moment is to avoid setting the true focus on the control, the proper solution at the end would be to have
 // an alternate path for carbon key events that routes automatically into the same wx flow of events
 
 
 // CS:TODO we still have a problem getting properly at the text events of a control because under Carbon
 // the MLTE engine registers itself for the key events thus the normal flow never occurs, the only measure for the
 // moment is to avoid setting the true focus on the control, the proper solution at the end would be to have
 // an alternate path for carbon key events that routes automatically into the same wx flow of events
 

-#include "MacTextEditor.h"
-

 /* part codes */
 
 /* kmUPTextPart is the part code we return to indicate the user has clicked
     in the text area of our control */
 #define kmUPTextPart 1
 
 /* part codes */
 
 /* kmUPTextPart is the part code we return to indicate the user has clicked
     in the text area of our control */
 #define kmUPTextPart 1
 

-/* kmUPScrollPart is the part code we return to indicate the user has clicked
-    in the scroll bar part of the control. */
-#define kmUPScrollPart 2
-

 
 /* routines for using existing user pane controls.
     These routines are useful for cases where you would like to use an
     existing user pane control in, say, a dialog window as a scrolling
     text edit field.*/
 
 /* routines for using existing user pane controls.
     These routines are useful for cases where you would like to use an
     existing user pane control in, say, a dialog window as a scrolling
     text edit field.*/

-    
-/* mUPOpenControl initializes a user pane control so it will be drawn
-    and will behave as a scrolling text edit field inside of a window.
-    This routine performs all of the initialization steps necessary,
-    except it does not create the user pane control itself.  theControl
-    should refer to a user pane control that you have either created
-    yourself or extracted from a dialog's control heirarchy using
-    the GetDialogItemAsControl routine.  */
-OSStatus mUPOpenControl(ControlHandle theControl, bool multiline);

 
 /* Utility Routines */
 
 
 /* Utility Routines */
 

-enum {
-    kShiftKeyCode = 56
-};
-

 /* kUserClickedToFocusPart is a part code we pass to the SetKeyboardFocus
     routine.  In our focus switching routine this part code is understood
     as meaning 'the user has clicked in the control and we need to switch
     the current focus to ourselves before we can continue'. */
 #define kUserClickedToFocusPart 100
 
 /* kUserClickedToFocusPart is a part code we pass to the SetKeyboardFocus
     routine.  In our focus switching routine this part code is understood
     as meaning 'the user has clicked in the control and we need to switch
     the current focus to ourselves before we can continue'. */
 #define kUserClickedToFocusPart 100
 

-
-/* kmUPClickScrollDelayTicks is a time measurement in ticks used to
-    slow the speed of 'auto scrolling' inside of our clickloop routine.
-    This value prevents the text from wizzzzzing by while the mouse
-    is being held down inside of the text area. */
-#define kmUPClickScrollDelayTicks 3
-
-

 /* STPTextPaneVars is a structure used for storing the the mUP Control's
     internal variables and state information.  A handle to this record is
     stored in the pane control's reference value field using the
 /* STPTextPaneVars is a structure used for storing the the mUP Control's
     internal variables and state information.  A handle to this record is
     stored in the pane control's reference value field using the


@@ -114,25 +178,37 @@ typedef struct {
         /* OS records referenced */
     TXNObject fTXNRec; /* the txn record */
     TXNFrameID fTXNFrame; /* the txn frame ID */
         /* OS records referenced */
     TXNObject fTXNRec; /* the txn record */
     TXNFrameID fTXNFrame; /* the txn frame ID */

-    ControlHandle fUserPaneRec;  /* handle to the user pane control */
+    ControlRef fUserPaneRec;  /* handle to the user pane control */

     WindowPtr fOwner; /* window containing control */
     GrafPtr fDrawingEnvironment; /* grafport where control is drawn */
         /* flags */
     Boolean fInFocus; /* true while the focus rect is drawn around the control */
     Boolean fIsActive; /* true while the control is drawn in the active state */
     WindowPtr fOwner; /* window containing control */
     GrafPtr fDrawingEnvironment; /* grafport where control is drawn */
         /* flags */
     Boolean fInFocus; /* true while the focus rect is drawn around the control */
     Boolean fIsActive; /* true while the control is drawn in the active state */

-    Boolean fTEActive; /* reflects the activation state of the text edit record */ 
-    Boolean fInDialogWindow; /* true if displayed in a dialog window */ 
+    Boolean fTXNObjectActive; /* reflects the activation state of the text edit record */
+       Boolean fFocusDrawState; /* true if focus is drawn (default: true) */ 

         /* calculated locations */
         /* calculated locations */

+    Rect fRBounds; /* control bounds */

     Rect fRTextArea; /* area where the text is drawn */
     Rect fRFocusOutline;  /* rectangle used to draw the focus box */
     Rect fRTextOutline; /* rectangle used to draw the border */
     Rect fRTextArea; /* area where the text is drawn */
     Rect fRFocusOutline;  /* rectangle used to draw the focus box */
     Rect fRTextOutline; /* rectangle used to draw the border */

-    RgnHandle fTextBackgroundRgn; /* background region for the text, erased before calling TEUpdate */
+    RgnHandle fRTextOutlineRegion; /* background region for the text, erased before calling TEUpdate */

         /* our focus advance override routine */
     EventHandlerUPP handlerUPP;
     EventHandlerRef handlerRef;
         /* our focus advance override routine */
     EventHandlerUPP handlerUPP;
     EventHandlerRef handlerRef;

-       bool fMultiline ;
+    bool fNoBorders ;
+    bool fMultiline ;
+    bool fVisible ;

 } STPTextPaneVars;
 
 } STPTextPaneVars;
 

+/* mUPOpenControl initializes a user pane control so it will be drawn
+    and will behave as a scrolling text edit field inside of a window.
+    This routine performs all of the initialization steps necessary,
+    except it does not create the user pane control itself.  theControl
+    should refer to a user pane control that you have either created
+    yourself or extracted from a dialog's control heirarchy using
+    the GetDialogItemAsControl routine.  */
+OSStatus mUPOpenControl(STPTextPaneVars* &handle, ControlRef theControl, long wxStyle);
+

 
 
 
 
 
 


@@ -147,82 +223,133 @@ ControlUserPaneKeyDownUPP gTPKeyProc = NULL;
 ControlUserPaneActivateUPP gTPActivateProc = NULL;
 ControlUserPaneFocusUPP gTPFocusProc = NULL;
 
 ControlUserPaneActivateUPP gTPActivateProc = NULL;
 ControlUserPaneFocusUPP gTPFocusProc = NULL;
 

-/* TPActivatePaneText activates or deactivates the text edit record
-    according to the value of setActive.  The primary purpose of this
-    routine is to ensure each call is only made once. */
-static void TPActivatePaneText(STPTextPaneVars **tpvars, Boolean setActive) {
-    STPTextPaneVars *varsp;
-    varsp = *tpvars;
-    if (varsp->fTEActive != setActive) {
-    
-        varsp->fTEActive = setActive;
-        
-        TXNActivate(varsp->fTXNRec, varsp->fTXNFrame, varsp->fTEActive);
+// one place for calculating all
+static void TPCalculateBounds(STPTextPaneVars *varsp, const Rect& bounds) 
+{
+    SetRect(&varsp->fRBounds, bounds.left, bounds.top, bounds.right, bounds.bottom);
+    SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
+    // eventually make TextOutline inset 1,1
+    SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
+    if ( !varsp->fNoBorders )
+    {
+       SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) ,
+        bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
+    }
+    else
+    {
+        SetRect(&varsp->fRTextArea, bounds.left , bounds.top ,
+            bounds.right, bounds.bottom);
+    }
+}

 
 

+OSStatus MLTESetObjectVisibility( STPTextPaneVars *varsp, Boolean vis , long wxStyle)
+{
+    OSStatus err = noErr ;
+#if TARGET_API_MAC_OSX
+    TXNControlTag iControlTags[1] = { kTXNVisibilityTag };
+    TXNControlData iControlData[1] = {{ vis }};
+    err = ::TXNSetTXNObjectControls( varsp->fTXNRec, false, 1, iControlTags, iControlData );
+#endif
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
+    if ( vis && textctrl )
+    {
+        Rect bounds ;
+        UMAGetControlBoundsInWindowCoords( varsp->fUserPaneRec, &bounds);
+        TPCalculateBounds( varsp , bounds ) ;
+        wxMacWindowClipper cl(textctrl) ;
+        TXNSetFrameBounds( varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
+            varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
+        TXNShowSelection( varsp->fTXNRec, kTXNShowStart);
+    }
+    return err ;
+}
+
+// make sure we don't miss changes as carbon events are not available for these under classic
+static void TPUpdateVisibility(ControlRef theControl) {
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
+    if ( textctrl == NULL )
+        return ;
+
+    STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
+
+    Rect bounds ;
+    UMAGetControlBoundsInWindowCoords(theControl, &bounds);
+    if ( textctrl->MacIsReallyShown() != varsp->fVisible )
+    {
+        // invalidate old position
+        // InvalWindowRect( GetControlOwner( theControl ) , &varsp->fRBounds ) ;
+        varsp->fVisible = textctrl->MacIsReallyShown() ;
+    }
+    if ( !EqualRect( &bounds , &varsp->fRBounds ) )
+    {
+        // old position
+        Rect oldBounds = varsp->fRBounds ;
+        TPCalculateBounds( varsp , bounds ) ;
+        // we only recalculate when visible, otherwise scrollbars get drawn at incorrect places
+        if ( varsp->fVisible )
+        {
+            wxMacWindowClipper cl(textctrl) ;
+            TXNSetFrameBounds( varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
+                varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
+        }
+        InvalWindowRect( GetControlOwner( theControl ) , &oldBounds ) ;
+        InvalWindowRect( GetControlOwner( theControl ) , &varsp->fRBounds ) ;
+    }
+}
+
+// make correct activations
+static void TPActivatePaneText(STPTextPaneVars *varsp, Boolean setActive) {
+
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
+    if (varsp->fTXNObjectActive != setActive && textctrl->MacIsReallyShown() ) 
+    {
+        varsp->fTXNObjectActive = setActive;
+        TXNActivate(varsp->fTXNRec, varsp->fTXNFrame, varsp->fTXNObjectActive);

         if (varsp->fInFocus)
         if (varsp->fInFocus)

-            TXNFocus( varsp->fTXNRec, varsp->fTEActive);
+            TXNFocus( varsp->fTXNRec, varsp->fTXNObjectActive);

     }
 }
 
     }
 }
 

+// update focus outlines
+static void TPRedrawFocusOutline(STPTextPaneVars *varsp) {

 
 

-/* TPFocusPaneText set the focus state for the text record. */
-static void TPFocusPaneText(STPTextPaneVars **tpvars, Boolean setFocus) {
-    STPTextPaneVars *varsp;
-    varsp = *tpvars;
-    if (varsp->fInFocus != setFocus) {
+    /* state changed */
+       if (varsp->fFocusDrawState != (varsp->fIsActive && varsp->fInFocus)) 
+       { 
+               varsp->fFocusDrawState = (varsp->fIsActive && varsp->fInFocus);
+               DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fFocusDrawState);
+       }
+}
+
+// update TXN focus state
+static void TPFocusPaneText(STPTextPaneVars *varsp, Boolean setFocus) {
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
+
+    if (varsp->fInFocus != setFocus && textctrl->MacIsReallyShown()) {

         varsp->fInFocus = setFocus;
         TXNFocus( varsp->fTXNRec, varsp->fInFocus);
     }
 }
 
         varsp->fInFocus = setFocus;
         TXNFocus( varsp->fTXNRec, varsp->fInFocus);
     }
 }
 

-
-/* TPPaneDrawProc is called to redraw the control and for update events
-    referring to the control.  This routine erases the text area's background,
-    and redraws the text.  This routine assumes the scroll bar has been
-    redrawn by a call to DrawControls. */
+// draw the control

 static pascal void TPPaneDrawProc(ControlRef theControl, ControlPartCode thePart) {
 static pascal void TPPaneDrawProc(ControlRef theControl, ControlPartCode thePart) {

-    STPTextPaneVars **tpvars, *varsp;
-    char state;
-    Rect bounds;

         /* set up our globals */
         /* set up our globals */

-        
-    tpvars = (STPTextPaneVars **) GetControlReference(theControl);
-    if (tpvars != NULL) {
-        state = HGetState((Handle) tpvars);
-        HLock((Handle) tpvars);
-        varsp = *tpvars;
-            
-            /* save the drawing state */
-        SetPort((**tpvars).fDrawingEnvironment);
-            /* verify our boundary */
-        GetControlBounds(theControl, &bounds);
-               if ( ! EqualRect(&bounds, &varsp->fRFocusOutline) ) {
-                   // scrollbar is on the border, we add one
-                   Rect oldbounds = varsp->fRFocusOutline ;
-                   InsetRect( &oldbounds , -1 , -1 ) ;
-                   
-                   InvalWindowRect( GetControlOwner( theControl ) , &oldbounds ) ;
-                       SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
-                       SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
-               SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) , 
-                   bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
-            RectRgn(varsp->fTextBackgroundRgn, &varsp->fRTextOutline);
-                       TXNSetFrameBounds(  varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left, 
-                           varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
-        }

 
 

-            /* update the text region */
-               RGBColor white = { 65535 , 65535 , 65535 } ;
-               RGBBackColor( &white ) ;
-        EraseRgn(varsp->fTextBackgroundRgn);
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
+    if ( textctrl == NULL )
+        return ;
+    TPUpdateVisibility( theControl ) ;
+  
+    STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
+    if ( textctrl->MacIsReallyShown() )
+    {
+        wxMacWindowClipper clipper( textctrl ) ;

         TXNDraw(varsp->fTXNRec, NULL);
         TXNDraw(varsp->fTXNRec, NULL);

-            /* restore the drawing environment */
-            /* draw the text frame and focus frame (if necessary) */
-        DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
-        if ((**tpvars).fIsActive && varsp->fInFocus) DrawThemeFocusRect(&varsp->fRFocusOutline, true);
-            /* release our globals */
-        HSetState((Handle) tpvars, state);
+        if ( !varsp->fNoBorders )
+               DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
+        TPRedrawFocusOutline( varsp ) ;

     }
     }

+

 }
 
 
 }
 
 


@@ -230,22 +357,21 @@ static pascal void TPPaneDrawProc(ControlRef theControl, ControlPartCode thePart
     like to determine what part of the control the mouse resides over.
     We also call this routine from our tracking proc to determine how
     to handle mouse clicks. */
     like to determine what part of the control the mouse resides over.
     We also call this routine from our tracking proc to determine how
     to handle mouse clicks. */

-static pascal ControlPartCode TPPaneHitTestProc(ControlHandle theControl, Point where) {
-    STPTextPaneVars **tpvars;
+static pascal ControlPartCode TPPaneHitTestProc(ControlRef theControl, Point where) {

     ControlPartCode result;
     ControlPartCode result;

-    char state;

         /* set up our locals and lock down our globals*/
     result = 0;
         /* set up our locals and lock down our globals*/
     result = 0;

-    tpvars = (STPTextPaneVars **) GetControlReference(theControl);
-    if (tpvars != NULL) {
-        state = HGetState((Handle) tpvars);
-        HLock((Handle) tpvars);
-            /* find the region where we clicked */
-        if (PtInRect(where, &(**tpvars).fRTextArea)) {
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
+    if ( textctrl == NULL )
+        return 0 ;
+    TPUpdateVisibility( theControl ) ;
+    STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
+    if (textctrl->MacIsReallyShown() ) 
+    {
+        if (PtInRect(where, &varsp->fRBounds))

             result = kmUPTextPart;
             result = kmUPTextPart;

-        } else result = 0;
-            /* release oure globals */
-        HSetState((Handle) tpvars, state);
+        else 
+            result = 0;

     }
     return result;
 }
     }
     return result;
 }


@@ -257,38 +383,51 @@ static pascal ControlPartCode TPPaneHitTestProc(ControlHandle theControl, Point
 /* TPPaneTrackingProc is called when the mouse is being held down
     over our control.  This routine handles clicks in the text area
     and in the scroll bar. */
 /* TPPaneTrackingProc is called when the mouse is being held down
     over our control.  This routine handles clicks in the text area
     and in the scroll bar. */

-static pascal ControlPartCode TPPaneTrackingProc(ControlHandle theControl, Point startPt, ControlActionUPP actionProc) {
-    STPTextPaneVars **tpvars, *varsp;
-    char state;
+static pascal ControlPartCode TPPaneTrackingProc(ControlRef theControl, Point startPt, ControlActionUPP actionProc) {
+       

     ControlPartCode partCodeResult;
     ControlPartCode partCodeResult;

-        /* make sure we have some variables... */
+       /* make sure we have some variables... */

     partCodeResult = 0;
     partCodeResult = 0;

-    tpvars = (STPTextPaneVars **) GetControlReference(theControl);
-    if (tpvars != NULL) {
-            /* lock 'em down */
-        state = HGetState((Handle) tpvars);
-        HLock((Handle) tpvars);
-        varsp = *tpvars;
-            /* we don't do any of these functions unless we're in focus */
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
+    if ( textctrl == NULL )
+        return 0;
+    TPUpdateVisibility( theControl ) ;
+    STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
+    if (textctrl->MacIsReallyShown() ) 
+       {
+               /* we don't do any of these functions unless we're in focus */

         if ( ! varsp->fInFocus) {
             WindowPtr owner;
             owner = GetControlOwner(theControl);
             ClearKeyboardFocus(owner);
             SetKeyboardFocus(owner, theControl, kUserClickedToFocusPart);
         }
         if ( ! varsp->fInFocus) {
             WindowPtr owner;
             owner = GetControlOwner(theControl);
             ClearKeyboardFocus(owner);
             SetKeyboardFocus(owner, theControl, kUserClickedToFocusPart);
         }

-            /* find the location for the click */
-        switch (TPPaneHitTestProc(theControl, startPt)) {
-                
-                /* handle clicks in the text part */
+               /* find the location for the click */
+        // for compositing, we must convert these into toplevel window coordinates, because hittesting expects them
+        if ( textctrl->MacGetTopLevelWindow()->MacUsesCompositing() )
+        {
+            int x = 0 , y = 0 ;
+            textctrl->MacClientToRootWindow( &x , &y ) ;
+            startPt.h += x ;
+            startPt.v += y ;
+        }
+
+        switch (TPPaneHitTestProc(theControl, startPt)) 
+        {
+                       
+                       /* handle clicks in the text part */

             case kmUPTextPart:
             case kmUPTextPart:

-                {   SetPort((**tpvars).fDrawingEnvironment);
-                    TXNClick( varsp->fTXNRec, (const EventRecord*) wxTheApp->MacGetCurrentEvent());
-                }
+                       { 
+                               wxMacWindowClipper clipper( textctrl ) ;
+                               
+                               EventRecord rec ;
+                               ConvertEventRefToEventRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) ;
+                               TXNClick( varsp->fTXNRec, &rec );
+                               
+                       }

                 break;
                 break;

-            
+                               

         }
         }

-        
-        HSetState((Handle) tpvars, state);

     }
     return partCodeResult;
 }
     }
     return partCodeResult;
 }


@@ -296,27 +435,25 @@ static pascal ControlPartCode TPPaneTrackingProc(ControlHandle theControl, Point
 
 /* TPPaneIdleProc is our user pane idle routine.  When our text field
     is active and in focus, we use this routine to set the cursor. */
 
 /* TPPaneIdleProc is our user pane idle routine.  When our text field
     is active and in focus, we use this routine to set the cursor. */

-static pascal void TPPaneIdleProc(ControlHandle theControl) {
-    STPTextPaneVars **tpvars, *varsp;
+static pascal void TPPaneIdleProc(ControlRef theControl) {

         /* set up locals */
         /* set up locals */

-    tpvars = (STPTextPaneVars **) GetControlReference(theControl);
-    if (tpvars != NULL) {
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
+    if ( textctrl == NULL )
+        return ;
+    TPUpdateVisibility( theControl ) ;
+    STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
+    if (textctrl->MacIsReallyShown()) {

             /* if we're not active, then we have nothing to say about the cursor */
             /* if we're not active, then we have nothing to say about the cursor */

-        if ((**tpvars).fIsActive) {
-            char state;
+        if (varsp->fIsActive) {

             Rect bounds;
             Point mousep;
             Rect bounds;
             Point mousep;

-                /* lock down the globals */
-            state = HGetState((Handle) tpvars);
-            HLock((Handle) tpvars);
-            varsp = *tpvars;
-                /* get the current mouse coordinates (in our window) */
-            SetPortWindowPort(GetControlOwner(theControl));
+
+            wxMacWindowClipper clipper( textctrl ) ;

             GetMouse(&mousep);
                 /* there's a 'focus thing' and an 'unfocused thing' */
             if (varsp->fInFocus) {
                     /* flash the cursor */
             GetMouse(&mousep);
                 /* there's a 'focus thing' and an 'unfocused thing' */
             if (varsp->fInFocus) {
                     /* flash the cursor */

-                SetPort((**tpvars).fDrawingEnvironment);
+                SetPort(varsp->fDrawingEnvironment);

                 TXNIdle(varsp->fTXNRec);
                 /* set the cursor */
                 if (PtInRect(mousep, &varsp->fRTextArea)) {
                 TXNIdle(varsp->fTXNRec);
                 /* set the cursor */
                 if (PtInRect(mousep, &varsp->fRTextArea)) {


@@ -324,15 +461,19 @@ static pascal void TPPaneIdleProc(ControlHandle theControl) {
                     RectRgn((theRgn = NewRgn()), &varsp->fRTextArea);
                     TXNAdjustCursor(varsp->fTXNRec, theRgn);
                     DisposeRgn(theRgn);
                     RectRgn((theRgn = NewRgn()), &varsp->fRTextArea);
                     TXNAdjustCursor(varsp->fTXNRec, theRgn);
                     DisposeRgn(theRgn);

-                 } else SetThemeCursor(kThemeArrowCursor);
+                 }
+                 else
+                 {
+                 // SetThemeCursor(kThemeArrowCursor);
+                 }

             } else {
                 /* if it's in our bounds, set the cursor */
             } else {
                 /* if it's in our bounds, set the cursor */

-                GetControlBounds(theControl, &bounds);
+                UMAGetControlBoundsInWindowCoords(theControl, &bounds);

                 if (PtInRect(mousep, &bounds))
                 if (PtInRect(mousep, &bounds))

-                    SetThemeCursor(kThemeArrowCursor);
+                {
+                //    SetThemeCursor(kThemeArrowCursor);
+                }

             }
             }

-            
-            HSetState((Handle) tpvars, state);

         }
     }
 }
         }
     }
 }


@@ -341,21 +482,25 @@ static pascal void TPPaneIdleProc(ControlHandle theControl) {
 /* TPPaneKeyDownProc is called whenever a keydown event is directed
     at our control.  Here, we direct the keydown event to the text
     edit record and redraw the scroll bar and text field as appropriate. */
 /* TPPaneKeyDownProc is called whenever a keydown event is directed
     at our control.  Here, we direct the keydown event to the text
     edit record and redraw the scroll bar and text field as appropriate. */

-static pascal ControlPartCode TPPaneKeyDownProc(ControlHandle theControl,
+static pascal ControlPartCode TPPaneKeyDownProc(ControlRef theControl,

                             SInt16 keyCode, SInt16 charCode, SInt16 modifiers) {
                             SInt16 keyCode, SInt16 charCode, SInt16 modifiers) {

-    STPTextPaneVars **tpvars;
-    tpvars = (STPTextPaneVars **) GetControlReference(theControl);
-    if (tpvars != NULL) {
-        if ((**tpvars).fInFocus) {
-                /* turn autoscrolling on and send the key event to text edit */
-            SetPort((**tpvars).fDrawingEnvironment);
-            EventRecord ev ;
-            memset( &ev , 0 , sizeof( ev ) ) ;
-            ev.what = keyDown ;
-            ev.modifiers = modifiers ;
-            ev.message = (( keyCode << 8 ) & keyCodeMask ) + ( charCode & charCodeMask ) ;
-            TXNKeyDown( (**tpvars).fTXNRec, &ev);
-        }
+
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
+    if ( textctrl == NULL )
+        return 0;
+    TPUpdateVisibility( theControl ) ;
+
+    STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
+    if (varsp->fInFocus) 
+    {
+            /* turn autoscrolling on and send the key event to text edit */
+        wxMacWindowClipper clipper( textctrl ) ;
+        EventRecord ev ;
+        memset( &ev , 0 , sizeof( ev ) ) ;
+        ev.what = keyDown ;
+        ev.modifiers = modifiers ;
+        ev.message = (( keyCode << 8 ) & keyCodeMask ) + ( charCode & charCodeMask ) ;
+        TXNKeyDown( varsp->fTXNRec, &ev);

     }
     return kControlEntireControl;
 }
     }
     return kControlEntireControl;
 }


@@ -364,25 +509,25 @@ static pascal ControlPartCode TPPaneKeyDownProc(ControlHandle theControl,
 /* TPPaneActivateProc is called when the window containing
     the user pane control receives activate events. Here, we redraw
     the control and it's text as necessary for the activation state. */
 /* TPPaneActivateProc is called when the window containing
     the user pane control receives activate events. Here, we redraw
     the control and it's text as necessary for the activation state. */

-static pascal void TPPaneActivateProc(ControlHandle theControl, Boolean activating) {
-    Rect bounds;
-    STPTextPaneVars **tpvars, *varsp;
-    char state;
+static pascal void TPPaneActivateProc(ControlRef theControl, Boolean activating) {

         /* set up locals */
         /* set up locals */

-    tpvars = (STPTextPaneVars **) GetControlReference(theControl);
-    if (tpvars != NULL) {
-        state = HGetState((Handle) tpvars);
-        HLock((Handle) tpvars);
-        varsp = *tpvars;
-            /* de/activate the text edit record */
-        SetPort((**tpvars).fDrawingEnvironment);
-            GetControlBounds(theControl, &bounds);
-            varsp->fIsActive = activating;
-            TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
-            /* redraw the frame */
-        DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
-        if (varsp->fInFocus) DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fIsActive);
-        HSetState((Handle) tpvars, state);
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
+    
+    if ( textctrl == NULL )
+        return ;
+    TPUpdateVisibility( theControl ) ;
+    
+    STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
+
+    varsp->fIsActive = activating;
+    wxMacWindowClipper clipper( textctrl ) ;
+    TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);
+        /* redraw the frame */
+    if ( textctrl->MacIsReallyShown() )
+    {
+        if ( !varsp->fNoBorders )
+               DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
+        TPRedrawFocusOutline( varsp ) ;

     }
 }
 
     }
 }
 


@@ -391,106 +536,104 @@ static pascal void TPPaneActivateProc(ControlHandle theControl, Boolean activati
     from our control.  Herein, switch the focus appropriately
     according to the parameters and redraw the control as
     necessary.  */
     from our control.  Herein, switch the focus appropriately
     according to the parameters and redraw the control as
     necessary.  */

-static pascal ControlPartCode TPPaneFocusProc(ControlHandle theControl, ControlFocusPart action) {
+static pascal ControlPartCode TPPaneFocusProc(ControlRef theControl, ControlFocusPart action) {

     ControlPartCode focusResult;
     ControlPartCode focusResult;

-    STPTextPaneVars **tpvars, *varsp;
-    char state;
-        /* set up locals */
+

     focusResult = kControlFocusNoPart;
     focusResult = kControlFocusNoPart;

-    tpvars = (STPTextPaneVars **) GetControlReference(theControl);
-    if (tpvars != NULL) {
-        state = HGetState((Handle) tpvars);
-        HLock((Handle) tpvars);
-        varsp = *tpvars;
-            /* if kControlFocusPrevPart and kControlFocusNextPart are received when the user is
-            tabbing forwards (or shift tabbing backwards) through the items in the dialog,
-            and kControlFocusNextPart will be received.  When the user clicks in our field
-            and it is not the current focus, then the constant kUserClickedToFocusPart will
-            be received.  The constant kControlFocusNoPart will be received when our control
-            is the current focus and the user clicks in another control.  In your focus routine,
-            you should respond to these codes as follows:
-
-            kControlFocusNoPart - turn off focus and return kControlFocusNoPart.  redraw
-                the control and the focus rectangle as necessary.
-
-            kControlFocusPrevPart or kControlFocusNextPart - toggle focus on or off
-                depending on its current state.  redraw the control and the focus rectangle
-                as appropriate for the new focus state.  If the focus state is 'off', return the constant
-                kControlFocusNoPart, otherwise return a non-zero part code.
-            kUserClickedToFocusPart - is a constant defined for this example.  You should
-                define your own value for handling click-to-focus type events. */
-            /* save the drawing state */
-        SetPort((**tpvars).fDrawingEnvironment);
-            /* calculate the next highlight state */
-        switch (action) {
-            default:
-            case kControlFocusNoPart:
-                TPFocusPaneText(tpvars, false);
-                focusResult = kControlFocusNoPart;
-                break;
-            case kUserClickedToFocusPart:
-                TPFocusPaneText(tpvars, true);
-                focusResult = 1;
-                break;
-            case kControlFocusPrevPart:
-            case kControlFocusNextPart:
-                TPFocusPaneText(tpvars, ( ! varsp->fInFocus));
-                focusResult = varsp->fInFocus ? 1 : kControlFocusNoPart;
-                break;
-        }
-            TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
-            /* redraw the text fram and focus rectangle to indicate the
-            new focus state */
-        DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
-        DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fIsActive && varsp->fInFocus);
-            /* done */
-        HSetState((Handle) tpvars, state);
+    wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
+    if ( textctrl == NULL )
+        return 0;
+    TPUpdateVisibility( theControl ) ;
+    STPTextPaneVars *varsp = (STPTextPaneVars *) textctrl->m_macTXNvars ;
+        /* if kControlFocusPrevPart and kControlFocusNextPart are received when the user is
+        tabbing forwards (or shift tabbing backwards) through the items in the dialog,
+        and kControlFocusNextPart will be received.  When the user clicks in our field
+        and it is not the current focus, then the constant kUserClickedToFocusPart will
+        be received.  The constant kControlFocusNoPart will be received when our control
+        is the current focus and the user clicks in another control.  In your focus routine,
+        you should respond to these codes as follows:
+
+        kControlFocusNoPart - turn off focus and return kControlFocusNoPart.  redraw
+            the control and the focus rectangle as necessary.
+
+        kControlFocusPrevPart or kControlFocusNextPart - toggle focus on or off
+            depending on its current state.  redraw the control and the focus rectangle
+            as appropriate for the new focus state.  If the focus state is 'off', return the constant
+            kControlFocusNoPart, otherwise return a non-zero part code.
+        kUserClickedToFocusPart - is a constant defined for this example.  You should
+            define your own value for handling click-to-focus type events. */
+         /* calculate the next highlight state */
+    switch (action) {
+        default:
+        case kControlFocusNoPart:
+            TPFocusPaneText(varsp, false);
+            focusResult = kControlFocusNoPart;
+            break;
+        case kUserClickedToFocusPart:
+            TPFocusPaneText(varsp, true);
+            focusResult = 1;
+            break;
+        case kControlFocusPrevPart:
+        case kControlFocusNextPart:
+            TPFocusPaneText(varsp, ( ! varsp->fInFocus));
+            focusResult = varsp->fInFocus ? 1 : kControlFocusNoPart;
+            break;
+    }
+    TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);
+    /* redraw the text fram and focus rectangle to indicate the
+    new focus state */
+    if ( textctrl->MacIsReallyShown() )
+    {
+        wxMacWindowClipper c( textctrl ) ;
+        if ( !varsp->fNoBorders )
+               DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
+        TPRedrawFocusOutline( varsp ) ;

     }
     return focusResult;
 }
 
 
 /* mUPOpenControl initializes a user pane control so it will be drawn
     }
     return focusResult;
 }
 
 
 /* mUPOpenControl initializes a user pane control so it will be drawn

-       and will behave as a scrolling text edit field inside of a window.
-       This routine performs all of the initialization steps necessary,
-       except it does not create the user pane control itself.  theControl
-       should refer to a user pane control that you have either created
-       yourself or extracted from a dialog's control heirarchy using
-       the GetDialogItemAsControl routine.  */
-OSStatus mUPOpenControl(ControlHandle theControl, bool multiline) 
-{
-       Rect bounds;
-       WindowRef theWindow;
-       STPTextPaneVars **tpvars, *varsp;
-       OSStatus err;
-       RGBColor rgbWhite = {0xFFFF, 0xFFFF, 0xFFFF};
-       TXNBackground tback;
-       
-               /* set up our globals */
-       if (gTPDrawProc == NULL) gTPDrawProc = NewControlUserPaneDrawUPP(TPPaneDrawProc);
-       if (gTPHitProc == NULL) gTPHitProc = NewControlUserPaneHitTestUPP(TPPaneHitTestProc);
-       if (gTPTrackProc == NULL) gTPTrackProc = NewControlUserPaneTrackingUPP(TPPaneTrackingProc);
-       if (gTPIdleProc == NULL) gTPIdleProc = NewControlUserPaneIdleUPP(TPPaneIdleProc);
-       if (gTPKeyProc == NULL) gTPKeyProc = NewControlUserPaneKeyDownUPP(TPPaneKeyDownProc);
-       if (gTPActivateProc == NULL) gTPActivateProc = NewControlUserPaneActivateUPP(TPPaneActivateProc);
-       if (gTPFocusProc == NULL) gTPFocusProc = NewControlUserPaneFocusUPP(TPPaneFocusProc);
-               
-               /* allocate our private storage */
-       tpvars = (STPTextPaneVars **) NewHandleClear(sizeof(STPTextPaneVars));
-       SetControlReference(theControl, (long) tpvars);
-       HLock((Handle) tpvars);
-       varsp = *tpvars;
-               /* set the initial settings for our private data */
-    varsp->fMultiline = multiline ;
-       varsp->fInFocus = false;
-       varsp->fIsActive = true;
-       varsp->fTEActive = true; // in order to get a deactivate
-       varsp->fUserPaneRec = theControl;
-       theWindow = varsp->fOwner = GetControlOwner(theControl);
+    and will behave as a scrolling text edit field inside of a window.
+    This routine performs all of the initialization steps necessary,
+    except it does not create the user pane control itself.  theControl
+    should refer to a user pane control that you have either created
+    yourself or extracted from a dialog's control heirarchy using
+    the GetDialogItemAsControl routine.  */
+OSStatus mUPOpenControl(STPTextPaneVars* &handle, ControlRef theControl, long wxStyle )
+{
+    Rect bounds;
+    WindowRef theWindow;
+    STPTextPaneVars *varsp;
+    OSStatus err = noErr ;
+
+        /* set up our globals */
+    if (gTPDrawProc == NULL) gTPDrawProc = NewControlUserPaneDrawUPP(TPPaneDrawProc);
+    if (gTPHitProc == NULL) gTPHitProc = NewControlUserPaneHitTestUPP(TPPaneHitTestProc);
+    if (gTPTrackProc == NULL) gTPTrackProc = NewControlUserPaneTrackingUPP(TPPaneTrackingProc);
+    if (gTPIdleProc == NULL) gTPIdleProc = NewControlUserPaneIdleUPP(TPPaneIdleProc);
+    if (gTPKeyProc == NULL) gTPKeyProc = NewControlUserPaneKeyDownUPP(TPPaneKeyDownProc);
+    if (gTPActivateProc == NULL) gTPActivateProc = NewControlUserPaneActivateUPP(TPPaneActivateProc);
+    if (gTPFocusProc == NULL) gTPFocusProc = NewControlUserPaneFocusUPP(TPPaneFocusProc);
+
+        /* allocate our private storage */
+    varsp = (STPTextPaneVars *) malloc(sizeof(STPTextPaneVars));
+    handle = varsp ;    
+
+        /* set the initial settings for our private data */
+    varsp->fMultiline = wxStyle & wxTE_MULTILINE ;
+    varsp->fNoBorders = wxStyle & wxNO_BORDER ;
+    varsp->fInFocus = false;
+    varsp->fIsActive = true;
+    varsp->fTXNObjectActive = false; 
+    varsp->fFocusDrawState = false ;
+    varsp->fUserPaneRec = theControl;
+    varsp->fVisible = true ;
+    
+    theWindow = varsp->fOwner = GetControlOwner(theControl);

 
     varsp->fDrawingEnvironment = (GrafPtr)  GetWindowPort(theWindow);
 
 
     varsp->fDrawingEnvironment = (GrafPtr)  GetWindowPort(theWindow);
 

-    varsp->fInDialogWindow = ( GetWindowKind(varsp->fOwner) == kDialogWindowKind );

         /* set up the user pane procedures */
     SetControlData(theControl, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(gTPDrawProc), &gTPDrawProc);
     SetControlData(theControl, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(gTPHitProc), &gTPHitProc);
         /* set up the user pane procedures */
     SetControlData(theControl, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(gTPDrawProc), &gTPDrawProc);
     SetControlData(theControl, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(gTPHitProc), &gTPHitProc);


@@ -499,64 +642,67 @@ OSStatus mUPOpenControl(ControlHandle theControl, bool multiline)
     SetControlData(theControl, kControlEntireControl, kControlUserPaneKeyDownProcTag, sizeof(gTPKeyProc), &gTPKeyProc);
     SetControlData(theControl, kControlEntireControl, kControlUserPaneActivateProcTag, sizeof(gTPActivateProc), &gTPActivateProc);
     SetControlData(theControl, kControlEntireControl, kControlUserPaneFocusProcTag, sizeof(gTPFocusProc), &gTPFocusProc);
     SetControlData(theControl, kControlEntireControl, kControlUserPaneKeyDownProcTag, sizeof(gTPKeyProc), &gTPKeyProc);
     SetControlData(theControl, kControlEntireControl, kControlUserPaneActivateProcTag, sizeof(gTPActivateProc), &gTPActivateProc);
     SetControlData(theControl, kControlEntireControl, kControlUserPaneFocusProcTag, sizeof(gTPFocusProc), &gTPFocusProc);

+    

         /* calculate the rectangles used by the control */
         /* calculate the rectangles used by the control */

-    GetControlBounds(theControl, &bounds);
-    SetRect(&varsp->fRFocusOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
-    SetRect(&varsp->fRTextOutline, bounds.left, bounds.top, bounds.right, bounds.bottom);
-    SetRect(&varsp->fRTextArea, bounds.left + 2 , bounds.top + (varsp->fMultiline ? 0 : 2) , 
-        bounds.right - (varsp->fMultiline ? 0 : 2), bounds.bottom - (varsp->fMultiline ? 0 : 2));
-        /* calculate the background region for the text.  In this case, it's kindof
-        and irregular region because we're setting the scroll bar a little ways inside
-        of the text area. */
-    RectRgn((varsp->fTextBackgroundRgn = NewRgn()), &varsp->fRTextOutline);
+    UMAGetControlBoundsInWindowCoords(theControl, &bounds);
+    varsp->fRTextOutlineRegion = NewRgn() ;
+    TPCalculateBounds( varsp , bounds ) ;

 
         /* set up the drawing environment */
     SetPort(varsp->fDrawingEnvironment);
 
         /* create the new edit field */
 
         /* set up the drawing environment */
     SetPort(varsp->fDrawingEnvironment);
 
         /* create the new edit field */

-    TXNNewObject(NULL, varsp->fOwner, &varsp->fRTextArea,
-         ( multiline ? kTXNWantVScrollBarMask : 0 ) |
-           kTXNDontDrawCaretWhenInactiveMask |
-           kTXNDontDrawSelectionWhenInactiveMask |
-               kTXNAlwaysWrapAtViewEdgeMask ,
+
+    TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( wxStyle ) ;
+
+    verify_noerr(TXNNewObject(NULL, varsp->fOwner, &varsp->fRTextArea,
+        frameOptions ,

         kTXNTextEditStyleFrameType,
         kTXNTextensionFile,
         kTXNTextEditStyleFrameType,
         kTXNTextensionFile,

-        kTXNSystemDefaultEncoding, 
-        &varsp->fTXNRec, &varsp->fTXNFrame, (TXNObjectRefcon) tpvars);
-
-               Str255 fontName ;
-               SInt16 fontSize ;
-               Style fontStyle ;
-               
-               GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
-
-               TXNTypeAttributes typeAttr[] =
-               {
-            {   kTXNQDFontNameAttribute , kTXNQDFontNameAttributeSize , { (void*) fontName } } ,
-                   {   kTXNQDFontSizeAttribute , kTXNFontSizeAttributeSize , { (void*) (fontSize << 16) } } ,
-                   {   kTXNQDFontStyleAttribute , kTXNQDFontStyleAttributeSize , {  (void*) normal } } ,
-        } ;
-
-    OSStatus status = TXNSetTypeAttributes (varsp->fTXNRec, sizeof( typeAttr ) / sizeof(TXNTypeAttributes) , typeAttr,
-      kTXNStartOffset,
-      kTXNEndOffset);
-        /* set the field's background */
-    tback.bgType = kTXNBackgroundTypeRGB;
-    tback.bg.color = rgbWhite;
-    TXNSetBackground( varsp->fTXNRec, &tback);
-               
-        /* unlock our storage */
-    HUnlock((Handle) tpvars);
+        kTXNSystemDefaultEncoding,
+        &varsp->fTXNRec, &varsp->fTXNFrame, (TXNObjectRefcon) varsp));
+
+    AdjustAttributesFromWXStyle( varsp->fTXNRec , wxStyle , varsp->fVisible ) ;

         /* perform final activations and setup for our text field.  Here,
         we assume that the window is going to be the 'active' window. */
         /* perform final activations and setup for our text field.  Here,
         we assume that the window is going to be the 'active' window. */

-    TPActivatePaneText(tpvars, varsp->fIsActive && varsp->fInFocus);
+    TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);

         /* all done */
         /* all done */

-    return noErr;
+    return err;

 }
 
 }
 

+#else
+struct STPTextPaneVars
+{
+} ;

 
 

+#endif
+
+static void SetTXNData( STPTextPaneVars *varsp, TXNObject txn , const wxString& st , TXNOffset start , TXNOffset end )
+{
+#if wxUSE_UNICODE
+#if SIZEOF_WCHAR_T == 2
+       size_t len = st.Len() ;
+    TXNSetData( txn , kTXNUnicodeTextData,  (void*)st.wc_str(), len * 2,
+      start, end);
+#else
+       wxMBConvUTF16BE converter ;
+       ByteCount byteBufferLen = converter.WC2MB( NULL , st.wc_str() , 0 ) ;
+       UniChar *unibuf = (UniChar*) malloc(byteBufferLen) ;
+       converter.WC2MB( (char*) unibuf , st.wc_str() , byteBufferLen ) ;
+    TXNSetData( txn , kTXNUnicodeTextData,  (void*)unibuf, byteBufferLen ,
+      start, end);
+       free( unibuf ) ;
+#endif
+#else
+       wxCharBuffer text =  st.mb_str(wxConvLocal)  ;
+    TXNSetData( txn , kTXNTextData,  (void*)text.data(), strlen( text ) ,
+      start, end);
+#endif  
+}

 
 
 
 

+#endif
+

 #if !USE_SHARED_LIBRARY
 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
 
 #if !USE_SHARED_LIBRARY
 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
 


@@ -578,202 +724,409 @@ END_EVENT_TABLE()
 #endif
 
 // Text item
 #endif
 
 // Text item

-wxTextCtrl::wxTextCtrl()
+void wxTextCtrl::Init()

 {
 {

-  m_macTE = NULL ;

   m_macTXN = NULL ;
   m_macTXNvars = NULL ;
   m_macTXN = NULL ;
   m_macTXNvars = NULL ;

-  m_macUsesTXN = false ;
+

   m_editable = true ;
   m_editable = true ;

+  m_dirty = false;
+
+  m_maxLength = TE_UNLIMITED_LENGTH ;

 }
 
 wxTextCtrl::~wxTextCtrl()
 {
 }
 
 wxTextCtrl::~wxTextCtrl()
 {

-    if ( m_macUsesTXN )
-    {
-        SetControlReference((ControlHandle)m_macControl, 0) ;
-        TXNDeleteObject((TXNObject)m_macTXN);
-        /* delete our private storage */
-        DisposeHandle((Handle) m_macTXNvars);
-        /* zero the control reference */
-    }
+#if wxMAC_USE_MLTE
+    SetControlReference((ControlRef)m_macControl, 0) ;
+#if !wxMAC_USE_MLTE_HIVIEW
+    TXNDeleteObject((TXNObject)m_macTXN);
+#endif
+    /* delete our private storage */
+    free(m_macTXNvars);
+    /* zero the control reference */
+#endif

 }
 
 }
 

-const short kVerticalMargin = 2 ;
-const short kHorizontalMargin = 2 ;

 
 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
 
 bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,

-           const wxString& st,
+           const wxString& str,

            const wxPoint& pos,
            const wxSize& size, long style,
            const wxValidator& validator,
            const wxString& name)
 {
            const wxPoint& pos,
            const wxSize& size, long style,
            const wxValidator& validator,
            const wxString& name)
 {

-  m_macTE = NULL ;
-  m_macTXN = NULL ;
-  m_macTXNvars = NULL ;
-  m_macUsesTXN = false ;
-  m_editable = true ;
-
-  m_macUsesTXN = ! (style & wxTE_PASSWORD ) ; 
-
-  m_macUsesTXN &= (TXNInitTextension != (void*) kUnresolvedCFragSymbolAddress) ;
+    m_macIsUserPane = FALSE ;

     
     

+    m_macTXN = NULL ;
+    m_macTXNvars = NULL ;
+    m_editable = true ;
+

     // base initialization
     // base initialization

-    if ( !CreateBase(parent, id, pos, size, style, validator, name) )
+    if ( !wxTextCtrlBase::Create(parent, id, pos, size, style & ~(wxHSCROLL|wxVSCROLL), validator, name) )

         return FALSE;
 
     wxSize mySize = size ;
         return FALSE;
 
     wxSize mySize = size ;

-       if ( m_macUsesTXN )
-       {
-               m_macHorizontalBorder = 5 ; // additional pixels around the real control
-               m_macVerticalBorder = 3 ;
-       }
-       else
+
+    Rect bounds = wxMacGetBoundsForControl( this , pos , size ) ;    
+
+    if ( m_windowStyle & wxTE_MULTILINE )

     {
     {

-        m_macHorizontalBorder = 5 ; // additional pixels around the real control
-        m_macVerticalBorder = 5 ;
-    }
+        wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
+                      wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );

 
 

+        m_windowStyle |= wxTE_PROCESS_ENTER;
+    }

 
 

-    Rect bounds ;
-    Str255 title ;
-    /*
-    if ( mySize.y == -1 )
+    wxString st = str ;
+    wxMacConvertNewlines13To10( &st ) ;
+#if wxMAC_USE_MLTE

     {
     {

-        mySize.y = 13 ;
-        if ( m_windowStyle & wxTE_MULTILINE )
-            mySize.y *= 5 ;
+#if wxMAC_USE_MLTE_HIVIEW
+        HIRect hr = { bounds.left , bounds.top , bounds.right - bounds.left , bounds.bottom- bounds.top } ;
+        HIViewRef scrollView = NULL ;
+        TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( style ) ;
+
+        if ( frameOptions & (kTXNWantVScrollBarMask|kTXNWantHScrollBarMask) )
+        {
+            HIScrollViewCreate(( frameOptions & kTXNWantHScrollBarMask ? kHIScrollViewOptionsHorizScroll : 0) | 
+                ( frameOptions & kTXNWantVScrollBarMask ? kHIScrollViewOptionsVertScroll: 0 ) , &scrollView ) ;
+           
+               HIViewSetFrame( scrollView, &hr );
+               HIViewSetVisible( scrollView, true );
+        }
+        HIViewRef textView ;
+        HITextViewCreate( NULL , 0, frameOptions , (ControlRef*) &textView ) ;
+        m_macTXN = HITextViewGetTXNObject( textView) ;
+        AdjustAttributesFromWXStyle( (TXNObject) m_macTXN , style , true ) ;
+        HIViewSetVisible( (ControlRef) textView , true ) ;
+        if ( scrollView )
+        {
+            HIViewAddSubview( scrollView , textView ) ;
+            m_macControl = (WXWidget) scrollView ;
+        }
+        else
+        {
+            m_macControl = (WXWidget) textView ;
+        }
+#else
+        short featurSet;
+
+        featurSet = kControlSupportsEmbedding | kControlSupportsFocus  | kControlWantsIdle
+                | kControlWantsActivate | kControlHandlesTracking | kControlHasSpecialBackground
+                | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
+            /* create the control */
+        verify_noerr( CreateUserPaneControl( MAC_WXHWND(GetParent()->MacGetTopLevelWindowRef()) , &bounds, featurSet , (ControlRef*) &m_macControl) ) ;

         
         

-        mySize.y += 2 * m_macVerticalBorder ;
+        wxMacWindowClipper c(this) ;
+        STPTextPaneVars *varsp ;
+        mUPOpenControl( varsp, (ControlRef) m_macControl, m_windowStyle );
+        m_macTXNvars = varsp ;
+        m_macTXN =  varsp->fTXNRec ;
+#endif
+
+        if ( style & wxTE_PASSWORD )
+        {
+            UniChar c = 0xA5 ;
+            verify_noerr(TXNEchoMode( (TXNObject) m_macTXN , c , 0 , true )) ;
+        }

     }
     }

-    */
-    MacPreControlCreate( parent , id ,  "" , pos , mySize ,style, validator , name , &bounds , title ) ;
+    MacPostControlCreate(pos,size) ;
+        
+#if !wxMAC_USE_MLTE_HIVIEW
+    if ( MacIsReallyShown() )
+        MLTESetObjectVisibility( (STPTextPaneVars*) m_macTXNvars, true , GetWindowStyle() ) ;
+#endif

 
 

-    if ( m_windowStyle & wxTE_MULTILINE )

     {
     {

-        wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
-                      wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
+       wxMacWindowClipper clipper( this ) ;
+#if !wxMAC_USE_MLTE_HIVIEW
+        TPUpdateVisibility( (ControlRef) m_macControl ) ;
+#endif
+        SetTXNData( (STPTextPaneVars *)m_macTXNvars , (TXNObject) m_macTXN , st , kTXNStartOffset, kTXNEndOffset ) ;

 
 

-        m_windowStyle |= wxTE_PROCESS_ENTER;
+        TXNSetSelection( (TXNObject) m_macTXN, 0, 0);
+        TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);

     }
     }

+    
+    // in case MLTE is catching events before we get the chance to do so, we'd have to reintroduce the tlw-handler in front :
+    // parent->MacGetTopLevelWindow()->MacInstallTopLevelWindowEventHandler() ;

 
 

+    SetBackgroundColour( *wxWHITE ) ;
+
+    TXNBackground tback;
+    tback.bgType = kTXNBackgroundTypeRGB;
+    tback.bg.color = MAC_WXCOLORREF( GetBackgroundColour().GetPixel() );
+    TXNSetBackground( (TXNObject) m_macTXN , &tback);

 
 

-    if ( !m_macUsesTXN )
+    if ( m_windowStyle & wxTE_READONLY)

     {
     {

-           m_macControl = ::NewControl( MAC_WXHWND(parent->MacGetRootWindow()) , &bounds , "\p" , true , 0 , 0 , 1, 
-                   (style & wxTE_PASSWORD) ? kControlEditTextPasswordProc : kControlEditTextProc , (long) this ) ;
-               long size ;
-        ::GetControlData((ControlHandle)  m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &((TEHandle) m_macTE) , &size ) ;
+        SetEditable( false ) ;
+    }
+#else
+    wxMacCFStringHolder cf(st , m_font.GetEncoding()) ;
+    CreateEditUnicodeTextControl( MAC_WXHWND(parent->MacGetTopLevelWindowRef()), &bounds , cf , style & wxTE_PASSWORD , NULL , (ControlRef*) &m_macControl ) ;
+    MacPostControlCreate(pos,size) ;
+#endif
+        

 
 

+    return TRUE;
+}
+
+void wxTextCtrl::MacVisibilityChanged() 
+{
+#if wxMAC_USE_MLTE && !wxMAC_USE_MLTE_HIVIEW
+    MLTESetObjectVisibility((STPTextPaneVars*) m_macTXNvars , MacIsReallyShown() , GetWindowStyle() ) ;
+    if ( !MacIsReallyShown() )
+        InvalWindowRect( GetControlOwner( (ControlHandle) m_macControl ) , &((STPTextPaneVars *)m_macTXNvars)->fRBounds ) ;
+#endif
+}
+
+void wxTextCtrl::MacEnabledStateChanged() 
+{
+}
+
+
+wxString wxTextCtrl::GetValue() const
+{
+    wxString result ;
+#if wxMAC_USE_MLTE
+    OSStatus err ;
+    Size actualSize = 0;
+    {
+#if wxUSE_UNICODE
+        Handle theText ;
+        err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNUnicodeTextData );
+        // all done
+        if ( err )
+        {
+            actualSize = 0 ;
+        }
+        else
+        {
+            actualSize = GetHandleSize( theText ) / sizeof( UniChar) ;
+            if ( actualSize > 0 )
+            {
+                wxChar *ptr = NULL ;
+#if SIZEOF_WCHAR_T == 2                
+                ptr = new wxChar[actualSize + 1 ] ;            
+                wxStrncpy( ptr , (wxChar*) *theText , actualSize ) ;
+                
+#else
+                SetHandleSize( theText , ( actualSize + 1 ) * sizeof( UniChar ) ) ;
+                               HLock( theText ) ;
+                (((UniChar*)*theText)[actualSize]) = 0 ;
+                               wxMBConvUTF16BE converter ;
+                               size_t noChars = converter.MB2WC( NULL , (const char*)*theText , 0 ) ;
+                               ptr = new wxChar[noChars + 1] ;
+                               
+                               noChars = converter.MB2WC( ptr , (const char*)*theText , noChars ) ;
+                               ptr[noChars] = 0 ;
+                               HUnlock( theText ) ;
+#endif
+                ptr[actualSize] = 0 ;
+                result = wxString( ptr ) ;
+                delete[] ptr ;
+            }
+            DisposeHandle( theText ) ;
+        }
+#else
+        Handle theText ;
+        err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
+        // all done
+        if ( err )
+        {
+            actualSize = 0 ;
+        }
+        else
+        {
+            actualSize = GetHandleSize( theText ) ;
+            if ( actualSize > 0 )
+            {
+                HLock( theText ) ;
+                result = wxString( *theText , wxConvLocal , actualSize ) ;
+                HUnlock( theText ) ;
+            }
+            DisposeHandle( theText ) ;
+        }
+#endif

     }
     }

-       else
-       {
-        short featurSet;
+#else
+    CFStringRef value = NULL ;
+    Size    actualSize = 0 ;
+
+    verify_noerr( GetControlData( (ControlRef) m_macControl , 0, GetWindowStyle() & wxTE_PASSWORD ? 
+        kControlEditTextPasswordCFStringTag : kControlEditTextCFStringTag, 
+                    sizeof(CFStringRef), &value, &actualSize ) );
+    if ( value )
+    {
+        wxMacCFStringHolder cf(value) ;
+        result = cf.AsString() ;
+    }
+#endif
+    wxMacConvertNewlines10To13( &result ) ;
+    return result ;
+}
+
+void wxTextCtrl::GetSelection(long* from, long* to) const
+{    
+#if wxMAC_USE_MLTE
+   TXNGetSelection( (TXNObject) m_macTXN , (TXNOffset*) from , (TXNOffset*) to ) ;
+#else
+    ControlEditTextSelectionRec sel ;
+    Size actualSize ;
+    verify_noerr( GetControlData( (ControlRef) m_macControl , 0, kControlEditTextSelectionTag, 
+                    sizeof(ControlEditTextSelectionRec), &sel, &actualSize ) );
+    if ( from ) *from = sel.selStart ;
+    if ( to ) *to = sel.selEnd ;
+#endif
+}

 
 

-        featurSet = kControlSupportsEmbedding | kControlSupportsFocus // | kControlWantsIdle
-                | kControlWantsActivate | kControlHandlesTracking | kControlHasSpecialBackground
-                | kControlGetsFocusOnClick | kControlSupportsLiveFeedback;
-            /* create the control */
-        m_macControl = NewControl(MAC_WXHWND(parent->MacGetRootWindow()), &bounds, "\p", true, featurSet, 0, featurSet, kControlUserPaneProc, 0);
-            /* set up the mUP specific features and data */
-       mUPOpenControl((ControlHandle) m_macControl, m_windowStyle & wxTE_MULTILINE );
-       if ( parent )
-       {
-           parent->MacGetTopLevelWindow()->MacInstallEventHandler() ;
-       }
-       }
-    MacPostControlCreate() ;
+void wxTextCtrl::SetValue(const wxString& str)
+{
+    // optimize redraws
+    if ( GetValue() == str )
+        return ;

 
 

-    wxString value ;
-    
-       if( wxApp::s_macDefaultEncodingIsPC )
-               value = wxMacMakeMacStringFromPC( st ) ;
-       else
-               value = st ;
-               
-       if ( !m_macUsesTXN )
-       {
-           ::SetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
-    }
-    else
+    wxString st = str ;
+    wxMacConvertNewlines13To10( &st ) ;
+#if wxMAC_USE_MLTE

     {
     {

-        STPTextPaneVars **tpvars;
-               /* set up locals */
-        tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
-               /* set the text in the record */
-        TXNSetData( (**tpvars).fTXNRec, kTXNTextData,  (void*)value.c_str(), value.Length(),
-          kTXNStartOffset, kTXNEndOffset);
-        m_macTXN =  (**tpvars).fTXNRec ;
-        m_macTXNvars = tpvars ;
-        m_macUsesTXN = true ;
+        wxMacWindowClipper c( this ) ;
+        bool formerEditable = m_editable ;
+        if ( !formerEditable )
+            SetEditable(true) ;
+
+#if !wxMAC_USE_MLTE_HIVIEW
+        // otherwise scrolling might have problems ?
+        TPUpdateVisibility( ( (STPTextPaneVars *)m_macTXNvars)->fUserPaneRec ) ;
+#endif
+        SetTXNData( (STPTextPaneVars *)m_macTXNvars , (TXNObject) m_macTXN , st , kTXNStartOffset, kTXNEndOffset ) ;
+        TXNSetSelection( (TXNObject) m_macTXN, 0, 0);
+        TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
+        if ( !formerEditable )
+            SetEditable(formerEditable) ;

     }
     }

-  
-  return TRUE;
+#else
+    wxMacCFStringHolder cf(st , m_font.GetEncoding() ) ;
+    CFStringRef value = cf ;
+    verify_noerr( SetControlData(  (ControlRef) m_macControl , 0, GetWindowStyle() & wxTE_PASSWORD ? 
+        kControlEditTextPasswordCFStringTag : kControlEditTextCFStringTag, 
+        sizeof(CFStringRef), &value ) );
+#endif

 }
 
 }
 

-wxString wxTextCtrl::GetValue() const
+void wxTextCtrl::SetMaxLength(unsigned long len)

 {
 {

-    Size actualsize;
-     if ( !m_macUsesTXN )
-     {
-      ::GetControlData( (ControlHandle) m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
-     }
-     else
-     {
-       Handle theText ;
-       OSStatus err = TXNGetDataEncoded( ((TXNObject) m_macTXN), kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
-               /* all done */
-       if ( err )
-       {
-         actualsize = 0 ;
-       }
-       else
-       {
-         actualsize = GetHandleSize( theText ) ;
-          if (actualsize != 0)
-             strncpy( wxBuffer , *theText , actualsize ) ;
-         DisposeHandle( theText ) ;
-       }
-     }
-    wxBuffer[actualsize] = 0 ;
-    if( wxApp::s_macDefaultEncodingIsPC )
-        return wxMacMakePCStringFromMac( wxBuffer ) ;
-    else
-        return wxString(wxBuffer);
+    m_maxLength = len ;

 }
 
 }
 

-void wxTextCtrl::GetSelection(long* from, long* to) const
+bool wxTextCtrl::SetFont( const wxFont& font )

 {
 {

-  if ( !m_macUsesTXN )
-  {
-    *from = (**((TEHandle) m_macTE)).selStart;
-    *to = (**((TEHandle) m_macTE)).selEnd;
-   }
-   else
-   {
-        TXNGetSelection(  ((TXNObject) m_macTXN) , (TXNOffset*) from , (TXNOffset*) to ) ;
-   }
+    if ( !wxTextCtrlBase::SetFont( font ) )
+        return FALSE ;
+        
+#if wxMAC_USE_MLTE        
+    wxMacWindowClipper c( this ) ;
+    bool formerEditable = m_editable ;
+    if ( !formerEditable )
+        SetEditable(true) ;
+
+    TXNTypeAttributes typeAttr[4] ;
+    Str255 fontName = "\pMonaco" ;
+    SInt16 fontSize = 12 ;
+    Style fontStyle = normal ;
+    int attrCounter = 0 ;
+
+    wxMacStringToPascal( font.GetFaceName() , fontName ) ;
+    fontSize = font.MacGetFontSize() ;
+    fontStyle = font.MacGetFontStyle() ;
+
+    typeAttr[attrCounter].tag = kTXNQDFontNameAttribute ;
+    typeAttr[attrCounter].size = kTXNQDFontNameAttributeSize ;
+    typeAttr[attrCounter].data.dataPtr = (void*) fontName ;
+    typeAttr[attrCounter+1].tag = kTXNQDFontSizeAttribute ;
+    typeAttr[attrCounter+1].size = kTXNFontSizeAttributeSize ;
+    typeAttr[attrCounter+1].data.dataValue =  (fontSize << 16) ;
+    typeAttr[attrCounter+2].tag = kTXNQDFontStyleAttribute ;
+    typeAttr[attrCounter+2].size = kTXNQDFontStyleAttributeSize ;
+    typeAttr[attrCounter+2].data.dataValue = fontStyle ;
+    attrCounter += 3 ;
+    /*
+    typeAttr[attrCounter].tag = kTXNQDFontColorAttribute ;
+    typeAttr[attrCounter].size = kTXNQDFontColorAttributeSize ;
+    typeAttr[attrCounter].data.dataPtr = (void*) &color ;
+    color = MAC_WXCOLORREF(GetForegroundColour().GetPixel()) ;
+    attrCounter += 1 ;
+    */
+    verify_noerr( TXNSetTypeAttributes ((TXNObject)m_macTXN, attrCounter , typeAttr, kTXNStartOffset,kTXNEndOffset) );
+
+    if ( !formerEditable )
+        SetEditable(formerEditable) ;
+#endif
+    return true ;

 }
 
 }
 

-void wxTextCtrl::SetValue(const wxString& st)
+bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)

 {
 {

-    wxString value ;
-    
-    if( wxApp::s_macDefaultEncodingIsPC )
-        value = wxMacMakeMacStringFromPC( st ) ;
-    else
-        value = st ;
-  if ( !m_macUsesTXN )
-  {
-         ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
-  }
-  else
-  {
-       TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)value.c_str(), value.Length(),
-         kTXNStartOffset, kTXNEndOffset);
-  }
-    MacRedrawControl() ;
+#if wxMAC_USE_MLTE
+    bool formerEditable = m_editable ;
+    if ( !formerEditable )
+        SetEditable(true) ;
+    TXNTypeAttributes typeAttr[4] ;
+    Str255 fontName = "\pMonaco" ;
+    SInt16 fontSize = 12 ;
+    Style fontStyle = normal ;
+    RGBColor color ;
+    int attrCounter = 0 ;
+    if ( style.HasFont() )
+    {
+        const wxFont &font = style.GetFont() ;
+        wxMacStringToPascal( font.GetFaceName() , fontName ) ;
+        fontSize = font.GetPointSize() ;
+        if ( font.GetUnderlined() )
+            fontStyle |= underline ;
+        if ( font.GetWeight() == wxBOLD )
+            fontStyle |= bold ;
+        if ( font.GetStyle() == wxITALIC )
+            fontStyle |= italic ;
+
+        typeAttr[attrCounter].tag = kTXNQDFontNameAttribute ;
+        typeAttr[attrCounter].size = kTXNQDFontNameAttributeSize ;
+        typeAttr[attrCounter].data.dataPtr = (void*) fontName ;
+        typeAttr[attrCounter+1].tag = kTXNQDFontSizeAttribute ;
+        typeAttr[attrCounter+1].size = kTXNFontSizeAttributeSize ;
+        typeAttr[attrCounter+1].data.dataValue =  (fontSize << 16) ;
+        typeAttr[attrCounter+2].tag = kTXNQDFontStyleAttribute ;
+        typeAttr[attrCounter+2].size = kTXNQDFontStyleAttributeSize ;
+        typeAttr[attrCounter+2].data.dataValue = fontStyle ;
+        attrCounter += 3 ;
+
+    }
+    if ( style.HasTextColour() )
+    {
+        typeAttr[attrCounter].tag = kTXNQDFontColorAttribute ;
+        typeAttr[attrCounter].size = kTXNQDFontColorAttributeSize ;
+        typeAttr[attrCounter].data.dataPtr = (void*) &color ;
+        color = MAC_WXCOLORREF(style.GetTextColour().GetPixel()) ;
+        attrCounter += 1 ;
+    }
+
+    if ( attrCounter > 0 )
+    {
+        verify_noerr( TXNSetTypeAttributes ((TXNObject)m_macTXN, attrCounter , typeAttr, start,end) );
+    }
+    if ( !formerEditable )
+        SetEditable(formerEditable) ;
+#endif
+    return TRUE ;
+}
+
+bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
+{
+    wxTextCtrlBase::SetDefaultStyle( style ) ;
+    SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
+    return TRUE ;

 }
 
 // Clipboard operations
 }
 
 // Clipboard operations


@@ -781,19 +1134,11 @@ void wxTextCtrl::Copy()
 {
     if (CanCopy())
     {
 {
     if (CanCopy())
     {

-      if ( !m_macUsesTXN )
-      {
-               TECopy( ((TEHandle) m_macTE) ) ;
-               ClearCurrentScrap();
-               TEToScrap() ;
-               MacRedrawControl() ;
-       }
-       else
-       {
-            ClearCurrentScrap();
-            TXNCopy((TXNObject)m_macTXN); 
-            TXNConvertToPublicScrap();
-       }
+#if wxMAC_USE_MLTE
+        ClearCurrentScrap();
+        TXNCopy((TXNObject)m_macTXN);
+        TXNConvertToPublicScrap();
+#endif

     }
 }
 
     }
 }
 


@@ -801,41 +1146,27 @@ void wxTextCtrl::Cut()
 {
     if (CanCut())
     {
 {
     if (CanCut())
     {

-        if ( !m_macUsesTXN )
-        {
-               TECut( ((TEHandle) m_macTE) ) ;
-               ClearCurrentScrap();
-               TEToScrap() ;
-               MacRedrawControl() ;
-        }
-       else
-       {
-            ClearCurrentScrap();
-            TXNCut((TXNObject)m_macTXN); 
-            TXNConvertToPublicScrap();
-       }
+#if wxMAC_USE_MLTE
+        ClearCurrentScrap();
+        TXNCut((TXNObject)m_macTXN);
+        TXNConvertToPublicScrap();
+#endif

         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
         event.SetString( GetValue() ) ;
         event.SetEventObject( this );
         GetEventHandler()->ProcessEvent(event);
         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
         event.SetString( GetValue() ) ;
         event.SetEventObject( this );
         GetEventHandler()->ProcessEvent(event);

-         }
+      }

 }
 
 void wxTextCtrl::Paste()
 {
     if (CanPaste())
     {
 }
 
 void wxTextCtrl::Paste()
 {
     if (CanPaste())
     {

-        if ( !m_macUsesTXN )
-        {
-            TEFromScrap() ;
-            TEPaste( (TEHandle) m_macTE ) ;
-            MacRedrawControl() ;
-        }
-               else
-               {
-            TXNConvertFromPublicScrap();
-            TXNPaste((TXNObject)m_macTXN); 
-               }
+#if wxMAC_USE_MLTE
+        TXNConvertFromPublicScrap();
+        TXNPaste((TXNObject)m_macTXN);
+        SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
+#endif

         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
         event.SetString( GetValue() ) ;
         event.SetEventObject( this );
         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
         event.SetString( GetValue() ) ;
         event.SetEventObject( this );


@@ -868,34 +1199,11 @@ bool wxTextCtrl::CanPaste() const
     if (!IsEditable())
         return FALSE;
 
     if (!IsEditable())
         return FALSE;
 

-    long offset ;
-#if TARGET_CARBON
-    OSStatus err = noErr;
-    ScrapRef scrapRef;
-    
-    err = GetCurrentScrap( &scrapRef );
-    if ( err != noTypeErr && err != memFullErr )    
-    {
-               ScrapFlavorFlags        flavorFlags;
-               Size                            byteCount;
-        
-        if (( err = GetScrapFlavorFlags( scrapRef, 'TEXT', &flavorFlags )) == noErr)
-        {
-            if (( err = GetScrapFlavorSize( scrapRef, 'TEXT', &byteCount )) == noErr)
-            {
-                return TRUE ;
-            }
-        }
-    }
-    return FALSE;
-    
+#if wxMAC_USE_MLTE
+    return TXNIsScrapPastable() ;

 #else
 #else

-    if ( GetScrap( NULL , 'TEXT' , &offset ) > 0 )
-    {
-        return TRUE ;
-    }
+    return true ;

 #endif
 #endif

-    return FALSE ;

 }
 
 void wxTextCtrl::SetEditable(bool editable)
 }
 
 void wxTextCtrl::SetEditable(bool editable)


@@ -903,10 +1211,11 @@ void wxTextCtrl::SetEditable(bool editable)
     if ( editable != m_editable )
     {
         m_editable = editable ;
     if ( editable != m_editable )
     {
         m_editable = editable ;

-    if ( editable )
-               UMAActivateControl( (ControlHandle) m_macControl ) ;
-        else
-               UMADeactivateControl((ControlHandle)  m_macControl ) ;
+#if wxMAC_USE_MLTE
+        TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
+        TXNControlData data[] = { { editable ? kTXNReadWrite : kTXNReadOnly } } ;
+        TXNSetTXNObjectControls( (TXNObject) m_macTXN , false , sizeof(tag) / sizeof (TXNControlTag) , tag , data ) ;
+#endif

     }
 }
 
     }
 }
 


@@ -923,101 +1232,82 @@ void wxTextCtrl::SetInsertionPointEnd()
 
 long wxTextCtrl::GetInsertionPoint() const
 {
 
 long wxTextCtrl::GetInsertionPoint() const
 {

-  long begin,end ;
-  GetSelection( &begin , &end ) ;
-  return begin ;
+    long begin,end ;
+    GetSelection( &begin , &end ) ;
+    return begin ;

 }
 
 long wxTextCtrl::GetLastPosition() const
 {
 }
 
 long wxTextCtrl::GetLastPosition() const
 {

-    if ( !m_macUsesTXN )
-  {
-    return (**((TEHandle) m_macTE)).teLength ;
-  }
-  else
-  {
+    long actualsize = 0 ;
+#if wxMAC_USE_MLTE

     Handle theText ;
     Handle theText ;

-    long actualsize ;

     OSErr err = TXNGetDataEncoded( (TXNObject) m_macTXN, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
     OSErr err = TXNGetDataEncoded( (TXNObject) m_macTXN, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );

-        /* all done */
+    /* all done */

     if ( err )
     {
     if ( err )
     {

-      actualsize = 0 ;
+        actualsize = 0 ;

     }
     else
     {
     }
     else
     {

-      actualsize = GetHandleSize( theText ) ;
-      DisposeHandle( theText ) ;
+        actualsize = GetHandleSize( theText ) ;
+        DisposeHandle( theText ) ;

     }
     }

+#endif

     return actualsize ;
     return actualsize ;

-  }

 }
 
 }
 

-void wxTextCtrl::Replace(long from, long to, const wxString& value)
+void wxTextCtrl::Replace(long from, long to, const wxString& str)

 {
 {

-  if ( !m_macUsesTXN )
-  {
-           ControlEditTextSelectionRec selection ;
-   
-           selection.selStart = from ;
-           selection.selEnd = to ;
-           ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
-           TESetSelect( from , to  , ((TEHandle) m_macTE) ) ;
-           TEDelete( ((TEHandle) m_macTE) ) ;
-               TEInsert( value , value.Length() , ((TEHandle) m_macTE) ) ;
-       }
-       else
-       {
-         TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
-         TXNClear( ((TXNObject) m_macTXN) ) ;
-         TXNSetData( ((TXNObject) m_macTXN), kTXNTextData,  (void*)value.c_str(), value.Length(),
-           kTXNUseCurrentSelection, kTXNUseCurrentSelection);
-       }
+#if wxMAC_USE_MLTE
+    wxString value = str ;
+    wxMacConvertNewlines13To10( &value ) ;
+
+    bool formerEditable = m_editable ;
+    if ( !formerEditable )
+        SetEditable(true) ;
+    TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
+    TXNClear( ((TXNObject) m_macTXN) ) ;
+    SetTXNData( (STPTextPaneVars *)m_macTXNvars , (TXNObject) m_macTXN , str , kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
+    if ( !formerEditable )
+        SetEditable( formerEditable ) ;
+

     Refresh() ;
     Refresh() ;

+#endif

 }
 
 void wxTextCtrl::Remove(long from, long to)
 {
 }
 
 void wxTextCtrl::Remove(long from, long to)
 {

-  if ( !m_macUsesTXN )
-  {
-       ControlEditTextSelectionRec selection ;
-   
-       selection.selStart = from ;
-       selection.selEnd = to ;
-       ::SetControlData( (ControlHandle) m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
-       TEDelete( ((TEHandle) m_macTE) ) ;
-  }
-  else
-  {
-    TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ; 
-    TXNClear( ((TXNObject) m_macTXN) ) ; 
-  }
+#if wxMAC_USE_MLTE
+    bool formerEditable = m_editable ;
+    if ( !formerEditable )
+        SetEditable(true) ;
+    TXNSetSelection( ((TXNObject) m_macTXN) , from , to ) ;
+    TXNClear( ((TXNObject) m_macTXN) ) ;
+    if ( !formerEditable )
+        SetEditable( formerEditable ) ;
+

     Refresh() ;
     Refresh() ;

+#endif

 }
 
 void wxTextCtrl::SetSelection(long from, long to)
 {
 }
 
 void wxTextCtrl::SetSelection(long from, long to)
 {

+#if wxMAC_USE_MLTE
+    /* change the selection */
+    if ((from == -1) && (to == -1))
+       TXNSelectAll((TXNObject) m_macTXN);
+    else
+       TXNSetSelection( (TXNObject) m_macTXN, from, to);
+    TXNShowSelection( (TXNObject) m_macTXN, kTXNShowStart);
+#else
+    ControlEditTextSelectionRec sel ;
+    sel.selStart = from ;
+    sel.selEnd = to ;
+    verify_noerr( SetControlData( (ControlRef) m_macControl , 0, kControlEditTextSelectionTag, 
+                    sizeof(ControlEditTextSelectionRec), &sel ) );

 
 

-  if ( !m_macUsesTXN )
-  {
-   ControlEditTextSelectionRec selection ;
-   selection.selStart = from ;
-   selection.selEnd = to ;
-   
-   TESetSelect( selection.selStart , selection.selEnd , ((TEHandle) m_macTE) ) ;
-   ::SetControlData((ControlHandle)  m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
-  }
-  else
-  {
-       STPTextPaneVars **tpvars;
-               /* set up our locals */
-       tpvars = (STPTextPaneVars **) GetControlReference((ControlHandle) m_macControl);
-               /* and our drawing environment as the operation
-               may force a redraw in the text area. */
-       SetPort((**tpvars).fDrawingEnvironment);
-               /* change the selection */
-       TXNSetSelection( (**tpvars).fTXNRec, from, to);
-  }
+#endif

 }
 
 bool wxTextCtrl::LoadFile(const wxString& file)
 }
 
 bool wxTextCtrl::LoadFile(const wxString& file)


@@ -1030,23 +1320,141 @@ bool wxTextCtrl::LoadFile(const wxString& file)
     return FALSE;
 }
 
     return FALSE;
 }
 

-void wxTextCtrl::WriteText(const wxString& text)
+class wxMacFunctor

 {
 {

-    wxString value ;
-       if( wxApp::s_macDefaultEncodingIsPC )
-               value = wxMacMakeMacStringFromPC( text ) ;
-       else
-               value = text ;
-    if ( !m_macUsesTXN )
+public :  
+    wxMacFunctor(){}
+    virtual ~wxMacFunctor() {}
+    virtual void* operator()() = 0 ;
+    static void* CallBackProc(void *param) 

     {
     {

-               TEInsert( value , value.Length() , ((TEHandle) m_macTE) ) ;
-       }
-       else
-       {
-       TXNSetData( ((TXNObject) m_macTXN), kTXNTextData, (void*) (const char*)value, value.Length(),
-         kTXNUseCurrentSelection, kTXNUseCurrentSelection);
-       }
-       MacRedrawControl() ;
+        wxMacFunctor* f = (wxMacFunctor*) param ;
+        void *result = (*f)() ;
+        return result ;
+    }
+} ;
+
+template<typename classtype,typename param1type>
+class wxMacObjectFunctor1 : public wxMacFunctor
+{
+    typedef void (classtype::*function)( param1type p1 ) ;
+    typedef void (classtype::*ref_function)( const param1type& p1 ) ;
+public :   
+    wxMacObjectFunctor1( classtype *obj , function f , param1type p1 ) :
+        wxMacFunctor(  )
+    {
+        m_object = obj ;
+        m_function = f ;
+        m_param1 = p1 ;
+    }
+
+    wxMacObjectFunctor1( classtype *obj , ref_function f , param1type p1 ) :
+        wxMacFunctor(  )
+    {
+        m_object = obj ;
+        m_refFunction = f ;
+        m_param1 = p1 ;
+    }
+
+    ~wxMacObjectFunctor1() {}
+    
+    virtual void* operator()() 
+    {
+        (m_object->*m_function)(m_param1) ;
+        return NULL ;
+    }
+private :
+    classtype* m_object ;
+    param1type m_param1 ;
+    union
+    {
+    function m_function ;
+    ref_function m_refFunction ;
+    } ;
+} ;
+
+template<typename classtype, typename param1type> 
+void* wxMacMPRemoteCall( classtype *object , void (classtype::*function)( param1type p1 ) , param1type p1 )
+{
+    wxMacObjectFunctor1<classtype,param1type> params(object,function,p1) ;   
+    void *result = 
+        MPRemoteCall( wxMacFunctor::CallBackProc , &params  , kMPOwningProcessRemoteContext ) ;
+    return result ;
+}
+
+template<typename classtype, typename param1type> 
+void* wxMacMPRemoteCall( classtype *object , void (classtype::*function)( const param1type& p1 ) , param1type p1 )
+{
+    wxMacObjectFunctor1<classtype,param1type> params(object,function,p1) ;   
+    void *result = 
+        MPRemoteCall( wxMacFunctor::CallBackProc , &params  , kMPOwningProcessRemoteContext ) ;
+    return result ;
+}
+
+template<typename classtype, typename param1type> 
+void* wxMacMPRemoteGUICall( classtype *object , void (classtype::*function)( param1type p1 ) , param1type p1 )
+{
+    wxMutexGuiLeave() ;
+    void *result = wxMacMPRemoteCall( object , function , p1 ) ;
+    wxMutexGuiEnter() ;
+    return result ;
+}
+
+template<typename classtype, typename param1type> 
+void* wxMacMPRemoteGUICall( classtype *object , void (classtype::*function)( const param1type& p1 ) , param1type p1 )
+{
+    wxMutexGuiLeave() ;
+    void *result = wxMacMPRemoteCall( object , function , p1 ) ;
+    wxMutexGuiEnter() ;
+    return result ;
+}
+
+void wxTextCtrl::WriteText(const wxString& str)
+{
+    if ( !wxIsMainThread() )
+    {
+        // unfortunately CW 8 is not able to correctly deduce the template types, so we have 
+        // to instantiate explicitely
+        wxMacMPRemoteGUICall<wxTextCtrl,wxString>( this , &wxTextCtrl::WriteText , str ) ;
+        return ;
+    }
+    else
+    {
+        wxString st = str ;
+        wxMacConvertNewlines13To10( &st ) ;
+    #if wxMAC_USE_MLTE
+        bool formerEditable = m_editable ;
+        if ( !formerEditable )
+            SetEditable(true) ;
+        {
+            wxMacWindowStateSaver s( this ) ;
+            long start , end , dummy ;
+            GetSelection( &start , &dummy ) ;
+            SetTXNData( (STPTextPaneVars *)m_macTXNvars , (TXNObject) m_macTXN , st , kTXNUseCurrentSelection, kTXNUseCurrentSelection ) ;
+            GetSelection( &dummy , &end ) ;
+            SetStyle( start , end , GetDefaultStyle() ) ;
+        }
+        if ( !formerEditable )
+            SetEditable( formerEditable ) ;
+
+        MacRedrawControl() ;
+    #else
+    #if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
+        wxMacCFStringHolder cf(st , m_font.GetEncoding() ) ;
+        CFStringRef value = cf ;
+        SetControlData(  (ControlRef) m_macControl , 0, kControlEditTextInsertCFStringRefTag, 
+            sizeof(CFStringRef), &value );
+    #else
+        wxString val = GetValue() ;
+        long start , end ;
+        GetSelection( &start , &end ) ;
+        val.Remove( start , end - start ) ;
+        val.insert( start , str ) ;
+        SetValue( val ) ;
+        SetInsertionPoint( start + str.Length() ) ;
+    #endif
+    #endif
+    }

 }
 
 void wxTextCtrl::AppendText(const wxString& text)
 }
 
 void wxTextCtrl::AppendText(const wxString& text)


@@ -1057,25 +1465,25 @@ void wxTextCtrl::AppendText(const wxString& text)
 
 void wxTextCtrl::Clear()
 {
 
 void wxTextCtrl::Clear()
 {

-    if ( !IsEditable() )
-    {
-        return ;
-    }
-  if ( !m_macUsesTXN )
-  {
-       ::SetControlData((ControlHandle)  m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char*) ((const char*)NULL) ) ;
-  }
-  else
-  {
-            ClearCurrentScrap();
-            TXNClear((TXNObject)m_macTXN); 
-  }
+#if wxMAC_USE_MLTE
+    bool formerEditable = m_editable ;
+    if ( !formerEditable )
+        SetEditable(true) ;
+    TXNSetSelection( (TXNObject)m_macTXN , kTXNStartOffset , kTXNEndOffset ) ;
+    TXNClear((TXNObject)m_macTXN);
+
+    if ( !formerEditable )
+        SetEditable( formerEditable ) ;
+

     Refresh() ;
     Refresh() ;

+#else
+    SetValue(wxEmptyString) ;
+#endif

 }
 
 bool wxTextCtrl::IsModified() const
 {
 }
 
 bool wxTextCtrl::IsModified() const
 {

-    return TRUE;
+    return m_dirty;

 }
 
 bool wxTextCtrl::IsEditable() const
 }
 
 bool wxTextCtrl::IsEditable() const


@@ -1092,33 +1500,37 @@ bool wxTextCtrl::AcceptsFocus() const
 wxSize wxTextCtrl::DoGetBestSize() const
 {
     int wText = 100 ;
 wxSize wxTextCtrl::DoGetBestSize() const
 {
     int wText = 100 ;

-    
+

     int hText;
     int hText;

-       if ( m_macUsesTXN )
-       {
-           hText = 17 ;
-       }
-       else
-       {
-           hText = 13 ;
-       }
-/*
-    int cx, cy;
-    wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());

 
 

-    int wText = DEFAULT_ITEM_WIDTH;
+    switch( m_windowVariant )
+    {
+        case wxWINDOW_VARIANT_NORMAL :
+            hText = 22 ;
+            break ;
+        case wxWINDOW_VARIANT_SMALL :
+            hText = 19 ;
+            break ;
+        case wxWINDOW_VARIANT_MINI :
+            hText= 15 ;
+            break ;
+        default :
+            hText = 22 ;
+            break ; 
+    }

 
 

-    int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
+#if !wxMAC_USE_MLTE
+    // unicode text control is using client size, ie 3 pixels on every side
+    // TODO make this fit into normal window size concept, probably having 
+    // to reintroduce the margin vars
+    hText -= 6 ;
+#endif

 
 

-    return wxSize(wText, hText);
-*/

     if ( m_windowStyle & wxTE_MULTILINE )
     {
          hText *= 5 ;
     }
     if ( m_windowStyle & wxTE_MULTILINE )
     {
          hText *= 5 ;
     }

-    hText += 2 * m_macVerticalBorder ;
-    wText += 2 * m_macHorizontalBorder ;
-    //else: for single line control everything is ok
+

     return wxSize(wText, hText);
 }
 
     return wxSize(wText, hText);
 }
 


@@ -1130,6 +1542,9 @@ void wxTextCtrl::Undo()
 {
     if (CanUndo())
     {
 {
     if (CanUndo())
     {

+#if wxMAC_USE_MLTE
+        TXNUndo((TXNObject)m_macTXN); 
+#endif

     }
 }
 
     }
 }
 


@@ -1137,114 +1552,253 @@ void wxTextCtrl::Redo()
 {
     if (CanRedo())
     {
 {
     if (CanRedo())
     {

+#if wxMAC_USE_MLTE
+        TXNRedo((TXNObject)m_macTXN); 
+#endif

     }
 }
 
 bool wxTextCtrl::CanUndo() const
 {
     }
 }
 
 bool wxTextCtrl::CanUndo() const
 {

-    return FALSE ;
+    if ( !IsEditable() ) 
+    {
+        return false ; 
+    }
+#if wxMAC_USE_MLTE
+    return TXNCanUndo((TXNObject)m_macTXN,NULL); 
+#else
+    return false ;
+#endif

 }
 
 bool wxTextCtrl::CanRedo() const
 {
 }
 
 bool wxTextCtrl::CanRedo() const
 {

-    return FALSE ;
+    if ( !IsEditable() ) 
+    {
+        return false ; 
+    }
+#if wxMAC_USE_MLTE
+    return TXNCanRedo((TXNObject)m_macTXN,NULL); 
+#else
+    return false ;
+#endif
+}
+
+// Makes modifie or unmodified
+void wxTextCtrl::MarkDirty()
+{
+    m_dirty = true;

 }
 
 }
 

-// Makes 'unmodified'

 void wxTextCtrl::DiscardEdits()
 {
 void wxTextCtrl::DiscardEdits()
 {

-    // TODO
+    m_dirty = false;

 }
 
 int wxTextCtrl::GetNumberOfLines() const
 {
 }
 
 int wxTextCtrl::GetNumberOfLines() const
 {

-  // TODO change this if possible to reflect real lines
-  wxString content = GetValue() ;
-    
-    int count = 1;
-       for (int i = 0; i < content.Length() ; i++)
-       {
-           if (content[i] == '\r') count++;
-    }
-    
-    return count;
+    ItemCount lines = 0 ;
+#if wxMAC_USE_MLTE
+    TXNGetLineCount((TXNObject)m_macTXN, &lines ) ;
+#endif
+    return lines ;

 }
 
 long wxTextCtrl::XYToPosition(long x, long y) const
 {
 }
 
 long wxTextCtrl::XYToPosition(long x, long y) const
 {

-    // TODO
+#if wxMAC_USE_MLTE
+    Point curpt ;
+    
+    long lastpos = GetLastPosition() ;
+    
+    // TODO find a better implementation : while we can get the 
+    // line metrics of a certain line, we don't get its starting
+    // position, so it would probably be rather a binary search
+    // for the start position
+    long xpos = 0 ; 
+    long ypos = 0 ;
+    int lastHeight = 0 ;
+
+    ItemCount n ;
+    for ( n = 0 ; n <= (ItemCount) lastpos ; ++n )
+    {
+        if ( y == ypos && x == xpos )
+            return n ;
+        
+        TXNOffsetToPoint( (TXNObject) m_macTXN,  n , &curpt);
+
+        if ( curpt.v > lastHeight )
+        {
+            xpos = 0 ;
+            if ( n > 0 )
+                ++ypos ;
+            lastHeight = curpt.v ;
+        }
+        else
+            ++xpos ;
+    }
+#endif    

     return 0;
 }
 
 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
 {
     return 0;
 }
 
 bool wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
 {

+#if wxMAC_USE_MLTE
+    Point curpt ;
+    
+    long lastpos = GetLastPosition() ;
+    
+    if ( y ) *y = 0 ;
+    if ( x ) *x = 0 ;
+    
+    if ( pos <= lastpos )
+    {
+        // TODO find a better implementation : while we can get the 
+        // line metrics of a certain line, we don't get its starting
+        // position, so it would probably be rather a binary search
+        // for the start position
+        long xpos = 0 ; 
+        long ypos = 0 ;
+        int lastHeight = 0 ;
+
+        ItemCount n ;
+        for ( n = 0 ; n <= (ItemCount) pos ; ++n )
+        {
+            TXNOffsetToPoint( (TXNObject) m_macTXN,  n , &curpt);
+
+            if ( curpt.v > lastHeight )
+            {
+                xpos = 0 ;
+                if ( n > 0 )
+                    ++ypos ;
+                lastHeight = curpt.v ;
+            }
+            else
+                ++xpos ;
+        }
+        if ( y ) *y = ypos ;
+        if ( x ) *x = xpos ;
+    }
+#else
+    if ( y ) *y = 0 ;
+    if ( x ) *x = 0 ;
+#endif    

     return FALSE ;
 }
 
 void wxTextCtrl::ShowPosition(long pos)
 {
     return FALSE ;
 }
 
 void wxTextCtrl::ShowPosition(long pos)
 {

-    // TODO
+#if wxMAC_USE_MLTE
+#if TARGET_RT_MAC_MACHO && defined(AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER)
+    {
+        Point current ;
+        Point desired ;
+        TXNOffset selstart , selend ;
+        TXNGetSelection(  (TXNObject) m_macTXN , &selstart , &selend) ;
+        TXNOffsetToPoint( (TXNObject) m_macTXN,  selstart , &current);
+        TXNOffsetToPoint( (TXNObject) m_macTXN,  pos , &desired);
+        //TODO use HIPoints for 10.3 and above
+        if ( (UInt32) TXNScroll != (UInt32) kUnresolvedCFragSymbolAddress )
+        {
+            OSErr theErr = noErr;
+            SInt32 dv = desired.v - current.v ;
+            SInt32 dh = desired.h - current.h ;
+            TXNShowSelection(  (TXNObject) m_macTXN , true ) ;
+            theErr = TXNScroll( (TXNObject) m_macTXN, kTXNScrollUnitsInPixels , kTXNScrollUnitsInPixels , &dv , &dh );          
+            wxASSERT_MSG( theErr == noErr, _T("TXNScroll returned an error!") );
+        }
+    }
+#endif
+#endif

 }
 
 int wxTextCtrl::GetLineLength(long lineNo) const
 {
 }
 
 int wxTextCtrl::GetLineLength(long lineNo) const
 {

-  // TODO change this if possible to reflect real lines
-  wxString content = GetValue() ;
-       
-       // Find line first
-       int count = 0;
-       for (int i = 0; i < content.Length() ; i++)
+#if wxMAC_USE_MLTE
+    Point curpt ;
+    if ( lineNo < GetNumberOfLines() )

     {
     {

-        if (count == lineNo)
+        // TODO find a better implementation : while we can get the 
+        // line metrics of a certain line, we don't get its starting
+        // position, so it would probably be rather a binary search
+        // for the start position
+        long xpos = 0 ; 
+        long ypos = 0 ;
+        int lastHeight = 0 ;
+        long lastpos = GetLastPosition() ;
+
+        ItemCount n ;
+        for ( n = 0 ; n <= (ItemCount) lastpos ; ++n )

         {
         {

-            // Count chars in line then
-            count = 0;
-               for (int j = i; j < content.Length(); j++)
+            TXNOffsetToPoint( (TXNObject) m_macTXN,  n , &curpt);
+
+            if ( curpt.v > lastHeight )

             {
             {

-                count++;
-                   if (content[j] == '\r') return count;
-               }
-               
-               return count;
-           }
-           if (content[i] == '\r') count++;
-       }
+                if ( ypos == lineNo )
+                    return xpos ;
+                    
+                xpos = 0 ;
+                if ( n > 0 )
+                    ++ypos ;
+                lastHeight = curpt.v ;
+            }
+            else
+                ++xpos ;
+        }
+    }
+#endif

     return 0;
 }
 
 wxString wxTextCtrl::GetLineText(long lineNo) const
 {
     return 0;
 }
 
 wxString wxTextCtrl::GetLineText(long lineNo) const
 {

-  // TODO change this if possible to reflect real lines
-  wxString content = GetValue() ;
+    wxString line ;
+#if wxMAC_USE_MLTE
+    Point curpt ;
+    wxString content = GetValue() ;

 
 

-       // Find line first
-       int count = 0;
-       for (int i = 0; i < content.Length() ; i++)
+    if ( lineNo < GetNumberOfLines() )

     {
     {

-        if (count == lineNo)
+        // TODO find a better implementation : while we can get the 
+        // line metrics of a certain line, we don't get its starting
+        // position, so it would probably be rather a binary search
+        // for the start position
+        long xpos = 0 ; 
+        long ypos = 0 ;
+        int lastHeight = 0 ;
+        long lastpos = GetLastPosition() ;
+
+        ItemCount n ;
+        for ( n = 0 ; n <= (ItemCount)lastpos ; ++n )

         {
         {

-            // Add chars in line then
-            wxString tmp("");
-            
-               for (int j = i; j < content.Length(); j++)
-               {
-                   if (content[j] == '\r')
-                       return tmp;
-                       
-                   tmp += content[j];
-               }
-               
-               return tmp;
-           }
-           if (content[i] == '\r') count++;
-       }
-       return "" ;
+            TXNOffsetToPoint( (TXNObject) m_macTXN,  n , &curpt);
+
+            if ( curpt.v > lastHeight )
+            {
+                if ( ypos == lineNo )
+                    return line ;
+                    
+                xpos = 0 ;
+                if ( n > 0 )
+                    ++ypos ;
+                lastHeight = curpt.v ;
+            }
+            else
+            {
+                if ( ypos == lineNo )
+                    line += content[n] ;
+                ++xpos ;
+            }
+        }
+    }
+#endif
+    return line ;

 }
 
 /*
  * Text item
  */
 }
 
 /*
  * Text item
  */

- 
+

 void wxTextCtrl::Command(wxCommandEvent & event)
 {
     SetValue (event.GetString());
 void wxTextCtrl::Command(wxCommandEvent & event)
 {
     SetValue (event.GetString());


@@ -1264,15 +1818,38 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
 {
     int key = event.GetKeyCode() ;
     bool eat_key = false ;
 {
     int key = event.GetKeyCode() ;
     bool eat_key = false ;

-    
-    if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB && 
-        !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) ) 
+
+    if ( key == 'c' && event.MetaDown() )
+    {
+        if ( CanCopy() )
+            Copy() ;
+        return ;
+    }
+
+    if ( !IsEditable() && key != WXK_LEFT && key != WXK_RIGHT && key != WXK_DOWN && key != WXK_UP && key != WXK_TAB &&
+        !( key == WXK_RETURN && ( (m_windowStyle & wxPROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )

 /*        && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
         )
     {
         // eat it
         return ;
     }
 /*        && key != WXK_PRIOR && key != WXK_NEXT && key != WXK_HOME && key != WXK_END */
         )
     {
         // eat it
         return ;
     }

+
+    // assume that any key not processed yet is going to modify the control
+    m_dirty = true;
+
+    if ( key == 'v' && event.MetaDown() )
+    {
+        if ( CanPaste() )
+            Paste() ;
+        return ;
+    }
+    if ( key == 'x' && event.MetaDown() )
+    {
+        if ( CanCut() )
+            Cut() ;
+        return ;
+    }

     switch ( key )
     {
         case WXK_RETURN:
     switch ( key )
     {
         case WXK_RETURN:


@@ -1283,7 +1860,7 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
                 event.SetString( GetValue() );
                 if ( GetEventHandler()->ProcessEvent(event) )
                     return;
                 event.SetString( GetValue() );
                 if ( GetEventHandler()->ProcessEvent(event) )
                     return;

-            } 
+            }

             if ( !(m_windowStyle & wxTE_MULTILINE) )
             {
                 wxWindow *parent = GetParent();
             if ( !(m_windowStyle & wxTE_MULTILINE) )
             {
                 wxWindow *parent = GetParent();


@@ -1302,7 +1879,7 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
                         return ;
                    }
                 }
                         return ;
                    }
                 }

-               
+

                 // this will make wxWindows eat the ENTER key so that
                 // we actually prevent line wrapping in a single line
                 // text control
                 // this will make wxWindows eat the ENTER key so that
                 // we actually prevent line wrapping in a single line
                 // text control


@@ -1330,15 +1907,30 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
             }
             break;
     }
             }
             break;
     }

-    
+

     if (!eat_key)
     {
     if (!eat_key)
     {

-        // default handling
-        event.Skip() ;
+        // perform keystroke handling
+        if ( wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL )
+            CallNextEventHandler((EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() , (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
+        else 
+        {
+            EventRecord rec ;
+            if ( wxMacConvertEventToRecord(  (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) )
+            {
+                EventRecord *ev = &rec ;
+                short keycode ;
+                short keychar ;
+                keychar = short(ev->message & charCodeMask);
+                keycode = short(ev->message & keyCodeMask) >> 8 ;
+
+                ::HandleControlKey( (ControlRef) m_macControl , keycode , keychar , ev->modifiers ) ;
+            }
+        }

     }
     }

-    if ( key >= 0x20 ||
+    if ( ( key >= 0x20 && key < WXK_START ) ||

          key == WXK_RETURN ||
          key == WXK_RETURN ||

-         key == WXK_DELETE || 
+         key == WXK_DELETE ||

          key == WXK_BACK)
     {
         wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
          key == WXK_BACK)
     {
         wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);


@@ -1348,65 +1940,31 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
     }
 }
 
     }
 }
 

-void  wxTextCtrl::MacSuperShown( bool show ) 
-{
-    bool former = m_macControlIsShown ;
-    wxControl::MacSuperShown( show ) ;
-    if ( (former != m_macControlIsShown) && m_macUsesTXN )
-    {
-        if ( m_macControlIsShown )
-               TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left, 
-                           (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom,(**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
-        else
-               TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left, 
-                          (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
-    }
-}
-
-bool  wxTextCtrl::Show(bool show) 
-{
-    bool former = m_macControlIsShown ;
-    
-    bool retval = wxControl::Show( show ) ;
-    
-    if ( former != m_macControlIsShown )
-    {
-        if ( m_macControlIsShown )
-               TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left, 
-                           (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom,(**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
-        else
-               TXNSetFrameBounds( (TXNObject) m_macTXN, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.top + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.left, 
-                          (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.bottom + 30000, (**(STPTextPaneVars **)m_macTXNvars).fRTextArea.right, (**(STPTextPaneVars **)m_macTXNvars).fTXNFrame);
-    }
-    
-    return retval ;
-}
-

 // ----------------------------------------------------------------------------
 // standard handlers for standard edit menu events
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // standard handlers for standard edit menu events
 // ----------------------------------------------------------------------------
 

-void wxTextCtrl::OnCut(wxCommandEvent& event)
+void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))

 {
     Cut();
 }
 
 {
     Cut();
 }
 

-void wxTextCtrl::OnCopy(wxCommandEvent& event)
+void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))

 {
     Copy();
 }
 
 {
     Copy();
 }
 

-void wxTextCtrl::OnPaste(wxCommandEvent& event)
+void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))

 {
     Paste();
 }
 
 {
     Paste();
 }
 

-void wxTextCtrl::OnUndo(wxCommandEvent& event)
+void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))

 {
     Undo();
 }
 
 {
     Undo();
 }
 

-void wxTextCtrl::OnRedo(wxCommandEvent& event)
+void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))

 {
     Redo();
 }
 {
     Redo();
 }


@@ -1436,7 +1994,48 @@ void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
     event.Enable( CanRedo() );
 }
 
     event.Enable( CanRedo() );
 }
 

+bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
+{
+    return true ;
+}
+
+// user pane implementation
+
+void wxTextCtrl::MacControlUserPaneDrawProc(wxInt16 part) 
+{
+}
+
+wxInt16 wxTextCtrl::MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y) 
+{
+    return kControlNoPart ;
+}
+
+wxInt16 wxTextCtrl::MacControlUserPaneTrackingProc(wxInt16 x, wxInt16 y, void* actionProc) 
+{
+    return kControlNoPart ;
+}
+
+void wxTextCtrl::MacControlUserPaneIdleProc() 
+{
+}
+
+wxInt16 wxTextCtrl::MacControlUserPaneKeyDownProc(wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers) 
+{
+    return kControlNoPart ;
+}

 
 

+void wxTextCtrl::MacControlUserPaneActivateProc(bool activating) 
+{
+}
+
+wxInt16 wxTextCtrl::MacControlUserPaneFocusProc(wxInt16 action) 
+{
+    return kControlNoPart ;
+}
+
+void wxTextCtrl::MacControlUserPaneBackgroundProc(void* info) 
+{
+}

 
 #endif
     // wxUSE_TEXTCTRL
 
 #endif
     // wxUSE_TEXTCTRL