src/osx/textctrl_osx.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/osx/textctrl_osx.cpp
// Purpose:     wxTextCtrl
// Author:      Stefan Csomor
// Modified by: Ryan Norton (MLTE GetLineLength and GetLineText)
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) Stefan Csomor
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#include "wx/wxprec.h"

#if wxUSE_TEXTCTRL

#include "wx/textctrl.h"

#ifndef WX_PRECOMP
    #include "wx/intl.h"
    #include "wx/app.h"
    #include "wx/utils.h"
    #include "wx/dc.h"
    #include "wx/button.h"
    #include "wx/menu.h"
    #include "wx/settings.h"
    #include "wx/msgdlg.h"
    #include "wx/toplevel.h"
#endif

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

#if wxUSE_STD_IOSTREAM
    #if wxUSE_IOSTREAMH
        #include <fstream.h>
    #else
        #include <fstream>
    #endif
#endif

#include "wx/filefn.h"
#include "wx/sysopt.h"
#include "wx/thread.h"

#include "wx/osx/private.h"

BEGIN_EVENT_TABLE(wxTextCtrl, wxTextCtrlBase)
    EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
    EVT_CHAR(wxTextCtrl::OnChar)
    EVT_KEY_DOWN(wxTextCtrl::OnKeyDown)
    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_MENU(wxID_CLEAR, wxTextCtrl::OnDelete)
    EVT_MENU(wxID_SELECTALL, wxTextCtrl::OnSelectAll)

    EVT_CONTEXT_MENU(wxTextCtrl::OnContextMenu)

    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)
    EVT_UPDATE_UI(wxID_CLEAR, wxTextCtrl::OnUpdateDelete)
    EVT_UPDATE_UI(wxID_SELECTALL, wxTextCtrl::OnUpdateSelectAll)
END_EVENT_TABLE()


void wxTextCtrl::Init()
{
    m_dirty = false;

    m_privateContextMenu = NULL;
}

wxTextCtrl::~wxTextCtrl()
{
#if wxUSE_MENUS
    delete m_privateContextMenu;
#endif
}

bool wxTextCtrl::Create( wxWindow *parent,
    wxWindowID id,
    const wxString& str,
    const wxPoint& pos,
    const wxSize& size,
    long style,
    const wxValidator& validator,
    const wxString& name )
{
    DontCreatePeer();
    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;

    if ( m_windowStyle & wxTE_MULTILINE )
    {
        // always turn on this style for multi-line controls
        m_windowStyle |= wxTE_PROCESS_ENTER;
        style |= wxTE_PROCESS_ENTER ;
    }


    SetPeer(wxWidgetImpl::CreateTextControl( this, GetParent(), GetId(), str, pos, size, style, GetExtraStyle() ));

    MacPostControlCreate(pos, size) ;

#if wxOSX_USE_COCOA
    // under carbon everything can already be set before the MacPostControlCreate embedding takes place
    // but under cocoa for single line textfields this only works after everything has been set up
    GetTextPeer()->SetStringValue(str);
#endif

    // only now the embedding is correct and we can do a positioning update

    MacSuperChangedPosition() ;

    if ( m_windowStyle & wxTE_READONLY)
        SetEditable( false ) ;

    SetCursor( wxCursor( wxCURSOR_IBEAM ) ) ;

    return true;
}

void wxTextCtrl::MacSuperChangedPosition()
{
    wxWindow::MacSuperChangedPosition() ;
#if wxOSX_USE_CARBON
    GetPeer()->SuperChangedPosition() ;
#endif
}

void wxTextCtrl::MacVisibilityChanged()
{
#if wxOSX_USE_CARBON
    GetPeer()->VisibilityChanged( GetPeer()->IsVisible() );
#endif
}

void wxTextCtrl::MacCheckSpelling(bool check)
{
    GetTextPeer()->CheckSpelling(check);
}

void wxTextCtrl::SetMaxLength(unsigned long len)
{
    m_maxLength = len ;
}

bool wxTextCtrl::SetFont( const wxFont& font )
{
    if ( !wxTextCtrlBase::SetFont( font ) )
        return false ;

    GetPeer()->SetFont( font , GetForegroundColour() , GetWindowStyle(), false /* dont ignore black */ ) ;

    return true ;
}

bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
{
    if (GetTextPeer())
        GetTextPeer()->SetStyle( start , end , style ) ;

    return true ;
}

bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
{
    wxTextCtrlBase::SetDefaultStyle( style ) ;
    SetStyle( -1  /*current selection*/  , -1 /*current selection*/ , GetDefaultStyle() ) ;

    return true ;
}

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

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

