src/mac/carbon/textctrl.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        textctrl.cpp
// Purpose:     wxTextCtrl
// Author:      AUTHOR
// Modified by:
// Created:     ??/??/98
// RCS-ID:      $Id$
// Copyright:   (c) AUTHOR
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "textctrl.h"
#endif

#ifdef __DARWIN__
  #include <sys/types.h>
  #include <sys/stat.h>
#else
  #include <stat.h>
#endif
#include <fstream.h>

#include "wx/app.h"
#include "wx/dc.h"
#include "wx/button.h"
#include "wx/panel.h"
#include "wx/textctrl.h"
#include "wx/notebook.h"
#include "wx/tabctrl.h"
#include "wx/settings.h"
#include "wx/filefn.h"
#include "wx/utils.h"

#if defined(__BORLANDC__) && !defined(__WIN32__)
  #include <alloc.h>
#elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
  #include <malloc.h>
#endif

#include "wx/mac/uma.h"

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)

BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
	EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
	EVT_CHAR(wxTextCtrl::OnChar)
    EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
    EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
    EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
    EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
    EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)

    EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
    EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
    EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
    EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
    EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
END_EVENT_TABLE()
#endif

// Text item
wxTextCtrl::wxTextCtrl()
{
}

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

bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
		   const wxString& st,
           const wxPoint& pos,
           const wxSize& size, long style,
           const wxValidator& validator,
           const wxString& name)
{
    // base initialization
    if ( !CreateBase(parent, id, pos, size, style, validator, name) )
        return FALSE;

	wxSize mySize = size ;
	if ( UMAHasAppearance() )
	{
		m_macHorizontalBorder = 5 ; // additional pixels around the real control
		m_macVerticalBorder = 5 ;
	}
	else
	{
		m_macHorizontalBorder = 0 ; // additional pixels around the real control
		m_macVerticalBorder = 0 ;
	}


	Rect bounds ;
	Str255 title ;

	if ( mySize.y == -1 )
	{
		if ( UMAHasAppearance() )
			mySize.y = 13 ;
		else
			mySize.y = 24 ;

		mySize.y += 2 * m_macVerticalBorder ;
	}

	MacPreControlCreate( parent , id ,  "" , pos , mySize ,style, validator , name , &bounds , title ) ;

    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)") );

        m_windowStyle |= wxTE_PROCESS_ENTER;
    }


	m_macControl = UMANewControl( parent->GetMacRootWindow() , &bounds , "\p" , true , 0 , 0 , 1,
	  	( style & wxTE_PASSWORD ) ? kControlEditTextPasswordProc : kControlEditTextProc , (long) this ) ;
	MacPostControlCreate() ;

	wxString value ;

	{
 		TEHandle teH ;
   		long size ;

   		UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
		(*teH)->lineHeight = -1 ;
	}

	if( wxApp::s_macDefaultEncodingIsPC )
		value = wxMacMakeMacStringFromPC( st ) ;
	else
		value = st ;
	UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;

  return TRUE;
}

wxString wxTextCtrl::GetValue() const
{
	Size actualsize;
	UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
	wxBuffer[actualsize] = 0 ;
	if( wxApp::s_macDefaultEncodingIsPC )
		return wxMacMakePCStringFromMac( wxBuffer ) ;
	else
    	return wxString(wxBuffer);
}

void wxTextCtrl::GetSelection(long* from, long* to) const
{
   ControlEditTextSelectionRec selection ;
   TEHandle teH ;
   long size ;

   UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;

    *from = (**teH).selStart;
    *to = (**teH).selEnd;
}

void wxTextCtrl::SetValue(const wxString& st)
{
	wxString value ;

	if( wxApp::s_macDefaultEncodingIsPC )
		value = wxMacMakeMacStringFromPC( st ) ;
	else
		value = st ;
	UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char*) ((const char*)value) ) ;
	WindowRef window = GetMacRootWindow() ;
	if ( window )
	{
		wxWindow* win = wxFindWinFromMacWindow( window ) ;
		if ( win )
		{
			wxMacDrawingHelper help( win ) ;
			// the mac control manager always assumes to have the origin at 0,0
			SetOrigin( 0 , 0 ) ;

			bool			hasTabBehind = false ;
			wxWindow* parent = GetParent() ;
			while ( parent )
			{
				if( parent->MacGetWindowData() )
				{
					UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , kThemeBrushDialogBackgroundActive , false ) ;
					break ;
				}

				if( parent->IsKindOf( CLASSINFO( wxNotebook ) ) ||  parent->IsKindOf( CLASSINFO( wxTabCtrl ) ))
				{
					if ( ((wxControl*)parent)->GetMacControl() )
						SetUpControlBackground( ((wxControl*)parent)->GetMacControl() , -1 , true ) ;
					break ;
				}

				parent = parent->GetParent() ;
			}

			UMADrawControl( m_macControl ) ;
			UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , win->MacGetWindowData()->m_macWindowBackgroundTheme , false ) ;
		}
	}
}

