[wxWidgets.git] / samples / text / text.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        controls.cpp
// Purpose:     TextCtrl wxWindows sample
// Author:      Robert Roebling
// Modified by:
// RCS-ID:      $Id$
// Copyright:   (c) Robert Roebling, Julian Smart
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

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

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#if wxUSE_CLIPBOARD
    #include "wx/dataobj.h"
    #include "wx/clipbrd.h"
#endif

#if wxUSE_TOOLTIPS
    #include "wx/tooltip.h"
#endif

#if defined(__WXGTK__) || defined(__WXMOTIF__)
    #include "mondrian.xpm"
#endif

// We test for wxUSE_DRAG_AND_DROP also, because data objects may not be
// implemented for compilers that can't cope with the OLE parts in
// wxUSE_DRAG_AND_DROP.
#if !wxUSE_DRAG_AND_DROP
    #undef wxUSE_CLIPBOARD
    #define wxUSE_CLIPBOARD 0
#endif

//----------------------------------------------------------------------
// class definitions
//----------------------------------------------------------------------

class MyApp: public wxApp
{
public:
    bool OnInit();
};

// a text ctrl which allows to call different wxTextCtrl functions
// interactively by pressing function keys in it
class MyTextCtrl : public wxTextCtrl
{
public:
    MyTextCtrl(wxWindow *parent, wxWindowID id, const wxString &value,
               const wxPoint &pos, const wxSize &size, int style = 0)
        : wxTextCtrl(parent, id, value, pos, size, style) { }

    void OnKeyDown(wxKeyEvent& event);
    void OnKeyUp(wxKeyEvent& event);
    void OnChar(wxKeyEvent& event);

private:
    static inline wxChar GetChar(bool on, wxChar c) { return on ? c : _T('-'); }
    void LogEvent(const wxChar *name, wxKeyEvent& event) const;

    DECLARE_EVENT_TABLE()
};

class MyPanel: public wxPanel
{
public:
    MyPanel(wxFrame *frame, int x, int y, int w, int h);

#if wxUSE_CLIPBOARD
    void DoPasteFromClipboard();
    void DoCopyToClipboard();
#endif // wxUSE_CLIPBOARD

    void DoMoveToEndOfText();
    void DoMoveToEndOfEntry();

    MyTextCtrl    *m_text;
    MyTextCtrl    *m_password;
    MyTextCtrl    *m_enter;
    MyTextCtrl    *m_tab;
    MyTextCtrl    *m_readonly;

    MyTextCtrl    *m_multitext;
    MyTextCtrl    *m_horizontal;

    wxTextCtrl    *m_log;
};

class MyFrame: public wxFrame
{
public:
    MyFrame(wxFrame *frame, const char *title, int x, int y, int w, int h);

    void OnQuit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);
#if wxUSE_TOOLTIPS
    void OnSetTooltipDelay(wxCommandEvent& event);
    void OnToggleTooltips(wxCommandEvent& event);
#endif // wxUSE_TOOLTIPS

#if wxUSE_CLIPBOARD
    void OnPasteFromClipboard( wxCommandEvent &event )
        { m_panel->DoPasteFromClipboard(); }
    void OnCopyToClipboard( wxCommandEvent &event )
        { m_panel->DoCopyToClipboard(); }
#endif // wxUSE_CLIPBOARD

    void OnMoveToEndOfText( wxCommandEvent &event )
        { m_panel->DoMoveToEndOfText(); }
    void OnMoveToEndOfEntry( wxCommandEvent &event )
        { m_panel->DoMoveToEndOfEntry(); }

    void OnFileLoad(wxCommandEvent& event);

    void OnIdle( wxIdleEvent& event );

private:
    MyPanel *m_panel;

    DECLARE_EVENT_TABLE()
};

//----------------------------------------------------------------------
// main()
//----------------------------------------------------------------------

IMPLEMENT_APP(MyApp)

//----------------------------------------------------------------------
// MyApp
//----------------------------------------------------------------------

enum
{
    TEXT_QUIT = 100,
    TEXT_ABOUT,
    TEXT_LOAD,

    // clipboard menu
    TEXT_CLIPBOARD_COPY = 200,
    TEXT_CLIPBOARD_PASTE,

    // tooltip menu
    TEXT_TOOLTIPS_SETDELAY = 300,
    TEXT_TOOLTIPS_ENABLE,

    // move menu
    TEXT_MOVE_ENDTEXT = 400,
    TEXT_MOVE_ENDENTRY
};

bool MyApp::OnInit()
{
    // Create the main frame window
    MyFrame *frame = new MyFrame((wxFrame *) NULL,
            "Text wxWindows App",
            50, 50, 640, 420);

    wxMenu *file_menu = new wxMenu;
    file_menu->Append(TEXT_LOAD, "&Load file\tCtrl-O",
                      "Load the sample file into text control");
    file_menu->AppendSeparator();
    file_menu->Append(TEXT_ABOUT, "&About\tAlt-A");
    file_menu->AppendSeparator();
    file_menu->Append(TEXT_QUIT, "E&xit\tAlt-X", "Quit controls sample");

    wxMenuBar *menu_bar = new wxMenuBar( wxMB_DOCKABLE );
    menu_bar->Append(file_menu, "&File");

#if wxUSE_TOOLTIPS
    wxMenu *tooltip_menu = new wxMenu;
    tooltip_menu->Append(TEXT_TOOLTIPS_SETDELAY, "Set &delay\tCtrl-D");
    tooltip_menu->AppendSeparator();
    tooltip_menu->Append(TEXT_TOOLTIPS_ENABLE, "&Toggle tooltips\tCtrl-T",
            "enable/disable tooltips", TRUE);
    tooltip_menu->Check(TEXT_TOOLTIPS_ENABLE, TRUE);
    menu_bar->Append(tooltip_menu, "&Tooltips");
#endif // wxUSE_TOOLTIPS

#if wxUSE_CLIPBOARD
    wxMenu *menuClipboard = new wxMenu;
    menuClipboard->Append(TEXT_CLIPBOARD_COPY, "&Copy\tCtrl-C",
                          "Copy the first line to the clipboard");
    menuClipboard->Append(TEXT_CLIPBOARD_PASTE, "&Paste\tCtrl-V",
                          "Paste from clipboard to the text control");
    menu_bar->Append(menuClipboard, "&Clipboard");
#endif // wxUSE_CLIPBOARD

    wxMenu *menuMove = new wxMenu;
    menuMove->Append(TEXT_MOVE_ENDTEXT, "To the end of &text");
    menuMove->Append(TEXT_MOVE_ENDENTRY, "To the end of &entry");
    menu_bar->Append(menuMove, "&Move");

    frame->SetMenuBar(menu_bar);

    frame->Show(TRUE);

    SetTopWindow(frame);

    // report success
    return TRUE;
}

//----------------------------------------------------------------------
// MyTextCtrl
//----------------------------------------------------------------------

