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 49c4126393e2e4cdffe761f528cff9377771b635..49730d5d9b970b9fca859167f45d82ed509b34df 100644 (file)
--- a/include/wx/os2/accel.h
+++ b/include/wx/os2/accel.h
@@ -1,23 +1,18 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        accel.h
 // Purpose:     wxAcceleratorTable class
 /////////////////////////////////////////////////////////////////////////////
 // Name:        accel.h
 // Purpose:     wxAcceleratorTable class

-// Author:      AUTHOR
+// Author:      David Webster

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     10/13/99

 // RCS-ID:      $Id$
 // RCS-ID:      $Id$

-// Copyright:   (c) AUTHOR
-// Licence:    wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_ACCEL_H_
 #define _WX_ACCEL_H_
 
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_ACCEL_H_
 #define _WX_ACCEL_H_
 

-#ifdef __GNUG__
-#pragma interface "accel.h"
-#endif
-

 #include "wx/object.h"
 #include "wx/object.h"

-#include "wx/string.h"

 
 class WXDLLEXPORT wxAcceleratorTable;
 
 
 class WXDLLEXPORT wxAcceleratorTable;
 

diff --git a/include/wx/os2/app.h b/include/wx/os2/app.h
index fba1c3f2416568306bf94aaad9ab8fbd07c62311..4b0c4d52a3f9f5e5e9959cc0420bfa65f4e9a0db 100644 (file)
--- a/include/wx/os2/app.h
+++ b/include/wx/os2/app.h
@@ -1,25 +1,19 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        app.h
 // Purpose:     wxApp class
 /////////////////////////////////////////////////////////////////////////////
 // Name:        app.h
 // Purpose:     wxApp class

-// Author:      AUTHOR
+// Author:      David Webster

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     10/13/99

 // RCS-ID:      $Id$
 // RCS-ID:      $Id$

-// Copyright:   (c) AUTHOR
+// Copyright:   (c) David Webster

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_APP_H_
 #define _WX_APP_H_
 
 // 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/event.h"

+#include "wx/icon.h"

 
 class WXDLLEXPORT wxFrame;
 class WXDLLEXPORT wxWindow;
 
 class WXDLLEXPORT wxFrame;
 class WXDLLEXPORT wxWindow;


@@ -27,9 +21,6 @@ class WXDLLEXPORT wxApp ;
 class WXDLLEXPORT wxKeyEvent;
 class WXDLLEXPORT wxLog;
 
 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
 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
 
 // 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:
 
 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:
 
 public:

-  static long           sm_lastMessageTime;
-  int                   m_nCmdShow;
+    int               m_nCmdShow;

 
 protected:
 
 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_
 
 #endif
     // _WX_APP_H_

diff --git a/include/wx/os2/bitmap.h b/include/wx/os2/bitmap.h
index 1dec7c28aa27b855da36dd8bdff6da4570472fa2..8ed76d060f5ff0265d689525dd7a14850d306ebf 100644 (file)
--- a/include/wx/os2/bitmap.h
+++ b/include/wx/os2/bitmap.h
@@ -1,21 +1,17 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        bitmap.h
 // Purpose:     wxBitmap class
 /////////////////////////////////////////////////////////////////////////////
 // Name:        bitmap.h
 // Purpose:     wxBitmap class

-// Author:      AUTHOR
+// Author:      David Webster

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     10/13/99

 // RCS-ID:      $Id$
 // RCS-ID:      $Id$

-// Copyright:   (c) AUTHOR
-// Licence:    wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_BITMAP_H_
 #define _WX_BITMAP_H_
 
 /////////////////////////////////////////////////////////////////////////////
 
 #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"
 #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 wxBitmapHandler;
 class WXDLLEXPORT wxIcon;
 class WXDLLEXPORT wxCursor;

+class WXDLLEXPORT wxControl;

 
 // A mask is a mono bitmap used for drawing bitmaps
 // transparently.
 
 // 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);
 
   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;
   // 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
 };
 
 class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData


@@ -124,22 +119,18 @@ public:
   wxBitmap(); // Platform-specific
 
   // Copy constructors
   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);
 
   wxBitmap(const char bits[], int width, int height, int depth = 1);
 

-/* TODO: maybe implement XPM reading

   // Initialize with XPM data
   // Initialize with XPM data

-  wxBitmap(const char **data);
-*/
+  wxBitmap(char **data, wxControl *anItem = NULL);

 
   // Load a file or resource
 
   // 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);
 
   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
   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);
 
   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);
 
   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; }
   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; }
 
   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;
 
 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); }
 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 <frederic.villeneuve@natinst.com>