// Clipboard operations
void wxTextCtrl::Copy()
{
    if (CanCopy())
    {
   		TEHandle teH ;
   		long size ;

  		 UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
		TECopy( teH ) ;
#if TARGET_CARBON
		OSStatus err ;
		err = ClearCurrentScrap( );
#else
		OSErr err ;
		err = ZeroScrap( );
#endif
		TEToScrap() ;
	}
}

void wxTextCtrl::Cut()
{
    if (CanCut())
    {
   		TEHandle teH ;
   		long size ;

   		UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
		TECut( teH ) ;
#if TARGET_CARBON
		OSStatus err ;
		err = ClearCurrentScrap( );
#else
		OSErr err ;
		err = ZeroScrap( );
#endif
		TEToScrap() ;
		//	MacInvalidateControl() ;
	}
}

void wxTextCtrl::Paste()
{
    if (CanPaste())
    {
   		TEHandle teH ;
   		long size ;

   		UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
		TEFromScrap() ;
		TEPaste( teH ) ;
		WindowRef window = GetMacRootWindow() ;
		if ( window )
		{
			wxWindow* win = wxFindWinFromMacWindow( window ) ;
			if ( win )
			{
				wxMacDrawingHelper help( win ) ;
				// the mac control manager always assumes to have the origin at 0,0
				SetOrigin( 0 , 0 ) ;

				bool			hasTabBehind = false ;
				wxWindow* parent = GetParent() ;
				while ( parent )
				{
					if( parent->MacGetWindowData() )
					{
						UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , kThemeBrushDialogBackgroundActive , false ) ;
						break ;
					}

					if( parent->IsKindOf( CLASSINFO( wxNotebook ) ) ||  parent->IsKindOf( CLASSINFO( wxTabCtrl ) ))
					{
						if ( ((wxControl*)parent)->GetMacControl() )
							SetUpControlBackground( ((wxControl*)parent)->GetMacControl() , -1 , true ) ;
						break ;
					}

					parent = parent->GetParent() ;
				}

				UMADrawControl( m_macControl ) ;
				UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , win->MacGetWindowData()->m_macWindowBackgroundTheme , false ) ;
			}
		}
	}
}

bool wxTextCtrl::CanCopy() const
{
    // Can copy if there's a selection
    long from, to;
    GetSelection(& from, & to);
    return (from != to);
}

bool wxTextCtrl::CanCut() const
{
    // Can cut if there's a selection
    long from, to;
    GetSelection(& from, & to);
    return (from != to);
}

bool wxTextCtrl::CanPaste() const
{
    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;

#else
	if ( GetScrap( NULL , 'TEXT' , &offset ) > 0 )
	{
		return TRUE ;
	}
#endif
	return FALSE ;
}

void wxTextCtrl::SetEditable(bool editable)
{
    if ( editable )
    	UMAActivateControl( m_macControl ) ;
    else
    	UMADeactivateControl( m_macControl ) ;
}

void wxTextCtrl::SetInsertionPoint(long pos)
{
	SetSelection( pos , pos ) ;
}

void wxTextCtrl::SetInsertionPointEnd()
{
    long pos = GetLastPosition();
    SetInsertionPoint(pos);
}

long wxTextCtrl::GetInsertionPoint() const
{
   ControlEditTextSelectionRec selection ;
   TEHandle teH ;
   long size ;

   UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
//   UMAGetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection , &size ) ;
    return (**teH).selStart ;
}

long wxTextCtrl::GetLastPosition() const
{
   ControlEditTextSelectionRec selection ;
   TEHandle teH ;
   long size ;

   UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;

//   UMAGetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection , &size ) ;
    return (**teH).teLength ;
}

void wxTextCtrl::Replace(long from, long to, const wxString& value)
{
   	TEHandle teH ;
   	long size ;

   	ControlEditTextSelectionRec selection ;

   	selection.selStart = from ;
   	selection.selEnd = to ;
   	UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
		UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
   	TESetSelect( from , to  , teH ) ;
   	TEDelete( teH ) ;
		TEInsert( value , value.Length() , teH ) ;
	Refresh() ;
}

void wxTextCtrl::Remove(long from, long to)
{
   	TEHandle teH ;
   	long size ;

   	ControlEditTextSelectionRec selection ;

   	selection.selStart = from ;
   	selection.selEnd = to ;
   	UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
   	TEDelete( teH ) ;
	Refresh() ;
}

void wxTextCtrl::SetSelection(long from, long to)
{
   ControlEditTextSelectionRec selection ;
   TEHandle teH ;
   long size ;

   UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;

   selection.selStart = from ;
   selection.selEnd = to ;

   UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
   TESetSelect( selection.selStart , selection.selEnd , teH ) ;
}

bool wxTextCtrl::LoadFile(const wxString& file)
{
    if ( wxTextCtrlBase::LoadFile(file) )
    {
        return TRUE;
    }

    return FALSE;
}