BEGIN_EVENT_TABLE(MyTextCtrl, wxTextCtrl)
    EVT_KEY_DOWN(MyTextCtrl::OnKeyDown)
    EVT_KEY_UP(MyTextCtrl::OnKeyUp)
    EVT_CHAR(MyTextCtrl::OnChar)
END_EVENT_TABLE()

void MyTextCtrl::LogEvent(const wxChar *name, wxKeyEvent& event) const
{
    wxString key;
    long keycode = event.KeyCode();
    if ( wxIsprint((int)keycode) )
        key.Printf( _T("'%c'") , (char)keycode);
    else
    {
        switch ( keycode )
        {
            case WXK_BACK: key = "BACK"; break;
            case WXK_TAB: key = "TAB"; break;
            case WXK_RETURN: key = "RETURN"; break;
            case WXK_ESCAPE: key = "ESCAPE"; break;
            case WXK_SPACE: key = "SPACE"; break;
            case WXK_DELETE: key = "DELETE"; break;
            case WXK_START: key = "START"; break;
            case WXK_LBUTTON: key = "LBUTTON"; break;
            case WXK_RBUTTON: key = "RBUTTON"; break;
            case WXK_CANCEL: key = "CANCEL"; break;
            case WXK_MBUTTON: key = "MBUTTON"; break;
            case WXK_CLEAR: key = "CLEAR"; break;
            case WXK_SHIFT: key = "SHIFT"; break;
            case WXK_ALT: key = "ALT"; break;
            case WXK_CONTROL: key = "CONTROL"; break;
            case WXK_MENU: key = "MENU"; break;
            case WXK_PAUSE: key = "PAUSE"; break;
            case WXK_CAPITAL: key = "CAPITAL"; break;
            case WXK_PRIOR: key = "PRIOR"; break;
            case WXK_NEXT: key = "NEXT"; break;
            case WXK_END: key = "END"; break;
            case WXK_HOME: key = "HOME"; break;
            case WXK_LEFT: key = "LEFT"; break;
            case WXK_UP: key = "UP"; break;
            case WXK_RIGHT: key = "RIGHT"; break;
            case WXK_DOWN: key = "DOWN"; break;
            case WXK_SELECT: key = "SELECT"; break;
            case WXK_PRINT: key = "PRINT"; break;
            case WXK_EXECUTE: key = "EXECUTE"; break;
            case WXK_SNAPSHOT: key = "SNAPSHOT"; break;
            case WXK_INSERT: key = "INSERT"; break;
            case WXK_HELP: key = "HELP"; break;
            case WXK_NUMPAD0: key = "NUMPAD0"; break;
            case WXK_NUMPAD1: key = "NUMPAD1"; break;
            case WXK_NUMPAD2: key = "NUMPAD2"; break;
            case WXK_NUMPAD3: key = "NUMPAD3"; break;
            case WXK_NUMPAD4: key = "NUMPAD4"; break;
            case WXK_NUMPAD5: key = "NUMPAD5"; break;
            case WXK_NUMPAD6: key = "NUMPAD6"; break;
            case WXK_NUMPAD7: key = "NUMPAD7"; break;
            case WXK_NUMPAD8: key = "NUMPAD8"; break;
            case WXK_NUMPAD9: key = "NUMPAD9"; break;
            case WXK_MULTIPLY: key = "MULTIPLY"; break;
            case WXK_ADD: key = "ADD"; break;
            case WXK_SEPARATOR: key = "SEPARATOR"; break;
            case WXK_SUBTRACT: key = "SUBTRACT"; break;
            case WXK_DECIMAL: key = "DECIMAL"; break;
            case WXK_DIVIDE: key = "DIVIDE"; break;
            case WXK_F1: key = "F1"; break;
            case WXK_F2: key = "F2"; break;
            case WXK_F3: key = "F3"; break;
            case WXK_F4: key = "F4"; break;
            case WXK_F5: key = "F5"; break;
            case WXK_F6: key = "F6"; break;
            case WXK_F7: key = "F7"; break;
            case WXK_F8: key = "F8"; break;
            case WXK_F9: key = "F9"; break;
            case WXK_F10: key = "F10"; break;
            case WXK_F11: key = "F11"; break;
            case WXK_F12: key = "F12"; break;
            case WXK_F13: key = "F13"; break;
            case WXK_F14: key = "F14"; break;
            case WXK_F15: key = "F15"; break;
            case WXK_F16: key = "F16"; break;
            case WXK_F17: key = "F17"; break;
            case WXK_F18: key = "F18"; break;
            case WXK_F19: key = "F19"; break;
            case WXK_F20: key = "F20"; break;
            case WXK_F21: key = "F21"; break;
            case WXK_F22: key = "F22"; break;
            case WXK_F23: key = "F23"; break;
            case WXK_F24: key = "F24"; break;
            case WXK_NUMLOCK: key = "NUMLOCK"; break;
            case WXK_SCROLL: key = "SCROLL"; break;
            case WXK_PAGEUP: key = "PAGEUP"; break;
            case WXK_PAGEDOWN: key = "PAGEDOWN"; break;
            case WXK_NUMPAD_SPACE: key = "NUMPAD_SPACE"; break;
            case WXK_NUMPAD_TAB: key = "NUMPAD_TAB"; break;
            case WXK_NUMPAD_ENTER: key = "NUMPAD_ENTER"; break;
            case WXK_NUMPAD_F1: key = "NUMPAD_F1"; break;
            case WXK_NUMPAD_F2: key = "NUMPAD_F2"; break;
            case WXK_NUMPAD_F3: key = "NUMPAD_F3"; break;
            case WXK_NUMPAD_F4: key = "NUMPAD_F4"; break;
            case WXK_NUMPAD_HOME: key = "NUMPAD_HOME"; break;
            case WXK_NUMPAD_LEFT: key = "NUMPAD_LEFT"; break;
            case WXK_NUMPAD_UP: key = "NUMPAD_UP"; break;
            case WXK_NUMPAD_RIGHT: key = "NUMPAD_RIGHT"; break;
            case WXK_NUMPAD_DOWN: key = "NUMPAD_DOWN"; break;
            case WXK_NUMPAD_PRIOR: key = "NUMPAD_PRIOR"; break;
            case WXK_NUMPAD_PAGEUP: key = "NUMPAD_PAGEUP"; break;
            case WXK_NUMPAD_PAGEDOWN: key = "NUMPAD_PAGEDOWN"; break;
            case WXK_NUMPAD_END: key = "NUMPAD_END"; break;
            case WXK_NUMPAD_BEGIN: key = "NUMPAD_BEGIN"; break;
            case WXK_NUMPAD_INSERT: key = "NUMPAD_INSERT"; break;
            case WXK_NUMPAD_DELETE: key = "NUMPAD_DELETE"; break;
            case WXK_NUMPAD_EQUAL: key = "NUMPAD_EQUAL"; break;
            case WXK_NUMPAD_MULTIPLY: key = "NUMPAD_MULTIPLY"; break;
            case WXK_NUMPAD_ADD: key = "NUMPAD_ADD"; break;
            case WXK_NUMPAD_SEPARATOR: key = "NUMPAD_SEPARATOR"; break;
            case WXK_NUMPAD_SUBTRACT: key = "NUMPAD_SUBTRACT"; break;
            case WXK_NUMPAD_DECIMAL: key = "NUMPAD_DECIMAL"; break;

            default:
                key.Printf( _T("unknown (%ld)"), keycode);
        }
    }

    wxLogMessage( _T("%s event: %s (flags = %c%c%c%c)"),
                  name,
                  key.c_str(),
                  GetChar( event.ControlDown(), _T('C') ),
                  GetChar( event.AltDown(), _T('A') ),
                  GetChar( event.ShiftDown(), _T('S') ),
                  GetChar( event.MetaDown(), _T('M') ) );

}

