src/os2/app.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/os2/app.cpp
// Purpose:     wxApp
// Author:      David Webster
// Modified by:
// Created:     10/13/99
// RCS-ID:      $Id$
// Copyright:   (c) David Webster
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#include "wx/app.h"

#ifndef WX_PRECOMP
    #include "wx/dynarray.h"
    #include "wx/frame.h"
    #include "wx/utils.h"
    #include "wx/gdicmn.h"
    #include "wx/pen.h"
    #include "wx/brush.h"
    #include "wx/cursor.h"
    #include "wx/icon.h"
    #include "wx/palette.h"
    #include "wx/dc.h"
    #include "wx/dialog.h"
    #include "wx/msgdlg.h"
    #include "wx/intl.h"
    #include "wx/crt.h"
    #include "wx/log.h"
    #include "wx/module.h"
#endif

#include "wx/stdpaths.h"
#include "wx/filename.h"
#include "wx/evtloop.h"

#include "wx/os2/private.h"

#ifdef __EMX__

#include <sys/ioctl.h>
#include <sys/select.h>

#else

#include <nerrno.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>

#endif //

#if defined(__WATCOMC__)

#include <tcpustd.h>

#elif !defined(__EMX__)

#define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
extern "C" int _System bsdselect(int,
                                 struct fd_set *,
                                 struct fd_set *,
                                 struct fd_set *,
                                 struct timeval *);
#endif

#if wxUSE_THREADS
    #include "wx/thread.h"
#endif // wxUSE_THREADS

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

#include <string.h>
#include <ctype.h>

// ---------------------------------------------------------------------------
// global variables
// ---------------------------------------------------------------------------

WXDLLEXPORT_DATA(wxChar*) wxBuffer;
extern wxCursor*                    g_globalCursor;

HAB                                 vHabmain = NULLHANDLE;


HICON wxSTD_FRAME_ICON          = (HICON) NULL;
HICON wxSTD_MDICHILDFRAME_ICON  = (HICON) NULL;
HICON wxSTD_MDIPARENTFRAME_ICON = (HICON) NULL;

HICON wxDEFAULT_FRAME_ICON           = (HICON) NULL;
HICON wxDEFAULT_MDICHILDFRAME_ICON   = (HICON) NULL;
HICON wxDEFAULT_MDIPARENTFRAME_ICON  = (HICON) NULL;

HBRUSH wxDisableButtonBrush = (HBRUSH) 0;

MRESULT EXPENTRY wxWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
MRESULT EXPENTRY wxFrameWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);

// ===========================================================================
// implementation
// ===========================================================================

// ---------------------------------------------------------------------------
// helper struct and functions for socket handling
// ---------------------------------------------------------------------------

struct GsocketCallbackInfo{
    void (*proc)(void *);
    int type;
    int handle;
    void* gsock;
};

// These defines are used here and in gsockpm.cpp
#define wxSockReadMask  0x01
#define wxSockWriteMask 0x02

void wxApp::HandleSockets()
{
    bool pendingEvent = false;

    // Check whether it's time for Gsocket operation
    if (m_maxSocketHandles > 0 && m_maxSocketNr > 0)
    {
        fd_set readfds = m_readfds;
        fd_set writefds = m_writefds;
        struct timeval timeout;
        int i;
        struct GsocketCallbackInfo
          *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
        timeout.tv_sec = 0;
        timeout.tv_usec = 0;
        if ( select(m_maxSocketNr, &readfds, &writefds, 0, &timeout) > 0)
        {
            for (i = m_lastUsedHandle + 1; i != m_lastUsedHandle;
                 (i < m_maxSocketNr - 1) ? i++ : (i = 0))
            {
                if (FD_ISSET(i, &readfds))
                {
                    int r;
                    for (r = 0; r < m_maxSocketHandles; r++){
                        if(CallbackInfo[r].handle == i &&
                           CallbackInfo[r].type == wxSockReadMask)
                            break;
                    }
                    if (r < m_maxSocketHandles)
                    {
                        CallbackInfo[r].proc(CallbackInfo[r].gsock);
                        pendingEvent = true;
                    }
                }
                if (FD_ISSET(i, &writefds))
                {
                    int r;
                    for (r = 0; r < m_maxSocketHandles; r++)
                        if(CallbackInfo[r].handle == i &&
                           CallbackInfo[r].type == wxSockWriteMask)
                            break;
                    if (r < m_maxSocketHandles)
                    {
                        CallbackInfo[r].proc(CallbackInfo[r].gsock);
                        pendingEvent = true;
                    }
                }
            }
            m_lastUsedHandle = i;
        }
        if (pendingEvent)
            ProcessPendingEvents();
    }
}
// ---------------------------------------------------------------------------
// wxApp
// ---------------------------------------------------------------------------

    IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)

    BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
        EVT_IDLE(wxApp::OnIdle)
        EVT_END_SESSION(wxApp::OnEndSession)
        EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
    END_EVENT_TABLE()