wxSize wxTextCtrl::DoGetBestSize() const
{
    if (GetTextPeer())
    {
        wxSize size = GetTextPeer()->GetBestSize();
        if (size.x > 0 && size.y > 0)
            return size;
    }

    int wText, hText;

    // these are the numbers from the HIG:
    // we reduce them by the borders first
    wText = 100 ;

    switch ( m_windowVariant )
    {
        case wxWINDOW_VARIANT_NORMAL :
            hText = 22 - 6 ;
            break ;

        case wxWINDOW_VARIANT_SMALL :
            hText = 19 - 6 ;
            break ;

        case wxWINDOW_VARIANT_MINI :
            hText = 15 - 6 ;
            break ;

        default :
            hText = 22 - 6;
            break ;
    }

    // as the above numbers have some free space around the text
    // we get 5 lines like this anyway
    if ( m_windowStyle & wxTE_MULTILINE )
         hText *= 5 ;

    if ( !HasFlag(wxNO_BORDER) )
        hText += 6 ;

    return wxSize(wText, hText);
}

bool wxTextCtrl::GetStyle(long position, wxTextAttr& style)
{
    return GetTextPeer()->GetStyle(position, style);
}

void wxTextCtrl::MarkDirty()
{
    m_dirty = true;
}

void wxTextCtrl::DiscardEdits()
{
    m_dirty = false;
}

int wxTextCtrl::GetNumberOfLines() const
{
    return GetTextPeer()->GetNumberOfLines() ;
}

long wxTextCtrl::XYToPosition(long x, long y) const
{
    return GetTextPeer()->XYToPosition( x , y ) ;
}

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

void wxTextCtrl::ShowPosition(long pos)
{
    return GetTextPeer()->ShowPosition(pos) ;
}

int wxTextCtrl::GetLineLength(long lineNo) const
{
    return GetTextPeer()->GetLineLength(lineNo) ;
}

wxString wxTextCtrl::GetLineText(long lineNo) const
{
    return GetTextPeer()->GetLineText(lineNo) ;
}

void wxTextCtrl::Copy()
{
    if (CanCopy())
    {
        wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_COPY, GetId());
        evt.SetEventObject(this);
        if (!GetEventHandler()->ProcessEvent(evt))
        {
            wxTextEntry::Copy();
        }
    }
}

void wxTextCtrl::Cut()
{
    if (CanCut())
    {
        wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_CUT, GetId());
        evt.SetEventObject(this);
        if (!GetEventHandler()->ProcessEvent(evt))
        {
            wxTextEntry::Cut();

            SendTextUpdatedEvent();
        }
    }
}

void wxTextCtrl::Paste()
{
    if (CanPaste())
    {
        wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_PASTE, GetId());
        evt.SetEventObject(this);
        if (!GetEventHandler()->ProcessEvent(evt))
        {
            wxTextEntry::Paste();

            // TODO: eventually we should add setting the default style again
            SendTextUpdatedEvent();
        }
    }
}

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::OnKeyDown(wxKeyEvent& event)
{
    if ( event.GetModifiers() == wxMOD_CMD )
    {
        switch( event.GetKeyCode() )
        {
            case 'A':
                SelectAll();
                return;
            case 'C':
                if ( CanCopy() )
                    Copy() ;
                return;
            case 'V':
                if ( CanPaste() )
                    Paste() ;
                return;
            case 'X':
                if ( CanCut() )
                    Cut() ;
                return;
            default:
                break;
        }
    }
    // no, we didn't process it
    event.Skip();
}

void wxTextCtrl::OnChar(wxKeyEvent& event)
{
    int key = event.GetKeyCode() ;
    bool eat_key = false ;
    long from, to;

    if ( !IsEditable() && !event.IsKeyInCategory(WXK_CATEGORY_ARROW | WXK_CATEGORY_TAB) &&
        !( key == WXK_RETURN && ( (m_windowStyle & wxTE_PROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
//        && key != WXK_PAGEUP && key != WXK_PAGEDOWN && key != WXK_HOME && key != WXK_END
        )
    {
        // eat it
        return ;
    }

    // Check if we have reached the max # of chars (if it is set), but still
    // allow navigation and deletion
    GetSelection( &from, &to );
    if ( !IsMultiLine() && m_maxLength && GetValue().length() >= m_maxLength &&
        !event.IsKeyInCategory(WXK_CATEGORY_ARROW | WXK_CATEGORY_TAB | WXK_CATEGORY_CUT) &&
        !( key == WXK_RETURN && (m_windowStyle & wxTE_PROCESS_ENTER) ) &&
        from == to )
    {
        // eat it, we don't want to add more than allowed # of characters

        // TODO: generate EVT_TEXT_MAXLEN()
        return;
    }

    // assume that any key not processed yet is going to modify the control
    m_dirty = true;

    switch ( key )
    {
        case WXK_RETURN:
            if (m_windowStyle & wxTE_PROCESS_ENTER)
            {
                wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
                event.SetEventObject( this );
                event.SetString( GetValue() );
                if ( HandleWindowEvent(event) )
                    return;
            }

            if ( !(m_windowStyle & wxTE_MULTILINE) )
            {
                wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
                if ( tlw && tlw->GetDefaultItem() )
                {
                    wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
                    if ( def && def->IsEnabled() )
                    {
                        wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
                        event.SetEventObject(def);
                        def->Command(event);

                        return ;
                    }
                }

                // this will make wxWidgets eat the ENTER key so that
                // we actually prevent line wrapping in a single line text control
                eat_key = true;
            }
            break;

        case WXK_TAB:
            if ( !(m_windowStyle & wxTE_PROCESS_TAB))
            {
                int flags = 0;
                if (!event.ShiftDown())
                    flags |= wxNavigationKeyEvent::IsForward ;
                if (event.ControlDown())
                    flags |= wxNavigationKeyEvent::WinChange ;
                Navigate(flags);

                return;
            }
            else
            {
                // This is necessary (don't know why);
                // otherwise the tab will not be inserted.
                WriteText(wxT("\t"));
                eat_key = true;
            }
            break;

        default:
            break;
    }

    if (!eat_key)
    {
        // perform keystroke handling
        event.Skip(true) ;
    }

    // osx_cocoa sends its event upon insertText
#if wxOSX_USE_CARBON
    if ( ( key >= 0x20 && key < WXK_START ) ||
         ( key >= WXK_NUMPAD0 && key <= WXK_DIVIDE ) ||
         key == WXK_RETURN ||
         key == WXK_DELETE ||
         key == WXK_BACK)
    {
        wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
        event1.SetEventObject( this );
        wxPostEvent( GetEventHandler(), event1 );
    }
#endif
}

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

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

// CS: Context Menus only work with MLTE implementations or non-multiline HIViews at the moment

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

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

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

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

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

void wxTextCtrl::OnDelete(wxCommandEvent& WXUNUSED(event))
{
    long from, to;

    GetSelection( &from, &to );
    if (from != -1 && to != -1)
        Remove( from, to );
}

void wxTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
{
    SetSelection(-1, -1);
}

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() );
}

void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent& event)
{
    long from, to;

    GetSelection( &from, &to );
    event.Enable( from != -1 && to != -1 && from != to && IsEditable() ) ;
}