void MyTextCtrl::OnChar(wxKeyEvent& event)
{
    LogEvent( _T("Char"), event);

    if ( event.KeyCode() == WXK_TAB )
    {
        WriteText("\t");
    }
    else
    {
        event.Skip();
    }
}

void MyTextCtrl::OnKeyUp(wxKeyEvent& event)
{
    LogEvent( _("Key up"), event);

    event.Skip();
}

void MyTextCtrl::OnKeyDown(wxKeyEvent& event)
{
    switch ( event.KeyCode() )
    {
        case WXK_F1:
            // show current position and text length
            {
                long line, column, pos = GetInsertionPoint();
                PositionToXY(pos, &column, &line);

                wxLogMessage( _T("Current position: %ld\n"
                        "Current line, column: (%ld, %ld)\n"
                        "Number of lines: %ld\n"
                        "Current line length: %ld\n"
                        "Total text length: %ld"),
                        pos,
                        line, column,
                        GetNumberOfLines(),
                        GetLineLength(line),
                        GetLastPosition());
            }
            break;

        case WXK_F2:
            // go to the end
            SetInsertionPointEnd();
            break;

        case WXK_F3:
            // go to position 10
            SetInsertionPoint(10);
            break;
    }

    LogEvent( _("Key down"), event);

    event.Skip();
}

//----------------------------------------------------------------------
// MyPanel
//----------------------------------------------------------------------

MyPanel::MyPanel( wxFrame *frame, int x, int y, int w, int h )
       : wxPanel( frame, -1, wxPoint(x, y), wxSize(w, h) )
{
    m_log = new wxTextCtrl( this, -1, "This is the log window.\n", wxPoint(5,260), wxSize(630,100), wxTE_MULTILINE );

    delete wxLog::SetActiveTarget(new wxLogStderr);

    // single line text controls

    m_text = new MyTextCtrl( this, -1, "Single line.",
      wxPoint(10,10), wxSize(140,-1), 0);
    (*m_text) << " Appended.";
    m_text->SetInsertionPoint(0);
    m_text->WriteText( "Prepended. " );

    m_password = new MyTextCtrl( this, -1, "",
      wxPoint(10,50), wxSize(140,-1), wxTE_PASSWORD );

    m_readonly = new MyTextCtrl( this, -1, "Read only",
      wxPoint(10,90), wxSize(140,-1), wxTE_READONLY );

    // multi line text controls

    m_horizontal = new MyTextCtrl( this, -1, "Multiline text control with a horizontal scrollbar.",
      wxPoint(10,170), wxSize(140,70), wxTE_MULTILINE | wxHSCROLL );
    m_horizontal->SetFont(wxFont(18, wxSWISS, wxNORMAL, wxBOLD));

    m_multitext = new MyTextCtrl( this, -1, "Multi line.",
      wxPoint(180,10), wxSize(240,70), wxTE_MULTILINE );
    (*m_multitext) << " Appended.";
    m_multitext->SetInsertionPoint(0);
    m_multitext->WriteText( "Prepended. " );

#if wxUSE_TOOLTIPS
    m_multitext->SetToolTip("Press F1 here.");
#endif

    m_tab = new MyTextCtrl( this, -1, "Multiline, allow <TAB> processing.",
      wxPoint(180,90), wxSize(240,70), wxTE_MULTILINE |  wxTE_PROCESS_TAB );

    m_enter = new MyTextCtrl( this, -1, "Multiline, allow <ENTER> processing.",
      wxPoint(180,170), wxSize(240,70), wxTE_MULTILINE);
}

#if wxUSE_CLIPBOARD
void MyPanel::DoPasteFromClipboard()
{
    // On X11, we want to get the data from the primary selection instead
    // of the normal clipboard (which isn't normal under X11 at all). This
    // call has no effect under MSW.
    wxTheClipboard->UsePrimarySelection();

    if (!wxTheClipboard->Open())
    {
        *m_log << "Error opening the clipboard.\n";
        return;
    }
    else
    {
        *m_log << "Successfully opened the clipboard.\n";
    }

    wxTextDataObject data;

    if (wxTheClipboard->IsSupported( data.GetFormat() ))
    {
        *m_log << "Clipboard supports requested format.\n";

        if (wxTheClipboard->GetData( &data ))
        {
            *m_log << "Successfully retrieved data from the clipboard.\n";
            *m_multitext << data.GetText() << "\n";
        }
        else
        {
            *m_log << "Error getting data from the clipboard.\n";
        }
    }
    else
    {
        *m_log << "Clipboard doesn't support requested format.\n";
    }

    wxTheClipboard->Close();

    *m_log << "Closed the clipboard.\n";
}

void MyPanel::DoCopyToClipboard()
{
    wxString text( m_multitext->GetLineText(0) );

    if (text.IsEmpty())
    {
        *m_log << "No text to copy.\n";

        return;
    }

    if (!wxTheClipboard->Open())
    {
        *m_log << "Error opening the clipboard.\n";

        return;
    }
    else
    {
        *m_log << "Successfully opened the clipboard.\n";
    }

    wxTextDataObject *data = new wxTextDataObject( text );

    if (!wxTheClipboard->SetData( data ))
    {
        *m_log << "Error while copying to the clipboard.\n";
    }
    else
    {
        *m_log << "Successfully copied data to the clipboard.\n";
    }

    wxTheClipboard->Close();

    *m_log << "Closed the clipboard.\n";
}

#endif // wxUSE_CLIPBOARD

void MyPanel::DoMoveToEndOfText()
{
    m_multitext->SetInsertionPointEnd();
    m_multitext->SetFocus();
}

void MyPanel::DoMoveToEndOfEntry()
{
    m_text->SetInsertionPointEnd();
    m_text->SetFocus();
}

//----------------------------------------------------------------------
// MyFrame
//----------------------------------------------------------------------

BEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_MENU(TEXT_QUIT,   MyFrame::OnQuit)
    EVT_MENU(TEXT_ABOUT,  MyFrame::OnAbout)
    EVT_MENU(TEXT_LOAD,   MyFrame::OnFileLoad)