//
// Initialize
//
bool wxApp::Initialize(int& argc, wxChar **argv)
{
    if ( !wxAppBase::Initialize(argc, argv) )
        return false;

#if defined(wxUSE_CONSOLEDEBUG)
  #if wxUSE_CONSOLEDEBUG
/***********************************************/
/* Code for using stdout debug                 */
/* To use it you mast link app as "Window" - EK*/
/***********************************************/
  {
     PPIB pib;
     PTIB tib;

    printf("In console\n");

  DosGetInfoBlocks(&tib, &pib);
/* Try morphing into a PM application. */
//  if(pib->pib_ultype == 2)    /* VIO */
    pib->pib_ultype = 3;
   }
/**********************************************/
/**********************************************/
  #endif //wxUSE_CONSOLEDEBUG
#endif

    //
    // OS2 has to have an anchorblock
    //
    vHabmain = WinInitialize(0);
    wxFileName GetPrefix(argv[0]);
    GetPrefix.MakeAbsolute();
    wxStandardPaths::SetInstallPrefix(GetPrefix.GetPath());
    if (!vHabmain)
    {
        // TODO: at least give some error message here...
        wxAppBase::CleanUp();

        return false;
    }

    wxBuffer = new wxChar[1500]; // FIXME; why?

    // Some people may wish to use this, but
    // probably it shouldn't be here by default.
    //    wxRedirectIOToConsole();

    wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);

    // This is to foil optimizations in Visual C++ that throw out dummy.obj.
    // PLEASE DO NOT ALTER THIS.
#if !defined(WXMAKINGDLL) && defined(__VISAGECPP__)
    extern char wxDummyChar;
    if (wxDummyChar) wxDummyChar++;
#endif

    // wxSetKeyboardHook(TRUE);

    RegisterWindowClasses(vHabmain);

    return true;
} // end of wxApp::Initialize

const char*                         CANTREGISTERCLASS = " Can't register Class ";
// ---------------------------------------------------------------------------
// RegisterWindowClasses
// ---------------------------------------------------------------------------

bool wxApp::RegisterWindowClasses( HAB vHab )
{
    ERRORID vError = 0L;
    wxString sError;

    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxFrameClassName
                            ,wxFrameWndProc
                            ,CS_SIZEREDRAW | CS_SYNCPAINT
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }

    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxFrameClassNameNoRedraw
                            ,wxWndProc
                            ,0
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }

    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxMDIFrameClassName
                            ,wxWndProc
                            ,CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }

    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxMDIFrameClassNameNoRedraw
                            ,wxWndProc
                            ,0
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }

    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxMDIChildFrameClassName
                            ,wxWndProc
                            ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }

    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxMDIChildFrameClassNameNoRedraw
                            ,wxWndProc
                            ,CS_HITTEST
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }

    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxPanelClassName
                            ,wxWndProc
                            ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }

    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxCanvasClassName
                            ,wxWndProc
                            ,CS_SIZEREDRAW | CS_HITTEST | CS_SYNCPAINT
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }
    if (!::WinRegisterClass( vHab
                            ,(PSZ)wxCanvasClassNameNR
                            ,wxWndProc
                            ,CS_HITTEST | CS_SYNCPAINT
                            ,sizeof(ULONG)
                           ))
    {
        vError = ::WinGetLastError(vHab);
        sError = wxPMErrorToStr(vError);
        wxLogLastError(sError.c_str());
        return false;
    }
    return true;
} // end of wxApp::RegisterWindowClasses