void wxTextCtrl::WriteText(const wxString& text)
{
    TEHandle teH ;
    long size ;

   	memcpy( wxBuffer, text , text.Length() ) ;
   	wxBuffer[text.Length() ] = 0 ;
//    wxMacConvertNewlines( wxBuffer , wxBuffer ) ;

    UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;

		TEInsert( wxBuffer , strlen( wxBuffer) , teH ) ;
		Refresh() ;
}

void wxTextCtrl::AppendText(const wxString& text)
{
    SetInsertionPointEnd();
    WriteText(text);
}

void wxTextCtrl::Clear()
{
	UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char*) ((const char*)NULL) ) ;
	Refresh() ;
}

bool wxTextCtrl::IsModified() const
{
    return TRUE;
}

bool wxTextCtrl::IsEditable() const
{
    return IsEnabled();
}

bool wxTextCtrl::AcceptsFocus() const
{
    // we don't want focus if we can't be edited
    return IsEditable() && wxControl::AcceptsFocus();
}

wxSize wxTextCtrl::DoGetBestSize() const
{
    int wText = 100 ;

    int hText ;
		if ( UMAHasAppearance() )
			hText = 13 ;
		else
			hText = 24 ;
	hText += 2 * m_macHorizontalBorder ;
/*
    int cx, cy;
    wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());

    int wText = DEFAULT_ITEM_WIDTH;

    int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);

    return wxSize(wText, hText);
*/
    if ( m_windowStyle & wxTE_MULTILINE )
    {
        hText *= wxMin(GetNumberOfLines(), 5);
    }
    //else: for single line control everything is ok
    return wxSize(wText, hText);
}

// ----------------------------------------------------------------------------
// Undo/redo
// ----------------------------------------------------------------------------

void wxTextCtrl::Undo()
{
    if (CanUndo())
    {
    }
}

void wxTextCtrl::Redo()
{
    if (CanRedo())
    {
    }
}

bool wxTextCtrl::CanUndo() const
{
    return FALSE ;
}

bool wxTextCtrl::CanRedo() const
{
    return FALSE ;
}

// Makes 'unmodified'
void wxTextCtrl::DiscardEdits()
{
    // TODO
}

int wxTextCtrl::GetNumberOfLines() const
{
	Size actualsize;
	UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;

	int count = 1;
	for (int i = 0; i < actualsize; i++)
	{
	    if (wxBuffer[i] == '\r') count++;
	}

    return count;
}

long wxTextCtrl::XYToPosition(long x, long y) const
{
    // TODO
    return 0;
}

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

void wxTextCtrl::ShowPosition(long pos)
{
    // TODO
}

int wxTextCtrl::GetLineLength(long lineNo) const
{
	Size actualsize;
	UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;

	// Find line first
	int count = 0;
	for (int i = 0; i < actualsize; i++)
	{
	    if (count == lineNo)
	    {
	        // Count chars in line then
	    	count = 0;
	    	for (int j = i; j < actualsize; j++)
	    	{
	    	    count++;
	    	    if (wxBuffer[j] == '\r') return count;
	    	}

	    	return count;
	    }
	    if (wxBuffer[i] == '\r') count++;
	}

    return 0;
}

wxString wxTextCtrl::GetLineText(long lineNo) const
{
	Size actualsize;
	UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;

	// Find line first
	int count = 0;
	for (int i = 0; i < actualsize; i++)
	{
	    if (count == lineNo)
	    {
	        // Add chars in line then
	    	wxString tmp("");

	    	for (int j = i; j < actualsize; j++)
	    	{
	    	    if (wxBuffer[j] == '\r')
	    	        return tmp;

	    	    tmp += wxBuffer[j];
	    	}

	    	return tmp;
	    }
	    if (wxBuffer[i] == '\r') count++;
	}

    return wxString("");
}

/*
 * Text item
 */

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

void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
{
    // By default, load the first file into the text window.
    if (event.GetNumberOfFiles() > 0)
    {
        LoadFile(event.GetFiles()[0]);
    }
}

void wxTextCtrl::OnChar(wxKeyEvent& event)
{
    switch ( event.KeyCode() )
    {
        case WXK_RETURN:
        	if (m_windowStyle & wxPROCESS_ENTER)
        	{
                wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
                event.SetEventObject( this );
                if ( GetEventHandler()->ProcessEvent(event) )
                    return;
        	}
            if ( !(m_windowStyle & wxTE_MULTILINE) )
            {
    			wxWindow *parent = GetParent();
    			wxPanel *panel = wxDynamicCast(parent, wxPanel);
    			while ( parent != NULL && panel == NULL )
    			{
    				parent = parent->GetParent() ;
    				panel = wxDynamicCast(parent, wxPanel);
    			}
           		if ( panel && panel->GetDefaultItem() )
           		{
           			wxButton *def = panel->GetDefaultItem() ;
    				wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
   					event.SetEventObject(def);
   					def->Command(event);
               		event.Skip() ;
                	return ;
           		}
            }
            //else: multiline controls need Enter for themselves

            break;

        case WXK_TAB:
            // always produce navigation event - even if we process TAB
            // ourselves the fact that we got here means that the user code
            // decided to skip processing of this TAB - probably to let it
            // do its default job.
            {
                wxNavigationKeyEvent eventNav;
                eventNav.SetDirection(!event.ShiftDown());
                eventNav.SetWindowChange(event.ControlDown());
                eventNav.SetEventObject(this);

                if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
                    return;
               	event.Skip() ;
                return ;
            }
            break;
    }

	EventRecord *ev = wxTheApp->MacGetCurrentEvent() ;
	short keycode ;
	short keychar ;
	keychar = short(ev->message & charCodeMask);
	keycode = short(ev->message & keyCodeMask) >> 8 ;
	UMAHandleControlKey( m_macControl , keycode , keychar , ev->modifiers ) ;
	if ( keychar >= 0x20 || event.KeyCode() == WXK_RETURN || event.KeyCode() == WXK_DELETE || event.KeyCode() == WXK_BACK)
	{
        wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
        event.SetString( GetValue() ) ;
        event.SetEventObject( this );
        GetEventHandler()->ProcessEvent(event);
	}

}

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