#if wxUSE_TOOLTIPS
    EVT_MENU(TEXT_TOOLTIPS_SETDELAY,  MyFrame::OnSetTooltipDelay)
    EVT_MENU(TEXT_TOOLTIPS_ENABLE,    MyFrame::OnToggleTooltips)
#endif // wxUSE_TOOLTIPS

    EVT_MENU(TEXT_CLIPBOARD_PASTE,    MyFrame::OnPasteFromClipboard)
    EVT_MENU(TEXT_CLIPBOARD_COPY,     MyFrame::OnCopyToClipboard)
    EVT_MENU(TEXT_MOVE_ENDTEXT,       MyFrame::OnMoveToEndOfText)
    EVT_MENU(TEXT_MOVE_ENDENTRY,      MyFrame::OnMoveToEndOfEntry)

    EVT_IDLE(MyFrame::OnIdle)
END_EVENT_TABLE()

MyFrame::MyFrame(wxFrame *frame, const char *title, int x, int y, int w, int h)
       : wxFrame(frame, -1, title, wxPoint(x, y), wxSize(w, h) )
{
    CreateStatusBar(2);

    m_panel = new MyPanel( this, 10, 10, 300, 100 );
}

void MyFrame::OnQuit (wxCommandEvent& WXUNUSED(event) )
{
    Close(TRUE);
}

void MyFrame::OnAbout( wxCommandEvent& WXUNUSED(event) )
{
    wxBeginBusyCursor();

    wxMessageDialog dialog(this,
        "This is a text control sample. It demonstrates the many different\n"
        "text control styles, the use of the clipboard, setting and handling\n"
        "tooltips and intercepting key and char events.\n"
        "\n"
        "Copyright (c) 1999, Robert Roebling, Julian Smart, Vadim Zeitlin",
        "About Text Controls",
        wxOK | wxICON_INFORMATION);

    dialog.ShowModal();

    wxEndBusyCursor();
}

#if wxUSE_TOOLTIPS
void MyFrame::OnSetTooltipDelay(wxCommandEvent& event)
{
    static long s_delay = 5000;

    wxString delay;
    delay.Printf( _T("%ld"), s_delay);

    delay = wxGetTextFromUser("Enter delay (in milliseconds)",
                              "Set tooltip delay",
                              delay,
                              this);
    if ( !delay )
        return; // cancelled

    wxSscanf(delay, _T("%ld"), &s_delay);

    wxToolTip::SetDelay(s_delay);

    wxLogStatus(this, _T("Tooltip delay set to %ld milliseconds"), s_delay);
}

void MyFrame::OnToggleTooltips(wxCommandEvent& event)
{
    static bool s_enabled = TRUE;

    s_enabled = !s_enabled;

    wxToolTip::Enable(s_enabled);

    wxLogStatus(this, _T("Tooltips %sabled"), s_enabled ? _T("en") : _T("dis") );
}
#endif // tooltips

void MyFrame::OnFileLoad(wxCommandEvent& event)
{
    if ( m_panel->m_multitext->LoadFile("controls.cpp") )
        wxLogStatus(this, _T("Successfully loaded file"));
    else
        wxLogStatus(this, _T("Couldn't load the file"));
}

void MyFrame::OnIdle( wxIdleEvent& event )
{
    // track the window which has the focus in the status bar
    static wxWindow *s_windowFocus = (wxWindow *)NULL;
    wxWindow *focus = wxWindow::FindFocus();
    if ( focus && (focus != s_windowFocus) )
    {
        s_windowFocus = focus;

        wxString msg;
        msg.Printf(
#ifdef __WXMSW__
                _T("Focus: wxWindow = %p, HWND = %08x"),
#else
                _T("Focus: wxWindow = %p"),
#endif
                s_windowFocus
#ifdef __WXMSW__
                , s_windowFocus->GetHWND()
#endif
                  );

        SetStatusText(msg);
    }
    event.Skip();
}
Commit	Line	Data
02e8b87f RR	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: controls.cpp
	3	// Purpose: TextCtrl wxWindows sample
	4	// Author: Robert Roebling
	5	// Modified by:
	6	// RCS-ID: $Id$
	7	// Copyright: (c) Robert Roebling, Julian Smart
	8	// Licence: wxWindows license
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	#ifdef __GNUG__
	12	#pragma implementation "controls.h"
	13	#endif
	14
	15	// For compilers that support precompilation, includes "wx/wx.h".
	16	#include "wx/wxprec.h"
	17
	18	#ifdef __BORLANDC__
	19	#pragma hdrstop
	20	#endif
	21
	22	#ifndef WX_PRECOMP
	23	#include "wx/wx.h"
	24	#endif
	25
	26	#if wxUSE_CLIPBOARD
	27	#include "wx/dataobj.h"
	28	#include "wx/clipbrd.h"
	29	#endif
	30
	31	#if wxUSE_TOOLTIPS
	32	#include "wx/tooltip.h"
	33	#endif
	34
	35	#if defined(__WXGTK__) \|\| defined(__WXMOTIF__)
	36	#include "mondrian.xpm"
	37	#endif
	38
b6a0d8a2 VZ	39	// We test for wxUSE_DRAG_AND_DROP also, because data objects may not be
	40	// implemented for compilers that can't cope with the OLE parts in
	41	// wxUSE_DRAG_AND_DROP.
	42	#if !wxUSE_DRAG_AND_DROP
	43	#undef wxUSE_CLIPBOARD
	44	#define wxUSE_CLIPBOARD 0
	45	#endif
	46