+  wxBitmap GetBitmapForDC(wxDC& dc) const;

 };
 #endif
   // _WX_BITMAP_H_
 };
 #endif
   // _WX_BITMAP_H_

diff --git a/include/wx/os2/button.h b/include/wx/os2/button.h
index a7dee7609e35df83cb57707c61cca7b5c00c95a8..802f1c3623bcfe00ad9bf45549cf4e483f775aea 100644 (file)
--- a/include/wx/os2/button.h
+++ b/include/wx/os2/button.h
@@ -1,23 +1,18 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        button.h
 // Purpose:     wxButton class
 /////////////////////////////////////////////////////////////////////////////
 // Name:        button.h
 // Purpose:     wxButton class

-// Author:      AUTHOR
+// Author:      David Webster

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     10/13/99

 // RCS-ID:      $Id$
 // RCS-ID:      $Id$

-// Copyright:   (c) AUTHOR
-// Licence:    wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_BUTTON_H_
 #define _WX_BUTTON_H_
 
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_BUTTON_H_
 #define _WX_BUTTON_H_
 

-#ifdef __GNUG__
-#pragma interface "button.h"
-#endif
-

 #include "wx/control.h"
 #include "wx/control.h"

-#include "wx/gdicmn.h"

 
 WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr;
 
 
 WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr;
 


@@ -44,14 +39,23 @@ class WXDLLEXPORT wxButton: public wxControl
 
   virtual ~wxButton();
 
 
   virtual ~wxButton();
 

-  virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);

   virtual void SetDefault();
   virtual void SetDefault();

-  virtual void SetLabel(const wxString& label);
-  virtual wxString GetLabel() const ;

 
   static wxSize GetDefaultSize();
 
   virtual void Command(wxCommandEvent& event);
 
   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
 };
 
 #endif

diff --git a/src/os2/accel.cpp b/src/os2/accel.cpp
index 438c075e32c783c5162645b9917d25cc743ec2ed..881da9b4c56f8b261d377b627c8467cf28fed1b8 100644 (file)
--- a/src/os2/accel.cpp
+++ b/src/os2/accel.cpp
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        accel.cpp
 // Purpose:     wxAcceleratorTable
 /////////////////////////////////////////////////////////////////////////////
 // Name:        accel.cpp
 // Purpose:     wxAcceleratorTable

-// Author:      AUTHOR
+// Author:      David Webster

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     10/13/99

 // RCS-ID:      $Id$
 // RCS-ID:      $Id$

-// Copyright:   (c) AUTHOR
+// Copyright:   (c) David Webster

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -37,6 +37,7 @@ public:
     inline HACCEL GetHACCEL() const { return m_hAccel; }
 protected:
     HACCEL      m_hAccel;
     inline HACCEL GetHACCEL() const { return m_hAccel; }
 protected:
     HACCEL      m_hAccel;

+    bool        m_ok;

 };
 
 #define M_ACCELDATA ((wxAcceleratorRefData *)m_refData)
 };
 
 #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[])
 {
 // Create from an array
 wxAcceleratorTable::wxAcceleratorTable(int n, wxAcceleratorEntry entries[])
 {

diff --git a/src/os2/app.cpp b/src/os2/app.cpp
index c30b689ba5fbeacc8e13197e41c7488a8be67fc3..eb5a01b4ccb25c3e4663c505ee17bdbff7610ef3 100644 (file)
--- a/src/os2/app.cpp
+++ b/src/os2/app.cpp
@@ -1,235 +1,796 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        app.cpp
 // Purpose:     wxApp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        app.cpp
 // Purpose:     wxApp

-// Author:      AUTHOR
+// Author:      David Webster

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     10/13/99

 // RCS-ID:      $Id$
 // 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
 
 #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/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
 
 #if wxUSE_WX_RESOURCES

-#include "wx/resource.h"
+    #include "wx/resource.h"

 #endif
 
 #include <string.h>
 #endif
 
 #include <string.h>

+#include <ctype.h>
+
+// ---------------------------------------------------------------------------
+// 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;
 
 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
 #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()
 {
 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
 
 #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
 
 #if wxUSE_WX_RESOURCES

-  wxInitializeResourceSystem();
+    wxInitializeResourceSystem();

 #endif
 
 #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()
 {
 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
 
 #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
 
 #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
 
 #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()
 {
 
 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()
 {
 }
 
 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;
     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()
 {
 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.
 }
 
 // Returns TRUE if more time is needed.


@@ -242,66 +803,131 @@ bool wxApp::ProcessIdle()
     return event.MoreRequested();
 }
 
     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()
 {
 void wxApp::ExitMainLoop()
 {

-  m_keepGoing = FALSE;
+    m_keepGoing = FALSE;

 }
 
 }
 

-// Is a message/event pending?

 bool wxApp::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()
 {
 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;
 }
 
 // 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;
             needMore = TRUE;

+        node = node->GetNext();
+    }

 
 

-               node = node->Next();
-       }

     return needMore;
 }
 
     return needMore;
 }
 