void wxTextCtrl::OnCut(wxCommandEvent& event)
{
    Cut();
}

void wxTextCtrl::OnCopy(wxCommandEvent& event)
{
    Copy();
}

void wxTextCtrl::OnPaste(wxCommandEvent& event)
{
    Paste();
}

void wxTextCtrl::OnUndo(wxCommandEvent& event)
{
    Undo();
}

void wxTextCtrl::OnRedo(wxCommandEvent& event)
{
    Redo();
}

void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
{
    event.Enable( CanCut() );
}

void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
{
    event.Enable( CanCopy() );
}

void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
{
    event.Enable( CanPaste() );
}

void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
{
    event.Enable( CanUndo() );
}

void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
{
    event.Enable( CanRedo() );
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: textctrl.cpp
	3	// Purpose: wxTextCtrl
	4	// Author: AUTHOR
	5	// Modified by:
	6	// Created: ??/??/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) AUTHOR
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "textctrl.h"
	14	#endif
	15
	16	#ifdef __DARWIN__
	17	#include <sys/types.h>
	18	#include <sys/stat.h>
	19	#else
	20	#include <stat.h>
	21	#endif
	22	#include <fstream.h>
	23
	24	#include "wx/app.h"
	25	#include "wx/dc.h"
	26	#include "wx/button.h"
	27	#include "wx/panel.h"
	28	#include "wx/textctrl.h"
	29	#include "wx/notebook.h"
	30	#include "wx/tabctrl.h"
	31	#include "wx/settings.h"
	32	#include "wx/filefn.h"
	33	#include "wx/utils.h"
	34
	35	#if defined(__BORLANDC__) && !defined(__WIN32__)
	36	#include <alloc.h>
	37	#elif !defined(__MWERKS__) && !defined(__GNUWIN32) && !defined(__DARWIN__)
	38	#include <malloc.h>
	39	#endif
	40
	41	#include "wx/mac/uma.h"
	42
	43	#if !USE_SHARED_LIBRARY
	44	IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
	45
	46	BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
	47	EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
	48	EVT_CHAR(wxTextCtrl::OnChar)
	49	EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
	50	EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
	51	EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
	52	EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
	53	EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
	54
	55	EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
	56	EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
	57	EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
	58	EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
	59	EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
	60	END_EVENT_TABLE()
	61	#endif
	62
	63	// Text item
	64	wxTextCtrl::wxTextCtrl()
	65	{
	66	}
	67
	68	const short kVerticalMargin = 2 ;
	69	const short kHorizontalMargin = 2 ;
	70
	71	bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
	72	const wxString& st,
	73	const wxPoint& pos,
	74	const wxSize& size, long style,
	75	const wxValidator& validator,
	76	const wxString& name)
	77	{
	78	// base initialization
	79	if ( !CreateBase(parent, id, pos, size, style, validator, name) )
	80	return FALSE;
	81
	82	wxSize mySize = size ;
	83	if ( UMAHasAppearance() )
	84	{
	85	m_macHorizontalBorder = 5 ; // additional pixels around the real control
	86	m_macVerticalBorder = 5 ;
	87	}
	88	else
	89	{
	90	m_macHorizontalBorder = 0 ; // additional pixels around the real control
	91	m_macVerticalBorder = 0 ;
	92	}
	93
	94
	95	Rect bounds ;
	96	Str255 title ;
	97
	98	if ( mySize.y == -1 )
	99	{
	100	if ( UMAHasAppearance() )
	101	mySize.y = 13 ;
	102	else
	103	mySize.y = 24 ;
	104
	105	mySize.y += 2 * m_macVerticalBorder ;
	106	}
	107
	108	MacPreControlCreate( parent , id , "" , pos , mySize ,style, validator , name , &bounds , title ) ;
	109
	110	if ( m_windowStyle & wxTE_MULTILINE )
	111	{
	112	wxASSERT_MSG( !(m_windowStyle & wxTE_PROCESS_ENTER),
	113	wxT("wxTE_PROCESS_ENTER style is ignored for multiline text controls (they always process it)") );
	114
	115	m_windowStyle \|= wxTE_PROCESS_ENTER;
	116	}
	117
	118
	119	m_macControl = UMANewControl( parent->GetMacRootWindow() , &bounds , "\p" , true , 0 , 0 , 1,
	120	( style & wxTE_PASSWORD ) ? kControlEditTextPasswordProc : kControlEditTextProc , (long) this ) ;
	121	MacPostControlCreate() ;
	122
	123	wxString value ;
	124
	125	{
	126	TEHandle teH ;
	127	long size ;
	128
	129	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	130	(*teH)->lineHeight = -1 ;
	131	}
	132
	133	if( wxApp::s_macDefaultEncodingIsPC )
	134	value = wxMacMakeMacStringFromPC( st ) ;
	135	else
	136	value = st ;
	137	UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char) ((const char)value) ) ;
	138
	139	return TRUE;
	140	}
	141
	142	wxString wxTextCtrl::GetValue() const
	143	{
	144	Size actualsize;
	145	UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
	146	wxBuffer[actualsize] = 0 ;
	147	if( wxApp::s_macDefaultEncodingIsPC )
	148	return wxMacMakePCStringFromMac( wxBuffer ) ;
	149	else
	150	return wxString(wxBuffer);
	151	}
	152
	153	void wxTextCtrl::GetSelection(long* from, long* to) const
	154	{
	155	ControlEditTextSelectionRec selection ;
	156	TEHandle teH ;
	157	long size ;
	158
	159	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	160
	161	from = (*teH).selStart;
	162	to = (*teH).selEnd;
	163	}
	164
	165	void wxTextCtrl::SetValue(const wxString& st)
	166	{
	167	wxString value ;
	168
	169	if( wxApp::s_macDefaultEncodingIsPC )
	170	value = wxMacMakeMacStringFromPC( st ) ;
	171	else
	172	value = st ;
	173	UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , value.Length() , (char) ((const char)value) ) ;
	174	WindowRef window = GetMacRootWindow() ;
	175	if ( window )
	176	{
	177	wxWindow* win = wxFindWinFromMacWindow( window ) ;
	178	if ( win )
	179	{
	180	wxMacDrawingHelper help( win ) ;
	181	// the mac control manager always assumes to have the origin at 0,0
	182	SetOrigin( 0 , 0 ) ;
	183
	184	bool hasTabBehind = false ;
	185	wxWindow* parent = GetParent() ;
	186	while ( parent )
	187	{
	188	if( parent->MacGetWindowData() )
	189	{
	190	UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , kThemeBrushDialogBackgroundActive , false ) ;
	191	break ;
	192	}
	193
	194	if( parent->IsKindOf( CLASSINFO( wxNotebook ) ) \|\| parent->IsKindOf( CLASSINFO( wxTabCtrl ) ))
	195	{
	196	if ( ((wxControl*)parent)->GetMacControl() )
	197	SetUpControlBackground( ((wxControl*)parent)->GetMacControl() , -1 , true ) ;
	198	break ;
	199	}
	200
	201	parent = parent->GetParent() ;
	202	}
	203
	204	UMADrawControl( m_macControl ) ;
	205	UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , win->MacGetWindowData()->m_macWindowBackgroundTheme , false ) ;
	206	}
	207	}
	208	}
	209
	210	// Clipboard operations
	211	void wxTextCtrl::Copy()
	212	{
	213	if (CanCopy())
	214	{
	215	TEHandle teH ;
	216	long size ;
	217
	218	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	219	TECopy( teH ) ;
	220	#if TARGET_CARBON
	221	OSStatus err ;
	222	err = ClearCurrentScrap( );
	223	#else
	224	OSErr err ;
	225	err = ZeroScrap( );
	226	#endif
	227	TEToScrap() ;
	228	}
	229	}
	230
	231	void wxTextCtrl::Cut()
	232	{
	233	if (CanCut())
	234	{
	235	TEHandle teH ;
	236	long size ;
	237
	238	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	239	TECut( teH ) ;
	240	#if TARGET_CARBON
	241	OSStatus err ;
	242	err = ClearCurrentScrap( );
	243	#else
	244	OSErr err ;
	245	err = ZeroScrap( );
	246	#endif
	247	TEToScrap() ;
	248	// MacInvalidateControl() ;
	249	}
	250	}
	251
	252	void wxTextCtrl::Paste()
	253	{
	254	if (CanPaste())
	255	{
	256	TEHandle teH ;
	257	long size ;
	258
	259	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	260	TEFromScrap() ;
	261	TEPaste( teH ) ;
	262	WindowRef window = GetMacRootWindow() ;
	263	if ( window )
	264	{
	265	wxWindow* win = wxFindWinFromMacWindow( window ) ;
	266	if ( win )
	267	{
	268	wxMacDrawingHelper help( win ) ;
	269	// the mac control manager always assumes to have the origin at 0,0
	270	SetOrigin( 0 , 0 ) ;
	271
	272	bool hasTabBehind = false ;
	273	wxWindow* parent = GetParent() ;
	274	while ( parent )
	275	{
	276	if( parent->MacGetWindowData() )
	277	{
	278	UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , kThemeBrushDialogBackgroundActive , false ) ;
	279	break ;
	280	}
	281
	282	if( parent->IsKindOf( CLASSINFO( wxNotebook ) ) \|\| parent->IsKindOf( CLASSINFO( wxTabCtrl ) ))
	283	{
	284	if ( ((wxControl*)parent)->GetMacControl() )
	285	SetUpControlBackground( ((wxControl*)parent)->GetMacControl() , -1 , true ) ;
	286	break ;
	287	}
	288
	289	parent = parent->GetParent() ;
	290	}
	291
	292	UMADrawControl( m_macControl ) ;
	293	UMASetThemeWindowBackground( win->MacGetWindowData()->m_macWindow , win->MacGetWindowData()->m_macWindowBackgroundTheme , false ) ;
	294	}
	295	}
	296	}
	297	}
	298
	299	bool wxTextCtrl::CanCopy() const
	300	{
	301	// Can copy if there's a selection
	302	long from, to;
	303	GetSelection(& from, & to);
	304	return (from != to);
	305	}
	306
	307	bool wxTextCtrl::CanCut() const
	308	{
	309	// Can cut if there's a selection
	310	long from, to;
	311	GetSelection(& from, & to);
	312	return (from != to);
	313	}
	314
	315	bool wxTextCtrl::CanPaste() const
	316	{
	317	if (!IsEditable())
	318	return FALSE;
	319
	320	long offset ;
	321	#if TARGET_CARBON
	322	OSStatus err = noErr;
	323	ScrapRef scrapRef;
	324
	325	err = GetCurrentScrap( &scrapRef );
	326	if ( err != noTypeErr && err != memFullErr )
	327	{
	328	ScrapFlavorFlags flavorFlags;
	329	Size byteCount;
	330
	331	if (( err = GetScrapFlavorFlags( scrapRef, 'TEXT', &flavorFlags )) == noErr)
	332	{
	333	if (( err = GetScrapFlavorSize( scrapRef, 'TEXT', &byteCount )) == noErr)
	334	{
	335	return TRUE ;
	336	}
	337	}
	338	}
	339	return FALSE;
	340
	341	#else
	342	if ( GetScrap( NULL , 'TEXT' , &offset ) > 0 )
	343	{
	344	return TRUE ;
	345	}
	346	#endif
	347	return FALSE ;
	348	}
	349
	350	void wxTextCtrl::SetEditable(bool editable)
	351	{
	352	if ( editable )
	353	UMAActivateControl( m_macControl ) ;
	354	else
	355	UMADeactivateControl( m_macControl ) ;
	356	}
	357
	358	void wxTextCtrl::SetInsertionPoint(long pos)
	359	{
	360	SetSelection( pos , pos ) ;
	361	}
	362
	363	void wxTextCtrl::SetInsertionPointEnd()
	364	{
	365	long pos = GetLastPosition();
	366	SetInsertionPoint(pos);
	367	}
	368
	369	long wxTextCtrl::GetInsertionPoint() const
	370	{
	371	ControlEditTextSelectionRec selection ;
	372	TEHandle teH ;
	373	long size ;
	374
	375	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	376	// UMAGetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection , &size ) ;
	377	return (**teH).selStart ;
	378	}
	379
	380	long wxTextCtrl::GetLastPosition() const
	381	{
	382	ControlEditTextSelectionRec selection ;
	383	TEHandle teH ;
	384	long size ;
	385
	386	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	387
	388	// UMAGetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection , &size ) ;
	389	return (**teH).teLength ;
	390	}
	391
	392	void wxTextCtrl::Replace(long from, long to, const wxString& value)
	393	{
	394	TEHandle teH ;
	395	long size ;
	396
	397	ControlEditTextSelectionRec selection ;
	398
	399	selection.selStart = from ;
	400	selection.selEnd = to ;
	401	UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
	402	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	403	TESetSelect( from , to , teH ) ;
	404	TEDelete( teH ) ;
	405	TEInsert( value , value.Length() , teH ) ;
	406	Refresh() ;
	407	}
	408
	409	void wxTextCtrl::Remove(long from, long to)
	410	{
	411	TEHandle teH ;
	412	long size ;
	413
	414	ControlEditTextSelectionRec selection ;
	415
	416	selection.selStart = from ;
	417	selection.selEnd = to ;
	418	UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
	419	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	420	TEDelete( teH ) ;
	421	Refresh() ;
	422	}
	423
	424	void wxTextCtrl::SetSelection(long from, long to)
	425	{
	426	ControlEditTextSelectionRec selection ;
	427	TEHandle teH ;
	428	long size ;
	429
	430	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	431
	432	selection.selStart = from ;
	433	selection.selEnd = to ;
	434
	435	UMASetControlData( m_macControl , 0, kControlEditTextSelectionTag , sizeof( selection ) , (char*) &selection ) ;
	436	TESetSelect( selection.selStart , selection.selEnd , teH ) ;
	437	}
	438
	439	bool wxTextCtrl::LoadFile(const wxString& file)
	440	{
	441	if ( wxTextCtrlBase::LoadFile(file) )
	442	{
	443	return TRUE;
	444	}
	445
	446	return FALSE;
	447	}
	448
	449	void wxTextCtrl::WriteText(const wxString& text)
	450	{
	451	TEHandle teH ;
	452	long size ;
	453
	454	memcpy( wxBuffer, text , text.Length() ) ;
	455	wxBuffer[text.Length() ] = 0 ;
	456	// wxMacConvertNewlines( wxBuffer , wxBuffer ) ;
	457
	458	UMAGetControlData( m_macControl , 0, kControlEditTextTEHandleTag , sizeof( TEHandle ) , (char*) &teH , &size ) ;
	459
	460	TEInsert( wxBuffer , strlen( wxBuffer) , teH ) ;
	461	Refresh() ;
	462	}
	463
	464	void wxTextCtrl::AppendText(const wxString& text)
	465	{
	466	SetInsertionPointEnd();
	467	WriteText(text);
	468	}
	469
	470	void wxTextCtrl::Clear()
	471	{
	472	UMASetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 0 , (char) ((const char)NULL) ) ;
	473	Refresh() ;
	474	}
	475
	476	bool wxTextCtrl::IsModified() const
	477	{
	478	return TRUE;
	479	}
	480
	481	bool wxTextCtrl::IsEditable() const
	482	{
	483	return IsEnabled();
	484	}
	485
	486	bool wxTextCtrl::AcceptsFocus() const
	487	{
	488	// we don't want focus if we can't be edited
	489	return IsEditable() && wxControl::AcceptsFocus();
	490	}
	491
	492	wxSize wxTextCtrl::DoGetBestSize() const
	493	{
	494	int wText = 100 ;
	495
	496	int hText ;
	497	if ( UMAHasAppearance() )
	498	hText = 13 ;
	499	else
	500	hText = 24 ;
	501	hText += 2 * m_macHorizontalBorder ;
	502	/*
	503	int cx, cy;
	504	wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
	505
	506	int wText = DEFAULT_ITEM_WIDTH;
	507
	508	int hText = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
	509
	510	return wxSize(wText, hText);
	511	*/
	512	if ( m_windowStyle & wxTE_MULTILINE )
	513	{
	514	hText *= wxMin(GetNumberOfLines(), 5);
	515	}
	516	//else: for single line control everything is ok
	517	return wxSize(wText, hText);
	518	}
	519
	520	// ----------------------------------------------------------------------------
	521	// Undo/redo
	522	// ----------------------------------------------------------------------------
	523
	524	void wxTextCtrl::Undo()
	525	{
	526	if (CanUndo())
	527	{
	528	}
	529	}
	530
	531	void wxTextCtrl::Redo()
	532	{
	533	if (CanRedo())
	534	{
	535	}
	536	}
	537
	538	bool wxTextCtrl::CanUndo() const
	539	{
	540	return FALSE ;
	541	}
	542
	543	bool wxTextCtrl::CanRedo() const
	544	{
	545	return FALSE ;
	546	}
	547
	548	// Makes 'unmodified'
	549	void wxTextCtrl::DiscardEdits()
	550	{
	551	// TODO
	552	}
	553
	554	int wxTextCtrl::GetNumberOfLines() const
	555	{
	556	Size actualsize;
	557	UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
	558
	559	int count = 1;
	560	for (int i = 0; i < actualsize; i++)
	561	{
	562	if (wxBuffer[i] == '\r') count++;
	563	}
	564
	565	return count;
	566	}
	567
	568	long wxTextCtrl::XYToPosition(long x, long y) const
	569	{
	570	// TODO
	571	return 0;
	572	}
	573
	574	bool wxTextCtrl::PositionToXY(long pos, long x, long y) const
	575	{
	576	return FALSE ;
	577	}
	578
	579	void wxTextCtrl::ShowPosition(long pos)
	580	{
	581	// TODO
	582	}
	583
	584	int wxTextCtrl::GetLineLength(long lineNo) const
	585	{
	586	Size actualsize;
	587	UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
	588
	589	// Find line first
	590	int count = 0;
	591	for (int i = 0; i < actualsize; i++)
	592	{
	593	if (count == lineNo)
	594	{
	595	// Count chars in line then
	596	count = 0;
	597	for (int j = i; j < actualsize; j++)
	598	{
	599	count++;
	600	if (wxBuffer[j] == '\r') return count;
	601	}
	602
	603	return count;
	604	}
	605	if (wxBuffer[i] == '\r') count++;
	606	}
	607
	608	return 0;
	609	}
	610
	611	wxString wxTextCtrl::GetLineText(long lineNo) const
	612	{
	613	Size actualsize;
	614	UMAGetControlData( m_macControl, 0, ( m_windowStyle & wxTE_PASSWORD ) ? kControlEditTextPasswordTag : kControlEditTextTextTag , 32767 , wxBuffer , &actualsize) ;
	615
	616	// Find line first
	617	int count = 0;
	618	for (int i = 0; i < actualsize; i++)
	619	{
	620	if (count == lineNo)
	621	{
	622	// Add chars in line then
	623	wxString tmp("");
	624
	625	for (int j = i; j < actualsize; j++)
	626	{
	627	if (wxBuffer[j] == '\r')
	628	return tmp;
	629
	630	tmp += wxBuffer[j];
	631	}
	632
	633	return tmp;
	634	}
	635	if (wxBuffer[i] == '\r') count++;
	636	}
	637
	638	return wxString("");
	639	}
	640
	641	/*
	642	* Text item
	643	*/
	644
	645	void wxTextCtrl::Command(wxCommandEvent & event)
	646	{
	647	SetValue (event.GetString());
	648	ProcessCommand (event);
	649	}
	650
	651	void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
	652	{
	653	// By default, load the first file into the text window.
	654	if (event.GetNumberOfFiles() > 0)
	655	{
	656	LoadFile(event.GetFiles()[0]);
	657	}
	658	}
	659
	660	void wxTextCtrl::OnChar(wxKeyEvent& event)
	661	{
	662	switch ( event.KeyCode() )
	663	{
	664	case WXK_RETURN:
	665	if (m_windowStyle & wxPROCESS_ENTER)
	666	{
	667	wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
	668	event.SetEventObject( this );
	669	if ( GetEventHandler()->ProcessEvent(event) )
	670	return;
	671	}
	672	if ( !(m_windowStyle & wxTE_MULTILINE) )
	673	{
	674	wxWindow *parent = GetParent();
	675	wxPanel *panel = wxDynamicCast(parent, wxPanel);
	676	while ( parent != NULL && panel == NULL )
	677	{
	678	parent = parent->GetParent() ;
	679	panel = wxDynamicCast(parent, wxPanel);
	680	}
	681	if ( panel && panel->GetDefaultItem() )
	682	{
	683	wxButton *def = panel->GetDefaultItem() ;
	684	wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
	685	event.SetEventObject(def);
	686	def->Command(event);
	687	event.Skip() ;
	688	return ;
	689	}
	690	}
	691	//else: multiline controls need Enter for themselves
	692
	693	break;
	694
	695	case WXK_TAB:
	696	// always produce navigation event - even if we process TAB
	697	// ourselves the fact that we got here means that the user code
	698	// decided to skip processing of this TAB - probably to let it
	699	// do its default job.
	700	{
	701	wxNavigationKeyEvent eventNav;
	702	eventNav.SetDirection(!event.ShiftDown());
	703	eventNav.SetWindowChange(event.ControlDown());
	704	eventNav.SetEventObject(this);
	705
	706	if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
	707	return;
	708	event.Skip() ;
	709	return ;
	710	}
	711	break;
	712	}
	713
	714	EventRecord *ev = wxTheApp->MacGetCurrentEvent() ;
	715	short keycode ;
	716	short keychar ;
	717	keychar = short(ev->message & charCodeMask);
	718	keycode = short(ev->message & keyCodeMask) >> 8 ;
	719	UMAHandleControlKey( m_macControl , keycode , keychar , ev->modifiers ) ;
	720	if ( keychar >= 0x20 \|\| event.KeyCode() == WXK_RETURN \|\| event.KeyCode() == WXK_DELETE \|\| event.KeyCode() == WXK_BACK)
	721	{
	722	wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
	723	event.SetString( GetValue() ) ;
	724	event.SetEventObject( this );
	725	GetEventHandler()->ProcessEvent(event);
	726	}
	727
	728	}
	729
	730	// ----------------------------------------------------------------------------
	731	// standard handlers for standard edit menu events
	732	// ----------------------------------------------------------------------------
	733
	734	void wxTextCtrl::OnCut(wxCommandEvent& event)
	735	{
	736	Cut();
	737	}
	738
	739	void wxTextCtrl::OnCopy(wxCommandEvent& event)
	740	{
	741	Copy();
	742	}
	743
	744	void wxTextCtrl::OnPaste(wxCommandEvent& event)
	745	{
	746	Paste();
	747	}
	748
	749	void wxTextCtrl::OnUndo(wxCommandEvent& event)
	750	{
	751	Undo();
	752	}
	753
	754	void wxTextCtrl::OnRedo(wxCommandEvent& event)
	755	{
	756	Redo();
	757	}
	758
	759	void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
	760	{
	761	event.Enable( CanCut() );
	762	}
	763
	764	void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
	765	{
	766	event.Enable( CanCopy() );
	767	}
	768
	769	void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
	770	{
	771	event.Enable( CanPaste() );
	772	}
	773
	774	void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
	775	{
	776	event.Enable( CanUndo() );
	777	}
	778
	779	void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
	780	{
	781	event.Enable( CanRedo() );
	782	}
	783