02e8b87f RR	47	//----------------------------------------------------------------------
	48	// class definitions
	49	//----------------------------------------------------------------------
	50
	51	class MyApp: public wxApp
	52	{
	53	public:
	54	bool OnInit();
	55	};
	56
	57	// a text ctrl which allows to call different wxTextCtrl functions
	58	// interactively by pressing function keys in it
	59	class MyTextCtrl : public wxTextCtrl
	60	{
	61	public:
	62	MyTextCtrl(wxWindow *parent, wxWindowID id, const wxString &value,
	63	const wxPoint &pos, const wxSize &size, int style = 0)
	64	: wxTextCtrl(parent, id, value, pos, size, style) { }
	65
	66	void OnKeyDown(wxKeyEvent& event);
	67	void OnKeyUp(wxKeyEvent& event);
	68	void OnChar(wxKeyEvent& event);
	69
	70	private:
	71	static inline wxChar GetChar(bool on, wxChar c) { return on ? c : _T('-'); }
	72	void LogEvent(const wxChar *name, wxKeyEvent& event) const;
	73
	74	DECLARE_EVENT_TABLE()
	75	};
	76
	77	class MyPanel: public wxPanel
	78	{
	79	public:
	80	MyPanel(wxFrame *frame, int x, int y, int w, int h);
	81
b6a0d8a2 VZ	82	#if wxUSE_CLIPBOARD
	83	void DoPasteFromClipboard();
	84	void DoCopyToClipboard();
	85	#endif // wxUSE_CLIPBOARD
	86
	87	void DoMoveToEndOfText();
	88	void DoMoveToEndOfEntry();
02e8b87f RR	89
	90	MyTextCtrl *m_text;
	91	MyTextCtrl *m_password;
	92	MyTextCtrl *m_enter;
	93	MyTextCtrl *m_tab;
02e8b87f	94	MyTextCtrl *m_readonly;
bb69661b	95
02e8b87f RR	96	MyTextCtrl *m_multitext;
02e8b87f RR	97	MyTextCtrl *m_horizontal;
02e8b87f RR	98
02e8b87f RR	99	wxTextCtrl *m_log;
02e8b87f RR	100	};
	101
	102	class MyFrame: public wxFrame
	103	{
	104	public:
b6a0d8a2	105	MyFrame(wxFrame frame, const char title, int x, int y, int w, int h);
02e8b87f RR	106
	107	void OnQuit(wxCommandEvent& event);
	108	void OnAbout(wxCommandEvent& event);
	109	#if wxUSE_TOOLTIPS
	110	void OnSetTooltipDelay(wxCommandEvent& event);
	111	void OnToggleTooltips(wxCommandEvent& event);
	112	#endif // wxUSE_TOOLTIPS
b6a0d8a2 VZ	113
	114	#if wxUSE_CLIPBOARD
	115	void OnPasteFromClipboard( wxCommandEvent &event )
	116	{ m_panel->DoPasteFromClipboard(); }
	117	void OnCopyToClipboard( wxCommandEvent &event )
	118	{ m_panel->DoCopyToClipboard(); }
	119	#endif // wxUSE_CLIPBOARD
	120
	121	void OnMoveToEndOfText( wxCommandEvent &event )
	122	{ m_panel->DoMoveToEndOfText(); }
	123	void OnMoveToEndOfEntry( wxCommandEvent &event )
	124	{ m_panel->DoMoveToEndOfEntry(); }
	125
	126	void OnFileLoad(wxCommandEvent& event);
	127
02e8b87f RR	128	void OnIdle( wxIdleEvent& event );
	129
	130	private:
b6a0d8a2 VZ	131	MyPanel *m_panel;
b6a0d8a2 VZ	132
02e8b87f RR	133	DECLARE_EVENT_TABLE()
	134	};
	135
	136	//----------------------------------------------------------------------
	137	// main()
	138	//----------------------------------------------------------------------
	139
	140	IMPLEMENT_APP(MyApp)
	141
	142	//----------------------------------------------------------------------
	143	// MyApp
	144	//----------------------------------------------------------------------
	145
	146	enum
	147	{
b6a0d8a2 VZ	148	TEXT_QUIT = 100,
	149	TEXT_ABOUT,
	150	TEXT_LOAD,
	151
	152	// clipboard menu
	153	TEXT_CLIPBOARD_COPY = 200,
	154	TEXT_CLIPBOARD_PASTE,
02e8b87f RR	155
02e8b87f RR	156	// tooltip menu
b6a0d8a2 VZ	157	TEXT_TOOLTIPS_SETDELAY = 300,
	158	TEXT_TOOLTIPS_ENABLE,
	159
	160	// move menu
	161	TEXT_MOVE_ENDTEXT = 400,
	162	TEXT_MOVE_ENDENTRY
02e8b87f RR	163	};
	164
	165	bool MyApp::OnInit()
	166	{
	167	// Create the main frame window
	168	MyFrame frame = new MyFrame((wxFrame ) NULL,
	169	"Text wxWindows App",
	170	50, 50, 640, 420);
	171
02e8b87f	172	wxMenu *file_menu = new wxMenu;
b6a0d8a2 VZ	173	file_menu->Append(TEXT_LOAD, "&Load file\tCtrl-O",
	174	"Load the sample file into text control");
	175	file_menu->AppendSeparator();
	176	file_menu->Append(TEXT_ABOUT, "&About\tAlt-A");
	177	file_menu->AppendSeparator();
	178	file_menu->Append(TEXT_QUIT, "E&xit\tAlt-X", "Quit controls sample");
02e8b87f RR	179
	180	wxMenuBar *menu_bar = new wxMenuBar( wxMB_DOCKABLE );
	181	menu_bar->Append(file_menu, "&File");
	182
	183	#if wxUSE_TOOLTIPS
	184	wxMenu *tooltip_menu = new wxMenu;
b6a0d8a2	185	tooltip_menu->Append(TEXT_TOOLTIPS_SETDELAY, "Set &delay\tCtrl-D");
02e8b87f	186	tooltip_menu->AppendSeparator();
b6a0d8a2	187	tooltip_menu->Append(TEXT_TOOLTIPS_ENABLE, "&Toggle tooltips\tCtrl-T",
02e8b87f	188	"enable/disable tooltips", TRUE);
b6a0d8a2	189	tooltip_menu->Check(TEXT_TOOLTIPS_ENABLE, TRUE);
02e8b87f RR	190	menu_bar->Append(tooltip_menu, "&Tooltips");
	191	#endif // wxUSE_TOOLTIPS
	192
b6a0d8a2 VZ	193	#if wxUSE_CLIPBOARD
	194	wxMenu *menuClipboard = new wxMenu;
	195	menuClipboard->Append(TEXT_CLIPBOARD_COPY, "&Copy\tCtrl-C",
	196	"Copy the first line to the clipboard");
	197	menuClipboard->Append(TEXT_CLIPBOARD_PASTE, "&Paste\tCtrl-V",
	198	"Paste from clipboard to the text control");
	199	menu_bar->Append(menuClipboard, "&Clipboard");
	200	#endif // wxUSE_CLIPBOARD
	201
	202	wxMenu *menuMove = new wxMenu;
	203	menuMove->Append(TEXT_MOVE_ENDTEXT, "To the end of &text");
	204	menuMove->Append(TEXT_MOVE_ENDENTRY, "To the end of &entry");
	205	menu_bar->Append(menuMove, "&Move");
	206
02e8b87f RR	207	frame->SetMenuBar(menu_bar);
	208
	209	frame->Show(TRUE);
	210
	211	SetTopWindow(frame);
	212
	213	// report success
	214	return TRUE;
	215	}
	216
	217	//----------------------------------------------------------------------
	218	// MyTextCtrl
	219	//----------------------------------------------------------------------
	220
	221	BEGIN_EVENT_TABLE(MyTextCtrl, wxTextCtrl)
	222	EVT_KEY_DOWN(MyTextCtrl::OnKeyDown)
	223	EVT_KEY_UP(MyTextCtrl::OnKeyUp)
	224	EVT_CHAR(MyTextCtrl::OnChar)
	225	END_EVENT_TABLE()
	226
	227	void MyTextCtrl::LogEvent(const wxChar *name, wxKeyEvent& event) const
	228	{
	229	wxString key;
	230	long keycode = event.KeyCode();
	231	if ( wxIsprint((int)keycode) )
	232	key.Printf( _T("'%c'") , (char)keycode);
	233	else
	234	{
	235	switch ( keycode )
	236	{
	237	case WXK_BACK: key = "BACK"; break;
	238	case WXK_TAB: key = "TAB"; break;
	239	case WXK_RETURN: key = "RETURN"; break;
	240	case WXK_ESCAPE: key = "ESCAPE"; break;
	241	case WXK_SPACE: key = "SPACE"; break;
	242	case WXK_DELETE: key = "DELETE"; break;
	243	case WXK_START: key = "START"; break;
	244	case WXK_LBUTTON: key = "LBUTTON"; break;
	245	case WXK_RBUTTON: key = "RBUTTON"; break;
	246	case WXK_CANCEL: key = "CANCEL"; break;
	247	case WXK_MBUTTON: key = "MBUTTON"; break;
	248	case WXK_CLEAR: key = "CLEAR"; break;
	249	case WXK_SHIFT: key = "SHIFT"; break;
	250	case WXK_ALT: key = "ALT"; break;
	251	case WXK_CONTROL: key = "CONTROL"; break;
	252	case WXK_MENU: key = "MENU"; break;
	253	case WXK_PAUSE: key = "PAUSE"; break;
	254	case WXK_CAPITAL: key = "CAPITAL"; break;
	255	case WXK_PRIOR: key = "PRIOR"; break;
	256	case WXK_NEXT: key = "NEXT"; break;
	257	case WXK_END: key = "END"; break;
	258	case WXK_HOME: key = "HOME"; break;
	259	case WXK_LEFT: key = "LEFT"; break;
	260	case WXK_UP: key = "UP"; break;
	261	case WXK_RIGHT: key = "RIGHT"; break;
	262	case WXK_DOWN: key = "DOWN"; break;
	263	case WXK_SELECT: key = "SELECT"; break;
	264	case WXK_PRINT: key = "PRINT"; break;
	265	case WXK_EXECUTE: key = "EXECUTE"; break;
	266	case WXK_SNAPSHOT: key = "SNAPSHOT"; break;
	267	case WXK_INSERT: key = "INSERT"; break;
	268	case WXK_HELP: key = "HELP"; break;
	269	case WXK_NUMPAD0: key = "NUMPAD0"; break;
	270	case WXK_NUMPAD1: key = "NUMPAD1"; break;
271	case WXK_NUMPAD2: key = "NUMPAD2"; break;
272	case WXK_NUMPAD3: key = "NUMPAD3"; break;
273	case WXK_NUMPAD4: key = "NUMPAD4"; break;
274	case WXK_NUMPAD5: key = "NUMPAD5"; break;
275	case WXK_NUMPAD6: key = "NUMPAD6"; break;
276	case WXK_NUMPAD7: key = "NUMPAD7"; break;
277	case WXK_NUMPAD8: key = "NUMPAD8"; break;
278	case WXK_NUMPAD9: key = "NUMPAD9"; break;
279	case WXK_MULTIPLY: key = "MULTIPLY"; break;
280	case WXK_ADD: key = "ADD"; break;
281	case WXK_SEPARATOR: key = "SEPARATOR"; break;
282	case WXK_SUBTRACT: key = "SUBTRACT"; break;
283	case WXK_DECIMAL: key = "DECIMAL"; break;
284	case WXK_DIVIDE: key = "DIVIDE"; break;
285	case WXK_F1: key = "F1"; break;
286	case WXK_F2: key = "F2"; break;
287	case WXK_F3: key = "F3"; break;
288	case WXK_F4: key = "F4"; break;
289	case WXK_F5: key = "F5"; break;
290	case WXK_F6: key = "F6"; break;
291	case WXK_F7: key = "F7"; break;
292	case WXK_F8: key = "F8"; break;
293	case WXK_F9: key = "F9"; break;
294	case WXK_F10: key = "F10"; break;
295	case WXK_F11: key = "F11"; break;
296	case WXK_F12: key = "F12"; break;
297	case WXK_F13: key = "F13"; break;
298	case WXK_F14: key = "F14"; break;
299	case WXK_F15: key = "F15"; break;
300	case WXK_F16: key = "F16"; break;
301	case WXK_F17: key = "F17"; break;
302	case WXK_F18: key = "F18"; break;
303	case WXK_F19: key = "F19"; break;
304	case WXK_F20: key = "F20"; break;
305	case WXK_F21: key = "F21"; break;
306	case WXK_F22: key = "F22"; break;
307	case WXK_F23: key = "F23"; break;
308	case WXK_F24: key = "F24"; break;
309	case WXK_NUMLOCK: key = "NUMLOCK"; break;
310	case WXK_SCROLL: key = "SCROLL"; break;
311	case WXK_PAGEUP: key = "PAGEUP"; break;
312	case WXK_PAGEDOWN: key = "PAGEDOWN"; break;
313	case WXK_NUMPAD_SPACE: key = "NUMPAD_SPACE"; break;
314	case WXK_NUMPAD_TAB: key = "NUMPAD_TAB"; break;
315	case WXK_NUMPAD_ENTER: key = "NUMPAD_ENTER"; break;
316	case WXK_NUMPAD_F1: key = "NUMPAD_F1"; break;
317	case WXK_NUMPAD_F2: key = "NUMPAD_F2"; break;
318	case WXK_NUMPAD_F3: key = "NUMPAD_F3"; break;
319	case WXK_NUMPAD_F4: key = "NUMPAD_F4"; break;
320	case WXK_NUMPAD_HOME: key = "NUMPAD_HOME"; break;
321	case WXK_NUMPAD_LEFT: key = "NUMPAD_LEFT"; break;
322	case WXK_NUMPAD_UP: key = "NUMPAD_UP"; break;
323	case WXK_NUMPAD_RIGHT: key = "NUMPAD_RIGHT"; break;
324	case WXK_NUMPAD_DOWN: key = "NUMPAD_DOWN"; break;
325	case WXK_NUMPAD_PRIOR: key = "NUMPAD_PRIOR"; break;
326	case WXK_NUMPAD_PAGEUP: key = "NUMPAD_PAGEUP"; break;
327	case WXK_NUMPAD_PAGEDOWN: key = "NUMPAD_PAGEDOWN"; break;
328	case WXK_NUMPAD_END: key = "NUMPAD_END"; break;
329	case WXK_NUMPAD_BEGIN: key = "NUMPAD_BEGIN"; break;
330	case WXK_NUMPAD_INSERT: key = "NUMPAD_INSERT"; break;
331	case WXK_NUMPAD_DELETE: key = "NUMPAD_DELETE"; break;
332	case WXK_NUMPAD_EQUAL: key = "NUMPAD_EQUAL"; break;
333	case WXK_NUMPAD_MULTIPLY: key = "NUMPAD_MULTIPLY"; break;
334	case WXK_NUMPAD_ADD: key = "NUMPAD_ADD"; break;
335	case WXK_NUMPAD_SEPARATOR: key = "NUMPAD_SEPARATOR"; break;
336	case WXK_NUMPAD_SUBTRACT: key = "NUMPAD_SUBTRACT"; break;
337	case WXK_NUMPAD_DECIMAL: key = "NUMPAD_DECIMAL"; break;
338
339	default:
340	key.Printf( _T("unknown (%ld)"), keycode);
341	}
342	}
343
344	wxLogMessage( _T("%s event: %s (flags = %c%c%c%c)"),
345	name,
346	key.c_str(),
347	GetChar( event.ControlDown(), _T('C') ),
348	GetChar( event.AltDown(), _T('A') ),
349	GetChar( event.ShiftDown(), _T('S') ),
350	GetChar( event.MetaDown(), _T('M') ) );
351
352	}
353
354	void MyTextCtrl::OnChar(wxKeyEvent& event)
355	{
356	LogEvent( _T("Char"), event);
357
b6a0d8a2 VZ	358	if ( event.KeyCode() == WXK_TAB )
	359	{
	360	WriteText("\t");
	361	}
	362	else
	363	{
	364	event.Skip();
	365	}
02e8b87f RR	366	}
	367
	368	void MyTextCtrl::OnKeyUp(wxKeyEvent& event)
	369	{
	370	LogEvent( _("Key up"), event);
	371
	372	event.Skip();
	373	}
	374
	375	void MyTextCtrl::OnKeyDown(wxKeyEvent& event)
	376	{
	377	switch ( event.KeyCode() )
	378	{
	379	case WXK_F1:
	380	// show current position and text length
	381	{
	382	long line, column, pos = GetInsertionPoint();
	383	PositionToXY(pos, &column, &line);
	384
	385	wxLogMessage( _T("Current position: %ld\n"
	386	"Current line, column: (%ld, %ld)\n"
	387	"Number of lines: %ld\n"
	388	"Current line length: %ld\n"
	389	"Total text length: %ld"),
	390	pos,
	391	line, column,
	392	GetNumberOfLines(),
	393	GetLineLength(line),
	394	GetLastPosition());
	395	}
	396	break;
	397
	398	case WXK_F2:
	399	// go to the end
	400	SetInsertionPointEnd();
	401	break;
	402
	403	case WXK_F3:
	404	// go to position 10
	405	SetInsertionPoint(10);
	406	break;
	407	}
	408
	409	LogEvent( _("Key down"), event);
	410
	411	event.Skip();
	412	}
	413
	414	//----------------------------------------------------------------------
	415	// MyPanel
	416	//----------------------------------------------------------------------
	417