void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
{
    event.Enable(GetLastPosition() > 0);
}

void wxTextCtrl::OnContextMenu(wxContextMenuEvent& event)
{
    if ( GetTextPeer()->HasOwnContextMenu() )
    {
        event.Skip() ;
        return ;
    }

#if wxUSE_MENUS
    if (m_privateContextMenu == NULL)
    {
        m_privateContextMenu = new wxMenu;
        m_privateContextMenu->Append(wxID_UNDO, _("&Undo"));
        m_privateContextMenu->Append(wxID_REDO, _("&Redo"));
        m_privateContextMenu->AppendSeparator();
        m_privateContextMenu->Append(wxID_CUT, _("Cu&t"));
        m_privateContextMenu->Append(wxID_COPY, _("&Copy"));
        m_privateContextMenu->Append(wxID_PASTE, _("&Paste"));
        m_privateContextMenu->Append(wxID_CLEAR, _("&Delete"));
        m_privateContextMenu->AppendSeparator();
        m_privateContextMenu->Append(wxID_SELECTALL, _("Select &All"));
    }

    PopupMenu(m_privateContextMenu);
#endif
}

bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
{
    if ( !GetTextPeer()->SetupCursor( pt ) )
        return wxWindow::MacSetupCursor( pt ) ;
    else
        return true ;
}

bool wxTextCtrl::SetHint(const wxString& hint)
{
    m_hintString = hint;

    if ( GetTextPeer() && GetTextPeer()->SetHint(hint) )
        return true;

    return false;
}

wxString wxTextCtrl::GetHint() const
{
    return m_hintString;
}

// ----------------------------------------------------------------------------
// implementation base class
// ----------------------------------------------------------------------------

bool wxTextWidgetImpl::GetStyle(long WXUNUSED(position),
                                wxTextAttr& WXUNUSED(style))
{
    return false;
}

void wxTextWidgetImpl::SetStyle(long WXUNUSED(start),
                                long WXUNUSED(end),
                                const wxTextAttr& WXUNUSED(style))
{
}

void wxTextWidgetImpl::Copy()
{
}

void wxTextWidgetImpl::Cut()
{
}

void wxTextWidgetImpl::Paste()
{
}

bool wxTextWidgetImpl::CanPaste() const
{
    return false ;
}

void wxTextWidgetImpl::SetEditable(bool WXUNUSED(editable))
{
}

long wxTextWidgetImpl::GetLastPosition() const
{
    return GetStringValue().length() ;
}

void wxTextWidgetImpl::Replace( long from , long to , const wxString &val )
{
    SetSelection( from , to ) ;
    WriteText( val ) ;
}

void wxTextWidgetImpl::Remove( long from , long to )
{
    SetSelection( from , to ) ;
    WriteText( wxEmptyString) ;
}

void wxTextWidgetImpl::Clear()
{
    SetStringValue( wxEmptyString ) ;
}

bool wxTextWidgetImpl::CanUndo() const
{
    return false ;
}

void wxTextWidgetImpl::Undo()
{
}

bool wxTextWidgetImpl::CanRedo()  const
{
    return false ;
}

void wxTextWidgetImpl::Redo()
{
}

long wxTextWidgetImpl::XYToPosition(long WXUNUSED(x), long WXUNUSED(y)) const
{
    return 0 ;
}

bool wxTextWidgetImpl::PositionToXY(long WXUNUSED(pos),
                                    long *WXUNUSED(x),
                                    long *WXUNUSED(y)) const
{
    return false ;
}