@@ -310,73 +936,174 @@ bool wxApp::SendIdleEvents(wxWindow* win)
 {
     bool needMore = FALSE;
 
 {
     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;
 
 
     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;
 
             needMore = TRUE;
 

-               node = node->Next();
-       }
-    return needMore ;
+        node = node->Next();
+    }
+    return needMore;

 }
 
 void wxApp::DeletePendingObjects()
 {
 }
 
 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()
 {
 }
 
 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()
 {
 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 7b8c21c2d7bf6ec2ab80900ad78cb2204a4b232b..93ea059994be3632224595570017a120bb42f7ca 100644 (file)
--- a/src/os2/bitmap.cpp
+++ b/src/os2/bitmap.cpp
@@ -9,17 +9,28 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // 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 <stdio.h>
+
+    #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
 
 #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"
 
 #include "wx/log.h"
 

+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------
+

 #if !USE_SHARED_LIBRARIES
 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 #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_height = 0;
     m_depth = 0;
     m_quality = 0;

+    m_hBitmap = 0 ;
+    m_selectedInto = NULL;

     m_numColors = 0;
     m_bitmapMask = NULL;
 }
 
 wxBitmapRefData::~wxBitmapRefData()
 {
     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;
 
     if (m_bitmapMask)
         delete m_bitmapMask;


@@ -57,12 +78,68 @@ wxBitmap::wxBitmap()
         wxTheBitmapList->AddBitmap(this);
 }
 
         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);
 }
 
 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;
 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);
 }
 
         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);
 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);
 }
 
         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();
 bool wxBitmap::Create(int w, int h, int d)
 {
     UnRef();


@@ -228,6 +303,14 @@ void wxBitmap::SetMask(wxMask *mask)
     M_BITMAPDATA->m_bitmapMask = 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);
 void wxBitmap::AddHandler(wxBitmapHandler *handler)
 {
     sm_handlers.Append(handler);


@@ -290,24 +373,77 @@ wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
     return NULL;
 }
 
     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 <frederic.villeneuve@natinst.com>
+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()
 {
 /*
  * wxMask
  */
 
 wxMask::wxMask()
 {

-/* TODO

     m_maskBitmap = 0;
     m_maskBitmap = 0;

-*/

 }
 
 // Construct a mask from a bitmap and a colour indicating
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 {
 }
 
 // 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;
     m_maskBitmap = 0;

-*/

     Create(bitmap, colour);
 }
 
     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)
 {
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 {

-/* TODO

     m_maskBitmap = 0;
     m_maskBitmap = 0;

-*/
-

     Create(bitmap, paletteIndex);
 }
 
 // Construct a mask from a mono bitmap (copies the bitmap).
 wxMask::wxMask(const wxBitmap& bitmap)
 {
     Create(bitmap, paletteIndex);
 }
 
 // Construct a mask from a mono bitmap (copies the bitmap).
 wxMask::wxMask(const wxBitmap& bitmap)
 {

-/* TODO

     m_maskBitmap = 0;
     m_maskBitmap = 0;

-*/
-

     Create(bitmap);
 }
 
     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 54fba624567d764a147a659aa247443ee8d80c21..7f1caf34d4721b235fa7e0f9e55114f176ebe306 100644 (file)
--- a/src/os2/button.cpp
+++ b/src/os2/button.cpp
@@ -1,19 +1,27 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        button.cpp
 // Purpose:     wxButton
 /////////////////////////////////////////////////////////////////////////////
 // Name:        button.cpp
 // Purpose:     wxButton

-// Author:      AUTHOR
+// Author:      David Webster

 // Modified by:
 // Modified by:

-// Created:     ??/??/98
+// Created:     10/13/99

 // RCS-ID:      $Id$
 // 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
 
 #endif
 

-#include "wx/button.h"
+#include "wx/os2/private.h"

 
 #if !USE_SHARED_LIBRARY
 IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
 
 #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;
 }
 
     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()
 }
 
 void wxButton::SetDefault()


@@ -59,19 +139,36 @@ void wxButton::SetDefault()
     // TODO: make button the default
 }
 
     // 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
     // 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();

 }
 
 }
 

+