02e8b87f RR	418	MyPanel::MyPanel( wxFrame *frame, int x, int y, int w, int h )
	419	: wxPanel( frame, -1, wxPoint(x, y), wxSize(w, h) )
	420	{
	421	m_log = new wxTextCtrl( this, -1, "This is the log window.\n", wxPoint(5,260), wxSize(630,100), wxTE_MULTILINE );
	422
	423	delete wxLog::SetActiveTarget(new wxLogStderr);
	424
	425	// single line text controls
	426
bb69661b	427	m_text = new MyTextCtrl( this, -1, "Single line.",
02e8b87f RR	428	wxPoint(10,10), wxSize(140,-1), 0);
	429	(*m_text) << " Appended.";
	430	m_text->SetInsertionPoint(0);
	431	m_text->WriteText( "Prepended. " );
bb69661b VZ	432
bb69661b VZ	433	m_password = new MyTextCtrl( this, -1, "",
02e8b87f	434	wxPoint(10,50), wxSize(140,-1), wxTE_PASSWORD );
bb69661b VZ	435
bb69661b VZ	436	m_readonly = new MyTextCtrl( this, -1, "Read only",
02e8b87f	437	wxPoint(10,90), wxSize(140,-1), wxTE_READONLY );
bb69661b	438
02e8b87f RR	439	// multi line text controls
02e8b87f RR	440
bb69661b VZ	441	m_horizontal = new MyTextCtrl( this, -1, "Multiline text control with a horizontal scrollbar.",
	442	wxPoint(10,170), wxSize(140,70), wxTE_MULTILINE \| wxHSCROLL );
	443	m_horizontal->SetFont(wxFont(18, wxSWISS, wxNORMAL, wxBOLD));
	444
5e3dad49	445	m_multitext = new MyTextCtrl( this, -1, "Multi line.",
02e8b87f RR	446	wxPoint(180,10), wxSize(240,70), wxTE_MULTILINE );
	447	(*m_multitext) << " Appended.";
	448	m_multitext->SetInsertionPoint(0);
	449	m_multitext->WriteText( "Prepended. " );
bb69661b	450
02e8b87f RR	451	#if wxUSE_TOOLTIPS
	452	m_multitext->SetToolTip("Press F1 here.");
	453	#endif
	454
bb69661b	455	m_tab = new MyTextCtrl( this, -1, "Multiline, allow <TAB> processing.",
02e8b87f RR	456	wxPoint(180,90), wxSize(240,70), wxTE_MULTILINE \| wxTE_PROCESS_TAB );
02e8b87f RR	457
b6a0d8a2 VZ	458	m_enter = new MyTextCtrl( this, -1, "Multiline, allow <ENTER> processing.",
b6a0d8a2 VZ	459	wxPoint(180,170), wxSize(240,70), wxTE_MULTILINE);
02e8b87f RR	460	}
02e8b87f RR	461
b6a0d8a2 VZ	462	#if wxUSE_CLIPBOARD
b6a0d8a2 VZ	463	void MyPanel::DoPasteFromClipboard()
02e8b87f	464	{
7e2c43b8 RR	465	// On X11, we want to get the data from the primary selection instead
	466	// of the normal clipboard (which isn't normal under X11 at all). This
	467	// call has no effect under MSW.
	468	wxTheClipboard->UsePrimarySelection();
	469
02e8b87f RR	470	if (!wxTheClipboard->Open())
	471	{
	472	*m_log << "Error opening the clipboard.\n";
02e8b87f RR	473	return;
	474	}
	475	else
	476	{
	477	*m_log << "Successfully opened the clipboard.\n";
	478	}
	479
	480	wxTextDataObject data;
	481
	482	if (wxTheClipboard->IsSupported( data.GetFormat() ))
	483	{
	484	*m_log << "Clipboard supports requested format.\n";
	485
	486	if (wxTheClipboard->GetData( &data ))
	487	{
	488	*m_log << "Successfully retrieved data from the clipboard.\n";
	489	*m_multitext << data.GetText() << "\n";
	490	}
	491	else
	492	{
	493	*m_log << "Error getting data from the clipboard.\n";
	494	}
	495	}
	496	else
	497	{
	498	*m_log << "Clipboard doesn't support requested format.\n";
	499	}
	500
	501	wxTheClipboard->Close();
	502
	503	*m_log << "Closed the clipboard.\n";
02e8b87f RR	504	}
02e8b87f RR	505
b6a0d8a2	506	void MyPanel::DoCopyToClipboard()
02e8b87f	507	{
02e8b87f RR	508	wxString text( m_multitext->GetLineText(0) );
	509
	510	if (text.IsEmpty())
	511	{
	512	*m_log << "No text to copy.\n";
	513
	514	return;
	515	}
	516
	517	if (!wxTheClipboard->Open())
	518	{
	519	*m_log << "Error opening the clipboard.\n";
	520
	521	return;
	522	}
	523	else
	524	{
	525	*m_log << "Successfully opened the clipboard.\n";
	526	}
	527
	528	wxTextDataObject *data = new wxTextDataObject( text );
	529
	530	if (!wxTheClipboard->SetData( data ))
	531	{
	532	*m_log << "Error while copying to the clipboard.\n";
	533	}
	534	else
	535	{
	536	*m_log << "Successfully copied data to the clipboard.\n";
	537	}
	538
	539	wxTheClipboard->Close();
	540
	541	*m_log << "Closed the clipboard.\n";
02e8b87f RR	542	}
02e8b87f RR	543
b6a0d8a2 VZ	544	#endif // wxUSE_CLIPBOARD
	545
	546	void MyPanel::DoMoveToEndOfText()