//
// Cleans up any wxWidgets internal structures left lying around
//
void wxApp::CleanUp()
{
    delete[] wxBuffer;
    wxBuffer = NULL;

    //
    // PM-SPECIFIC CLEANUP
    //

    // wxSetKeyboardHook(false);

    if (wxSTD_FRAME_ICON)
        ::WinFreeFileIcon(wxSTD_FRAME_ICON);
    if (wxSTD_MDICHILDFRAME_ICON)
        ::WinFreeFileIcon(wxSTD_MDICHILDFRAME_ICON);
    if (wxSTD_MDIPARENTFRAME_ICON)
        ::WinFreeFileIcon(wxSTD_MDIPARENTFRAME_ICON);

    if (wxDEFAULT_FRAME_ICON)
        ::WinFreeFileIcon(wxDEFAULT_FRAME_ICON);
    if (wxDEFAULT_MDICHILDFRAME_ICON)
        ::WinFreeFileIcon(wxDEFAULT_MDICHILDFRAME_ICON);
    if (wxDEFAULT_MDIPARENTFRAME_ICON)
        ::WinFreeFileIcon(wxDEFAULT_MDIPARENTFRAME_ICON);

    if ( wxDisableButtonBrush )
    {
// TODO:        ::DeleteObject( wxDisableButtonBrush );
    }

    delete wxWinHandleHash;
    wxWinHandleHash = NULL;

    // Delete Message queue
    if (wxTheApp->m_hMq)
        ::WinDestroyMsgQueue(wxTheApp->m_hMq);

    wxAppBase::CleanUp();
} // end of wxApp::CleanUp

bool wxApp::OnInitGui()
{
    ERRORID vError;
    wxString sError;

    if (!wxAppBase::OnInitGui())
        return false;

    m_hMq = ::WinCreateMsgQueue(vHabmain, 0);
    if (!m_hMq)
    {
        vError = ::WinGetLastError(vHabmain);
        sError = wxPMErrorToStr(vError);
        wxLogDebug(sError);
        return false;
    }

    return true;
} // end of wxApp::OnInitGui

wxApp::wxApp()
{
    m_nPrintMode = wxPRINT_WINDOWS;
    m_hMq = 0;
    m_maxSocketHandles = 0;
    m_maxSocketNr = 0;
    m_sockCallbackInfo = 0;
} // end of wxApp::wxApp

wxApp::~wxApp()
{
} // end of wxApp::~wxApp

bool gbInOnIdle = false;

void wxApp::OnIdle( wxIdleEvent& WXUNUSED(rEvent) )
{
    //
    // Avoid recursion (via ProcessEvent default case)
    //
    if (gbInOnIdle)
        return;

    gbInOnIdle = true;

#if wxUSE_DC_CACHEING
    // automated DC cache management: clear the cached DCs and bitmap
    // if it's likely that the app has finished with them, that is, we
    // get an idle event and we're not dragging anything.
    if (!::WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) &&
        !::WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) &&
        !::WinGetKeyState(HWND_DESKTOP, VK_BUTTON2))
        wxDC::ClearCache();
#endif // wxUSE_DC_CACHEING

    gbInOnIdle = false;
} // end of wxApp::OnIdle

void wxApp::OnEndSession(
  wxCloseEvent&                     WXUNUSED(rEvent))
{
    if (GetTopWindow())
        GetTopWindow()->Close(true);
} // end of wxApp::OnEndSession

//
// Default behaviour: close the application with prompts. The
// user can veto the close, and therefore the end session.
//
void wxApp::OnQueryEndSession( wxCloseEvent& rEvent )
{
    if (GetTopWindow())
    {
        if (!GetTopWindow()->Close(!rEvent.CanVeto()))
            rEvent.Veto(true);
    }
} // end of wxApp::OnQueryEndSession

int wxApp::AddSocketHandler(int handle, int mask,
                            void (*callback)(void*), void * gsock)
{
    int find;
    struct GsocketCallbackInfo
        *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;

    for (find = 0; find < m_maxSocketHandles; find++)
        if (CallbackInfo[find].handle == -1)
            break;
    if (find == m_maxSocketHandles)
    {
        // Allocate new memory
        m_sockCallbackInfo = realloc(m_sockCallbackInfo,
                                     (m_maxSocketHandles+=10)*
                                     sizeof(struct GsocketCallbackInfo));
        CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
        for (find = m_maxSocketHandles - 10; find < m_maxSocketHandles; find++)
            CallbackInfo[find].handle = -1;
        find = m_maxSocketHandles - 10;
    }
    CallbackInfo[find].proc = callback;
    CallbackInfo[find].type = mask;
    CallbackInfo[find].handle = handle;
    CallbackInfo[find].gsock = gsock;
    if (mask & wxSockReadMask)
        FD_SET(handle, &m_readfds);
    if (mask & wxSockWriteMask)
        FD_SET(handle, &m_writefds);
    if (handle >= m_maxSocketNr)
        m_maxSocketNr = handle + 1;
    return find;
}