void wxTextWidgetImpl::ShowPosition( long WXUNUSED(pos) )
{
}

int wxTextWidgetImpl::GetNumberOfLines() const
{
    wxString content = GetStringValue() ;
    ItemCount lines = 1;

    for (size_t i = 0; i < content.length() ; i++)
    {
#if wxOSX_USE_COCOA
        if (content[i] == '\n')
#else
        if (content[i] == '\r')
#endif
            lines++;
    }

    return lines ;
}

wxString wxTextWidgetImpl::GetLineText(long lineNo) const
{
    // 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++)
    {
        if (count == lineNo)
        {
            // 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++;
    }

    return wxEmptyString ;
}

int wxTextWidgetImpl::GetLineLength(long lineNo) const
{
    // 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++)
    {
        if (count == lineNo)
        {
            // Count chars in line then
            count = 0;
            for (size_t j = i; j < content.length(); j++)
            {
                count++;
                if (content[j] == '\n')
                    return count;
            }

            return count;
        }

        if (content[i] == '\n')
            count++;
    }

    return 0 ;
}

#endif // wxUSE_TEXTCTRL
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/osx/textctrl_osx.cpp
	3	// Purpose: wxTextCtrl
	4	// Author: Stefan Csomor
	5	// Modified by: Ryan Norton (MLTE GetLineLength and GetLineText)
	6	// Created: 1998-01-01
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Stefan Csomor
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#include "wx/wxprec.h"
	13
	14	#if wxUSE_TEXTCTRL
	15
	16	#include "wx/textctrl.h"
	17
	18	#ifndef WX_PRECOMP
	19	#include "wx/intl.h"
	20	#include "wx/app.h"
	21	#include "wx/utils.h"
	22	#include "wx/dc.h"
	23	#include "wx/button.h"
	24	#include "wx/menu.h"
	25	#include "wx/settings.h"
	26	#include "wx/msgdlg.h"
	27	#include "wx/toplevel.h"
	28	#endif
	29
	30	#ifdef __DARWIN__
	31	#include <sys/types.h>
	32	#include <sys/stat.h>
	33	#else
	34	#include <stat.h>
	35	#endif
	36
	37	#if wxUSE_STD_IOSTREAM
	38	#if wxUSE_IOSTREAMH
	39	#include <fstream.h>
	40	#else
	41	#include <fstream>
	42	#endif
	43	#endif
	44
	45	#include "wx/filefn.h"
	46	#include "wx/sysopt.h"
	47	#include "wx/thread.h"
	48
	49	#include "wx/osx/private.h"
	50
	51	BEGIN_EVENT_TABLE(wxTextCtrl, wxTextCtrlBase)
	52	EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
	53	EVT_CHAR(wxTextCtrl::OnChar)
	54	EVT_KEY_DOWN(wxTextCtrl::OnKeyDown)
	55	EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
	56	EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
	57	EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
	58	EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
	59	EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
	60	EVT_MENU(wxID_CLEAR, wxTextCtrl::OnDelete)
	61	EVT_MENU(wxID_SELECTALL, wxTextCtrl::OnSelectAll)
	62
	63	EVT_CONTEXT_MENU(wxTextCtrl::OnContextMenu)
	64
	65	EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
	66	EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
	67	EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
	68	EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
	69	EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
	70	EVT_UPDATE_UI(wxID_CLEAR, wxTextCtrl::OnUpdateDelete)
	71	EVT_UPDATE_UI(wxID_SELECTALL, wxTextCtrl::OnUpdateSelectAll)
	72	END_EVENT_TABLE()
	73
	74
	75	void wxTextCtrl::Init()
	76	{
	77	m_dirty = false;
	78
	79	m_privateContextMenu = NULL;
	80	}
	81
	82	wxTextCtrl::~wxTextCtrl()
	83	{
	84	#if wxUSE_MENUS
	85	delete m_privateContextMenu;
	86	#endif
	87	}
	88
	89	bool wxTextCtrl::Create( wxWindow *parent,
	90	wxWindowID id,
	91	const wxString& str,
	92	const wxPoint& pos,
	93	const wxSize& size,
	94	long style,
	95	const wxValidator& validator,
	96	const wxString& name )
	97	{
	98	DontCreatePeer();
	99	m_editable = true ;
	100
	101	if ( ! (style & wxNO_BORDER) )
	102	style = (style & ~wxBORDER_MASK) \| wxSUNKEN_BORDER ;
	103
	104	if ( !wxTextCtrlBase::Create( parent, id, pos, size, style & ~(wxHSCROLL \| wxVSCROLL), validator, name ) )
	105	return false;
	106
	107	if ( m_windowStyle & wxTE_MULTILINE )
	108	{
	109	// always turn on this style for multi-line controls
	110	m_windowStyle \|= wxTE_PROCESS_ENTER;
	111	style \|= wxTE_PROCESS_ENTER ;
	112	}
	113
	114
	115	SetPeer(wxWidgetImpl::CreateTextControl( this, GetParent(), GetId(), str, pos, size, style, GetExtraStyle() ));
	116
	117	MacPostControlCreate(pos, size) ;
	118
	119	#if wxOSX_USE_COCOA
	120	// under carbon everything can already be set before the MacPostControlCreate embedding takes place
	121	// but under cocoa for single line textfields this only works after everything has been set up
	122	GetTextPeer()->SetStringValue(str);
	123	#endif
	124
	125	// only now the embedding is correct and we can do a positioning update
	126
	127	MacSuperChangedPosition() ;
	128
	129	if ( m_windowStyle & wxTE_READONLY)
	130	SetEditable( false ) ;
	131
	132	SetCursor( wxCursor( wxCURSOR_IBEAM ) ) ;
	133
	134	return true;
	135	}
	136
	137	void wxTextCtrl::MacSuperChangedPosition()
	138	{
	139	wxWindow::MacSuperChangedPosition() ;
	140	#if wxOSX_USE_CARBON
	141	GetPeer()->SuperChangedPosition() ;
	142	#endif
	143	}
	144
	145	void wxTextCtrl::MacVisibilityChanged()
	146	{
	147	#if wxOSX_USE_CARBON
	148	GetPeer()->VisibilityChanged( GetPeer()->IsVisible() );
	149	#endif
	150	}
	151
	152	void wxTextCtrl::MacCheckSpelling(bool check)
	153	{
	154	GetTextPeer()->CheckSpelling(check);
	155	}
	156
	157	void wxTextCtrl::SetMaxLength(unsigned long len)
	158	{
	159	m_maxLength = len ;
	160	}
	161
	162	bool wxTextCtrl::SetFont( const wxFont& font )
	163	{
	164	if ( !wxTextCtrlBase::SetFont( font ) )
	165	return false ;
	166
	167	GetPeer()->SetFont( font , GetForegroundColour() , GetWindowStyle(), false /* dont ignore black */ ) ;
	168
	169	return true ;
	170	}
	171
	172	bool wxTextCtrl::SetStyle(long start, long end, const wxTextAttr& style)
	173	{
	174	if (GetTextPeer())
	175	GetTextPeer()->SetStyle( start , end , style ) ;
	176
	177	return true ;
	178	}
	179
	180	bool wxTextCtrl::SetDefaultStyle(const wxTextAttr& style)
	181	{
	182	wxTextCtrlBase::SetDefaultStyle( style ) ;
	183	SetStyle( -1 /current selection/ , -1 /current selection/ , GetDefaultStyle() ) ;
	184
	185	return true ;
	186	}
	187
	188	bool wxTextCtrl::IsModified() const
	189	{
	190	return m_dirty;
	191	}
	192
	193	bool wxTextCtrl::AcceptsFocus() const
	194	{
	195	// we don't want focus if we can't be edited
	196	return /IsEditable() && / wxControl::AcceptsFocus();
	197	}
	198
	199	wxSize wxTextCtrl::DoGetBestSize() const
	200	{
	201	if (GetTextPeer())
	202	{
	203	wxSize size = GetTextPeer()->GetBestSize();
	204	if (size.x > 0 && size.y > 0)
	205	return size;
	206	}
	207
	208	int wText, hText;
	209
	210	// these are the numbers from the HIG:
	211	// we reduce them by the borders first
	212	wText = 100 ;
	213
	214	switch ( m_windowVariant )
	215	{
	216	case wxWINDOW_VARIANT_NORMAL :
	217	hText = 22 - 6 ;
	218	break ;
	219
	220	case wxWINDOW_VARIANT_SMALL :
	221	hText = 19 - 6 ;
	222	break ;
	223
	224	case wxWINDOW_VARIANT_MINI :
	225	hText = 15 - 6 ;
	226	break ;
	227
	228	default :
	229	hText = 22 - 6;
	230	break ;
	231	}
	232
	233	// as the above numbers have some free space around the text
	234	// we get 5 lines like this anyway
	235	if ( m_windowStyle & wxTE_MULTILINE )
	236	hText *= 5 ;
	237
	238	if ( !HasFlag(wxNO_BORDER) )
	239	hText += 6 ;
	240
	241	return wxSize(wText, hText);
	242	}
	243
	244	bool wxTextCtrl::GetStyle(long position, wxTextAttr& style)
	245	{
	246	return GetTextPeer()->GetStyle(position, style);
	247	}
	248
	249	void wxTextCtrl::MarkDirty()
	250	{
	251	m_dirty = true;
	252	}
	253
	254	void wxTextCtrl::DiscardEdits()
	255	{
	256	m_dirty = false;
	257	}
	258
	259	int wxTextCtrl::GetNumberOfLines() const
	260	{
	261	return GetTextPeer()->GetNumberOfLines() ;
	262	}
	263
	264	long wxTextCtrl::XYToPosition(long x, long y) const
	265	{
	266	return GetTextPeer()->XYToPosition( x , y ) ;
	267	}
	268
	269	bool wxTextCtrl::PositionToXY(long pos, long x, long y) const
	270	{
	271	return GetTextPeer()->PositionToXY( pos , x , y ) ;
	272	}
	273
	274	void wxTextCtrl::ShowPosition(long pos)
	275	{
	276	return GetTextPeer()->ShowPosition(pos) ;
	277	}
	278
	279	int wxTextCtrl::GetLineLength(long lineNo) const
	280	{
	281	return GetTextPeer()->GetLineLength(lineNo) ;
	282	}
	283
	284	wxString wxTextCtrl::GetLineText(long lineNo) const
	285	{
	286	return GetTextPeer()->GetLineText(lineNo) ;
	287	}
	288
	289	void wxTextCtrl::Copy()
	290	{
	291	if (CanCopy())
	292	{
	293	wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_COPY, GetId());
	294	evt.SetEventObject(this);
	295	if (!GetEventHandler()->ProcessEvent(evt))
	296	{
	297	wxTextEntry::Copy();
	298	}
	299	}
	300	}
	301
	302	void wxTextCtrl::Cut()
	303	{
	304	if (CanCut())
	305	{
	306	wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_CUT, GetId());
	307	evt.SetEventObject(this);
	308	if (!GetEventHandler()->ProcessEvent(evt))
	309	{
	310	wxTextEntry::Cut();
	311
	312	SendTextUpdatedEvent();
	313	}
	314	}
	315	}
	316
	317	void wxTextCtrl::Paste()
	318	{
	319	if (CanPaste())
	320	{
	321	wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_PASTE, GetId());
	322	evt.SetEventObject(this);
	323	if (!GetEventHandler()->ProcessEvent(evt))
	324	{
	325	wxTextEntry::Paste();
	326
	327	// TODO: eventually we should add setting the default style again
	328	SendTextUpdatedEvent();
	329	}
	330	}
	331	}
	332
	333	void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
	334	{
	335	// By default, load the first file into the text window.
	336	if (event.GetNumberOfFiles() > 0)
	337	LoadFile( event.GetFiles()[0] );
	338	}
	339
	340	void wxTextCtrl::OnKeyDown(wxKeyEvent& event)
	341	{
	342	if ( event.GetModifiers() == wxMOD_CMD )
	343	{
	344	switch( event.GetKeyCode() )
	345	{
	346	case 'A':
	347	SelectAll();
	348	return;
	349	case 'C':
	350	if ( CanCopy() )
	351	Copy() ;
	352	return;
	353	case 'V':
	354	if ( CanPaste() )
	355	Paste() ;
	356	return;
	357	case 'X':
	358	if ( CanCut() )
	359	Cut() ;
	360	return;
	361	default:
	362	break;
	363	}
	364	}
	365	// no, we didn't process it
	366	event.Skip();
	367	}
	368
	369	void wxTextCtrl::OnChar(wxKeyEvent& event)
	370	{
	371	int key = event.GetKeyCode() ;
	372	bool eat_key = false ;
	373	long from, to;
	374
	375	if ( !IsEditable() && !event.IsKeyInCategory(WXK_CATEGORY_ARROW \| WXK_CATEGORY_TAB) &&
	376	!( key == WXK_RETURN && ( (m_windowStyle & wxTE_PROCESS_ENTER) \|\| (m_windowStyle & wxTE_MULTILINE) ) )
	377	// && key != WXK_PAGEUP && key != WXK_PAGEDOWN && key != WXK_HOME && key != WXK_END
	378	)
	379	{
	380	// eat it
	381	return ;
	382	}
	383
	384	// Check if we have reached the max # of chars (if it is set), but still
	385	// allow navigation and deletion
	386	GetSelection( &from, &to );
	387	if ( !IsMultiLine() && m_maxLength && GetValue().length() >= m_maxLength &&
	388	!event.IsKeyInCategory(WXK_CATEGORY_ARROW \| WXK_CATEGORY_TAB \| WXK_CATEGORY_CUT) &&
	389	!( key == WXK_RETURN && (m_windowStyle & wxTE_PROCESS_ENTER) ) &&
	390	from == to )
	391	{
	392	// eat it, we don't want to add more than allowed # of characters
	393
	394	// TODO: generate EVT_TEXT_MAXLEN()
	395	return;
	396	}
	397
	398	// assume that any key not processed yet is going to modify the control
	399	m_dirty = true;
	400
	401	switch ( key )
	402	{
	403	case WXK_RETURN:
	404	if (m_windowStyle & wxTE_PROCESS_ENTER)
	405	{
	406	wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
	407	event.SetEventObject( this );
	408	event.SetString( GetValue() );
	409	if ( HandleWindowEvent(event) )
	410	return;
	411	}
	412
	413	if ( !(m_windowStyle & wxTE_MULTILINE) )
	414	{
	415	wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
	416	if ( tlw && tlw->GetDefaultItem() )
	417	{
	418	wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
	419	if ( def && def->IsEnabled() )
	420	{
	421	wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
	422	event.SetEventObject(def);
	423	def->Command(event);
	424
	425	return ;
	426	}
	427	}
	428
	429	// this will make wxWidgets eat the ENTER key so that
	430	// we actually prevent line wrapping in a single line text control
	431	eat_key = true;
	432	}
	433	break;
	434
	435	case WXK_TAB:
	436	if ( !(m_windowStyle & wxTE_PROCESS_TAB))
	437	{
	438	int flags = 0;
	439	if (!event.ShiftDown())
	440	flags \|= wxNavigationKeyEvent::IsForward ;
	441	if (event.ControlDown())
	442	flags \|= wxNavigationKeyEvent::WinChange ;
	443	Navigate(flags);
	444
	445	return;
	446	}
	447	else
	448	{
	449	// This is necessary (don't know why);
	450	// otherwise the tab will not be inserted.
	451	WriteText(wxT("\t"));
	452	eat_key = true;
	453	}
	454	break;
	455
	456	default:
	457	break;
	458	}
	459
	460	if (!eat_key)
	461	{
	462	// perform keystroke handling
	463	event.Skip(true) ;
	464	}
	465
	466	// osx_cocoa sends its event upon insertText
	467	#if wxOSX_USE_CARBON
	468	if ( ( key >= 0x20 && key < WXK_START ) \|\|
	469	( key >= WXK_NUMPAD0 && key <= WXK_DIVIDE ) \|\|
	470	key == WXK_RETURN \|\|
	471	key == WXK_DELETE \|\|
	472	key == WXK_BACK)
	473	{
	474	wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
	475	event1.SetEventObject( this );
	476	wxPostEvent( GetEventHandler(), event1 );
	477	}
	478	#endif
	479	}
	480
	481	void wxTextCtrl::Command(wxCommandEvent & event)
	482	{
	483	SetValue(event.GetString());
	484	ProcessCommand(event);
	485	}
	486
	487	// ----------------------------------------------------------------------------
	488	// standard handlers for standard edit menu events
	489	// ----------------------------------------------------------------------------
	490
	491	// CS: Context Menus only work with MLTE implementations or non-multiline HIViews at the moment
	492
	493	void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
	494	{
	495	Cut();
	496	}
	497
	498	void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
	499	{
	500	Copy();
	501	}
	502
	503	void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
	504	{
	505	Paste();
	506	}
	507
	508	void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
	509	{
	510	Undo();
	511	}
	512
	513	void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
	514	{
	515	Redo();
	516	}
	517
	518	void wxTextCtrl::OnDelete(wxCommandEvent& WXUNUSED(event))
	519	{
	520	long from, to;
	521
	522	GetSelection( &from, &to );
	523	if (from != -1 && to != -1)
	524	Remove( from, to );
	525	}
	526
	527	void wxTextCtrl::OnSelectAll(wxCommandEvent& WXUNUSED(event))
	528	{
	529	SetSelection(-1, -1);
	530	}
	531
	532	void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
	533	{
	534	event.Enable( CanCut() );
	535	}
	536
	537	void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
	538	{
	539	event.Enable( CanCopy() );
	540	}
	541
	542	void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
	543	{
	544	event.Enable( CanPaste() );
	545	}
	546
	547	void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
	548	{
	549	event.Enable( CanUndo() );
	550	}
	551
	552	void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
	553	{
	554	event.Enable( CanRedo() );
	555	}
	556
	557	void wxTextCtrl::OnUpdateDelete(wxUpdateUIEvent& event)
	558	{
	559	long from, to;
	560
	561	GetSelection( &from, &to );
	562	event.Enable( from != -1 && to != -1 && from != to && IsEditable() ) ;
	563	}
	564
	565	void wxTextCtrl::OnUpdateSelectAll(wxUpdateUIEvent& event)
	566	{
	567	event.Enable(GetLastPosition() > 0);
	568	}
	569
	570	void wxTextCtrl::OnContextMenu(wxContextMenuEvent& event)
	571	{
	572	if ( GetTextPeer()->HasOwnContextMenu() )
	573	{
	574	event.Skip() ;
	575	return ;
	576	}
	577
	578	#if wxUSE_MENUS
	579	if (m_privateContextMenu == NULL)
	580	{
	581	m_privateContextMenu = new wxMenu;
	582	m_privateContextMenu->Append(wxID_UNDO, _("&Undo"));
	583	m_privateContextMenu->Append(wxID_REDO, _("&Redo"));
	584	m_privateContextMenu->AppendSeparator();
	585	m_privateContextMenu->Append(wxID_CUT, _("Cu&t"));
	586	m_privateContextMenu->Append(wxID_COPY, _("&Copy"));
	587	m_privateContextMenu->Append(wxID_PASTE, _("&Paste"));
	588	m_privateContextMenu->Append(wxID_CLEAR, _("&Delete"));
	589	m_privateContextMenu->AppendSeparator();
	590	m_privateContextMenu->Append(wxID_SELECTALL, _("Select &All"));
	591	}
	592
	593	PopupMenu(m_privateContextMenu);
	594	#endif
	595	}
	596
	597	bool wxTextCtrl::MacSetupCursor( const wxPoint& pt )
	598	{
	599	if ( !GetTextPeer()->SetupCursor( pt ) )
	600	return wxWindow::MacSetupCursor( pt ) ;
	601	else
	602	return true ;
	603	}
	604
	605	bool wxTextCtrl::SetHint(const wxString& hint)
	606	{
	607	m_hintString = hint;
	608
	609	if ( GetTextPeer() && GetTextPeer()->SetHint(hint) )
	610	return true;
	611
	612	return false;
	613	}
	614
	615	wxString wxTextCtrl::GetHint() const
	616	{
	617	return m_hintString;
	618	}
	619
	620	// ----------------------------------------------------------------------------
	621	// implementation base class
	622	// ----------------------------------------------------------------------------
	623
	624	bool wxTextWidgetImpl::GetStyle(long WXUNUSED(position),
	625	wxTextAttr& WXUNUSED(style))
	626	{
	627	return false;
	628	}
	629
	630	void wxTextWidgetImpl::SetStyle(long WXUNUSED(start),
	631	long WXUNUSED(end),
	632	const wxTextAttr& WXUNUSED(style))
	633	{
	634	}
	635
	636	void wxTextWidgetImpl::Copy()
	637	{
	638	}
	639
	640	void wxTextWidgetImpl::Cut()
	641	{
	642	}
	643
	644	void wxTextWidgetImpl::Paste()
	645	{
	646	}
	647
	648	bool wxTextWidgetImpl::CanPaste() const
	649	{
	650	return false ;
	651	}
	652
	653	void wxTextWidgetImpl::SetEditable(bool WXUNUSED(editable))
	654	{
	655	}
	656
	657	long wxTextWidgetImpl::GetLastPosition() const
	658	{
	659	return GetStringValue().length() ;
	660	}
	661
	662	void wxTextWidgetImpl::Replace( long from , long to , const wxString &val )
	663	{
	664	SetSelection( from , to ) ;
	665	WriteText( val ) ;
	666	}
	667
	668	void wxTextWidgetImpl::Remove( long from , long to )
	669	{
	670	SetSelection( from , to ) ;
	671	WriteText( wxEmptyString) ;
	672	}
	673
	674	void wxTextWidgetImpl::Clear()
	675	{
	676	SetStringValue( wxEmptyString ) ;
	677	}
	678
	679	bool wxTextWidgetImpl::CanUndo() const
	680	{
	681	return false ;
	682	}
	683
	684	void wxTextWidgetImpl::Undo()
	685	{
	686	}
	687
	688	bool wxTextWidgetImpl::CanRedo() const
	689	{
	690	return false ;
	691	}
	692
	693	void wxTextWidgetImpl::Redo()
	694	{
	695	}
	696
	697	long wxTextWidgetImpl::XYToPosition(long WXUNUSED(x), long WXUNUSED(y)) const
	698	{
	699	return 0 ;
	700	}
	701
	702	bool wxTextWidgetImpl::PositionToXY(long WXUNUSED(pos),
	703	long *WXUNUSED(x),
	704	long *WXUNUSED(y)) const
	705	{
	706	return false ;
	707	}
	708
	709	void wxTextWidgetImpl::ShowPosition( long WXUNUSED(pos) )
	710	{
	711	}
	712
	713	int wxTextWidgetImpl::GetNumberOfLines() const
	714	{
	715	wxString content = GetStringValue() ;
	716	ItemCount lines = 1;
	717
	718	for (size_t i = 0; i < content.length() ; i++)
	719	{
	720	#if wxOSX_USE_COCOA
	721	if (content[i] == '\n')
	722	#else
	723	if (content[i] == '\r')
	724	#endif
	725	lines++;
	726	}
	727
	728	return lines ;
	729	}
	730
	731	wxString wxTextWidgetImpl::GetLineText(long lineNo) const
	732	{
	733	// TODO: change this if possible to reflect real lines
	734	wxString content = GetStringValue() ;
	735
	736	// Find line first
	737	int count = 0;
	738	for (size_t i = 0; i < content.length() ; i++)
	739	{
	740	if (count == lineNo)
	741	{
	742	// Add chars in line then
	743	wxString tmp;
	744
	745	for (size_t j = i; j < content.length(); j++)
	746	{
	747	if (content[j] == '\n')
	748	return tmp;
	749
	750	tmp += content[j];
	751	}
	752
	753	return tmp;
	754	}
	755
	756	if (content[i] == '\n')
	757	count++;
	758	}
	759
	760	return wxEmptyString ;
	761	}
	762
	763	int wxTextWidgetImpl::GetLineLength(long lineNo) const
	764	{
	765	// TODO: change this if possible to reflect real lines
	766	wxString content = GetStringValue() ;
	767
	768	// Find line first
	769	int count = 0;
	770	for (size_t i = 0; i < content.length() ; i++)
	771	{
	772	if (count == lineNo)
	773	{
	774	// Count chars in line then
	775	count = 0;
	776	for (size_t j = i; j < content.length(); j++)
	777	{
	778	count++;
	779	if (content[j] == '\n')
	780	return count;
	781	}
	782
	783	return count;
	784	}
	785
	786	if (content[i] == '\n')
	787	count++;
	788	}
	789
	790	return 0 ;
	791	}
	792
	793	#endif // wxUSE_TEXTCTRL