02e8b87f RR	547	{
	548	m_multitext->SetInsertionPointEnd();
	549	m_multitext->SetFocus();
	550	}
	551
b6a0d8a2	552	void MyPanel::DoMoveToEndOfEntry()
02e8b87f RR	553	{
	554	m_text->SetInsertionPointEnd();
	555	m_text->SetFocus();
	556	}
	557
	558	//----------------------------------------------------------------------
	559	// MyFrame
	560	//----------------------------------------------------------------------
	561
	562	BEGIN_EVENT_TABLE(MyFrame, wxFrame)
b6a0d8a2 VZ	563	EVT_MENU(TEXT_QUIT, MyFrame::OnQuit)
	564	EVT_MENU(TEXT_ABOUT, MyFrame::OnAbout)
	565	EVT_MENU(TEXT_LOAD, MyFrame::OnFileLoad)
	566
02e8b87f	567	#if wxUSE_TOOLTIPS
b6a0d8a2 VZ	568	EVT_MENU(TEXT_TOOLTIPS_SETDELAY, MyFrame::OnSetTooltipDelay)
b6a0d8a2 VZ	569	EVT_MENU(TEXT_TOOLTIPS_ENABLE, MyFrame::OnToggleTooltips)
02e8b87f	570	#endif // wxUSE_TOOLTIPS
b6a0d8a2 VZ	571
	572	EVT_MENU(TEXT_CLIPBOARD_PASTE, MyFrame::OnPasteFromClipboard)
	573	EVT_MENU(TEXT_CLIPBOARD_COPY, MyFrame::OnCopyToClipboard)
	574	EVT_MENU(TEXT_MOVE_ENDTEXT, MyFrame::OnMoveToEndOfText)
	575	EVT_MENU(TEXT_MOVE_ENDENTRY, MyFrame::OnMoveToEndOfEntry)
	576
	577	EVT_IDLE(MyFrame::OnIdle)