void wxApp::RemoveSocketHandler(int handle)
{
    struct GsocketCallbackInfo
        *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
    if (handle < m_maxSocketHandles)
    {
        if (CallbackInfo[handle].type & wxSockReadMask)
            FD_CLR(CallbackInfo[handle].handle, &m_readfds);
        if (CallbackInfo[handle].type & wxSockWriteMask)
            FD_CLR(CallbackInfo[handle].handle, &m_writefds);
        CallbackInfo[handle].handle = -1;
    }
}

//-----------------------------------------------------------------------------
// wxWakeUpIdle
//-----------------------------------------------------------------------------

void wxApp::WakeUpIdle()
{
    //
    // Send the top window a dummy message so idle handler processing will
    // start up again.  Doing it this way ensures that the idle handler
    // wakes up in the right thread (see also wxWakeUpMainThread() which does
    // the same for the main app thread only)
    //
    wxWindow*                       pTopWindow = wxTheApp->GetTopWindow();

    if (pTopWindow)
    {
        if ( !::WinPostMsg(GetHwndOf(pTopWindow), WM_NULL, (MPARAM)0, (MPARAM)0))
        {
            //
            // Should never happen
            //
            wxLogLastError(wxT("PostMessage(WM_NULL)"));
        }
    }
} // end of wxWakeUpIdle

HAB wxGetInstance()
{
    return vHabmain;
}

