From: David Webster Date: Wed, 13 Oct 1999 22:34:18 +0000 (+0000) Subject: Latest Updates X-Git-Url: https://git.saurik.com/wxWidgets.git/commitdiff_plain/d88de032d3009be88d0f0ba4a882784aa9493331 Latest Updates git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3974 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- diff --git a/include/wx/os2/accel.h b/include/wx/os2/accel.h index 49c4126393..49730d5d9b 100644 --- a/include/wx/os2/accel.h +++ b/include/wx/os2/accel.h @@ -1,23 +1,18 @@ ///////////////////////////////////////////////////////////////////////////// // Name: accel.h // Purpose: wxAcceleratorTable class -// Author: AUTHOR +// Author: David Webster // Modified by: -// Created: ??/??/98 +// Created: 10/13/99 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR -// Licence: wxWindows licence +// Copyright: (c) David Webster +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifndef _WX_ACCEL_H_ #define _WX_ACCEL_H_ -#ifdef __GNUG__ -#pragma interface "accel.h" -#endif - #include "wx/object.h" -#include "wx/string.h" class WXDLLEXPORT wxAcceleratorTable; diff --git a/include/wx/os2/app.h b/include/wx/os2/app.h index fba1c3f241..4b0c4d52a3 100644 --- a/include/wx/os2/app.h +++ b/include/wx/os2/app.h @@ -1,25 +1,19 @@ ///////////////////////////////////////////////////////////////////////////// // Name: app.h // Purpose: wxApp class -// Author: AUTHOR +// Author: David Webster // Modified by: -// Created: ??/??/98 +// Created: 10/13/99 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR +// Copyright: (c) David Webster // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifndef _WX_APP_H_ #define _WX_APP_H_ -#ifdef __GNUG__ -#pragma interface "app.h" -#endif - -#include "wx/defs.h" -#include "wx/object.h" -#include "wx/gdicmn.h" #include "wx/event.h" +#include "wx/icon.h" class WXDLLEXPORT wxFrame; class WXDLLEXPORT wxWindow; @@ -27,9 +21,6 @@ class WXDLLEXPORT wxApp ; class WXDLLEXPORT wxKeyEvent; class WXDLLEXPORT wxLog; -#define wxPRINT_WINDOWS 1 -#define wxPRINT_POSTSCRIPT 2 - WXDLLEXPORT_DATA(extern wxApp*) wxTheApp; // Force an exit from main loop @@ -40,116 +31,83 @@ bool WXDLLEXPORT wxYield(); // Represents the application. Derive OnInit and declare // a new App object to start application -class WXDLLEXPORT wxApp: public wxEvtHandler +class WXDLLEXPORT wxApp : public wxAppBase { - DECLARE_DYNAMIC_CLASS(wxApp) - wxApp(); - inline ~wxApp() {} - - static void SetInitializerFunction(wxAppInitializerFunction fn) { m_appInitFn = fn; } - static wxAppInitializerFunction GetInitializerFunction() { return m_appInitFn; } - - virtual int MainLoop(); - void ExitMainLoop(); - bool Initialized(); - virtual bool Pending() ; - virtual void Dispatch() ; - - void OnIdle(wxIdleEvent& event); - -// Generic - virtual bool OnInit() { return FALSE; }; - - // No specific tasks to do here. - virtual bool OnInitGui() { return TRUE; } - - // Called to set off the main loop - virtual int OnRun() { return MainLoop(); }; - virtual int OnExit() { return 0; } - - /** Returns the standard icons for the msg dialogs, implemented in - src/generic/msgdlgg.cpp and src/gtk/app.cpp. */ - virtual wxIcon GetStdIcon(int which) const; - - inline void SetPrintMode(int mode) { m_printMode = mode; } - inline int GetPrintMode() const { return m_printMode; } + DECLARE_DYNAMIC_CLASS(wxApp) - inline void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; } - inline bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; } - - inline wxString GetAppName() const { - if (m_appName != "") - return m_appName; - else return m_className; - } - - inline void SetAppName(const wxString& name) { m_appName = name; }; - inline wxString GetClassName() const { return m_className; } - inline void SetClassName(const wxString& name) { m_className = name; } - - void SetVendorName(const wxString& vendorName) { m_vendorName = vendorName; } - const wxString& GetVendorName() const { return m_vendorName; } +public: + wxApp(); + virtual ~wxApp(); - wxWindow *GetTopWindow() const ; - inline void SetTopWindow(wxWindow *win) { m_topWindow = win; } + // override base class (pure) virtuals + virtual int MainLoop(); + virtual void ExitMainLoop(); + virtual bool Initialized(); + virtual bool Pending() ; + virtual void Dispatch() ; - inline void SetWantDebugOutput(bool flag) { m_wantDebugOutput = flag; } - inline bool GetWantDebugOutput() { return m_wantDebugOutput; } + virtual wxIcon GetStdIcon(int which) const; - // Send idle event to all top-level windows. - // Returns TRUE if more idle time is requested. - bool SendIdleEvents(); + virtual void SetPrintMode(int mode) { m_printMode = mode; } + virtual int GetPrintMode() const { return m_printMode; } - // Send idle event to window and all subwindows - // Returns TRUE if more idle time is requested. - bool SendIdleEvents(wxWindow* win); + // implementation only + void OnIdle(wxIdleEvent& event); + void OnEndSession(wxCloseEvent& event); + void OnQueryEndSession(wxCloseEvent& event); - // Windows only, but for compatibility... - inline void SetAuto3D(bool flag) { m_auto3D = flag; } - inline bool GetAuto3D() const { return m_auto3D; } + // Send idle event to all top-level windows. + // Returns TRUE if more idle time is requested. + bool SendIdleEvents(); - // Creates a log object - virtual wxLog* CreateLogTarget(); + // Send idle event to window and all subwindows + // Returns TRUE if more idle time is requested. + bool SendIdleEvents(wxWindow* win); -public: - // Will always be set to the appropriate, main-style values. - int argc; - char ** argv; + void SetAuto3D(bool flag) { m_auto3D = flag; } + bool GetAuto3D() const { return m_auto3D; } protected: - bool m_wantDebugOutput ; - wxString m_className; - wxString m_appName, - m_vendorName; - wxWindow * m_topWindow; - bool m_exitOnFrameDelete; - bool m_showOnInit; - int m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT - bool m_auto3D ; // Always use 3D controls, except - // where overriden - static wxAppInitializerFunction m_appInitFn; + bool m_showOnInit; + int m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT + bool m_auto3D ; // Always use 3D controls, except where overriden -public: + /* Windows-specific wxApp definitions */ - // Implementation - static bool Initialize(); - static void CleanUp(); +public: - void DeletePendingObjects(); - bool ProcessIdle(); + // Implementation + static bool Initialize(); + static void CleanUp(); + + static bool RegisterWindowClasses(); + // Convert Windows to argc, argv style + void ConvertToStandardCommandArgs(char* p); + virtual bool DoMessage(); + virtual bool ProcessMessage(WXMSG* pMsg); + void DeletePendingObjects(); + bool ProcessIdle(); +#if wxUSE_THREADS + void ProcessPendingEvents(); +#endif + int GetComCtl32Version() const; public: - static long sm_lastMessageTime; - int m_nCmdShow; + int m_nCmdShow; protected: - bool m_keepGoing ; + bool m_keepGoing ; -DECLARE_EVENT_TABLE() + DECLARE_EVENT_TABLE() }; -// TODO: add platform-specific arguments -int WXDLLEXPORT wxEntry( int argc, char *argv[] ); +#if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL)) +int WXDLLEXPORT wxEntry(WXHINSTANCE hInstance, WXHINSTANCE hPrevInstance, char *lpszCmdLine, + int nCmdShow, bool enterLoop = TRUE); +#else +int WXDLLEXPORT wxEntry(WXHINSTANCE hInstance); +#endif + #endif // _WX_APP_H_ diff --git a/include/wx/os2/bitmap.h b/include/wx/os2/bitmap.h index 1dec7c28aa..8ed76d060f 100644 --- a/include/wx/os2/bitmap.h +++ b/include/wx/os2/bitmap.h @@ -1,21 +1,17 @@ ///////////////////////////////////////////////////////////////////////////// // Name: bitmap.h // Purpose: wxBitmap class -// Author: AUTHOR +// Author: David Webster // Modified by: -// Created: ??/??/98 +// Created: 10/13/99 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR -// Licence: wxWindows licence +// Copyright: (c) David Webster +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifndef _WX_BITMAP_H_ #define _WX_BITMAP_H_ -#ifdef __GNUG__ -#pragma interface "bitmap.h" -#endif - #include "wx/gdiobj.h" #include "wx/gdicmn.h" #include "wx/palette.h" @@ -27,6 +23,7 @@ class WXDLLEXPORT wxBitmap; class WXDLLEXPORT wxBitmapHandler; class WXDLLEXPORT wxIcon; class WXDLLEXPORT wxCursor; +class WXDLLEXPORT wxControl; // A mask is a mono bitmap used for drawing bitmaps // transparently. @@ -54,13 +51,11 @@ public: bool Create(const wxBitmap& bitmap, int paletteIndex); bool Create(const wxBitmap& bitmap); -/* TODO: platform-specific data access // Implementation inline WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; } inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; } protected: WXHBITMAP m_maskBitmap; -*/ }; class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData @@ -124,22 +119,18 @@ public: wxBitmap(); // Platform-specific // Copy constructors - inline wxBitmap(const wxBitmap& bitmap) - { Ref(bitmap); if ( wxTheBitmapList ) wxTheBitmapList->AddBitmap(this); } + wxBitmap(const wxBitmap& bitmap); - // Initialize with raw data. + // Initialize with raw data wxBitmap(const char bits[], int width, int height, int depth = 1); -/* TODO: maybe implement XPM reading // Initialize with XPM data - wxBitmap(const char **data); -*/ + wxBitmap(char **data, wxControl *anItem = NULL); // Load a file or resource - // TODO: make default type whatever's appropriate for the platform. wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE); - // Constructor for generalised creation from data + // New constructor for generalised creation from data wxBitmap(void *data, long type, int width, int height, int depth = 1); // If depth is omitted, will create a bitmap compatible with the display @@ -162,6 +153,10 @@ public: void SetQuality(int q); void SetOk(bool isOk); +#if WXWIN_COMPATIBILITY + inline wxPalette *GetColourMap(void) const { return GetPalette(); } + void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); }; +#endif inline wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (wxPalette*) NULL); } void SetPalette(const wxPalette& palette); @@ -169,6 +164,7 @@ public: void SetMask(wxMask *mask) ; inline wxBitmap& operator = (const wxBitmap& bitmap) { if (*this == bitmap) return (*this); Ref(bitmap); return *this; } + inline bool operator == (const wxBitmap& bitmap) { return m_refData == bitmap.m_refData; } inline bool operator != (const wxBitmap& bitmap) { return m_refData != bitmap.m_refData; } @@ -186,13 +182,26 @@ public: protected: static wxList sm_handlers; - // TODO: Implementation + // Implementation public: void SetHBITMAP(WXHBITMAP bmp); inline WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); } inline void SetSelectedInto(wxDC *dc) { if (M_BITMAPDATA) M_BITMAPDATA->m_selectedInto = dc; } inline wxDC *GetSelectedInto(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_selectedInto : (wxDC*) NULL); } -// bool FreeResource(bool force = FALSE); + bool FreeResource(bool force = FALSE); + + // Creates a bitmap that matches the device context's depth, from + // an arbitray bitmap. At present, the original bitmap must have an + // associated palette. (TODO: use a default palette if no palette exists.) + // This function is necessary for you to Blit an arbitrary bitmap (which may have + // the wrong depth). wxDC::SelectObject will compare the depth of the bitmap + // with the DC's depth, and create a new bitmap if the depths differ. + // Eventually we should perhaps make this a public API function so that + // an app can efficiently produce bitmaps of the correct depth. + // The Windows solution is to use SetDibBits to blit an arbotrary DIB directly to a DC, but + // this is too Windows-specific, hence this solution of quietly converting the wxBitmap. + // Contributed by Frederic Villeneuve + wxBitmap GetBitmapForDC(wxDC& dc) const; }; #endif // _WX_BITMAP_H_ diff --git a/include/wx/os2/button.h b/include/wx/os2/button.h index a7dee7609e..802f1c3623 100644 --- a/include/wx/os2/button.h +++ b/include/wx/os2/button.h @@ -1,23 +1,18 @@ ///////////////////////////////////////////////////////////////////////////// // Name: button.h // Purpose: wxButton class -// Author: AUTHOR +// Author: David Webster // Modified by: -// Created: ??/??/98 +// Created: 10/13/99 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR -// Licence: wxWindows licence +// Copyright: (c) David Webster +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifndef _WX_BUTTON_H_ #define _WX_BUTTON_H_ -#ifdef __GNUG__ -#pragma interface "button.h" -#endif - #include "wx/control.h" -#include "wx/gdicmn.h" WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr; @@ -44,14 +39,23 @@ class WXDLLEXPORT wxButton: public wxControl virtual ~wxButton(); - virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); virtual void SetDefault(); - virtual void SetLabel(const wxString& label); - virtual wxString GetLabel() const ; static wxSize GetDefaultSize(); virtual void Command(wxCommandEvent& event); + virtual bool OS2Command(WXUINT param, WXWORD id); + virtual WXHBRUSH OnCtlColor(WXHDC pDC, + WXHWND pWnd, + WXUINT nCtlColor, + WXUINT message, + WXWPARAM wParam, + WXLPARAM lParam); +protected: + // send a notification event, return TRUE if processed + bool SendClickEvent(); + + virtual wxSize DoGetBestSize(); }; #endif diff --git a/src/os2/accel.cpp b/src/os2/accel.cpp index 438c075e32..881da9b4c5 100644 --- a/src/os2/accel.cpp +++ b/src/os2/accel.cpp @@ -1,11 +1,11 @@ ///////////////////////////////////////////////////////////////////////////// // Name: accel.cpp // Purpose: wxAcceleratorTable -// Author: AUTHOR +// Author: David Webster // Modified by: -// Created: ??/??/98 +// Created: 10/13/99 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR +// Copyright: (c) David Webster // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -37,6 +37,7 @@ public: inline HACCEL GetHACCEL() const { return m_hAccel; } protected: HACCEL m_hAccel; + bool m_ok; }; #define M_ACCELDATA ((wxAcceleratorRefData *)m_refData) @@ -80,6 +81,8 @@ wxAcceleratorTable::wxAcceleratorTable(const wxString& resource) */ } +extern int wxCharCodeWXToOS2(int id, bool *isVirtual); + // Create from an array wxAcceleratorTable::wxAcceleratorTable(int n, wxAcceleratorEntry entries[]) { diff --git a/src/os2/app.cpp b/src/os2/app.cpp index c30b689ba5..eb5a01b4cc 100644 --- a/src/os2/app.cpp +++ b/src/os2/app.cpp @@ -1,235 +1,796 @@ ///////////////////////////////////////////////////////////////////////////// // Name: app.cpp // Purpose: wxApp -// Author: AUTHOR +// Author: David Webster // Modified by: -// Created: ??/??/98 +// Created: 10/13/99 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR -// Licence: wxWindows licence +// Copyright: (c) David Webster +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "app.h" +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/frame.h" + #include "wx/app.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/dynarray.h" +# include "wx/wxchar.h" +# include "wx/icon.h" #endif -#include "wx/frame.h" -#include "wx/app.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/log.h" #include "wx/module.h" -#include "wx/memory.h" + +#include "wx/os2/private.h" + +#if wxUSE_THREADS + #include "wx/thread.h" + + // define the array of MSG strutures +// TODO: WX_DECLARE_OBJARRAY(MSG, wxMsgArray); + + #include "wx/arrimpl.cpp" + +// TODO: WX_DEFINE_OBJARRAY(wxMsgArray); +#endif // wxUSE_THREADS #if wxUSE_WX_RESOURCES -#include "wx/resource.h" + #include "wx/resource.h" #endif #include +#include + +// --------------------------------------------------------------------------- +// global variables +// --------------------------------------------------------------------------- + +extern wxChar *wxBuffer; +extern wxChar *wxOsVersion; +extern wxList *wxWinHandleList; +extern wxList WXDLLEXPORT wxPendingDelete; +#if wxUSE_THREADS +extern wxList *wxPendingEvents; +extern wxCriticalSection *wxPendingEventsLocker; +#endif +extern void wxSetKeyboardHook(bool doIt); +extern wxCursor *g_globalCursor; -extern char *wxBuffer; -extern wxList wxPendingDelete; - +HINSTANCE wxhInstance = 0; +// TODO: MSG s_currentMsg; wxApp *wxTheApp = NULL; +// FIXME why not const? and not static? + +// NB: all "NoRedraw" classes must have the same names as the "normal" classes +// with NR suffix - wxWindow::MSWCreate() supposes this +wxChar wxFrameClassName[] = wxT("wxFrameClass"); +wxChar wxFrameClassNameNoRedraw[] = wxT("wxFrameClassNR"); +wxChar wxMDIFrameClassName[] = wxT("wxMDIFrameClass"); +wxChar wxMDIFrameClassNameNoRedraw[] = wxT("wxMDIFrameClassNR"); +wxChar wxMDIChildFrameClassName[] = wxT("wxMDIChildFrameClass"); +wxChar wxMDIChildFrameClassNameNoRedraw[] = wxT("wxMDIChildFrameClassNR"); +wxChar wxPanelClassName[] = wxT("wxPanelClass"); +wxChar wxCanvasClassName[] = wxT("wxCanvasClass"); + +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 wxWndProc(HWND, UINT, MPARAM, MPARAM); + +// =========================================================================== +// implementation +// =========================================================================== + +// --------------------------------------------------------------------------- +// wxApp +// --------------------------------------------------------------------------- + #if !USE_SHARED_LIBRARY -IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler) -BEGIN_EVENT_TABLE(wxApp, wxEvtHandler) - EVT_IDLE(wxApp::OnIdle) -END_EVENT_TABLE() -#endif + IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler) -long wxApp::sm_lastMessageTime = 0; + BEGIN_EVENT_TABLE(wxApp, wxEvtHandler) + EVT_IDLE(wxApp::OnIdle) + EVT_END_SESSION(wxApp::OnEndSession) + EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession) + END_EVENT_TABLE() +#endif +//// Initialize bool wxApp::Initialize() { -#ifdef __WXMSW__ - wxBuffer = new char[1500]; -#else - wxBuffer = new char[BUFSIZ + 512]; + // Some people may wish to use this, but + // probably it shouldn't be here by default. +#ifdef __WXDEBUG__ + // wxRedirectIOToConsole(); #endif - wxClassInfo::InitializeClasses(); + wxBuffer = new wxChar[1500]; // FIXME - wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING); - wxTheColourDatabase->Initialize(); + wxClassInfo::InitializeClasses(); - wxInitializeStockLists(); - wxInitializeStockObjects(); +#if wxUSE_RESOURCES + wxGetResource(wxT("wxWindows"), wxT("OsVersion"), &wxOsVersion); +#endif + + // I'm annoyed ... I don't know where to put this and I don't want to + // create a module for that as it's part of the core. +#if wxUSE_THREADS + wxPendingEvents = new wxList(); + wxPendingEventsLocker = new wxCriticalSection(); +#endif + + wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING); + wxTheColourDatabase->Initialize(); + + wxInitializeStockLists(); + wxInitializeStockObjects(); #if wxUSE_WX_RESOURCES - wxInitializeResourceSystem(); + wxInitializeResourceSystem(); #endif - wxBitmap::InitStandardHandlers(); + wxBitmap::InitStandardHandlers(); + + g_globalCursor = new wxCursor; + +// TODO: +/* + wxSTD_FRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_FRAME")); + wxSTD_MDIPARENTFRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_MDIPARENTFRAME")); + wxSTD_MDICHILDFRAME_ICON = LoadIcon(wxhInstance, wxT("wxSTD_MDICHILDFRAME")); + + wxDEFAULT_FRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_FRAME")); + wxDEFAULT_MDIPARENTFRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_MDIPARENTFRAME")); + wxDEFAULT_MDICHILDFRAME_ICON = LoadIcon(wxhInstance, wxT("wxDEFAULT_MDICHILDFRAME")); +*/ + RegisterWindowClasses(); + + // Create the brush for disabling bitmap buttons +// TODO: +/* + LOGBRUSH lb; + lb.lbStyle = BS_PATTERN; + lb.lbHatch = (int)LoadBitmap( wxhInstance, wxT("wxDISABLE_BUTTON_BITMAP") ); + if ( lb.lbHatch ) + { + wxDisableButtonBrush = ::CreateBrushIndirect( & lb ); + ::DeleteObject( (HGDIOBJ)lb.lbHatch ); + } + */ + //else: wxWindows resources are probably not linked in + + wxWinHandleList = new wxList(wxKEY_INTEGER); + + // This is to foil optimizations in Visual C++ that throw out dummy.obj. + // PLEASE DO NOT ALTER THIS. +#if !defined(WXMAKINGDLL) + extern char wxDummyChar; + if (wxDummyChar) wxDummyChar++; +#endif + + wxSetKeyboardHook(TRUE); + + wxModule::RegisterModules(); + if (!wxModule::InitializeModules()) + return FALSE; + return TRUE; +} + +// --------------------------------------------------------------------------- +// RegisterWindowClasses +// --------------------------------------------------------------------------- + +// TODO we should only register classes really used by the app. For this it +// would be enough to just delay the class registration until an attempt +// to create a window of this class is made. +bool wxApp::RegisterWindowClasses() +{ +// TODO: +/* + WNDCLASS wndclass; + + // for each class we register one with CS_(V|H)REDRAW style and one + // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag + static const long styleNormal = 0; // TODO: CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS; + static const long styleNoRedraw = 0; // TODO: CS_DBLCLKS; + + // the fields which are common to all classes + wndclass.lpfnWndProc = (WNDPROC)wxWndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = sizeof( DWORD ); // VZ: what is this DWORD used for? + wndclass.hInstance = wxhInstance; + wndclass.hIcon = (HICON) NULL; + wndclass.hCursor = 0; // TODO: ::LoadCursor((HINSTANCE)NULL, IDC_ARROW); + wndclass.lpszMenuName = NULL; + + // Register the frame window class. + wndclass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1); + wndclass.lpszClassName = wxFrameClassName; + wndclass.style = styleNormal; + + if ( !RegisterClass(&wndclass) ) + { + wxLogLastError("RegisterClass(frame)"); + + return FALSE; + } + + // "no redraw" frame + wndclass.lpszClassName = wxFrameClassNameNoRedraw; + wndclass.style = styleNoRedraw; + + if ( !RegisterClass(&wndclass) ) + { + wxLogLastError("RegisterClass(no redraw frame)"); + + return FALSE; + } + + // Register the MDI frame window class. + wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves + wndclass.lpszClassName = wxMDIFrameClassName; + wndclass.style = styleNormal; + + if ( !RegisterClass(&wndclass) ) + { + wxLogLastError("RegisterClass(MDI parent)"); + + return FALSE; + } - wxModule::RegisterModules(); - wxASSERT( wxModule::InitializeModules() == TRUE ); + // "no redraw" MDI frame + wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw; + wndclass.style = styleNoRedraw; - return TRUE; + if ( !RegisterClass(&wndclass) ) + { + wxLogLastError("RegisterClass(no redraw MDI parent frame)"); + + return FALSE; + } + + // Register the MDI child frame window class. + wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); + wndclass.lpszClassName = wxMDIChildFrameClassName; + wndclass.style = styleNormal; + + if ( !RegisterClass(&wndclass) ) + { + wxLogLastError("RegisterClass(MDI child)"); + + return FALSE; + } + + // "no redraw" MDI child frame + wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw; + wndclass.style = styleNoRedraw; + + if ( !RegisterClass(&wndclass) ) + { + wxLogLastError("RegisterClass(no redraw MDI child)"); + + return FALSE; + } + + // Register the panel window class. + wndclass.hbrBackground = (HBRUSH) GetStockObject( LTGRAY_BRUSH ); + wndclass.lpszClassName = wxPanelClassName; + wndclass.style = styleNormal; + + if ( !RegisterClass(&wndclass) ) + { + wxLogLastError("RegisterClass(panel)"); + + return FALSE; + } + + // Register the canvas and textsubwindow class name + wndclass.hbrBackground = (HBRUSH)NULL; + wndclass.lpszClassName = wxCanvasClassName; + + if ( !RegisterClass(&wndclass) ) + { + wxLogLastError("RegisterClass(canvas)"); + + return FALSE; + } +*/ + return TRUE; } +// --------------------------------------------------------------------------- +// Convert Windows to argc, argv style +// --------------------------------------------------------------------------- + +void wxApp::ConvertToStandardCommandArgs(char* lpCmdLine) +{ + wxStringList args; + + wxString cmdLine(lpCmdLine); + int count = 0; + + // Get application name + wxChar name[260]; // 260 is MAX_PATH value from windef.h +// TODO: ::GetModuleFileName(wxhInstance, name, WXSIZEOF(name)); + + args.Add(name); + count++; + + wxStrcpy(name, wxFileNameFromPath(name)); + wxStripExtension(name); + wxTheApp->SetAppName(name); + + // Break up string + // Treat strings enclosed in double-quotes as single arguments + int i = 0; + int len = cmdLine.Length(); + while (i < len) + { + // Skip whitespace + while ((i < len) && wxIsspace(cmdLine.GetChar(i))) + i ++; + + if (i < len) + { + if (cmdLine.GetChar(i) == wxT('"')) // We found the start of a string + { + i ++; + int first = i; + while ((i < len) && (cmdLine.GetChar(i) != wxT('"'))) + i ++; + + wxString arg(cmdLine.Mid(first, (i - first))); + + args.Add(arg); + count ++; + + if (i < len) + i ++; // Skip past 2nd quote + } + else // Unquoted argument + { + int first = i; + while ((i < len) && !wxIsspace(cmdLine.GetChar(i))) + i ++; + + wxString arg(cmdLine.Mid(first, (i - first))); + + args.Add(arg); + count ++; + } + } + } + + wxTheApp->argv = new wxChar*[count + 1]; + for (i = 0; i < count; i++) + { + wxString arg(args[i]); + wxTheApp->argv[i] = copystring((const wxChar*)arg); + } + wxTheApp->argv[count] = NULL; // argv[] is a NULL-terminated list + wxTheApp->argc = count; +} + +//// Cleans up any wxWindows internal structures left lying around + void wxApp::CleanUp() { - wxModule::CleanUpModules(); + //// COMMON CLEANUP + +#if wxUSE_LOG + // flush the logged messages if any and install a 'safer' log target: the + // default one (wxLogGui) can't be used after the resources are freed just + // below and the user suppliedo ne might be even more unsafe (using any + // wxWindows GUI function is unsafe starting from now) + wxLog::DontCreateOnDemand(); + + // this will flush the old messages if any + delete wxLog::SetActiveTarget(new wxLogStderr); +#endif // wxUSE_LOG + + // One last chance for pending objects to be cleaned up + wxTheApp->DeletePendingObjects(); + + wxModule::CleanUpModules(); #if wxUSE_WX_RESOURCES - wxCleanUpResourceSystem(); -#endif + wxCleanUpResourceSystem(); - wxDeleteStockObjects() ; + // wxDefaultResourceTable->ClearTable(); +#endif - // Destroy all GDI lists, etc. + // Indicate that the cursor can be freed, so that cursor won't be deleted + // by deleting the bitmap list before g_globalCursor goes out of scope + // (double deletion of the cursor). + wxSetCursor(wxNullCursor); + delete g_globalCursor; + g_globalCursor = NULL; - delete wxTheBrushList; - wxTheBrushList = NULL; + wxDeleteStockObjects(); - delete wxThePenList; - wxThePenList = NULL; + // Destroy all GDI lists, etc. + wxDeleteStockLists(); - delete wxTheFontList; - wxTheFontList = NULL; + delete wxTheColourDatabase; + wxTheColourDatabase = NULL; - delete wxTheBitmapList; - wxTheBitmapList = NULL; + wxBitmap::CleanUpHandlers(); - delete wxTheColourDatabase; - wxTheColourDatabase = NULL; + delete[] wxBuffer; + wxBuffer = NULL; - wxBitmap::CleanUpHandlers(); + //// WINDOWS-SPECIFIC CLEANUP - delete[] wxBuffer; - wxBuffer = NULL; + wxSetKeyboardHook(FALSE); +// TODO: +/* + if (wxSTD_FRAME_ICON) + DestroyIcon(wxSTD_FRAME_ICON); + if (wxSTD_MDICHILDFRAME_ICON) + DestroyIcon(wxSTD_MDICHILDFRAME_ICON); + if (wxSTD_MDIPARENTFRAME_ICON) + DestroyIcon(wxSTD_MDIPARENTFRAME_ICON); + + if (wxDEFAULT_FRAME_ICON) + DestroyIcon(wxDEFAULT_FRAME_ICON); + if (wxDEFAULT_MDICHILDFRAME_ICON) + DestroyIcon(wxDEFAULT_MDICHILDFRAME_ICON); + if (wxDEFAULT_MDIPARENTFRAME_ICON) + DestroyIcon(wxDEFAULT_MDIPARENTFRAME_ICON); +*/ + if ( wxDisableButtonBrush ) + { +// TODO: ::DeleteObject( wxDisableButtonBrush ); + } + + if (wxWinHandleList) + delete wxWinHandleList; + + // GL: I'm annoyed ... I don't know where to put this and I don't want to + // create a module for that as it's part of the core. +#if wxUSE_THREADS + delete wxPendingEvents; + delete wxPendingEventsLocker; + // If we don't do the following, we get an apparent memory leak. + ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker(); +#endif - wxClassInfo::CleanUpClasses(); + wxClassInfo::CleanUpClasses(); - delete wxTheApp; - wxTheApp = NULL; + delete wxTheApp; + wxTheApp = NULL; #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT - // At this point we want to check if there are any memory - // blocks that aren't part of the wxDebugContext itself, - // as a special case. Then when dumping we need to ignore - // wxDebugContext, too. - if (wxDebugContext::CountObjectsLeft() > 0) - { - wxTrace("There were memory leaks.\n"); - wxDebugContext::Dump(); - wxDebugContext::PrintStatistics(); - } -// wxDebugContext::SetStream(NULL, NULL); + // At this point we want to check if there are any memory + // blocks that aren't part of the wxDebugContext itself, + // as a special case. Then when dumping we need to ignore + // wxDebugContext, too. + if (wxDebugContext::CountObjectsLeft(TRUE) > 0) + { + wxLogDebug(wxT("There were memory leaks.")); + wxDebugContext::Dump(); + wxDebugContext::PrintStatistics(); + } + // wxDebugContext::SetStream(NULL, NULL); #endif - // do it as the very last thing because everything else can log messages - wxLog::DontCreateOnDemand(); - // do it as the very last thing because everything else can log messages - delete wxLog::SetActiveTarget(NULL); +#if wxUSE_LOG + // do it as the very last thing because everything else can log messages + delete wxLog::SetActiveTarget(NULL); +#endif // wxUSE_LOG } -int wxEntry( int argc, char *argv[] ) -{ - if (!wxApp::Initialize()) - return FALSE; - if (!wxTheApp) - { - if (!wxApp::GetInitializerFunction()) - { - printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" ); - return 0; - }; +#if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL)) - wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) (); - }; +//// Main wxWindows entry point +int wxEntry(WXHINSTANCE hInstance, + WXHINSTANCE WXUNUSED(hPrevInstance), + char *lpCmdLine, + int nCmdShow, + bool enterLoop) +{ + // do check for memory leaks on program exit + // (another useful flag is _CRTDBG_DELAY_FREE_MEM_DF which doesn't free + // deallocated memory which may be used to simulate low-memory condition) +// TODO: wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF); + + // take everything into a try-except block in release build + // FIXME other compilers must support Win32 SEH (structured exception + // handling) too, just find the appropriate keyword in their docs! + // Please note that it's _not_ the same as C++ exceptions! + + wxhInstance = (HINSTANCE) hInstance; + + if (!wxApp::Initialize()) + return 0; + + // create the application object or ensure that one already exists + if (!wxTheApp) + { + // The app may have declared a global application object, but we recommend + // the IMPLEMENT_APP macro is used instead, which sets an initializer + // function for delayed, dynamic app object construction. + wxCHECK_MSG( wxApp::GetInitializerFunction(), 0, + wxT("No initializer - use IMPLEMENT_APP macro.") ); + + wxTheApp = (wxApp*)(*wxApp::GetInitializerFunction()) (); + } + + wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") ); + + // save the WinMain() parameters + wxTheApp->ConvertToStandardCommandArgs(lpCmdLine); + wxTheApp->m_nCmdShow = nCmdShow; + + // GUI-specific initialisation. In fact on Windows we don't have any, + // but this call is provided for compatibility across platforms. + wxTheApp->OnInitGui(); + + int retValue = 0; + + if ( wxTheApp->OnInit() ) + { + if ( enterLoop ) + { + retValue = wxTheApp->OnRun(); + } + else + // We want to initialize, but not run or exit immediately. + return 1; + } + //else: app initialization failed, so we skipped OnRun() + + wxWindow *topWindow = wxTheApp->GetTopWindow(); + if ( topWindow ) + { + // Forcibly delete the window. + if ( topWindow->IsKindOf(CLASSINFO(wxFrame)) || + topWindow->IsKindOf(CLASSINFO(wxDialog)) ) + { + topWindow->Close(TRUE); + wxTheApp->DeletePendingObjects(); + } + else + { + delete topWindow; + wxTheApp->SetTopWindow(NULL); + } + } + + wxTheApp->OnExit(); + + wxApp::CleanUp(); + + return retValue; +} - if (!wxTheApp) - { - printf( "wxWindows error: wxTheApp == NULL\n" ); - return 0; - }; +#else /* _WINDLL */ - wxTheApp->argc = argc; - wxTheApp->argv = argv; +//// Entry point for DLLs - // GUI-specific initialization, such as creating an app context. - wxTheApp->OnInitGui(); +int wxEntry(WXHINSTANCE hInstance) +{ + wxhInstance = (HINSTANCE) hInstance; + wxApp::Initialize(); - // Here frames insert themselves automatically - // into wxTopLevelWindows by getting created - // in OnInit(). + // The app may have declared a global application object, but we recommend + // the IMPLEMENT_APP macro is used instead, which sets an initializer function + // for delayed, dynamic app object construction. + if (!wxTheApp) + { + wxCHECK_MSG( wxApp::GetInitializerFunction(), 0, + "No initializer - use IMPLEMENT_APP macro." ); - if (!wxTheApp->OnInit()) return 0; + wxTheApp = (* wxApp::GetInitializerFunction()) (); + } - int retValue = 0; + wxCHECK_MSG( wxTheApp, 0, "You have to define an instance of wxApp!" ); - if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun(); + wxTheApp->argc = 0; + wxTheApp->argv = NULL; - if (wxTheApp->GetTopWindow()) - { - delete wxTheApp->GetTopWindow(); - wxTheApp->SetTopWindow(NULL); - } + wxTheApp->OnInitGui(); - wxTheApp->DeletePendingObjects(); + wxTheApp->OnInit(); - wxTheApp->OnExit(); + wxWindow *topWindow = wxTheApp->GetTopWindow(); + if ( topWindow && topWindow->GetHWND()) + { + topWindow->Show(TRUE); + } - wxApp::CleanUp(); + return 1; +} +#endif // _WINDLL - return retValue; -}; +//// Static member initialization -// Static member initialization -wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL; +wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL; wxApp::wxApp() { - m_topWindow = NULL; - wxTheApp = this; - m_className = ""; - m_wantDebugOutput = TRUE ; - m_appName = ""; - argc = 0; - argv = NULL; -#ifdef __WXPM__ - m_printMode = wxPRINT_WINDOWS; -#else - m_printMode = wxPRINT_POSTSCRIPT; -#endif - m_exitOnFrameDelete = TRUE; - m_auto3D = TRUE; + m_topWindow = NULL; + wxTheApp = this; + m_wantDebugOutput = TRUE; + + argc = 0; + argv = NULL; + m_printMode = wxPRINT_WINDOWS; + m_exitOnFrameDelete = TRUE; + m_auto3D = TRUE; +} + +wxApp::~wxApp() +{ + // Delete command-line args + int i; + for (i = 0; i < argc; i++) + { + delete[] argv[i]; + } + delete[] argv; } bool wxApp::Initialized() { - if (GetTopWindow()) +#ifndef _WINDLL + if (GetTopWindow()) + return TRUE; + else + return FALSE; +#endif +#ifdef _WINDLL // Assume initialized if DLL (no way of telling) return TRUE; - else - return FALSE; +#endif } +/* + * Get and process a message, returning FALSE if WM_QUIT + * received (and also set the flag telling the app to exit the main loop) + * + */ +bool wxApp::DoMessage() +{ + BOOL rc = FALSE; // TODO: ::GetMessage(&s_currentMsg, (HWND) NULL, 0, 0); + if ( rc == 0 ) + { + // got WM_QUIT + m_keepGoing = FALSE; + + return FALSE; + } + else if ( rc == -1 ) + { + // should never happen, but let's test for it nevertheless + wxLogLastError("GetMessage"); + } + else + { +#if wxUSE_THREADS + wxASSERT_MSG( wxThread::IsMain(), + wxT("only the main thread can process Windows messages") ); + + static bool s_hadGuiLock = TRUE; +// TODO: +/* + static wxMsgArray s_aSavedMessages; + + // if a secondary thread owns is doing GUI calls, save all messages for + // later processing - we can't process them right now because it will + // lead to recursive library calls (and we're not reentrant) + if ( !wxGuiOwnedByMainThread() ) + { + s_hadGuiLock = FALSE; + + // leave out WM_COMMAND messages: too dangerous, sometimes + // the message will be processed twice + if ( !wxIsWaitingForThread() || + s_currentMsg.message != WM_COMMAND ) + { + s_aSavedMessages.Add(s_currentMsg); + } + + return TRUE; + } + else + { + // have we just regained the GUI lock? if so, post all of the saved + // messages + // + // FIXME of course, it's not _exactly_ the same as processing the + // messages normally - expect some things to break... + if ( !s_hadGuiLock ) + { + s_hadGuiLock = TRUE; + + size_t count = s_aSavedMessages.Count(); + for ( size_t n = 0; n < count; n++ ) + { + MSG& msg = s_aSavedMessages[n]; + + if ( !ProcessMessage((WXMSG *)&msg) ) + { + ::TranslateMessage(&msg); + ::DispatchMessage(&msg); + } + } + s_aSavedMessages.Empty(); + } + } +*/ +#endif // wxUSE_THREADS + + // Process the message +// TODO: +/* + if ( !ProcessMessage((WXMSG *)&s_currentMsg) ) + { + ::TranslateMessage(&s_currentMsg); + ::DispatchMessage(&s_currentMsg); + } +*/ + } + + return TRUE; +} + +/* + * Keep trying to process messages until WM_QUIT + * received. + * + * If there are messages to be processed, they will all be + * processed and OnIdle will not be called. + * When there are no more messages, OnIdle is called. + * If OnIdle requests more time, + * it will be repeatedly called so long as there are no pending messages. + * A 'feature' of this is that once OnIdle has decided that no more processing + * is required, then it won't get processing time until further messages + * are processed (it'll sit in DoMessage). + */ + int wxApp::MainLoop() { - m_keepGoing = TRUE; - -/* TODO: implement your main loop here, calling ProcessIdle in idle time. - while (m_keepGoing) - { - while (!::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) && - ProcessIdle()) {} - if (!DoMessage()) - m_keepGoing = FALSE; - } + m_keepGoing = TRUE; + + while ( m_keepGoing ) + { +#if wxUSE_THREADS + wxMutexGuiLeaveOrEnter(); +#endif // wxUSE_THREADS +// TODO: +/* + while ( !::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) && + ProcessIdle() ) + { + } */ - return 0; + DoMessage(); + } + +// TODO: return s_currentMsg.wParam; + return FALSE; } // Returns TRUE if more time is needed. @@ -242,66 +803,131 @@ bool wxApp::ProcessIdle() return event.MoreRequested(); } +#if wxUSE_THREADS +void wxApp::ProcessPendingEvents() +{ + wxNode *node = wxPendingEvents->First(); + wxCriticalSectionLocker locker(*wxPendingEventsLocker); + + while (node) + { + wxEvtHandler *handler = (wxEvtHandler *)node->Data(); + + handler->ProcessPendingEvents(); + + delete node; + node = wxPendingEvents->First(); + } +} +#endif + + void wxApp::ExitMainLoop() { - m_keepGoing = FALSE; + m_keepGoing = FALSE; } -// Is a message/event pending? bool wxApp::Pending() { -/* TODO. - */ - return FALSE; +// TODO: return (::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) != 0); + return FALSE; } -// Dispatch a message. void wxApp::Dispatch() { -/* TODO. - */ + DoMessage(); } -void wxApp::OnIdle(wxIdleEvent& event) +/* + * Give all windows a chance to preprocess + * the message. Some may have accelerator tables, or have + * MDI complications. + */ + +bool wxApp::ProcessMessage(WXMSG *wxmsg) { - static bool inOnIdle = FALSE; +// TODO: +/* + MSG *msg = (MSG *)wxmsg; + HWND hWnd = msg->hwnd; + wxWindow *wndThis = wxFindWinFromHandle((WXHWND)hWnd), *wnd; + + // for some composite controls (like a combobox), wndThis might be NULL + // because the subcontrol is not a wxWindow, but only the control itself + // is - try to catch this case + while ( hWnd && !wndThis ) + { + hWnd = 0; // TODO: ::GetParent(hWnd); + wndThis = wxFindWinFromHandle((WXHWND)hWnd); + } - // Avoid recursion (via ProcessEvent default case) - if (inOnIdle) - return; + // Try translations first; find the youngest window with + // a translation table. + for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) + { + if ( wnd->OS2TranslateMessage(wxmsg) ) + return TRUE; + } - inOnIdle = TRUE; + // Anyone for a non-translation message? Try youngest descendants first. + for ( wnd = wndThis; wnd; wnd = wnd->GetParent() ) + { + if ( wnd->OS2ProcessMessage(wxmsg) ) + return TRUE; + } +*/ + return FALSE; +} - // 'Garbage' collection of windows deleted with Close(). - DeletePendingObjects(); +void wxApp::OnIdle(wxIdleEvent& event) +{ + static bool s_inOnIdle = FALSE; + + // Avoid recursion (via ProcessEvent default case) + if ( s_inOnIdle ) + return; - // flush the logged messages if any - wxLog *pLog = wxLog::GetActiveTarget(); - if ( pLog != NULL && pLog->HasPendingMessages() ) - pLog->Flush(); + s_inOnIdle = TRUE; - // Send OnIdle events to all windows - bool needMore = SendIdleEvents(); + // 'Garbage' collection of windows deleted with Close(). + DeletePendingObjects(); - if (needMore) - event.RequestMore(TRUE); +#if wxUSE_LOG + // flush the logged messages if any + wxLog *pLog = wxLog::GetActiveTarget(); + if ( pLog != NULL && pLog->HasPendingMessages() ) + pLog->Flush(); +#endif // wxUSE_LOG - inOnIdle = FALSE; + // Send OnIdle events to all windows + if ( SendIdleEvents() ) + { + // SendIdleEvents() returns TRUE if at least one window requested more + // idle events + event.RequestMore(TRUE); + } + + // If they are pending events, we must process them. +#if wxUSE_THREADS + ProcessPendingEvents(); +#endif + s_inOnIdle = FALSE; } // Send idle event to all top-level windows bool wxApp::SendIdleEvents() { bool needMore = FALSE; - wxNode* node = wxTopLevelWindows.First(); - while (node) - { - wxWindow* win = (wxWindow*) node->Data(); - if (SendIdleEvents(win)) + + wxWindowList::Node* node = wxTopLevelWindows.GetFirst(); + while (node) + { + wxWindow* win = node->GetData(); + if (SendIdleEvents(win)) needMore = TRUE; + node = node->GetNext(); + } - node = node->Next(); - } return needMore; } @@ -310,73 +936,174 @@ bool wxApp::SendIdleEvents(wxWindow* win) { bool needMore = FALSE; - wxIdleEvent event; - event.SetEventObject(win); - win->ProcessEvent(event); + wxIdleEvent event; + event.SetEventObject(win); + win->GetEventHandler()->ProcessEvent(event); if (event.MoreRequested()) needMore = TRUE; - wxNode* node = win->GetChildren().First(); - while (node) - { - wxWindow* win = (wxWindow*) node->Data(); - if (SendIdleEvents(win)) + wxNode* node = win->GetChildren().First(); + while (node) + { + wxWindow* win = (wxWindow*) node->Data(); + if (SendIdleEvents(win)) needMore = TRUE; - node = node->Next(); - } - return needMore ; + node = node->Next(); + } + return needMore; } void wxApp::DeletePendingObjects() { - wxNode *node = wxPendingDelete.First(); - while (node) - { - wxObject *obj = (wxObject *)node->Data(); + wxNode *node = wxPendingDelete.First(); + while (node) + { + wxObject *obj = (wxObject *)node->Data(); - delete obj; + delete obj; - if (wxPendingDelete.Member(obj)) - delete node; + if (wxPendingDelete.Member(obj)) + delete node; - // Deleting one object may have deleted other pending - // objects, so start from beginning of list again. - node = wxPendingDelete.First(); - } + // Deleting one object may have deleted other pending + // objects, so start from beginning of list again. + node = wxPendingDelete.First(); + } } -wxLog* wxApp::CreateLogTarget() +void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event)) { - return new wxLogGui; + if (GetTopWindow()) + GetTopWindow()->Close(TRUE); } -wxWindow* wxApp::GetTopWindow() const +// Default behaviour: close the application with prompts. The +// user can veto the close, and therefore the end session. +void wxApp::OnQueryEndSession(wxCloseEvent& event) { - if (m_topWindow) - return m_topWindow; - else if (wxTopLevelWindows.Number() > 0) - return (wxWindow*) wxTopLevelWindows.First()->Data(); - else - return NULL; + if (GetTopWindow()) + { + if (!GetTopWindow()->Close(!event.CanVeto())) + event.Veto(TRUE); + } +} + +int wxApp::GetComCtl32Version() const +{ + // TODO: Does OS/2 even need this method? + /* + // have we loaded COMCTL32 yet? + HMODULE theModule = ::GetModuleHandle(wxT("COMCTL32")); + int version = 0; + + // if so, then we can check for the version + if (theModule) + { + // InitCommonControlsEx is unique to 4.7 and later + FARPROC theProc = ::GetProcAddress(theModule, "InitCommonControlsEx"); + + if (! theProc) + { // not found, must be 4.00 + version = 400; + } + else + { + // The following symbol are unique to 4.71 + // DllInstall + // FlatSB_EnableScrollBar FlatSB_GetScrollInfo FlatSB_GetScrollPos + // FlatSB_GetScrollProp FlatSB_GetScrollRange FlatSB_SetScrollInfo + // FlatSB_SetScrollPos FlatSB_SetScrollProp FlatSB_SetScrollRange + // FlatSB_ShowScrollBar + // _DrawIndirectImageList _DuplicateImageList + // InitializeFlatSB + // UninitializeFlatSB + // we could check for any of these - I chose DllInstall + FARPROC theProc = ::GetProcAddress(theModule, "DllInstall"); + if (! theProc) + { + // not found, must be 4.70 + version = 470; + } + else + { // found, must be 4.71 + version = 471; + } + } + } + return version; +*/ + return 0; } void wxExit() { - wxApp::CleanUp(); -/* - * TODO: Exit in some platform-specific way. Not recommended that the app calls this: - * only for emergencies. - */ + wxLogError(_("Fatal error: exiting")); + + wxApp::CleanUp(); } -// Yield to other processes +// Yield to incoming messages bool wxYield() { - /* - * TODO - */ - return TRUE; + // TODO: +/* + MSG msg; + // We want to go back to the main message loop + // if we see a WM_QUIT. (?) +#ifdef __WXWINE__ + while (PeekMessage(&msg, (HWND)NULL, 0, 0, PM_NOREMOVE) && msg.message != WM_QUIT) +#else + while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) && msg.message != WM_QUIT) +#endif + { + if ( !wxTheApp->DoMessage() ) + break; + } + // If they are pending events, we must process them. +#if wxUSE_THREADS + wxTheApp->ProcessPendingEvents(); +#endif +*/ + return TRUE; +} + +wxIcon wxApp::GetStdIcon(int which) const +{ + // TODO: + /* + switch(which) + { + case wxICON_INFORMATION: + return wxIcon("wxICON_INFO"); + + case wxICON_QUESTION: + return wxIcon("wxICON_QUESTION"); + + case wxICON_EXCLAMATION: + return wxIcon("wxICON_WARNING"); + + default: + wxFAIL_MSG(wxT("requested non existent standard icon")); + // still fall through + + case wxICON_HAND: + return wxIcon("wxICON_ERROR"); + } +*/ + return wxIcon("wxICON_ERROR"); +} + + +HINSTANCE wxGetInstance() +{ + return wxhInstance; +} + +void wxSetInstance(HINSTANCE hInst) +{ + wxhInstance = hInst; } + diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp index 7b8c21c2d7..93ea059994 100644 --- a/src/os2/bitmap.cpp +++ b/src/os2/bitmap.cpp @@ -9,17 +9,28 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "bitmap.h" +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include + + #include "wx/list.h" + #include "wx/utils.h" + #include "wx/app.h" + #include "wx/palette.h" + #include "wx/dcmemory.h" + #include "wx/bitmap.h" + #include "wx/icon.h" #endif -#include "wx/setup.h" -#include "wx/utils.h" -#include "wx/palette.h" -#include "wx/bitmap.h" -#include "wx/icon.h" +#include "wx/os2/private.h" #include "wx/log.h" +// ---------------------------------------------------------------------------- +// macros +// ---------------------------------------------------------------------------- + #if !USE_SHARED_LIBRARIES IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) @@ -32,15 +43,25 @@ wxBitmapRefData::wxBitmapRefData() m_height = 0; m_depth = 0; m_quality = 0; + m_hBitmap = 0 ; + m_selectedInto = NULL; m_numColors = 0; m_bitmapMask = NULL; } wxBitmapRefData::~wxBitmapRefData() { - /* - * TODO: delete the bitmap data here. - */ + if (m_selectedInto) + { + wxChar buf[200]; + wxSprintf(buf, wxT("Bitmap was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) m_selectedInto); + wxFatalError(buf); + } + if (m_hBitmap) + { +// TODO: DeleteObject((HBITMAP) m_hBitmap); + } + m_hBitmap = 0 ; if (m_bitmapMask) delete m_bitmapMask; @@ -57,12 +78,68 @@ wxBitmap::wxBitmap() wxTheBitmapList->AddBitmap(this); } +wxBitmap::wxBitmap(const wxBitmap& bitmap) +{ +// TODO: +/* + wxIcon *icon = wxDynamicCast(&bitmap, wxIcon); + if ( icon ) + { + HDC hdc = ::CreateCompatibleDC(NULL); // screen DC + HBITMAP hbitmap = ::CreateCompatibleBitmap(hdc, + icon->GetWidth(), + icon->GetHeight()); + ::SelectObject(hdc, hbitmap); + ::DrawIcon(hdc, 0, 0, (HICON)icon->GetHICON()); + + ::DeleteDC(hdc); + + SetHBITMAP((WXHBITMAP)hbitmap); + } + else + { + Ref(bitmap); + } + + if ( wxTheBitmapList ) + wxTheBitmapList->AddBitmap(this); +*/ +} + wxBitmap::~wxBitmap() { if (wxTheBitmapList) wxTheBitmapList->DeleteObject(this); } +bool wxBitmap::FreeResource(bool WXUNUSED(force)) +{ + if ( !M_BITMAPDATA ) + return FALSE; + + if (M_BITMAPDATA->m_selectedInto) + { + wxChar buf[200]; + wxSprintf(buf, wxT("Bitmap %lX was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) this, (unsigned long) M_BITMAPDATA->m_selectedInto); + wxFatalError(buf); + } + if (M_BITMAPDATA->m_hBitmap) + { +// TODO: DeleteObject((HBITMAP) M_BITMAPDATA->m_hBitmap); + } + M_BITMAPDATA->m_hBitmap = 0 ; + +/* + if (M_BITMAPDATA->m_bitmapPalette) + delete M_BITMAPDATA->m_bitmapPalette; + + M_BITMAPDATA->m_bitmapPalette = NULL ; +*/ + + return TRUE; +} + + wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits) { m_refData = new wxBitmapRefData; @@ -78,6 +155,12 @@ wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits wxTheBitmapList->AddBitmap(this); } +// Create from XPM data +wxBitmap::wxBitmap(char **data, wxControl *WXUNUSED(anItem)) +{ + (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); +} + wxBitmap::wxBitmap(int w, int h, int d) { (void)Create(w, h, d); @@ -102,14 +185,6 @@ wxBitmap::wxBitmap(const wxString& filename, long type) wxTheBitmapList->AddBitmap(this); } -/* TODO: maybe allow creation from XPM -// Create from data -wxBitmap::wxBitmap(const char **data) -{ - (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); -} -*/ - bool wxBitmap::Create(int w, int h, int d) { UnRef(); @@ -228,6 +303,14 @@ void wxBitmap::SetMask(wxMask *mask) M_BITMAPDATA->m_bitmapMask = mask ; } +void wxBitmap::SetHBITMAP(WXHBITMAP bmp) +{ + if (!M_BITMAPDATA) + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_hBitmap = bmp; +} + void wxBitmap::AddHandler(wxBitmapHandler *handler) { sm_handlers.Append(handler); @@ -290,24 +373,77 @@ wxBitmapHandler *wxBitmap::FindHandler(long bitmapType) return NULL; } +// Creates a bitmap that matches the device context, from +// an arbitray bitmap. At present, the original bitmap must have an +// associated palette. TODO: use a default palette if no palette exists. +// Contributed by Frederic Villeneuve +wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const +{ + wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth()); +// TODO: +/* + wxMemoryDC memDC; + HPALETTE hPal = (HPALETTE) NULL; + LPBITMAPINFO lpDib; + void *lpBits = (void*) NULL; + + + wxASSERT( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) ); + + tmpBitmap.SetPalette(this->GetPalette()); + memDC.SelectObject(tmpBitmap); + memDC.SetPalette(this->GetPalette()); + + hPal = (HPALETTE) this->GetPalette()->GetHPALETTE(); + + if( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) ) + { + tmpBitmap.SetPalette(* this->GetPalette()); + memDC.SelectObject(tmpBitmap); + memDC.SetPalette(* this->GetPalette()); + hPal = (HPALETTE) this->GetPalette()->GetHPALETTE(); + } + else + { + hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE); + wxPalette palette; + palette.SetHPALETTE( (WXHPALETTE)hPal ); + tmpBitmap.SetPalette( palette ); + memDC.SelectObject(tmpBitmap); + memDC.SetPalette( palette ); + } + + // set the height negative because in a DIB the order of the lines is reversed + createDIB(this->GetWidth(), -this->GetHeight(), this->GetDepth(), hPal, &lpDib); + + lpBits = malloc(lpDib->bmiHeader.biSizeImage); + + ::GetBitmapBits((HBITMAP)GetHBITMAP(), lpDib->bmiHeader.biSizeImage, lpBits); + + ::SetDIBitsToDevice((HDC) memDC.GetHDC(), 0, 0, this->GetWidth(), this->GetHeight(), + 0, 0, 0, this->GetHeight(), lpBits, lpDib, DIB_RGB_COLORS); + + free(lpBits); + + freeDIB(lpDib); +*/ + return (tmpBitmap); +} + /* * wxMask */ wxMask::wxMask() { -/* TODO m_maskBitmap = 0; -*/ } // Construct a mask from a bitmap and a colour indicating // the transparent area wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour) { -/* TODO m_maskBitmap = 0; -*/ Create(bitmap, colour); } @@ -315,20 +451,14 @@ wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour) // the transparent area wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex) { -/* TODO m_maskBitmap = 0; -*/ - Create(bitmap, paletteIndex); } // Construct a mask from a mono bitmap (copies the bitmap). wxMask::wxMask(const wxBitmap& bitmap) { -/* TODO m_maskBitmap = 0; -*/ - Create(bitmap); } @@ -429,11 +559,3 @@ void wxBitmap::InitStandardHandlers() */ } -void wxBitmap::SetHBITMAP(WXHBITMAP bmp) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_hBitmap = bmp; -} - diff --git a/src/os2/button.cpp b/src/os2/button.cpp index 54fba62456..7f1caf34d4 100644 --- a/src/os2/button.cpp +++ b/src/os2/button.cpp @@ -1,19 +1,27 @@ ///////////////////////////////////////////////////////////////////////////// // Name: button.cpp // Purpose: wxButton -// Author: AUTHOR +// Author: David Webster // Modified by: -// Created: ??/??/98 +// Created: 10/13/99 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR -// Licence: wxWindows licence +// Copyright: (c) David Webster +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "button.h" +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include "wx/button.h" + #include "wx/brush.h" + #include "wx/panel.h" + #include "wx/bmpbuttn.h" + #include "wx/settings.h" + #include "wx/dcscreen.h" #endif -#include "wx/button.h" +#include "wx/os2/private.h" #if !USE_SHARED_LIBRARY IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl) @@ -43,9 +51,81 @@ bool wxButton::Create(wxWindow *parent, wxWindowID id, const wxString& label, return FALSE; } -void wxButton::SetSize(int x, int y, int width, int height, int sizeFlags) +wxButton::~wxButton() { - // TODO + wxPanel *panel = wxDynamicCast(GetParent(), wxPanel); + if ( panel ) + { + if ( panel->GetDefaultItem() == this ) + { + // don't leave the panel with invalid default item + panel->SetDefaultItem(NULL); + } + } +} + +// ---------------------------------------------------------------------------- +// size management including autosizing +// ---------------------------------------------------------------------------- + +wxSize wxButton::DoGetBestSize() +{ + wxString label = wxGetWindowText(GetHWND()); + int wBtn; + GetTextExtent(label, &wBtn, NULL); + + int wChar, hChar; + wxGetCharSize(GetHWND(), &wChar, &hChar, &GetFont()); + + // add a margin - the button is wider than just its label + wBtn += 3*wChar; + + // the button height is proportional to the height of the font used + int hBtn = BUTTON_HEIGHT_FROM_CHAR_HEIGHT(hChar); + + return wxSize(wBtn, hBtn); +} + +/* static */ +wxSize wxButton::GetDefaultSize() +{ + static wxSize s_sizeBtn; + + if ( s_sizeBtn.x == 0 ) + { + wxScreenDC dc; + dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT)); + + // the size of a standard button in the dialog units is 50x14, + // translate this to pixels + // NB1: the multipliers come from the Windows convention + // NB2: the extra +1/+2 were needed to get the size be the same as the + // size of the buttons in the standard dialog - I don't know how + // this happens, but on my system this size is 75x23 in pixels and + // 23*8 isn't even divisible by 14... Would be nice to understand + // why these constants are needed though! + s_sizeBtn.x = (50 * (dc.GetCharWidth() + 1))/4; + s_sizeBtn.y = ((14 * dc.GetCharHeight()) + 2)/8; + } + + return s_sizeBtn; +} + +void wxButton::Command (wxCommandEvent & event) +{ + ProcessCommand (event); +} + +// ---------------------------------------------------------------------------- +// helpers +// ---------------------------------------------------------------------------- + +bool wxButton::SendClickEvent() +{ + wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId()); + event.SetEventObject(this); + + return ProcessCommand(event); } void wxButton::SetDefault() @@ -59,19 +139,36 @@ void wxButton::SetDefault() // TODO: make button the default } -wxString wxButton::GetLabel() const -{ - // TODO - return wxString(""); -} +// ---------------------------------------------------------------------------- +// event/message handlers +// ---------------------------------------------------------------------------- -void wxButton::SetLabel(const wxString& label) +bool wxButton::OS2Command(WXUINT param, WXWORD id) { + bool processed = FALSE; // TODO + /* + switch ( param ) + { + case 1: // 1 for accelerator + case BN_CLICKED: + processed = SendClickEvent(); + break; + } + */ + return processed; } -void wxButton::Command (wxCommandEvent & event) +WXHBRUSH wxButton::OnCtlColor(WXHDC pDC, + WXHWND pWnd, + WXUINT nCtlColor, + WXUINT message, + WXWPARAM wParam, + WXLPARAM lParam) { - ProcessCommand (event); + wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID); + + return (WXHBRUSH) backgroundBrush->GetResourceHandle(); } +