02e8b87f RR	578	END_EVENT_TABLE()
02e8b87f RR	579
b6a0d8a2 VZ	580	MyFrame::MyFrame(wxFrame frame, const char title, int x, int y, int w, int h)
b6a0d8a2 VZ	581	: wxFrame(frame, -1, title, wxPoint(x, y), wxSize(w, h) )
02e8b87f RR	582	{
	583	CreateStatusBar(2);
	584
b6a0d8a2	585	m_panel = new MyPanel( this, 10, 10, 300, 100 );
02e8b87f RR	586	}
	587
	588	void MyFrame::OnQuit (wxCommandEvent& WXUNUSED(event) )
	589	{
	590	Close(TRUE);
	591	}
	592
	593	void MyFrame::OnAbout( wxCommandEvent& WXUNUSED(event) )
	594	{
	595	wxBeginBusyCursor();
	596
b6a0d8a2 VZ	597	wxMessageDialog dialog(this,
	598	"This is a text control sample. It demonstrates the many different\n"
	599	"text control styles, the use of the clipboard, setting and handling\n"
	600	"tooltips and intercepting key and char events.\n"
	601	"\n"
	602	"Copyright (c) 1999, Robert Roebling, Julian Smart, Vadim Zeitlin",
	603	"About Text Controls",
	604	wxOK \| wxICON_INFORMATION);
	605
02e8b87f RR	606	dialog.ShowModal();
	607
	608	wxEndBusyCursor();
	609	}
	610
	611	#if wxUSE_TOOLTIPS
	612	void MyFrame::OnSetTooltipDelay(wxCommandEvent& event)
	613	{
	614	static long s_delay = 5000;
	615
	616	wxString delay;
	617	delay.Printf( _T("%ld"), s_delay);
	618
	619	delay = wxGetTextFromUser("Enter delay (in milliseconds)",
bb69661b VZ	620	"Set tooltip delay",
	621	delay,
	622	this);
02e8b87f RR	623	if ( !delay )
	624	return; // cancelled
	625
	626	wxSscanf(delay, _T("%ld"), &s_delay);
	627
	628	wxToolTip::SetDelay(s_delay);
	629
	630	wxLogStatus(this, _T("Tooltip delay set to %ld milliseconds"), s_delay);
	631	}
	632
	633	void MyFrame::OnToggleTooltips(wxCommandEvent& event)
	634	{
	635	static bool s_enabled = TRUE;
	636
	637	s_enabled = !s_enabled;
	638
	639	wxToolTip::Enable(s_enabled);
	640
	641	wxLogStatus(this, _T("Tooltips %sabled"), s_enabled ? _T("en") : _T("dis") );
	642	}
	643	#endif // tooltips
	644
b6a0d8a2 VZ	645	void MyFrame::OnFileLoad(wxCommandEvent& event)
b6a0d8a2 VZ	646	{
5e3dad49 VZ	647	if ( m_panel->m_multitext->LoadFile("controls.cpp") )
	648	wxLogStatus(this, _T("Successfully loaded file"));
	649	else
	650	wxLogStatus(this, _T("Couldn't load the file"));
b6a0d8a2 VZ	651	}
b6a0d8a2 VZ	652
02e8b87f RR	653	void MyFrame::OnIdle( wxIdleEvent& event )
	654	{
	655	// track the window which has the focus in the status bar
	656	static wxWindow s_windowFocus = (wxWindow )NULL;
	657	wxWindow *focus = wxWindow::FindFocus();
	658	if ( focus && (focus != s_windowFocus) )
	659	{
	660	s_windowFocus = focus;
	661
	662	wxString msg;
	663	msg.Printf(
	664	#ifdef __WXMSW__
	665	_T("Focus: wxWindow = %p, HWND = %08x"),
	666	#else
	667	_T("Focus: wxWindow = %p"),
	668	#endif
	669	s_windowFocus
	670	#ifdef __WXMSW__
	671	, s_windowFocus->GetHWND()
	672	#endif
	673	);
	674
	675	SetStatusText(msg);
	676	}
	677	event.Skip();
	678	}