void wxSetInstance( HAB vHab )
{
    vHabmain = vHab;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/os2/app.cpp
	3	// Purpose: wxApp
	4	// Author: David Webster
	5	// Modified by:
	6	// Created: 10/13/99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) David Webster
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#include "wx/app.h"
	16
	17	#ifndef WX_PRECOMP
	18	#include "wx/dynarray.h"
	19	#include "wx/frame.h"
	20	#include "wx/utils.h"
	21	#include "wx/gdicmn.h"
	22	#include "wx/pen.h"
	23	#include "wx/brush.h"
	24	#include "wx/cursor.h"
	25	#include "wx/icon.h"
	26	#include "wx/palette.h"
	27	#include "wx/dc.h"
	28	#include "wx/dialog.h"
	29	#include "wx/msgdlg.h"
	30	#include "wx/intl.h"
	31	#include "wx/crt.h"
	32	#include "wx/log.h"
	33	#include "wx/module.h"
	34	#endif
	35
	36	#include "wx/stdpaths.h"
	37	#include "wx/filename.h"
	38	#include "wx/evtloop.h"
	39
	40	#include "wx/os2/private.h"
	41
	42	#ifdef __EMX__
	43
	44	#include <sys/ioctl.h>
	45	#include <sys/select.h>
	46
	47	#else
	48
	49	#include <nerrno.h>
	50	#include <sys/ioctl.h>
	51	#include <sys/select.h>
	52	#include <sys/time.h>
	53
	54	#endif //
	55
	56	#if defined(__WATCOMC__)
	57
	58	#include <tcpustd.h>
	59
	60	#elif !defined(__EMX__)
	61
	62	#define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
	63	extern "C" int _System bsdselect(int,
	64	struct fd_set *,
	65	struct fd_set *,
	66	struct fd_set *,
	67	struct timeval *);
	68	#endif
	69
	70	#if wxUSE_THREADS
	71	#include "wx/thread.h"
	72	#endif // wxUSE_THREADS
	73
	74	#if wxUSE_TOOLTIPS
	75	#include "wx/tooltip.h"
	76	#endif // wxUSE_TOOLTIPS
	77
	78	#include <string.h>
	79	#include <ctype.h>
	80
	81	// ---------------------------------------------------------------------------
	82	// global variables
	83	// ---------------------------------------------------------------------------
	84
	85	WXDLLEXPORT_DATA(wxChar*) wxBuffer;
	86	extern wxCursor* g_globalCursor;
	87
	88	HAB vHabmain = NULLHANDLE;
	89
	90
	91	HICON wxSTD_FRAME_ICON = (HICON) NULL;
	92	HICON wxSTD_MDICHILDFRAME_ICON = (HICON) NULL;
	93	HICON wxSTD_MDIPARENTFRAME_ICON = (HICON) NULL;
	94
	95	HICON wxDEFAULT_FRAME_ICON = (HICON) NULL;
	96	HICON wxDEFAULT_MDICHILDFRAME_ICON = (HICON) NULL;
	97	HICON wxDEFAULT_MDIPARENTFRAME_ICON = (HICON) NULL;
	98
	99	HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
	100
	101	MRESULT EXPENTRY wxWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
	102	MRESULT EXPENTRY wxFrameWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
	103
	104	// ===========================================================================
	105	// implementation
	106	// ===========================================================================
	107
	108	// ---------------------------------------------------------------------------
	109	// helper struct and functions for socket handling
	110	// ---------------------------------------------------------------------------
	111
	112	struct GsocketCallbackInfo{
	113	void (proc)(void );
	114	int type;
	115	int handle;
	116	void* gsock;
	117	};
	118
	119	// These defines are used here and in gsockpm.cpp
	120	#define wxSockReadMask 0x01
	121	#define wxSockWriteMask 0x02
	122
	123	void wxApp::HandleSockets()
	124	{
	125	bool pendingEvent = false;
	126
	127	// Check whether it's time for Gsocket operation
	128	if (m_maxSocketHandles > 0 && m_maxSocketNr > 0)
	129	{
	130	fd_set readfds = m_readfds;
	131	fd_set writefds = m_writefds;
	132	struct timeval timeout;
	133	int i;
	134	struct GsocketCallbackInfo
	135	CallbackInfo = (struct GsocketCallbackInfo )m_sockCallbackInfo;
	136	timeout.tv_sec = 0;
	137	timeout.tv_usec = 0;
	138	if ( select(m_maxSocketNr, &readfds, &writefds, 0, &timeout) > 0)
	139	{
	140	for (i = m_lastUsedHandle + 1; i != m_lastUsedHandle;
	141	(i < m_maxSocketNr - 1) ? i++ : (i = 0))
	142	{
	143	if (FD_ISSET(i, &readfds))
	144	{
	145	int r;
	146	for (r = 0; r < m_maxSocketHandles; r++){
	147	if(CallbackInfo[r].handle == i &&
	148	CallbackInfo[r].type == wxSockReadMask)
	149	break;
	150	}
	151	if (r < m_maxSocketHandles)
	152	{
	153	CallbackInfo[r].proc(CallbackInfo[r].gsock);
	154	pendingEvent = true;
	155	}
	156	}
	157	if (FD_ISSET(i, &writefds))
	158	{
	159	int r;
	160	for (r = 0; r < m_maxSocketHandles; r++)
	161	if(CallbackInfo[r].handle == i &&
	162	CallbackInfo[r].type == wxSockWriteMask)
	163	break;
	164	if (r < m_maxSocketHandles)
	165	{
	166	CallbackInfo[r].proc(CallbackInfo[r].gsock);
	167	pendingEvent = true;
	168	}
	169	}
	170	}
	171	m_lastUsedHandle = i;
	172	}
	173	if (pendingEvent)
	174	ProcessPendingEvents();
	175	}
	176	}
	177	// ---------------------------------------------------------------------------
	178	// wxApp
	179	// ---------------------------------------------------------------------------
	180
	181	IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
	182
	183	BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
	184	EVT_IDLE(wxApp::OnIdle)
	185	EVT_END_SESSION(wxApp::OnEndSession)
	186	EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
	187	END_EVENT_TABLE()
	188
	189	//
	190	// Initialize
	191	//
	192	bool wxApp::Initialize(int& argc, wxChar **argv)
	193	{
	194	if ( !wxAppBase::Initialize(argc, argv) )
	195	return false;
	196
	197	#if defined(wxUSE_CONSOLEDEBUG)
	198	#if wxUSE_CONSOLEDEBUG
	199	/***********************************************/
	200	/* Code for using stdout debug */
	201	/* To use it you mast link app as "Window" - EK*/
	202	/***********************************************/
	203	{
	204	PPIB pib;
	205	PTIB tib;
	206
	207	printf("In console\n");
	208
	209	DosGetInfoBlocks(&tib, &pib);
	210	/* Try morphing into a PM application. */
	211	// if(pib->pib_ultype == 2) /* VIO */
	212	pib->pib_ultype = 3;
	213	}
	214	/**********************************************/
	215	/**********************************************/
	216	#endif //wxUSE_CONSOLEDEBUG
	217	#endif
	218
	219	//
	220	// OS2 has to have an anchorblock
	221	//
	222	vHabmain = WinInitialize(0);
	223	wxFileName GetPrefix(argv[0]);
	224	GetPrefix.MakeAbsolute();
	225	wxStandardPaths::SetInstallPrefix(GetPrefix.GetPath());
	226	if (!vHabmain)
	227	{
	228	// TODO: at least give some error message here...
	229	wxAppBase::CleanUp();
	230
	231	return false;
	232	}
	233
	234	wxBuffer = new wxChar[1500]; // FIXME; why?
	235
	236	// Some people may wish to use this, but
	237	// probably it shouldn't be here by default.
	238	// wxRedirectIOToConsole();
	239
	240	wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
	241
	242	// This is to foil optimizations in Visual C++ that throw out dummy.obj.
	243	// PLEASE DO NOT ALTER THIS.
	244	#if !defined(WXMAKINGDLL) && defined(__VISAGECPP__)
	245	extern char wxDummyChar;
	246	if (wxDummyChar) wxDummyChar++;
	247	#endif
	248
	249	// wxSetKeyboardHook(TRUE);
	250
	251	RegisterWindowClasses(vHabmain);
	252
	253	return true;
	254	} // end of wxApp::Initialize
	255
	256	const char* CANTREGISTERCLASS = " Can't register Class ";
	257	// ---------------------------------------------------------------------------
	258	// RegisterWindowClasses
	259	// ---------------------------------------------------------------------------
	260
	261	bool wxApp::RegisterWindowClasses( HAB vHab )
	262	{
	263	ERRORID vError = 0L;
	264	wxString sError;
	265
	266	if (!::WinRegisterClass( vHab
	267	,(PSZ)wxFrameClassName
	268	,wxFrameWndProc
	269	,CS_SIZEREDRAW \| CS_SYNCPAINT
	270	,sizeof(ULONG)
	271	))
	272	{
	273	vError = ::WinGetLastError(vHab);
	274	sError = wxPMErrorToStr(vError);
	275	wxLogLastError(sError.c_str());
	276	return false;
	277	}
	278
	279	if (!::WinRegisterClass( vHab
	280	,(PSZ)wxFrameClassNameNoRedraw
	281	,wxWndProc
	282	,0
	283	,sizeof(ULONG)
	284	))
	285	{
	286	vError = ::WinGetLastError(vHab);
	287	sError = wxPMErrorToStr(vError);
	288	wxLogLastError(sError.c_str());
	289	return false;
	290	}
	291
	292	if (!::WinRegisterClass( vHab
	293	,(PSZ)wxMDIFrameClassName
	294	,wxWndProc
	295	,CS_SIZEREDRAW \| CS_MOVENOTIFY \| CS_SYNCPAINT
	296	,sizeof(ULONG)
	297	))
	298	{
	299	vError = ::WinGetLastError(vHab);
	300	sError = wxPMErrorToStr(vError);
	301	wxLogLastError(sError.c_str());
	302	return false;
	303	}
	304
	305	if (!::WinRegisterClass( vHab
	306	,(PSZ)wxMDIFrameClassNameNoRedraw
	307	,wxWndProc
	308	,0
	309	,sizeof(ULONG)
	310	))
	311	{
	312	vError = ::WinGetLastError(vHab);
	313	sError = wxPMErrorToStr(vError);
	314	wxLogLastError(sError.c_str());
	315	return false;
	316	}
	317
	318	if (!::WinRegisterClass( vHab
	319	,(PSZ)wxMDIChildFrameClassName
	320	,wxWndProc
	321	,CS_MOVENOTIFY \| CS_SIZEREDRAW \| CS_SYNCPAINT \| CS_HITTEST
	322	,sizeof(ULONG)
	323	))
	324	{
	325	vError = ::WinGetLastError(vHab);
	326	sError = wxPMErrorToStr(vError);
	327	wxLogLastError(sError.c_str());
	328	return false;
	329	}
	330
	331	if (!::WinRegisterClass( vHab
	332	,(PSZ)wxMDIChildFrameClassNameNoRedraw
	333	,wxWndProc
	334	,CS_HITTEST
	335	,sizeof(ULONG)
	336	))
	337	{
	338	vError = ::WinGetLastError(vHab);
	339	sError = wxPMErrorToStr(vError);
	340	wxLogLastError(sError.c_str());
	341	return false;
	342	}
	343
	344	if (!::WinRegisterClass( vHab
	345	,(PSZ)wxPanelClassName
	346	,wxWndProc
	347	,CS_MOVENOTIFY \| CS_SIZEREDRAW \| CS_HITTEST \| CS_SAVEBITS \| CS_SYNCPAINT
	348	,sizeof(ULONG)
	349	))
	350	{
	351	vError = ::WinGetLastError(vHab);
	352	sError = wxPMErrorToStr(vError);
	353	wxLogLastError(sError.c_str());
	354	return false;
	355	}
	356
	357	if (!::WinRegisterClass( vHab
	358	,(PSZ)wxCanvasClassName
	359	,wxWndProc
	360	,CS_SIZEREDRAW \| CS_HITTEST \| CS_SYNCPAINT
	361	,sizeof(ULONG)
	362	))
	363	{
	364	vError = ::WinGetLastError(vHab);
	365	sError = wxPMErrorToStr(vError);
	366	wxLogLastError(sError.c_str());
	367	return false;
	368	}
	369	if (!::WinRegisterClass( vHab
	370	,(PSZ)wxCanvasClassNameNR
	371	,wxWndProc
	372	,CS_HITTEST \| CS_SYNCPAINT
	373	,sizeof(ULONG)
	374	))
	375	{
	376	vError = ::WinGetLastError(vHab);
	377	sError = wxPMErrorToStr(vError);
	378	wxLogLastError(sError.c_str());
	379	return false;
	380	}
	381	return true;
	382	} // end of wxApp::RegisterWindowClasses
	383
	384	//
	385	// Cleans up any wxWidgets internal structures left lying around
	386	//
	387	void wxApp::CleanUp()
	388	{
	389	delete[] wxBuffer;
	390	wxBuffer = NULL;
	391
	392	//
	393	// PM-SPECIFIC CLEANUP
	394	//
	395
	396	// wxSetKeyboardHook(false);
	397
	398	if (wxSTD_FRAME_ICON)
	399	::WinFreeFileIcon(wxSTD_FRAME_ICON);
	400	if (wxSTD_MDICHILDFRAME_ICON)
	401	::WinFreeFileIcon(wxSTD_MDICHILDFRAME_ICON);
	402	if (wxSTD_MDIPARENTFRAME_ICON)
	403	::WinFreeFileIcon(wxSTD_MDIPARENTFRAME_ICON);
	404
	405	if (wxDEFAULT_FRAME_ICON)
	406	::WinFreeFileIcon(wxDEFAULT_FRAME_ICON);
	407	if (wxDEFAULT_MDICHILDFRAME_ICON)
	408	::WinFreeFileIcon(wxDEFAULT_MDICHILDFRAME_ICON);
	409	if (wxDEFAULT_MDIPARENTFRAME_ICON)
	410	::WinFreeFileIcon(wxDEFAULT_MDIPARENTFRAME_ICON);
	411
	412	if ( wxDisableButtonBrush )
	413	{
	414	// TODO: ::DeleteObject( wxDisableButtonBrush );
	415	}
	416
	417	delete wxWinHandleHash;
	418	wxWinHandleHash = NULL;
	419
	420	// Delete Message queue
	421	if (wxTheApp->m_hMq)
	422	::WinDestroyMsgQueue(wxTheApp->m_hMq);
	423
	424	wxAppBase::CleanUp();
	425	} // end of wxApp::CleanUp
	426
	427	bool wxApp::OnInitGui()
	428	{
	429	ERRORID vError;
	430	wxString sError;
	431
	432	if (!wxAppBase::OnInitGui())
	433	return false;
	434
	435	m_hMq = ::WinCreateMsgQueue(vHabmain, 0);
	436	if (!m_hMq)
	437	{
	438	vError = ::WinGetLastError(vHabmain);
	439	sError = wxPMErrorToStr(vError);
	440	wxLogDebug(sError);
	441	return false;
	442	}
	443
	444	return true;
	445	} // end of wxApp::OnInitGui
	446
	447	wxApp::wxApp()
	448	{
	449	m_nPrintMode = wxPRINT_WINDOWS;
	450	m_hMq = 0;
	451	m_maxSocketHandles = 0;
	452	m_maxSocketNr = 0;
	453	m_sockCallbackInfo = 0;
	454	} // end of wxApp::wxApp
	455
	456	wxApp::~wxApp()
	457	{
	458	} // end of wxApp::~wxApp
	459
	460	bool gbInOnIdle = false;
	461
	462	void wxApp::OnIdle( wxIdleEvent& WXUNUSED(rEvent) )
	463	{
	464	//
	465	// Avoid recursion (via ProcessEvent default case)
	466	//
	467	if (gbInOnIdle)
	468	return;
	469
	470	gbInOnIdle = true;
	471
	472	#if wxUSE_DC_CACHEING
	473	// automated DC cache management: clear the cached DCs and bitmap
	474	// if it's likely that the app has finished with them, that is, we
	475	// get an idle event and we're not dragging anything.
	476	if (!::WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) &&
	477	!::WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) &&
	478	!::WinGetKeyState(HWND_DESKTOP, VK_BUTTON2))
	479	wxDC::ClearCache();
	480	#endif // wxUSE_DC_CACHEING
	481
	482	gbInOnIdle = false;
	483	} // end of wxApp::OnIdle
	484
	485	void wxApp::OnEndSession(
	486	wxCloseEvent& WXUNUSED(rEvent))
	487	{
	488	if (GetTopWindow())
	489	GetTopWindow()->Close(true);
	490	} // end of wxApp::OnEndSession
	491
	492	//
	493	// Default behaviour: close the application with prompts. The
	494	// user can veto the close, and therefore the end session.
	495	//
	496	void wxApp::OnQueryEndSession( wxCloseEvent& rEvent )
	497	{
	498	if (GetTopWindow())
	499	{
	500	if (!GetTopWindow()->Close(!rEvent.CanVeto()))
	501	rEvent.Veto(true);
	502	}
	503	} // end of wxApp::OnQueryEndSession
	504
	505	int wxApp::AddSocketHandler(int handle, int mask,
	506	void (callback)(void), void * gsock)
	507	{
	508	int find;
	509	struct GsocketCallbackInfo
	510	CallbackInfo = (struct GsocketCallbackInfo )m_sockCallbackInfo;
	511
	512	for (find = 0; find < m_maxSocketHandles; find++)
	513	if (CallbackInfo[find].handle == -1)
	514	break;
	515	if (find == m_maxSocketHandles)
	516	{
	517	// Allocate new memory
	518	m_sockCallbackInfo = realloc(m_sockCallbackInfo,
	519	(m_maxSocketHandles+=10)*
	520	sizeof(struct GsocketCallbackInfo));
	521	CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
	522	for (find = m_maxSocketHandles - 10; find < m_maxSocketHandles; find++)
	523	CallbackInfo[find].handle = -1;
	524	find = m_maxSocketHandles - 10;
	525	}
	526	CallbackInfo[find].proc = callback;
	527	CallbackInfo[find].type = mask;
	528	CallbackInfo[find].handle = handle;
	529	CallbackInfo[find].gsock = gsock;
	530	if (mask & wxSockReadMask)
	531	FD_SET(handle, &m_readfds);
	532	if (mask & wxSockWriteMask)
	533	FD_SET(handle, &m_writefds);
	534	if (handle >= m_maxSocketNr)
	535	m_maxSocketNr = handle + 1;
	536	return find;
	537	}
	538
	539	void wxApp::RemoveSocketHandler(int handle)
	540	{
	541	struct GsocketCallbackInfo
	542	CallbackInfo = (struct GsocketCallbackInfo )m_sockCallbackInfo;
	543	if (handle < m_maxSocketHandles)
	544	{
	545	if (CallbackInfo[handle].type & wxSockReadMask)
	546	FD_CLR(CallbackInfo[handle].handle, &m_readfds);
	547	if (CallbackInfo[handle].type & wxSockWriteMask)
	548	FD_CLR(CallbackInfo[handle].handle, &m_writefds);
	549	CallbackInfo[handle].handle = -1;
	550	}
	551	}
	552
	553	//-----------------------------------------------------------------------------
	554	// wxWakeUpIdle
	555	//-----------------------------------------------------------------------------
	556
	557	void wxApp::WakeUpIdle()
	558	{
	559	//
	560	// Send the top window a dummy message so idle handler processing will
	561	// start up again. Doing it this way ensures that the idle handler
	562	// wakes up in the right thread (see also wxWakeUpMainThread() which does
	563	// the same for the main app thread only)
	564	//
	565	wxWindow* pTopWindow = wxTheApp->GetTopWindow();
	566
	567	if (pTopWindow)
	568	{
	569	if ( !::WinPostMsg(GetHwndOf(pTopWindow), WM_NULL, (MPARAM)0, (MPARAM)0))
	570	{
	571	//
	572	// Should never happen
	573	//
	574	wxLogLastError(wxT("PostMessage(WM_NULL)"));
	575	}
	576	}
	577	} // end of wxWakeUpIdle
	578
	579	HAB wxGetInstance()
	580	{
	581	return vHabmain;
	582	}
	583
	584	void wxSetInstance( HAB vHab )
	585	{
	586	vHabmain = vHab;
	587	}