// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "textctrl.h"
#endif
-#include "wx/defs.h"
+#include "wx/wxprec.h"
#if wxUSE_TEXTCTRL
class wxMacFunctor
{
-public :
+public :
wxMacFunctor(){}
virtual ~wxMacFunctor() {}
virtual void* operator()() = 0 ;
- static void* CallBackProc(void *param)
+ static void* CallBackProc(void *param)
{
wxMacFunctor* f = (wxMacFunctor*) param ;
void *result = (*f)() ;
{
typedef void (classtype::*function)( param1type p1 ) ;
typedef void (classtype::*ref_function)( const param1type& p1 ) ;
-public :
+public :
wxMacObjectFunctor1( classtype *obj , function f , param1type p1 ) :
wxMacFunctor( )
{
}
~wxMacObjectFunctor1() {}
-
- virtual void* operator()()
+
+ virtual void* operator()()
{
(m_object->*m_function)(m_param1) ;
return NULL ;
} ;
} ;
-template<typename classtype, typename param1type>
+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 =
+ wxMacObjectFunctor1<classtype,param1type> params(object,function,p1) ;
+ void *result =
MPRemoteCall( wxMacFunctor::CallBackProc , ¶ms , kMPOwningProcessRemoteContext ) ;
return result ;
}
-template<typename classtype, typename param1type>
+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 =
+ wxMacObjectFunctor1<classtype,param1type> params(object,function,p1) ;
+ void *result =
MPRemoteCall( wxMacFunctor::CallBackProc , ¶ms , kMPOwningProcessRemoteContext ) ;
return result ;
}
-template<typename classtype, typename param1type>
+template<typename classtype, typename param1type>
void* wxMacMPRemoteGUICall( classtype *object , void (classtype::*function)( param1type p1 ) , param1type p1 )
{
wxMutexGuiLeave() ;
return result ;
}
-template<typename classtype, typename param1type>
+template<typename classtype, typename param1type>
void* wxMacMPRemoteGUICall( classtype *object , void (classtype::*function)( const param1type& p1 ) , param1type p1 )
{
wxMutexGuiLeave() ;
public :
wxMacTextControl() ;
~wxMacTextControl() ;
-
+
virtual wxString GetStringValue() const = 0 ;
virtual void SetStringValue( const wxString &val ) = 0 ;
virtual void SetStyle(long start, long end, const wxTextAttr& style) ;
virtual void Paste() ;
virtual bool CanPaste() const ;
virtual void SetEditable(bool editable) ;
- virtual long GetLastPosition() const ;
+ virtual wxTextPos GetLastPosition() const ;
virtual void Replace( long from , long to , const wxString str ) ;
virtual void Remove( long from , long to ) = 0 ;
virtual void SetSelection( long from , long to ) = 0 ;
virtual void Clear() ;
virtual bool CanUndo() const;
- virtual void Undo() ;
+ virtual void Undo() ;
virtual bool CanRedo() const;
virtual void Redo() ;
virtual int GetNumberOfLines() const ;
public :
virtual wxString GetStringValue() const ;
virtual void SetStringValue( const wxString &str) ;
-
- static int ConvertAttribute( const wxTextAttr& style , TXNTypeAttributes attr[] ) ;
+
static TXNFrameOptions FrameOptionsFromWXStyle( long wxStyle ) ;
void AdjustCreationAttributes( const wxColour& background , bool visible ) ;
virtual void Paste() ;
virtual bool CanPaste() const ;
virtual void SetEditable(bool editable) ;
- virtual long GetLastPosition() const ;
+ virtual wxTextPos GetLastPosition() const ;
virtual void Replace( long from , long to , const wxString str ) ;
virtual void Remove( long from , long to ) ;
virtual void GetSelection( long* from, long* to) const ;
virtual void SetSelection( long from , long to ) ;
-
+
virtual void WriteText(const wxString& str) ;
virtual void Clear() ;
void SetTXNData( const wxString& st , TXNOffset start , TXNOffset end ) ;
protected :
+ void TXNSetAttribute( const wxTextAttr& style , long from , long to ) ;
TXNObject m_txn ;
} ;
#if MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_2
-class wxMacMLTEHIViewControl : public wxMacMLTEControl
+class wxMacMLTEHIViewControl : public wxMacMLTEControl
{
public :
wxMacMLTEHIViewControl( wxWindow *wxPeer,
const wxSize& size, long style ) ;
virtual OSStatus SetFocus( ControlFocusPart focusPart ) ;
virtual bool HasFocus() const ;
- virtual bool NeedsFocusRect() const ;
+ virtual bool NeedsFocusRect() const;
protected :
HIViewRef m_scrollView ;
HIViewRef m_textView ;
const wxValidator& validator,
const wxString& name)
{
- m_macIsUserPane = FALSE ;
+ m_macIsUserPane = false ;
m_editable = true ;
if ( ! ( style & wxNO_BORDER) )
style = ( style & ~wxBORDER_MASK) | wxSUNKEN_BORDER ;
-
+
if ( !wxTextCtrlBase::Create(parent, id, pos, size, style & ~(wxHSCROLL|wxVSCROLL), validator, name) )
- return FALSE;
+ return false;
- Rect bounds = wxMacGetBoundsForControl( this , pos , size ) ;
+ Rect bounds = wxMacGetBoundsForControl( this , pos , size ) ;
if ( m_windowStyle & wxTE_MULTILINE )
{
#endif
#if !wxMAC_AWAYS_USE_MLTE
if ( !m_peer )
- {
+ {
m_peer = new wxMacUnicodeTextControl( this , str , pos , size , style ) ;
}
#endif
if ( !HasFlag(wxNO_BORDER) )
{
m_windowStyle &= ~wxSUNKEN_BORDER ;
- bounds = wxMacGetBoundsForControl( this , pos , size ) ;
- }
+ bounds = wxMacGetBoundsForControl( this , pos , size ) ;
+ }
m_peer = new wxMacMLTEClassicControl( this , str , pos , size , style ) ;
}
{
SetEditable( false ) ;
}
-
- return TRUE;
+ return true;
}
-void wxTextCtrl::MacVisibilityChanged()
+void wxTextCtrl::MacVisibilityChanged()
{
GetPeer()->VisibilityChanged( MacIsReallyShown() ) ;
}
-void wxTextCtrl::MacEnabledStateChanged()
+void wxTextCtrl::MacEnabledStateChanged()
{
}
}
void wxTextCtrl::GetSelection(long* from, long* to) const
-{
+{
GetPeer()->GetSelection( from , to ) ;
}
return ;
GetPeer()->SetStringValue(str) ;
+
+ wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
+ event.SetString( GetValue() ) ;
+ event.SetEventObject( this );
+ GetEventHandler()->ProcessEvent(event);
}
void wxTextCtrl::SetMaxLength(unsigned long len)
bool wxTextCtrl::SetFont( const wxFont& font )
{
if ( !wxTextCtrlBase::SetFont( font ) )
- return FALSE ;
-
+ return false ;
+
GetPeer()->SetFont( font , GetForegroundColour() , GetWindowStyle() ) ;
return true ;
}
{
wxTextCtrlBase::SetDefaultStyle( style ) ;
SetStyle( kTXNUseCurrentSelection , kTXNUseCurrentSelection , GetDefaultStyle() ) ;
- return TRUE ;
+ return true ;
}
// Clipboard operations
{
if (CanCopy())
{
- GetPeer()->Copy() ;
+ GetPeer()->Copy() ;
}
}
{
if (CanCut())
{
- GetPeer()->Cut() ;
+ GetPeer()->Cut() ;
wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
- event.SetString( GetValue() ) ;
event.SetEventObject( this );
GetEventHandler()->ProcessEvent(event);
}
{
if (CanPaste())
{
- GetPeer()->Paste() ;
+ GetPeer()->Paste() ;
// eventually we should add setting the default style again
wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
- event.SetString( GetValue() ) ;
event.SetEventObject( this );
GetEventHandler()->ProcessEvent(event);
}
bool wxTextCtrl::CanPaste() const
{
if (!IsEditable())
- return FALSE;
+ return false;
return GetPeer()->CanPaste() ;
}
void wxTextCtrl::SetInsertionPointEnd()
{
- long pos = GetLastPosition();
+ wxTextPos pos = GetLastPosition();
SetInsertionPoint(pos);
}
return begin ;
}
-long wxTextCtrl::GetLastPosition() const
+wxTextPos wxTextCtrl::GetLastPosition() const
{
return GetPeer()->GetLastPosition( ) ;
}
{
if ( wxTextCtrlBase::LoadFile(file) )
{
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
void wxTextCtrl::WriteText(const wxString& str)
// TODO this MPRemoting will be moved into a remoting peer proxy for any command
if ( !wxIsMainThread() )
{
- // unfortunately CW 8 is not able to correctly deduce the template types, so we have
+ // 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 ;
break ;
default :
hText = 22 - 6;
- break ;
+ break ;
}
// as the above numbers have some free space around the text
bool wxTextCtrl::CanUndo() const
{
- if ( !IsEditable() )
+ if ( !IsEditable() )
{
- return false ;
+ return false ;
}
return GetPeer()->CanUndo() ;
}
bool wxTextCtrl::CanRedo() const
{
- if ( !IsEditable() )
+ if ( !IsEditable() )
{
- return false ;
+ return false ;
}
return GetPeer()->CanRedo() ;
}
return ;
}
+ // Check if we have reached the max # of chars, but still allow navigation and deletion
+ if ( !IsMultiLine() && GetValue().Length() >= m_maxLength &&
+ key != WXK_LEFT && key != WXK_RIGHT && key != WXK_TAB &&
+ key != WXK_BACK && !( key == WXK_RETURN && (m_windowStyle & wxPROCESS_ENTER) )
+ )
+ {
+ // eat it, we don't want to add more than allowed # of characters
+ return;
+ }
+
// assume that any key not processed yet is going to modify the control
m_dirty = true;
// this will make wxWidgets eat the ENTER key so that
// we actually prevent line wrapping in a single line
// text control
- eat_key = TRUE;
+ eat_key = true;
}
break;
// be inserted.
WriteText(wxT("\t"));
}
-
+
break;
}
// perform keystroke handling
if ( wxTheApp->MacGetCurrentEvent() != NULL && wxTheApp->MacGetCurrentEventHandlerCallRef() != NULL )
CallNextEventHandler((EventHandlerCallRef)wxTheApp->MacGetCurrentEventHandlerCallRef() , (EventRef) wxTheApp->MacGetCurrentEvent() ) ;
- else
+ else
{
EventRecord rec ;
if ( wxMacConvertEventToRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) )
key == WXK_BACK)
{
wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
- event1.SetString( GetValue() ) ;
event1.SetEventObject( this );
wxPostEvent(GetEventHandler(),event1);
}
{
return true ;
}
-
+#if !TARGET_API_MAC_OSX
// user pane implementation
-void wxTextCtrl::MacControlUserPaneDrawProc(wxInt16 part)
+void wxTextCtrl::MacControlUserPaneDrawProc(wxInt16 part)
{
}
-wxInt16 wxTextCtrl::MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y)
+wxInt16 wxTextCtrl::MacControlUserPaneHitTestProc(wxInt16 x, wxInt16 y)
{
return kControlNoPart ;
}
-wxInt16 wxTextCtrl::MacControlUserPaneTrackingProc(wxInt16 x, wxInt16 y, void* actionProc)
+wxInt16 wxTextCtrl::MacControlUserPaneTrackingProc(wxInt16 x, wxInt16 y, void* actionProc)
{
return kControlNoPart ;
}
-void wxTextCtrl::MacControlUserPaneIdleProc()
+void wxTextCtrl::MacControlUserPaneIdleProc()
{
}
-wxInt16 wxTextCtrl::MacControlUserPaneKeyDownProc(wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers)
+wxInt16 wxTextCtrl::MacControlUserPaneKeyDownProc(wxInt16 keyCode, wxInt16 charCode, wxInt16 modifiers)
{
return kControlNoPart ;
}
-void wxTextCtrl::MacControlUserPaneActivateProc(bool activating)
+void wxTextCtrl::MacControlUserPaneActivateProc(bool activating)
{
}
-wxInt16 wxTextCtrl::MacControlUserPaneFocusProc(wxInt16 action)
+wxInt16 wxTextCtrl::MacControlUserPaneFocusProc(wxInt16 action)
{
return kControlNoPart ;
}
-void wxTextCtrl::MacControlUserPaneBackgroundProc(void* info)
+void wxTextCtrl::MacControlUserPaneBackgroundProc(void* info)
{
}
-
+#endif
// ----------------------------------------------------------------------------
// implementation base class
// ----------------------------------------------------------------------------
-wxMacTextControl::wxMacTextControl()
+wxMacTextControl::wxMacTextControl()
{
}
-wxMacTextControl::~wxMacTextControl()
+wxMacTextControl::~wxMacTextControl()
{
}
-void wxMacTextControl::SetStyle(long start, long end, const wxTextAttr& style)
+void wxMacTextControl::SetStyle(long start, long end, const wxTextAttr& style)
{
}
-void wxMacTextControl::Copy()
+void wxMacTextControl::Copy()
{
}
-void wxMacTextControl::Cut()
+void wxMacTextControl::Cut()
{
}
-void wxMacTextControl::Paste()
+void wxMacTextControl::Paste()
{
}
-bool wxMacTextControl::CanPaste() const
-{
+bool wxMacTextControl::CanPaste() const
+{
return false ;
}
-void wxMacTextControl::SetEditable(bool editable)
+void wxMacTextControl::SetEditable(bool editable)
{
-}
+}
-long wxMacTextControl::GetLastPosition() const
+wxTextPos wxMacTextControl::GetLastPosition() const
{
return GetStringValue().Length() ;
}
-void wxMacTextControl::Replace( long from , long to , const wxString str )
+void wxMacTextControl::Replace( long from , long to , const wxString str )
{
}
-void wxMacTextControl::Clear()
+void wxMacTextControl::Clear()
{
SetStringValue( wxEmptyString ) ;
}
-bool wxMacTextControl::CanUndo() const
+bool wxMacTextControl::CanUndo() const
{
return false ;
}
-void wxMacTextControl::Undo() { }
+void wxMacTextControl::Undo() { }
bool wxMacTextControl::CanRedo() const
{
return false ;
-}
+}
-void wxMacTextControl::Redo()
+void wxMacTextControl::Redo()
{
}
return 0 ;
}
-bool wxMacTextControl::PositionToXY(long pos, long *x, long *y) const
+bool wxMacTextControl::PositionToXY(long pos, long *x, long *y) const
{
return false ;
}
-void wxMacTextControl::ShowPosition( long WXUNUSED(pos) )
-{
-}
+void wxMacTextControl::ShowPosition( long WXUNUSED(pos) )
+{
+}
-int wxMacTextControl::GetNumberOfLines() const
+int wxMacTextControl::GetNumberOfLines() const
{
ItemCount lines = 0 ;
wxString content = GetStringValue() ;
{
// TODO change this if possible to reflect real lines
wxString content = GetStringValue() ;
-
+
// Find line first
int count = 0;
for (size_t i = 0; i < content.Length() ; i++)
{
// Add chars in line then
wxString tmp;
-
+
for (size_t j = i; j < content.Length(); j++)
{
if (content[j] == '\n')
return tmp;
-
+
tmp += content[j];
}
-
+
return tmp;
}
if (content[i] == '\n') count++;
{
// TODO change this if possible to reflect real lines
wxString content = GetStringValue() ;
-
+
// Find line first
int count = 0;
for (size_t i = 0; i < content.Length() ; i++)
count++;
if (content[j] == '\n') return count;
}
-
+
return count;
}
if (content[i] == '\n') count++;
{
m_font = wxPeer->GetFont() ;
m_windowStyle = style ;
- Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
+ Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
wxString st = str ;
wxMacConvertNewlines10To13( &st ) ;
wxMacCFStringHolder cf(st , m_font.GetEncoding()) ;
Boolean isPassword = ( m_windowStyle & wxTE_PASSWORD ) != 0 ;
m_valueTag = isPassword ? kControlEditTextPasswordCFStringTag : kControlEditTextCFStringTag ;
CreateEditUnicodeTextControl( MAC_WXHWND(wxPeer->MacGetTopLevelWindowRef()), &bounds , cfr , isPassword , NULL , &m_controlRef ) ;
-
+
if ( !(m_windowStyle & wxTE_MULTILINE) )
{
SetData<Boolean>( kControlEditTextPart , kControlEditTextSingleLineTag , true ) ;
{
}
-void wxMacUnicodeTextControl::VisibilityChanged(bool shown)
+void wxMacUnicodeTextControl::VisibilityChanged(bool shown)
{
if ( !(m_windowStyle & wxTE_MULTILINE) && shown )
{
verify_noerr( GetData<CFStringRef>( 0, m_valueTag , &value ) );
verify_noerr( SetData<CFStringRef>( 0, m_valueTag, &value ) );
verify_noerr( SetData<ControlEditTextSelectionRec>( 0, kControlEditTextSelectionTag, &sel ) );
-
+
CFRelease( value ) ;
}
}
-wxString wxMacUnicodeTextControl::GetStringValue() const
+wxString wxMacUnicodeTextControl::GetStringValue() const
{
wxString result ;
CFStringRef value = GetData<CFStringRef>(0,m_valueTag) ;
wxMacCFStringHolder cf(value) ;
result = cf.AsString() ;
}
-#if TARGET_API_MAC_OSX
+#if '\n' == 10
wxMacConvertNewlines13To10( &result ) ;
#else
wxMacConvertNewlines10To13( &result ) ;
#endif
return result ;
}
-void wxMacUnicodeTextControl::SetStringValue( const wxString &str)
+void wxMacUnicodeTextControl::SetStringValue( const wxString &str)
{
wxString st = str ;
wxMacConvertNewlines10To13( &st ) ;
{
return true ;
}
-void wxMacUnicodeTextControl::SetEditable(bool editable)
+void wxMacUnicodeTextControl::SetEditable(bool editable)
{
SetData<Boolean>( 0 , kControlEditTextLockedTag , (Boolean) !editable ) ;
}
-void wxMacUnicodeTextControl::Remove( long from , long to )
+void wxMacUnicodeTextControl::Remove( long from , long to )
{
}
if ( to ) *to = sel.selEnd ;
}
-void wxMacUnicodeTextControl::SetSelection( long from , long to )
+void wxMacUnicodeTextControl::SetSelection( long from , long to )
{
ControlEditTextSelectionRec sel ;
sel.selStart = from ;
// MLTE control implementation (common part)
// ----------------------------------------------------------------------------
-#if TARGET_API_MAC_OSX == 0
+#if TARGET_API_MAC_OSX == 0
// declaration needed because of one line in the code...
static void TPUpdateVisibility(ControlRef theControl) ;
#endif
-// if mlte is on read only , no changes at all are allowed, not even from
+// if mlte is on read only , no changes at all are allowed, not even from
// procedural API, in order to allow changes via API all the same we must undo
// the readonly status while we are executing, this class helps to do so
TXNSetTXNObjectControls( m_txn , false , 1 , tag , data ) ;
}
}
- ~EditHelper()
+ ~EditHelper()
{
TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
if ( m_data[0].uValue == kTXNReadOnly )
TXNControlData m_data[1] ;
} ;
-wxString wxMacMLTEControl::GetStringValue() const
+wxString wxMacMLTEControl::GetStringValue() const
{
wxString result ;
OSStatus err ;
if ( actualSize > 0 )
{
wxChar *ptr = NULL ;
-#if SIZEOF_WCHAR_T == 2
- ptr = new wxChar[actualSize + 1 ] ;
+#if SIZEOF_WCHAR_T == 2
+ ptr = new wxChar[actualSize + 1 ] ;
wxStrncpy( ptr , (wxChar*) *theText , actualSize ) ;
-
#else
SetHandleSize( theText , ( actualSize + 1 ) * sizeof( UniChar ) ) ;
HLock( theText ) ;
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
}
-#if TARGET_API_MAC_OSX
+#if '\n' == 10
wxMacConvertNewlines13To10( &result ) ;
#else
wxMacConvertNewlines10To13( &result ) ;
return result ;
}
-void wxMacMLTEControl::SetStringValue( const wxString &str)
+void wxMacMLTEControl::SetStringValue( const wxString &str)
{
wxString st = str ;
}
else
frameOptions |= kTXNSingleLineOnlyMask ;
-
+
if ( wxStyle & wxHSCROLL )
frameOptions |= kTXNWantHScrollBarMask ;
-
+
return frameOptions ;
}
iControlTags[2] = kTXNVisibilityTag ;
iControlData[2].uValue = visible ;
toptag++ ;
-#endif
-
+#endif
+
if ( m_windowStyle & wxTE_MULTILINE )
{
if (m_windowStyle & wxTE_DONTWRAP)
iControlData[1].uValue = kTXNNoAutoWrap ;
else
iControlData[1].uValue = kTXNAutoWrap ;
-
}
verify_noerr( TXNSetTXNObjectControls( m_txn, false, toptag,
iControlTags, iControlData )) ;
TXNSetBackground( m_txn , &tback);
}
-void wxMacMLTEControl::SetBackground( const wxBrush &brush )
+void wxMacMLTEControl::SetBackground( const wxBrush &brush )
{
// currently only solid background are supported
TXNBackground tback;
TXNSetBackground( m_txn , &tback);
}
-int wxMacMLTEControl::ConvertAttribute( const wxTextAttr& style , TXNTypeAttributes typeAttr[] )
+void wxMacMLTEControl::TXNSetAttribute( const wxTextAttr& style , long from , long to)
{
+ TXNTypeAttributes typeAttr[4] ;
Str255 fontName = "\pMonaco" ;
SInt16 fontSize = 12 ;
Style fontStyle = normal ;
fontStyle |= bold ;
if ( font.GetStyle() == wxITALIC )
fontStyle |= italic ;
-
+
typeAttr[attrCounter].tag = kTXNQDFontNameAttribute ;
typeAttr[attrCounter].size = kTXNQDFontNameAttributeSize ;
typeAttr[attrCounter].data.dataPtr = (void*) fontName ;
color = MAC_WXCOLORREF(style.GetTextColour().GetPixel()) ;
attrCounter += 1 ;
}
- return attrCounter ;
+ if ( attrCounter > 0 )
+ {
+ verify_noerr( TXNSetTypeAttributes ( m_txn , attrCounter , typeAttr, from , to) );
+ }
}
-void wxMacMLTEControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
+void wxMacMLTEControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
{
EditHelper help(m_txn) ;
- wxTextAttr style(foreground,wxNullColour,font) ;
- TXNTypeAttributes typeAttr[4] ;
- int attrCounter = ConvertAttribute( style , typeAttr ) ;
- if ( attrCounter > 0 )
- {
- verify_noerr( TXNSetTypeAttributes ( m_txn , attrCounter , typeAttr, kTXNStartOffset,kTXNEndOffset) );
- }
+ TXNSetAttribute( wxTextAttr(foreground,wxNullColour,font) , kTXNStartOffset,kTXNEndOffset ) ;
}
-void wxMacMLTEControl::SetStyle(long start, long end, const wxTextAttr& style)
-{
+void wxMacMLTEControl::SetStyle(long start, long end, const wxTextAttr& style)
+{
EditHelper help(m_txn) ;
- TXNTypeAttributes typeAttr[4] ;
- int attrCounter = ConvertAttribute( style , typeAttr ) ;
- if ( attrCounter > 0 )
- {
- verify_noerr( TXNSetTypeAttributes ( m_txn , attrCounter , typeAttr, start,end) );
- }
-}
-
-void wxMacMLTEControl::Copy()
+ TXNSetAttribute( style , start,end ) ;
+}
+
+void wxMacMLTEControl::Copy()
{
ClearCurrentScrap();
TXNCopy(m_txn);
TXNConvertToPublicScrap();
}
-void wxMacMLTEControl::Cut()
+void wxMacMLTEControl::Cut()
{
ClearCurrentScrap();
TXNCut(m_txn);
TXNConvertToPublicScrap();
}
-void wxMacMLTEControl::Paste()
+void wxMacMLTEControl::Paste()
{
TXNConvertFromPublicScrap();
TXNPaste(m_txn);
return TXNIsScrapPastable() ;
}
-void wxMacMLTEControl::SetEditable(bool editable)
+void wxMacMLTEControl::SetEditable(bool editable)
{
TXNControlTag tag[] = { kTXNIOPrivilegesTag } ;
TXNControlData data[] = { { editable ? kTXNReadWrite : kTXNReadOnly } } ;
TXNSetTXNObjectControls( m_txn , false , sizeof(tag) / sizeof (TXNControlTag) , tag , data ) ;
}
-long wxMacMLTEControl::GetLastPosition() const
+wxTextPos wxMacMLTEControl::GetLastPosition() const
{
- long actualsize = 0 ;
+ wxTextPos actualsize = 0 ;
Handle theText ;
OSErr err = TXNGetDataEncoded( m_txn, kTXNStartOffset, kTXNEndOffset, &theText , kTXNTextData );
return actualsize ;
}
-void wxMacMLTEControl::Replace( long from , long to , const wxString str )
+void wxMacMLTEControl::Replace( long from , long to , const wxString str )
{
wxString value = str ;
wxMacConvertNewlines10To13( &value ) ;
TXNGetSelection( m_txn , (TXNOffset*) from , (TXNOffset*) to ) ;
}
-void wxMacMLTEControl::SetSelection( long from , long to )
+void wxMacMLTEControl::SetSelection( long from , long to )
{
/* change the selection */
if ((from == -1) && (to == -1))
- TXNSelectAll(m_txn);
+ TXNSelectAll(m_txn);
else
- TXNSetSelection( m_txn, from, to);
+ TXNSetSelection( m_txn, from, to);
TXNShowSelection( m_txn, kTXNShowStart);
}
-void wxMacMLTEControl::WriteText(const wxString& str)
+void wxMacMLTEControl::WriteText(const wxString& str)
{
EditHelper helper( m_txn ) ;
wxString st = str ;
// TODO SetStyle( start , end , GetDefaultStyle() ) ;
}
-void wxMacMLTEControl::Clear()
+void wxMacMLTEControl::Clear()
{
EditHelper st(m_txn) ;
TXNSetSelection( m_txn , kTXNStartOffset , kTXNEndOffset ) ;
TXNClear(m_txn);
}
-bool wxMacMLTEControl::CanUndo() const
+bool wxMacMLTEControl::CanUndo() const
{
return TXNCanUndo( m_txn , NULL ) ;
}
-void wxMacMLTEControl::Undo()
+void wxMacMLTEControl::Undo()
{
- TXNUndo( m_txn ) ;
-}
+ TXNUndo( m_txn ) ;
+}
bool wxMacMLTEControl::CanRedo() const
{
return TXNCanRedo( m_txn , NULL ) ;
-}
+}
-void wxMacMLTEControl::Redo()
-{
+void wxMacMLTEControl::Redo()
+{
TXNRedo( m_txn ) ;
}
-int wxMacMLTEControl::GetNumberOfLines() const
+int wxMacMLTEControl::GetNumberOfLines() const
{
ItemCount lines = 0 ;
TXNGetLineCount(m_txn, &lines ) ;
long wxMacMLTEControl::XYToPosition(long x, long y) const
{
Point curpt ;
-
- long lastpos = GetLastPosition() ;
-
- // TODO find a better implementation : while we can get the
+
+ wxTextPos 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 xpos = 0 ;
long ypos = 0 ;
int lastHeight = 0 ;
{
if ( y == ypos && x == xpos )
return n ;
-
+
TXNOffsetToPoint( m_txn , n , &curpt);
if ( curpt.v > lastHeight )
bool wxMacMLTEControl::PositionToXY(long pos, long *x, long *y) const
{
Point curpt ;
-
- long lastpos = GetLastPosition() ;
-
+
+ wxTextPos lastpos = GetLastPosition() ;
+
if ( y ) *y = 0 ;
if ( x ) *x = 0 ;
-
+
if ( pos <= lastpos )
{
- // TODO find a better implementation : while we can get the
+ // 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 xpos = 0 ;
long ypos = 0 ;
int lastHeight = 0 ;
if ( x ) *x = xpos ;
}
- return FALSE ;
+ return false ;
}
-void wxMacMLTEControl::ShowPosition( long pos )
+void wxMacMLTEControl::ShowPosition( long pos )
{
#if TARGET_RT_MAC_MACHO && defined(AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER)
{
SInt32 dv = desired.v - current.v ;
SInt32 dh = desired.h - current.h ;
TXNShowSelection( m_txn , true ) ;
- theErr = TXNScroll( m_txn, kTXNScrollUnitsInPixels , kTXNScrollUnitsInPixels , &dv , &dh );
+ theErr = TXNScroll( m_txn, kTXNScrollUnitsInPixels , kTXNScrollUnitsInPixels , &dv , &dh );
wxASSERT_MSG( theErr == noErr, _T("TXNScroll returned an error!") );
}
}
{
#if wxUSE_UNICODE
#if SIZEOF_WCHAR_T == 2
- size_t len = st.Len() ;
+ size_t len = st.Len() ;
TXNSetData( m_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 ) ;
+ 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( m_txn , kTXNUnicodeTextData, (void*)unibuf, byteBufferLen ,
start, end);
- free( unibuf ) ;
+ free( unibuf ) ;
#endif
#else
- wxCharBuffer text = st.mb_str(wxConvLocal) ;
+ wxCharBuffer text = st.mb_str(wxConvLocal) ;
TXNSetData( m_txn , kTXNTextData, (void*)text.data(), strlen( text ) ,
start, end);
-#endif
+#endif
}
if ( lineNo < GetNumberOfLines() )
{
long ypos = 0 ;
-
- Fixed lineWidth,
+
+ Fixed lineWidth,
lineHeight,
currentHeight = 0;
-
+
// get the first possible position in the control
Point firstPoint;
TXNOffsetToPoint(m_txn, 0, &firstPoint);
-
+
// Iterate through the lines until we reach the one we want,
// adding to our current y pixel point position
while (ypos < lineNo)
TXNGetLineMetrics(m_txn, ypos++, &lineWidth, &lineHeight);
currentHeight += lineHeight;
}
-
- Point thePoint = { firstPoint.v + Fix2Long(currentHeight), firstPoint.h + Fix2Long(0) };
+
+ Point thePoint = { firstPoint.v + (currentHeight >> 16), firstPoint.h + (0) };
TXNOffset theOffset;
TXNPointToOffset(m_txn, thePoint, &theOffset);
-
+
wxString content = GetStringValue() ;
Point currentPoint = thePoint;
while(thePoint.v == currentPoint.v && theOffset < content.length())
if ( lineNo < GetNumberOfLines() )
{
long ypos = 0 ;
-
- Fixed lineWidth,
+
+ Fixed lineWidth,
lineHeight,
currentHeight = 0;
-
+
// get the first possible position in the control
Point firstPoint;
TXNOffsetToPoint(m_txn, 0, &firstPoint);
-
+
// Iterate through the lines until we reach the one we want,
// adding to our current y pixel point position
while (ypos < lineNo)
TXNGetLineMetrics(m_txn, ypos++, &lineWidth, &lineHeight);
currentHeight += lineHeight;
}
-
- Point thePoint = { firstPoint.v + Fix2Long(currentHeight), firstPoint.h + Fix2Long(0) };
+
+ Point thePoint = { firstPoint.v + (currentHeight >> 16), firstPoint.h + (0) };
TXNOffset theOffset;
TXNPointToOffset(m_txn, thePoint, &theOffset);
-
+
wxString content = GetStringValue() ;
Point currentPoint = thePoint;
while(thePoint.v == currentPoint.v && theOffset < content.length())
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 fTXNObjectActive; /* reflects the activation state of the text edit record */
- Boolean fFocusDrawState; /* true if focus is drawn (default: true) */
+ Boolean fFocusDrawState; /* true if focus is drawn (default: true) */
/* calculated locations */
Rect fRBounds; /* control bounds */
Rect fRTextArea; /* area where the text is drawn */
ControlUserPaneFocusUPP gTPFocusProc = NULL;
// one place for calculating all
-static void TPCalculateBounds(STPTextPaneVars *varsp, const Rect& bounds)
+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);
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) ,
+ 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
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 )
+ if ( textctrl )
{
+#if TARGET_API_MAC_OSX
+ TXNControlTag iControlTags[1] = { kTXNVisibilityTag };
+ TXNControlData iControlData[1] = {{ vis }};
+ err = ::TXNSetTXNObjectControls( varsp->fTXNRec, false, 1, iControlTags, iControlData );
+#endif
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);
+ if ( vis )
+ {
+ wxMacWindowClipper cl(textctrl) ;
+ TXNSetFrameBounds( varsp->fTXNRec, varsp->fRTextArea.top, varsp->fRTextArea.left,
+ varsp->fRTextArea.bottom, varsp->fRTextArea.right, varsp->fTXNFrame);
+ TXNShowSelection( varsp->fTXNRec, kTXNShowStart);
+ }
+ else
+ {
+#if TARGET_API_MAC_OSX
+ // in 10.2 the scrollbars are still actively redrawn when using only the code above
+ if ( UMAGetSystemVersion() < 0x1030 )
+ {
+ TXNSetFrameBounds( varsp->fTXNRec, varsp->fRTextArea.top + 20000 , varsp->fRTextArea.left + 20000 ,
+ varsp->fRTextArea.bottom + 20000 , varsp->fRTextArea.right + 20000 , varsp->fTXNFrame);
+ }
+#endif
+ }
}
return err ;
}
wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
if ( textctrl == NULL )
return ;
-
+
STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
-
+
Rect bounds ;
UMAGetControlBoundsInWindowCoords(theControl, &bounds);
if ( textctrl->MacIsReallyShown() != varsp->fVisible )
// make correct activations
static void TPActivatePaneText(STPTextPaneVars *varsp, Boolean setActive) {
-
wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(varsp->fUserPaneRec);
- if (varsp->fTXNObjectActive != setActive && textctrl->MacIsReallyShown() )
+ if (varsp->fTXNObjectActive != setActive && textctrl->MacIsReallyShown() )
{
varsp->fTXNObjectActive = setActive;
TXNActivate(varsp->fTXNRec, varsp->fTXNFrame, varsp->fTXNObjectActive);
// update focus outlines
static void TPRedrawFocusOutline(STPTextPaneVars *varsp) {
-
/* state changed */
- if (varsp->fFocusDrawState != (varsp->fIsActive && varsp->fInFocus))
- {
- varsp->fFocusDrawState = (varsp->fIsActive && varsp->fInFocus);
- DrawThemeFocusRect(&varsp->fRFocusOutline, varsp->fFocusDrawState);
- }
+ 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);
// draw the control
static pascal void TPPaneDrawProc(ControlRef theControl, ControlPartCode thePart) {
/* set up our globals */
-
+
wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
if ( textctrl == NULL )
return ;
TPUpdateVisibility( theControl ) ;
-
+
STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
if ( textctrl->MacIsReallyShown() )
{
wxMacWindowClipper clipper( textctrl ) ;
TXNDraw(varsp->fTXNRec, NULL);
if ( !varsp->fNoBorders )
- DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
+ DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
TPRedrawFocusOutline( varsp ) ;
}
-
}
return 0 ;
TPUpdateVisibility( theControl ) ;
STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
- if (textctrl->MacIsReallyShown() )
+ if (textctrl->MacIsReallyShown() )
{
if (PtInRect(where, &varsp->fRBounds))
result = kmUPTextPart;
- else
+ else
{
// sometimes we get the coords also in control local coordinates, therefore test again
if ( textctrl->MacGetTopLevelWindow()->MacUsesCompositing() )
}
if (PtInRect(where, &varsp->fRBounds))
result = kmUPTextPart;
- else
+ else
result = 0;
}
}
over our control. This routine handles clicks in the text area
and in the scroll bar. */
static pascal ControlPartCode TPPaneTrackingProc(ControlRef theControl, Point startPt, ControlActionUPP actionProc) {
-
+
ControlPartCode partCodeResult;
- /* make sure we have some variables... */
+ /* make sure we have some variables... */
partCodeResult = 0;
wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
if ( textctrl == NULL )
return 0;
TPUpdateVisibility( theControl ) ;
STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
- if (textctrl->MacIsReallyShown() )
- {
- /* we don't do any of these functions unless we're in focus */
+ 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);
}
- /* find the location for the click */
+ /* find the location for the click */
// for compositing, we must convert these into toplevel window coordinates, because hittesting expects them
if ( textctrl->MacGetTopLevelWindow()->MacUsesCompositing() )
{
startPt.h += x ;
startPt.v += y ;
}
-
- switch (TPPaneHitTestProc(theControl, startPt))
+
+ switch (TPPaneHitTestProc(theControl, startPt))
{
-
- /* handle clicks in the text part */
+ /* handle clicks in the text part */
case kmUPTextPart:
- {
- wxMacWindowClipper clipper( textctrl ) ;
-
- EventRecord rec ;
- ConvertEventRefToEventRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) ;
- TXNClick( varsp->fTXNRec, &rec );
-
- }
+ {
+ wxMacWindowClipper clipper( textctrl ) ;
+
+ EventRecord rec ;
+ ConvertEventRefToEventRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) ;
+ TXNClick( varsp->fTXNRec, &rec );
+
+ }
break;
-
+
}
}
return partCodeResult;
if (varsp->fIsActive) {
Rect bounds;
Point mousep;
-
+
wxMacWindowClipper clipper( textctrl ) ;
GetMouse(&mousep);
/* there's a 'focus thing' and an 'unfocused thing' */
edit record and redraw the scroll bar and text field as appropriate. */
static pascal ControlPartCode TPPaneKeyDownProc(ControlRef theControl,
SInt16 keyCode, SInt16 charCode, SInt16 modifiers) {
-
+
wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
if ( textctrl == NULL )
return 0;
TPUpdateVisibility( theControl ) ;
-
+
STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
- if (varsp->fInFocus)
+ if (varsp->fInFocus)
{
/* turn autoscrolling on and send the key event to text edit */
wxMacWindowClipper clipper( textctrl ) ;
static pascal void TPPaneActivateProc(ControlRef theControl, Boolean activating) {
/* set up locals */
wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
-
+
if ( textctrl == NULL )
return ;
TPUpdateVisibility( theControl ) ;
-
+
STPTextPaneVars *varsp = (STPTextPaneVars *) ((wxMacMLTEClassicControl*)textctrl->GetPeer())->m_macTXNvars ;
-
+
varsp->fIsActive = activating;
wxMacWindowClipper clipper( textctrl ) ;
TPActivatePaneText(varsp, varsp->fIsActive && varsp->fInFocus);
if ( textctrl->MacIsReallyShown() )
{
if ( !varsp->fNoBorders )
- DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
+ DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
TPRedrawFocusOutline( varsp ) ;
}
}
necessary. */
static pascal ControlPartCode TPPaneFocusProc(ControlRef theControl, ControlFocusPart action) {
ControlPartCode focusResult;
-
+
focusResult = kControlFocusNoPart;
wxTextCtrl* textctrl = (wxTextCtrl*) GetControlReference(theControl);
if ( textctrl == NULL )
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
{
wxMacWindowClipper c( textctrl ) ;
if ( !varsp->fNoBorders )
- DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
+ DrawThemeEditTextFrame(&varsp->fRTextOutline, varsp->fIsActive ? kThemeStateActive: kThemeStateInactive);
TPRedrawFocusOutline( varsp ) ;
}
return focusResult;
wxMacMLTEClassicControl::wxMacMLTEClassicControl( wxWindow *wxPeer,
const wxString& str,
const wxPoint& pos,
- const wxSize& size, long style )
+ const wxSize& size, long style )
{
m_font = wxPeer->GetFont() ;
m_windowStyle = style ;
- Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
+ Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
wxString st = str ;
wxMacConvertNewlines10To13( &st ) ;
/* create the control */
verify_noerr( ::CreateUserPaneControl( MAC_WXHWND(wxPeer->GetParent()->MacGetTopLevelWindowRef()), &bounds, featurSet, &m_controlRef ) );
-
+
{
// wxMacWindowClipper c(wxPeer) ;
DoCreate();
}
-
+
if ( wxPeer->MacIsReallyShown() )
MLTESetObjectVisibility( (STPTextPaneVars*) m_macTXNvars, true , style ) ;
{
- // wxMacWindowClipper clipper( wxPeer ) ;
+ // wxMacWindowClipper clipper( wxPeer ) ;
TPUpdateVisibility( m_controlRef ) ;
TXNSetSelection( m_txn, 0, 0);
TXNShowSelection( m_txn, kTXNShowStart);
- }
-
+ }
+
AdjustCreationAttributes( *wxWHITE , true ) ;
}
free(m_macTXNvars);
}
-void wxMacMLTEClassicControl::VisibilityChanged(bool shown)
+void wxMacMLTEClassicControl::VisibilityChanged(bool shown)
{
MLTESetObjectVisibility((STPTextPaneVars*) m_macTXNvars , shown , m_windowStyle ) ;
if ( !shown )
InvalWindowRect( GetControlOwner( m_controlRef ) , &((STPTextPaneVars *)m_macTXNvars)->fRBounds ) ;
}
+bool wxMacMLTEClassicControl::NeedsFocusRect() const
+{
+ return true;
+}
+
OSStatus wxMacMLTEClassicControl::DoCreate()
{
Rect bounds;
WindowRef theWindow;
OSStatus err = noErr ;
-
+
/* set up our globals */
if (gTPDrawProc == NULL) gTPDrawProc = NewControlUserPaneDrawUPP(TPPaneDrawProc);
if (gTPHitProc == NULL) gTPHitProc = NewControlUserPaneHitTestUPP(TPPaneHitTestProc);
if (gTPKeyProc == NULL) gTPKeyProc = NewControlUserPaneKeyDownUPP(TPPaneKeyDownProc);
if (gTPActivateProc == NULL) gTPActivateProc = NewControlUserPaneActivateUPP(TPPaneActivateProc);
if (gTPFocusProc == NULL) gTPFocusProc = NewControlUserPaneFocusUPP(TPPaneFocusProc);
-
+
/* allocate our private storage */
m_macTXNvars = (STPTextPaneVars *) malloc(sizeof(STPTextPaneVars));
-
+
/* set the initial settings for our private data */
m_macTXNvars->fMultiline = m_windowStyle & wxTE_MULTILINE ;
m_macTXNvars->fNoBorders = m_windowStyle & wxNO_BORDER ;
m_macTXNvars->fInFocus = false;
m_macTXNvars->fIsActive = true;
- m_macTXNvars->fTXNObjectActive = false;
+ m_macTXNvars->fTXNObjectActive = false;
m_macTXNvars->fFocusDrawState = false ;
m_macTXNvars->fUserPaneRec = m_controlRef ;
m_macTXNvars->fVisible = true ;
-
+
theWindow = m_macTXNvars->fOwner = GetControlOwner(m_controlRef);
-
+
m_macTXNvars->fDrawingEnvironment = (GrafPtr) GetWindowPort(theWindow);
-
+
/* set up the user pane procedures */
SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneDrawProcTag, sizeof(gTPDrawProc), &gTPDrawProc);
SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneHitTestProcTag, sizeof(gTPHitProc), &gTPHitProc);
SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneKeyDownProcTag, sizeof(gTPKeyProc), &gTPKeyProc);
SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneActivateProcTag, sizeof(gTPActivateProc), &gTPActivateProc);
SetControlData(m_controlRef, kControlEntireControl, kControlUserPaneFocusProcTag, sizeof(gTPFocusProc), &gTPFocusProc);
-
+
/* calculate the rectangles used by the control */
UMAGetControlBoundsInWindowCoords(m_controlRef, &bounds);
m_macTXNvars->fRTextOutlineRegion = NewRgn() ;
TPCalculateBounds( m_macTXNvars , bounds ) ;
-
+
/* set up the drawing environment */
SetPort(m_macTXNvars->fDrawingEnvironment);
-
+
/* create the new edit field */
-
+
TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( m_windowStyle ) ;
-
+
verify_noerr(TXNNewObject(NULL, m_macTXNvars->fOwner, &m_macTXNvars->fRTextArea,
frameOptions ,
kTXNTextEditStyleFrameType,
kTXNSystemDefaultEncoding,
&m_macTXNvars->fTXNRec, &m_macTXNvars->fTXNFrame, (TXNObjectRefcon) m_macTXNvars));
m_txn = m_macTXNvars->fTXNRec ;
-
+
/* perform final activations and setup for our text field. Here,
we assume that the window is going to be the 'active' window. */
TPActivatePaneText(m_macTXNvars, m_macTXNvars->fIsActive && m_macTXNvars->fInFocus);
return err;
}
-//
-// HACKHACK: (RN)
-// Classic controls are not initially focused and
-// smaller ones are focused badly with the focus rect
-// this "fixes" the above issue - but there is probably a
-// a better way.
-//
-// Still, on smaller text controls the focus rect is off
-//
-
-bool wxMacMLTEClassicControl::NeedsFocusRect() const
-{
- return m_windowStyle & wxNO_BORDER ? false : true;
-}
-
// ----------------------------------------------------------------------------
// MLTE control implementation (OSX part)
// ----------------------------------------------------------------------------
wxMacMLTEHIViewControl::wxMacMLTEHIViewControl( wxWindow *wxPeer,
const wxString& str,
const wxPoint& pos,
- const wxSize& size, long style )
+ const wxSize& size, long style )
{
m_font = wxPeer->GetFont() ;
m_windowStyle = style ;
- Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
+ Rect bounds = wxMacGetBoundsForControl( wxPeer , pos , size ) ;
wxString st = str ;
wxMacConvertNewlines10To13( &st ) ;
-
+
HIRect hr = { bounds.left , bounds.top , bounds.right - bounds.left , bounds.bottom- bounds.top } ;
m_scrollView = NULL ;
TXNFrameOptions frameOptions = FrameOptionsFromWXStyle( style ) ;
if ( frameOptions & (kTXNWantVScrollBarMask|kTXNWantHScrollBarMask) )
{
- HIScrollViewCreate(( frameOptions & kTXNWantHScrollBarMask ? kHIScrollViewOptionsHorizScroll : 0) |
+ HIScrollViewCreate(( frameOptions & kTXNWantHScrollBarMask ? kHIScrollViewOptionsHorizScroll : 0) |
( frameOptions & kTXNWantVScrollBarMask ? kHIScrollViewOptionsVertScroll: 0 ) , &m_scrollView ) ;
-
- HIViewSetFrame( m_scrollView, &hr );
- HIViewSetVisible( m_scrollView, true );
+
+ HIViewSetFrame( m_scrollView, &hr );
+ HIViewSetVisible( m_scrollView, true );
}
-
+
m_textView = NULL ;
HITextViewCreate( NULL , 0, frameOptions , &m_textView ) ;
m_txn = HITextViewGetTXNObject( m_textView) ;
}
else
{
- HIViewSetFrame( m_textView, &hr );
+ HIViewSetFrame( m_textView, &hr );
m_controlRef = m_textView ;
}
-
-
+
SetTXNData( st , kTXNStartOffset, kTXNEndOffset ) ;
TXNSetSelection( m_txn, 0, 0);
AdjustCreationAttributes( *wxWHITE , true ) ;
}
-OSStatus wxMacMLTEHIViewControl::SetFocus( ControlFocusPart focusPart )
+OSStatus wxMacMLTEHIViewControl::SetFocus( ControlFocusPart focusPart )
{
- return SetKeyboardFocus( GetControlOwner( m_textView ) ,
+ return SetKeyboardFocus( GetControlOwner( m_textView ) ,
m_textView , focusPart ) ;
}
-bool wxMacMLTEHIViewControl::HasFocus() const
+bool wxMacMLTEHIViewControl::HasFocus() const
{
ControlRef control ;
GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
return control == m_textView ;
}
-bool wxMacMLTEHIViewControl::NeedsFocusRect() const
+bool wxMacMLTEHIViewControl::NeedsFocusRect() const
{
return m_windowStyle & wxNO_BORDER ? false : true;
}
projects / wxWidgets.git / blobdiff