/////////////////////////////////////////////////////////////////////////////
// Name: app.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxApp class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef __GTKAPPH__
-#define __GTKAPPH__
+#ifndef _WX_APP_H_
+#define _WX_APP_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "app.h"
#endif
-#include "wx/window.h"
-#include "wx/frame.h"
+#include "wx/defs.h"
+#include "wx/object.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxFrame;
+class WXDLLEXPORT wxWindow;
+class WXDLLEXPORT wxApp ;
+class WXDLLEXPORT wxKeyEvent;
+class WXDLLEXPORT wxLog;
-class wxApp;
-class wxLog;
-class wxConfig; // it's not used #if !USE_WXCONFIG, but fwd decl doesn't harm
+#define wxPRINT_WINDOWS 1
+#define wxPRINT_POSTSCRIPT 2
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
-extern wxApp *wxTheApp;
+void WXDLLEXPORT wxCleanUp();
+void WXDLLEXPORT wxCommonCleanUp(); // Call this from the platform's wxCleanUp()
+void WXDLLEXPORT wxCommonInit(); // Call this from the platform's initialization
-//-----------------------------------------------------------------------------
-// global functions
-//-----------------------------------------------------------------------------
+// Force an exit from main loop
+void WXDLLEXPORT wxExit();
-void wxExit(void);
-bool wxYield(void);
+// Yield to other apps/messages
+bool WXDLLEXPORT wxYield();
-//-----------------------------------------------------------------------------
-// constants
-//-----------------------------------------------------------------------------
+// Represents the application. Derive OnInit and declare
+// a new App object to start application
+class WXDLLEXPORT wxApp: public wxEvtHandler
+{
+ DECLARE_DYNAMIC_CLASS(wxApp)
+ wxApp();
+ inline ~wxApp() {}
-#define wxPRINT_WINDOWS 1
-#define wxPRINT_POSTSCRIPT 2
+ static void SetInitializerFunction(wxAppInitializerFunction fn) { m_appInitFn = fn; }
+ static wxAppInitializerFunction GetInitializerFunction() { return m_appInitFn; }
-//-----------------------------------------------------------------------------
-// wxApp
-//-----------------------------------------------------------------------------
+ virtual int MainLoop();
+ void ExitMainLoop();
+ bool Initialized();
+ virtual bool Pending() ;
+ virtual void Dispatch() ;
-class wxApp: public wxEvtHandler
-{
- DECLARE_DYNAMIC_CLASS(wxApp)
+ virtual void OnIdle(wxIdleEvent& event);
- public:
-
- wxApp(void);
- ~wxApp(void);
-
- static void SetInitializerFunction(wxAppInitializerFunction fn) { m_appInitFn = fn; }
- static wxAppInitializerFunction GetInitializerFunction(void) { return m_appInitFn; }
-
- virtual bool OnInit(void);
- virtual bool OnInitGui(void);
- virtual int OnRun(void);
- virtual int OnExit(void);
-
- wxWindow *GetTopWindow(void);
- void SetTopWindow( wxWindow *win );
- virtual int MainLoop(void);
- void ExitMainLoop(void);
- bool Initialized(void);
- virtual bool Pending(void);
- virtual void Dispatch(void);
-
- inline void SetWantDebugOutput(bool flag) { m_wantDebugOutput = flag; }
- inline bool GetWantDebugOutput(void) { return m_wantDebugOutput; }
-
- void OnIdle( wxIdleEvent &event );
- bool SendIdleEvents(void);
- bool SendIdleEvents( wxWindow* win );
-
- inline wxString GetAppName(void) const {
+// 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; }
+
+ inline void SetPrintMode(int mode) { m_printMode = mode; }
+ inline int GetPrintMode() const { return m_printMode; }
+
+ 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(void) const { return m_className; }
- inline void SetClassName(const wxString& name) { m_className = name; }
- const wxString& GetVendorName() const { return m_vendorName; }
- void SetVendorName(const wxString& name) { m_vendorName = name; }
-
- inline void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; }
- inline bool GetExitOnFrameDelete(void) const { return m_exitOnFrameDelete; }
-
- void SetPrintMode(int WXUNUSED(mode) ) {};
- int GetPrintMode(void) const { return wxPRINT_POSTSCRIPT; };
-
- // override this function to create default log target of arbitrary
- // user-defined classv (default implementation creates a wxLogGui object)
- virtual wxLog *CreateLogTarget();
-
-#if USE_WXCONFIG
- // override this function to create a global wxConfig object of different
- // than default type (right now the default implementation returns NULL)
- virtual wxConfig *CreateConfig() { return NULL; }
-#endif
-
- // GTK implementation
-
- static void CommonInit(void);
- static void CommonCleanUp(void);
-
- bool ProcessIdle(void);
- void DeletePendingObjects(void);
-
- bool m_initialized;
- bool m_exitOnFrameDelete;
- bool m_wantDebugOutput;
- wxWindow *m_topWindow;
-
- int argc;
- char **argv;
-
- static wxAppInitializerFunction m_appInitFn;
-
-private:
- wxString m_vendorName,
- m_appName,
- m_className;
-
- DECLARE_EVENT_TABLE()
+
+ 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; }
+
+ wxWindow *GetTopWindow() const ;
+ inline void SetTopWindow(wxWindow *win) { m_topWindow = win; }
+
+ inline void SetWantDebugOutput(bool flag) { m_wantDebugOutput = flag; }
+ inline bool GetWantDebugOutput() { return m_wantDebugOutput; }
+
+ // Send idle event to all top-level windows.
+ // Returns TRUE if more idle time is requested.
+ bool SendIdleEvents();
+
+ // Send idle event to window and all subwindows
+ // Returns TRUE if more idle time is requested.
+ bool SendIdleEvents(wxWindow* win);
+
+ // Windows only, but for compatibility...
+ inline void SetAuto3D(bool flag) { m_auto3D = flag; }
+ inline bool GetAuto3D() const { return m_auto3D; }
+
+ // Creates a log object
+ virtual wxLog* CreateLogTarget();
+
+public:
+ // Will always be set to the appropriate, main-style values.
+ int argc;
+ char ** argv;
+
+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;
+
+public:
+
+ // Implementation
+ static void CommonInit();
+ static void CommonCleanUp();
+ void DeletePendingObjects();
+ bool ProcessIdle();
+
+public:
+ static long sm_lastMessageTime;
+ int m_nCmdShow;
+
+protected:
+ bool m_keepGoing ;
+
+DECLARE_EVENT_TABLE()
};
-#endif // __GTKAPPH__
+// TODO: add platform-specific arguments
+int WXDLLEXPORT wxEntry( int argc, char *argv[] );
+
+#endif
+ // _WX_APP_H_
+
/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
+// Purpose: wxBitmap class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
// RCS-ID: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKBITMAPH__
-#define __GTKBITMAPH__
+#ifndef _WX_BITMAP_H_
+#define _WX_BITMAP_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "bitmap.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
+#include "wx/gdiobj.h"
+#include "wx/gdicmn.h"
#include "wx/palette.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+// Bitmap
+class WXDLLEXPORT wxDC;
+class WXDLLEXPORT wxControl;
+class WXDLLEXPORT wxBitmap;
+class WXDLLEXPORT wxBitmapHandler;
+class WXDLLEXPORT wxIcon;
+class WXDLLEXPORT wxCursor;
+
+// A mask is a mono bitmap used for drawing bitmaps
+// transparently.
+class WXDLLEXPORT wxMask: public wxObject
+{
+ DECLARE_DYNAMIC_CLASS(wxMask)
-class wxDC;
-class wxPaintDC;
-class wxMemoryDC;
-class wxToolBar;
-class wxBitmapButton;
-class wxStaticBitmap;
-class wxFrame;
+public:
+ wxMask();
-class wxMask;
-class wxBitmap;
+ // Construct a mask from a bitmap and a colour indicating
+ // the transparent area
+ wxMask(const wxBitmap& bitmap, const wxColour& colour);
-//-----------------------------------------------------------------------------
-// wxMask
-//-----------------------------------------------------------------------------
+ // Construct a mask from a bitmap and a palette index indicating
+ // the transparent area
+ wxMask(const wxBitmap& bitmap, int paletteIndex);
-class wxMask: public wxObject
-{
- DECLARE_DYNAMIC_CLASS(wxMask)
+ // Construct a mask from a mono bitmap (copies the bitmap).
+ wxMask(const wxBitmap& bitmap);
- public:
+ ~wxMask();
- wxMask();
- wxMask( const wxBitmap& bitmap, const wxColour& colour );
- wxMask( const wxBitmap& bitmap, int paletteIndex );
- wxMask( const wxBitmap& bitmap );
- ~wxMask();
+ bool Create(const wxBitmap& bitmap, const wxColour& colour);
+ bool Create(const wxBitmap& bitmap, int paletteIndex);
+ bool Create(const wxBitmap& bitmap);
- private:
+/* 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;
+*/
+};
- friend wxBitmap;
- friend wxDC;
- friend wxPaintDC;
- friend wxToolBar;
- friend wxBitmapButton;
- friend wxStaticBitmap;
- friend wxFrame;
+class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
+{
+ friend class WXDLLEXPORT wxBitmap;
+ friend class WXDLLEXPORT wxIcon;
+ friend class WXDLLEXPORT wxCursor;
+public:
+ wxBitmapRefData();
+ ~wxBitmapRefData();
+
+public:
+ int m_width;
+ int m_height;
+ int m_depth;
+ bool m_ok;
+ int m_numColors;
+ wxPalette m_bitmapPalette;
+ int m_quality;
+
+/* WXHBITMAP m_hBitmap; TODO: platform-specific handle */
+ wxMask * m_bitmapMask; // Optional mask
+};
- protected:
+#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
+class WXDLLEXPORT wxBitmapHandler: public wxObject
+{
+ DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
+public:
+ wxBitmapHandler() { m_name = ""; m_extension = ""; m_type = 0; };
+
+ virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
+ virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
+ int desiredWidth, int desiredHeight);
+ virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
+
+ inline void SetName(const wxString& name) { m_name = name; }
+ inline void SetExtension(const wxString& ext) { m_extension = ext; }
+ inline void SetType(long type) { m_type = type; }
+ inline wxString GetName() const { return m_name; }
+ inline wxString GetExtension() const { return m_extension; }
+ inline long GetType() const { return m_type; }
+protected:
+ wxString m_name;
+ wxString m_extension;
+ long m_type;
};
-//-----------------------------------------------------------------------------
-// wxBitmap
-//-----------------------------------------------------------------------------
+#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
-// CMB 20/5/98: added xbm constructor and GetBitmap() method
-class wxBitmap: public wxObject
+class WXDLLEXPORT wxBitmap: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxBitmap)
- public:
-
- wxBitmap();
- wxBitmap( int width, int height, int depth = -1 );
- wxBitmap( const char bits[], int width, int height, int depth = 1 );
- wxBitmap( char **bits );
- wxBitmap( const wxBitmap& bmp );
- wxBitmap( const wxBitmap* bmp );
- wxBitmap( const wxString &filename, int type = wxBITMAP_TYPE_XPM);
- ~wxBitmap();
- wxBitmap& operator = ( const wxBitmap& bmp );
- bool operator == ( const wxBitmap& bmp );
- bool operator != ( const wxBitmap& bmp );
- bool Ok() const;
-
- int GetHeight() const;
- int GetWidth() const;
- int GetDepth() const;
- void SetHeight( int height );
- void SetWidth( int width );
- void SetDepth( int depth );
-
- wxMask *GetMask() const;
- void SetMask( wxMask *mask );
-
- void Resize( int height, int width );
-
- bool SaveFile( const wxString &name, int type, wxPalette *palette = NULL );
- bool LoadFile( const wxString &name, int type = wxBITMAP_TYPE_XPM);
-
- wxPalette *GetPalette() const;
- wxPalette *GetColourMap() const
- { return GetPalette(); };
-
- private:
-
- friend wxDC;
- friend wxPaintDC;
- friend wxMemoryDC;
- friend wxToolBar;
- friend wxBitmapButton;
- friend wxStaticBitmap;
- friend wxFrame;
-
- // no data :-)
-};
+ friend class WXDLLEXPORT wxBitmapHandler;
+
+public:
+ wxBitmap(); // Platform-specific
+
+ // Copy constructors
+ inline wxBitmap(const wxBitmap& bitmap)
+ { Ref(bitmap); if ( wxTheBitmapList ) wxTheBitmapList->AddBitmap(this); }
+ inline wxBitmap(const wxBitmap* bitmap) { if (bitmap) Ref(*bitmap); if ( wxTheBitmapList ) wxTheBitmapList->AddBitmap(this); }
+
+ // 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);
+*/
+
+ // 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
+ 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(int width, int height, int depth = -1);
+ ~wxBitmap();
+
+ virtual bool Create(int width, int height, int depth = -1);
+ virtual bool Create(void *data, long type, int width, int height, int depth = 1);
+ virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
+ virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
+
+ inline bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
+ inline int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
+ inline int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
+ inline int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
+ inline int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); }
+ void SetWidth(int w);
+ void SetHeight(int h);
+ void SetDepth(int d);
+ void SetQuality(int q);
+ void SetOk(bool isOk);
+
+ inline wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : NULL); }
+ void SetPalette(const wxPalette& palette);
+
+ inline wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : NULL); }
+ 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; }
+
+ // Format handling
+ static inline wxList& GetHandlers() { return sm_handlers; }
+ static void AddHandler(wxBitmapHandler *handler);
+ static void InsertHandler(wxBitmapHandler *handler);
+ static bool RemoveHandler(const wxString& name);
+ static wxBitmapHandler *FindHandler(const wxString& name);
+ static wxBitmapHandler *FindHandler(const wxString& extension, long bitmapType);
+ static wxBitmapHandler *FindHandler(long bitmapType);
+
+ static void InitStandardHandlers();
+ static void CleanUpHandlers();
+protected:
+ static wxList sm_handlers;
+
+/*
+ // TODO: Implementation
+public:
+ void SetHBITMAP(WXHBITMAP bmp);
+ inline WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
+ bool FreeResource(bool force = FALSE);
+*/
-#endif // __GTKBITMAPH__
+};
+#endif
+ // _WX_BITMAP_H_
/////////////////////////////////////////////////////////////////////////////
-// Name: bmpbutton.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Name: bmpbuttn.h
+// Purpose: wxBitmapButton class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __BMPBUTTONH__
-#define __BMPBUTTONH__
+#ifndef _WX_BMPBUTTN_H_
+#define _WX_BMPBUTTN_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "bmpbuttn.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
-#include "wx/control.h"
+#include "wx/button.h"
+
+WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr;
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+#define wxDEFAULT_BUTTON_MARGIN 4
-class wxBitmapButton;
+class WXDLLEXPORT wxBitmapButton: public wxButton
+{
+ DECLARE_DYNAMIC_CLASS(wxBitmapButton)
+ public:
+ inline wxBitmapButton() { m_marginX = wxDEFAULT_BUTTON_MARGIN; m_marginY = wxDEFAULT_BUTTON_MARGIN; }
+ inline wxBitmapButton(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxButtonNameStr)
+ {
+ Create(parent, id, bitmap, pos, size, style, validator, name);
+ }
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+ bool Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxButtonNameStr);
-extern const char *wxButtonNameStr;
+ virtual void SetLabel(const wxBitmap& bitmap)
+ {
+ SetBitmapLabel(bitmap);
+ }
-//-----------------------------------------------------------------------------
-// wxBitmapButton
-//-----------------------------------------------------------------------------
+ virtual void SetBitmapLabel(const wxBitmap& bitmap);
-class wxBitmapButton: public wxControl
-{
- DECLARE_DYNAMIC_CLASS(wxBitmapButton)
+ inline wxBitmap& GetBitmapLabel() const { return (wxBitmap&) m_buttonBitmap; }
+ inline wxBitmap& GetBitmapSelected() const { return (wxBitmap&) m_buttonBitmapSelected; }
+ inline wxBitmap& GetBitmapFocus() const { return (wxBitmap&) m_buttonBitmapFocus; }
+ inline wxBitmap& GetBitmapDisabled() const { return (wxBitmap&) m_buttonBitmapDisabled; }
- public:
-
- wxBitmapButton(void);
- wxBitmapButton( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxButtonNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxButtonNameStr );
- void SetDefault(void);
- void SetLabel( const wxString &label );
- wxString GetLabel(void) const;
-
- public:
-
- wxBitmap m_bitmap;
-
+ inline void SetBitmapSelected(const wxBitmap& sel) { m_buttonBitmapSelected = sel; };
+ inline void SetBitmapFocus(const wxBitmap& focus) { m_buttonBitmapFocus = focus; };
+ inline void SetBitmapDisabled(const wxBitmap& disabled) { m_buttonBitmapDisabled = disabled; };
+
+ inline void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
+ inline int GetMarginX() { return m_marginX; }
+ inline int GetMarginY() { return m_marginY; }
+
+/*
+ // TODO: Implementation
+ virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item);
+ virtual void DrawFace( WXHDC dc, int left, int top, int right, int bottom, bool sel );
+ virtual void DrawButtonFocus( WXHDC dc, int left, int top, int right, int bottom, bool sel );
+ virtual void DrawButtonDisable( WXHDC dc, int left, int top, int right, int bottom, bool with_marg );
+*/
+
+ protected:
+ wxBitmap m_buttonBitmap;
+ wxBitmap m_buttonBitmapSelected;
+ wxBitmap m_buttonBitmapFocus;
+ wxBitmap m_buttonBitmapDisabled;
+ int m_marginX;
+ int m_marginY;
};
-#endif // __BMPBUTTONH__
+
+#endif
+ // _WX_BMPBUTTN_H_
/////////////////////////////////////////////////////////////////////////////
// Name: brush.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxBrush class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKBRUSHH__
-#define __GTKBRUSHH__
+#ifndef _WX_BRUSH_H_
+#define _WX_BRUSH_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "brush.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
+#include "wx/gdicmn.h"
#include "wx/gdiobj.h"
#include "wx/bitmap.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxBrush;
+
+class WXDLLEXPORT wxBrushRefData: public wxGDIRefData
+{
+ friend class WXDLLEXPORT wxBrush;
+public:
+ wxBrushRefData();
+ wxBrushRefData(const wxBrushRefData& data);
+ ~wxBrushRefData();
-class wxBrush;
+protected:
+ int m_style;
+ wxBitmap m_stipple ;
+ wxColour m_colour;
-//-----------------------------------------------------------------------------
-// wxBrush
-//-----------------------------------------------------------------------------
+/* TODO: implementation
+ WXHBRUSH m_hBrush;
+*/
+};
-class wxBrush: public wxGDIObject
+#define M_BRUSHDATA ((wxBrushRefData *)m_refData)
+
+// Brush
+class WXDLLEXPORT wxBrush: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxBrush)
- public:
-
- wxBrush(void);
- wxBrush( const wxColour &colour, int style );
- wxBrush( const wxString &colourName, int style );
- wxBrush( const wxBitmap &stippleBitmap );
- wxBrush( const wxBrush &brush );
- wxBrush( const wxBrush *brush );
- ~wxBrush(void);
- wxBrush& operator = ( const wxBrush& brush );
- bool operator == ( const wxBrush& brush );
- bool operator != ( const wxBrush& brush );
- bool Ok(void) const;
-
- int GetStyle(void) const;
- wxColour &GetColour(void) const;
- wxBitmap *GetStipple(void) const;
-
- // no data :-)
+public:
+ wxBrush();
+ wxBrush(const wxColour& col, int style);
+ wxBrush(const wxString& col, int style);
+ wxBrush(const wxBitmap& stipple);
+ inline wxBrush(const wxBrush& brush) { Ref(brush); }
+ inline wxBrush(const wxBrush* brush) { if (brush) Ref(*brush); }
+ ~wxBrush();
+
+ virtual void SetColour(const wxColour& col) ;
+ virtual void SetColour(const wxString& col) ;
+ virtual void SetColour(unsigned char r, unsigned char g, unsigned char b) ;
+ virtual void SetStyle(int style) ;
+ virtual void SetStipple(const wxBitmap& stipple) ;
+
+ inline wxBrush& operator = (const wxBrush& brush) { if (*this == brush) return (*this); Ref(brush); return *this; }
+ inline bool operator == (const wxBrush& brush) { return m_refData == brush.m_refData; }
+ inline bool operator != (const wxBrush& brush) { return m_refData != brush.m_refData; }
+
+ inline wxColour& GetColour() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_colour : wxNullColour); };
+ inline int GetStyle() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_style : 0); };
+ inline wxBitmap *GetStipple() const { return (M_BRUSHDATA ? & M_BRUSHDATA->m_stipple : 0); };
+
+ virtual bool Ok() const { return (m_refData != NULL) ; }
+
+// Implementation
+
+ // Useful helper: create the brush resource
+ void RealizeResource();
+
+ // When setting properties, we must make sure we're not changing
+ // another object
+ void Unshare();
};
-#endif // __GTKBRUSHH__
+#endif
+ // _WX_BRUSH_H_
/////////////////////////////////////////////////////////////////////////////
// Name: button.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxButton class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKBUTTONH__
-#define __GTKBUTTONH__
+#ifndef _WX_BUTTON_H_
+#define _WX_BUTTON_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "button.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
+#include "wx/gdicmn.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxButton;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const char *wxButtonNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr;
-//-----------------------------------------------------------------------------
-// wxButton
-//-----------------------------------------------------------------------------
-
-class wxButton: public wxControl
+// Pushbutton
+class WXDLLEXPORT wxButton: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxButton)
-
- public:
-
- wxButton(void);
- wxButton( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxButtonNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxButtonNameStr );
- void SetDefault(void);
- void SetLabel( const wxString &label );
- wxString GetLabel(void) const;
+ public:
+ inline wxButton() {}
+ inline wxButton(wxWindow *parent, wxWindowID id, const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxButtonNameStr)
+ {
+ Create(parent, id, label, pos, size, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID id, const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxButtonNameStr);
+
+ 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 ;
+ virtual void Command(wxCommandEvent& event);
};
-#endif // __GTKBUTTONH__
+#endif
+ // _WX_BUTTON_H_
/////////////////////////////////////////////////////////////////////////////
// Name: checkbox.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxCheckBox class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKCHECKBOXH__
-#define __GTKCHECKBOXH__
+#ifndef _WX_CHECKBOX_H_
+#define _WX_CHECKBOX_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "checkbox.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxCheckBox;
+WXDLLEXPORT_DATA(extern const char*) wxCheckBoxNameStr;
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+// Checkbox item (single checkbox)
+class WXDLLEXPORT wxBitmap;
+class WXDLLEXPORT wxCheckBox: public wxControl
+{
+ DECLARE_DYNAMIC_CLASS(wxCheckBox)
-extern const char *wxCheckBoxNameStr;
+ public:
+ inline wxCheckBox() { }
+ inline wxCheckBox(wxWindow *parent, wxWindowID id, const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxCheckBoxNameStr)
+ {
+ Create(parent, id, label, pos, size, style, validator, name);
+ }
-//-----------------------------------------------------------------------------
-// wxCheckBox
-//-----------------------------------------------------------------------------
+ bool Create(wxWindow *parent, wxWindowID id, const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxCheckBoxNameStr);
+ virtual void SetValue(bool);
+ virtual bool GetValue() const ;
+ virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ virtual void SetLabel(const wxString& label);
+ virtual void Command(wxCommandEvent& event);
+};
-class wxCheckBox: public wxControl
+class WXDLLEXPORT wxBitmapCheckBox: public wxCheckBox
{
- DECLARE_DYNAMIC_CLASS(wxCheckBox)
+ DECLARE_DYNAMIC_CLASS(wxBitmapCheckBox)
- public:
-
- wxCheckBox(void);
- wxCheckBox( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxCheckBoxNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxCheckBoxNameStr );
- void SetValue( bool state );
- bool GetValue(void) const;
-};
+ public:
+ int checkWidth ;
+ int checkHeight ;
+
+ inline wxBitmapCheckBox() { checkWidth = -1; checkHeight = -1; }
+ inline wxBitmapCheckBox(wxWindow *parent, wxWindowID id, const wxBitmap *label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxCheckBoxNameStr)
+ {
+ Create(parent, id, label, pos, size, style, validator, name);
+ }
-#endif // __GTKCHECKBOXH__
+ bool Create(wxWindow *parent, wxWindowID id, const wxBitmap *bitmap,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxCheckBoxNameStr);
+ virtual void SetValue(bool);
+ virtual bool GetValue() const ;
+ virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ virtual void SetLabel(const wxBitmap *bitmap);
+};
+#endif
+ // _WX_CHECKBOX_H_
/////////////////////////////////////////////////////////////////////////////
// Name: choice.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxChoice class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKCHOICEH__
-#define __GTKCHOICEH__
+#ifndef _WX_CHOICE_H_
+#define _WX_CHOICE_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "choice.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxChoiceNameStr;
-class wxChoice;
+// Choice item
+class WXDLLEXPORT wxChoice: public wxControl
+{
+ DECLARE_DYNAMIC_CLASS(wxChoice)
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+ public:
+ inline wxChoice() { m_noStrings = 0; }
-extern const char *wxChoiceNameStr;
+ inline wxChoice(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxChoiceNameStr)
+ {
+ Create(parent, id, pos, size, n, choices, style, validator, name);
+ }
-//-----------------------------------------------------------------------------
-// wxChoice
-//-----------------------------------------------------------------------------
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxChoiceNameStr);
-class wxChoice: public wxControl
-{
- DECLARE_DYNAMIC_CLASS(wxChoice)
+ virtual void Append(const wxString& item);
+ virtual void Delete(int n);
+ virtual void Clear();
+ virtual int GetSelection() const ;
+ virtual void SetSelection(int n);
+ virtual int FindString(const wxString& s) const;
+ virtual wxString GetString(int n) const ;
+ virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ virtual wxString GetStringSelection() const ;
+ virtual bool SetStringSelection(const wxString& sel);
+
+ virtual inline int Number() const { return m_noStrings; }
+ virtual void Command(wxCommandEvent& event);
- public:
+ virtual inline void SetColumns(int WXUNUSED(n) = 1 ) { /* No effect */ } ;
+ virtual inline int GetColumns() const { return 1 ; };
- wxChoice(void);
- wxChoice( wxWindow *parent, wxWindowID id,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- int n = 0, const wxString choices[] = NULL,
- long style = 0, const wxString &name = wxChoiceNameStr );
- bool Create( wxWindow *parent, wxWindowID id,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- int n = 0, const wxString choices[] = NULL,
- long style = 0, const wxString &name = wxChoiceNameStr );
- void Append( const wxString &item );
- void Clear(void);
- int FindString( const wxString &string ) const;
- int GetColumns(void) const;
- int GetSelection(void);
- wxString GetString( int n ) const;
- wxString GetStringSelection(void) const;
- int Number(void) const;
- void SetColumns( int n = 1 );
- void SetSelection( int n );
- void SetStringSelection( const wxString &string );
+protected:
+ int m_noStrings;
};
-#endif // __GTKCHOICEH__
+#endif
+ // _WX_CHOICE_H_
/////////////////////////////////////////////////////////////////////////////
// Name: colour.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxColour class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKCOLOURH__
-#define __GTKCOLOURH__
+#ifndef _WX_COLOUR_H_
+#define _WX_COLOUR_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "colour.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
-#include "wx/gdiobj.h"
-#include "wx/palette.h"
+// Colour
+class WXDLLEXPORT wxColour: public wxObject
+{
+ DECLARE_DYNAMIC_CLASS(wxColour)
+public:
+ wxColour();
+ wxColour(unsigned char r, unsigned char g, unsigned char b);
+ wxColour(unsigned long colRGB) { Set(colRGB); }
+ wxColour(const wxColour& col);
+ wxColour(const wxString& col);
+ ~wxColour() ;
+ wxColour& operator =(const wxColour& src) ;
+ wxColour& operator =(const wxString& src) ;
+ inline int Ok() const { return (m_isInit) ; }
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+ void Set(unsigned char r, unsigned char g, unsigned char b);
+ void Set(unsigned long colRGB)
+ {
+ // we don't need to know sizeof(long) here because we assume that the three
+ // least significant bytes contain the R, G and B values
+ Set((unsigned char)colRGB,
+ (unsigned char)(colRGB >> 8),
+ (unsigned char)(colRGB >> 16));
+ }
-class wxDC;
-class wxPaintDC;
-class wxBitmap;
-class wxWindow;
+ inline unsigned char Red() const { return m_red; }
+ inline unsigned char Green() const { return m_green; }
+ inline unsigned char Blue() const { return m_blue; }
-class wxColour;
+ inline bool operator == (const wxColour& colour) { return (m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue); }
-//-----------------------------------------------------------------------------
-// wxColour
-//-----------------------------------------------------------------------------
+ inline bool operator != (const wxColour& colour) { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); }
-class wxColour: public wxGDIObject
-{
- DECLARE_DYNAMIC_CLASS(wxColour)
+ WXCOLORREF GetPixel() const { return m_pixel; };
- public:
+ private:
+ bool m_isInit;
+ unsigned char m_red;
+ unsigned char m_blue;
+ unsigned char m_green;
+ public:
+/* TODO: implementation
+ WXCOLORREF m_pixel ;
+*/
+};
- wxColour(void);
- wxColour( char red, char green, char blue );
- wxColour( const wxString &colourName );
- wxColour( const wxColour& col );
- wxColour( const wxColour* col );
- ~wxColour(void);
- wxColour& operator = ( const wxColour& col );
- wxColour& operator = ( const wxString& colourName );
- bool operator == ( const wxColour& col );
- bool operator != ( const wxColour& col );
- void Set( const unsigned char red, const unsigned char green, const unsigned char blue );
- unsigned char Red(void) const;
- unsigned char Green(void) const;
- unsigned char Blue(void) const;
- bool Ok(void) const;
+#define wxColor wxColour
- private:
- public:
-
- friend wxDC;
- friend wxPaintDC;
- friend wxBitmap;
- friend wxWindow;
-
- int GetPixel(void);
-
- // no data :-)
-};
-
-#endif // __GTKCOLOURH__
+#endif
+ // _WX_COLOUR_H_
/////////////////////////////////////////////////////////////////////////////
// Name: combobox.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxComboBox class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKCOMBOBOXH__
-#define __GTKCOMBOBOXH__
+#ifndef _WX_COMBOBOX_H_
+#define _WX_COMBOBOX_H_
#ifdef __GNUG__
#pragma interface "combobox.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/control.h"
-
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxComboBox;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const char* wxComboBoxNameStr;
-extern const char* wxEmptyString;
+#include "wx/choice.h"
-//-----------------------------------------------------------------------------
-// wxComboBox
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxComboBoxNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
-class wxComboBox: public wxControl
+// Combobox item
+class WXDLLEXPORT wxComboBox: public wxChoice
{
DECLARE_DYNAMIC_CLASS(wxComboBox)
public:
- inline wxComboBox(void) {}
+ inline wxComboBox() {}
inline wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
- Create(parent, id, value, pos, size, n, choices, style, name);
+ Create(parent, id, value, pos, size, n, choices, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
- // List functions
- void Clear(void);
- void Append( const wxString &item );
- void Append( const wxString &item, char* clientData );
- void Delete( int n );
- int FindString( const wxString &item );
- char* GetClientData( int n );
- void SetClientData( int n, char * clientData );
- int GetSelection(void) const;
- wxString GetString( int n ) const;
- wxString GetStringSelection(void) const;
- int Number(void) const;
- void SetSelection( int n );
- void SetStringSelection( const wxString &string );
-
+ // List functions: see wxChoice
+
// Text field functions
- wxString GetValue(void) const ;
- void SetValue(const wxString& value);
+ virtual wxString GetValue() const ;
+ virtual void SetValue(const wxString& value);
// Clipboard operations
- void Copy(void);
- void Cut(void);
- void Paste(void);
- void SetInsertionPoint(long pos);
- void SetInsertionPointEnd(void);
- long GetInsertionPoint(void) const ;
- long GetLastPosition(void) const ;
- void Replace(long from, long to, const wxString& value);
- void Remove(long from, long to);
- void SetSelection(long from, long to);
- void SetEditable(bool editable);
-
+ virtual void Copy();
+ virtual void Cut();
+ virtual void Paste();
+ virtual void SetInsertionPoint(long pos);
+ virtual void SetInsertionPointEnd();
+ virtual long GetInsertionPoint() const ;
+ virtual long GetLastPosition() const ;
+ virtual void Replace(long from, long to, const wxString& value);
+ virtual void Remove(long from, long to);
+ virtual void SetSelection(int n)
+ {
+ wxChoice::SetSelection(n);
+ }
+ virtual void SetSelection(long from, long to);
+ virtual void SetEditable(bool editable);
};
-#endif // __GTKCOMBOBOXH__
+#endif
+ // _WX_COMBOBOX_H_
/////////////////////////////////////////////////////////////////////////////
// Name: control.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxControl class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKCONTROLH__
-#define __GTKCONTROLH__
+#ifndef _WX_CONTROL_H_
+#define _WX_CONTROL_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "control.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/window.h"
+#include "wx/list.h"
+#include "wx/validate.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxControl;
+// General item class
+class WXDLLEXPORT wxControl: public wxWindow
+{
+ DECLARE_ABSTRACT_CLASS(wxControl)
+public:
+ wxControl();
+ ~wxControl();
-//-----------------------------------------------------------------------------
-// wxControl
-//-----------------------------------------------------------------------------
+ virtual void Command(wxCommandEvent& WXUNUSED(event)) = 0; // Simulates an event
+ virtual void ProcessCommand(wxCommandEvent& event); // Calls the callback and
+ // appropriate event handlers
+ virtual void SetLabel(const wxString& label);
+ virtual wxString GetLabel() const ;
-class wxControl: public wxWindow
-{
-DECLARE_DYNAMIC_CLASS(wxControl)
+ // Places item in centre of panel - so can't be used BEFORE panel->Fit()
+ void Centre(int direction = wxHORIZONTAL);
+ inline void Callback(const wxFunction function) { m_callback = function; }; // Adds callback
-public:
- // construction
- wxControl();
- wxControl( wxWindow *parent, wxWindowID id,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxPanelNameStr );
-
- // overridables
- virtual void Command( wxCommandEvent &event );
-
- // accessors
- // this function will filter out '&' characters and will put the accelerator
- // char (the one immediately after '&') into m_chAccel (@@ not yet)
- virtual void SetLabel( const wxString &label );
- virtual wxString GetLabel() const;
+ inline wxFunction GetCallback() { return m_callback; }
protected:
- wxString m_label;
- // when we implement keyboard interface we will make use of this, but not yet
- //char m_chAccel;
+ wxFunction m_callback; // Callback associated with the window
+
+DECLARE_EVENT_TABLE()
};
-#endif // __GTKCONTROLH__
+#endif
+ // _WX_CONTROL_H_
/////////////////////////////////////////////////////////////////////////////
// Name: cursor.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxCursor class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKCURSORH__
-#define __GTKCURSORH__
+#ifndef _WX_CURSOR_H_
+#define _WX_CURSOR_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "cursor.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/gdicmn.h"
-
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+#include "wx/bitmap.h"
-class wxWindow;
+class WXDLLEXPORT wxCursorRefData: public wxBitmapRefData
+{
+ friend class WXDLLEXPORT wxBitmap;
+ friend class WXDLLEXPORT wxCursor;
+public:
+ wxCursorRefData();
+ ~wxCursorRefData();
-class wxCursor;
+protected:
+/* TODO: implementation
+ WXHCURSOR m_hCursor;
+*/
+};
-//-----------------------------------------------------------------------------
-// wxCursor
-//-----------------------------------------------------------------------------
+#define M_CURSORDATA ((wxCursorRefData *)m_refData)
+#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData)
-class wxCursor: public wxObject
+// Cursor
+class WXDLLEXPORT wxCursor: public wxBitmap
{
DECLARE_DYNAMIC_CLASS(wxCursor)
- public:
-
- wxCursor(void);
- wxCursor( int cursorId );
- wxCursor( const wxCursor &cursor );
- wxCursor( const wxCursor *cursor );
- ~wxCursor(void);
- wxCursor& operator = ( const wxCursor& cursor );
- bool operator == ( const wxCursor& cursor );
- bool operator != ( const wxCursor& cursor );
- bool Ok(void) const;
-
- private:
- public:
-
- friend wxWindow;
-
- // no data :-)
+public:
+ wxCursor();
+
+ // Copy constructors
+ inline wxCursor(const wxCursor& cursor) { Ref(cursor); }
+ inline wxCursor(const wxCursor* cursor) { if (cursor) Ref(*cursor); }
+
+ wxCursor(const char bits[], int width, int height, int hotSpotX = -1, int hotSpotY = -1,
+ const char maskBits[] = NULL);
+
+ /* TODO: make default type suit platform */
+ wxCursor(const wxString& name, long flags = wxBITMAP_TYPE_CUR_RESOURCE,
+ int hotSpotX = 0, int hotSpotY = 0);
+
+ wxCursor(int cursor_type);
+ ~wxCursor();
+
+ virtual bool Ok() const { return (m_refData != NULL && M_CURSORDATA->m_hCursor) ; }
+
+ inline wxCursor& operator = (const wxCursor& cursor) { if (*this == cursor) return (*this); Ref(cursor); return *this; }
+ inline bool operator == (const wxCursor& cursor) { return m_refData == cursor.m_refData; }
+ inline bool operator != (const wxCursor& cursor) { return m_refData != cursor.m_refData; }
+
+/* TODO: implementation
+ void SetHCURSOR(WXHCURSOR cursor);
+ inline WXHCURSOR GetHCURSOR() const { return (M_CURSORDATA ? M_CURSORDATA->m_hCursor : 0); }
+*/
};
-#endif // __GTKCURSORH__
+extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);
+
+#endif
+ // _WX_CURSOR_H_
/////////////////////////////////////////////////////////////////////////////
// Name: dc.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxDC class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKDCH__
-#define __GTKDCH__
+#ifndef _WX_DC_H_
+#define _WX_DC_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "dc.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/gdicmn.h"
#include "wx/pen.h"
#include "wx/brush.h"
#include "wx/icon.h"
#include "wx/font.h"
#include "wx/gdicmn.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxDC;
-
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
#define MM_TEXT 0
-#define MM_ISOTROPIC 1
-#define MM_ANISOTROPIC 2
+#define MM_ISOTROPIC 1
+#define MM_ANISOTROPIC 2
#define MM_LOMETRIC 3
#define MM_HIMETRIC 4
#define MM_TWIPS 5
// wxDC
//-----------------------------------------------------------------------------
-class wxDC: public wxObject
+class WXDLLEXPORT wxDC: public wxObject
{
DECLARE_ABSTRACT_CLASS(wxDC)
virtual bool Ok(void) const { return m_ok; };
virtual void FloodFill( long x1, long y1, wxColour *col, int style=wxFLOOD_SURFACE ) = 0;
+ inline void FloodFill(const wxPoint& pt, const wxColour& col, int style=wxFLOOD_SURFACE)
+ {
+ FloodFill(pt.x, pt.y, col, style);
+ }
virtual bool GetPixel( long x1, long y1, wxColour *col ) const = 0;
+ inline bool GetPixel(const wxPoint& pt, wxColour *col) const
+ {
+ return GetPixel(pt.x, pt.y, col);
+ }
virtual void DrawLine( long x1, long y1, long x2, long y2 ) = 0;
+ inline void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
+ {
+ DrawLine(pt1.x, pt1.y, pt2.x, pt2.y);
+ }
+
virtual void CrossHair( long x, long y ) = 0;
- virtual void DrawArc( long x1, long y1, long x2, long y2, double xc, double yc );
+ inline void CrossHair(const wxPoint& pt)
+ {
+ CrossHair(pt.x, pt.y);
+ }
+
+ virtual void DrawArc( long x1, long y1, long x2, long y2, double xc, double yc ) = 0;
+ inline void DrawArc(const wxPoint& pt1, const wxPoint& pt2, double xc, double yc)
+ {
+ DrawArc(pt1.x, pt1.y, pt2.x, pt2.y, xc, yc);
+ }
+
virtual void DrawEllipticArc( long x, long y, long width, long height, double sa, double ea ) = 0;
+ virtual void DrawEllipticArc (const wxPoint& pt, const wxSize& sz, double sa, double ea)
+ {
+ DrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea);
+ }
+
virtual void DrawPoint( long x, long y ) = 0;
virtual void DrawPoint( wxPoint& point );
int fillStyle=wxODDEVEN_RULE );
virtual void DrawRectangle( long x, long y, long width, long height ) = 0;
+ inline void DrawRectangle(const wxPoint& pt, const wxSize& sz)
+ {
+ DrawRectangle(pt.x, pt.y, sz.x, sz.y);
+ }
+ inline void DrawRectangle(const wxRect& rect)
+ {
+ DrawRectangle(rect.x, rect.y, rect.width, rect.height);
+ }
virtual void DrawRoundedRectangle( long x, long y, long width, long height, double radius = 20.0 ) = 0;
+ inline void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius = 20.0)
+ {
+ DrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius);
+ }
+ inline void DrawRoundedRectangle(const wxRect& rect, double radius = 20.0)
+ {
+ DrawRoundedRectangle(rect.x, rect.y, rect.width, rect.height, radius);
+ }
+
virtual void DrawEllipse( long x, long y, long width, long height ) = 0;
-
+ inline void DrawEllipse(const wxPoint& pt, const wxSize& sz)
+ {
+ DrawEllipse(pt.x, pt.y, sz.x, sz.y);
+ }
+ inline void DrawEllipse(const wxRect& rect)
+ {
+ DrawEllipse(rect.x, rect.y, rect.width, rect.height);
+ }
+
+ virtual void DrawIcon(const wxIcon& icon, long x, long y) = 0;
+
virtual void DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 );
virtual void DrawSpline( wxList *points );
virtual void DrawSpline( int n, wxPoint points[] );
virtual bool CanDrawBitmap(void) const = 0;
+
virtual void DrawIcon( const wxIcon &icon, long x, long y, bool useMask=FALSE );
- void DrawBitmap( const wxBitmap &bmp, long x, long y, bool useMask=FALSE )
- { DrawIcon( *((wxIcon*)(&bmp)), x, y, useMask ); }
+ inline void DrawIcon(const wxIcon& icon, const wxPoint& pt)
+ {
+ DrawIcon(icon, pt.x, pt.y);
+ }
+
+ // TODO DrawBitmap is not always the same as DrawIcon, especially if bitmaps and
+ // icons are implemented differently.
+ void DrawBitmap( const wxBitmap &bmp, long x, long y, bool useMask=FALSE )
+ { DrawIcon( *((wxIcon*)(&bmp)), x, y, useMask ); }
+
virtual bool Blit( long xdest, long ydest, long width, long height,
wxDC *source, long xsrc, long ysrc, int logical_func = wxCOPY, bool useMask=FALSE ) = 0;
+ inline bool Blit(const wxPoint& destPt, const wxSize& sz,
+ wxDC *source, const wxPoint& srcPt, int rop = wxCOPY, bool useMask = FALSE)
+ {
+ return Blit(destPt.x, destPt.y, sz.x, sz.y, source, srcPt.x, srcPt.y, rop, useMask);
+ }
virtual void DrawText( const wxString &text, long x, long y, bool use16 = FALSE ) = 0;
+ inline void DrawText(const wxString& text, const wxPoint& pt, bool use16bit = FALSE)
+ {
+ DrawText(text, pt.x, pt.y, use16bit);
+ }
+
virtual bool CanGetTextExtent(void) const = 0;
virtual void GetTextExtent( const wxString &string, long *width, long *height,
long *descent = NULL, long *externalLeading = NULL,
virtual void Clear(void) = 0;
virtual void SetFont( const wxFont &font ) = 0;
- virtual wxFont *GetFont(void) { return &m_font; };
+ virtual wxFont *GetFont(void) const { return &m_font; };
virtual void SetPen( const wxPen &pen ) = 0;
- virtual wxPen *GetPen(void) { return &m_pen; };
+ virtual wxPen *GetPen(void) const { return &m_pen; };
virtual void SetBrush( const wxBrush &brush ) = 0;
- virtual wxBrush *GetBrush(void) { return &m_brush; };
+ virtual wxBrush *GetBrush(void) const { return &m_brush; };
virtual void SetBackground( const wxBrush &brush ) = 0;
- virtual wxBrush *GetBackground(void) { return &m_backgroundBrush; };
+ virtual wxBrush *GetBackground(void) const { return &m_backgroundBrush; };
virtual void SetLogicalFunction( int function ) = 0;
- virtual int GetLogicalFunction(void) { return m_logicalFunction; };
+ virtual int GetLogicalFunction(void) const { return m_logicalFunction; };
virtual void SetTextForeground( const wxColour &col );
virtual void SetTextBackground( const wxColour &col );
virtual wxColour& GetTextForeground(void) const { return (wxColour&)m_textForegroundColour; };
virtual void SetBackgroundMode( int mode ) = 0;
- virtual int GetBackgroundMode(void) { return m_backgroundMode; };
+ virtual int GetBackgroundMode(void) const { return m_backgroundMode; };
virtual void SetPalette( const wxPalette& palette ) = 0;
- void SetColourMap( const wxPalette& palette ) { SetPalette(palette); };
+ void SetColourMap( const wxPalette& palette ) { SetPalette(palette); };
// the first two must be overridden and called
virtual void SetClippingRegion( long x, long y, long width, long height );
long m_minX,m_maxX,m_minY,m_maxY;
};
-#endif // __GTKDCH__
+#endif
+ // _WX_DC_H_
/////////////////////////////////////////////////////////////////////////////
// Name: dcclient.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxClientDC, wxPaintDC and wxWindowDC classes
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKDCCLIENTH__
-#define __GTKDCCLIENTH__
+#ifndef _WX_DCCLIENT_H_
+#define _WX_DCCLIENT_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "dcclient.h"
#endif
#include "wx/dc.h"
-#include "wx/window.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
-class wxPaintDC;
+class WXDLLEXPORT wxPaintDC;
+
+// Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented differently.
+// On many platforms, however, they will be the same.
+
typedef wxPaintDC wxClientDC;
typedef wxPaintDC wxWindowDC;
// wxPaintDC
//-----------------------------------------------------------------------------
-class wxPaintDC: public wxDC
+class WXDLLEXPORT wxPaintDC: public wxDC
{
DECLARE_DYNAMIC_CLASS(wxPaintDC)
virtual void DestroyClippingRegion(void);
virtual void DrawOpenSpline( wxList *points );
-
};
-#endif // __GTKDCCLIENTH__
+#endif
+ // _WX_DCCLIENT_H_
/////////////////////////////////////////////////////////////////////////////
// Name: dcmemory.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
+// Purpose: wxMemoryDC class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
// RCS-ID: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKDCMEMORYH__
-#define __GTKDCMEMORYH__
+#ifndef _WX_DCMEMORY_H_
+#define _WX_DCMEMORY_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "dcmemory.h"
#endif
-#include "wx/defs.h"
#include "wx/dcclient.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxMemoryDC;
-
-//-----------------------------------------------------------------------------
-// wxMemoryDC
-//-----------------------------------------------------------------------------
-
class WXDLLEXPORT wxMemoryDC: public wxPaintDC
{
DECLARE_DYNAMIC_CLASS(wxMemoryDC)
};
#endif
- // __GTKDCMEMORYH__
-
+ // _WX_DCMEMORY_H_
/////////////////////////////////////////////////////////////////////////////
// Name: dcscreen.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxScreenDC class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+#ifndef _WX_DCSCREEN_H_
+#define _WX_DCSCREEN_H_
-#ifndef __GTKDCSCREENH__
-#define __GTKDCSCREENH__
+#ifdef __GNUG__
+#pragma interface "dcscreen.h"
+#endif
#include "wx/dcclient.h"
DECLARE_DYNAMIC_CLASS(wxScreenDC)
public:
- wxScreenDC(void);
- ~wxScreenDC(void);
-
- static bool StartDrawingOnTop( wxWindow *window );
- static bool StartDrawingOnTop( wxRectangle *rect = NULL );
- static bool EndDrawingOnTop(void);
+ // Create a DC representing the whole screen
+ wxScreenDC();
+ ~wxScreenDC();
+
+ // Compatibility with X's requirements for
+ // drawing on top of all windows
+ static bool StartDrawingOnTop(wxWindow* WXUNUSED(window)) { return TRUE; }
+ static bool StartDrawingOnTop(wxRectangle* WXUNUSED(rect) = NULL) { return TRUE; }
+ static bool EndDrawingOnTop() { return TRUE; }
};
#endif
- // __GTKDCSCREENH__
+ // _WX_DCSCREEN_H_
/////////////////////////////////////////////////////////////////////////////
// Name: dialog.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxDialog class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKDIALOGH__
-#define __GTKDIALOGH__
+#ifndef _WX_DIALOG_H_
+#define _WX_DIALOG_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "dialog.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
-#include "wx/event.h"
-#include "wx/window.h"
+#include "wx/panel.h"
-//-----------------------------------------------------------------------------
-// forward decls
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxDialogNameStr;
-class wxRadioBox;
+// Dialog boxes
+class WXDLLEXPORT wxDialog: public wxPanel
+{
+ DECLARE_DYNAMIC_CLASS(wxDialog)
+public:
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+ wxDialog();
-class wxDialog;
+ // Constructor with a modal flag, but no window id - the old convention
+ inline wxDialog(wxWindow *parent,
+ const wxString& title, bool modal,
+ int x = -1, int y= -1, int width = 500, int height = 500,
+ long style = wxDEFAULT_DIALOG_STYLE,
+ const wxString& name = wxDialogNameStr)
+ {
+ long modalStyle = modal ? wxDIALOG_MODAL : wxDIALOG_MODELESS ;
+ Create(parent, -1, title, wxPoint(x, y), wxSize(width, height), style|modalStyle, name);
+ }
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+ // Constructor with no modal flag - the new convention.
+ inline wxDialog(wxWindow *parent, wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_DIALOG_STYLE,
+ const wxString& name = wxDialogNameStr)
+ {
+ Create(parent, id, title, pos, size, style, name);
+ }
-extern const char *wxDialogNameStr;
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxString& title, // bool modal = FALSE, // TODO make this a window style?
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_DIALOG_STYLE,
+ const wxString& name = wxDialogNameStr);
-//-----------------------------------------------------------------------------
-// wxDialog
-//-----------------------------------------------------------------------------
+ ~wxDialog();
-class wxDialog: public wxWindow
-{
- DECLARE_DYNAMIC_CLASS(wxDialog)
+ virtual bool Destroy();
+ void SetClientSize(int width, int height);
+ void GetPosition(int *x, int *y) const;
+ bool Show(bool show);
+ void Iconize(bool iconize);
+
+ virtual bool IsIconized() const;
+ void Fit();
+
+ void SetTitle(const wxString& title);
+ wxString GetTitle() const ;
- public:
-
- wxDialog(void);
- wxDialog( wxWindow *parent, wxWindowID id, const wxString &title,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = wxDEFAULT_DIALOG_STYLE, const wxString &name = wxDialogNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxString &title,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = wxDEFAULT_DIALOG_STYLE, const wxString &name = wxDialogNameStr );
- ~wxDialog(void);
- void SetTitle(const wxString& title);
- wxString GetTitle(void) const;
- bool OnClose(void);
- void OnApply( wxCommandEvent &event );
- void OnCancel( wxCommandEvent &event );
- void OnOk( wxCommandEvent &event );
- void OnPaint(wxPaintEvent& event);
- bool Destroy(void);
- void OnCloseWindow(wxCloseEvent& event);
-/*
- void OnCharHook(wxKeyEvent& event);
-*/
- virtual bool Show( bool show );
- virtual int ShowModal(void);
- virtual void EndModal(int retCode);
- virtual bool IsModal(void) const { return ((GetWindowStyleFlag() & wxDIALOG_MODAL) == wxDIALOG_MODAL); }
- virtual void InitDialog(void);
-
- private:
-
- friend wxWindow;
- friend wxDC;
- friend wxRadioBox;
- bool m_modalShowing;
- wxString m_title;
-
- DECLARE_EVENT_TABLE()
-
+ bool OnClose();
+ void OnCharHook(wxKeyEvent& event);
+ void OnCloseWindow(wxCloseEvent& event);
+
+ void SetModal(bool flag);
+
+ virtual void Centre(int direction = wxBOTH);
+ virtual bool IsModal() const { return ((GetWindowStyleFlag() & wxDIALOG_MODAL) == wxDIALOG_MODAL); }
+
+ virtual int ShowModal();
+ virtual void EndModal(int retCode);
+
+ // Standard buttons
+ void OnOK(wxCommandEvent& event);
+ void OnApply(wxCommandEvent& event);
+ void OnCancel(wxCommandEvent& event);
+
+ // Responds to colour changes
+ void OnSysColourChanged(wxSysColourChangedEvent& event);
+
+DECLARE_EVENT_TABLE()
};
-#endif // __GTKDIALOGH__
+#endif
+ // _WX_DIALOG_H_
/////////////////////////////////////////////////////////////////////////////
// Name: dirdlg.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxDirDialog class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __DIRDIALOGH__
-#define __DIRDIALOGH__
+#ifndef _WX_DIRDLG_H_
+#define _WX_DIRDLG_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "dirdlg.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
-#include "wx/control.h"
#include "wx/dialog.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxDirDialog: public wxDialog
+{
+DECLARE_DYNAMIC_CLASS(wxDirDialog)
+public:
+ wxDirDialog(wxWindow *parent, const wxString& message = wxFileSelectorPromptStr,
+ const wxString& defaultPath = "",
+ long style = 0, const wxPoint& pos = wxDefaultPosition);
+
+ inline void SetMessage(const wxString& message) { m_message = message; }
+ inline void SetPath(const wxString& path) { m_path = path; }
+ inline void SetStyle(long style) { m_dialogStyle = style; }
-class wxDirDialog;
+ inline wxString GetMessage() const { return m_message; }
+ inline wxString GetPath() const { return m_path; }
+ inline long GetStyle() const { return m_dialogStyle; }
-//-----------------------------------------------------------------------------
-// wxDirDialog
-//-----------------------------------------------------------------------------
+ int ShowModal();
-#endif // __DIRDIALOGH__
+protected:
+ wxString m_message;
+ long m_dialogStyle;
+ wxWindow * m_parent;
+ wxString m_path;
+};
+
+#endif
+ // _WX_DIRDLG_H_
/////////////////////////////////////////////////////////////////////////////
// Name: filedlg.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxFileDialog class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKFILEDLGH__
-#define __GTKFILEDLGH__
+#ifndef _WX_FILEDLG_H_
+#define _WX_FILEDLG_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "filedlg.h"
#endif
#include "wx/dialog.h"
-//-------------------------------------------------------------------------
-// File selector
-//-------------------------------------------------------------------------
+/*
+ * File selector
+ */
-extern const char *wxFileSelectorPromptStr;
-extern const char *wxFileSelectorDefaultWildcardStr;
+WXDLLEXPORT_DATA(extern const char*) wxFileSelectorPromptStr;
+WXDLLEXPORT_DATA(extern const char*) wxFileSelectorDefaultWildcardStr;
-class wxFileDialog: public wxDialog
+class WXDLLEXPORT wxFileDialog: public wxDialog
{
-
- DECLARE_DYNAMIC_CLASS(wxFileDialog)
-
- public:
-
- wxFileDialog() {};
-
+DECLARE_DYNAMIC_CLASS(wxFileDialog)
+protected:
+ wxString m_message;
+ long m_dialogStyle;
+ wxWindow * m_parent;
+ wxString m_dir;
+ wxString m_path; // Full path
+ wxString m_fileName;
+ wxString m_wildCard;
+ int m_filterIndex;
+public:
wxFileDialog(wxWindow *parent, const wxString& message = wxFileSelectorPromptStr,
- const wxString& defaultDir = "", const wxString& defaultFile = "",
- const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
+ const wxString& defaultDir = "", const wxString& defaultFile = "", const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = 0, const wxPoint& pos = wxDefaultPosition);
inline void SetMessage(const wxString& message) { m_message = message; }
inline void SetStyle(long style) { m_dialogStyle = style; }
inline void SetFilterIndex(int filterIndex) { m_filterIndex = filterIndex; }
- inline wxString GetMessage(void) const { return m_message; }
- inline wxString GetPath(void) const { return m_path; }
- inline wxString GetDirectory(void) const { return m_dir; }
- inline wxString GetFilename(void) const { return m_fileName; }
- inline wxString GetWildcard(void) const { return m_wildCard; }
- inline long GetStyle(void) const { return m_dialogStyle; }
- inline int GetFilterIndex(void) const { return m_filterIndex ; }
+ inline wxString GetMessage() const { return m_message; }
+ inline wxString GetPath() const { return m_path; }
+ inline wxString GetDirectory() const { return m_dir; }
+ inline wxString GetFilename() const { return m_fileName; }
+ inline wxString GetWildcard() const { return m_wildCard; }
+ inline long GetStyle() const { return m_dialogStyle; }
+ inline int GetFilterIndex() const { return m_filterIndex ; }
- int ShowModal(void);
-
- protected:
-
- wxString m_message;
- long m_dialogStyle;
- wxWindow * m_parent;
- wxString m_dir;
- wxString m_path; // Full path
- wxString m_fileName;
- wxString m_wildCard;
- int m_filterIndex;
+ int ShowModal();
};
-#define wxOPEN 1
-#define wxSAVE 2
-#define wxOVERWRITE_PROMPT 4
-#define wxHIDE_READONLY 8
-#define wxFILE_MUST_EXIST 16
+#define wxOPEN 0x0001
+#define wxSAVE 0x0002
+#define wxOVERWRITE_PROMPT 0x0004
+#define wxHIDE_READONLY 0x0008
+#define wxFILE_MUST_EXIST 0x0010
// File selector - backward compatibility
+char* WXDLLEXPORT wxFileSelector(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
+ const char *default_filename = NULL, const char *default_extension = NULL,
+ const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
+ wxWindow *parent = NULL, int x = -1, int y = -1);
-char* wxFileSelector(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
- const char *default_filename = NULL, const char *default_extension = NULL,
- const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
- wxWindow *parent = NULL, int x = -1, int y = -1);
-
-char* wxLoadFileSelector(const char *what, const char *extension, const char *default_name = NULL,
- wxWindow *parent = NULL);
-
-char* wxSaveFileSelector(const char *what, const char *extension, const char *default_name = NULL,
- wxWindow *parent = NULL);
+// An extended version of wxFileSelector
+char* WXDLLEXPORT wxFileSelectorEx(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
+ const char *default_filename = NULL, int *indexDefaultExtension = NULL,
+ const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
+ wxWindow *parent = NULL, int x = -1, int y = -1);
+// Generic file load dialog
+char* WXDLLEXPORT wxLoadFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL);
+// Generic file save dialog
+char* WXDLLEXPORT wxSaveFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL);
#endif
- // __GTKFILEDLGH__
+ // _WX_FILEDLG_H_
/////////////////////////////////////////////////////////////////////////////
// Name: font.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxFont class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKFONTH__
-#define __GTKFONTH__
+#ifndef _WX_FONT_H_
+#define _WX_FONT_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "font.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
-#include "wx/hash.h"
#include "wx/gdiobj.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxDC;
-class wxPaintDC;
-class wxWindow;
+class WXDLLEXPORT wxFont;
-class wxFont;
-class wxFontNameDirectory;
-
-//-----------------------------------------------------------------------------
-// global variables
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxFontRefData: public wxGDIRefData
+{
+ friend class WXDLLEXPORT wxFont;
+public:
+ wxFontRefData();
+ ~wxFontRefData();
+protected:
+ int m_pointSize;
+ int m_family;
+ int m_style;
+ int m_weight;
+ bool m_underlined;
+ wxString m_faceName;
+/* TODO: implementation
+ WXHFONT m_hFont;
+*/
+};
-// extern wxFontNameDirectory wxTheFontNameDirectory; // defined below
+#define M_FONTDATA ((wxFontRefData *)m_refData)
-//-----------------------------------------------------------------------------
-// wxFont
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
-class wxFont: public wxGDIObject
+// Font
+class WXDLLEXPORT wxFont: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxFont)
-
- public:
- wxFont(void);
- wxFont( int PointSize, int FontIdOrFamily, int Style, int Weight,
- bool underlined = FALSE, const char *Face=NULL );
- wxFont( int PointSize, const char *Face, int Family, int Style, int Weight,
- bool underlined = FALSE );
- wxFont( const wxFont& font );
- wxFont( const wxFont* font );
- ~wxFont(void);
- wxFont& operator = ( const wxFont& font );
- bool operator == ( const wxFont& font );
- bool operator != ( const wxFont& font );
- bool Ok();
-
- int GetPointSize(void) const;
- wxString GetFaceName(void) const;
- int GetFamily(void) const;
- wxString GetFamilyString(void) const;
- int GetFontId(void) const;
- wxString GetFaceString(void) const;
- int GetStyle(void) const;
- wxString GetStyleString(void) const;
- int GetWeight(void) const;
- wxString GetWeightString(void) const;
- bool GetUnderlined(void) const;
-
- wxFont( char *xFontName );
-
- private:
-
- friend wxDC;
- friend wxPaintDC;
- friend wxWindow;
-
- // no data :-)
+public:
+ wxFont();
+ wxFont(int pointSize, int family, int style, int weight, bool underlined = FALSE, const wxString& faceName = wxEmptyString);
+ inline wxFont(const wxFont& font) { Ref(font); }
+ inline wxFont(const wxFont* font) { if (font) Ref(*font); }
+
+ ~wxFont();
+
+ bool Create(int pointSize, int family, int style, int weight, bool underlined = FALSE, const wxString& faceName = wxEmptyString);
+
+ virtual bool Ok() const { return (m_refData != NULL) ; }
+
+ inline int GetPointSize() const { return M_FONTDATA->m_pointSize; }
+ inline int GetFamily() const { return M_FONTDATA->m_family; }
+ inline int GetStyle() const { return M_FONTDATA->m_style; }
+ inline int GetWeight() const { return M_FONTDATA->m_weight; }
+ wxString GetFamilyString() const ;
+ wxString GetFaceName() const ;
+ wxString GetStyleString() const ;
+ wxString GetWeightString() const ;
+ inline bool GetUnderlined() const { return M_FONTDATA->m_underlined; }
+
+ void SetPointSize(int pointSize);
+ void SetFamily(int family);
+ void SetStyle(int style);
+ void SetWeight(int weight);
+ void SetFaceName(const wxString& faceName);
+ void SetUnderlined(bool underlined);
+
+ inline wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; }
+ inline bool operator == (const wxFont& font) { return m_refData == font.m_refData; }
+ inline bool operator != (const wxFont& font) { return m_refData != font.m_refData; }
+
+ // Implementation
+protected:
+ void Unshare();
};
-#endif // __GTKFONTH__
+#endif
+ // _WX_FONT_H_
/////////////////////////////////////////////////////////////////////////////
// Name: frame.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxFrame class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKFRAMEH__
-#define __GTKFRAMEH__
+#ifndef _WX_FRAME_H_
+#define _WX_FRAME_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "frame.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
#include "wx/window.h"
+#include "wx/toolbar.h"
+#include "wx/accel.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxMDIChildFrame;
-class wxMDIClientWindow;
-class wxMenu;
-class wxMenuBar;
-class wxToolBar;
-class wxStatusBar;
-
-class wxFrame;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxToolBarNameStr;
-extern const char *wxFrameNameStr;
-extern const char *wxToolBarNameStr;
+class WXDLLEXPORT wxMenuBar;
+class WXDLLEXPORT wxStatusBar;
-//-----------------------------------------------------------------------------
-// wxFrame
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxFrame: public wxWindow {
-class wxFrame: public wxWindow
-{
DECLARE_DYNAMIC_CLASS(wxFrame)
-public:
+public:
wxFrame();
- wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = wxDEFAULT_FRAME_STYLE, const wxString &name = wxFrameNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxString &title,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = wxDEFAULT_FRAME_STYLE, const wxString &name = wxFrameNameStr );
+ inline wxFrame(wxWindow *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE,
+ const wxString& name = wxFrameNameStr)
+ {
+ Create(parent, id, title, pos, size, style, name);
+ }
+
~wxFrame();
- bool Destroy();
- virtual bool Show( bool show );
- virtual void Enable( bool enable );
+ bool Create(wxWindow *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE,
+ const wxString& name = wxFrameNameStr);
+
+ virtual bool Destroy();
+ void SetClientSize(int width, int height);
+ void GetClientSize(int *width, int *height) const;
+
+ void GetSize(int *width, int *height) const ;
+ void GetPosition(int *x, int *y) const ;
+ void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+
+ virtual bool OnClose();
+
+ void OnSize(wxSizeEvent& event);
+ void OnMenuHighlight(wxMenuEvent& event);
+ void OnActivate(wxActivateEvent& event);
+ void OnIdle(wxIdleEvent& event);
+ void OnCloseWindow(wxCloseEvent& event);
+
+ bool Show(bool show);
+
+ // Set menu bar
+ void SetMenuBar(wxMenuBar *menu_bar);
+ virtual wxMenuBar *GetMenuBar() const ;
+
+ // Set title
+ void SetTitle(const wxString& title);
+ wxString GetTitle() const ;
- virtual void GetClientSize( int *width, int *height ) const;
-
- // set minimal/maxmimal size for the frame
- virtual void SetSizeHints( int minW, int minH, int maxW, int maxH, int incW = -1 );
+ void Centre(int direction = wxBOTH);
+ // Call this to simulate a menu command
+ virtual void Command(int id);
+ virtual void ProcessCommand(int id);
+
+ // Set icon
+ virtual void SetIcon(const wxIcon& icon);
+
+ // Create status line
virtual wxStatusBar* CreateStatusBar(int number=1, long style = wxST_SIZEGRIP, wxWindowID id = 0,
const wxString& name = "statusBar");
- virtual wxStatusBar *GetStatusBar();
- virtual void SetStatusText( const wxString &text, int number = 0 );
- virtual void SetStatusWidths( int n, int *width );
-
- virtual wxToolBar* CreateToolBar( long style = wxNO_BORDER|wxTB_HORIZONTAL, wxWindowID id = -1,
- const wxString& name = wxToolBarNameStr);
- virtual wxToolBar *GetToolBar();
-
- virtual void SetMenuBar( wxMenuBar *menuBar );
- virtual wxMenuBar *GetMenuBar();
-
- virtual void SetTitle( const wxString &title );
- virtual wxString GetTitle() const { return m_title; }
-
- virtual void SetIcon( const wxIcon &icon );
-
- void OnActivate( wxActivateEvent &WXUNUSED(event) ) { } // called from docview.cpp
- void OnSize( wxSizeEvent &event );
- void OnCloseWindow( wxCloseEvent& event );
- void OnIdle(wxIdleEvent& event);
+ inline wxStatusBar *GetStatusBar() const { return m_frameStatusBar; }
+ virtual void PositionStatusBar();
+ virtual wxStatusBar *OnCreateStatusBar(int number, long style, wxWindowID id,
+ const wxString& name);
+
+ // Create toolbar
+ virtual wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL, wxWindowID id = -1, const wxString& name = wxToolBarNameStr);
+ virtual wxToolBar *OnCreateToolBar(long style, wxWindowID id, const wxString& name);
+ // If made known to the frame, the frame will manage it automatically.
+ virtual inline void SetToolBar(wxToolBar *toolbar) { m_frameToolBar = toolbar; }
+ virtual inline wxToolBar *GetToolBar() const { return m_frameToolBar; }
+ virtual void PositionToolBar();
+
+ // Set status line text
+ virtual void SetStatusText(const wxString& text, int number = 0);
+
+ // Set status line widths
+ virtual void SetStatusWidths(int n, const int widths_field[]);
+
+ // Hint to tell framework which status bar to use
+ // TODO: should this go into a wxFrameworkSettings class perhaps?
+ static void UseNativeStatusBar(bool useNative) { m_useNativeStatusBar = useNative; };
+ static bool UsesNativeStatusBar() { return m_useNativeStatusBar; };
+
+ // Fit frame around subwindows
+ virtual void Fit();
-private:
- friend wxWindow;
- friend wxMDIChildFrame;
- friend wxMDIClientWindow;
+ // Iconize
+ virtual void Iconize(bool iconize);
- // update frame's menus (called from OnIdle)
+ virtual bool IsIconized() const ;
+
+ // Compatibility
+ inline bool Iconized() const { return IsIconized(); }
+
+ virtual void Maximize(bool maximize);
+
+ virtual void SetAcceleratorTable(const wxAcceleratorTable& accel);
+
+ // Responds to colour changes
+ void OnSysColourChanged(wxSysColourChangedEvent& event);
+
+ // Query app for menu item updates (called from OnIdle)
void DoMenuUpdates();
void DoMenuUpdates(wxMenu* menu);
- wxMenuBar *m_frameMenuBar;
- wxStatusBar *m_frameStatusBar;
- wxToolBar *m_frameToolBar;
- int m_toolBarHeight;
- wxString m_title;
- wxIcon m_icon;
+ // Checks if there is a toolbar, and returns the first free client position
+ virtual wxPoint GetClientAreaOrigin() const;
+
+protected:
+ wxMenuBar * m_frameMenuBar;
+ wxStatusBar * m_frameStatusBar;
+ wxIcon m_icon;
+ bool m_iconized;
+ static bool m_useNativeStatusBar;
+ wxToolBar * m_frameToolBar ;
+ wxAcceleratorTable m_acceleratorTable;
DECLARE_EVENT_TABLE()
};
-#endif // __GTKFRAMEH__
+#endif
+ // _WX_FRAME_H_
/////////////////////////////////////////////////////////////////////////////
// Name: gauge.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxGauge class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKGAUGEH__
-#define __GTKGAUGEH__
+#ifndef _WX_GAUGE_H_
+#define _WX_GAUGE_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "gauge.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxGauge;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const char* wxGaugeNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxGaugeNameStr;
-//-----------------------------------------------------------------------------
-// wxGaugeBox
-//-----------------------------------------------------------------------------
-
-class wxGauge: public wxControl
+// Group box
+class WXDLLEXPORT wxGauge: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxGauge)
-
- public:
- inline wxGauge(void) { m_rangeMax = 0; m_gaugePos = 0; m_useProgressBar = TRUE; }
+ public:
+ inline wxGauge() { m_rangeMax = 0; m_gaugePos = 0; }
inline wxGauge(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
+ const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr)
{
- Create(parent, id, range, pos, size, style, name);
- };
+ Create(parent, id, range, pos, size, style, validator, name);
+ }
bool Create(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
- const wxString& name = wxGaugeNameStr );
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxGaugeNameStr);
+
+ void SetShadowWidth(int w);
+ void SetBezelFace(int w);
+ void SetRange(int r);
+ void SetValue(int pos);
- void SetShadowWidth( int WXUNUSED(w) ) {};
- void SetBezelFace( int WXUNUSED(w) ) {};
- void SetRange( int r );
- void SetValue( int pos );
- int GetShadowWidth(void) const { return 0; };
- int GetBezelFace(void) const { return 0; };
- int GetRange(void) const;
- int GetValue(void) const;
+ int GetShadowWidth() const ;
+ int GetBezelFace() const ;
+ int GetRange() const ;
+ int GetValue() const ;
- // Are we a Win95/GTK progress bar, or a normal gauge?
- inline bool GetProgressBar(void) const { return m_useProgressBar; }
+ void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+
+ virtual void Command(wxCommandEvent& WXUNUSED(event)) {} ;
protected:
-
int m_rangeMax;
int m_gaugePos;
- bool m_useProgressBar;
};
-#endif // __GTKGAUGEH__
+#endif
+ // _WX_GAUGE_H_
/////////////////////////////////////////////////////////////////////////////
// Name: gdiobj.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxGDIObject class: base class for other GDI classes
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GDIOBJH__
-#define __GDIOBJH__
+#ifndef _WX_GDIOBJ_H_
+#define _WX_GDIOBJ_H_
#include "wx/object.h"
#ifdef __GNUG__
-#pragma interface
+#pragma interface "gdiobj.h"
#endif
+class WXDLLEXPORT wxGDIRefData: public wxObjectRefData {
+public:
+ inline wxGDIRefData()
+ {
+ }
+};
+
+#define M_GDIDATA ((wxGDIRefData *)m_refData)
+
class WXDLLEXPORT wxGDIObject: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxGDIObject)
public:
- inline wxGDIObject(void) { m_visible = FALSE; };
- inline ~wxGDIObject(void) {};
+ inline wxGDIObject() { m_visible = FALSE; };
+ inline ~wxGDIObject() {};
+
+ inline bool IsNull() const { return (m_refData == 0); }
- virtual bool GetVisible(void) { return m_visible; }
+ virtual bool GetVisible() { return m_visible; }
virtual void SetVisible(bool v) { m_visible = v; }
protected:
};
#endif
- // __GDIOBJH__
+ // _WX_GDIOBJ_H_
/////////////////////////////////////////////////////////////////////////////
// Name: icon.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxIcon class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKICONH__
-#define __GTKICONH__
+#ifndef _WX_ICON_H_
+#define _WX_ICON_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "icon.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
#include "wx/bitmap.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxIconRefData: public wxBitmapRefData
+{
+ friend class WXDLLEXPORT wxBitmap;
+ friend class WXDLLEXPORT wxIcon;
+public:
+ wxIconRefData();
+ ~wxIconRefData();
-class wxIcon;
+public:
+/* TODO: whatever your actual icon handle is
+ WXHICON m_hIcon;
+*/
+};
-//-----------------------------------------------------------------------------
-// wxIcon
-//-----------------------------------------------------------------------------
+#define M_ICONDATA ((wxIconRefData *)m_refData)
+#define M_ICONHANDLERDATA ((wxIconRefData *)bitmap->GetRefData())
-class wxIcon: public wxBitmap
+// Icon
+class WXDLLEXPORT wxIcon: public wxBitmap
{
DECLARE_DYNAMIC_CLASS(wxIcon)
public:
+ wxIcon();
- wxIcon(void) {};
-
+ // Copy constructors
inline wxIcon(const wxIcon& icon) { Ref(icon); }
inline wxIcon(const wxIcon* icon) { if (icon) Ref(*icon); }
- wxIcon( char **bits, int width=-1, int height=-1 );
-
+
+ wxIcon(const char bits[], int width, int height);
+ wxIcon(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE,
+ int desiredWidth = -1, int desiredHeight = -1);
+ ~wxIcon();
+
+ bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE,
+ int desiredWidth = -1, int desiredHeight = -1);
+
inline wxIcon& operator = (const wxIcon& icon) { if (*this == icon) return (*this); Ref(icon); return *this; }
inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; }
inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; }
+
+/* TODO: implementation
+ void SetHICON(WXHICON ico);
+ inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); }
+*/
+
+/* TODO */
+ virtual bool Ok() const { return (m_refData != NULL) ; }
+};
+
+/* Example handlers. TODO: write your own handlers for relevant types.
+
+class WXDLLEXPORT wxICOFileHandler: public wxBitmapHandler
+{
+ DECLARE_DYNAMIC_CLASS(wxICOFileHandler)
+public:
+ inline wxICOFileHandler()
+ {
+ m_name = "ICO icon file";
+ m_extension = "ico";
+ m_type = wxBITMAP_TYPE_ICO;
+ };
+
+ virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
+ int desiredWidth = -1, int desiredHeight = -1);
+};
+
+class WXDLLEXPORT wxICOResourceHandler: public wxBitmapHandler
+{
+ DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
+public:
+ inline wxICOResourceHandler()
+ {
+ m_name = "ICO resource";
+ m_extension = "ico";
+ m_type = wxBITMAP_TYPE_ICO_RESOURCE;
+ };
+
+ virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
+ int desiredWidth = -1, int desiredHeight = -1);
+
};
+*/
-#endif // __GTKICONH__
+#endif
+ // _WX_ICON_H_
/////////////////////////////////////////////////////////////////////////////
// Name: joystick.h
// Purpose: wxJoystick class
-// Author: Guilhem Lavaux
+// Author: AUTHOR
// Modified by:
-// Created: 01/02/97
+// Created: ??/??/98
// RCS-ID: $Id$
-// Copyright:
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef __JOYSTICKH__
-#define __JOYSTICKH__
+#ifndef _WX_JOYSTICK_H_
+#define _WX_JOYSTICK_H_
#ifdef __GNUG__
#pragma interface "joystick.h"
#endif
#include "wx/event.h"
-#include "wx/thread.h"
-class WXDLLEXPORT wxJoystick: public wxObject, public wxThread
+class WXDLLEXPORT wxJoystick: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxJoystick)
public:
* Public interface
*/
- wxJoystick(int joystick = wxJOYSTICK1);
+ wxJoystick(int joystick = wxJOYSTICK1) { m_joystick = joystick; };
// Attributes
////////////////////////////////////////////////////////////////////////////
- wxPoint GetPosition(void) const;
- int GetZPosition(void) const;
- int GetButtonState(void) const;
- int GetPOVPosition(void) const;
- int GetPOVCTSPosition(void) const;
- int GetRudderPosition(void) const;
- int GetUPosition(void) const;
- int GetVPosition(void) const;
- int GetMovementThreshold(void) const;
+ wxPoint GetPosition() const;
+ int GetZPosition() const;
+ int GetButtonState() const;
+ int GetPOVPosition() const;
+ int GetPOVCTSPosition() const;
+ int GetRudderPosition() const;
+ int GetUPosition() const;
+ int GetVPosition() const;
+ int GetMovementThreshold() const;
void SetMovementThreshold(int threshold) ;
// Capabilities
////////////////////////////////////////////////////////////////////////////
- bool IsOk(void) const; // Checks that the joystick is functioning
- int GetNumberJoysticks(void) const ;
- int GetManufacturerId(void) const ;
- int GetProductId(void) const ;
- wxString GetProductName(void) const ;
- int GetXMin(void) const;
- int GetYMin(void) const;
- int GetZMin(void) const;
- int GetXMax(void) const;
- int GetYMax(void) const;
- int GetZMax(void) const;
- int GetNumberButtons(void) const;
- int GetNumberAxes(void) const;
- int GetMaxButtons(void) const;
- int GetMaxAxes(void) const;
- int GetPollingMin(void) const;
- int GetPollingMax(void) const;
- int GetRudderMin(void) const;
- int GetRudderMax(void) const;
- int GetUMin(void) const;
- int GetUMax(void) const;
- int GetVMin(void) const;
- int GetVMax(void) const;
-
- bool HasRudder(void) const;
- bool HasZ(void) const;
- bool HasU(void) const;
- bool HasV(void) const;
- bool HasPOV(void) const;
- bool HasPOV4Dir(void) const;
- bool HasPOVCTS(void) const;
+ bool IsOk() const; // Checks that the joystick is functioning
+ int GetNumberJoysticks() const ;
+ int GetManufacturerId() const ;
+ int GetProductId() const ;
+ wxString GetProductName() const ;
+ int GetXMin() const;
+ int GetYMin() const;
+ int GetZMin() const;
+ int GetXMax() const;
+ int GetYMax() const;
+ int GetZMax() const;
+ int GetNumberButtons() const;
+ int GetNumberAxes() const;
+ int GetMaxButtons() const;
+ int GetMaxAxes() const;
+ int GetPollingMin() const;
+ int GetPollingMax() const;
+ int GetRudderMin() const;
+ int GetRudderMax() const;
+ int GetUMin() const;
+ int GetUMax() const;
+ int GetVMin() const;
+ int GetVMax() const;
+
+ bool HasRudder() const;
+ bool HasZ() const;
+ bool HasU() const;
+ bool HasV() const;
+ bool HasPOV() const;
+ bool HasPOV4Dir() const;
+ bool HasPOVCTS() const;
// Operations
////////////////////////////////////////////////////////////////////////////
// pollingFreq = 0 means that movement events are sent when above the threshold.
// If pollingFreq > 0, events are received every this many milliseconds.
bool SetCapture(wxWindow* win, int pollingFreq = 0);
- bool ReleaseCapture(void);
+ bool ReleaseCapture();
protected:
int m_joystick;
- wxPoint m_lastposition;
- int m_axe[15];
- int m_buttons;
- wxWindow *m_catchwin;
- int m_polling;
-
- void *Entry(void);
};
#endif
- // __JOYSTICKH__
-
+ // _WX_JOYSTICK_H_
/////////////////////////////////////////////////////////////////////////////
// Name: listbox.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxListBox class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKLISTBOXH__
-#define __GTKLISTBOXH__
+#ifndef _WX_LISTBOX_H_
+#define _WX_LISTBOX_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "listbox.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxListBox;
+WXDLLEXPORT_DATA(extern const char*) wxListBoxNameStr;
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+// forward decl for GetSelections()
+class WXDLLEXPORT wxArrayInt;
-extern const char *wxListBoxNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
-//-----------------------------------------------------------------------------
-// wxListBox
-//-----------------------------------------------------------------------------
-
-class wxListBox: public wxControl
+// List box item
+class WXDLLEXPORT wxListBox: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxListBox)
+ public:
+
+ wxListBox();
+ inline wxListBox(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxListBoxNameStr)
+ {
+ Create(parent, id, pos, size, n, choices, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxListBoxNameStr);
+
+ ~wxListBox();
+
+ virtual void Append(const wxString& item);
+ virtual void Append(const wxString& item, char *clientData);
+ virtual void Set(int n, const wxString* choices, char **clientData = NULL);
+ virtual int FindString(const wxString& s) const ;
+ virtual void Clear();
+ virtual void SetSelection(int n, bool select = TRUE);
- public:
-
- wxListBox(void);
- wxListBox( wxWindow *parent, wxWindowID id,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- int n = 0, const wxString choices[] = NULL,
- long style = 0, const wxString &name = wxListBoxNameStr );
- bool Create( wxWindow *parent, wxWindowID id,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- int n = 0, const wxString choices[] = NULL,
- long style = 0, const wxString &name = wxListBoxNameStr );
- void Append( const wxString &item );
- void Append( const wxString &item, char *clientData );
- void Clear(void);
- void Delete( int n );
- void Deselect( int n );
- int FindString( const wxString &item ) const;
- char *GetClientData( int n ) const;
- int GetSelection(void) const;
- int GetSelections( class wxArrayInt &) const;
- wxString GetString( int n ) const;
- wxString GetStringSelection(void) const;
- int Number(void);
- bool Selected( int n );
- void Set( int n, const wxString *choices );
- void SetClientData( int n, char *clientData );
- void SetFirstItem( int n );
- void SetFirstItem( const wxString &item );
- void SetSelection( int n, bool select = TRUE );
- void SetString( int n, const wxString &string );
- void SetStringSelection( const wxString &string, bool select = TRUE );
+ virtual void Deselect(int n);
+ // For single choice list item only
+ virtual int GetSelection() const ;
+ virtual void Delete(int n);
+ virtual char *GetClientData(int n) const ;
+ virtual void SetClientData(int n, char *clientData);
+ virtual void SetString(int n, const wxString& s);
+
+ // For single or multiple choice list item
+ virtual int GetSelections(wxArrayInt& aSelections) const;
+ virtual bool Selected(int n) const ;
+ virtual wxString GetString(int n) const ;
+ virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+
+ // Set the specified item at the first visible item
+ // or scroll to max range.
+ virtual void SetFirstItem(int n) ;
+ virtual void SetFirstItem(const wxString& s) ;
+
+ virtual void InsertItems(int nItems, const wxString items[], int pos);
+
+ virtual wxString GetStringSelection() const ;
+ virtual bool SetStringSelection(const wxString& s, bool flag = TRUE);
+ virtual int Number() const ;
+
+ void Command(wxCommandEvent& event);
+
+ protected:
+ int m_noItems;
+ int m_selected;
};
-#endif // __GTKLISTBOXH__
+#endif
+ // _WX_LISTBOX_H_
/////////////////////////////////////////////////////////////////////////////
// Name: mdi.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: MDI (Multiple Document Interface) classes.
+// This doesn't have to be implemented just like Windows,
+// it could be a tabbed design as in wxGTK.
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __MDIH__
-#define __MDIH__
+#ifndef _WX_MDI_H_
+#define _WX_MDI_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "mdi.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
-#include "wx/control.h"
-#include "wx/panel.h"
#include "wx/frame.h"
-#include "wx/toolbar.h"
-
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxMDIParentFrame;
-class wxMDIClientWindow;
-class wxMDIChildFrame;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-extern const char* wxFrameNameStr;
-extern const char* wxStatusLineNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxStatusLineNameStr;
-//-----------------------------------------------------------------------------
-// wxMDIParentFrame
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxMDIClientWindow;
+class WXDLLEXPORT wxMDIChildFrame;
-class wxMDIParentFrame: public wxFrame
+class WXDLLEXPORT wxMDIParentFrame: public wxFrame
{
- DECLARE_DYNAMIC_CLASS(wxMDIParentFrame)
-
- friend class wxMDIChildFrame;
-
- public:
-
- wxMDIParentFrame(void);
- wxMDIParentFrame( wxWindow *parent,
- wxWindowID id, const wxString& title,
- const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
- long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
- const wxString& name = wxFrameNameStr );
- ~wxMDIParentFrame(void);
- bool Create( wxWindow *parent,
- wxWindowID id, const wxString& title,
- const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
- long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
- const wxString& name = wxFrameNameStr );
-
-
- void GetClientSize(int *width, int *height) const;
- wxMDIChildFrame *GetActiveChild(void) const;
-
- wxMDIClientWindow *GetClientWindow(void) const;
- virtual wxMDIClientWindow *OnCreateClient(void);
-
- virtual void Cascade(void) {};
- virtual void Tile(void) {};
- virtual void ArrangeIcons(void) {};
- virtual void ActivateNext(void);
- virtual void ActivatePrevious(void);
-
- void OnActivate( wxActivateEvent& event );
- void OnSysColourChanged( wxSysColourChangedEvent& event );
-
- //private:
-
- wxMDIChildFrame *m_currentChild;
-
- void SetMDIMenuBar( wxMenuBar *menu_bar );
-
- private:
-
- wxMDIClientWindow *m_clientWindow;
- bool m_parentFrameActive;
- wxMenuBar *m_mdiMenuBar;
-
- DECLARE_EVENT_TABLE()
+DECLARE_DYNAMIC_CLASS(wxMDIParentFrame)
+
+ friend class WXDLLEXPORT wxMDIChildFrame;
+public:
+
+ wxMDIParentFrame();
+ inline wxMDIParentFrame(wxWindow *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL, // Scrolling refers to client window
+ const wxString& name = wxFrameNameStr)
+ {
+ Create(parent, id, title, pos, size, style, name);
+ }
+
+ ~wxMDIParentFrame();
+
+ bool Create(wxWindow *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
+ const wxString& name = wxFrameNameStr);
+
+ void OnSize(wxSizeEvent& event);
+ void OnActivate(wxActivateEvent& event);
+
+ void SetMenuBar(wxMenuBar *menu_bar);
+
+ // Gets the size available for subwindows after menu size, toolbar size
+ // and status bar size have been subtracted. If you want to manage your own
+ // toolbar(s), don't call SetToolBar.
+ void GetClientSize(int *width, int *height) const;
+
+ // Get the active MDI child window (Windows only)
+ wxMDIChildFrame *GetActiveChild() const ;
+
+ // Get the client window
+ inline wxMDIClientWindow *GetClientWindow() const { return m_clientWindow; };
+
+ // Create the client window class (don't Create the window,
+ // just return a new class)
+ virtual wxMDIClientWindow *OnCreateClient() ;
+
+ // MDI operations
+ virtual void Cascade();
+ virtual void Tile();
+ virtual void ArrangeIcons();
+ virtual void ActivateNext();
+ virtual void ActivatePrevious();
+
+protected:
+
+DECLARE_EVENT_TABLE()
};
-//-----------------------------------------------------------------------------
-// wxMDIChildFrame
-//-----------------------------------------------------------------------------
-
-class wxMDIChildFrame: public wxFrame
+class WXDLLEXPORT wxMDIChildFrame: public wxFrame
{
- DECLARE_DYNAMIC_CLASS(wxMDIChildFrame)
-
- public:
-
- wxMDIChildFrame(void);
- wxMDIChildFrame( wxMDIParentFrame *parent,
- wxWindowID id, const wxString& title,
- const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
- long style = wxDEFAULT_FRAME_STYLE, const wxString& name = wxFrameNameStr );
- ~wxMDIChildFrame(void);
- bool Create( wxMDIParentFrame *parent,
- wxWindowID id, const wxString& title,
- const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
- long style = wxDEFAULT_FRAME_STYLE, const wxString& name = wxFrameNameStr );
-
- virtual void SetMenuBar( wxMenuBar *menu_bar );
- virtual wxMenuBar *GetMenuBar();
-
- virtual void GetClientSize( int *width, int *height ) const;
- virtual void AddChild( wxWindow *child );
-
- virtual void Activate(void);
-
- // no status bars
- virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number), long WXUNUSED(style),
- wxWindowID WXUNUSED(id), const wxString& WXUNUSED(name) ) {return (wxStatusBar*)NULL; }
- virtual wxStatusBar *GetStatusBar() { return (wxStatusBar*)NULL; }
- virtual void SetStatusText( const wxString &WXUNUSED(text), int WXUNUSED(number) ) {}
- virtual void SetStatusWidths( int WXUNUSED(n), int *WXUNUSED(width) ) {}
-
- // no size hints
- virtual void SetSizeHints( int WXUNUSED(minW), int WXUNUSED(minH), int WXUNUSED(maxW),
- int WXUNUSED(maxH), int WXUNUSED(incW) ) {}
-
- // no toolbar bars
- virtual wxToolBar* CreateToolBar( long WXUNUSED(style), wxWindowID WXUNUSED(id),
- const wxString& WXUNUSED(name) ) { return (wxToolBar*)NULL; }
- virtual wxToolBar *GetToolBar() { return (wxToolBar*)NULL; }
-
- // no icon
- void SetIcon( const wxIcon &icon ) { m_icon = icon; }
-
- // no title
- void SetTitle( const wxString &title ) { m_title = title; }
- wxString GetTitle() const { return m_title; }
-
- // no maximize etc
- virtual void Maximize(void) {}
- virtual void Restore(void) {}
-
- void OnActivate( wxActivateEvent &event );
-
- public:
-
- wxMenuBar *m_menuBar;
-
- DECLARE_EVENT_TABLE()
+DECLARE_DYNAMIC_CLASS(wxMDIChildFrame)
+public:
+
+ wxMDIChildFrame();
+ inline wxMDIChildFrame(wxMDIParentFrame *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE,
+ const wxString& name = wxFrameNameStr)
+ {
+ Create(parent, id, title, pos, size, style, name);
+ }
+
+ ~wxMDIChildFrame();
+
+ bool Create(wxMDIParentFrame *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_FRAME_STYLE,
+ const wxString& name = wxFrameNameStr);
+
+ // Set menu bar
+ void SetMenuBar(wxMenuBar *menu_bar);
+ void SetClientSize(int width, int height);
+ void GetPosition(int *x, int *y) const ;
+
+ // MDI operations
+ virtual void Maximize();
+ virtual void Restore();
+ virtual void Activate();
};
-//-----------------------------------------------------------------------------
-// wxMDIClientWindow
-//-----------------------------------------------------------------------------
+/* The client window is a child of the parent MDI frame, and itself
+ * contains the child MDI frames.
+ * However, you create the MDI children as children of the MDI parent:
+ * only in the implementation does the client window become the parent
+ * of the children. Phew! So the children are sort of 'adopted'...
+ */
-class wxMDIClientWindow: public wxWindow
+class WXDLLEXPORT wxMDIClientWindow: public wxWindow
{
DECLARE_DYNAMIC_CLASS(wxMDIClientWindow)
-
- public:
-
- wxMDIClientWindow(void);
- wxMDIClientWindow( wxMDIParentFrame *parent, long style = 0 );
- ~wxMDIClientWindow(void);
- virtual bool CreateClient( wxMDIParentFrame *parent, long style = wxVSCROLL | wxHSCROLL );
- void AddChild( wxWindow *child );
-};
+ public:
+
+ wxMDIClientWindow() ;
+ inline wxMDIClientWindow(wxMDIParentFrame *parent, long style = 0)
+ {
+ CreateClient(parent, style);
+ }
-#endif // __MDIH__
+ ~wxMDIClientWindow();
+ // Note: this is virtual, to allow overridden behaviour.
+ virtual bool CreateClient(wxMDIParentFrame *parent, long style = wxVSCROLL | wxHSCROLL);
+
+ // Explicitly call default scroll behaviour
+ void OnScroll(wxScrollEvent& event);
+
+protected:
+
+DECLARE_EVENT_TABLE()
+};
+
+#endif
+ // _WX_MDI_H_
/////////////////////////////////////////////////////////////////////////////
// Name: menu.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxMenu, wxMenuBar classes
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKMENUH__
-#define __GTKMENUH__
+#ifndef _WX_MENU_H_
+#define _WX_MENU_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "menu.h"
#endif
#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
-#include "wx/window.h"
-
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxMenuBar;
-class wxMenuItem;
-class wxMenu;
-
-//-----------------------------------------------------------------------------
-// const
-//-----------------------------------------------------------------------------
+#include "wx/event.h"
-#define ID_SEPARATOR (-1)
+class WXDLLEXPORT wxMenuItem;
+class WXDLLEXPORT wxMenuBar;
+class WXDLLEXPORT wxMenu;
-//-----------------------------------------------------------------------------
-// wxMenuBar
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
-class wxMenuBar: public wxWindow
+// ----------------------------------------------------------------------------
+// Menu
+// ----------------------------------------------------------------------------
+class WXDLLEXPORT wxMenu: public wxEvtHandler
{
-DECLARE_DYNAMIC_CLASS(wxMenuBar)
+ DECLARE_DYNAMIC_CLASS(wxMenu)
public:
- wxMenuBar();
- void Append( wxMenu *menu, const wxString &title );
-
- int FindMenuItem( const wxString &menuString, const wxString &itemString ) const;
- wxMenuItem* FindMenuItemById( int id ) const;
-
- void Check( int id, bool check );
- bool Checked( int id ) const;
- void Enable( int id, bool enable );
- bool Enabled( int id ) const;
- inline bool IsEnabled(int Id) const { return Enabled(Id); };
- inline bool IsChecked(int Id) const { return Checked(Id); };
+ // ctor & dtor
+ wxMenu(const wxString& title = wxEmptyString, const wxFunction func = NULL);
+ ~wxMenu();
- int GetMenuCount() const { return m_menus.Number(); }
- wxMenu *GetMenu(int n) const { return (wxMenu *)m_menus.Nth(n)->Data(); }
-
- wxList m_menus;
-};
-
-//-----------------------------------------------------------------------------
-// wxMenu
-//-----------------------------------------------------------------------------
-
-class wxMenuItem: public wxObject
-{
-DECLARE_DYNAMIC_CLASS(wxMenuItem)
+ // construct menu
+ // append items to the menu
+ // separator line
+ void AppendSeparator();
+ // normal item
+ void Append(int id, const wxString& Label, const wxString& helpString = wxEmptyString,
+ bool checkable = FALSE);
+ // a submenu
+ void Append(int id, const wxString& Label, wxMenu *SubMenu,
+ const wxString& helpString = wxEmptyString);
+ // the most generic form (create wxMenuItem first and use it's functions)
+ void Append(wxMenuItem *pItem);
+ // insert a break in the menu
+ void Break();
+ // delete an item
+ void Delete(int id);
+
+ // menu item control
+ void Enable(int id, bool Flag);
+ bool Enabled(int id) const;
+ inline bool IsEnabled(int id) const { return Enabled(id); };
+ void Check(int id, bool Flag);
+ bool Checked(int id) const;
+ inline bool IsChecked(int id) const { return IsChecked(id); };
+
+ // item properties
+ // title
+ void SetTitle(const wxString& label);
+ const wxString& GetTitle() const;
+ // label
+ void SetLabel(int id, const wxString& label);
+ wxString GetLabel(int id) const;
+ // help string
+ virtual void SetHelpString(int id, const wxString& helpString);
+ virtual wxString GetHelpString(int id) const ;
+
+ // find item
+ // Finds the item id matching the given string, -1 if not found.
+ virtual int FindItem(const wxString& itemString) const ;
+ // Find wxMenuItem by ID, and item's menu too if itemMenu is !NULL.
+ wxMenuItem *FindItemForId(int itemId, wxMenu **itemMenu = NULL) const;
+
+ void ProcessCommand(wxCommandEvent& event);
+ inline void Callback(const wxFunction func) { m_callback = func; }
+
+ virtual void SetParent(wxEvtHandler *parent) { m_parent = parent; }
+ inline void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; }
+ inline wxEvtHandler *GetEventHandler() { return m_eventHandler; }
+
+ inline wxList& GetItems() const { return (wxList&) m_menuItems; }
public:
- wxMenuItem();
-
- // accessors
- // id
- void SetId(int id) { m_id = id; }
- int GetId() const { return m_id; }
- bool IsSeparator() const { return m_id == ID_SEPARATOR; }
-
- // the item's text
- void SetText(const wxString& str);
- const wxString& GetText() const { return m_text; }
-
- // what kind of menu item we are
- void SetCheckable(bool checkable) { m_isCheckMenu = checkable; }
- bool IsCheckable() const { return m_isCheckMenu; }
- void SetSubMenu(wxMenu *menu) { m_subMenu = menu; }
- wxMenu *GetSubMenu() const { return m_subMenu; }
- bool IsSubMenu() const { return m_subMenu != NULL; }
-
- // state
- void Enable(bool enable = TRUE) { m_isEnabled = enable; }
- bool IsEnabled() const { return m_isEnabled; }
- void Check(bool check = TRUE);
- bool IsChecked() const;
-
- // help string (displayed in the status bar by default)
- void SetHelpString(const wxString& str) { m_helpStr = str; }
-
-
-private:
- int m_id;
- wxString m_text;
- bool m_isCheckMenu;
- bool m_isChecked;
- bool m_isEnabled;
- wxMenu *m_subMenu;
- wxString m_helpStr;
+ wxFunction m_callback;
+
+ int m_noItems;
+ wxString m_title;
+ wxMenuBar * m_menuBar;
+ wxList m_menuItems;
+ wxEvtHandler * m_parent;
+ wxEvtHandler * m_eventHandler;
};
-class wxMenu: public wxEvtHandler
+// ----------------------------------------------------------------------------
+// Menu Bar (a la Windows)
+// ----------------------------------------------------------------------------
+class WXDLLEXPORT wxFrame;
+class WXDLLEXPORT wxMenuBar: public wxEvtHandler
{
-DECLARE_DYNAMIC_CLASS(wxMenu)
+ DECLARE_DYNAMIC_CLASS(wxMenuBar)
-public:
- // construction
- wxMenu( const wxString &title = "" );
-
- // operations
- // menu creation
- void AppendSeparator();
- void Append(int id, const wxString &item,
- const wxString &helpStr = "", bool checkable = FALSE);
- void Append(int id, const wxString &item,
- wxMenu *subMenu, const wxString &helpStr = "" );
- void Break() {};
-
- // find item by name/id
- int FindItem( const wxString itemString ) const;
- wxMenuItem *FindItem(int id) const;
-
- // get/set item's state
- void Enable( int id, bool enable );
- bool IsEnabled( int id ) const;
- void Check( int id, bool check );
- bool IsChecked( int id ) const;
-
- void SetLabel( int id, const wxString &label );
-
- // accessors
- wxList& GetItems() { return m_items; }
-
-public:
- void SetInvokingWindow( wxWindow *win );
- wxWindow *GetInvokingWindow();
-
- wxString m_title;
- wxList m_items;
- wxWindow *m_invokingWindow;
+ wxMenuBar();
+ wxMenuBar(int n, wxMenu *menus[], const wxString titles[]);
+ ~wxMenuBar();
+
+ void Append(wxMenu *menu, const wxString& title);
+ // Must only be used AFTER menu has been attached to frame,
+ // otherwise use individual menus to enable/disable items
+ void Enable(int Id, bool Flag);
+ bool Enabled(int Id) const ;
+ inline bool IsEnabled(int Id) const { return Enabled(Id); };
+ void EnableTop(int pos, bool Flag);
+ void Check(int id, bool Flag);
+ bool Checked(int id) const ;
+ inline bool IsChecked(int Id) const { return Checked(Id); };
+ void SetLabel(int id, const wxString& label) ;
+ wxString GetLabel(int id) const ;
+ void SetLabelTop(int pos, const wxString& label) ;
+ wxString GetLabelTop(int pos) const ;
+ virtual void Delete(wxMenu *menu, int index = 0); /* Menu not destroyed */
+ virtual bool OnAppend(wxMenu *menu, const char *title);
+ virtual bool OnDelete(wxMenu *menu, int index);
+
+ virtual void SetHelpString(int Id, const wxString& helpString);
+ virtual wxString GetHelpString(int Id) const ;
+
+ virtual int FindMenuItem(const wxString& menuString, const wxString& itemString) const ;
+
+ // Find wxMenuItem for item ID, and return item's
+ // menu too if itemMenu is non-NULL.
+ wxMenuItem *FindItemForId(int itemId, wxMenu **menuForItem = NULL) const ;
+
+ inline void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; }
+ inline wxEvtHandler *GetEventHandler() { return m_eventHandler; }
+
+ inline int GetMenuCount() const { return m_menuCount; }
+ inline wxMenu* GetMenu(int i) const { return m_menus[i]; }
+
+ public:
+ wxEvtHandler * m_eventHandler;
+ int m_menuCount;
+ wxMenu ** m_menus;
+ wxString * m_titles;
+ wxFrame * m_menuBarFrame;
+/* TODO: data that represents the actual menubar when created.
+ */
};
-#endif // __GTKMENUH__
+#endif // _WX_MENU_H_
/////////////////////////////////////////////////////////////////////////////
// Name: notebook.h
-// Purpose: wxNotebook class
-// Author: Robert Roebling
+// Purpose: MSW/GTK compatible notebook (a.k.a. property sheet)
+// Author: AUTHOR
// Modified by:
// RCS-ID: $Id$
-// Copyright: (c) Julian Smart and Markus Holzem
-// Licence: wxWindows license
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef __NOTEBOOKH__
-#define __NOTEBOOKH__
+#ifndef _WX_NOTEBOOK_H_
+#define _WX_NOTEBOOK_H_
#ifdef __GNUG__
#pragma interface "notebook.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
-#include "wx/control.h"
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+#include <wx/dynarray.h>
+
+// ----------------------------------------------------------------------------
+// types
+// ----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+// fwd declarations
+class WXDLLEXPORT wxImageList;
+class WXDLLEXPORT wxWindow;
-class wxImageList;
-class wxNotebook;
-class wxNotebookPage;
+// array of notebook pages
+typedef wxWindow wxNotebookPage; // so far, any window can be a page
+WX_DEFINE_ARRAY(wxNotebookPage *, wxArrayPages);
// ----------------------------------------------------------------------------
// notebook events
// ----------------------------------------------------------------------------
-
-class wxNotebookEvent : public wxCommandEvent
+class WXDLLEXPORT wxNotebookEvent : public wxCommandEvent
{
public:
- wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0,
+ wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0,
int nSel = -1, int nOldSel = -1)
: wxCommandEvent(commandType, id) { m_nSel = nSel; m_nOldSel = nOldSel; }
DECLARE_DYNAMIC_CLASS(wxNotebookEvent)
};
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
// wxNotebook
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// @@@ this class should really derive from wxTabCtrl, but the interface is not
+// exactly the same, so I can't do it right now and instead we reimplement
+// part of wxTabCtrl here
class wxNotebook : public wxControl
{
public:
wxNotebook();
// the same arguments as for wxControl (@@@ any special styles?)
wxNotebook(wxWindow *parent,
- wxWindowID id,
+ wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = "notebook");
// Create() function
bool Create(wxWindow *parent,
- wxWindowID id,
+ wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
// cycle thru the tabs
void AdvanceSelection(bool bForward = TRUE);
// get the currently selected page
- int GetSelection() const;
+ int GetSelection() const { return m_nSelection; }
// set/get the title of a page
bool SetPageText(int nPage, const wxString& strText);
// associate image list with a control
void SetImageList(wxImageList* imageList);
// get pointer (may be NULL) to the associated image list
- wxImageList* GetImageList() const { return m_imageList; }
+ wxImageList* GetImageList() const { return m_pImageList; }
// sets/returns item's image index in the current image list
int GetPageImage(int nPage) const;
bool DeleteAllPages();
// adds a new page to the notebook (it will be deleted ny the notebook,
// don't delete it yourself). If bSelect, this page becomes active.
- bool AddPage(wxWindow *pPage,
+ bool AddPage(wxNotebookPage *pPage,
const wxString& strText,
bool bSelect = FALSE,
int imageId = -1);
- // @@@@ VZ: I don't know how to implement InsertPage()
-
+ // the same as AddPage(), but adds it at the specified position
+ bool InsertPage(int nPage,
+ wxNotebookPage *pPage,
+ const wxString& strText,
+ bool bSelect = FALSE,
+ int imageId = -1);
// get the panel which represents the given page
- wxWindow *GetPage(int nPage) const;
-
- // implementation
- // --------------
- // base class virtuals
- virtual void AddChild(wxWindow *child);
- virtual void SetConstraintSizes(bool recurse);
- virtual bool DoPhase(int phase);
+ wxNotebookPage *GetPage(int nPage) { return m_aPages[nPage]; }
-private:
+ // callbacks
+ // ---------
+ void OnSize(wxSizeEvent& event);
+ void OnSelChange(wxNotebookEvent& event);
+ void OnSetFocus(wxFocusEvent& event);
+ void OnNavigationKey(wxNavigationKeyEvent& event);
+
+ // base class virtuals
+ // -------------------
+ virtual void Command(wxCommandEvent& event);
+ virtual void SetConstraintSizes(bool recurse = TRUE);
+ virtual bool DoPhase(int nPhase);
+
+protected:
// common part of all ctors
void Init();
- wxImageList* m_imageList;
- wxList m_pages;
+ // helper functions
+ void ChangePage(int nOldSel, int nSel); // change pages
+
+ wxImageList *m_pImageList; // we can have an associated image list
+ wxArrayPages m_aPages; // array of pages
+
+ int m_nSelection; // the current selection (-1 if none)
DECLARE_DYNAMIC_CLASS(wxNotebook)
+ DECLARE_EVENT_TABLE()
};
// ----------------------------------------------------------------------------
NULL \
},
-#endif
- // __NOTEBOOKH__
+#endif // _WX_NOTEBOOK_H_
/////////////////////////////////////////////////////////////////////////////
// Name: palette.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxPalette class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKPALETTEH__
-#define __GTKPALETTEH__
+#ifndef _WX_PALETTE_H_
+#define _WX_PALETTE_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "palette.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
#include "wx/gdiobj.h"
-#include "wx/gdicmn.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxPalette;
-class wxPalette;
+class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData
+{
+ friend class WXDLLEXPORT wxPalette;
+public:
+ wxPaletteRefData();
+ ~wxPaletteRefData();
+/* TODO: implementation
+protected:
+ WXHPALETTE m_hPalette;
+*/
+};
-//-----------------------------------------------------------------------------
-// wxPalette
-//-----------------------------------------------------------------------------
+#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
-class wxPalette: public wxGDIObject
+class WXDLLEXPORT wxPalette: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxPalette)
- public:
-
- wxPalette(void);
- wxPalette( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue );
- wxPalette( const wxPalette& palette );
- wxPalette( const wxPalette* palette );
- ~wxPalette(void);
- wxPalette& operator = ( const wxPalette& palette );
- bool operator == ( const wxPalette& palette );
- bool operator != ( const wxPalette& palette );
- bool Ok(void) const;
-
- bool Create( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
- int GetPixel( const unsigned char red, const unsigned char green, const unsigned char blue ) const;
- bool GetRGB( int pixel, unsigned char *red, unsigned char *green, unsigned char *blue ) const;
-
- // no data
-};
+public:
+ wxPalette();
+ inline wxPalette(const wxPalette& palette) { Ref(palette); }
+ inline wxPalette(const wxPalette* palette) { UnRef(); if (palette) Ref(*palette); }
+
+ wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
+ ~wxPalette();
+ bool Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
+ int GetPixel(const unsigned char red, const unsigned char green, const unsigned char blue) const;
+ bool GetRGB(int pixel, unsigned char *red, unsigned char *green, unsigned char *blue) const;
-#define wxColorMap wxPalette
-#define wxColourMap wxPalette
+ virtual bool Ok() const { return (m_refData != NULL) ; }
-#endif // __GTKPALETTEH__
+ inline wxPalette& operator = (const wxPalette& palette) { if (*this == palette) return (*this); Ref(palette); return *this; }
+ inline bool operator == (const wxPalette& palette) { return m_refData == palette.m_refData; }
+ inline bool operator != (const wxPalette& palette) { return m_refData != palette.m_refData; }
+
+ virtual bool FreeResource(bool force = FALSE);
+/* TODO: implementation
+ inline WXHPALETTE GetHPALETTE() const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
+ void SetHPALETTE(WXHPALETTE pal);
+*/
+};
+
+#endif
+ // _WX_PALETTE_H_
/////////////////////////////////////////////////////////////////////////////
// Name: pen.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxPen class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKPENH__
-#define __GTKPENH__
+#ifndef _WX_PEN_H_
+#define _WX_PEN_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "pen.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
#include "wx/gdiobj.h"
-#include "wx/gdicmn.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+typedef WXDWORD wxDash ;
+
+class WXDLLEXPORT wxPen;
-class wxPen;
+class WXDLLEXPORT wxPenRefData: public wxGDIRefData
+{
+ friend class WXDLLEXPORT wxPen;
+public:
+ wxPenRefData();
+ wxPenRefData(const wxPenRefData& data);
+ ~wxPenRefData();
-//-----------------------------------------------------------------------------
-// wxPen
-//-----------------------------------------------------------------------------
+protected:
+ int m_width;
+ int m_style;
+ int m_join ;
+ int m_cap ;
+ wxBitmap m_stipple ;
+ int m_nbDash ;
+ wxDash * m_dash ;
+ wxColour m_colour;
+/* TODO: implementation
+ WXHPEN m_hPen;
+*/
+};
-class wxPen: public wxGDIObject
+#define M_PENDATA ((wxPenRefData *)m_refData)
+
+// Pen
+class WXDLLEXPORT wxPen: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxPen)
+public:
+ wxPen();
+ wxPen(const wxColour& col, int width, int style);
+ wxPen(const wxString& col, int width, int style);
+ wxPen(const wxBitmap& stipple, int width);
+ inline wxPen(const wxPen& pen) { Ref(pen); }
+ inline wxPen(const wxPen* pen) { if (pen) Ref(*pen); }
+ ~wxPen();
+
+ inline wxPen& operator = (const wxPen& pen) { if (*this == pen) return (*this); Ref(pen); return *this; }
+ inline bool operator == (const wxPen& pen) { return m_refData == pen.m_refData; }
+ inline bool operator != (const wxPen& pen) { return m_refData != pen.m_refData; }
+
+ virtual bool Ok() const { return (m_refData != NULL) ; }
- public:
-
- wxPen(void);
- wxPen( const wxColour &colour, int width, int style );
- wxPen( const wxString &colourName, int width, int style );
- wxPen( const wxPen& pen );
- wxPen( const wxPen* pen );
- ~wxPen(void);
- wxPen& operator = ( const wxPen& pen );
- bool operator == ( const wxPen& pen );
- bool operator != ( const wxPen& pen );
-
- void SetColour( const wxColour &colour );
- void SetColour( const wxString &colourName );
- void SetColour( int red, int green, int blue );
- void SetCap( int capStyle );
- void SetJoin( int joinStyle );
- void SetStyle( int style );
- void SetWidth( int width );
- wxColour &GetColour(void) const;
- int GetCap(void) const;
- int GetJoin(void) const;
- int GetStyle(void) const;
- int GetWidth(void) const;
- bool Ok(void) const;
-
- // no data :-)
+ // Override in order to recreate the pen
+ void SetColour(const wxColour& col) ;
+ void SetColour(const wxString& col) ;
+ void SetColour(const unsigned char r, const unsigned char g, const unsigned char b) ;
+
+ void SetWidth(int width) ;
+ void SetStyle(int style) ;
+ void SetStipple(const wxBitmap& stipple) ;
+ void SetDashes(int nb_dashes, const wxDash *dash) ;
+ void SetJoin(int join) ;
+ void SetCap(int cap) ;
+
+ inline wxColour& GetColour() const { return (M_PENDATA ? M_PENDATA->m_colour : wxNullColour); };
+ inline int GetWidth() const { return (M_PENDATA ? M_PENDATA->m_width : 0); };
+ inline int GetStyle() const { return (M_PENDATA ? M_PENDATA->m_style : 0); };
+ inline int GetJoin() const { return (M_PENDATA ? M_PENDATA->m_join : 0); };
+ inline int GetCap() const { return (M_PENDATA ? M_PENDATA->m_cap : 0); };
+ inline int GetDashes(wxDash **ptr) const {
+ *ptr = (M_PENDATA ? M_PENDATA->m_dash : NULL); return (M_PENDATA ? M_PENDATA->m_nbDash : 0);
+ }
+
+ inline wxBitmap *GetStipple() const { return (M_PENDATA ? (& M_PENDATA->m_stipple) : NULL); };
+
+// Implementation
+
+ // Useful helper: create the brush resource
+ void RealizeResource();
+
+ // When setting properties, we must make sure we're not changing
+ // another object
+ void Unshare();
};
-#endif // __GTKPENH__
+#endif
+ // _WX_PEN_H_
/////////////////////////////////////////////////////////////////////////////
// Name: radiobox.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxRadioBox class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKRADIOBOXH__
-#define __GTKRADIOBOXH__
+#ifndef _WX_RADIOBOX_H_
+#define _WX_RADIOBOX_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "radiobox.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-#include "wx/bitmap.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxRadioBoxNameStr;
-class wxRadioBox;
+// List box item
+class WXDLLEXPORT wxBitmap ;
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxRadioBox: public wxControl
+{
+ DECLARE_DYNAMIC_CLASS(wxRadioBox)
+public:
+ wxRadioBox();
-extern const char *wxRadioBoxNameStr;
+ inline wxRadioBox(wxWindow *parent, wxWindowID id, const wxString& title,
+ const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ int majorDim = 0, long style = wxRA_HORIZONTAL,
+ const wxValidator& val = wxDefaultValidator, const wxString& name = wxRadioBoxNameStr)
+ {
+ Create(parent, id, title, pos, size, n, choices, majorDim, style, val, name);
+ }
-//-----------------------------------------------------------------------------
-// wxRadioBox
-//-----------------------------------------------------------------------------
+ ~wxRadioBox();
-class wxRadioBox: public wxControl
-{
+ bool Create(wxWindow *parent, wxWindowID id, const wxString& title,
+ const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+ int n = 0, const wxString choices[] = NULL,
+ int majorDim = 0, long style = wxRA_HORIZONTAL,
+ const wxValidator& val = wxDefaultValidator, const wxString& name = wxRadioBoxNameStr);
- DECLARE_DYNAMIC_CLASS(wxRadioBox)
-
- public:
+ int FindString(const wxString& s) const;
+ void SetSelection(int N);
+ int GetSelection() const;
+ wxString GetString(int N) const;
+ void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ void GetSize(int *x, int *y) const;
+ void GetPosition(int *x, int *y) const;
+ wxString GetLabel() const;
+ void SetLabel(const wxString& label);
+ void SetLabel(int item, const wxString& label) ;
+ wxString GetLabel(int item) const;
+ bool Show(bool show);
+ void SetFocus();
+ void Enable(bool enable);
+ void Enable(int item, bool enable);
+ void Show(int item, bool show) ;
+ inline void SetLabelFont(const wxFont& WXUNUSED(font)) {};
+ inline void SetButtonFont(const wxFont& font) { SetFont(font); }
+
+ virtual wxString GetStringSelection() const;
+ virtual bool SetStringSelection(const wxString& s);
+ inline virtual int Number() const { return m_noItems; } ;
+ void Command(wxCommandEvent& event);
- wxRadioBox(void);
- wxRadioBox( wxWindow *parent, wxWindowID id, const wxString& title,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- int n = 0, const wxString choices[] = NULL,
- int majorDim = 0, long style = wxRA_HORIZONTAL,
- const wxString &name = wxRadioBoxNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxString& title,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- int n = 0, const wxString choices[] = NULL,
- int majorDim = 0, long style = wxRA_HORIZONTAL,
- const wxString &name = wxRadioBoxNameStr );
- int FindString( const wxString& s) const;
- void SetSelection( int n );
- int GetSelection(void) const;
- wxString GetString( int n ) const;
- wxString GetLabel(void) const;
- void SetLabel( const wxString& label );
- void SetLabel( int item, const wxString& label );
- void SetLabel( int item, wxBitmap *bitmap );
- wxString GetLabel( int item ) const;
- bool Show( bool show );
- void Enable( bool enable );
- void Enable( int item, bool enable );
- void Show( int item, bool show );
- virtual wxString GetStringSelection(void) const;
- virtual bool SetStringSelection( const wxString& s );
- virtual int Number(void) const;
- int GetNumberOfRowsOrCols(void) const;
- void SetNumberOfRowsOrCols( int n );
-
+ inline int GetNumberOfRowsOrCols() const { return m_noRowsOrCols; }
+ inline void SetNumberOfRowsOrCols(int n) { m_noRowsOrCols = n; }
+
+protected:
+/* TODO: implementation
+ WXHWND * m_radioButtons;
+*/
+ int m_majorDim ;
+ int m_noItems;
+ int m_noRowsOrCols;
+ int m_selectedButton;
+
};
-#endif // __GTKRADIOBOXH__
+#endif
+ // _WX_RADIOBOX_H_
/////////////////////////////////////////////////////////////////////////////
// Name: radiobut.h
-// Purpose:
-// Author: Robert Roebling
+// Purpose: wxRadioButton class
+// Author: AUTHOR
+// Modified by:
// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKRADIOBUTTONH__
-#define __GTKRADIOBUTTONH__
+#ifndef _WX_RADIOBUT_H_
+#define _WX_RADIOBUT_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "radiobut.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxRadioButtonNameStr;
+
+class WXDLLEXPORT wxRadioButton: public wxControl
+{
+ DECLARE_DYNAMIC_CLASS(wxRadioButton)
+ protected:
+ public:
+ inline wxRadioButton() {}
+ inline wxRadioButton(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxRadioButtonNameStr)
+ {
+ Create(parent, id, label, pos, size, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxRadioButtonNameStr);
+
+ virtual void SetLabel(const wxString& label);
+ virtual void SetValue(bool val);
+ virtual bool GetValue() const ;
+
+ void Command(wxCommandEvent& event);
+ virtual WXHBRUSH OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
+ WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
+};
-class wxRadioButton;
+// Not implemented
+#if 0
+class WXDLLEXPORT wxBitmap ;
+WXDLLEXPORT_DATA(extern const char*) wxBitmapRadioButtonNameStr;
-#endif // __GTKRADIOBUTTONH__
+class WXDLLEXPORT wxBitmapRadioButton: public wxRadioButton
+{
+ DECLARE_DYNAMIC_CLASS(wxBitmapRadioButton)
+ protected:
+ wxBitmap *theButtonBitmap;
+ public:
+ inline wxBitmapRadioButton() { theButtonBitmap = NULL; }
+ inline wxBitmapRadioButton(wxWindow *parent, wxWindowID id,
+ const wxBitmap *label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxBitmapRadioButtonNameStr)
+ {
+ Create(parent, id, label, pos, size, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxBitmap *label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxBitmapRadioButtonNameStr);
+
+ virtual void SetLabel(const wxBitmap *label);
+ virtual void SetValue(bool val) ;
+ virtual bool GetValue() const ;
+};
+#endif
+
+#endif
+ // _WX_RADIOBUT_H_
/////////////////////////////////////////////////////////////////////////////
// Name: region.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxRegion class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef __REGIONH__
-#define __REGIONH__
+#ifndef _WX_REGION_H_
+#define _WX_REGION_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "region.h"
#endif
#include "wx/list.h"
#include "wx/gdiobj.h"
-#include "wx/gdicmn.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+class WXDLLEXPORT wxRect;
+class WXDLLEXPORT wxPoint;
-class wxRegion;
-
-//-----------------------------------------------------------------------------
-// constants
-//-----------------------------------------------------------------------------
-
-enum wxRegionContain
-{
- wxOutRegion = 0, wxPartRegion = 1, wxInRegion = 2
+enum wxRegionContain {
+ wxOutRegion = 0, wxPartRegion = 1, wxInRegion = 2
};
// So far, for internal use only
wxRGN_XOR // Creates the union of two combined regions except for any overlapping areas.
};
-//-----------------------------------------------------------------------------
-// wxRegion
-//-----------------------------------------------------------------------------
-
-class wxRegion : public wxGDIObject
-{
- DECLARE_DYNAMIC_CLASS(wxRegion);
-
- public:
-
- wxRegion( long x, long y, long w, long h );
- wxRegion( const wxPoint& topLeft, const wxPoint& bottomRight );
- wxRegion( const wxRect& rect );
- wxRegion(void);
- ~wxRegion(void);
-
- inline wxRegion( const wxRegion& r )
- { Ref(r); }
- inline wxRegion& operator = ( const wxRegion& r )
- { Ref(r); return (*this); }
-
- void Clear(void);
-
- bool Union( long x, long y, long width, long height );
- bool Union( const wxRect& rect );
- bool Union( const wxRegion& region );
-
- bool Intersect( long x, long y, long width, long height );
- bool Intersect( const wxRect& rect );
- bool Intersect( const wxRegion& region );
-
- bool Subtract( long x, long y, long width, long height );
- bool Subtract( const wxRect& rect );
- bool Subtract( const wxRegion& region );
-
- bool Xor( long x, long y, long width, long height );
- bool Xor( const wxRect& rect );
- bool Xor( const wxRegion& region );
-
- void GetBox( long& x, long& y, long&w, long &h ) const;
- wxRect GetBox(void) const ;
-
- bool Empty(void) const;
-
- wxRegionContain Contains( long x, long y ) const;
- wxRegionContain Contains( long x, long y, long w, long h ) const;
-
+class WXDLLEXPORT wxRegion : public wxGDIObject {
+DECLARE_DYNAMIC_CLASS(wxRegion);
+ friend class WXDLLEXPORT wxRegionIterator;
+public:
+ wxRegion(long x, long y, long w, long h);
+ wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
+ wxRegion(const wxRect& rect);
+
+/* TODO: implementation
+ wxRegion(WXHRGN hRegion); // Hangs on to this region
+*/
+
+ wxRegion();
+ ~wxRegion();
+
+ //# Copying
+ inline wxRegion(const wxRegion& r)
+ { Ref(r); }
+ inline wxRegion& operator = (const wxRegion& r)
+ { Ref(r); return (*this); }
+
+ //# Modify region
+ // Clear current region
+ void Clear();
+
+ // Union rectangle or region with this.
+ inline bool Union(long x, long y, long width, long height) { return Combine(x, y, width, height, wxRGN_OR); }
+ inline bool Union(const wxRect& rect) { return Combine(rect, wxRGN_OR); }
+ inline bool Union(const wxRegion& region) { return Combine(region, wxRGN_OR); }
+
+ // Intersect rectangle or region with this.
+ inline bool Intersect(long x, long y, long width, long height) { return Combine(x, y, width, height, wxRGN_AND); }
+ inline bool Intersect(const wxRect& rect) { return Combine(rect, wxRGN_AND); }
+ inline bool Intersect(const wxRegion& region) { return Combine(region, wxRGN_AND); }
+
+ // Subtract rectangle or region from this:
+ // Combines the parts of 'this' that are not part of the second region.
+ inline bool Subtract(long x, long y, long width, long height) { return Combine(x, y, width, height, wxRGN_DIFF); }
+ inline bool Subtract(const wxRect& rect) { return Combine(rect, wxRGN_DIFF); }
+ inline bool Subtract(const wxRegion& region) { return Combine(region, wxRGN_DIFF); }
+
+ // XOR: the union of two combined regions except for any overlapping areas.
+ inline bool Xor(long x, long y, long width, long height) { return Combine(x, y, width, height, wxRGN_XOR); }
+ inline bool Xor(const wxRect& rect) { return Combine(rect, wxRGN_XOR); }
+ inline bool Xor(const wxRegion& region) { return Combine(region, wxRGN_XOR); }
+
+ //# Information on region
+ // Outer bounds of region
+ void GetBox(long& x, long& y, long&w, long &h) const;
+ wxRect GetBox() const ;
+
+ // Is region empty?
+ bool Empty() const;
+ inline bool IsEmpty() const { return Empty(); }
+
+ //# Tests
+ // Does the region contain the point (x,y)?
+ wxRegionContain Contains(long x, long y) const;
+ // Does the region contain the point pt?
+ wxRegionContain Contains(const wxPoint& pt) const;
+ // Does the region contain the rectangle (x, y, w, h)?
+ wxRegionContain Contains(long x, long y, long w, long h) const;
+ // Does the region contain the rectangle rect?
+ wxRegionContain Contains(const wxRect& rect) const;
+
+// Internal
+ bool Combine(long x, long y, long width, long height, wxRegionOp op);
+ bool Combine(const wxRegion& region, wxRegionOp op);
+ bool Combine(const wxRect& rect, wxRegionOp op);
+};
+
+class WXDLLEXPORT wxRegionIterator : public wxObject {
+DECLARE_DYNAMIC_CLASS(wxRegionIterator);
+public:
+ wxRegionIterator();
+ wxRegionIterator(const wxRegion& region);
+ ~wxRegionIterator();
+
+ void Reset() { m_current = 0; }
+ void Reset(const wxRegion& region);
+
+ operator bool () const { return m_current < m_numRects; }
+ bool HaveRects() const { return m_current < m_numRects; }
+
+ void operator ++ ();
+ void operator ++ (int);
+
+ long GetX() const;
+ long GetY() const;
+ long GetW() const;
+ long GetWidth() const { return GetW(); }
+ long GetH() const;
+ long GetHeight() const { return GetH(); }
+
+private:
+ long m_current;
+ long m_numRects;
+ wxRegion m_region;
+ wxRect* m_rects;
};
#endif
- // __REGIONH__
+ // _WX_REGION_H_
/////////////////////////////////////////////////////////////////////////////
-// Name: scrolbar.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Name: scrollbar.h
+// Purpose: wxScrollBar class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKSCROLLBARH__
-#define __GTKSCROLLBARH__
+#ifndef _WX_SCROLBAR_H_
+#define _WX_SCROLBAR_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "scrolbar.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxScrollBar;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const char *wxScrollBarNameStr;
-
-//-----------------------------------------------------------------------------
-// wxScrollBar
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxScrollBarNameStr;
-class wxScrollBar: public wxControl
+// Scrollbar item
+class WXDLLEXPORT wxScrollBar: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxScrollBar)
- public:
-
- wxScrollBar(void) { };
- wxScrollBar(wxWindow *parent, wxWindowID id,
+public:
+ inline wxScrollBar() { m_pageSize = 0; m_viewSize = 0; m_objectSize = 0; }
+ ~wxScrollBar();
+
+ inline wxScrollBar(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
- const wxString& name = wxScrollBarNameStr );
- ~wxScrollBar(void);
- bool Create(wxWindow *parent, wxWindowID id,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxScrollBarNameStr)
+ {
+ Create(parent, id, pos, size, style, validator, name);
+ }
+ bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
+ const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr);
- int GetPosition(void) const;
- int GetThumbSize() const;
- int GetPageSize() const;
- int GetRange() const;
- virtual void SetPosition( int viewStart );
- virtual void SetScrollbar( int position, int thumbSize, int range, int pageSize,
- bool refresh = TRUE );
- // Backward compatibility
- int GetValue(void) const;
- void SetValue( int viewStart );
- void GetValues( int *viewStart, int *viewLength, int *objectLength, int *pageLength) const;
- int GetViewLength() const;
- int GetObjectLength() const;
- void SetPageSize( int pageLength );
- void SetObjectLength( int objectLength );
- void SetViewLength( int viewLength );
+ int GetPosition() const ;
+ inline int GetThumbSize() const { return m_pageSize; }
+ inline int GetPageSize() const { return m_viewSize; }
+ inline int GetRange() const { return m_objectSize; }
+
+ virtual void SetPosition(int viewStart);
+ virtual void SetScrollbar(int position, int thumbSize, int range, int pageSize,
+ bool refresh = TRUE);
+
+ void Command(wxCommandEvent& event);
+
+protected:
+ int m_pageSize;
+ int m_viewSize;
+ int m_objectSize;
+DECLARE_EVENT_TABLE()
};
#endif
- // __GTKSCROLLBARH__
+ // _WX_SCROLBAR_H_
/////////////////////////////////////////////////////////////////////////////
// Name: settings.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxSystemSettings class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKSETTINGSH__
-#define __GTKSETTINGSH__
+#ifndef _WX_SETTINGS_H_
+#define _WX_SETTINGS_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "settings.h"
#endif
-#include "wx/defs.h"
-#include "wx/gdicmn.h"
-#include "wx/pen.h"
-#include "wx/font.h"
+#include "wx/setup.h"
+
+#define wxSYS_WHITE_BRUSH 0
+#define wxSYS_LTGRAY_BRUSH 1
+#define wxSYS_GRAY_BRUSH 2
+#define wxSYS_DKGRAY_BRUSH 3
+#define wxSYS_BLACK_BRUSH 4
+#define wxSYS_NULL_BRUSH 5
+#define wxSYS_HOLLOW_BRUSH wxSYS_NULL_BRUSH
+#define wxSYS_WHITE_PEN 6
+#define wxSYS_BLACK_PEN 7
+#define wxSYS_NULL_PEN 8
+#define wxSYS_OEM_FIXED_FONT 10
+#define wxSYS_ANSI_FIXED_FONT 11
+#define wxSYS_ANSI_VAR_FONT 12
+#define wxSYS_SYSTEM_FONT 13
+#define wxSYS_DEVICE_DEFAULT_FONT 14
+#define wxSYS_DEFAULT_PALETTE 15
+#define wxSYS_SYSTEM_FIXED_FONT 16 // Obsolete
+#define wxSYS_DEFAULT_GUI_FONT 17
+
+#define wxSYS_COLOUR_SCROLLBAR 0
+#define wxSYS_COLOUR_BACKGROUND 1
+#define wxSYS_COLOUR_ACTIVECAPTION 2
+#define wxSYS_COLOUR_INACTIVECAPTION 3
+#define wxSYS_COLOUR_MENU 4
+#define wxSYS_COLOUR_WINDOW 5
+#define wxSYS_COLOUR_WINDOWFRAME 6
+#define wxSYS_COLOUR_MENUTEXT 7
+#define wxSYS_COLOUR_WINDOWTEXT 8
+#define wxSYS_COLOUR_CAPTIONTEXT 9
+#define wxSYS_COLOUR_ACTIVEBORDER 10
+#define wxSYS_COLOUR_INACTIVEBORDER 11
+#define wxSYS_COLOUR_APPWORKSPACE 12
+#define wxSYS_COLOUR_HIGHLIGHT 13
+#define wxSYS_COLOUR_HIGHLIGHTTEXT 14
+#define wxSYS_COLOUR_BTNFACE 15
+#define wxSYS_COLOUR_BTNSHADOW 16
+#define wxSYS_COLOUR_GRAYTEXT 17
+#define wxSYS_COLOUR_BTNTEXT 18
+#define wxSYS_COLOUR_INACTIVECAPTIONTEXT 19
+#define wxSYS_COLOUR_BTNHIGHLIGHT 20
+
+#define wxSYS_COLOUR_3DDKSHADOW 21
+#define wxSYS_COLOUR_3DLIGHT 22
+#define wxSYS_COLOUR_INFOTEXT 23
+#define wxSYS_COLOUR_INFOBK 24
+
+#define wxSYS_COLOUR_DESKTOP wxSYS_COLOUR_BACKGROUND
+#define wxSYS_COLOUR_3DFACE wxSYS_COLOUR_BTNFACE
+#define wxSYS_COLOUR_3DSHADOW wxSYS_COLOUR_BTNSHADOW
+#define wxSYS_COLOUR_3DHIGHLIGHT wxSYS_COLOUR_BTNHIGHLIGHT
+#define wxSYS_COLOUR_3DHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
+#define wxSYS_COLOUR_BTNHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
+
+// Metrics
+#define wxSYS_MOUSE_BUTTONS 1
+#define wxSYS_BORDER_X 2
+#define wxSYS_BORDER_Y 3
+#define wxSYS_CURSOR_X 4
+#define wxSYS_CURSOR_Y 5
+#define wxSYS_DCLICK_X 6
+#define wxSYS_DCLICK_Y 7
+#define wxSYS_DRAG_X 8
+#define wxSYS_DRAG_Y 9
+#define wxSYS_EDGE_X 10
+#define wxSYS_EDGE_Y 11
+#define wxSYS_HSCROLL_ARROW_X 12
+#define wxSYS_HSCROLL_ARROW_Y 13
+#define wxSYS_HTHUMB_X 14
+#define wxSYS_ICON_X 15
+#define wxSYS_ICON_Y 16
+#define wxSYS_ICONSPACING_X 17
+#define wxSYS_ICONSPACING_Y 18
+#define wxSYS_WINDOWMIN_X 19
+#define wxSYS_WINDOWMIN_Y 20
+#define wxSYS_SCREEN_X 21
+#define wxSYS_SCREEN_Y 22
+#define wxSYS_FRAMESIZE_X 23
+#define wxSYS_FRAMESIZE_Y 24
+#define wxSYS_SMALLICON_X 25
+#define wxSYS_SMALLICON_Y 26
+#define wxSYS_HSCROLL_Y 27
+#define wxSYS_VSCROLL_X 28
+#define wxSYS_VSCROLL_ARROW_X 29
+#define wxSYS_VSCROLL_ARROW_Y 30
+#define wxSYS_VTHUMB_Y 31
+#define wxSYS_CAPTION_Y 32
+#define wxSYS_MENU_Y 33
+#define wxSYS_NETWORK_PRESENT 34
+#define wxSYS_PENWINDOWS_PRESENT 35
+#define wxSYS_SHOW_SOUNDS 36
+#define wxSYS_SWAP_BUTTONS 37
class WXDLLEXPORT wxSystemSettings: public wxObject
{
public:
- inline wxSystemSettings(void) {}
+ inline wxSystemSettings() {}
// Get a system colour
static wxColour GetSystemColour(int index);
};
#endif
- // __GTKSETTINGSH__
+ // _WX_SETTINGS_H_
/////////////////////////////////////////////////////////////////////////////
// Name: slider.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxSlider class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKSLIDERH__
-#define __GTKSLIDERH__
+#ifndef _WX_SLIDER_H_
+#define _WX_SLIDER_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "slider.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxSlider;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const char *wxSliderNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxSliderNameStr;
-//-----------------------------------------------------------------------------
-// wxSlider
-//-----------------------------------------------------------------------------
-
-class wxSlider: public wxControl
+// Slider
+class WXDLLEXPORT wxSlider: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxSlider)
- public:
- wxSlider(void);
- wxSlider( wxWindow *parent, wxWindowID id,
+public:
+ wxSlider();
+
+ inline wxSlider(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
-/* const wxValidator& validator = wxDefaultValidator, */
- const wxString& name = wxSliderNameStr);
- ~wxSlider(void);
- bool Create(wxWindow *parent, wxWindowID id,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxSliderNameStr)
+ {
+ Create(parent, id, value, minValue, maxValue, pos, size, style, validator, name);
+ }
+
+ ~wxSlider();
+
+ bool Create(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
-/* const wxValidator& validator = wxDefaultValidator, */
+ const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
- virtual int GetValue(void) const;
- virtual void SetValue( int );
- void GetSize( int *x, int *y ) const;
- void SetSize( int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO );
- void GetPosition( int *x, int *y ) const;
- void SetRange( int minValue, int maxValue );
- int GetMin(void) const;
- int GetMax(void) const;
- void SetTickFreq( int n, int pos );
- int GetTickFreq(void) const;
- void SetPageSize( int pageSize );
- int GetPageSize(void) const;
- void ClearSel(void);
- void ClearTicks(void);
- void SetLineSize( int lineSize );
- int GetLineSize(void) const;
- int GetSelEnd(void) const;
- int GetSelStart(void) const;
- void SetSelection( int minPos, int maxPos );
- void SetThumbLength( int len );
- int GetThumbLength(void) const;
- void SetTick( int tickPos );
-
+
+ virtual int GetValue() const ;
+ virtual void SetValue(int);
+ void GetSize(int *x, int *y) const ;
+ void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ void GetPosition(int *x, int *y) const ;
+ bool Show(bool show);
+
+ void SetRange(int minValue, int maxValue);
+
+ inline int GetMin() const { return m_rangeMin; }
+ inline int GetMax() const { return m_rangeMax; }
+
+ // For trackbars only
+ void SetTickFreq(int n, int pos);
+ inline int GetTickFreq() const { return m_tickFreq; }
+ void SetPageSize(int pageSize);
+ int GetPageSize() const ;
+ void ClearSel() ;
+ void ClearTicks() ;
+ void SetLineSize(int lineSize);
+ int GetLineSize() const ;
+ int GetSelEnd() const ;
+ int GetSelStart() const ;
+ void SetSelection(int minPos, int maxPos);
+ void SetThumbLength(int len) ;
+ int GetThumbLength() const ;
+ void SetTick(int tickPos) ;
+
+ void Command(wxCommandEvent& event);
+ protected:
+ int m_rangeMin;
+ int m_rangeMax;
+ int m_pageSize;
+ int m_lineSize;
+ int m_tickFreq;
+DECLARE_EVENT_TABLE()
};
-#endif // __GTKSLIDERH__
+#endif
+ // _WX_SLIDER_H_
/////////////////////////////////////////////////////////////////////////////
// Name: statbmp.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxStaticBitmap class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKSTATICBITMAPH__
-#define __GTKSTATICBITMAPH__
+#ifndef _WX_STATBMP_H_
+#define _WX_STATBMP_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "statbmp.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxStaticBitmapNameStr;
+
+class WXDLLEXPORT wxStaticBitmap: public wxControl
+{
+ DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
+ public:
+ inline wxStaticBitmap() { }
-class wxStaticBitmap;
+ inline wxStaticBitmap(wxWindow *parent, wxWindowID id,
+ const wxBitmap& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxStaticBitmapNameStr)
+ {
+ Create(parent, id, label, pos, size, style, name);
+ }
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxBitmap& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxStaticBitmapNameStr);
-extern const char* wxStaticBitmapNameStr;
+ virtual void SetBitmap(const wxBitmap& bitmap);
-//-----------------------------------------------------------------------------
-// wxStaticBitmap
-//-----------------------------------------------------------------------------
+ virtual void Command(wxCommandEvent& WXUNUSED(event)) {};
+ virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {};
+
+ void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+
+ inline wxBitmap& GetBitmap() const { return (wxBitmap&) m_messageBitmap; }
+
+ // overriden base class virtuals
+ virtual bool AcceptsFocus() const { return FALSE; }
+
+ protected:
+ wxBitmap m_messageBitmap;
-class wxStaticBitmap: public wxControl
-{
- DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
-
- public:
-
- wxStaticBitmap(void);
- wxStaticBitmap( wxWindow *parent, wxWindowID id, const wxBitmap& label,
- const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
- long style = 0, const wxString& name = wxStaticBitmapNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxBitmap& label,
- const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
- long style = 0, const wxString& name = wxStaticBitmapNameStr);
- virtual void SetBitmap( const wxBitmap& bitmap );
- wxBitmap& GetBitmap(void) const { return (wxBitmap&)m_bitmap; }
-
- private:
-
- wxBitmap m_bitmap;
};
-#endif // __GTKSTATICBITMAPH__
+#endif
+ // _WX_STATBMP_H_
/////////////////////////////////////////////////////////////////////////////
-// Name: stabox.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Name: statbox.h
+// Purpose: wxStaticBox class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKSTATICBOXH__
-#define __GTKSTATICBOXH__
+#ifndef _WX_STATBOX_H_
+#define _WX_STATBOX_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "statbox.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxStaticBox;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const char *wxStaticBoxNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxStaticBoxNameStr;
-//-----------------------------------------------------------------------------
-// wxStaticBox
-//-----------------------------------------------------------------------------
-
-class wxStaticBox: public wxControl
+// Group box
+class WXDLLEXPORT wxStaticBox: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxStaticBox)
- public:
-
- wxStaticBox(void);
- wxStaticBox( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxStaticBoxNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxStaticBoxNameStr );
+ public:
+ inline wxStaticBox() {}
+ inline wxStaticBox(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxStaticBoxNameStr)
+ {
+ Create(parent, id, label, pos, size, style, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxStaticBoxNameStr);
+
+ virtual void Command(wxCommandEvent& WXUNUSED(event)) {};
+ virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {};
+
+ void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ void SetLabel(const wxString& label);
+
+DECLARE_EVENT_TABLE()
};
-#endif // __GTKSTATICBOXH__
+#endif
+ // _WX_STATBOX_H_
/////////////////////////////////////////////////////////////////////////////
// Name: stattext.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxStaticText class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKSTATICTEXTH__
-#define __GTKSTATICTEXTH__
+#ifndef _WX_STATTEXT_H_
+#define _WX_STATTEXT_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "stattext.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
-
-class wxStaticText;
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-
-extern const char *wxStaticTextNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxStaticTextNameStr;
-//-----------------------------------------------------------------------------
-// wxStaticText
-//-----------------------------------------------------------------------------
-
-class wxStaticText: public wxControl
+class WXDLLEXPORT wxStaticText: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxStaticText)
-
- public:
-
- wxStaticText(void);
- wxStaticText( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxStaticTextNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxStaticTextNameStr );
- wxString GetLabel(void) const;
- void SetLabel( const wxString &label );
+ public:
+ inline wxStaticText() { }
+
+ inline wxStaticText(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxStaticTextNameStr)
+ {
+ Create(parent, id, label, pos, size, style, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxStaticTextNameStr);
+
+ // accessors
+ void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ void SetLabel(const wxString&);
+
+ // operations
+ virtual void Command(wxCommandEvent& WXUNUSED(event)) {};
+ virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {};
};
-#endif // __GTKSTATICTEXTH__
+#endif
+ // _WX_STATTEXT_H_
/////////////////////////////////////////////////////////////////////////////
// Name: textctrl.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxTextCtrl class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKTEXTCTRLH__
-#define __GTKTEXTCTRLH__
+#ifndef _WX_TEXTCTRL_H_
+#define _WX_TEXTCTRL_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "textctrl.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
#include "wx/control.h"
#if USE_IOSTREAMH
#include <iostream>
#endif
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const char*) wxTextCtrlNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
-class wxTextCtrl;
+// Single-line text item
+class WXDLLEXPORT wxTextCtrl: public wxControl
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+// TODO Some platforms/compilers don't like inheritance from streambuf.
-extern const char *wxTextCtrlNameStr;
+#if (defined(__BORLANDC__) && !defined(__WIN32__)) || defined(__MWERKS__)
+#define NO_TEXT_WINDOW_STREAM
+#endif
-//-----------------------------------------------------------------------------
-// wxTextCtrl
-//-----------------------------------------------------------------------------
+#ifndef NO_TEXT_WINDOW_STREAM
+, public streambuf
+#endif
-class wxTextCtrl: public wxControl, public streambuf
{
- DECLARE_EVENT_TABLE()
- DECLARE_DYNAMIC_CLASS(wxTextCtrl);
-
+ DECLARE_DYNAMIC_CLASS(wxTextCtrl)
+
public:
- wxTextCtrl();
- wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value = "",
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- int style = 0, const wxString &name = wxTextCtrlNameStr );
- bool Create( wxWindow *parent, wxWindowID id, const wxString &value = "",
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- int style = 0, const wxString &name = wxTextCtrlNameStr );
- wxString GetValue() const;
- void SetValue( const wxString &value );
- void WriteText( const wxString &text );
-
- bool LoadFile( const wxString &file );
- bool SaveFile( const wxString &file );
- bool IsModified() const { return m_modified; }
- void SetModified() { m_modified = TRUE; }
- void DiscardEdits() { m_modified = FALSE; }
-/*
- wxString GetLineText( long lineNo ) const;
- void OnDropFiles( wxDropFilesEvent &event );
- long PositionToXY( long pos, long *x, long *y ) const;
- long XYToPosition( long x, long y );
- int GetNumberOfLines();
-*/
- virtual void SetInsertionPoint( long pos );
- virtual void SetInsertionPointEnd();
- virtual void SetEditable( bool editable );
- virtual void SetSelection( long from, long to );
- void ShowPosition( long pos );
- virtual long GetInsertionPoint() const;
- virtual long GetLastPosition() const;
- virtual void Remove( long from, long to );
- virtual void Replace( long from, long to, const wxString &value );
- void Cut();
- void Copy();
- void Paste();
- void Delete();
-
- void OnChar( wxKeyEvent &event );
-
- int overflow(int i);
- int sync();
- int underflow();
-
- wxTextCtrl& operator<<(const wxString& s);
- wxTextCtrl& operator<<(int i);
- wxTextCtrl& operator<<(long i);
- wxTextCtrl& operator<<(float f);
- wxTextCtrl& operator<<(double d);
- wxTextCtrl& operator<<(const char c);
-
-private:
- bool m_modified;
+ // creation
+ // --------
+ wxTextCtrl();
+ inline wxTextCtrl(wxWindow *parent, wxWindowID id,
+ const wxString& value = wxEmptyString,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxTextCtrlNameStr)
+#ifndef NO_TEXT_WINDOW_STREAM
+ :streambuf()
+#endif
+ {
+ Create(parent, id, value, pos, size, style, validator, name);
+ }
+
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxString& value = wxEmptyString,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxTextCtrlNameStr);
+
+ // accessors
+ // ---------
+ virtual wxString GetValue() const ;
+ virtual void SetValue(const wxString& value);
+
+ virtual int GetLineLength(long lineNo) const;
+ virtual wxString GetLineText(long lineNo) const;
+ virtual int GetNumberOfLines() const;
+
+ // operations
+ // ----------
+ virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+
+ // Clipboard operations
+ virtual void Copy();
+ virtual void Cut();
+ virtual void Paste();
+
+ virtual void SetInsertionPoint(long pos);
+ virtual void SetInsertionPointEnd();
+ virtual long GetInsertionPoint() const ;
+ virtual long GetLastPosition() const ;
+ virtual void Replace(long from, long to, const wxString& value);
+ virtual void Remove(long from, long to);
+ virtual void SetSelection(long from, long to);
+ virtual void SetEditable(bool editable);
+
+ // streambuf implementation
+#ifndef NO_TEXT_WINDOW_STREAM
+ int overflow(int i);
+ int sync();
+ int underflow();
+#endif
+
+ wxTextCtrl& operator<<(const wxString& s);
+ wxTextCtrl& operator<<(int i);
+ wxTextCtrl& operator<<(long i);
+ wxTextCtrl& operator<<(float f);
+ wxTextCtrl& operator<<(double d);
+ wxTextCtrl& operator<<(const char c);
+
+ virtual bool LoadFile(const wxString& file);
+ virtual bool SaveFile(const wxString& file);
+ virtual void WriteText(const wxString& text);
+ virtual void DiscardEdits();
+ virtual bool IsModified() const;
+
+ virtual long XYToPosition(long x, long y) const ;
+ virtual void PositionToXY(long pos, long *x, long *y) const ;
+ virtual void ShowPosition(long pos);
+ virtual void Clear();
+
+ // callbacks
+ // ---------
+ void OnDropFiles(wxDropFilesEvent& event);
+ void OnChar(wxKeyEvent& event); // Process 'enter' if required
+ void OnEraseBackground(wxEraseEvent& event);
+
+ // Implementation
+ // --------------
+ virtual void Command(wxCommandEvent& event);
+
+protected:
+ wxString m_fileName;
+
+ DECLARE_EVENT_TABLE()
};
-#endif // __GTKTEXTCTRLH__
-
-
+#endif
+ // _WX_TEXTCTRL_H_
/////////////////////////////////////////////////////////////////////////////
// Name: timer.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxTimer class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKTIMERH__
-#define __GTKTIMERH__
+#ifndef _WX_TIMER_H_
+#define _WX_TIMER_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "timer.h"
#endif
-#include "wx/defs.h"
#include "wx/object.h"
-//-----------------------------------------------------------------------------
-// derived classes
-//-----------------------------------------------------------------------------
-
-class wxTimer;
-
-//-----------------------------------------------------------------------------
-// wxTimer
-//-----------------------------------------------------------------------------
-
-class wxTimer: public wxObject
+class WXDLLEXPORT wxTimer: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxTimer)
- public:
-
- wxTimer(void);
- ~wxTimer(void);
- int Interval(void);
- bool OneShot(void);
- virtual void Notify(void);
- void Start( int millisecs = -1, bool oneShot = FALSE );
- void Stop(void);
-
- private:
-
- int m_time;
- bool m_oneShot;
+ public:
+ wxTimer();
+ ~wxTimer();
+ virtual bool Start(int milliseconds = -1,bool one_shot = FALSE); // Start timer
+ virtual void Stop(); // Stop timer
+ virtual void Notify() = 0; // Override this member
+ inline int Interval() { return m_milli ; }; // Returns the current interval time (0 if stop)
+
+protected:
+ bool m_oneShot ;
+ int m_milli ;
+ int m_lastMilli ;
+ long m_id;
+
};
-#endif // __GTKTIMERH__
+/* Note: these are implemented in common/timercmn.cpp, so need to implement them separately.
+ * But you may need to modify timercmn.cpp.
+ */
+
+// Timer functions (milliseconds)
+void WXDLLEXPORT wxStartTimer();
+// Gets time since last wxStartTimer or wxGetElapsedTime
+long WXDLLEXPORT wxGetElapsedTime(bool resetTimer = TRUE);
+
+// EXPERIMENTAL: comment this out if it doesn't compile.
+bool WXDLLEXPORT wxGetLocalTime(long *timeZone, int *dstObserved);
+
+// Get number of seconds since 00:00:00 GMT, Jan 1st 1970.
+long WXDLLEXPORT wxGetCurrentTime();
+
+#endif
+ // _WX_TIMER_H_
/////////////////////////////////////////////////////////////////////////////
// Name: window.h
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxWindow class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GTKWINDOWH__
-#define __GTKWINDOWH__
+#ifndef _WX_WINDOW_H_
+#define _WX_WINDOW_H_
#ifdef __GNUG__
-#pragma interface
+#pragma interface "window.h"
#endif
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/list.h"
-#include "wx/event.h"
-#include "wx/validate.h"
+#include "wx/gdicmn.h"
+#include "wx/icon.h"
#include "wx/cursor.h"
+#include "wx/pen.h"
#include "wx/font.h"
-#include "wx/dc.h"
+#include "wx/validate.h"
+#include "wx/event.h"
+#include "wx/string.h"
+#include "wx/list.h"
#include "wx/region.h"
-#include "wx/dnd.h"
-
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
-extern const char *wxFrameNameStr;
-extern wxList wxTopLevelWindows;
-
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+#define wxKEY_SHIFT 1
+#define wxKEY_CTRL 2
+
+/*
+ * Base class for frame, panel, canvas, panel items, dialog box.
+ *
+ */
+
+/*
+ * Event handler: windows have themselves as their event handlers
+ * by default, but their event handlers could be set to another
+ * object entirely. This separation can reduce the amount of
+ * derivation required, and allow alteration of a window's functionality
+ * (e.g. by a resource editor that temporarily switches event handlers).
+ */
+
+class WXDLLEXPORT wxWindow;
+class WXDLLEXPORT wxEvent;
+class WXDLLEXPORT wxCommandEvent;
+class WXDLLEXPORT wxKeyEvent;
+class WXDLLEXPORT wxControl;
+class WXDLLEXPORT wxCursor;
+class WXDLLEXPORT wxColourMap;
+class WXDLLEXPORT wxFont;
+class WXDLLEXPORT wxMenu;
+class WXDLLEXPORT wxRectangle;
+class WXDLLEXPORT wxBitmap;
+class WXDLLEXPORT wxSizer;
+class WXDLLEXPORT wxList;
+class WXDLLEXPORT wxLayoutConstraints;
+class WXDLLEXPORT wxMouseEvent;
+class WXDLLEXPORT wxButton;
+class WXDLLEXPORT wxColour;
+class WXDLLEXPORT wxBrush;
+class WXDLLEXPORT wxPen;
+class WXDLLEXPORT wxIcon;
+class WXDLLEXPORT wxDC;
+class WXDLLEXPORT wxValidator;
+
+#if USE_DRAG_AND_DROP
+class WXDLLEXPORT wxDropTarget;
+#endif
-class wxLayoutConstraints;
-class wxSizer;
+#if USE_WX_RESOURCES
+class WXDLLEXPORT wxResourceTable;
+class WXDLLEXPORT wxItemResource;
+#endif
-class wxWindow;
-class wxCanvas;
+WXDLLEXPORT_DATA(extern const char*) wxPanelNameStr;
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
+WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
-extern const char *wxPanelNameStr;
-extern const wxSize wxDefaultSize;
-extern const wxPoint wxDefaultPosition;
+class WXDLLEXPORT wxWindow: public wxEvtHandler
+{
+ DECLARE_ABSTRACT_CLASS(wxWindow)
-//-----------------------------------------------------------------------------
-// wxWindow
-//-----------------------------------------------------------------------------
+ friend class wxDC;
+ friend class wxPaintDC;
-class wxWindow: public wxEvtHandler
-{
public:
wxWindow();
- wxWindow( wxWindow *parent, wxWindowID id,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxPanelNameStr );
- bool Create( wxWindow *parent, wxWindowID id,
- const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
- long style = 0, const wxString &name = wxPanelNameStr );
+ inline wxWindow(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxPanelNameStr)
+ {
+ m_children = new wxList;
+ Create(parent, id, pos, size, style, name);
+ }
+
virtual ~wxWindow();
- bool Close( bool force = FALSE );
- virtual bool Destroy();
- virtual bool DestroyChildren();
-
- virtual void PrepareDC( wxDC &dc );
-
- virtual void SetSize( int x, int y, int width, int height,
- int sizeFlags = wxSIZE_AUTO );
- virtual void SetSize( int width, int height );
- virtual void Move( int x, int y );
- virtual void GetSize( int *width, int *height ) const;
- virtual void SetClientSize( int const width, int const height );
- virtual void GetClientSize( int *width, int *height ) const;
- virtual void GetPosition( int *x, int *y ) const;
- virtual void Centre( int direction = wxHORIZONTAL );
+
+ bool Create(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = 0,
+ const wxString& name = wxPanelNameStr);
+
+ // Fit the window around the items
virtual void Fit();
- void OnSize( wxSizeEvent &event );
- void OnIdle( wxIdleEvent& event );
+ // Show or hide the window
+ virtual bool Show(bool show);
- virtual bool Show( bool show );
- virtual void Enable( bool enable );
- virtual void MakeModal( bool modal );
- virtual bool IsEnabled() const { return m_isEnabled; };
- virtual void SetFocus();
- virtual bool OnClose();
+ // Is the window shown?
+ virtual bool IsShown() const;
- virtual void AddChild( wxWindow *child );
- wxList *GetChildren();
- virtual void RemoveChild( wxWindow *child );
- void SetReturnCode( int retCode );
- int GetReturnCode();
- wxWindow *GetParent();
+ // Raise the window to the top of the Z order
+ virtual void Raise();
- wxEvtHandler *GetEventHandler();
- void SetEventhandler( wxEvtHandler *handler );
+ // Lower the window to the bottom of the Z order
+ virtual void Lower();
- virtual wxValidator *GetValidator();
- virtual void SetValidator( wxValidator *validator );
+ // Is the window enabled?
+ virtual bool IsEnabled() const;
- bool IsBeingDeleted();
+ // For compatibility
+ inline bool Enabled() const { return IsEnabled(); }
- void SetId( wxWindowID id );
- wxWindowID GetId();
+ // Dialog support: override these and call
+ // base class members to add functionality
+ // that can't be done using validators.
- void SetCursor( const wxCursor &cursor );
+ // Transfer values to controls. If returns FALSE,
+ // it's an application error (pops up a dialog)
+ virtual bool TransferDataToWindow();
- virtual void Refresh( bool eraseBackground = TRUE, const wxRect *rect = NULL );
- virtual void Clear();
- virtual bool IsExposed( long x, long y );
- virtual bool IsExposed( long x, long y, long width, long height );
-
- virtual wxColour GetBackgroundColour() const;
- virtual void SetBackgroundColour( const wxColour &colour );
-
- virtual void SetDefaultBackgroundColour( const wxColour& col )
- { m_defaultBackgroundColour = col; };
- virtual wxColour GetDefaultBackgroundColour() const
- { return m_defaultBackgroundColour; };
- virtual void SetDefaultForegroundColour( const wxColour& col )
- { m_defaultForegroundColour = col; };
- virtual wxColour GetDefaultForegroundColour() const
- { return m_defaultForegroundColour; };
-
- virtual void SetFont( const wxFont &font );
- virtual wxFont *GetFont();
- // For backward compatibility
- inline virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
- inline virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
- inline virtual wxFont *GetLabelFont() { return GetFont(); };
- inline virtual wxFont *GetButtonFont() { return GetFont(); };
- virtual void SetWindowStyleFlag( long flag );
- virtual long GetWindowStyleFlag() const;
+ // Transfer values from controls. If returns FALSE,
+ // transfer failed: don't quit
+ virtual bool TransferDataFromWindow();
+
+ // Validate controls. If returns FALSE,
+ // validation failed: don't quit
+ virtual bool Validate();
+
+ // Return code for dialogs
+ inline void SetReturnCode(int retCode);
+ inline int GetReturnCode();
+
+ // Set the cursor
+ virtual void SetCursor(const wxCursor& cursor);
+ inline virtual wxCursor *GetCursor() const { return (wxCursor *)& m_windowCursor; };
+
+ // Get the window with the focus
+ static wxWindow *FindFocus();
+
+ // Get character size
+ virtual int GetCharHeight() const;
+ virtual int GetCharWidth() const;
+
+ // Get overall window size
+ virtual void GetSize(int *width, int *height) const;
+
+ // Get window position, relative to parent (or screen if no parent)
+ virtual void GetPosition(int *x, int *y) const;
+
+ // Get client (application-useable) size
+ virtual void GetClientSize(int *width, int *height) const;
+
+ // Set overall size and position
+ virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
+ inline virtual void SetSize(int width, int height) { SetSize(-1, -1, width, height, wxSIZE_USE_EXISTING); }
+ inline virtual void Move(int x, int y) { SetSize(x, y, -1, -1, wxSIZE_USE_EXISTING); }
+
+ // Set client size
+ virtual void SetClientSize(int width, int size);
+
+ // Convert client to screen coordinates
+ virtual void ClientToScreen(int *x, int *y) const;
+
+ // Convert screen to client coordinates
+ virtual void ScreenToClient(int *x, int *y) const;
+
+ // Set the focus to this window
+ virtual void SetFocus();
+
+ // Capture/release mouse
virtual void CaptureMouse();
virtual void ReleaseMouse();
- virtual void SetTitle( const wxString &title );
- virtual wxString GetTitle() const;
- virtual void SetName( const wxString &name );
- virtual wxString GetName() const;
- virtual wxString GetLabel() const;
- void OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) ) {};
+ // Enable or disable the window
+ virtual void Enable(bool enable);
- virtual bool IsShown() const;
- virtual bool IsRetained();
- virtual wxWindow *FindWindow( long id );
- virtual wxWindow *FindWindow( const wxString& name );
- void AllowDoubleClick( bool WXUNUSED(allow) ) {};
- void SetDoubleClick( bool WXUNUSED(allow) ) {};
- virtual void ClientToScreen( int *x, int *y );
- virtual void ScreenToClient( int *x, int *y );
-
- virtual bool Validate();
- virtual bool TransferDataToWindow();
- virtual bool TransferDataFromWindow();
- void OnInitDialog( wxInitDialogEvent &event );
- virtual void InitDialog();
+#if USE_DRAG_AND_DROP
+ // Associate a drop target with this window (if the window already had a drop
+ // target, it's deleted!) and return the current drop target (may be NULL).
+ void SetDropTarget(wxDropTarget *pDropTarget);
+ wxDropTarget *GetDropTarget() const { return m_pDropTarget; }
+#endif
- virtual void SetDropTarget( wxDropTarget *dropTarget );
- virtual wxDropTarget *GetDropTarget() const;
+ // Accept files for dragging
+ virtual void DragAcceptFiles(bool accept);
+
+ // Update region access
+ virtual wxRegion GetUpdateRegion() const;
+ virtual bool IsExposed(int x, int y, int w, int h) const;
+ virtual bool IsExposed(const wxPoint& pt) const;
+ virtual bool IsExposed(const wxRect& rect) const;
+
+ // Set/get the window title
+ virtual inline void SetTitle(const wxString& WXUNUSED(title)) {};
+ inline virtual wxString GetTitle() const { return wxString(""); };
+ // Most windows have the concept of a label; for frames, this is the
+ // title; for items, this is the label or button text.
+ inline virtual wxString GetLabel() const { return GetTitle(); }
+
+ // Set/get the window name (used for resource setting in X)
+ inline virtual wxString GetName() const;
+ inline virtual void SetName(const wxString& name);
+
+ // Centre the window
+ virtual void Centre(int direction) ;
+ inline void Center(int direction = wxHORIZONTAL) { Centre(direction); }
+
+ // Popup a menu
+ virtual bool PopupMenu(wxMenu *menu, int x, int y);
+
+ // Send the window a refresh event
+ virtual void Refresh(bool eraseBack = TRUE, const wxRectangle *rect = NULL);
+
+ // New functions that will replace the above.
+ virtual void SetScrollbar(int orient, int pos, int thumbVisible,
+ int range, bool refresh = TRUE);
+
+ virtual void SetScrollPos(int orient, int pos, bool refresh = TRUE);
+ virtual int GetScrollPos(int orient) const;
+ virtual int GetScrollRange(int orient) const;
+ virtual int GetScrollThumb(int orient) const;
+
+ virtual void ScrollWindow(int dx, int dy, const wxRectangle *rect = NULL);
+
+ // Caret manipulation
+ virtual void CreateCaret(int w, int h);
+ virtual void CreateCaret(const wxBitmap *bitmap);
+ virtual void DestroyCaret();
+ virtual void ShowCaret(bool show);
+ virtual void SetCaretPos(int x, int y);
+ virtual void GetCaretPos(int *x, int *y) const;
+
+ // Tell window how much it can be sized
+ virtual void SetSizeHints(int minW = -1, int minH = -1, int maxW = -1, int maxH = -1, int incW = -1, int incH = -1);
+
+ // Set/get the window's identifier
+ inline int GetId() const;
+ inline void SetId(int id);
+
+ // Make the window modal (all other windows unresponsive)
+ virtual void MakeModal(bool modal);
+
+ // Get the private handle (platform-dependent)
+ inline void *GetHandle() const;
+
+ // Set/get the window's relatives
+ inline wxWindow *GetParent() const;
+ inline void SetParent(wxWindow *p) ;
+ inline wxWindow *GetGrandParent() const;
+ inline wxList *GetChildren() const;
+
+ // Set/get the window's font
+ virtual void SetFont(const wxFont& f);
+ inline virtual wxFont *GetFont() const;
+
+ // Set/get the window's validator
+ void SetValidator(const wxValidator& validator);
+ inline wxValidator *GetValidator() const;
+
+ // Set/get the window's style
+ inline void SetWindowStyleFlag(long flag);
+ inline long GetWindowStyleFlag() const;
+
+ // Set/get event handler
+ inline void SetEventHandler(wxEvtHandler *handler);
+ inline wxEvtHandler *GetEventHandler() const;
+
+ // Push/pop event handler (i.e. allow a chain of event handlers
+ // be searched)
+ void PushEventHandler(wxEvtHandler *handler) ;
+ wxEvtHandler *PopEventHandler(bool deleteHandler = FALSE) ;
-public:
- virtual void SetScrollbar( int orient, int pos, int thumbVisible,
- int range, bool refresh = TRUE );
- virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE );
- virtual int GetScrollPos( int orient ) const;
- virtual int GetScrollThumb( int orient ) const;
- virtual int GetScrollRange( int orient ) const;
- virtual void ScrollWindow( int dx, int dy, const wxRect* rect = NULL );
-
- // return FALSE from here if the window doesn't want the focus
- virtual bool AcceptsFocus() const;
+ // Close the window by calling OnClose, posting a deletion
+ virtual bool Close(bool force = FALSE);
+
+ // Destroy the window (delayed, if a managed window)
+ virtual bool Destroy() ;
+
+ // Mode for telling default OnSize members to
+ // call Layout(), if not using Sizers, just top-down constraints
+ inline void SetAutoLayout(bool a);
+ inline bool GetAutoLayout() const;
+
+ // Set/get constraints
+ inline wxLayoutConstraints *GetConstraints() const;
+ void SetConstraints(wxLayoutConstraints *c);
+
+ // Set/get window background colour
+ inline virtual void SetBackgroundColour(const wxColour& col);
+ inline virtual wxColour GetBackgroundColour() const;
+
+ // Set/get window foreground colour
+ inline virtual void SetForegroundColour(const wxColour& col);
+ inline virtual wxColour GetForegroundColour() const;
+
+ // Set/get window default background colour (for children to inherit).
+ // NOTE: these may be removed in later revisions.
+ inline virtual void SetDefaultBackgroundColour(const wxColour& col);
+ inline virtual wxColour GetDefaultBackgroundColour(void) const;
+
+ // Set/get window default foreground colour (for children to inherit)
+ inline virtual void SetDefaultForegroundColour(const wxColour& col);
+ inline virtual wxColour GetDefaultForegroundColour(void) const;
+
+ // Get the default button, if there is one
+ inline virtual wxButton *GetDefaultItem() const;
+ inline virtual void SetDefaultItem(wxButton *but);
+
+ // Override to define new behaviour for default action (e.g. double clicking
+ // on a listbox)
+ virtual void OnDefaultAction(wxControl *initiatingItem);
+
+ // Resource loading
+#if USE_WX_RESOURCES
+ virtual bool LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table = NULL);
+ virtual wxControl *CreateItem(const wxItemResource *childResource, const wxResourceTable *table = NULL);
+#endif
+
+ // Native resource loading
+ virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id);
+ virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name);
+ virtual wxWindow* GetWindowChild1(wxWindowID& id);
+ virtual wxWindow* GetWindowChild(wxWindowID& id);
+
+ virtual void GetTextExtent(const wxString& string, int *x, int *y,
+ int *descent = NULL,
+ int *externalLeading = NULL,
+ const wxFont *theFont = NULL, bool use16 = FALSE) const;
+
+ // Is the window retained?
+ inline bool IsRetained() const;
- // update the UI state (called from OnIdle)
+ // Warp the pointer the given position
+ virtual void WarpPointer(int x_pos, int y_pos) ;
+
+ // Clear the window
+ virtual void Clear();
+
+ // Find a window by id or name
+ virtual wxWindow *FindWindow(long id);
+ virtual wxWindow *FindWindow(const wxString& name);
+
+ // Constraint operations
+ bool Layout();
+ void SetSizer(wxSizer *sizer); // Adds sizer child to this window
+ inline wxSizer *GetSizer() const ;
+ inline wxWindow *GetSizerParent() const ;
+ inline void SetSizerParent(wxWindow *win);
+
+ // Do Update UI processing for controls
void UpdateWindowUI();
+ void OnEraseBackground(wxEraseEvent& event);
+ void OnChar(wxKeyEvent& event);
+ void OnPaint(wxPaintEvent& event);
+ void OnIdle(wxIdleEvent& event);
+
+ // Does this window want to accept keyboard focus?
+ virtual bool AcceptsFocus() const;
+
+public:
+ ////////////////////////////////////////////////////////////////////////
+ //// IMPLEMENTATION
-public: // cannot get private going yet
-
-
- wxWindow *m_parent;
- wxList m_children;
- int m_x,m_y;
- int m_width,m_height;
- int m_retCode;
- wxEvtHandler *m_eventHandler;
- wxValidator *m_windowValidator;
- wxDropTarget *m_pDropTarget;
- wxWindowID m_windowId;
- wxCursor *m_cursor;
- wxFont m_font;
- wxColour m_backgroundColour;
- wxColour m_defaultBackgroundColour;
- wxColour m_foregroundColour ;
- wxColour m_defaultForegroundColour;
- wxRegion m_updateRegion;
- long m_windowStyle;
- bool m_isShown;
- bool m_isEnabled;
- wxString m_windowName;
-
-
-public: // Layout section
-
- wxLayoutConstraints * m_constraints;
- wxList * m_constraintsInvolvedIn;
- wxSizer * m_windowSizer;
- wxWindow * m_sizerParent;
- bool m_autoLayout;
-
- wxLayoutConstraints *GetConstraints() const;
- void SetConstraints( wxLayoutConstraints *constraints );
- void SetAutoLayout( bool autoLayout );
- bool GetAutoLayout() const;
- bool Layout();
- void SetSizer( wxSizer *sizer );
- wxSizer *GetSizer() const;
- void SetSizerParent( wxWindow *win );
- wxWindow *GetSizerParent() const;
+ // For implementation purposes - sometimes decorations make the client area
+ // smaller
+ virtual wxPoint GetClientAreaOrigin() const;
+
+ // Makes an adjustment to the window position (for example, a frame that has
+ // a toolbar that it manages itself).
+ virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
+
+ // Executes the default message
+ virtual long Default();
+
+/* TODO: you may need something like this
+ // Determine whether 3D effects are wanted
+ virtual WXDWORD Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D);
+*/
+
+ virtual void AddChild(wxWindow *child); // Adds reference to the child object
+ virtual void RemoveChild(wxWindow *child); // Removes reference to child
+ // (but doesn't delete the child object)
+ virtual void DestroyChildren(); // Removes and destroys all children
+
+ // Constraint implementation
void UnsetConstraints(wxLayoutConstraints *c);
inline wxList *GetConstraintsInvolvedIn() const ;
+ // Back-pointer to other windows we're involved with, so if we delete
+ // this window, we must delete any constraints we're involved with.
void AddConstraintReference(wxWindow *otherWin);
void RemoveConstraintReference(wxWindow *otherWin);
void DeleteRelatedConstraints();
+
virtual void ResetConstraints();
virtual void SetConstraintSizes(bool recurse = TRUE);
virtual bool LayoutPhase1(int *noChanges);
virtual bool LayoutPhase2(int *noChanges);
virtual bool DoPhase(int);
+ // Transforms from sizer coordinate space to actual
+ // parent coordinate space
virtual void TransformSizerToActual(int *x, int *y) const ;
+
+ // Set size with transformation to actual coordinates if nec.
virtual void SizerSetSize(int x, int y, int w, int h);
virtual void SizerMove(int x, int y);
+
+ // Only set/get the size/position of the constraint (if any)
virtual void SetSizeConstraint(int x, int y, int w, int h);
virtual void MoveConstraint(int x, int y);
virtual void GetSizeConstraint(int *w, int *h) const ;
virtual void GetClientSizeConstraint(int *w, int *h) const ;
virtual void GetPositionConstraint(int *x, int *y) const ;
- DECLARE_DYNAMIC_CLASS(wxWindow)
- DECLARE_EVENT_TABLE()
+ wxObject *GetChild(int number) const ;
+
+ inline void SetShowing(bool show);
+ inline bool IsUserEnabled() const;
+ inline bool GetTransparentBackground() const ;
+
+ // Responds to colour changes: passes event on to children.
+ void OnSysColourChanged(wxSysColourChangedEvent& event);
+
+ // Transfers data to any child controls
+ void OnInitDialog(wxInitDialogEvent& event);
+
+ // Sends an OnInitDialog event, which in turns transfers data to
+ // to the window via validators.
+ virtual void InitDialog();
+
+ ////////////////////////////////////////////////////////////////////////
+ //// PROTECTED DATA
+protected:
+ int m_windowId;
+ long m_windowStyle; // Store the window's style
+ wxEvtHandler * m_windowEventHandler; // Usually is 'this'
+ wxLayoutConstraints * m_constraints; // Constraints for this window
+ wxList * m_constraintsInvolvedIn; // List of constraints we're involved in
+ wxSizer * m_windowSizer; // Window's top-level sizer (if any)
+ wxWindow * m_sizerParent; // Window's parent sizer (if any)
+ bool m_autoLayout; // Whether to call Layout() in OnSize
+ wxWindow * m_windowParent; // Each window always knows its parent
+ wxValidator * m_windowValidator;
+ int m_minSizeX;
+ int m_minSizeY;
+ int m_maxSizeX;
+ int m_maxSizeY;
+
+ // Caret data
+ int m_caretWidth;
+ int m_caretHeight;
+ bool m_caretEnabled;
+ bool m_caretShown;
+ wxFont m_windowFont; // Window's font
+ wxCursor m_windowCursor; // Window's cursor
+ wxString m_windowName; // Window name
+
+ wxButton * m_defaultItem;
+
+ wxColour m_backgroundColour ;
+ wxColour m_foregroundColour ;
+ wxColour m_defaultBackgroundColour;
+ wxColour m_defaultForegroundColour;
+
+#if USE_DRAG_AND_DROP
+ wxDropTarget *m_pDropTarget; // the current drop target or NULL
+#endif //USE_DRAG_AND_DROP
+
+public:
+ wxRegion m_updateRegion;
+ wxList * m_children; // Window's children
+ int m_returnCode;
+
+DECLARE_EVENT_TABLE()
};
-#endif // __GTKWINDOWH__
+////////////////////////////////////////////////////////////////////////
+//// INLINES
+
+inline void *wxWindow::GetHandle() const { return (void *)NULL; }
+inline int wxWindow::GetId() const { return m_windowId; }
+inline void wxWindow::SetId(int id) { m_windowId = id; }
+inline wxWindow *wxWindow::GetParent() const { return m_windowParent; }
+inline void wxWindow::SetParent(wxWindow *p) { m_windowParent = p; }
+inline wxWindow *wxWindow::GetGrandParent() const { return (m_windowParent ? m_windowParent->m_windowParent : NULL); }
+inline wxList *wxWindow::GetChildren() const { return m_children; }
+inline wxFont *wxWindow::GetFont() const { return (wxFont *) & m_windowFont; }
+inline wxString wxWindow::GetName() const { return m_windowName; }
+inline void wxWindow::SetName(const wxString& name) { m_windowName = name; }
+inline long wxWindow::GetWindowStyleFlag() const { return m_windowStyle; }
+inline void wxWindow::SetWindowStyleFlag(long flag) { m_windowStyle = flag; }
+inline void wxWindow::SetDoubleClick(bool flag) { m_doubleClickAllowed = flag; }
+inline bool wxWindow::GetDoubleClick() const { return m_doubleClickAllowed; }
+inline void wxWindow::SetEventHandler(wxEvtHandler *handler) { m_windowEventHandler = handler; }
+inline wxEvtHandler *wxWindow::GetEventHandler() const { return m_windowEventHandler; }
+inline void wxWindow::SetAutoLayout(bool a) { m_autoLayout = a; }
+inline bool wxWindow::GetAutoLayout() const { return m_autoLayout; }
+inline wxLayoutConstraints *wxWindow::GetConstraints() const { return m_constraints; }
+inline void wxWindow::SetBackgroundColour(const wxColour& col) { m_backgroundColour = col; };
+inline wxColour wxWindow::GetBackgroundColour() const { return m_backgroundColour; };
+inline void wxWindow::SetForegroundColour(const wxColour& col) { m_foregroundColour = col; };
+inline wxColour wxWindow::GetForegroundColour() const { return m_foregroundColour; };
+inline void wxWindow::SetDefaultForegroundColour(const wxColour& col) { m_defaultForegroundColour = col; };
+inline wxColour wxWindow::GetDefaultForegroundColour(void) const { return m_defaultForegroundColour; };
+inline void wxWindow::SetDefaultBackgroundColour(const wxColour& col) { m_defaultBackgroundColour = col; };
+inline wxColour wxWindow::GetDefaultBackgroundColour(void) const { return m_defaultBackgroundColour; };
+
+inline wxButton *wxWindow::GetDefaultItem() const { return m_defaultItem; }
+inline void wxWindow::SetDefaultItem(wxButton *but) { m_defaultItem = but; }
+inline bool wxWindow::IsRetained() const { return ((m_windowStyle & wxRETAINED) == wxRETAINED); }
+
+inline void wxWindow::SetShowing(bool show) { m_isShown = show; }
+inline wxList *wxWindow::GetConstraintsInvolvedIn() const { return m_constraintsInvolvedIn; }
+inline wxSizer *wxWindow::GetSizer() const { return m_windowSizer; }
+inline wxWindow *wxWindow::GetSizerParent() const { return m_sizerParent; }
+inline void wxWindow::SetSizerParent(wxWindow *win) { m_sizerParent = win; }
+inline wxValidator *wxWindow::GetValidator() const { return m_windowValidator; }
+inline bool wxWindow::IsUserEnabled() const { return m_winEnabled; }
+inline bool wxWindow::GetTransparentBackground() const { return m_backgroundTransparent; }
+inline void wxWindow::SetReturnCode(int retCode) { m_returnCode = retCode; }
+inline int wxWindow::GetReturnCode() { return m_returnCode; }
+
+// Get the active window.
+wxWindow* WXDLLEXPORT wxGetActiveWindow();
+
+WXDLLEXPORT_DATA(extern wxList) wxTopLevelWindows;
+
+#endif
+ // _WX_WINDOW_H_
/////////////////////////////////////////////////////////////////////////////
// Name: app.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxApp
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#pragma implementation "app.h"
#endif
+#include "wx/frame.h"
#include "wx/app.h"
-#include "wx/gdicmn.h"
#include "wx/utils.h"
-#include "wx/postscrp.h"
-#include "wx/intl.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/memory.h"
-
-#include "unistd.h"
+#include "wx/module.h"
-//-----------------------------------------------------------------------------
-// global data
-//-----------------------------------------------------------------------------
+#if USE_WX_RESOURCES
+#include "wx/resource.h"
+#endif
-wxApp *wxTheApp = NULL;
-wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
+#include <string.h>
+#if defined(__WIN95__) && !defined(__GNUWIN32__)
+extern char *wxBuffer;
extern wxList wxPendingDelete;
-//-----------------------------------------------------------------------------
-// local functions
-//-----------------------------------------------------------------------------
-
-extern void wxFlushResources(void);
-
-//-----------------------------------------------------------------------------
-// global functions
-//-----------------------------------------------------------------------------
-
-void wxExit(void)
-{
-};
-
-bool wxYield(void)
-{
- return TRUE;
-};
-
-//-----------------------------------------------------------------------------
-// wxApp
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
+wxApp *wxTheApp = NULL;
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
EVT_IDLE(wxApp::OnIdle)
END_EVENT_TABLE()
+#endif
-wxApp::wxApp()
-{
- m_topWindow = NULL;
- m_exitOnFrameDelete = TRUE;
-};
-
-wxApp::~wxApp(void)
-{
-};
-
-bool wxApp::OnInit(void)
-{
- return TRUE;
-};
-
-bool wxApp::OnInitGui(void)
-{
- return TRUE;
-};
-
-int wxApp::OnRun(void)
-{
- return MainLoop();
-};
-
-bool wxApp::ProcessIdle(void)
-{
- wxIdleEvent event;
- event.SetEventObject( this );
- ProcessEvent( event );
-
- return event.MoreRequested();
-};
-
-void wxApp::OnIdle( wxIdleEvent &event )
-{
- static bool inOnIdle = FALSE;
-
- // Avoid recursion (via ProcessEvent default case)
- if (inOnIdle)
- return;
-
- inOnIdle = TRUE;
-
- // 'Garbage' collection of windows deleted with Close().
- DeletePendingObjects();
-
- // flush the logged messages if any
- wxLog *pLog = wxLog::GetActiveTarget();
- if ( pLog != NULL && pLog->HasPendingMessages() )
- pLog->Flush();
-
- // Send OnIdle events to all windows
- bool needMore = SendIdleEvents();
-
- if (needMore)
- event.RequestMore(TRUE);
-
- inOnIdle = FALSE;
-};
+long wxApp::sm_lastMessageTime = 0;
-bool wxApp::SendIdleEvents(void)
+void wxApp::CommonInit()
{
- bool needMore = FALSE;
- wxNode* node = wxTopLevelWindows.First();
- while (node)
- {
- wxWindow* win = (wxWindow*) node->Data();
- if (SendIdleEvents(win))
- needMore = TRUE;
-
- node = node->Next();
- }
- return needMore;
-};
-
-bool wxApp::SendIdleEvents( wxWindow* win )
-{
- bool needMore = FALSE;
-
- wxIdleEvent event;
- event.SetEventObject(win);
- win->ProcessEvent(event);
-
- if (event.MoreRequested())
- needMore = TRUE;
-
- wxNode* node = win->GetChildren()->First();
- while (node)
- {
- wxWindow* win = (wxWindow*) node->Data();
- if (SendIdleEvents(win))
- needMore = TRUE;
+#ifdef __WXMSW__
+ wxBuffer = new char[1500];
+#else
+ wxBuffer = new char[BUFSIZ + 512];
+#endif
- node = node->Next();
- }
- return needMore ;
-};
+ wxClassInfo::InitializeClasses();
-int wxApp::OnExit(void)
-{
- return 0;
-};
+ wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
+ wxTheColourDatabase->Initialize();
+ wxInitializeStockObjects();
-int wxApp::MainLoop(void)
-{
- return 0;
-};
+#if USE_WX_RESOURCES
+ wxInitializeResourceSystem();
+#endif
-void wxApp::ExitMainLoop(void)
-{
-};
+ // For PostScript printing
+#if USE_POSTSCRIPT
+ wxInitializePrintSetupData();
+ wxThePrintPaperDatabase = new wxPrintPaperDatabase;
+ wxThePrintPaperDatabase->CreateDatabase();
+#endif
-bool wxApp::Initialized(void)
-{
- return m_initialized;
-};
+ wxBitmap::InitStandardHandlers();
-bool wxApp::Pending(void)
-{
- return FALSE;
-};
+ wxModule::RegisterModules();
+ wxASSERT( wxModule::InitializeModules() == TRUE );
+}
-void wxApp::Dispatch(void)
+void wxApp::CommonCleanUp()
{
-};
+ wxModule::CleanUpModules();
-void wxApp::DeletePendingObjects(void)
-{
- wxNode *node = wxPendingDelete.First();
- while (node)
- {
- wxObject *obj = (wxObject *)node->Data();
-
- delete obj;
+#if USE_WX_RESOURCES
+ wxCleanUpResourceSystem();
+#endif
- if (wxPendingDelete.Member(obj))
- delete node;
+ wxDeleteStockObjects() ;
- node = wxPendingDelete.First();
- };
-};
+ // Destroy all GDI lists, etc.
+ delete wxTheBrushList;
+ wxTheBrushList = NULL;
-wxWindow *wxApp::GetTopWindow(void)
-{
- if (m_topWindow) return m_topWindow;
- wxNode *node = wxTopLevelWindows.First();
- if (!node) return NULL;
- return (wxWindow*)node->Data();
-};
+ delete wxThePenList;
+ wxThePenList = NULL;
-void wxApp::SetTopWindow( wxWindow *win )
-{
- m_topWindow = win;
-};
+ delete wxTheFontList;
+ wxTheFontList = NULL;
-void wxApp::CommonInit(void)
-{
+ delete wxTheBitmapList;
+ wxTheBitmapList = NULL;
-/*
-#if USE_RESOURCES
- (void) wxGetResource("wxWindows", "OsVersion", &wxOsVersion);
-#endif
-*/
+ delete wxTheColourDatabase;
+ wxTheColourDatabase = NULL;
- wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
- wxTheColourDatabase->Initialize();
- wxInitializeStockObjects();
-
- // For PostScript printing
#if USE_POSTSCRIPT
- wxInitializePrintSetupData();
- wxThePrintPaperDatabase = new wxPrintPaperDatabase;
- wxThePrintPaperDatabase->CreateDatabase();
+ wxInitializePrintSetupData(FALSE);
+ delete wxThePrintPaperDatabase;
+ wxThePrintPaperDatabase = NULL;
#endif
+ wxBitmap::CleanUpHandlers();
-/*
- wxBitmap::InitStandardHandlers();
-
- g_globalCursor = new wxCursor;
-*/
+ delete[] wxBuffer;
+ wxBuffer = NULL;
- wxInitializeStockObjects();
-};
-
-void wxApp::CommonCleanUp(void)
-{
- wxDeleteStockObjects();
-
- wxFlushResources();
-};
-
-wxLog *wxApp::CreateLogTarget()
-{
- return new wxLogGui;
+ // do it as the very last thing because everything else can log messages
+ delete wxLog::SetActiveTarget(NULL);
}
-//-----------------------------------------------------------------------------
-// wxEntry
-//-----------------------------------------------------------------------------
-
int wxEntry( int argc, char *argv[] )
{
- wxBuffer = new char[BUFSIZ + 512];
-
wxClassInfo::InitializeClasses();
#if (WXDEBUG && USE_MEMORY_TRACING) || USE_DEBUG_CONTEXT
return 0;
};
- wxAppInitializerFunction app_ini = wxApp::GetInitializerFunction();
-
- wxObject *test_app = app_ini();
-
- wxTheApp = (wxApp*) test_app;
-
-// wxTheApp = (wxApp*)( app_ini() );
+ wxTheApp = (* wxApp::GetInitializerFunction()) ();
};
if (!wxTheApp)
return 0;
};
-// printf( "Programmstart.\n" );
-
wxTheApp->argc = argc;
wxTheApp->argv = argv;
-// Your init here !!!!
-
+ // TODO: your platform-specific initialization.
+
wxApp::CommonInit();
+ // GUI-specific initialization, such as creating an app context.
wxTheApp->OnInitGui();
// Here frames insert themselves automatically
return retValue;
};
-//-----------------------------------------------------------------------------
-// main()
-//-----------------------------------------------------------------------------
+// Static member initialization
+wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
-#if defined(AIX) || defined(AIX4) || defined(____HPUX__)
+wxApp::wxApp()
+{
+ m_topWindow = NULL;
+ wxTheApp = this;
+ m_className = "";
+ m_wantDebugOutput = TRUE ;
+ m_appName = "";
+ argc = 0;
+ argv = NULL;
+#ifdef __WXMSW__
+ m_printMode = wxPRINT_WINDOWS;
+#else
+ m_printMode = wxPRINT_POSTSCRIPT;
+#endif
+ m_exitOnFrameDelete = TRUE;
+ m_auto3D = TRUE;
+}
- // main in IMPLEMENT_WX_MAIN in IMPLEMENT_APP in app.h
+bool wxApp::Initialized()
+{
+ if (GetTopWindow())
+ return TRUE;
+ else
+ return FALSE;
+}
-#else
+int wxApp::MainLoop()
+{
+ m_keepGoing = TRUE;
- int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
+/* 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;
+ }
+*/
-#endif
+ return 0;
+}
+
+// Returns TRUE if more time is needed.
+bool wxApp::ProcessIdle()
+{
+ wxIdleEvent event;
+ event.SetEventObject(this);
+ ProcessEvent(event);
+
+ return event.MoreRequested();
+}
+
+void wxApp::ExitMainLoop()
+{
+ m_keepGoing = FALSE;
+}
+
+// Is a message/event pending?
+bool wxApp::Pending()
+{
+/* TODO.
+ */
+ return FALSE;
+}
+
+// Dispatch a message.
+void wxApp::Dispatch()
+{
+/* TODO.
+ */
+}
+
+void wxApp::OnIdle(wxIdleEvent& event)
+{
+ static bool inOnIdle = FALSE;
+
+ // Avoid recursion (via ProcessEvent default case)
+ if (inOnIdle)
+ return;
+
+ inOnIdle = TRUE;
+
+ // 'Garbage' collection of windows deleted with Close().
+ DeletePendingObjects();
+
+ // flush the logged messages if any
+ wxLog *pLog = wxLog::GetActiveTarget();
+ if ( pLog != NULL && pLog->HasPendingMessages() )
+ pLog->Flush();
+
+ // Send OnIdle events to all windows
+ bool needMore = SendIdleEvents();
+
+ if (needMore)
+ event.RequestMore(TRUE);
+
+ 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))
+ needMore = TRUE;
+ node = node->Next();
+ }
+ return needMore;
+}
+
+// Send idle event to window and all subwindows
+bool wxApp::SendIdleEvents(wxWindow* win)
+{
+ bool needMore = FALSE;
+
+ wxIdleEvent event;
+ event.SetEventObject(win);
+ win->ProcessEvent(event);
+
+ if (event.MoreRequested())
+ needMore = TRUE;
+
+ wxNode* node = win->GetChildren()->First();
+ while (node)
+ {
+ wxWindow* win = (wxWindow*) node->Data();
+ if (SendIdleEvents(win))
+ needMore = TRUE;
+
+ node = node->Next();
+ }
+ return needMore ;
+}
+
+void wxApp::DeletePendingObjects()
+{
+ wxNode *node = wxPendingDelete.First();
+ while (node)
+ {
+ wxObject *obj = (wxObject *)node->Data();
+
+ delete obj;
+
+ 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();
+ }
+}
+
+wxLog* wxApp::CreateLogTarget()
+{
+ return new wxLogGui;
+}
+
+wxWindow* wxApp::GetTopWindow() const
+{
+ if (m_topWindow)
+ return m_topWindow;
+ else if (wxTopLevelWindows.Number() > 0)
+ return (wxWindow*) wxTopLevelWindows.First()->Data();
+ else
+ return NULL;
+}
+
+void wxExit()
+{
+ wxApp::CommonCleanUp();
+/*
+ * TODO: Exit in some platform-specific way. Not recommended that the app calls this:
+ * only for emergencies.
+ */
+}
+
+// Yield to other processes
+bool wxYield()
+{
+ /*
+ * TODO
+ */
+ return TRUE;
+}
/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
+// Purpose: wxBitmap
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
// RCS-ID: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "bitmap.h"
#endif
+#include "wx/setup.h"
+#include "wx/utils.h"
+#include "wx/palette.h"
#include "wx/bitmap.h"
+#include "wx/icon.h"
+#include "wx/log.h"
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
+IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
+#endif
+
+wxBitmapRefData::wxBitmapRefData()
+{
+ m_ok = FALSE;
+ m_width = 0;
+ m_height = 0;
+ m_depth = 0;
+ m_quality = 0;
+ m_numColors = 0;
+ m_bitmapMask = NULL;
+}
-//-----------------------------------------------------------------------------
-// wxMask
-//-----------------------------------------------------------------------------
+wxBitmapRefData::~wxBitmapRefData()
+{
+ /*
+ * TODO: delete the bitmap data here.
+ */
+
+ if (m_bitmapMask)
+ delete m_bitmapMask;
+ m_bitmapMask = NULL;
+}
-IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
+wxList wxBitmap::sm_handlers;
-wxMask::wxMask(void)
+wxBitmap::wxBitmap()
{
-};
+ m_refData = NULL;
-wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour) )
+ if ( wxTheBitmapList )
+ wxTheBitmapList->AddBitmap(this);
+}
+
+wxBitmap::~wxBitmap()
{
-};
+ if (wxTheBitmapList)
+ wxTheBitmapList->DeleteObject(this);
+}
-wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex) )
+wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
{
-};
+ m_refData = new wxBitmapRefData;
+
+ M_BITMAPDATA->m_width = the_width ;
+ M_BITMAPDATA->m_height = the_height ;
+ M_BITMAPDATA->m_depth = no_bits ;
+ M_BITMAPDATA->m_numColors = 0;
-wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap) )
+ /* TODO: create the bitmap from data */
+
+ if ( wxTheBitmapList )
+ wxTheBitmapList->AddBitmap(this);
+}
+
+wxBitmap::wxBitmap(int w, int h, int d)
{
-};
+ (void)Create(w, h, d);
+
+ if ( wxTheBitmapList )
+ wxTheBitmapList->AddBitmap(this);
+}
-wxMask::~wxMask(void)
+wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
{
-};
+ (void) Create(data, type, width, height, depth);
-//-----------------------------------------------------------------------------
-// wxBitmap
-//-----------------------------------------------------------------------------
-
-class wxBitmapRefData: public wxObjectRefData
-{
- public:
-
- wxBitmapRefData(void);
- ~wxBitmapRefData(void);
-
- wxMask *m_mask;
- int m_width;
- int m_height;
- int m_bpp;
- wxPalette *m_palette;
-};
+ if ( wxTheBitmapList )
+ wxTheBitmapList->AddBitmap(this);
+}
-wxBitmapRefData::wxBitmapRefData(void)
+wxBitmap::wxBitmap(const wxString& filename, long type)
{
- m_mask = NULL;
- m_width = 0;
- m_height = 0;
- m_bpp = 0;
- m_palette = NULL;
-};
+ LoadFile(filename, (int)type);
-wxBitmapRefData::~wxBitmapRefData(void)
+ if ( wxTheBitmapList )
+ wxTheBitmapList->AddBitmap(this);
+}
+
+/* TODO: maybe allow creation from XPM
+// Create from data
+wxBitmap::wxBitmap(const char **data)
{
- if (m_mask) delete m_mask;
- if (m_palette) delete m_palette;
-};
+ (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+}
+*/
+
+bool wxBitmap::Create(int w, int h, int d)
+{
+ UnRef();
+
+ m_refData = new wxBitmapRefData;
-//-----------------------------------------------------------------------------
+ M_BITMAPDATA->m_width = w;
+ M_BITMAPDATA->m_height = h;
+ M_BITMAPDATA->m_depth = d;
-#define M_BMPDATA ((wxBitmapRefData *)m_refData)
+ /* TODO: create new bitmap */
-IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
+ return M_BITMAPDATA->m_ok;
+}
-wxBitmap::wxBitmap(void)
+bool wxBitmap::LoadFile(const wxString& filename, long type)
{
- if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
-};
-
-wxBitmap::wxBitmap( int width, int height, int depth )
-{
- m_refData = new wxBitmapRefData();
- M_BMPDATA->m_mask = NULL;
- M_BMPDATA->m_width = width;
- M_BMPDATA->m_height = height;
- M_BMPDATA->m_bpp = depth;
-
- if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
-};
+ UnRef();
+
+ m_refData = new wxBitmapRefData;
+
+ wxBitmapHandler *handler = FindHandler(type);
+
+ if ( handler == NULL ) {
+ wxLogWarning("no bitmap handler for type %d defined.", type);
+
+ return FALSE;
+ }
+
+ return handler->LoadFile(this, filename, type, -1, -1);
+}
-wxBitmap::wxBitmap( char **WXUNUSED(bits) )
+bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
{
- m_refData = new wxBitmapRefData();
+ UnRef();
- if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
-};
-
-wxBitmap::wxBitmap( const wxBitmap& bmp )
+ m_refData = new wxBitmapRefData;
+
+ wxBitmapHandler *handler = FindHandler(type);
+
+ if ( handler == NULL ) {
+ wxLogWarning("no bitmap handler for type %d defined.", type);
+
+ return FALSE;
+ }
+
+ return handler->Create(this, data, type, width, height, depth);
+}
+
+bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
{
- Ref( bmp );
-
- if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
-};
-
-wxBitmap::wxBitmap( const wxBitmap* bmp )
+ wxBitmapHandler *handler = FindHandler(type);
+
+ if ( handler == NULL ) {
+ wxLogWarning("no bitmap handler for type %d defined.", type);
+
+ return FALSE;
+ }
+
+ return handler->SaveFile(this, filename, type, palette);
+}
+
+void wxBitmap::SetWidth(int w)
{
- if (bmp) Ref( *bmp );
-
- if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
-};
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
-wxBitmap::wxBitmap( const wxString &filename, int type )
+ M_BITMAPDATA->m_width = w;
+}
+
+void wxBitmap::SetHeight(int h)
{
- LoadFile( filename, type );
-};
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
+
+ M_BITMAPDATA->m_height = h;
+}
-wxBitmap::wxBitmap( const char WXUNUSED(bits)[], int width, int height, int WXUNUSED(depth))
+void wxBitmap::SetDepth(int d)
{
- m_refData = new wxBitmapRefData();
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
- M_BMPDATA->m_mask = NULL;
- M_BMPDATA->m_width = width;
- M_BMPDATA->m_height = height;
- M_BMPDATA->m_bpp = 1;
+ M_BITMAPDATA->m_depth = d;
+}
+
+void wxBitmap::SetQuality(int q)
+{
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
- if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
+ M_BITMAPDATA->m_quality = q;
}
-
-wxBitmap::~wxBitmap(void)
+
+void wxBitmap::SetOk(bool isOk)
{
- if (wxTheBitmapList) wxTheBitmapList->DeleteObject(this);
-};
-
-wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
+
+ M_BITMAPDATA->m_ok = isOk;
+}
+
+void wxBitmap::SetPalette(const wxPalette& palette)
{
- if (*this == bmp) return (*this);
- Ref( bmp );
- return *this;
-};
-
-bool wxBitmap::operator == ( const wxBitmap& bmp )
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
+
+ M_BITMAPDATA->m_bitmapPalette = palette ;
+}
+
+void wxBitmap::SetMask(wxMask *mask)
{
- return m_refData == bmp.m_refData;
-};
-
-bool wxBitmap::operator != ( const wxBitmap& bmp )
+ if (!M_BITMAPDATA)
+ m_refData = new wxBitmapRefData;
+
+ M_BITMAPDATA->m_bitmapMask = mask ;
+}
+
+void wxBitmap::AddHandler(wxBitmapHandler *handler)
{
- return m_refData != bmp.m_refData;
-};
-
-bool wxBitmap::Ok(void) const
+ sm_handlers.Append(handler);
+}
+
+void wxBitmap::InsertHandler(wxBitmapHandler *handler)
{
- return m_refData != NULL;
-};
-
-int wxBitmap::GetHeight(void) const
+ sm_handlers.Insert(handler);
+}
+
+bool wxBitmap::RemoveHandler(const wxString& name)
{
- if (!Ok()) return 0;
- return M_BMPDATA->m_height;
-};
+ wxBitmapHandler *handler = FindHandler(name);
+ if ( handler )
+ {
+ sm_handlers.DeleteObject(handler);
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
+{
+ wxNode *node = sm_handlers.First();
+ while ( node )
+ {
+ wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
+ if ( handler->GetName() == name )
+ return handler;
+ node = node->Next();
+ }
+ return NULL;
+}
-int wxBitmap::GetWidth(void) const
+wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
+{
+ wxNode *node = sm_handlers.First();
+ while ( node )
+ {
+ wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
+ if ( handler->GetExtension() == extension &&
+ (bitmapType == -1 || handler->GetType() == bitmapType) )
+ return handler;
+ node = node->Next();
+ }
+ return NULL;
+}
+
+wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
+{
+ wxNode *node = sm_handlers.First();
+ while ( node )
+ {
+ wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
+ if (handler->GetType() == bitmapType)
+ return handler;
+ node = node->Next();
+ }
+ return NULL;
+}
+
+/*
+ * wxMask
+ */
+
+wxMask::wxMask()
{
- if (!Ok()) return 0;
- return M_BMPDATA->m_width;
-};
+/* TODO
+ m_maskBitmap = 0;
+*/
+}
-int wxBitmap::GetDepth(void) const
+// Construct a mask from a bitmap and a colour indicating
+// the transparent area
+wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
{
- if (!Ok()) return 0;
- return M_BMPDATA->m_bpp;
-};
+/* TODO
+ m_maskBitmap = 0;
+*/
+ Create(bitmap, colour);
+}
-void wxBitmap::SetHeight( int height )
+// Construct a mask from a bitmap and a palette index indicating
+// the transparent area
+wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
{
- if (!Ok()) return;
- M_BMPDATA->m_height = height;
-};
+/* TODO
+ m_maskBitmap = 0;
+*/
+
+ Create(bitmap, paletteIndex);
+}
-void wxBitmap::SetWidth( int width )
+// Construct a mask from a mono bitmap (copies the bitmap).
+wxMask::wxMask(const wxBitmap& bitmap)
{
- if (!Ok()) return;
- M_BMPDATA->m_width = width;
-};
+/* TODO
+ m_maskBitmap = 0;
+*/
+
+ Create(bitmap);
+}
-void wxBitmap::SetDepth( int depth )
+wxMask::~wxMask()
{
- if (!Ok()) return;
- M_BMPDATA->m_bpp = depth;
-};
+// TODO: delete mask bitmap
+}
-wxMask *wxBitmap::GetMask(void) const
+// Create a mask from a mono bitmap (copies the bitmap).
+bool wxMask::Create(const wxBitmap& bitmap)
{
- if (!Ok()) return NULL;
-
- return M_BMPDATA->m_mask;
-};
+// TODO
+ return FALSE;
+}
-void wxBitmap::SetMask( wxMask *mask )
+// Create a mask from a bitmap and a palette index indicating
+// the transparent area
+bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
{
- if (!Ok()) return;
-
- if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
- M_BMPDATA->m_mask = mask;
-};
+// TODO
+ return FALSE;
+}
-void wxBitmap::Resize( int WXUNUSED(height), int WXUNUSED(width) )
+// Create a mask from a bitmap and a colour indicating
+// the transparent area
+bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
{
- if (!Ok()) return;
-
-};
+// TODO
+ return FALSE;
+}
-bool wxBitmap::SaveFile( const wxString &WXUNUSED(name), int WXUNUSED(type),
- wxPalette *WXUNUSED(palette) )
+/*
+ * wxBitmapHandler
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
+
+bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
{
- return FALSE;
-};
+ return FALSE;
+}
-bool wxBitmap::LoadFile( const wxString &WXUNUSED(name), int WXUNUSED(type) )
+bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type,
+ int desiredWidth, int desiredHeight)
{
- return FALSE;
-};
-
-wxPalette *wxBitmap::GetPalette(void) const
+ return FALSE;
+}
+
+bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
{
- if (!Ok()) return NULL;
- return M_BMPDATA->m_palette;
+ return FALSE;
+}
+
+/*
+ * Standard handlers
+ */
+
+/* TODO: bitmap handlers, a bit like this:
+class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
+{
+ DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
+public:
+ inline wxBMPResourceHandler()
+ {
+ m_name = "Windows bitmap resource";
+ m_extension = "";
+ m_type = wxBITMAP_TYPE_BMP_RESOURCE;
+ };
+
+ virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
+ int desiredWidth, int desiredHeight);
};
+IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
+*/
+
+void wxBitmap::CleanUpHandlers()
+{
+ wxNode *node = sm_handlers.First();
+ while ( node )
+ {
+ wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
+ wxNode *next = node->Next();
+ delete handler;
+ delete node;
+ node = next;
+ }
+}
+void wxBitmap::InitStandardHandlers()
+{
+/* TODO: initialize all standard bitmap or derive class handlers here.
+ AddHandler(new wxBMPResourceHandler);
+ AddHandler(new wxBMPFileHandler);
+ AddHandler(new wxXPMFileHandler);
+ AddHandler(new wxXPMDataHandler);
+ AddHandler(new wxICOResourceHandler);
+ AddHandler(new wxICOFileHandler);
+*/
+}
/////////////////////////////////////////////////////////////////////////////
// Name: bmpbuttn.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxBitmapButton
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/bmpbuttn.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxButton)
+#endif
-class wxBitmapButton;
+bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
+ const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator,
+ const wxString& name)
+{
+ m_buttonBitmap = bitmap;
+ SetName(name);
+ SetValidator(validator);
+ parent->AddChild(this);
-//-----------------------------------------------------------------------------
-// wxBitmapButton
-//-----------------------------------------------------------------------------
+ m_backgroundColour = parent->GetDefaultBackgroundColour() ;
+ m_foregroundColour = parent->GetDefaultForegroundColour() ;
+ m_windowStyle = style;
+ m_marginX = 0;
+ m_marginY = 0;
-IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton,wxControl)
+ int x = pos.x;
+ int y = pos.y;
+ int width = size.x;
+ int height = size.y;
-wxBitmapButton::wxBitmapButton(void)
-{
-};
+ if (id == -1)
+ m_windowId = NewControlId();
+ else
+ m_windowId = id;
-wxBitmapButton::wxBitmapButton( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
-{
- Create( parent, id, bitmap, pos, size, style, name );
-};
+ if ( width == -1 && bitmap.Ok())
+ width = bitmap.GetWidth() + 2*m_marginX;
-bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
-{
- m_needParent = TRUE;
-
- wxSize newSize = size;
+ if ( height == -1 && bitmap.Ok())
+ height = bitmap.GetHeight() + 2*m_marginY;
- PreCreation( parent, id, pos, newSize, style, name );
-
- m_bitmap = bitmap;
- m_label = "";
-
-
- if (newSize.x == -1) newSize.x = m_bitmap.GetHeight()+10;
- if (newSize.y == -1) newSize.y = m_bitmap.GetWidth()+10;
- SetSize( newSize.x, newSize.y );
-
+ /* TODO: create bitmap button
+ */
- PostCreation();
-
- Show( TRUE );
-
- return TRUE;
-};
-
-void wxBitmapButton::SetDefault(void)
-{
-};
+ return FALSE;
+}
-void wxBitmapButton::SetLabel( const wxString &label )
+void wxBitmapButton::SetBitmapLabel(const wxBitmap& bitmap)
{
- wxControl::SetLabel( label );
-};
+ m_buttonBitmap = bitmap;
+}
-wxString wxBitmapButton::GetLabel(void) const
-{
- return wxControl::GetLabel();
-};
/////////////////////////////////////////////////////////////////////////////
// Name: brush.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxBrush
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#pragma implementation "brush.h"
#endif
+#include "wx/setup.h"
+#include "wx/utils.h"
#include "wx/brush.h"
-//-----------------------------------------------------------------------------
-// wxBrush
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject)
+#endif
-class wxBrushRefData: public wxObjectRefData
-{
- public:
-
- wxBrushRefData(void);
-
- int m_style;
- wxBitmap m_stipple;
- wxColour m_colour;
-};
-
-wxBrushRefData::wxBrushRefData(void)
+wxBrushRefData::wxBrushRefData()
{
- m_style = 0;
-};
-
-//-----------------------------------------------------------------------------
-
-#define M_BRUSHDATA ((wxBrushRefData *)m_refData)
+ m_style = wxSOLID;
+// TODO: null data
+}
-IMPLEMENT_DYNAMIC_CLASS(wxBrush,wxGDIObject)
-
-wxBrush::wxBrush(void)
+wxBrushRefData::wxBrushRefData(const wxBrushRefData& data)
{
- if (wxTheBrushList) wxTheBrushList->AddBrush( this );
-};
+ m_style = data.m_style;
+ m_stipple = data.m_stipple;
+ m_colour = data.m_colour;
+/* TODO: null data
+ m_hBrush = 0;
+*/
+}
-wxBrush::wxBrush( const wxColour &colour, int style )
-{
- m_refData = new wxBrushRefData();
- M_BRUSHDATA->m_style = style;
- M_BRUSHDATA->m_colour = colour;
-
- if (wxTheBrushList) wxTheBrushList->AddBrush( this );
-};
-
-wxBrush::wxBrush( const wxString &colourName, int style )
+wxBrushRefData::~wxBrushRefData()
{
- m_refData = new wxBrushRefData();
- M_BRUSHDATA->m_style = style;
- M_BRUSHDATA->m_colour = colourName;
-
- if (wxTheBrushList) wxTheBrushList->AddBrush( this );
-};
-
-wxBrush::wxBrush( const wxBitmap &stippleBitmap )
+// TODO: delete data
+}
+
+// Brushes
+wxBrush::wxBrush()
{
- m_refData = new wxBrushRefData();
- M_BRUSHDATA->m_style = wxSTIPPLE;
- M_BRUSHDATA->m_colour = *wxBLACK;
- M_BRUSHDATA->m_stipple = stippleBitmap;
-
- if (wxTheBrushList) wxTheBrushList->AddBrush( this );
-};
-
-wxBrush::wxBrush( const wxBrush &brush )
+ if ( wxTheBrushList )
+ wxTheBrushList->AddBrush(this);
+}
+
+wxBrush::~wxBrush()
{
- Ref( brush );
-
- if (wxTheBrushList) wxTheBrushList->AddBrush( this );
-};
+ if ( wxTheBrushList )
+ wxTheBrushList->RemoveBrush(this);
+}
-wxBrush::wxBrush( const wxBrush *brush )
+wxBrush::wxBrush(const wxColour& col, int Style)
{
- if (brush) Ref( *brush );
-
- if (wxTheBrushList) wxTheBrushList->Append( this );
-};
+ m_refData = new wxBrushRefData;
-wxBrush::~wxBrush(void)
+ M_BRUSHDATA->m_colour = col;
+ M_BRUSHDATA->m_style = Style;
+
+ RealizeResource();
+
+ if ( wxTheBrushList )
+ wxTheBrushList->AddBrush(this);
+}
+
+wxBrush::wxBrush(const wxString& col, int Style)
{
- if (wxTheBrushList) wxTheBrushList->RemoveBrush( this );
-};
+ m_refData = new wxBrushRefData;
+
+ // Implicit conversion from string to wxColour via colour database
+ M_BRUSHDATA->m_colour = col;
+ M_BRUSHDATA->m_style = Style;
-wxBrush& wxBrush::operator = ( const wxBrush& brush )
+ RealizeResource();
+
+ if ( wxTheBrushList )
+ wxTheBrushList->AddBrush(this);
+}
+
+wxBrush::wxBrush(const wxBitmap& stipple)
{
- if (*this == brush) return (*this);
- Ref( brush );
- return *this;
-};
-
-bool wxBrush::operator == ( const wxBrush& brush )
+ m_refData = new wxBrushRefData;
+
+ M_BRUSHDATA->m_style = wxSTIPPLE;
+ M_BRUSHDATA->m_stipple = stipple;
+
+ RealizeResource();
+
+ if ( wxTheBrushList )
+ wxTheBrushList->AddBrush(this);
+}
+
+void wxBrush::Unshare()
{
- return m_refData == brush.m_refData;
-};
+ // Don't change shared data
+ if (!m_refData)
+ {
+ m_refData = new wxBrushRefData();
+ }
+ else
+ {
+ wxBrushRefData* ref = new wxBrushRefData(*(wxBrushRefData*)m_refData);
+ UnRef();
+ m_refData = ref;
+ }
+}
-bool wxBrush::operator != ( const wxBrush& brush )
+void wxBrush::SetColour(const wxColour& col)
{
- return m_refData != brush.m_refData;
-};
+ Unshare();
+
+ M_BRUSHDATA->m_colour = col;
-bool wxBrush::Ok(void) const
+ RealizeResource();
+}
+
+void wxBrush::SetColour(const wxString& col)
{
- return ((m_refData) && M_BRUSHDATA->m_colour.Ok());
-};
+ Unshare();
+
+ M_BRUSHDATA->m_colour = col;
+
+ RealizeResource();
+}
-int wxBrush::GetStyle(void) const
+void wxBrush::SetColour(const unsigned char r, const unsigned char g, const unsigned char b)
{
- return M_BRUSHDATA->m_style;
-};
+ Unshare();
-wxColour &wxBrush::GetColour(void) const
+ M_BRUSHDATA->m_colour.Set(r, g, b);
+
+ RealizeResource();
+}
+
+void wxBrush::SetStyle(int Style)
{
- return M_BRUSHDATA->m_colour;
-};
+ Unshare();
+
+ M_BRUSHDATA->m_style = Style;
+
+ RealizeResource();
+}
-wxBitmap *wxBrush::GetStipple(void) const
+void wxBrush::SetStipple(const wxBitmap& Stipple)
{
- return &M_BRUSHDATA->m_stipple;
-};
+ Unshare();
+ M_BRUSHDATA->m_stipple = Stipple;
+
+ RealizeResource();
+}
+
+void wxBrush::RealizeResource()
+{
+// TODO: create the brush
+}
/////////////////////////////////////////////////////////////////////////////
// Name: button.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxButton
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/button.h"
-//-----------------------------------------------------------------------------
-// classes
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
+#endif
-class wxButton;
+// Button
-//-----------------------------------------------------------------------------
-// wxButton
-//-----------------------------------------------------------------------------
+bool wxButton::Create(wxWindow *parent, wxWindowID id, const wxString& label,
+ const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator,
+ const wxString& name)
+{
+ SetName(name);
+ SetValidator(validator);
+ m_windowStyle = style;
-IMPLEMENT_DYNAMIC_CLASS(wxButton,wxControl)
+ parent->AddChild((wxButton *)this);
-//-----------------------------------------------------------------------------
+ if (id == -1)
+ m_windowId = NewControlId();
+ else
+ m_windowId = id;
-wxButton::wxButton(void)
-{
-};
+ // TODO: create button
-wxButton::wxButton( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+ return FALSE;
+}
+
+void wxButton::SetSize(int x, int y, int width, int height, int sizeFlags)
{
- Create( parent, id, label, pos, size, style, name );
-};
+ // TODO
+}
-bool wxButton::Create( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+void wxButton::SetDefault()
{
- return TRUE;
-};
+ wxWindow *parent = (wxWindow *)GetParent();
+ if (parent)
+ parent->SetDefaultItem(this);
+
+ // TODO: make button the default
+}
-void wxButton::SetDefault(void)
+wxString wxButton::GetLabel() const
{
-};
+ // TODO
+ return wxString("");
+}
-void wxButton::SetLabel( const wxString &label )
+void wxButton::SetLabel(const wxString& label)
{
- wxControl::SetLabel( label );
-};
+ // TODO
+}
-wxString wxButton::GetLabel(void) const
+void wxButton::Command (wxCommandEvent & event)
{
- return wxControl::GetLabel();
-};
+ ProcessCommand (event);
+}
+
/////////////////////////////////////////////////////////////////////////////
// Name: checkbox.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxCheckBox
+// Author: AUTHOR
+// Modified by:
+// Created: 04/01/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "checkbox.h"
#endif
#include "wx/checkbox.h"
-//-----------------------------------------------------------------------------
-// wxCheckBox
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapCheckBox, wxCheckBox)
+#endif
+
+// Single check box item
+bool wxCheckBox::Create(wxWindow *parent, wxWindowID id, const wxString& label,
+ const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator,
+ const wxString& name)
+{
+ SetName(name);
+ SetValidator(validator);
+ m_windowStyle = style;
+
+ if (parent) parent->AddChild(this);
+
+ if ( id == -1 )
+ m_windowId = NewControlId();
+ else
+ m_windowId = id;
+
+ // TODO: create checkbox
+
+ return FALSE;
+}
+
+void wxCheckBox::SetLabel(const wxString& label)
+{
+ // TODO
+}
+
+void wxCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+ // TODO
+}
-IMPLEMENT_DYNAMIC_CLASS(wxCheckBox,wxControl)
+void wxCheckBox::SetValue(bool val)
+{
+ // TODO
+}
-wxCheckBox::wxCheckBox(void)
+bool wxCheckBox::GetValue() const
{
-};
+ // TODO
+ return FALSE;
+}
-wxCheckBox::wxCheckBox( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+void wxCheckBox::Command (wxCommandEvent & event)
{
- Create( parent, id, label, pos, size, style, name );
-};
+ SetValue ((event.GetInt() != 0));
+ ProcessCommand (event);
+}
-bool wxCheckBox::Create( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+// Bitmap checkbox
+bool wxBitmapCheckBox::Create(wxWindow *parent, wxWindowID id, const wxBitmap *label,
+ const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator,
+ const wxString& name)
{
- return TRUE;
-};
+ SetName(name);
+ SetValidator(validator);
+ m_windowStyle = style;
+
+ if (parent) parent->AddChild(this);
+
+ if ( id == -1 )
+ m_windowId = NewControlId();
+ else
+ m_windowId = id;
+
+ // TODO: Create the bitmap checkbox
+
+ return FALSE;
+}
-void wxCheckBox::SetValue( bool WXUNUSED(state) )
+void wxBitmapCheckBox::SetLabel(const wxBitmap *bitmap)
{
-};
+ // TODO
+}
-bool wxCheckBox::GetValue(void) const
+void wxBitmapCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
- return FALSE;
-};
+ // TODO
+}
+
+void wxBitmapCheckBox::SetValue(bool val)
+{
+ // TODO
+}
+
+bool wxBitmapCheckBox::GetValue() const
+{
+ // TODOD
+ return FALSE;
+}
+
/////////////////////////////////////////////////////////////////////////////
// Name: choice.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxChoice
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "choice.h"
#endif
+// For compilers that support precompilation, includes "wx.h".
#include "wx/choice.h"
-//-----------------------------------------------------------------------------
-// wxChoice
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
+#endif
-//-----------------------------------------------------------------------------
+bool wxChoice::Create(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ int n, const wxString choices[],
+ long style,
+ const wxValidator& validator,
+ const wxString& name)
+{
+ SetName(name);
+ SetValidator(validator);
+ m_noStrings = n;
+ m_windowStyle = style;
-IMPLEMENT_DYNAMIC_CLASS(wxChoice,wxControl)
+ if (parent) parent->AddChild(this);
-wxChoice::wxChoice(void)
-{
-};
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
-wxChoice::wxChoice( wxWindow *parent, wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- int n, const wxString choices[],
- long style, const wxString &name )
-{
- Create( parent, id, pos, size, n, choices, style, name );
-};
+ // TODO: create choice control
+ return FALSE;
+}
-bool wxChoice::Create( wxWindow *parent, wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- int n, const wxString choices[],
- long style, const wxString &name )
+void wxChoice::Append(const wxString& item)
{
- return TRUE;
-};
-
-void wxChoice::Append( const wxString &WXUNUSED(item) )
-{
-};
-
-void wxChoice::Clear(void)
-{
-};
+ // TODO
+ m_noStrings ++;
+}
-int wxChoice::FindString( const wxString &WXUNUSED(string) ) const
+void wxChoice::Delete(int n)
{
- return -1;
-};
+ // TODO
+ m_noStrings --;
+}
-int wxChoice::GetColumns(void) const
+void wxChoice::Clear()
{
- return 1;
-};
+ // TODO
+ m_noStrings = 0;
+}
-int wxChoice::GetSelection(void)
+int wxChoice::GetSelection() const
{
- return -1;
-};
+ // TODO
+ return 0;
+}
-wxString wxChoice::GetString( int WXUNUSED(n) ) const
+void wxChoice::SetSelection(int n)
{
- return "";
-};
+ // TODO
+}
-wxString wxChoice::GetStringSelection(void) const
+int wxChoice::FindString(const wxString& s) const
{
- return "";
-};
+ // TODO
+ return 0;
+}
-int wxChoice::Number(void) const
+wxString wxChoice::GetString(int n) const
{
- return 0;
-};
+ // TODO
+ return wxString("");
+}
-void wxChoice::SetColumns( int WXUNUSED(n) )
+void wxChoice::SetSize(int x, int y, int width, int height, int sizeFlags)
{
-};
+ // TODO
+}
-void wxChoice::SetSelection( int WXUNUSED(n) )
+wxString wxChoice::GetStringSelection () const
{
-};
-
-void wxChoice::SetStringSelection( const wxString &string )
+ int sel = GetSelection ();
+ if (sel > -1)
+ return wxString(this->GetString (sel));
+ else
+ return wxString("");
+}
+
+bool wxChoice::SetStringSelection (const wxString& s)
+{
+ int sel = FindString (s);
+ if (sel > -1)
+ {
+ SetSelection (sel);
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+void wxChoice::Command(wxCommandEvent & event)
{
- int n = FindString( string );
- if (n != -1) SetSelection( n );
-};
+ SetSelection (event.GetInt());
+ ProcessCommand (event);
+}
/////////////////////////////////////////////////////////////////////////////
// Name: colour.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxColour class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "colour.h"
#endif
#include "wx/gdicmn.h"
+#include "wx/colour.h"
-//-----------------------------------------------------------------------------
-// wxColour
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject)
+#endif
-class wxColourRefData: public wxObjectRefData
-{
- public:
-
- wxColourRefData(void);
- ~wxColourRefData(void);
- void FreeColour(void);
-
- bool m_hasPixel;
-
- friend wxColour;
-};
+// Colour
-wxColourRefData::wxColourRefData(void)
+wxColour::wxColour ()
{
- m_hasPixel = FALSE;
-};
-
-wxColourRefData::~wxColourRefData(void)
+ m_isInit = FALSE;
+ m_red = m_blue = m_green = 0;
+/* TODO
+ m_pixel = 0;
+*/
+}
+
+wxColour::wxColour (unsigned char r, unsigned char g, unsigned char b)
{
- FreeColour();
-};
-
-void wxColourRefData::FreeColour(void)
+ m_red = r;
+ m_green = g;
+ m_blue = b;
+ m_isInit = TRUE;
+/* TODO
+ m_pixel = PALETTERGB (m_red, m_green, m_blue);
+*/
+}
+
+wxColour::wxColour (const wxColour& col)
{
-};
-
-//-----------------------------------------------------------------------------
-
-#define M_COLDATA ((wxColourRefData *)m_refData)
-
-#define SHIFT (8*(sizeof(short int)-sizeof(char)))
-
-IMPLEMENT_DYNAMIC_CLASS(wxColour,wxGDIObject)
-
-wxColour::wxColour(void)
+ m_red = col.m_red;
+ m_green = col.m_green;
+ m_blue = col.m_blue;
+ m_isInit = col.m_isInit;
+/* TODO
+ m_pixel = col.m_pixel;
+*/
+}
+
+wxColour& wxColour::operator =(const wxColour& col)
{
-};
-
-wxColour::wxColour( char WXUNUSED(red), char WXUNUSED(green), char WXUNUSED(blue) )
+ m_red = col.m_red;
+ m_green = col.m_green;
+ m_blue = col.m_blue;
+ m_isInit = col.m_isInit;
+/* TODO
+ m_pixel = col.m_pixel;
+*/
+ return *this;
+}
+
+wxColour::wxColour (const wxString& col)
{
- m_refData = new wxColourRefData();
-};
-
-wxColour::wxColour( const wxString &colourName )
+ wxColour *the_colour = wxTheColourDatabase->FindColour (col);
+ if (the_colour)
+ {
+ m_red = the_colour->Red ();
+ m_green = the_colour->Green ();
+ m_blue = the_colour->Blue ();
+ m_isInit = TRUE;
+ }
+ else
+ {
+ m_red = 0;
+ m_green = 0;
+ m_blue = 0;
+ m_isInit = FALSE;
+ }
+/* TODO
+ m_pixel = PALETTERGB (m_red, m_green, m_blue);
+*/
+}
+
+wxColour::~wxColour ()
{
- wxNode *node = NULL;
- if ( (wxTheColourDatabase) && (node = wxTheColourDatabase->Find(colourName)) )
- {
- wxColour *col = (wxColour*)node->Data();
- UnRef();
- if (col) Ref( *col );
- }
- else
- {
- m_refData = new wxColourRefData();
- };
-};
-
-wxColour::wxColour( const wxColour& col )
-{
- Ref( col );
-};
+}
-wxColour::wxColour( const wxColour* col )
-{
- if (col) Ref( *col );
-};
-
-wxColour::~wxColour(void)
+wxColour& wxColour::operator = (const wxString& col)
{
-};
-
-wxColour& wxColour::operator = ( const wxColour& col )
-{
- if (*this == col) return (*this);
- Ref( col );
- return *this;
-};
-
-wxColour& wxColour::operator = ( const wxString& colourName )
-{
- UnRef();
- wxNode *node = NULL;
- if ((wxTheColourDatabase) && (node = wxTheColourDatabase->Find(colourName)) )
- {
- wxColour *col = (wxColour*)node->Data();
- if (col) Ref( *col );
- }
- else
- {
- m_refData = new wxColourRefData();
- };
- return *this;
-};
-
-bool wxColour::operator == ( const wxColour& col )
-{
- return m_refData == col.m_refData;
-};
-
-bool wxColour::operator != ( const wxColour& col)
-{
- return m_refData != col.m_refData;
-};
-
-void wxColour::Set( const unsigned char WXUNUSED(red), const unsigned char WXUNUSED(green),
- const unsigned char WXUNUSED(blue) )
-{
- UnRef();
- m_refData = new wxColourRefData();
-};
-
-unsigned char wxColour::Red(void) const
-{
- if (!Ok()) return 0;
- return 0;
-};
-
-unsigned char wxColour::Green(void) const
+ wxColour *the_colour = wxTheColourDatabase->FindColour (col);
+ if (the_colour)
+ {
+ m_red = the_colour->Red ();
+ m_green = the_colour->Green ();
+ m_blue = the_colour->Blue ();
+ m_isInit = TRUE;
+ }
+ else
+ {
+ m_red = 0;
+ m_green = 0;
+ m_blue = 0;
+ m_isInit = FALSE;
+ }
+/* TODO
+ m_pixel = PALETTERGB (m_red, m_green, m_blue);
+*/
+ return (*this);
+}
+
+void wxColour::Set (unsigned char r, unsigned char g, unsigned char b)
{
- if (!Ok()) return 0;
- return 0;
-};
-
-unsigned char wxColour::Blue(void) const
-{
- if (!Ok()) return 0;
- return 0;
-};
-
-bool wxColour::Ok(void) const
-{
- return (m_refData);
- return 0;
-};
-
-int wxColour::GetPixel(void)
-{
- if (!Ok()) return 0;
- return 0;
-};
-
+ m_red = r;
+ m_green = g;
+ m_blue = b;
+ m_isInit = TRUE;
+/* TODO
+ m_pixel = PALETTERGB (m_red, m_green, m_blue);
+*/
+}
/////////////////////////////////////////////////////////////////////////////
// Name: combobox.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxComboBox class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/combobox.h"
-//-----------------------------------------------------------------------------
-// wxComboBox
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxComboBox,wxControl)
-
-bool wxComboBox::Create(wxWindow *parent, wxWindowID id, const wxString& value,
- const wxPoint& pos, const wxSize& size, int n, const wxString choices[],
- long style, const wxString& name )
-{
- return TRUE;
-};
-
-void wxComboBox::Clear(void)
-{
-};
-
-void wxComboBox::Append( const wxString &item )
-{
- Append( item, (char*)NULL );
-};
-
-void wxComboBox::Append( const wxString &WXUNUSED(item), char *WXUNUSED(clientData) )
-{
-};
-
-void wxComboBox::Delete( int WXUNUSED(n) )
-{
-};
-
-int wxComboBox::FindString( const wxString &WXUNUSED(item) )
-{
- return -1;
-};
-
-char* wxComboBox::GetClientData( int WXUNUSED(n) )
-{
- return (char*)NULL;
-};
-
-void wxComboBox::SetClientData( int WXUNUSED(n), char *WXUNUSED(clientData) )
-{
-};
-
-int wxComboBox::GetSelection(void) const
-{
- return -1;
-};
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
+#endif
-wxString wxComboBox::GetString( int WXUNUSED(n) ) const
+bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
+ const wxString& value,
+ const wxPoint& pos,
+ const wxSize& size,
+ int n, const wxString choices[],
+ long style,
+ const wxValidator& validator,
+ const wxString& name)
{
- return "";
-};
+ SetName(name);
+ SetValidator(validator);
+ m_noStrings = n;
+ m_windowStyle = style;
-wxString wxComboBox::GetStringSelection(void) const
-{
- return "";
-};
+ if (parent) parent->AddChild(this);
-int wxComboBox::Number(void) const
-{
- return 0;
-};
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
-void wxComboBox::SetSelection( int WXUNUSED(n) )
-{
-};
+ // TODO: create combobox control
-void wxComboBox::SetStringSelection( const wxString &string )
-{
- int res = FindString( string );
- if (res == -1) return;
- SetSelection( res );
-};
+ return TRUE;
+}
-wxString wxComboBox::GetValue(void) const
+wxString wxComboBox::GetValue() const
{
- return "";
-};
+ // TODO
+ return wxString("");
+}
-void wxComboBox::SetValue( const wxString& WXUNUSED(value) )
+void wxComboBox::SetValue(const wxString& value)
{
-};
+ // TODO
+}
-void wxComboBox::Copy(void)
+// Clipboard operations
+void wxComboBox::Copy()
{
-};
+ // TODO
+}
-void wxComboBox::Cut(void)
+void wxComboBox::Cut()
{
-};
+ // TODO
+}
-void wxComboBox::Paste(void)
+void wxComboBox::Paste()
{
-};
+ // TODO
+}
-void wxComboBox::SetInsertionPoint( long WXUNUSED(pos) )
+void wxComboBox::SetEditable(bool editable)
{
-};
+ // TODO
+}
-void wxComboBox::SetInsertionPointEnd(void)
+void wxComboBox::SetInsertionPoint(long pos)
{
-};
+ // TODO
+}
-long wxComboBox::GetInsertionPoint(void) const
+void wxComboBox::SetInsertionPointEnd()
{
- return 0;
-};
+ // TODO
+}
-long wxComboBox::GetLastPosition(void) const
+long wxComboBox::GetInsertionPoint() const
{
- return 0;
-};
+ // TODO
+ return 0;
+}
-void wxComboBox::Replace( long WXUNUSED(from), long WXUNUSED(to), const wxString& WXUNUSED(value) )
+long wxComboBox::GetLastPosition() const
{
-};
+ // TODO
+ return 0;
+}
-void wxComboBox::Remove(long WXUNUSED(from), long WXUNUSED(to) )
+void wxComboBox::Replace(long from, long to, const wxString& value)
{
-};
+ // TODO
+}
-void wxComboBox::SetSelection( long WXUNUSED(from), long WXUNUSED(to) )
+void wxComboBox::Remove(long from, long to)
{
-};
+ // TODO
+}
-void wxComboBox::SetEditable( bool WXUNUSED(editable) )
+void wxComboBox::SetSelection(long from, long to)
{
-};
+ // TODO
+}
-
/////////////////////////////////////////////////////////////////////////////
// Name: control.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxControl class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#include "wx/control.h"
-//-----------------------------------------------------------------------------
-// wxControl
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
-IMPLEMENT_DYNAMIC_CLASS(wxControl,wxWindow)
+BEGIN_EVENT_TABLE(wxControl, wxWindow)
+END_EVENT_TABLE()
+#endif
-wxControl::wxControl(void)
+// Item members
+wxControl::wxControl()
{
-};
+ m_backgroundColour = *wxWHITE;
+ m_foregroundColour = *wxBLACK;
+ m_callback = 0;
+}
-wxControl::wxControl( wxWindow *parent, wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name ) :
- wxWindow( parent, id, pos, size, style, name )
+wxControl::~wxControl()
{
-};
+ // If we delete an item, we should initialize the parent panel,
+ // because it could now be invalid.
+ wxWindow *parent = (wxWindow *)GetParent();
+ if (parent)
+ {
+ if (parent->GetDefaultItem() == this)
+ parent->SetDefaultItem(NULL);
+ }
+}
-void wxControl::Command( wxCommandEvent &WXUNUSED(event) )
+void wxControl::SetLabel(const wxString& label)
{
-};
+ // TODO
+}
-void wxControl::SetLabel( const wxString &label )
+wxString wxControl::GetLabel() const
{
- for ( const char *pc = label; *pc != '\0'; pc++ ) {
- if ( *pc == '&' ) {
- pc++; // skip it
-#if 0 // it would be unused anyhow for now - kbd interface not done yet
- if ( *pc != '&' )
- m_chAccel = *pc;
-#endif
+ // TODO
+ return wxString("");
+}
+
+/*
+ * Allocates control IDs within the appropriate range
+ */
+
+int NewControlId()
+{
+ static int s_controlId = 0;
+ s_controlId ++;
+ return s_controlId;
+}
+
+void wxControl::ProcessCommand (wxCommandEvent & event)
+{
+ // Tries:
+ // 1) A callback function (to become obsolete)
+ // 2) OnCommand, starting at this window and working up parent hierarchy
+ // 3) OnCommand then calls ProcessEvent to search the event tables.
+ if (m_callback)
+ {
+ (void) (*(m_callback)) (*this, event);
+ }
+ else
+ {
+ GetEventHandler()->OnCommand(*this, event);
}
+}
- m_label << *pc;
- }
-};
+void wxControl::SetClientSize (int width, int height)
+{
+ SetSize (-1, -1, width, height);
+}
-wxString wxControl::GetLabel(void) const
+void wxControl::Centre (int direction)
{
- return m_label;
-};
+ int x, y, width, height, panel_width, panel_height, new_x, new_y;
+
+ wxWindow *parent = (wxWindow *) GetParent ();
+ if (!parent)
+ return;
+
+ parent->GetClientSize (&panel_width, &panel_height);
+ GetSize (&width, &height);
+ GetPosition (&x, &y);
+
+ new_x = x;
+ new_y = y;
+
+ if (direction & wxHORIZONTAL)
+ new_x = (int) ((panel_width - width) / 2);
+ if (direction & wxVERTICAL)
+ new_y = (int) ((panel_height - height) / 2);
+ SetSize (new_x, new_y, width, height);
+}
/////////////////////////////////////////////////////////////////////////////
// Name: cursor.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxCursor class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "cursor.h"
#endif
#include "wx/cursor.h"
-//-----------------------------------------------------------------------------
-// wxCursor
-//-----------------------------------------------------------------------------
-
-class wxCursorRefData: public wxObjectRefData
-{
- public:
-
- wxCursorRefData(void);
- ~wxCursorRefData(void);
-
-};
-
-wxCursorRefData::wxCursorRefData(void)
-{
-};
-
-wxCursorRefData::~wxCursorRefData(void)
-{
-};
-
-//-----------------------------------------------------------------------------
-
-#define M_CURSORDATA ((wxCursorRefData *)m_refData)
-
-IMPLEMENT_DYNAMIC_CLASS(wxCursor,wxObject)
-
-wxCursor::wxCursor(void)
-{
-};
-
-wxCursor::wxCursor( int WXUNUSED(cursorId) )
-{
- m_refData = new wxCursorRefData();
-};
-
-wxCursor::wxCursor( const wxCursor &cursor )
-{
- Ref( cursor );
-};
-
-wxCursor::wxCursor( const wxCursor *cursor )
-{
- UnRef();
- if (cursor) Ref( *cursor );
-};
-
-wxCursor::~wxCursor(void)
-{
-};
-
-wxCursor& wxCursor::operator = ( const wxCursor& cursor )
-{
- if (*this == cursor) return (*this);
- Ref( cursor );
- return *this;
-};
-
-bool wxCursor::operator == ( const wxCursor& cursor )
-{
- return m_refData == cursor.m_refData;
-};
-
-bool wxCursor::operator != ( const wxCursor& cursor )
-{
- return m_refData != cursor.m_refData;
-};
-
-bool wxCursor::Ok(void) const
-{
- return TRUE;
-};
-
-//-----------------------------------------------------------------------------
-// busy cursor routines
-//-----------------------------------------------------------------------------
-
-bool g_isBusy = FALSE;
-
-void wxEndBusyCursor(void)
-{
- g_isBusy = FALSE;
-};
-
-void wxBeginBusyCursor( wxCursor *WXUNUSED(cursor) )
-{
- g_isBusy = TRUE;
-};
-
-bool wxIsBusy(void)
-{
- return g_isBusy;
-};
-
-void wxSetCursor( const wxCursor& cursor )
-{
- extern wxCursor *g_globalCursor;
- if (g_globalCursor) (*g_globalCursor) = cursor;
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
+#endif
- if (cursor.Ok()) {};
-};
+wxCursorRefData::wxCursorRefData()
+{
+ m_width = 32; m_height = 32;
+
+/* TODO
+ m_hCursor = 0 ;
+*/
+}
+
+wxCursorRefData::~wxCursorRefData()
+{
+ // TODO: destroy cursor
+}
+
+// Cursors
+wxCursor::wxCursor()
+{
+}
+
+wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
+ int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
+{
+}
+
+wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
+{
+ m_refData = new wxIconRefData;
+
+ // TODO: create cursor from a file
+}
+
+// Cursors by stock number
+wxCursor::wxCursor(int cursor_type)
+{
+ m_refData = new wxIconRefData;
+
+/* TODO
+ switch (cursor_type)
+ {
+ case wxCURSOR_WAIT:
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_WAIT);
+ break;
+ case wxCURSOR_IBEAM:
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_IBEAM);
+ break;
+ case wxCURSOR_CROSS:
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_CROSS);
+ break;
+ case wxCURSOR_SIZENWSE:
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENWSE);
+ break;
+ case wxCURSOR_SIZENESW:
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENESW);
+ break;
+ case wxCURSOR_SIZEWE:
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZEWE);
+ break;
+ case wxCURSOR_SIZENS:
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENS);
+ break;
+ case wxCURSOR_CHAR:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+ break;
+ }
+ case wxCURSOR_HAND:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_HAND");
+ break;
+ }
+ case wxCURSOR_BULLSEYE:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BULLSEYE");
+ break;
+ }
+ case wxCURSOR_PENCIL:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PENCIL");
+ break;
+ }
+ case wxCURSOR_MAGNIFIER:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_MAGNIFIER");
+ break;
+ }
+ case wxCURSOR_NO_ENTRY:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_NO_ENTRY");
+ break;
+ }
+ case wxCURSOR_LEFT_BUTTON:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+ break;
+ }
+ case wxCURSOR_RIGHT_BUTTON:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+ break;
+ }
+ case wxCURSOR_MIDDLE_BUTTON:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+ break;
+ }
+ case wxCURSOR_SIZING:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_SIZING");
+ break;
+ }
+ case wxCURSOR_WATCH:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_WATCH");
+ break;
+ }
+ case wxCURSOR_SPRAYCAN:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_ROLLER");
+ break;
+ }
+ case wxCURSOR_PAINT_BRUSH:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PBRUSH");
+ break;
+ }
+ case wxCURSOR_POINT_LEFT:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PLEFT");
+ break;
+ }
+ case wxCURSOR_POINT_RIGHT:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PRIGHT");
+ break;
+ }
+ case wxCURSOR_QUESTION_ARROW:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_QARROW");
+ break;
+ }
+ case wxCURSOR_BLANK:
+ {
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BLANK");
+ break;
+ }
+ default:
+ case wxCURSOR_ARROW:
+ M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
+ break;
+ }
+*/
+
+}
+
+wxCursor::~wxCursor()
+{
+}
+
+// Global cursor setting
+void wxSetCursor(const wxCursor& cursor)
+{
+ // TODO (optional on platforms with no global cursor)
+}
/////////////////////////////////////////////////////////////////////////////
// Name: data.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: Various data
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
-// #pragma implementation
+#pragma implementation
#endif
#include "wx/wx.h"
#define _MAXPATHLEN 500
-// Used for X resources
-
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xresource.h>
-
-wxList wxResourceCache(wxKEY_STRING);
-XrmDatabase wxResourceDatabase;
-
-// Useful buffer, initialized in wxCommonInit
+// Useful buffer, initialized in CommonInit
char *wxBuffer = NULL;
// Windows List
// List of windows pending deletion
wxList wxPendingDelete;
-// Current cursor, in order to hang on to
-// cursor handle when setting the cursor globally
-wxCursor *g_globalCursor = NULL;
-
-// Don't allow event propagation during drag
-bool g_blockEventsOnDrag = FALSE;
-
-// Message Strings for Internationalization
-char **wx_msg_str = (char**)NULL;
-
-// Custom OS version, as optionally placed in wx.ini/.wxrc
-// Currently this can be Win95, Windows, Win32s, WinNT.
-// For some systems, you can't tell until run-time what services you
-// have. See wxGetOsVersion, which uses this string if present.
-char *wxOsVersion = NULL;
-
-// For printing several pages
int wxPageNumber;
-wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL;
// GDI Object Lists
-wxBrushList *wxTheBrushList = NULL;
-wxPenList *wxThePenList = NULL;
-wxFontList *wxTheFontList = NULL;
-wxColourDatabase *wxTheColourDatabase = NULL;
+wxBrushList *wxTheBrushList = NULL;
+wxPenList *wxThePenList = NULL;
+wxFontList *wxTheFontList = NULL;
wxBitmapList *wxTheBitmapList = NULL;
-
-// X only font names
-// wxFontNameDirectory wxTheFontNameDirectory;
+wxColourDatabase *wxTheColourDatabase = NULL;
// Stock objects
wxFont *wxNORMAL_FONT;
wxFont *wxSMALL_FONT;
wxFont *wxITALIC_FONT;
wxFont *wxSWISS_FONT;
-
wxPen *wxRED_PEN;
+
wxPen *wxCYAN_PEN;
wxPen *wxGREEN_PEN;
wxPen *wxBLACK_PEN;
wxColour *wxBLACK;
wxColour *wxWHITE;
-wxColour *wxGREY; // Robert Roebling
wxColour *wxRED;
wxColour *wxBLUE;
wxColour *wxGREEN;
wxCursor *wxCROSS_CURSOR = NULL;
// 'Null' objects
+wxAcceleratorTable wxNullAcceleratorTable;
wxBitmap wxNullBitmap;
-wxIcon wxNullIcon;
+wxIcon wxNullIcon;
wxCursor wxNullCursor;
wxPen wxNullPen;
wxBrush wxNullBrush;
+wxPalette wxNullPalette;
wxFont wxNullFont;
wxColour wxNullColour;
-wxPalette wxNullPalette;
// Default window names
const char *wxButtonNameStr = "button";
const char *wxFloatToStringStr = "%.2f";
const char *wxDoubleToStringStr = "%.2f";
-#ifdef wx_msw
-const char *wxUserResourceStr = "TEXT";
-#endif
-
-
-#if USE_SHARED_LIBRARY
-/*
- * For wxWindows to be made into a dynamic library (e.g. Sun),
- * all IMPLEMENT_... macros must be in one place.
- * But normally, the definitions are in the appropriate places.
- */
-
-// Hand-coded IMPLEMENT... macro for wxObject (define static data)
-wxClassInfo wxObject::classwxObject("wxObject", NULL, NULL, sizeof(wxObject), NULL);
-wxClassInfo *wxClassInfo::first = NULL;
-
-#include "wx/button.h"
-#include "wx/bmpbuttn.h"
-IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
-IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxButton)
-
-#include "wx/checkbox.h"
-IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
-IMPLEMENT_DYNAMIC_CLASS(wxBitmapCheckBox, wxCheckBox)
-
-#include "wx/choice.h"
-IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
-
-#if USE_CLIPBOARD
-#include "wx/clipbrd.h"
-IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
-IMPLEMENT_ABSTRACT_CLASS(wxClipboardClient, wxObject)
-#endif
-
-#if USE_COMBOBOX
-#include "wx/combobox.h"
-IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
-#endif
-
-#include "wx/dc.h"
-#include "wx/dcmemory.h"
-#include "wx/dcclient.h"
-#include "wx/dcscreen.h"
-IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
-IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC)
-IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
-IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
-
-#if defined(wx_msw)
-#include "wx/dcprint.h"
-IMPLEMENT_CLASS(wxPrinterDC, wxDC)
-#endif
-
-#include "wx/dialog.h"
-IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxWindow)
-
-#include "wx/frame.h"
-IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
-
-#include "wx/mdi.h"
-IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
-IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
-IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
-
-#include "wx/cmndata.h"
-IMPLEMENT_DYNAMIC_CLASS(wxColourData, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxFontData, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxPrintData, wxObject)
-
-#include "wx/colordlg.h"
-#include "wx/fontdlg.h"
-
-#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
-#include "wx/generic/colordlg.h"
-#include "wx/generic/fontdlg.h"
-IMPLEMENT_DYNAMIC_CLASS(wxGenericColourDialog, wxDialog)
-IMPLEMENT_DYNAMIC_CLASS(wxGenericFontDialog, wxDialog)
-#endif
-
-// X defines wxColourDialog to be wxGenericColourDialog
-#ifndef wx_x
-IMPLEMENT_DYNAMIC_CLASS(wxColourDialog, wxDialog)
-IMPLEMENT_DYNAMIC_CLASS(wxFontDialog, wxDialog)
-#endif
-
-#include "wx/gdicmn.h"
-#include "wx/pen.h"
-#include "wx/brush.h"
-#include "wx/font.h"
-#include "wx/palette.h"
-#include "wx/icon.h"
-#include "wx/cursor.h"
-
-IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject)
-IMPLEMENT_CLASS(wxColourDatabase, wxList)
-IMPLEMENT_DYNAMIC_CLASS(wxFontList, wxList)
-IMPLEMENT_DYNAMIC_CLASS(wxPenList, wxList)
-IMPLEMENT_DYNAMIC_CLASS(wxBrushList, wxList)
-IMPLEMENT_DYNAMIC_CLASS(wxBitmapList, wxList)
-
-/*
-#if (!USE_TYPEDEFS)
-IMPLEMENT_DYNAMIC_CLASS(wxPoint, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxIntPoint, wxObject)
-#endif
-*/
-
-#if defined(wx_x) || (defined(wx_msw) && USE_PORTABLE_FONTS_IN_MSW)
-IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject)
-#endif
-
-#include "wx/hash.h"
-IMPLEMENT_DYNAMIC_CLASS(wxHashTable, wxObject)
-
-#include "wx/help.h"
-IMPLEMENT_DYNAMIC_CLASS(wxHelpInstance, wxClient)
-IMPLEMENT_CLASS(wxHelpConnection, wxConnection)
-
-#include "wx/list.h"
-IMPLEMENT_DYNAMIC_CLASS(wxNode, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxList, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxStringList, wxList)
-
-#if USE_PRINTING_ARCHITECTURE
-#include "wx/print.h"
-IMPLEMENT_DYNAMIC_CLASS(wxPrintDialog, wxDialog)
-IMPLEMENT_DYNAMIC_CLASS(wxPrinterBase, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxPostScriptPrinter, wxPrinterBase)
-IMPLEMENT_DYNAMIC_CLASS(wxWindowsPrinter, wxPrinterBase)
-IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
-IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
-IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
-IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
-IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
-IMPLEMENT_CLASS(wxPostScriptPrintPreview, wxPrintPreviewBase)
-IMPLEMENT_CLASS(wxWindowsPrintPreview, wxPrintPreviewBase)
-IMPLEMENT_CLASS(wxGenericPrintDialog, wxDialog)
-IMPLEMENT_CLASS(wxGenericPrintSetupDialog, wxDialog)
-#endif
-
#if USE_POSTSCRIPT
-#include "wx/postscrp.h"
-IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
-IMPLEMENT_DYNAMIC_CLASS(wxPrintSetupData, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxPageSetupData, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperType, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperDatabase, wxList)
-#endif
-
-#if USE_WX_RESOURCES
-#include "wx/resource.h"
-IMPLEMENT_DYNAMIC_CLASS(wxItemResource, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxResourceTable, wxHashTable)
-#endif
-
-#include "wx/event.h"
-IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
-IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxEvent)
-IMPLEMENT_DYNAMIC_CLASS(wxProcessEvent, wxEvent)
-
-#include "wx/utils.h"
-IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxList)
-
-// IMPLEMENT_DYNAMIC_CLASS(wxRect, wxObject)
-
-#include "wx/process.h"
-IMPLEMENT_DYNAMIC_CLASS(wxProcess, wxEvtHandler)
-
-#if USE_TIMEDATE
-#include "wx/date.h"
-IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
-#endif
-
-#if USE_DOC_VIEW_ARCHITECTURE
-#include "wx/docview.h"
-//IMPLEMENT_ABSTRACT_CLASS(wxDocItem, wxObject)
-IMPLEMENT_ABSTRACT_CLASS(wxDocument, wxEvtHandler)
-IMPLEMENT_ABSTRACT_CLASS(wxView, wxEvtHandler)
-IMPLEMENT_ABSTRACT_CLASS(wxDocTemplate, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxDocManager, wxEvtHandler)
-IMPLEMENT_CLASS(wxDocChildFrame, wxFrame)
-IMPLEMENT_CLASS(wxDocParentFrame, wxFrame)
-#if USE_PRINTING_ARCHITECTURE
-IMPLEMENT_DYNAMIC_CLASS(wxDocPrintout, wxPrintout)
-#endif
-IMPLEMENT_CLASS(wxCommand, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxCommandProcessor, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxFileHistory, wxObject)
-#endif
-
-#if USE_CONSTRAINTS
-#include "wx/layout.h"
-IMPLEMENT_DYNAMIC_CLASS(wxIndividualLayoutConstraint, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxLayoutConstraints, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxSizer, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxRowColSizer, wxSizer)
-#endif
-
-#if USE_TOOLBAR
-#include "wx/tbarbase.h"
-IMPLEMENT_DYNAMIC_CLASS(wxToolBarTool, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxToolBarBase, wxControl)
-
-#include "wx/tbarsmpl.h"
-IMPLEMENT_DYNAMIC_CLASS(wxToolBarSimple, wxToolBarBase)
-
-#ifdef wx_msw
-#include "wx/tbarmsw.h"
-IMPLEMENT_DYNAMIC_CLASS(wxToolBarMSW, wxToolBarBase)
-
-#include "wx/tbar95.h"
-IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase)
-#endif
-
-#endif
-
-#include "wx/statusbr.h"
-
-IMPLEMENT_DYNAMIC_CLASS(wxStatusBar, wxWindow)
-
-BEGIN_EVENT_TABLE(wxStatusBar, wxWindow)
- EVT_PAINT(wxStatusBar::OnPaint)
- EVT_SYS_COLOUR_CHANGED(wxStatusBar::OnSysColourChanged)
-END_EVENT_TABLE()
-
-#if USE_TIMEDATE
-#include "wx/time.h"
-IMPLEMENT_DYNAMIC_CLASS(wxTime, wxObject)
-#endif
-
-#if !USE_GNU_WXSTRING
-#include "wx/string.h"
-IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
-#endif
-
-#ifdef wx_motif
-IMPLEMENT_DYNAMIC_CLASS(wxXColormap, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxXFont, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxXCursor, wxObject)
-#endif
-IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
-IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
-IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
-IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject)
-IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
-IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
-IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
-IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
-
-// This will presumably be implemented on other platforms too
-#ifdef wx_msw
-IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
-IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
-IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
-IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
-IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
-IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
-#endif
-
-#include "wx/statbox.h"
-IMPLEMENT_DYNAMIC_CLASS(wxStaticBox, wxControl)
-
-#if USE_IPC
-#include "wx/dde.h"
-IMPLEMENT_ABSTRACT_CLASS(wxDDEObject, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxDDEServer, wxDDEObject)
-IMPLEMENT_DYNAMIC_CLASS(wxDDEClient, wxDDEObject)
-IMPLEMENT_CLASS(wxDDEConnection, wxObject)
-#endif
-
-IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
-
-#include "wx/listbox.h"
-IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
-
-IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
-
-#include "wx/menu.h"
-IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxWindow)
-IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
-
-#include "wx/stattext.h"
-#include "wx/statbmp.h"
-IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl)
-IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
-
-#if USE_METAFILE
-#include "wx/metafile.h"
-IMPLEMENT_DYNAMIC_CLASS(wxMetaFile, wxObject)
-IMPLEMENT_ABSTRACT_CLASS(wxMetaFileDC, wxDC)
-#endif
-
-#include "wx/radiobox.h"
-#include "wx/radiobut.h"
-IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
-
-IMPLEMENT_DYNAMIC_CLASS(wxRadioButton, wxControl)
-// IMPLEMENT_DYNAMIC_CLASS(wxBitmapRadioButton, wxRadioButton)
-
-#include "wx/scrolbar.h"
-IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
-
-#if WXWIN_COMPATIBILITY
-BEGIN_EVENT_TABLE(wxScrollBar, wxControl)
- EVT_SCROLL(wxScrollBar::OnScroll)
-END_EVENT_TABLE()
-#endif
-
-#include "wx/slider.h"
-IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl)
-
-#if WXWIN_COMPATIBILITY
-BEGIN_EVENT_TABLE(wxSlider, wxControl)
- EVT_SCROLL(wxSlider::OnScroll)
-END_EVENT_TABLE()
-#endif
-
-#include "wx/timer.h"
-IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
-
-#include "wx/textctrl.h"
-IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
-
-#include "wx/window.h"
-IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
-
-#include "wx/scrolwin.h"
-IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxWindow)
-
-#include "wx/panel.h"
-IMPLEMENT_DYNAMIC_CLASS(wxPanel, wxWindow)
-
-#include "wx/msgbxdlg.h"
-#include "wx/textdlg.h"
-#include "wx/filedlg.h"
-#include "wx/dirdlg.h"
-#include "wx/choicdlg.h"
-
-#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
-#include "wx/generic/msgdlgg.h"
-IMPLEMENT_CLASS(wxGenericMessageDialog, wxDialog)
-#endif
-
-IMPLEMENT_CLASS(wxTextEntryDialog, wxDialog)
-IMPLEMENT_CLASS(wxSingleChoiceDialog, wxDialog)
-IMPLEMENT_CLASS(wxFileDialog, wxDialog)
-IMPLEMENT_CLASS(wxDirDialog, wxDialog)
-
-#ifdef wx_msw
-IMPLEMENT_CLASS(wxMessageDialog)
-#endif
-
-#if USE_GAUGE
-#ifdef wx_motif
-#include "../../contrib/xmgauge/gauge.h"
-#endif
-#include "wx_gauge.h"
-IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
+wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL;
#endif
-#include "wx/grid.h"
-IMPLEMENT_DYNAMIC_CLASS(wxGenericGrid, wxPanel)
-
///// Event tables (also must be in one, statically-linked file for shared libraries)
// This is the base, wxEvtHandler 'bootstrap' code which is expanded manually here
const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] = { { 0, 0, 0, NULL } };
-BEGIN_EVENT_TABLE(wxFrame, wxWindow)
- EVT_ACTIVATE(wxFrame::OnActivate)
- EVT_SIZE(wxFrame::OnSize)
- EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight)
- EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
- EVT_IDLE(wxFrame::OnIdle)
- EVT_CLOSE(wxFrame::OnCloseWindow)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxDialog, wxPanel)
- EVT_BUTTON(wxID_OK, wxDialog::OnOK)
- EVT_BUTTON(wxID_APPLY, wxDialog::OnApply)
- EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
- EVT_CHAR_HOOK(wxDialog::OnCharHook)
- EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged)
- EVT_CLOSE(wxDialog::OnCloseWindow)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
- EVT_CHAR(wxWindow::OnChar)
- EVT_SIZE(wxWindow::Size)
- EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
- EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
- EVT_INIT_DIALOG(wxWindow::OnInitDialog)
- EVT_IDLE(wxWindow::OnIdle)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxScrolledWindow, wxWindow)
- EVT_SCROLL(wxScrolledWindow::OnScroll)
- EVT_SIZE(wxScrolledWindow::OnSize)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxPanel, wxWindow)
- EVT_SYS_COLOUR_CHANGED(wxPanel::OnSysColourChanged)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
- EVT_CHAR(wxTextCtrl::OnChar)
- EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
- EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
-END_EVENT_TABLE()
-
-#ifdef wx_msw
-BEGIN_EVENT_TABLE(wxMDIParentWindow, wxFrame)
- EVT_SIZE(wxMDIParentWindow::OnSize)
- EVT_ACTIVATE(wxMDIParentWindow::OnActivate)
- EVT_SYS_COLOUR_CHANGED(wxMDIParentWindow::OnSysColourChanged)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
- EVT_SCROLL(wxMDIClientWindow::OnScroll)
-END_EVENT_TABLE()
-#endif
-
-BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
- EVT_SCROLL(wxToolBarBase::OnScroll)
- EVT_SIZE(wxToolBarBase::OnSize)
- EVT_IDLE(wxToolBarBase::OnIdle)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxToolBarSimple, wxToolBarBase)
- EVT_SIZE(wxToolBarSimple::OnSize)
- EVT_PAINT(wxToolBarSimple::OnPaint)
- EVT_KILL_FOCUS(wxToolBarSimple::OnKillFocus)
- EVT_MOUSE_EVENTS(wxToolBarSimple::OnMouseEvent)
-END_EVENT_TABLE()
-
-#ifdef wx_msw
-BEGIN_EVENT_TABLE(wxToolBarMSW, wxToolBarBase)
- EVT_SIZE(wxToolBarMSW::OnSize)
- EVT_PAINT(wxToolBarMSW::OnPaint)
- EVT_MOUSE_EVENTS(wxToolBarMSW::OnMouseEvent)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
- EVT_SIZE(wxToolBar95::OnSize)
- EVT_PAINT(wxToolBar95::OnPaint)
- EVT_KILL_FOCUS(wxToolBar95::OnKillFocus)
- EVT_MOUSE_EVENTS(wxToolBar95::OnMouseEvent)
- EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged)
-END_EVENT_TABLE()
-#endif
-
-BEGIN_EVENT_TABLE(wxGenericGrid, wxPanel)
- EVT_SIZE(wxGenericGrid::OnSize)
- EVT_PAINT(wxGenericGrid::OnPaint)
- EVT_MOUSE_EVENTS(wxGenericGrid::OnMouseEvent)
- EVT_TEXT(wxGRID_TEXT_CTRL, wxGenericGrid::OnText)
- EVT_COMMAND_SCROLL(wxGRID_HSCROLL, wxGenericGrid::OnGridScroll)
- EVT_COMMAND_SCROLL(wxGRID_VSCROLL, wxGenericGrid::OnGridScroll)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxControl, wxWindow)
- EVT_ERASE_BACKGROUND(wxControl::OnEraseBackground)
-END_EVENT_TABLE()
-
-#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
-BEGIN_EVENT_TABLE(wxGenericMessageDialog, wxDialog)
- EVT_BUTTON(wxID_YES, wxGenericMessageDialog::OnYes)
- EVT_BUTTON(wxID_NO, wxGenericMessageDialog::OnNo)
- EVT_BUTTON(wxID_CANCEL, wxGenericMessageDialog::OnCancel)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxGenericColourDialog, wxDialog)
- EVT_BUTTON(wxID_ADD_CUSTOM, wxGenericColourDialog::OnAddCustom)
- EVT_SLIDER(wxID_RED_SLIDER, wxGenericColourDialog::OnRedSlider)
- EVT_SLIDER(wxID_GREEN_SLIDER, wxGenericColourDialog::OnGreenSlider)
- EVT_SLIDER(wxID_BLUE_SLIDER, wxGenericColourDialog::OnBlueSlider)
- EVT_PAINT(wxGenericColourDialog::OnPaint)
- EVT_MOUSE_EVENTS(wxGenericColourDialog::OnMouseEvent)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxGenericFontDialog, wxDialog)
- EVT_CHECKBOX(wxID_FONT_UNDERLINE, wxGenericFontDialog::OnChangeFont)
- EVT_CHOICE(wxID_FONT_STYLE, wxGenericFontDialog::OnChangeFont)
- EVT_CHOICE(wxID_FONT_WEIGHT, wxGenericFontDialog::OnChangeFont)
- EVT_CHOICE(wxID_FONT_FAMILY, wxGenericFontDialog::OnChangeFont)
- EVT_CHOICE(wxID_FONT_COLOUR, wxGenericFontDialog::OnChangeFont)
- EVT_CHOICE(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeFont)
- EVT_PAINT(wxGenericFontDialog::OnPaint)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxGenericPrintDialog, wxDialog)
- EVT_BUTTON(wxID_OK, wxGenericPrintDialog::OnOK)
- EVT_BUTTON(wxPRINTID_SETUP, wxGenericPrintDialog::OnSetup)
- EVT_RADIOBOX(wxPRINTID_RANGE, wxGenericPrintDialog::OnRange)
-END_EVENT_TABLE()
-
-#endif
-
-BEGIN_EVENT_TABLE(wxTextEntryDialog, wxDialog)
- EVT_BUTTON(wxID_OK, wxTextEntryDialog::OnOK)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxSingleChoiceDialog, wxDialog)
- EVT_BUTTON(wxID_OK, wxSingleChoiceDialog::OnOK)
-END_EVENT_TABLE()
-
-#include "wx/prntbase.h"
-
-BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
- EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
-END_EVENT_TABLE()
-
-BEGIN_EVENT_TABLE(wxPreviewControlBar, wxWindow)
- EVT_BUTTON(wxID_PREVIEW_CLOSE, wxPreviewControlBar::OnClose)
- EVT_BUTTON(wxID_PREVIEW_PRINT, wxPreviewControlBar::OnPrint)
- EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPrevious)
- EVT_BUTTON(wxID_PREVIEW_NEXT, wxPreviewControlBar::OnNext)
- EVT_CHOICE(wxID_PREVIEW_ZOOM, wxPreviewControlBar::OnZoom)
-END_EVENT_TABLE()
-
-#endif
-
-
const wxSize wxDefaultSize(-1, -1);
const wxPoint wxDefaultPosition(-1, -1);
/////////////////////////////////////////////////////////////////////////////
// Name: dc.cpp
-// Purpose:
-// Author: Robert Roebling
+// Purpose: wxDC class
+// Author: AUTHOR
+// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "dc.h"
#endif
#include "wx/dc.h"
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
+#endif
+
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
{
};
-void wxDC::DrawArc( long WXUNUSED(x1), long WXUNUSED(y1), long WXUNUSED(x2), long WXUNUSED(y2),
- double WXUNUSED(xc), double WXUNUSED(yc) )
-{
-};
-
-void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y), bool WXUNUSED(useMask) )
+void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y), bool WXUNUSED(useMask) )
{
};
/////////////////////////////////////////////////////////////////////////////
// Name: dcclient.cpp
-// Purpose:
-// Author: Robert Roebling
+// Purpose: wxClientDC class
+// Author: AUTHOR
+// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/dcmemory.h"
#include <math.h>
-//-----------------------------------------------------------------------------
-// local data
-//-----------------------------------------------------------------------------
-
-#include "bdiag.xbm"
-#include "fdiag.xbm"
-#include "cdiag.xbm"
-#include "horiz.xbm"
-#include "verti.xbm"
-#include "cross.xbm"
-#define num_hatches 6
-
-
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
// wxPaintDC
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC,wxDC)
+#if !USE_SHARED_LIBRARY
+//IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
+//IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
+IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC)
+#endif
+
wxPaintDC::wxPaintDC(void)
{
/////////////////////////////////////////////////////////////////////////////
// Name: dcmemory.cpp
-// Purpose:
-// Author: Robert Roebling
+// Purpose: wxMemoryDC class
+// Author: AUTHOR
+// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/dcmemory.h"
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
+#endif
+
//-----------------------------------------------------------------------------
// wxMemoryDC
//-----------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
// Name: dcscreen.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxScreenDC class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#endif
#include "wx/dcscreen.h"
-#include "wx/window.h"
-//-----------------------------------------------------------------------------
-// wxScreenDC
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxScreenDC,wxPaintDC)
-
-wxScreenDC::wxScreenDC(void)
-{
- m_ok = FALSE;
-};
-
-wxScreenDC::~wxScreenDC(void)
-{
- EndDrawingOnTop();
-};
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxPaintDC)
+#endif
-bool wxScreenDC::StartDrawingOnTop( wxWindow *WXUNUSED(window) )
+// Create a DC representing the whole screen
+wxScreenDC::wxScreenDC()
{
- return TRUE;
-};
+ // TODO
+}
-bool wxScreenDC::StartDrawingOnTop( wxRectangle *WXUNUSED(rect) )
+wxScreenDC::~wxScreenDC()
{
- return TRUE;
-};
+ // TODO
+}
-bool wxScreenDC::EndDrawingOnTop(void)
-{
- return TRUE;
-};
/////////////////////////////////////////////////////////////////////////////
// Name: dialog.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxDialog class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#endif
#include "wx/dialog.h"
+#include "wx/utils.h"
#include "wx/frame.h"
#include "wx/app.h"
+#include "wx/settings.h"
-//-----------------------------------------------------------------------------
-
+// Lists to keep track of windows, so we can disable/enable them
+// for modal dialogs
+wxList wxModalDialogs;
+wxList wxModelessWindows; // Frames and modeless dialogs
extern wxList wxPendingDelete;
-//-----------------------------------------------------------------------------
-// wxDialog
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxPanel)
-BEGIN_EVENT_TABLE(wxDialog,wxWindow)
- EVT_BUTTON (wxID_OK, wxDialog::OnOk)
- EVT_BUTTON (wxID_CANCEL, wxDialog::OnCancel)
- EVT_BUTTON (wxID_APPLY, wxDialog::OnApply)
- EVT_CLOSE (wxDialog::OnCloseWindow)
+BEGIN_EVENT_TABLE(wxDialog, wxPanel)
+ EVT_BUTTON(wxID_OK, wxDialog::OnOK)
+ EVT_BUTTON(wxID_APPLY, wxDialog::OnApply)
+ EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
+ EVT_CHAR_HOOK(wxDialog::OnCharHook)
+ EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged)
+ EVT_CLOSE(wxDialog::OnCloseWindow)
END_EVENT_TABLE()
-IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxWindow)
+#endif
-wxDialog::wxDialog(void)
+wxDialog::wxDialog()
{
- m_title = "";
- m_modalShowing = FALSE;
- wxTopLevelWindows.Insert( this );
-};
+ SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
+}
-wxDialog::wxDialog( wxWindow *parent,
- wxWindowID id, const wxString &title,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+bool wxDialog::Create(wxWindow *parent, wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
- m_modalShowing = FALSE;
- wxTopLevelWindows.Insert( this );
- Create( parent, id, title, pos, size, style, name );
-};
+ m_windowStyle = style;
-bool wxDialog::Create( wxWindow *parent,
- wxWindowID id, const wxString &title,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+ SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
+ SetName(name);
+
+ if (!parent)
+ wxTopLevelWindows.Append(this);
+
+ if (parent) parent->AddChild(this);
+
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
+
+ // TODO: create dialog
+
+ return FALSE;
+}
+
+void wxDialog::SetModal(bool flag)
{
- return TRUE;
-};
+ if ( flag )
+ m_windowStyle |= wxDIALOG_MODAL ;
+ else
+ if ( m_windowStyle & wxDIALOG_MODAL )
+ m_windowStyle -= wxDIALOG_MODAL ;
+
+ wxModelessWindows.DeleteObject(this);
+ if (!flag)
+ wxModelessWindows.Append(this);
+}
-wxDialog::~wxDialog(void)
+wxDialog::~wxDialog()
{
- wxTopLevelWindows.DeleteObject( this );
- if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
-};
+ // TODO
+ wxTopLevelWindows.DeleteObject(this);
+
+ if ( (GetWindowStyleFlag() & wxDIALOG_MODAL) != wxDIALOG_MODAL )
+ wxModelessWindows.DeleteObject(this);
+
+ // If this is the last top-level window, exit.
+ if (wxTheApp && (wxTopLevelWindows.Number() == 0))
+ {
+ wxTheApp->SetTopWindow(NULL);
+
+ if (wxTheApp->GetExitOnFrameDelete())
+ {
+ // TODO: exit
+ }
+ }
+}
-void wxDialog::SetTitle(const wxString& title )
+// By default, pressing escape cancels the dialog
+void wxDialog::OnCharHook(wxKeyEvent& event)
{
- m_title = title;
-};
+ if (GetHWND())
+ {
+ if (event.m_keyCode == WXK_ESCAPE)
+ {
+ // Behaviour changed in 2.0: we'll send a Cancel message
+ // to the dialog instead of Close.
+ wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
+ cancelEvent.SetEventObject( this );
+ GetEventHandler()->ProcessEvent(cancelEvent);
-wxString wxDialog::GetTitle(void) const
+ return;
+ }
+ }
+ // We didn't process this event.
+ event.Skip();
+}
+
+void wxDialog::Iconize(bool WXUNUSED(iconize))
{
- return (wxString&)m_title;
-};
+ // TODO
+}
-void wxDialog::OnApply( wxCommandEvent &WXUNUSED(event) )
+bool wxDialog::IsIconized() const
{
- if (Validate()) TransferDataFromWindow();
-};
+ // TODO
+ return FALSE;
+}
-void wxDialog::OnCancel( wxCommandEvent &WXUNUSED(event) )
+void wxDialog::SetClientSize(int width, int height)
{
- if (IsModal())
- {
- EndModal(wxID_CANCEL);
- }
- else
- {
- SetReturnCode(wxID_CANCEL);
- this->Show(FALSE);
- };
-};
+ // TODO
+}
+
+void wxDialog::GetPosition(int *x, int *y) const
+{
+ // TODO
+}
-void wxDialog::OnOk( wxCommandEvent &WXUNUSED(event) )
+bool wxDialog::Show(bool show)
{
- if ( Validate() && TransferDataFromWindow())
+ // TODO
+ return FALSE;
+}
+
+void wxDialog::SetTitle(const wxString& title)
+{
+ // TODO
+}
+
+wxString wxDialog::GetTitle() const
+{
+ // TODO
+ return wxString("");
+}
+
+void wxDialog::Centre(int direction)
+{
+ int x_offset,y_offset ;
+ int display_width, display_height;
+ int width, height, x, y;
+ wxFrame *frame ;
+ if (direction & wxCENTER_FRAME)
{
- if (IsModal())
+ frame = (wxFrame*)GetParent() ;
+ if (frame)
{
- EndModal(wxID_OK);
+ frame->GetPosition(&x_offset,&y_offset) ;
+ frame->GetSize(&display_width,&display_height) ;
}
- else
- {
- SetReturnCode(wxID_OK);
- this->Show(FALSE);
- };
- };
-};
+ }
+ else
+ frame = NULL ;
-void wxDialog::OnPaint( wxPaintEvent& WXUNUSED(event) )
-{
- // yes
-};
+ if (frame==NULL)
+ {
+ wxDisplaySize(&display_width, &display_height);
+ x_offset = 0 ;
+ y_offset = 0 ;
+ }
-bool wxDialog::OnClose(void)
-{
- static wxList closing;
+ GetSize(&width, &height);
+ GetPosition(&x, &y);
- if (closing.Member(this)) return FALSE; // no loops
-
- closing.Append(this);
+ if (direction & wxHORIZONTAL)
+ x = (int)((display_width - width)/2);
+ if (direction & wxVERTICAL)
+ y = (int)((display_height - height)/2);
- wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
- cancelEvent.SetEventObject( this );
- GetEventHandler()->ProcessEvent(cancelEvent);
- closing.DeleteObject(this);
-
- return FALSE;
+ SetSize(x+x_offset, y+y_offset, width, height);
}
-bool wxDialog::Destroy(void)
+// Replacement for Show(TRUE) for modal dialogs - returns return code
+int wxDialog::ShowModal()
{
- if (!wxPendingDelete.Member(this))
- wxPendingDelete.Append(this);
+ m_windowStyle |= wxDIALOG_MODAL;
+ // TODO: modal showing
+ Show(TRUE);
+ return GetReturnCode();
+}
- return TRUE;
+void wxDialog::EndModal(int retCode)
+{
+ SetReturnCode(retCode);
+ // TODO modal un-showing
+ Show(FALSE);
}
-void wxDialog::OnCloseWindow(wxCloseEvent& event)
+// Standard buttons
+void wxDialog::OnOK(wxCommandEvent& event)
{
- if (GetEventHandler()->OnClose() || event.GetForce())
- {
- this->Destroy();
- };
-};
+ if ( Validate() && TransferDataFromWindow() )
+ {
+ if ( IsModal() )
+ EndModal(wxID_OK);
+ else
+ {
+ SetReturnCode(wxID_OK);
+ this->Show(FALSE);
+ }
+ }
+}
-bool wxDialog::Show( bool show )
+void wxDialog::OnApply(wxCommandEvent& event)
{
- if (!show && IsModal() && m_modalShowing)
- {
- EndModal( wxID_CANCEL );
- };
+ if (Validate())
+ TransferDataFromWindow();
+ // TODO probably need to disable the Apply button until things change again
+}
- wxWindow::Show( show );
-
- if (show) InitDialog();
-
- return TRUE;
-};
+void wxDialog::OnCancel(wxCommandEvent& event)
+{
+ if ( IsModal() )
+ EndModal(wxID_CANCEL);
+ else
+ {
+ SetReturnCode(wxID_CANCEL);
+ this->Show(FALSE);
+ }
+}
-int wxDialog::ShowModal(void)
+bool wxDialog::OnClose()
{
- if (m_modalShowing) return GetReturnCode();
+ // Behaviour changed in 2.0: we'll send a Cancel message by default,
+ // which may close the dialog.
+ // Check for looping if the Cancel event handler calls Close()
- Show( TRUE );
-
- m_modalShowing = TRUE;
-
- // grab here
- // main here
- // release here
-
- return GetReturnCode();
-};
+ static wxList closing;
+
+ if ( closing.Member(this) )
+ return FALSE;
+
+ closing.Append(this);
+
+ wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
+ cancelEvent.SetEventObject( this );
+ GetEventHandler()->ProcessEvent(cancelEvent);
+
+ closing.DeleteObject(this);
+
+ return FALSE;
+}
+
+void wxDialog::OnCloseWindow(wxCloseEvent& event)
+{
+ // Compatibility
+ if ( GetEventHandler()->OnClose() || event.GetForce())
+ {
+ this->Destroy();
+ }
+}
-void wxDialog::EndModal( int retCode )
+// Destroy the window (delayed, if a managed window)
+bool wxDialog::Destroy()
{
- SetReturnCode( retCode );
-
- if (!m_modalShowing) return;
- m_modalShowing = FALSE;
-
- // quit main
-};
+ if (!wxPendingDelete.Member(this))
+ wxPendingDelete.Append(this);
+ return TRUE;
+}
-void wxDialog::InitDialog(void)
+void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& event)
{
- wxWindow::InitDialog();
-};
+ SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
+ Refresh();
+}
///////////////////////////////////////////////////////////////////////////////
// Name: dnd.cpp
-// Purpose: wxDropTarget class
-// Author: Robert Roebling
-// Copyright: Robert Roebling
-// Licence: wxWindows license
+// Purpose: wxDropTarget, wxDropSource, wxDataObject implementation
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) 1998 AUTHOR
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
// global
// ----------------------------------------------------------------------------
-extern bool g_blockEventsOnDrag;
-
// ----------------------------------------------------------------------------
// wxDropTarget
// ----------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
-wxDropSource::wxDropSource( wxWindow *WXUNUSED(win) )
+//-----------------------------------------------------------------------------
+// drag request
+
+wxDropSource::wxDropSource( wxWindow *win )
{
- g_blockEventsOnDrag = TRUE;
+ // TODO
+ m_window = win;
+ m_data = NULL;
+
+ m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
+ m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
-wxDropSource::wxDropSource( wxDataObject &data, wxWindow *WXUNUSED(win) )
+wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
{
- g_blockEventsOnDrag = TRUE;
-
- m_data = &data;
+ // TODO
+ m_window = win;
+ m_data = &data;
+
+ m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
+ m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
void wxDropSource::SetData( wxDataObject &data )
{
- m_data = &data;
+ m_data = &data;
};
wxDropSource::~wxDropSource(void)
{
-// if (m_data) delete m_data;
-
- g_blockEventsOnDrag = FALSE;
};
wxDropSource::DragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
{
- return Copy;
+ // TODO
+ return Error;
};
/////////////////////////////////////////////////////////////////////////////
// Name: filedlg.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxFileDialog
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "filedlg.h"
#endif
-#include "wx/filedlg.h"
+#include "wx/defs.h"
#include "wx/utils.h"
-#include "wx/intl.h"
-#include "wx/generic/msgdlgg.h"
-
-//-----------------------------------------------------------------------------
-// wxFileDialog
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxFileDialog,wxDialog)
-
-wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
- const wxString& defaultDir, const wxString& defaultFileName,
- const wxString& wildCard,
- long style, const wxPoint& pos )
-{
- m_message = message;
- m_path = "";
- m_fileName = defaultFileName;
- m_dir = defaultDir;
- m_wildCard = wildCard;
- m_dialogStyle = style;
- m_filterIndex = 1;
-
- m_path.Append(m_dir);
- if(! m_path.IsEmpty() && m_path.Last()!='/') m_path.Append('/');
- m_path.Append(m_fileName);
-
-};
-
-int wxFileDialog::ShowModal(void)
-{
- int ret = wxDialog::ShowModal();
+#include "wx/dialog.h"
+#include "wx/filedlg.h"
- if (ret == wxID_OK)
- {
- };
- return ret;
-};
-
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_CLASS(wxFileDialog, wxDialog)
+#endif
char *wxFileSelector(const char *title,
const char *defaultDir, const char *defaultFileName,
const char *defaultExtension, const char *filter, int flags,
wxWindow *parent, int x, int y)
{
- wxString filter2("");
- if ( defaultExtension && !filter )
- filter2 = wxString("*.") + wxString(defaultExtension) ;
- else if ( filter )
- filter2 = filter;
-
- wxString defaultDirString;
- if (defaultDir)
- defaultDirString = defaultDir;
- else
- defaultDirString = "";
-
- wxString defaultFilenameString;
- if (defaultFileName)
- defaultFilenameString = defaultFileName;
- else
- defaultFilenameString = "";
-
- wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString,
- filter2, flags, wxPoint(x, y));
-
- if ( fileDialog.ShowModal() == wxID_OK )
- {
- strcpy(wxBuffer, (const char *)fileDialog.GetPath());
- return wxBuffer;
- }
- else
- return NULL;
-};
-
-char* wxLoadFileSelector(const char *what, const char *extension, const char *default_name,
- wxWindow *parent )
-{
- char *ext = (char *)extension;
-
- char prompt[50];
- wxString str = _("Load %s file");
- sprintf(prompt, str, what);
+ // If there's a default extension specified but no filter, we create a suitable
+ // filter.
+
+ wxString filter2("");
+ if ( defaultExtension && !filter )
+ filter2 = wxString("*.") + wxString(defaultExtension) ;
+ else if ( filter )
+ filter2 = filter;
+
+ wxString defaultDirString;
+ if (defaultDir)
+ defaultDirString = defaultDir;
+ else
+ defaultDirString = "";
+
+ wxString defaultFilenameString;
+ if (defaultFileName)
+ defaultFilenameString = defaultFileName;
+ else
+ defaultFilenameString = "";
+
+ wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString, filter2, flags, wxPoint(x, y));
+
+ if ( fileDialog.ShowModal() == wxID_OK )
+ {
+ strcpy(wxBuffer, (const char *)fileDialog.GetPath());
+ return wxBuffer;
+ }
+ else
+ return NULL;
+}
+
+char *wxFileSelectorEx(const char *title,
+ const char *defaultDir,
+ const char *defaultFileName,
+ int* defaultFilterIndex,
+ const char *filter,
+ int flags,
+ wxWindow* parent,
+ int x,
+ int y)
- if (*ext == '.') ext++;
- char wild[60];
- sprintf(wild, "*.%s", ext);
+{
+ wxFileDialog fileDialog(parent, title ? title : "", defaultDir ? defaultDir : "",
+ defaultFileName ? defaultFileName : "", filter ? filter : "", flags, wxPoint(x, y));
+
+ if ( fileDialog.ShowModal() == wxID_OK )
+ {
+ *defaultFilterIndex = fileDialog.GetFilterIndex();
+ strcpy(wxBuffer, (const char *)fileDialog.GetPath());
+ return wxBuffer;
+ }
+ else
+ return NULL;
+}
- return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
-};
+wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
+ const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
+ long style, const wxPoint& pos)
+{
+ m_message = message;
+ m_dialogStyle = style;
+ m_parent = parent;
+ m_path = "";
+ m_fileName = defaultFileName;
+ m_dir = defaultDir;
+ m_wildCard = wildCard;
+ m_filterIndex = 1;
+}
+
+int wxFileDialog::ShowModal()
+{
+ // TODO
+ wxID_CANCEL;
+}
-char* wxSaveFileSelector(const char *what, const char *extension, const char *default_name,
- wxWindow *parent )
+// Generic file load/save dialog
+static char *
+wxDefaultFileSelector(bool load, const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
char *ext = (char *)extension;
char prompt[50];
- wxString str = _("Save %s file");
- sprintf(prompt, str, what);
+ wxString str;
+ if (load)
+ str = "Load %s file";
+ else
+ str = "Save %s file";
+ sprintf(prompt, wxGetTranslation(str), what);
if (*ext == '.') ext++;
char wild[60];
sprintf(wild, "*.%s", ext);
return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
-};
+}
+
+// Generic file load dialog
+char *
+wxLoadFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
+{
+ return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
+}
+// Generic file save dialog
+char *
+wxSaveFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
+{
+ return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
+}
/////////////////////////////////////////////////////////////////////////////
// Name: font.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxFont class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#endif
#include "wx/font.h"
-#include "wx/utils.h"
-#include <strings.h>
-
-//-----------------------------------------------------------------------------
-// local data
-//-----------------------------------------------------------------------------
-
-static char *wx_font_family [] = {
- "wxDEFAULT", "wxDECORATIVE", "wxMODERN", "wxROMAN", "wxSCRIPT",
- "wxSWISS", "wxTELETYPE",
-};
-static char *wx_font_style [] = {
- "wxDEFAULT", "wxNORMAL", "wxSLANT", "wxITALIC",
-};
-static char *wx_font_weight [] = {
- "wxDEFAULT", "wxNORMAL", "wxBOLD", "wxLIGHT",
-};
-
-extern wxFontNameDirectory wxTheFontNameDirectory;
-
-//-----------------------------------------------------------------------------
-// wxFont
-//-----------------------------------------------------------------------------
-
-class wxFontRefData: public wxObjectRefData
-{
- public:
-
- wxFontRefData(void);
- ~wxFontRefData(void);
-
- wxList m_scaled_xfonts;
- int m_pointSize;
- int m_family, m_style, m_weight;
- bool m_underlined;
- int m_fontId;
- char* m_faceName;
-
-};
-
-wxFontRefData::wxFontRefData(void) : m_scaled_xfonts(wxKEY_INTEGER)
-{
- m_pointSize = -1;
- m_family = -1;
- m_style = -1;
- m_weight = -1;
- m_underlined = FALSE;
- m_fontId = 0;
- m_faceName = NULL;
-};
-
-wxFontRefData::~wxFontRefData(void)
-{
- wxNode *node = m_scaled_xfonts.First();
- while (node)
- {
- wxNode *next = node->Next();
- node = next;
- };
- if (m_faceName)
- {
- delete m_faceName;
- m_faceName = NULL;
- };
-};
-
-//-----------------------------------------------------------------------------
-
-#define M_FONTDATA ((wxFontRefData *)m_refData)
+#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
+#endif
-wxFont::wxFont(void)
+wxFontRefData::wxFontRefData()
{
- if (wxTheFontList) wxTheFontList->Append( this );
-};
+ m_style = 0;
+ m_pointSize = 0;
+ m_family = 0;
+ m_style = 0;
+ m_weight = 0;
+ m_underlined = 0;
+ m_faceName = "";
+/* TODO
+ m_hFont = 0;
+*/
+}
-wxFont::wxFont( char *xFontName )
+wxFontRefData::wxFontRefData(const wxFontRefData& data)
{
- if (!xFontName) return;
-
- m_refData = new wxFontRefData();
-
-};
+ m_style = data.m_style;
+ m_pointSize = data.m_pointSize;
+ m_family = data.m_family;
+ m_style = data.m_style;
+ m_weight = data.m_weight;
+ m_underlined = data.m_underlined;
+ m_faceName = data.m_faceName;
+/* TODO
+ m_hFont = 0;
+*/
+}
-wxFont::wxFont(int PointSize, int FontIdOrFamily, int Style, int Weight,
- bool Underlined, const char* Face)
+wxFontRefData::~wxFontRefData()
{
- m_refData = new wxFontRefData();
-
-
- if (wxTheFontList) wxTheFontList->Append( this );
-};
+ // TODO: delete font data
+}
-wxFont::wxFont(int PointSize, const char *Face, int Family, int Style,
- int Weight, bool Underlined)
+wxFont::wxFont()
{
- m_refData = new wxFontRefData();
+ if ( wxTheFontList )
+ wxTheFontList->Append(this);
+}
+wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
+{
+ Create(pointSize, family, style, weight, underlined, faceName);
- if (wxTheFontList) wxTheFontList->Append( this );
-};
-
-wxFont::wxFont( const wxFont& font )
-{
- Ref( font );
-};
-
-wxFont::wxFont( const wxFont* font )
-{
- UnRef();
- if (font) Ref( *font );
-};
+ if ( wxTheFontList )
+ wxTheFontList->Append(this);
+}
-wxFont::~wxFont(void)
+bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
{
- if (wxTheFontList) wxTheFontList->DeleteObject( this );
-};
+ UnRef();
+ m_refData = new wxFontRefData;
-wxFont& wxFont::operator = ( const wxFont& font )
-{
- if (*this == font) return (*this);
- Ref( font );
- return *this;
-};
+ M_FONTDATA->m_family = family;
+ M_FONTDATA->m_style = style;
+ M_FONTDATA->m_weight = weight;
+ M_FONTDATA->m_pointSize = pointSize;
+ M_FONTDATA->m_underlined = underlined;
+ M_FONTDATA->m_faceName = faceName;
-bool wxFont::operator == ( const wxFont& font )
-{
- return m_refData == font.m_refData;
-};
+ RealizeResource();
-bool wxFont::operator != ( const wxFont& font )
-{
- return m_refData != font.m_refData;
-};
+ return TRUE;
+}
-bool wxFont::Ok()
+wxFont::~wxFont()
{
- return (m_refData != NULL);
-};
+ if (wxTheFontList)
+ wxTheFontList->DeleteObject(this);
+}
-int wxFont::GetPointSize(void) const
+bool wxFont::RealizeResource()
{
- return M_FONTDATA->m_pointSize;
-};
+ // TODO: create the font (if there is a native font object)
+ return FALSE;
+}
-wxString wxFont::GetFaceString(void) const
+void wxFont::Unshare()
{
- return "";
-};
+ // Don't change shared data
+ if (!m_refData)
+ {
+ m_refData = new wxFontRefData();
+ }
+ else
+ {
+ wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
+ UnRef();
+ m_refData = ref;
+ }
+}
-wxString wxFont::GetFaceName(void) const
+void wxFont::SetPointSize(int pointSize)
{
- return "";
-};
+ Unshare();
-int wxFont::GetFamily(void) const
-{
- return M_FONTDATA->m_family;
-};
+ M_FONTDATA->m_pointSize = pointSize;
-wxString wxFont::GetFamilyString(void) const
-{
- wxString s = wx_font_family[M_FONTDATA->m_family];
- return s;
-};
+ RealizeResource();
+}
-int wxFont::GetFontId(void) const
+void wxFont::SetFamily(int family)
{
- return M_FONTDATA->m_fontId; // stub
-};
+ Unshare();
+
+ M_FONTDATA->m_family = family;
-int wxFont::GetStyle(void) const
+ RealizeResource();
+}
+
+void wxFont::SetStyle(int style)
{
- return M_FONTDATA->m_style;
-};
+ Unshare();
+
+ M_FONTDATA->m_style = style;
+
+ RealizeResource();
+}
-wxString wxFont::GetStyleString(void) const
+void wxFont::SetWeight(int weight)
{
- wxString s = wx_font_style[M_FONTDATA->m_style];
- return s;
-};
+ Unshare();
-int wxFont::GetWeight(void) const
+ M_FONTDATA->m_weight = weight;
+
+ RealizeResource();
+}
+
+void wxFont::SetFaceName(const wxString& faceName)
{
- return M_FONTDATA->m_weight;
-};
+ Unshare();
+
+ M_FONTDATA->m_faceName = faceName;
-wxString wxFont::GetWeightString(void) const
+ RealizeResource();
+}
+
+void wxFont::SetUnderlined(bool underlined)
{
- wxString s = wx_font_weight[M_FONTDATA->m_weight];
- return s;
-};
+ Unshare();
+
+ M_FONTDATA->m_underlined = underlined;
+
+ RealizeResource();
+}
-bool wxFont::GetUnderlined(void) const
+wxString wxFont::GetFamilyString() const
{
- return M_FONTDATA->m_underlined;
-};
+ wxString fam("");
+ switch (GetFamily())
+ {
+ case wxDECORATIVE:
+ fam = "wxDECORATIVE";
+ break;
+ case wxROMAN:
+ fam = "wxROMAN";
+ break;
+ case wxSCRIPT:
+ fam = "wxSCRIPT";
+ break;
+ case wxSWISS:
+ fam = "wxSWISS";
+ break;
+ case wxMODERN:
+ fam = "wxMODERN";
+ break;
+ case wxTELETYPE:
+ fam = "wxTELETYPE";
+ break;
+ default:
+ fam = "wxDEFAULT";
+ break;
+ }
+ return fam;
+}
+
+/* New font system */
+wxString wxFont::GetFaceName() const
+{
+ wxString str("");
+ if (M_FONTDATA)
+ str = M_FONTDATA->m_faceName ;
+ return str;
+}
+
+wxString wxFont::GetStyleString() const
+{
+ wxString styl("");
+ switch (GetStyle())
+ {
+ case wxITALIC:
+ styl = "wxITALIC";
+ break;
+ case wxSLANT:
+ styl = "wxSLANT";
+ break;
+ default:
+ styl = "wxNORMAL";
+ break;
+ }
+ return styl;
+}
+
+wxString wxFont::GetWeightString() const
+{
+ wxString w("");
+ switch (GetWeight())
+ {
+ case wxBOLD:
+ w = "wxBOLD";
+ break;
+ case wxLIGHT:
+ w = "wxLIGHT";
+ break;
+ default:
+ w = "wxNORMAL";
+ break;
+ }
+ return w;
+}
+
/////////////////////////////////////////////////////////////////////////////
// Name: frame.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxFrame
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#endif
#include "wx/frame.h"
-#include "wx/dialog.h"
-#include "wx/control.h"
-#include "wx/app.h"
-#include "wx/menu.h"
-#include "wx/toolbar.h"
#include "wx/statusbr.h"
-#include "wx/mdi.h"
-
-const wxMENU_HEIGHT = 28;
-const wxSTATUS_HEIGHT = 25;
+#include "wx/toolbar.h"
+#include "wx/menuitem.h"
-extern wxList wxTopLevelWindows;
+extern wxList wxModelessWindows;
extern wxList wxPendingDelete;
-//-----------------------------------------------------------------------------
-// wxFrame
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-
+#if !USE_SHARED_LIBRARY
BEGIN_EVENT_TABLE(wxFrame, wxWindow)
EVT_SIZE(wxFrame::OnSize)
- EVT_CLOSE(wxFrame::OnCloseWindow)
+ EVT_ACTIVATE(wxFrame::OnActivate)
+ EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight)
+ EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
EVT_IDLE(wxFrame::OnIdle)
+ EVT_CLOSE(wxFrame::OnCloseWindow)
END_EVENT_TABLE()
-IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
+IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
+#endif
+
+#if USE_NATIVE_STATUSBAR
+bool wxFrame::m_useNativeStatusBar = TRUE;
+#else
+bool wxFrame::m_useNativeStatusBar = FALSE;
+#endif
wxFrame::wxFrame()
{
- wxTopLevelWindows.Insert( this );
-};
+ m_frameToolBar = NULL ;
+ m_frameMenuBar = NULL;
+ m_frameStatusBar = NULL;
-wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
-{
- Create( parent, id, title, pos, size, style, name );
- wxTopLevelWindows.Insert( this );
-};
+ m_windowParent = NULL;
+ m_iconized = FALSE;
+}
-bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+bool wxFrame::Create(wxWindow *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
- m_title = title;
+ if (!parent)
+ wxTopLevelWindows.Append(this);
- return TRUE;
-};
+ SetName(name);
+ m_windowStyle = style;
+ m_frameMenuBar = NULL;
+ m_frameToolBar = NULL ;
+ m_frameStatusBar = NULL;
+
+ SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
+
+ if ( id > -1 )
+ m_windowId = id;
+ else
+ m_windowId = (int)NewControlId();
+
+ if (parent) parent->AddChild(this);
+
+ wxModelessWindows.Append(this);
+
+ // TODO: create frame.
+
+ return FALSE;
+}
wxFrame::~wxFrame()
{
- if (m_frameMenuBar) delete m_frameMenuBar;
- if (m_frameStatusBar) delete m_frameStatusBar;
+ wxTopLevelWindows.DeleteObject(this);
+
+ if (m_frameStatusBar)
+ delete m_frameStatusBar;
+ if (m_frameMenuBar)
+ delete m_frameMenuBar;
+
+/* Check if it's the last top-level window */
+
+ if (wxTheApp && (wxTopLevelWindows.Number() == 0))
+ {
+ wxTheApp->SetTopWindow(NULL);
+
+ if (wxTheApp->GetExitOnFrameDelete())
+ {
+ // TODO signal to the app that we're going to close
+ }
+ }
+
+ wxModelessWindows.DeleteObject(this);
+}
+
+// Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
+void wxFrame::GetClientSize(int *x, int *y) const
+{
+ // TODO
+}
- wxTopLevelWindows.DeleteObject( this );
- if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
-};
+// Set the client size (i.e. leave the calculation of borders etc.
+// to wxWindows)
+void wxFrame::SetClientSize(int width, int height)
+{
+ // TODO
+}
+
+void wxFrame::GetSize(int *width, int *height) const
+{
+ // TODO
+}
+
+void wxFrame::GetPosition(int *x, int *y) const
+{
+ // TODO
+}
+
+void wxFrame::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+ // TODO
+}
-bool wxFrame::Show( bool show )
+bool wxFrame::Show(bool show)
{
- if (show)
+ // TODO
+ return FALSE;
+}
+
+void wxFrame::Iconize(bool iconize)
+{
+ // TODO
+}
+
+// Equivalent to maximize/restore in Windows
+void wxFrame::Maximize(bool maximize)
+{
+ // TODO
+}
+
+bool wxFrame::IsIconized() const
+{
+ // TODO
+ return FALSE;
+}
+
+void wxFrame::SetTitle(const wxString& title)
+{
+ // TODO
+}
+
+wxString wxFrame::GetTitle() const
+{
+ // TODO
+ return wxString("");
+}
+
+void wxFrame::SetIcon(const wxIcon& icon)
+{
+ m_icon = icon;
+ // TODO
+}
+
+void wxFrame::SetAcceleratorTable(const wxAcceleratorTable& accel)
+{
+ m_acceleratorTable = accel;
+}
+
+wxStatusBar *wxFrame::OnCreateStatusBar(int number, long style, wxWindowID id,
+ const wxString& name)
+{
+ wxStatusBar *statusBar = NULL;
+
+ statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20),
+ style, name);
+
+ // Set the height according to the font and the border size
+ wxClientDC dc(statusBar);
+ dc.SetFont(* statusBar->GetFont());
+
+ long x, y;
+ dc.GetTextExtent("X", &x, &y);
+
+ int height = (int)( (y * 1.1) + 2* statusBar->GetBorderY());
+
+ statusBar->SetSize(-1, -1, 100, height);
+
+ statusBar->SetFieldsCount(number);
+ return statusBar;
+}
+
+wxStatusBar* wxFrame::CreateStatusBar(int number, long style, wxWindowID id,
+ const wxString& name)
+{
+ // Calling CreateStatusBar twice is an error.
+ wxCHECK_MSG( m_frameStatusBar == NULL, FALSE,
+ "recreating status bar in wxFrame" );
+
+ m_frameStatusBar = OnCreateStatusBar(number, style, id,
+ name);
+ if ( m_frameStatusBar )
{
- wxSizeEvent event( wxSize(m_width,m_height), GetId() );
- ProcessEvent( event );
- };
- return wxWindow::Show( show );
-};
+ PositionStatusBar();
+ return m_frameStatusBar;
+ }
+ else
+ return NULL;
+}
-void wxFrame::Enable( bool enable )
+void wxFrame::SetStatusText(const wxString& text, int number)
{
- wxWindow::Enable( enable );
-};
+ wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set text for" );
-void wxFrame::OnCloseWindow( wxCloseEvent &event )
+ m_frameStatusBar->SetStatusText(text, number);
+}
+
+void wxFrame::SetStatusWidths(int n, const int widths_field[])
{
- if ( GetEventHandler()->OnClose() || event.GetForce())
+ wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set widths for" );
+
+ m_frameStatusBar->SetStatusWidths(n, widths_field);
+ PositionStatusBar();
+}
+
+void wxFrame::PositionStatusBar()
+{
+ int w, h;
+ GetClientSize(&w, &h);
+ int sw, sh;
+ m_frameStatusBar->GetSize(&sw, &sh);
+
+ // Since we wish the status bar to be directly under the client area,
+ // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
+ m_frameStatusBar->SetSize(0, h, w, sh);
+}
+
+void wxFrame::SetMenuBar(wxMenuBar *menuBar)
+{
+ if (!menuBar)
{
- this->Destroy();
+ m_frameMenuBar = NULL;
+ return;
}
-};
+
+ m_frameMenuBar = menuBar;
-bool wxFrame::Destroy()
+ // TODO
+}
+
+void wxFrame::Fit()
{
- if (!wxPendingDelete.Member(this))
- wxPendingDelete.Append(this);
+ // Work out max. size
+ wxNode *node = GetChildren()->First();
+ int max_width = 0;
+ int max_height = 0;
+ while (node)
+ {
+ // Find a child that's a subwindow, but not a dialog box.
+ wxWindow *win = (wxWindow *)node->Data();
- return TRUE;
+ if (!win->IsKindOf(CLASSINFO(wxFrame)) &&
+ !win->IsKindOf(CLASSINFO(wxDialog)))
+ {
+ int width, height;
+ int x, y;
+ win->GetSize(&width, &height);
+ win->GetPosition(&x, &y);
+
+ if ((x + width) > max_width)
+ max_width = x + width;
+ if ((y + height) > max_height)
+ max_height = y + height;
+ }
+ node = node->Next();
+ }
+ SetClientSize(max_width, max_height);
}
-void wxFrame::GetClientSize( int *width, int *height ) const
+// Responds to colour changes, and passes event on to children.
+void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
{
- wxWindow::GetClientSize( width, height );
- if (height)
- {
- if (m_frameMenuBar) (*height) -= wxMENU_HEIGHT;
- if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
- if (m_frameToolBar)
+ SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
+ Refresh();
+
+ if ( m_frameStatusBar )
{
- int y = 0;
- m_frameToolBar->GetSize( NULL, &y );
- (*height) -= y;
+ wxSysColourChangedEvent event2;
+ event2.SetEventObject( m_frameStatusBar );
+ m_frameStatusBar->ProcessEvent(event2);
}
- };
-};
+ // Propagate the event to the non-top-level children
+ wxWindow::OnSysColourChanged(event);
+}
-void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
+// Default resizing behaviour - if only ONE subwindow,
+// resize to client rectangle size
+void wxFrame::OnSize(wxSizeEvent& event)
{
- if ( GetAutoLayout() )
- Layout();
- else {
- // no child: go out !
- if (!GetChildren()->First())
+ // if we're using constraints - do use them
+ #if USE_CONSTRAINTS
+ if ( GetAutoLayout() ) {
+ Layout();
return;
-
- // do we have exactly one child?
- wxWindow *child = NULL;
- for(wxNode *node = GetChildren()->First(); node; node = node->Next())
+ }
+ #endif
+
+ // do we have _exactly_ one child?
+ wxWindow *child = NULL;
+ for ( wxNode *node = GetChildren()->First(); node; node = node->Next() )
+ {
+ wxWindow *win = (wxWindow *)node->Data();
+ if ( !win->IsKindOf(CLASSINFO(wxFrame)) &&
+ !win->IsKindOf(CLASSINFO(wxDialog)) &&
+ (win != GetStatusBar()) &&
+ (win != GetToolBar()) )
{
- wxWindow *win = (wxWindow *)node->Data();
- if (!IS_KIND_OF(win,wxFrame) && !IS_KIND_OF(win,wxDialog)
-#if 0 // not in m_children anyway
- && (win != m_frameMenuBar) &&
- (win != m_frameToolBar) &&
- (win != m_frameStatusBar)
-#endif
- )
- {
- if ( child ) // it's the second one: do nothing
- return;
+ if ( child )
+ return; // it's our second subwindow - nothing to do
+ child = win;
+ }
+ }
- child = win;
- };
- };
+ if ( child ) {
+ // we have exactly one child - set it's size to fill the whole frame
+ int clientW, clientH;
+ GetClientSize(&clientW, &clientH);
- // yes: set it's size to fill all the frame
- int client_x, client_y;
- GetClientSize(&client_x, &client_y);
- child->SetSize( 1, 1, client_x-2, client_y);
+ int x = 0;
+ int y = 0;
+
+ child->SetSize(x, y, clientW, clientH);
}
-};
+}
-static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
+// Default activation behaviour - set the focus for the first child
+// subwindow found.
+void wxFrame::OnActivate(wxActivateEvent& event)
{
- menu->SetInvokingWindow( win );
- wxNode *node = menu->m_items.First();
- while (node)
+ for(wxNode *node = GetChildren()->First(); node; node = node->Next())
{
- wxMenuItem *menuitem = (wxMenuItem*)node->Data();
- if (menuitem->IsSubMenu())
- SetInvokingWindow( menuitem->GetSubMenu(), win );
- node = node->Next();
- };
-};
+ // Find a child that's a subwindow, but not a dialog box.
+ wxWindow *child = (wxWindow *)node->Data();
+ if (!child->IsKindOf(CLASSINFO(wxFrame)) &&
+ !child->IsKindOf(CLASSINFO(wxDialog)))
+ {
+#if WXDEBUG > 1
+ wxDebugMsg("wxFrame::OnActivate: about to set the child's focus.\n");
+#endif
+ child->SetFocus();
+ return;
+ }
+ }
+}
+
+// The default implementation for the close window event - calls
+// OnClose for backward compatibility.
-void wxFrame::SetMenuBar( wxMenuBar *menuBar )
+void wxFrame::OnCloseWindow(wxCloseEvent& event)
{
- m_frameMenuBar = menuBar;
-
- if (m_frameMenuBar)
+ // Compatibility
+ if ( GetEventHandler()->OnClose() || event.GetForce())
+ {
+ this->Destroy();
+ }
+}
+
+bool wxFrame::OnClose()
+{
+ return TRUE;
+}
+
+// Destroy the window (delayed, if a managed window)
+bool wxFrame::Destroy()
+{
+ if (!wxPendingDelete.Member(this))
+ wxPendingDelete.Append(this);
+ return TRUE;
+}
+
+// Default menu selection behaviour - display a help string
+void wxFrame::OnMenuHighlight(wxMenuEvent& event)
+{
+ if (GetStatusBar())
{
- if (m_frameMenuBar->m_parent != this)
+ if (event.GetMenuId() == -1)
+ SetStatusText("");
+ else
{
- wxNode *node = m_frameMenuBar->m_menus.First();
- while (node)
+ wxMenuBar *menuBar = GetMenuBar();
+ if (menuBar)
{
- wxMenu *menu = (wxMenu*)node->Data();
- SetInvokingWindow( menu, this );
- node = node->Next();
- };
-
+ wxString helpString(menuBar->GetHelpString(event.GetMenuId()));
+ if (helpString != "")
+ SetStatusText(helpString);
+ }
}
}
-};
+}
-wxMenuBar *wxFrame::GetMenuBar(void)
+wxMenuBar *wxFrame::GetMenuBar() const
{
return m_frameMenuBar;
-};
+}
-wxToolBar *wxFrame::CreateToolBar( long style , wxWindowID id, const wxString& name )
+void wxFrame::Centre(int direction)
{
- m_frameToolBar = new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );
-
- return m_frameToolBar;
-};
+ int display_width, display_height, width, height, x, y;
+ wxDisplaySize(&display_width, &display_height);
+
+ GetSize(&width, &height);
+ GetPosition(&x, &y);
+
+ if (direction & wxHORIZONTAL)
+ x = (int)((display_width - width)/2);
+ if (direction & wxVERTICAL)
+ y = (int)((display_height - height)/2);
+
+ SetSize(x, y, width, height);
+}
-wxToolBar *wxFrame::GetToolBar(void)
+// Call this to simulate a menu command
+void wxFrame::Command(int id)
{
- return m_frameToolBar;
-};
+ ProcessCommand(id);
+}
-wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
+void wxFrame::ProcessCommand(int id)
{
- if (m_frameStatusBar)
- delete m_frameStatusBar;
+ wxCommandEvent commandEvent(wxEVENT_TYPE_MENU_COMMAND, id);
+ commandEvent.SetInt( id );
+ commandEvent.SetEventObject( this );
- m_frameStatusBar = new wxStatusBar( this, id, wxPoint(0,0), wxSize(100,20), style, name );
+ wxMenuBar *bar = GetMenuBar() ;
+ if (!bar)
+ return;
- m_frameStatusBar->SetFieldsCount( number );
-
- return m_frameStatusBar;
-};
+/* TODO: check the menu item if required
+ wxMenuItem *item = bar->FindItemForId(id) ;
+ if (item && item->IsCheckable())
+ {
+ bar->Check(id,!bar->Checked(id)) ;
+ }
+*/
-void wxFrame::SetStatusText( const wxString &text, int number )
-{
- if (m_frameStatusBar) m_frameStatusBar->SetStatusText( text, number );
-};
+ GetEventHandler()->ProcessEvent(commandEvent);
+}
-void wxFrame::SetStatusWidths( int n, int *width )
+// Checks if there is a toolbar, and returns the first free client position
+wxPoint wxFrame::GetClientAreaOrigin() const
{
- if (m_frameStatusBar) m_frameStatusBar->SetStatusWidths( n, width );
-};
+ wxPoint pt(0, 0);
+ if (GetToolBar())
+ {
+ int w, h;
+ GetToolBar()->GetSize(& w, & h);
+
+ if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
+ {
+ pt.x += w;
+ }
+ else
+ {
+ pt.y += h;
+ }
+ }
+ return pt;
+}
-wxStatusBar *wxFrame::GetStatusBar(void)
+wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
{
- return m_frameStatusBar;
-};
+ wxCHECK_MSG( m_frameToolBar == NULL, FALSE,
+ "recreating toolbar in wxFrame" );
-void wxFrame::SetTitle( const wxString &title )
-{
- m_title = title;
-};
+ wxToolBar* toolBar = OnCreateToolBar(style, id, name);
+ if (toolBar)
+ {
+ SetToolBar(toolBar);
+ PositionToolBar();
+ return toolBar;
+ }
+ else
+ {
+ return NULL;
+ }
+}
-void wxFrame::SetSizeHints( int WXUNUSED(minW), int WXUNUSED(minH),
- int WXUNUSED(maxW), int WXUNUSED(maxH), int WXUNUSED(incW) )
+wxToolBar* wxFrame::OnCreateToolBar(long style, wxWindowID id, const wxString& name)
{
+ return new wxToolBar(this, id, wxDefaultPosition, wxDefaultSize, style, name);
}
-void wxFrame::SetIcon( const wxIcon &icon )
+void wxFrame::PositionToolBar()
{
- m_icon = icon;
- if (!icon.Ok()) return;
-
+ int cw, ch;
+
+ // TODO: we actually need to use the low-level client size, before
+ // the toolbar/status bar were added.
+ // So DEFINITELY replace the line below with something appropriate.
+
+ wxCHECK_MSG( TRUE, FALSE,
+ "PositionToolBar not implemented properly, see frame.cpp" );
+
+ GetClientSize(& cw, &ch);
+
+ if ( GetStatusBar() )
+ {
+ int statusX, statusY;
+ GetStatusBar()->GetClientSize(&statusX, &statusY);
+ ch -= statusY;
+ }
+
+ if (GetToolBar())
+ {
+ int tw, th;
+ GetToolBar()->GetSize(& tw, & th);
+
+ if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
+ {
+ // Use the 'real' position. wxSIZE_NO_ADJUSTMENTS
+ // means, pretend we don't have toolbar/status bar, so we
+ // have the original client size.
+ GetToolBar()->SetSize(0, 0, tw, ch, wxSIZE_NO_ADJUSTMENTS);
+ }
+ else
+ {
+ // Use the 'real' position
+ GetToolBar()->SetSize(0, 0, cw, th, wxSIZE_NO_ADJUSTMENTS);
+ }
+ }
}
/////////////////////////////////////////////////////////////////////////////
// Name: gauge.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxGauge class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/gauge.h"
-//-----------------------------------------------------------------------------
-// wxGauge
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
+#endif
+
+bool wxGauge::Create(wxWindow *parent, wxWindowID id,
+ int range,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxValidator& validator,
+ const wxString& name)
+{
+ SetName(name);
+ SetValidator(validator);
+ m_rangeMax = range;
+ m_windowStyle = style;
+
+ if (parent) parent->AddChild(this);
+
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
+
+
+ // TODO
+ return FALSE;
+}
+
+void wxGauge::SetSize(int x, int y, int width, int height, int sizeFlags)
+{
+ // TODO
+}
-IMPLEMENT_DYNAMIC_CLASS(wxGauge,wxControl)
+void wxGauge::SetShadowWidth(int w)
+{
+ // TODO optional
+}
+
+void wxGauge::SetBezelFace(int w)
+{
+ // TODO optional
+}
+
+void wxGauge::SetRange(int r)
+{
+ m_rangeMax = r;
+ // TODO
+}
+
+void wxGauge::SetValue(int pos)
+{
+ m_gaugePos = pos;
+ // TODO
+}
+
+int wxGauge::GetShadowWidth() const
+{
+ // TODO optional
+ return 0;
+}
-bool wxGauge::Create( wxWindow *parent, wxWindowID id, int range,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name )
+int wxGauge::GetBezelFace() const
{
- return TRUE;
-};
+ // TODO optional
+ return 0;
+}
-void wxGauge::SetRange( int r )
+int wxGauge::GetRange() const
{
- m_rangeMax = r;
- if (m_gaugePos > m_rangeMax) m_gaugePos = m_rangeMax;
-};
+ return m_rangeMax;
+}
-void wxGauge::SetValue( int pos )
+int wxGauge::GetValue() const
{
- m_gaugePos = pos;
- if (m_gaugePos > m_rangeMax) m_gaugePos = m_rangeMax;
-};
+ return m_gaugePos;
+}
-int wxGauge::GetRange(void) const
+void wxGauge::SetForegroundColour(const wxColour& col)
{
- return m_rangeMax;
-};
+ m_foregroundColour = col ;
+}
-int wxGauge::GetValue(void) const
+void wxGauge::SetBackgroundColour(const wxColour& col)
{
- return m_gaugePos;
-};
+ m_backgroundColour = col ;
+}
/////////////////////////////////////////////////////////////////////////////
// Name: gdiobj.cpp
// Purpose: wxGDIObject class
-// Author: Julian Smart
+// Author: AUTHOR
// Modified by:
-// Created: 01/02/97
+// Created: ??/??/98
// RCS-ID: $Id$
-// Copyright: (c) Julian Smart and Markus Holzem
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC_CLASS(wxGDIObject, wxObject)
#endif
+// TODO: Nothing to do, unless you want to.
/////////////////////////////////////////////////////////////////////////////
// Name: icon.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxIcon class
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/icon.h"
-//-----------------------------------------------------------------------------
-// wxIcon
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
+#endif
+
+/*
+ * Icons
+ */
+
+
+wxIconRefData::wxIconRefData()
+{
+ // TODO: init icon handle
+}
-IMPLEMENT_DYNAMIC_CLASS(wxIcon,wxBitmap)
+wxIconRefData::~wxIconRefData()
+{
+ // TODO: destroy icon handle
+}
+
+wxIcon::wxIcon()
+{
+}
-wxIcon::wxIcon( char **bits, int WXUNUSED(width), int WXUNUSED(height) ) :
- wxBitmap( bits )
+wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height))
{
-};
-
+}
+
+wxIcon::wxIcon(const wxString& icon_file, long flags,
+ int desiredWidth, int desiredHeight)
+
+{
+ LoadFile(icon_file, flags, desiredWidth, desiredHeight);
+}
+
+wxIcon::~wxIcon()
+{
+}
+
+bool wxIcon::LoadFile(const wxString& filename, long type,
+ int desiredWidth, int desiredHeight)
+{
+ UnRef();
+
+ m_refData = new wxIconRefData;
+
+ wxBitmapHandler *handler = FindHandler(type);
+
+ if ( handler )
+ return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
+ else
+ return FALSE;
+}
+
/////////////////////////////////////////////////////////////////////////////
// Name: joystick.cpp
// Purpose: wxJoystick class
-// Author: Ported to Linux by Guilhem Lavaux
+// Author: AUTHOR
// Modified by:
-// Created: 05/23/98
+// Created: ??/??/98
// RCS-ID: $Id$
-// Copyright: (c) Guilhem Lavaux
-// Licence: wxWindows license
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "joystick.h"
#endif
-#include <linux/joystick.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include "wx/event.h"
-#include "wx/window.h"
-#include "wx/gtk/joystick.h"
-
-#define JOYSTICK_AXE_MAX 32767
-#define JOYSTICK_AXE_MIN -32767
+#include <wx/joystick.h>
IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)
-wxJoystick::wxJoystick(int joystick)
-{
- wxString dev_name;
- // Assume it's the same device name on all Linux systems ...
- dev_name.Printf("/dev/js%d", (joystick == wxJOYSTICK1) ? 0 : 1);
-
- m_joystick = open(dev_name, O_RDWR);
- m_lastposition = wxPoint(-1, -1);
- for (int i=0;i<15;i++)
- m_axe[i] = 0;
- if (m_joystick != -1)
- Create();
-}
-
+// Attributes
////////////////////////////////////////////////////////////////////////////
-// Background thread
-////////////////////////////////////////////////////////////////////////////
-void *wxJoystick::Entry(void)
-{
- struct js_event j_evt;
- wxJoystickEvent jwx_event;
- fd_set read_fds;
- struct timeval time_out = {0, 0};
-
- FD_ZERO(&read_fds);
- DeferDestroy(TRUE);
- while (1) {
- TestDestroy();
-
- if (m_polling) {
- FD_SET(m_joystick, &read_fds);
- select(m_joystick+1, &read_fds, NULL, NULL, &time_out);
- if (FD_ISSET(m_joystick, &read_fds))
- read(m_joystick, &j_evt, sizeof(j_evt));
- else
- j_evt.type = 0;
- } else {
- read(m_joystick, &j_evt, sizeof(j_evt));
- }
-
- if ((j_evt.type & JS_EVENT_AXIS) == JS_EVENT_AXIS) {
- switch (j_evt.number) {
- case 1:
- m_lastposition.x = j_evt.value;
- jwx_event.SetEventType(wxEVT_JOY_MOVE);
- break;
- case 2:
- m_lastposition.y = j_evt.value;
- jwx_event.SetEventType(wxEVT_JOY_MOVE);
- break;
- case 3:
- m_axe[3] = j_evt.value;
- jwx_event.SetEventType(wxEVT_JOY_ZMOVE);
- break;
- default:
- m_axe[j_evt.number] = j_evt.value;
- jwx_event.SetEventType(wxEVT_JOY_MOVE);
- break;
- }
- jwx_event.SetPosition(m_lastposition);
- jwx_event.SetZPosition(m_axe[3]);
- }
- if ((j_evt.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON) {
- register int mask = 1 << j_evt.number;
- char button = m_buttons & mask;
-
- m_buttons &= ~mask;
- if (button) {
- jwx_event.SetEventType(wxEVT_JOY_BUTTON_UP);
- } else {
- jwx_event.SetEventType(wxEVT_JOY_BUTTON_DOWN);
- m_buttons |= mask;
- }
-
- jwx_event.SetButtonState(m_buttons);
- jwx_event.SetButtonChange(j_evt.number);
- }
- }
- if (m_catchwin)
- m_catchwin->ProcessEvent(jwx_event);
- if (m_polling)
- usleep(m_polling*1000);
-}
-////////////////////////////////////////////////////////////////////////////
-// State
-////////////////////////////////////////////////////////////////////////////
-
-wxPoint wxJoystick::GetPosition(void) const
+wxPoint wxJoystick::GetPosition() const
{
- return m_lastposition;
+ // TODO
+ return wxPoint(0, 0);
}
-int wxJoystick::GetZPosition(void) const
+int wxJoystick::GetZPosition() const
{
- return m_axe[3];
+ // TODO
+ return 0;
}
-int wxJoystick::GetButtonState(void) const
+int wxJoystick::GetButtonState() const
{
- return m_buttons;
+ // TODO
+ return 0;
}
-int wxJoystick::GetPOVPosition(void) const
+int wxJoystick::GetPOVPosition() const
{
- return 0;
+ // TODO
+ return 0;
}
-int wxJoystick::GetPOVCTSPosition(void) const
+int wxJoystick::GetPOVCTSPosition() const
{
- return 0;
+ // TODO
+ return 0;
}
-int wxJoystick::GetRudderPosition(void) const
+int wxJoystick::GetRudderPosition() const
{
- return m_axe[4];
+ // TODO
+ return 0;
}
-int wxJoystick::GetUPosition(void) const
+int wxJoystick::GetUPosition() const
{
- return m_axe[5];
+ // TODO
+ return 0;
}
-int wxJoystick::GetVPosition(void) const
+int wxJoystick::GetVPosition() const
{
- return m_axe[6];
+ // TODO
+ return 0;
}
-int wxJoystick::GetMovementThreshold(void) const
+int wxJoystick::GetMovementThreshold() const
{
- return 0;
+ // TODO
+ return 0;
}
void wxJoystick::SetMovementThreshold(int threshold)
{
+ // TODO
}
-////////////////////////////////////////////////////////////////////////////
// Capabilities
////////////////////////////////////////////////////////////////////////////
-bool wxJoystick::IsOk(void) const
+bool wxJoystick::IsOk() const
{
- return (m_joystick != -1);
+ // TODO
+ return FALSE;
}
-int wxJoystick::GetNumberJoysticks(void) const
+int wxJoystick::GetNumberJoysticks() const
{
- wxString dev_name;
- int fd, j;
-
- for (j=0;j<2;j++) {
- dev_name.Printf("/dev/js%d", j);
- fd = open(dev_name, O_RDONLY);
- if (fd == -1)
- return j;
- close(fd);
- }
- return j;
+ // TODO
+ return 0;
}
-int wxJoystick::GetManufacturerId(void) const
+int wxJoystick::GetManufacturerId() const
{
- return 0;
+ // TODO
+ return 0;
}
-int wxJoystick::GetProductId(void) const
+int wxJoystick::GetProductId() const
{
- return 0;
+ // TODO
+ return 0;
}
-wxString wxJoystick::GetProductName(void) const
+wxString wxJoystick::GetProductName() const
{
- return "";
+ // TODO
+ return wxString("");
}
-int wxJoystick::GetXMin(void) const
+int wxJoystick::GetXMin() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-int wxJoystick::GetYMin(void) const
+int wxJoystick::GetYMin() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-int wxJoystick::GetZMin(void) const
+int wxJoystick::GetZMin() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-int wxJoystick::GetXMax(void) const
+int wxJoystick::GetXMax() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-int wxJoystick::GetYMax(void) const
+int wxJoystick::GetYMax() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-int wxJoystick::GetZMax(void) const
+int wxJoystick::GetZMax() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-int wxJoystick::GetNumberButtons(void) const
+int wxJoystick::GetNumberButtons() const
{
- int nb;
-
- ioctl(m_joystick, JSIOCGBUTTONS, &nb);
-
- return nb;
+ // TODO
+ return 0;
}
-int wxJoystick::GetNumberAxes(void) const
+int wxJoystick::GetNumberAxes() const
{
- int nb;
-
- ioctl(m_joystick, JSIOCGAXES, &nb);
-
- return nb;
+ // TODO
+ return 0;
}
-int wxJoystick::GetMaxButtons(void) const
+int wxJoystick::GetMaxButtons() const
{
- return 15; // internal
+ // TODO
+ return 0;
}
-int wxJoystick::GetMaxAxes(void) const
+int wxJoystick::GetMaxAxes() const
{
- return 15; // internal
+ // TODO
+ return 0;
}
-int wxJoystick::GetPollingMin(void) const
+int wxJoystick::GetPollingMin() const
{
- return -1;
+ // TODO
+ return 0;
}
-int wxJoystick::GetPollingMax(void) const
+int wxJoystick::GetPollingMax() const
{
- return -1;
+ // TODO
+ return 0;
}
-int wxJoystick::GetRudderMin(void) const
+int wxJoystick::GetRudderMin() const
{
- return JOYSTICK_AXE_MIN;
+ // TODO
+ return 0;
}
-int wxJoystick::GetRudderMax(void) const
+int wxJoystick::GetRudderMax() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-int wxJoystick::GetUMin(void) const
+int wxJoystick::GetUMin() const
{
- return JOYSTICK_AXE_MIN;
+ // TODO
+ return 0;
}
-int wxJoystick::GetUMax(void) const
+int wxJoystick::GetUMax() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-int wxJoystick::GetVMin(void) const
+int wxJoystick::GetVMin() const
{
- return JOYSTICK_AXE_MIN;
+ // TODO
+ return 0;
}
-int wxJoystick::GetVMax(void) const
+int wxJoystick::GetVMax() const
{
- return JOYSTICK_AXE_MAX;
+ // TODO
+ return 0;
}
-bool wxJoystick::HasRudder(void) const
+bool wxJoystick::HasRudder() const
{
- return GetNumberAxes() >= 4;
+ // TODO
+ return FALSE;
}
-bool wxJoystick::HasZ(void) const
+bool wxJoystick::HasZ() const
{
- return GetNumberAxes() >= 3;
+ // TODO
+ return FALSE;
}
-bool wxJoystick::HasU(void) const
+bool wxJoystick::HasU() const
{
- return GetNumberAxes() >= 5;
+ // TODO
+ return FALSE;
}
-bool wxJoystick::HasV(void) const
+bool wxJoystick::HasV() const
{
- return GetNumberAxes() >= 6;
+ // TODO
+ return FALSE;
}
-bool wxJoystick::HasPOV(void) const
+bool wxJoystick::HasPOV() const
{
- return FALSE;
+ // TODO
+ return FALSE;
}
-bool wxJoystick::HasPOV4Dir(void) const
+bool wxJoystick::HasPOV4Dir() const
{
- return FALSE;
+ // TODO
+ return FALSE;
}
-bool wxJoystick::HasPOVCTS(void) const
+bool wxJoystick::HasPOVCTS() const
{
- return FALSE;
+ // TODO
+ return FALSE;
}
-////////////////////////////////////////////////////////////////////////////
// Operations
////////////////////////////////////////////////////////////////////////////
-bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq = 0)
+bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
{
- m_catchwin = win;
- m_polling = pollingFreq;
- return TRUE;
+ // TODO
+ return FALSE;
}
-bool wxJoystick::ReleaseCapture(void)
+bool wxJoystick::ReleaseCapture()
{
- m_catchwin = NULL;
- m_polling = 0;
- return TRUE;
+ // TODO
+ return FALSE;
}
-/////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
// Name: listbox.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
-
+// Purpose: wxListBox
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "listbox.h"
#endif
-#include "wx/dynarray.h"
#include "wx/listbox.h"
-#include "wx/utils.h"
-//-----------------------------------------------------------------------------
-// wxListBox
-//-----------------------------------------------------------------------------
+#include "wx/dynarray.h"
+#include "wx/log.h"
+#if !USE_SHARED_LIBRARY
+ IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
+#endif
-IMPLEMENT_DYNAMIC_CLASS(wxListBox,wxControl)
+// ============================================================================
+// list box control implementation
+// ============================================================================
-wxListBox::wxListBox(void)
+// Listbox item
+wxListBox::wxListBox()
{
-};
+ m_noItems = 0;
+ m_selected = 0;
+}
-wxListBox::wxListBox( wxWindow *parent, wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- int n, const wxString choices[],
- long style, const wxString &name )
+bool wxListBox::Create(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ int n, const wxString choices[],
+ long style,
+ const wxValidator& validator,
+ const wxString& name)
{
- Create( parent, id, pos, size, n, choices, style, name );
-};
+ m_noItems = n;
+ m_selected = 0;
+
+ SetName(name);
+ SetValidator(validator);
+
+ if (parent) parent->AddChild(this);
+
+ wxSystemSettings settings;
+ SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
-bool wxListBox::Create( wxWindow *parent, wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- int n, const wxString choices[],
- long style, const wxString &name )
+ m_windowId = ( id == -1 ) ? (int)NewControlId() : id;
+
+ // TODO create listbox
+
+ return FALSE;
+}
+
+wxListBox::~wxListBox()
{
- return TRUE;
-};
+}
-void wxListBox::Append( const wxString &item )
+void wxListBox::SetupColours()
{
- Append( item, (char*)NULL );
-};
+ SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
+}
-void wxListBox::Append( const wxString &WXUNUSED(item), char *WXUNUSED(clientData) )
+void wxListBox::SetFirstItem(int N)
{
-};
+ // TODO
+}
-void wxListBox::Clear(void)
+void wxListBox::SetFirstItem(const wxString& s)
{
-};
+ // TODO
+}
-void wxListBox::Delete( int WXUNUSED(n) )
+void wxListBox::Delete(int N)
{
-};
+ m_noItems --;
+ // TODO
+}
-void wxListBox::Deselect( int WXUNUSED(n) )
+void wxListBox::Append(const wxString& item)
{
-};
+ m_noItems ++;
+
+ // TODO
+}
-int wxListBox::FindString( const wxString &WXUNUSED(item) ) const
+void wxListBox::Append(const wxString& item, char *Client_data)
{
- return -1;
-};
+ m_noItems ++;
+
+ // TODO
+}
-char *wxListBox::GetClientData( int WXUNUSED(n) ) const
+void wxListBox::Set(int n, const wxString *choices, char** clientData)
{
- return (char*)NULL;
-};
+ m_noItems = n;
-int wxListBox::GetSelection(void) const
+ // TODO
+}
+
+int wxListBox::FindString(const wxString& s) const
{
- return -1;
-};
+ // TODO
+ return -1;
+}
-int wxListBox::GetSelections( wxArrayInt& WXUNUSED(aSelections) ) const
+void wxListBox::Clear()
{
- return 0;
-};
+ m_noItems = 0;
+ // TODO
+}
-wxString wxListBox::GetString( int WXUNUSED(n) ) const
+void wxListBox::SetSelection(int N, bool select)
{
- return "";
-};
+ // TODO
+}
-wxString wxListBox::GetStringSelection(void) const
+bool wxListBox::Selected(int N) const
{
- return "";
-};
+ // TODO
+ return FALSE;
+}
-int wxListBox::Number(void)
+void wxListBox::Deselect(int N)
{
- return 0;
-};
+ // TODO
+}
-bool wxListBox::Selected( int WXUNUSED(n) )
+char *wxListBox::GetClientData(int N) const
{
- return FALSE;
-};
+ // TODO
+ return (char *)NULL;
+}
+
+void wxListBox::SetClientData(int N, char *Client_data)
+{
+ // TODO
+}
+
+// Return number of selections and an array of selected integers
+int wxListBox::GetSelections(wxArrayInt& aSelections) const
+{
+ aSelections.Empty();
-void wxListBox::Set( int WXUNUSED(n), const wxString *WXUNUSED(choices) )
+/* TODO
+ if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED))
+ {
+ int no_sel = ??
+ for ( int n = 0; n < no_sel; n++ )
+ aSelections.Add(??);
+
+ return no_sel;
+ }
+ else // single-selection listbox
+ {
+ aSelections.Add(??);
+
+ return 1;
+ }
+*/
+ return 0;
+}
+
+// Get single selection, for single choice list items
+int wxListBox::GetSelection() const
{
-};
+ // TODO
+ return -1;
+}
-void wxListBox::SetClientData( int WXUNUSED(n), char *WXUNUSED(clientData) )
+// Find string for position
+wxString wxListBox::GetString(int N) const
{
-};
+ // TODO
+ return wxString("");
+}
-void wxListBox::SetFirstItem( int WXUNUSED(n) )
+void wxListBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
-};
+ // TODO
+}
-void wxListBox::SetFirstItem( const wxString &WXUNUSED(item) )
+void wxListBox::InsertItems(int nItems, const wxString items[], int pos)
{
-};
+ m_noItems += nItems;
-void wxListBox::SetSelection( int WXUNUSED(n), bool WXUNUSED(select) )
+ // TODO
+}
+
+void wxListBox::SetString(int N, const wxString& s)
{
-};
+ // TODO
+}
-void wxListBox::SetString( int WXUNUSED(n), const wxString &WXUNUSED(string) )
+int wxListBox::Number () const
{
-};
+ return m_noItems;
+}
-void wxListBox::SetStringSelection( const wxString &WXUNUSED(string), bool WXUNUSED(select) )
+// For single selection items only
+wxString wxListBox::GetStringSelection () const
{
-};
+ int sel = GetSelection ();
+ if (sel > -1)
+ return this->GetString (sel);
+ else
+ return wxString("");
+}
+bool wxListBox::SetStringSelection (const wxString& s, bool flag)
+{
+ int sel = FindString (s);
+ if (sel > -1)
+ {
+ SetSelection (sel, flag);
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+void wxListBox::Command (wxCommandEvent & event)
+{
+ if (event.m_extraLong)
+ SetSelection (event.m_commandInt);
+ else
+ {
+ Deselect (event.m_commandInt);
+ return;
+ }
+ ProcessCommand (event);
+}
/////////////////////////////////////////////////////////////////////////////
// Name: mdi.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: MDI classes
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#endif
#include "wx/mdi.h"
-#include "wx/dialog.h"
-#include "wx/menu.h"
-//-----------------------------------------------------------------------------
+extern wxList wxModelessWindows;
-extern wxList wxPendingDelete;
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
+IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
+IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
-//-----------------------------------------------------------------------------
-// wxMDIParentFrame
-//-----------------------------------------------------------------------------
+BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
+ EVT_SIZE(wxMDIParentFrame::OnSize)
+ EVT_ACTIVATE(wxMDIParentFrame::OnActivate)
+ EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
+END_EVENT_TABLE()
-//-----------------------------------------------------------------------------
+BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
+ EVT_SCROLL(wxMDIClientWindow::OnScroll)
+END_EVENT_TABLE()
-IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame,wxFrame)
+#endif
-BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
-END_EVENT_TABLE()
+// Parent frame
-wxMDIParentFrame::wxMDIParentFrame(void)
+wxMDIParentFrame::wxMDIParentFrame()
{
- m_clientWindow = NULL;
- m_currentChild = NULL;
- m_parentFrameActive = TRUE;
-};
+}
-wxMDIParentFrame::wxMDIParentFrame( wxWindow *parent,
- wxWindowID id, const wxString& title,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name )
+bool wxMDIParentFrame::Create(wxWindow *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
- m_clientWindow = NULL;
- m_currentChild = NULL;
- m_parentFrameActive = TRUE;
- Create( parent, id, title, pos, size, style, name );
-};
+ if (!parent)
+ wxTopLevelWindows.Append(this);
+
+ SetName(name);
+ m_windowStyle = style;
+
+ if (parent) parent->AddChild(this);
-wxMDIParentFrame::~wxMDIParentFrame(void)
+ if ( id > -1 )
+ m_windowId = id;
+ else
+ m_windowId = (int)NewControlId();
+
+ // TODO: create MDI parent frame
+
+ wxModelessWindows.Append(this);
+
+ return TRUE;
+}
+
+wxMDIParentFrame::~wxMDIParentFrame()
{
-};
+}
-bool wxMDIParentFrame::Create( wxWindow *parent,
- wxWindowID id, const wxString& title,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name )
+// Get size *available for subwindows* i.e. excluding menu bar.
+void wxMDIParentFrame::GetClientSize(int *x, int *y) const
{
- wxFrame::Create( parent, id, title, pos, size, style, name );
-
- OnCreateClient();
-
- return TRUE;
-};
+ // TODO
+}
-void wxMDIParentFrame::GetClientSize(int *width, int *height ) const
+void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar)
{
- wxFrame::GetClientSize( width, height );
-};
+ // TODO
+ if (!menu_bar)
+ {
+ m_frameMenuBar = NULL;
+ return;
+ }
+
+ if (menu_bar->m_menuBarFrame)
+ return;
-wxMDIChildFrame *wxMDIParentFrame::GetActiveChild(void) const
+ m_frameMenuBar = menu_bar;
+}
+
+void wxMDIParentFrame::OnSize(wxSizeEvent& event)
{
- return m_currentChild;
-};
+#if USE_CONSTRAINTS
+ if (GetAutoLayout())
+ Layout();
+#endif
+ int x = 0;
+ int y = 0;
+ int width, height;
+ GetClientSize(&width, &height);
+
+ if ( GetClientWindow() )
+ GetClientWindow()->SetSize(x, y, width, height);
+}
-wxMDIClientWindow *wxMDIParentFrame::GetClientWindow(void) const
+void wxMDIParentFrame::OnActivate(wxActivateEvent& event)
{
- return m_clientWindow;
-};
+ // Do nothing
+}
-wxMDIClientWindow *wxMDIParentFrame::OnCreateClient(void)
+// Returns the active MDI child window
+wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
- m_clientWindow = new wxMDIClientWindow( this );
- return m_clientWindow;
-};
+ // TODO
+ return NULL;
+}
-void wxMDIParentFrame::ActivateNext(void)
+// Create the client window class (don't Create the window,
+// just return a new class)
+wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
{
-};
+ return new wxMDIClientWindow ;
+}
-void wxMDIParentFrame::ActivatePrevious(void)
+// Responds to colour changes, and passes event on to children.
+void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
{
-};
+ // TODO
-void wxMDIParentFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
+ // Propagate the event to the non-top-level children
+ wxFrame::OnSysColourChanged(event);
+}
+
+// MDI operations
+void wxMDIParentFrame::Cascade()
{
-};
+ // TODO
+}
-void wxMDIParentFrame::OnSysColourChanged( wxSysColourChangedEvent& WXUNUSED(event) )
+void wxMDIParentFrame::Tile()
{
-};
+ // TODO
+}
-//-----------------------------------------------------------------------------
-// wxMDIChildFrame
-//-----------------------------------------------------------------------------
+void wxMDIParentFrame::ArrangeIcons()
+{
+ // TODO
+}
-IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
-
-BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
- EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
-END_EVENT_TABLE()
+void wxMDIParentFrame::ActivateNext()
+{
+ // TODO
+}
-wxMDIChildFrame::wxMDIChildFrame(void)
+void wxMDIParentFrame::ActivatePrevious()
{
-};
+ // TODO
+}
+
+// Child frame
-wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
- wxWindowID id, const wxString& title,
- const wxPoint& WXUNUSED(pos), const wxSize& size,
- long style, const wxString& name )
+wxMDIChildFrame::wxMDIChildFrame()
{
- Create( parent, id, title, wxDefaultPosition, size, style, name );
-};
+}
-wxMDIChildFrame::~wxMDIChildFrame(void)
+bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
+ wxWindowID id,
+ const wxString& title,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
-};
+ SetName(name);
+
+ if ( id > -1 )
+ m_windowId = id;
+ else
+ m_windowId = (int)NewControlId();
+
+ if (parent) parent->AddChild(this);
+
+ // TODO: create child frame
-bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
- wxWindowID id, const wxString& title,
- const wxPoint& WXUNUSED(pos), const wxSize& size,
- long style, const wxString& name )
+ wxModelessWindows.Append(this);
+ return FALSE;
+}
+
+wxMDIChildFrame::~wxMDIChildFrame()
{
- m_title = title;
- return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
-};
+}
-void wxMDIChildFrame::GetClientSize( int *width, int *height ) const
+// Set the client size (i.e. leave the calculation of borders etc.
+// to wxWindows)
+void wxMDIChildFrame::SetClientSize(int width, int height)
{
- wxWindow::GetClientSize( width, height );
+ // TODO
}
-void wxMDIChildFrame::AddChild( wxWindow *child )
+void wxMDIChildFrame::GetPosition(int *x, int *y) const
{
- wxWindow::AddChild( child );
+ // TODO
}
-
-static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
-{
- menu->SetInvokingWindow( win );
- wxNode *node = menu->m_items.First();
- while (node)
- {
- wxMenuItem *menuitem = (wxMenuItem*)node->Data();
- if (menuitem->IsSubMenu())
- SetInvokingWindow( menuitem->GetSubMenu(), win );
- node = node->Next();
- };
-};
-
-void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
-{
- m_menuBar = menu_bar;
-
- if (m_menuBar)
- {
- wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->m_parent;
-
- if (m_menuBar->m_parent != this)
+
+void wxMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
+{
+ // TODO
+ if (!menu_bar)
{
- wxNode *node = m_menuBar->m_menus.First();
- while (node)
- {
- wxMenu *menu = (wxMenu*)node->Data();
- SetInvokingWindow( menu, this );
- node = node->Next();
- };
-
- m_menuBar->m_parent = mdi_frame;
+ m_frameMenuBar = NULL;
+ return;
}
- mdi_frame->SetMDIMenuBar( m_menuBar );
-
- }
-};
+
+ if (menu_bar->m_menuBarFrame)
+ return;
+ m_frameMenuBar = menu_bar;
+}
-wxMenuBar *wxMDIChildFrame::GetMenuBar()
+// MDI operations
+void wxMDIChildFrame::Maximize()
{
- return m_menuBar;
-};
+ // TODO
+}
-void wxMDIChildFrame::Activate(void)
+void wxMDIChildFrame::Restore()
{
-};
+ // TODO
+}
-void wxMDIChildFrame::OnActivate( wxActivateEvent &WXUNUSED(event) )
+void wxMDIChildFrame::Activate()
{
-};
-
-//-----------------------------------------------------------------------------
-// wxMDIClientWindow
-//-----------------------------------------------------------------------------
+ // TODO
+}
-IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
+// Client window
-wxMDIClientWindow::wxMDIClientWindow(void)
+wxMDIClientWindow::wxMDIClientWindow()
{
-};
+}
-wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
+wxMDIClientWindow::~wxMDIClientWindow()
{
- CreateClient( parent, style );
-};
+}
-wxMDIClientWindow::~wxMDIClientWindow(void)
+bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
{
-};
+ // TODO create client window
+ m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
-bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *WXUNUSED(parent), long WXUNUSED(style) )
-{
- return TRUE;
-};
+ return FALSE;
+}
-void wxMDIClientWindow::AddChild( wxWindow *WXUNUSED(child) )
+// Explicitly call default scroll behaviour
+void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
{
-};
-
+ Default(); // Default processing
+}
/////////////////////////////////////////////////////////////////////////////
// Name: menu.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id: $Id$
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxMenu, wxMenuBar, wxMenuItem
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+// ============================================================================
+// headers & declarations
+// ============================================================================
+
+// wxWindows headers
+// -----------------
+
#ifdef __GNUG__
#pragma implementation "menu.h"
+#pragma implementation "menuitem.h"
#endif
#include "wx/menu.h"
+#include "wx/menuitem.h"
#include "wx/log.h"
-//-----------------------------------------------------------------------------
-// wxMenuBar
-//-----------------------------------------------------------------------------
+// other standard headers
+// ----------------------
+#include <string.h>
+
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
+IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
+#endif
-IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow)
+// ============================================================================
+// implementation
+// ============================================================================
-wxMenuBar::wxMenuBar()
+// Menus
+
+// Construct a menu with optional title (then use append)
+wxMenu::wxMenu(const wxString& title, const wxFunction func)
{
-};
+ m_title = title;
+ m_parent = NULL;
+ m_eventHandler = this;
+ m_noItems = 0;
+ m_menuBar = NULL;
+ if (m_title != "")
+ {
+ Append(-2, m_title) ;
+ AppendSeparator() ;
+ }
+
+ Callback(func);
+
+ // TODO create menu
+}
-void wxMenuBar::Append( wxMenu *menu, const wxString &title )
-{
- m_menus.Append( menu );
- menu->m_title = title; // ??????
+// The wxWindow destructor will take care of deleting the submenus.
+wxMenu::~wxMenu()
+{
+ // TODO destroy menu and children
+
+ wxNode *node = m_menuItems.First();
+ while (node)
+ {
+ wxMenuItem *item = (wxMenuItem *)node->Data();
+
+ // Delete child menus.
+ // Beware: they must not be appended to children list!!!
+ // (because order of delete is significant)
+ if (item->GetSubMenu())
+ item->DeleteSubMenu();
+
+ wxNode *next = node->Next();
+ delete item;
+ delete node;
+ node = next;
+ }
+}
- int pos;
- do {
- pos = menu->m_title.First( '&' );
- if (pos != -1) menu->m_title.Remove( pos, 1 );
- } while (pos != -1);
+void wxMenu::Break()
+{
+ // TODO
+}
-};
+// function appends a new item or submenu to the menu
+void wxMenu::Append(wxMenuItem *pItem)
+{
+ // TODO
-static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString )
+ wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );
+
+ m_menuItems.Append(pItem);
+
+ m_noItems++;
+}
+
+void wxMenu::AppendSeparator()
{
- if (menu->m_title == menuString)
- {
- int res = menu->FindItem( itemString );
- if (res != -1) return res;
- };
- wxNode *node = menu->m_items.First();
- while (node)
- {
- wxMenuItem *item = (wxMenuItem*)node->Data();
- if (item->IsSubMenu())
- return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString);
- node = node->Next();
- };
- return -1;
-};
+ // TODO
+ Append(new wxMenuItem(this, ID_SEPARATOR));
+}
-int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const
+// Pullright item
+void wxMenu::Append(int Id, const wxString& label, wxMenu *SubMenu,
+ const wxString& helpString)
{
- wxNode *node = m_menus.First();
- while (node)
- {
- wxMenu *menu = (wxMenu*)node->Data();
- int res = FindMenuItemRecursive( menu, menuString, itemString);
- if (res != -1) return res;
- node = node->Next();
- };
- return -1;
-};
+ Append(new wxMenuItem(this, Id, label, helpString, FALSE, SubMenu));
+}
-// Find a wxMenuItem using its id. Recurses down into sub-menus
-static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id)
+// Ordinary menu item
+void wxMenu::Append(int Id, const wxString& label,
+ const wxString& helpString, bool checkable)
{
- wxMenuItem* result = menu->FindItem(id);
+ // 'checkable' parameter is useless for Windows.
+ Append(new wxMenuItem(this, Id, label, helpString, checkable));
+}
+
+void wxMenu::Delete(int id)
+{
+ wxNode *node;
+ wxMenuItem *item;
+ int pos;
+
+ for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++) {
+ item = (wxMenuItem *)node->Data();
+ if (item->GetId() == id)
+ break;
+ }
- wxNode *node = menu->m_items.First();
- while ( node && result == NULL ) {
- wxMenuItem *item = (wxMenuItem*)node->Data();
- if ( item->IsSubMenu() )
- result = FindMenuItemByIdRecursive( item->GetSubMenu(), id );
- node = node->Next();
- };
+ if (!node)
+ return;
- return result;
-};
+ m_menuItems.DeleteNode(node);
+ delete item;
-wxMenuItem* wxMenuBar::FindMenuItemById( int id ) const
+ // TODO
+}
+
+void wxMenu::Enable(int Id, bool Flag)
{
- wxMenuItem* result = 0;
- wxNode *node = m_menus.First();
- while (node && result == 0)
- {
- wxMenu *menu = (wxMenu*)node->Data();
- result = FindMenuItemByIdRecursive( menu, id );
- node = node->Next();
- }
- return result;
+ wxMenuItem *item = FindItemForId(Id);
+ wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );
+
+ item->Enable(Flag);
}
-void wxMenuBar::Check( int id, bool check )
+bool wxMenu::Enabled(int Id) const
{
- wxMenuItem* item = FindMenuItemById( id );
- if (item) item->Check(check);
-};
+ wxMenuItem *item = FindItemForId(Id);
+ wxCHECK( item != NULL, FALSE );
+
+ return item->IsEnabled();
+}
-bool wxMenuBar::Checked( int id ) const
+void wxMenu::Check(int Id, bool Flag)
{
- wxMenuItem* item = FindMenuItemById( id );
- if (item) return item->IsChecked();
- return FALSE;
-};
+ wxMenuItem *item = FindItemForId(Id);
+ wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );
-void wxMenuBar::Enable( int id, bool enable )
+ item->Check(Flag);
+}
+
+bool wxMenu::Checked(int Id) const
{
- wxMenuItem* item = FindMenuItemById( id );
- if (item) item->Enable(enable);
-};
+ wxMenuItem *item = FindItemForId(Id);
+ wxCHECK( item != NULL, FALSE );
+
+ return item->IsChecked();
+}
-bool wxMenuBar::Enabled( int id ) const
+void wxMenu::SetTitle(const wxString& label)
{
- wxMenuItem* item = FindMenuItemById( id );
- if (item) return item->IsEnabled();
- return FALSE;
-};
+ m_title = label ;
+ // TODO
+}
-//-----------------------------------------------------------------------------
-// wxMenu
-//-----------------------------------------------------------------------------
+const wxString& wxMenu::GetTitle() const
+{
+ return m_title;
+}
+void wxMenu::SetLabel(int id, const wxString& label)
+{
+ wxMenuItem *item = FindItemForId(id) ;
+ if (item==NULL)
+ return;
+
+ if (item->GetSubMenu()==NULL)
+ {
+ // TODO
+ }
+ else
+ {
+ // TODO
+ }
+ item->SetName(label);
+}
-IMPLEMENT_DYNAMIC_CLASS(wxMenuItem,wxObject)
+wxString wxMenu::GetLabel(int Id) const
+{
+ // TODO
+ return wxString("") ;
+}
-wxMenuItem::wxMenuItem()
+// Finds the item id matching the given string, -1 if not found.
+int wxMenu::FindItem (const wxString& itemString) const
{
- m_id = ID_SEPARATOR;
- m_isCheckMenu = FALSE;
- m_isChecked = FALSE;
- m_isEnabled = TRUE;
- m_subMenu = NULL;
-};
+ char buf1[200];
+ char buf2[200];
+ wxStripMenuCodes ((char *)(const char *)itemString, buf1);
+
+ for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
+ {
+ wxMenuItem *item = (wxMenuItem *) node->Data ();
+ if (item->GetSubMenu())
+ {
+ int ans = item->GetSubMenu()->FindItem(itemString);
+ if (ans > -1)
+ return ans;
+ }
+ if ( !item->IsSeparator() )
+ {
+ wxStripMenuCodes((char *)item->GetName().c_str(), buf2);
+ if (strcmp(buf1, buf2) == 0)
+ return item->GetId();
+ }
+ }
+
+ return -1;
+}
-void wxMenuItem::SetText(const wxString& str)
+wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
{
- for ( const char *pc = str; *pc != '\0'; pc++ ) {
- if ( *pc == '&' )
- pc++; // skip it
+ if (itemMenu)
+ *itemMenu = NULL;
+ for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
+ {
+ wxMenuItem *item = (wxMenuItem *) node->Data ();
+
+ if (item->GetId() == itemId)
+ {
+ if (itemMenu)
+ *itemMenu = (wxMenu *) this;
+ return item;
+ }
+
+ if (item->GetSubMenu())
+ {
+ wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu);
+ if (ans)
+ return ans;
+ }
+ }
+
+ if (itemMenu)
+ *itemMenu = NULL;
+ return NULL;
+}
- m_text << *pc;
- }
+void wxMenu::SetHelpString(int itemId, const wxString& helpString)
+{
+ wxMenuItem *item = FindItemForId (itemId);
+ if (item)
+ item->SetHelp(helpString);
}
-void wxMenuItem::Check( bool check )
+wxString wxMenu::GetHelpString (int itemId) const
{
- wxCHECK_RET( IsCheckable(), "can't check uncheckable item!" )
+ wxMenuItem *item = FindItemForId (itemId);
+ wxString str("");
+ return (item == NULL) ? str : item->GetHelp();
+}
- m_isChecked = check;
+void wxMenu::ProcessCommand(wxCommandEvent & event)
+{
+ bool processed = FALSE;
+
+ // Try a callback
+ if (m_callback)
+ {
+ (void) (*(m_callback)) (*this, event);
+ processed = TRUE;
+ }
+
+ // Try the menu's event handler
+ if ( !processed && GetEventHandler())
+ {
+ processed = GetEventHandler()->ProcessEvent(event);
+ }
+
+ // Try the window the menu was popped up from (and up
+ // through the hierarchy)
+ if ( !processed && GetInvokingWindow())
+ processed = GetInvokingWindow()->ProcessEvent(event);
+}
+
+bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
+{
+ // TODO
+ return FALSE;
}
-bool wxMenuItem::IsChecked() const
+// Menu Bar
+wxMenuBar::wxMenuBar()
{
- wxCHECK( IsCheckable(), FALSE ); // can't get state of uncheckable item!
+ m_eventHandler = this;
+ m_menuCount = 0;
+ m_menus = NULL;
+ m_titles = NULL;
+ m_menuBarFrame = NULL;
- return FALSE;
+ // TODO
}
-IMPLEMENT_DYNAMIC_CLASS(wxMenu,wxEvtHandler)
+wxMenuBar::wxMenuBar(int n, wxMenu *Mmnus[], const wxString titles[])
+{
+ m_eventHandler = this;
+ m_menuCount = n;
+ m_menus = menus;
+ m_titles = new wxString[n];
+ int i;
+ for ( i = 0; i < n; i++ )
+ m_titles[i] = titles[i];
+ m_menuBarFrame = NULL;
+
+ // TODO
+}
-wxMenu::wxMenu( const wxString &title )
+wxMenuBar::~wxMenuBar()
{
- m_title = title;
- m_items.DeleteContents( TRUE );
- m_invokingWindow = NULL;
-};
+ int i;
+ for (i = 0; i < m_menuCount; i++)
+ {
+ delete m_menus[i];
+ }
+ delete[] m_menus;
+ delete[] m_titles;
+
+ // TODO
+}
-void wxMenu::AppendSeparator()
+// Must only be used AFTER menu has been attached to frame,
+// otherwise use individual menus to enable/disable items
+void wxMenuBar::Enable(int id, bool flag)
+{
+ wxMenu *itemMenu = NULL;
+ wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+ if (!item)
+ return;
+
+ // TODO
+}
+
+void wxMenuBar::EnableTop(int pos, bool flag)
+{
+ // TODO
+}
+
+// Must only be used AFTER menu has been attached to frame,
+// otherwise use individual menus
+void wxMenuBar::Check(int id, bool flag)
{
- wxMenuItem *mitem = new wxMenuItem();
- mitem->SetId(ID_SEPARATOR);
+ wxMenu *itemMenu = NULL;
+ wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+ if (!item)
+ return;
- m_items.Append( mitem );
-};
+ if (!item->IsCheckable())
+ return ;
-void wxMenu::Append( int id, const wxString &item, const wxString &helpStr, bool checkable )
+ // TODO
+}
+
+bool wxMenuBar::Checked(int id) const
{
- wxMenuItem *mitem = new wxMenuItem();
- mitem->SetId(id);
- mitem->SetText(item);
- mitem->SetHelpString(helpStr);
- mitem->SetCheckable(checkable);
-
- m_items.Append( mitem );
-};
+ wxMenu *itemMenu = NULL;
+ wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+ if (!item)
+ return FALSE;
+
+ // TODO
+ return FALSE;
+}
-void wxMenu::Append( int id, const wxString &text, wxMenu *subMenu, const wxString &helpStr )
+bool wxMenuBar::Enabled(int id) const
{
- wxMenuItem *mitem = new wxMenuItem();
- mitem->SetId(id);
- mitem->SetText(text);
- mitem->SetHelpString(helpStr);
- mitem->SetSubMenu(subMenu);
+ wxMenu *itemMenu = NULL;
+ wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+ if (!item)
+ return FALSE;
+
+ // TODO
+ return FALSE ;
+}
- m_items.Append( mitem );
-};
-int wxMenu::FindItem( const wxString itemString ) const
+void wxMenuBar::SetLabel(int id, const wxString& label)
{
- wxString s( itemString );
+ wxMenu *itemMenu = NULL;
+ wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+
+ if (!item)
+ return;
- int pos;
- do {
- pos = s.First( '&' );
- if (pos != -1) s.Remove( pos, 1 );
- } while (pos != -1);
+ // TODO
+}
- wxNode *node = m_items.First();
- while (node)
- {
- wxMenuItem *item = (wxMenuItem*)node->Data();
- if (item->GetText() == s)
- return item->GetId();
- node = node->Next();
- };
+wxString wxMenuBar::GetLabel(int id) const
+{
+ wxMenu *itemMenu = NULL;
+ wxMenuItem *item = FindItemForId(id, &itemMenu) ;
- return -1;
-};
+ if (!item)
+ return wxString("");
-void wxMenu::Enable( int id, bool enable )
+ // TODO
+ return wxString("") ;
+}
+
+void wxMenuBar::SetLabelTop(int pos, const wxString& label)
{
- wxMenuItem *item = FindItem(id);
- if ( item )
- item->Enable(enable);
-};
+ // TODO
+}
-bool wxMenu::IsEnabled( int id ) const
+wxString wxMenuBar::GetLabelTop(int pos) const
{
- wxMenuItem *item = FindItem(id);
- if ( item )
- return item->IsEnabled();
- else
- return FALSE;
-};
+ // TODO
+ return wxString("");
+}
-void wxMenu::Check( int id, bool enable )
+bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
{
- wxMenuItem *item = FindItem(id);
- if ( item )
- item->Check(enable);
-};
+ // TODO
+ return FALSE;
+}
-bool wxMenu::IsChecked( int id ) const
+bool wxMenuBar::OnAppend(wxMenu *a_menu, const char *title)
{
- wxMenuItem *item = FindItem(id);
- if ( item )
- return item->IsChecked();
- else
+ // TODO
return FALSE;
-};
+}
-void wxMenu::SetLabel( int id, const wxString &label )
+void wxMenuBar::Append (wxMenu * menu, const wxString& title)
{
- wxMenuItem *item = FindItem(id);
- if ( item )
- item->SetText(label);
-};
+ if (!OnAppend(menu, title))
+ return;
+
+ m_menuCount ++;
+ wxMenu **new_menus = new wxMenu *[m_menuCount];
+ wxString *new_titles = new wxString[m_menuCount];
+ int i;
+
+ for (i = 0; i < m_menuCount - 1; i++)
+ {
+ new_menus[i] = m_menus[i];
+ m_menus[i] = NULL;
+ new_titles[i] = m_titles[i];
+ m_titles[i] = "";
+ }
+ if (m_menus)
+ {
+ delete[]m_menus;
+ delete[]m_titles;
+ }
+ m_menus = new_menus;
+ m_titles = new_titles;
+
+ m_menus[m_menuCount - 1] = (wxMenu *)menu;
+ m_titles[m_menuCount - 1] = title;
+
+ // TODO
+}
-wxMenuItem *wxMenu::FindItem(int id) const
+void wxMenuBar::Delete(wxMenu * menu, int i)
{
- wxNode *node = m_items.First();
- while (node) {
- wxMenuItem *item = (wxMenuItem*)node->Data();
- if ( item->GetId() == id )
- return item;
- node = node->Next();
- };
+ int j;
+ int ii = (int) i;
+
+ if (menu != 0)
+ {
+ for (ii = 0; ii < m_menuCount; ii++)
+ {
+ if (m_menus[ii] == menu)
+ break;
+ }
+ if (ii >= m_menuCount)
+ return;
+ } else
+ {
+ if (ii < 0 || ii >= m_menuCount)
+ return;
+ menu = m_menus[ii];
+ }
+
+ if (!OnDelete(menu, ii))
+ return;
+
+ menu->SetParent(NULL);
+
+ -- m_menuCount;
+ for (j = ii; j < m_menuCount; j++)
+ {
+ m_menus[j] = m_menus[j + 1];
+ m_titles[j] = m_titles[j + 1];
+ }
+}
- wxLogDebug("wxMenu::FindItem: item %d not found.", id);
+// Find the menu menuString, item itemString, and return the item id.
+// Returns -1 if none found.
+int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
+{
+ char buf1[200];
+ char buf2[200];
+ wxStripMenuCodes ((char *)(const char *)menuString, buf1);
+ int i;
+ for (i = 0; i < m_menuCount; i++)
+ {
+ wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
+ if (strcmp (buf1, buf2) == 0)
+ return m_menus[i]->FindItem (itemString);
+ }
+ return -1;
+}
- return NULL;
+wxMenuItem *wxMenuBar::FindItemForId (int Id, wxMenu ** itemMenu) const
+{
+ if (itemMenu)
+ *itemMenu = NULL;
+
+ wxMenuItem *item = NULL;
+ int i;
+ for (i = 0; i < m_menuCount; i++)
+ if ((item = m_menus[i]->FindItemForId (Id, itemMenu)))
+ return item;
+ return NULL;
}
-void wxMenu::SetInvokingWindow( wxWindow *win )
+void wxMenuBar::SetHelpString (int Id, const wxString& helpString)
{
- m_invokingWindow = win;
-};
+ int i;
+ for (i = 0; i < m_menuCount; i++)
+ {
+ if (m_menus[i]->FindItemForId (Id))
+ {
+ m_menus[i]->SetHelpString (Id, helpString);
+ return;
+ }
+ }
+}
-wxWindow *wxMenu::GetInvokingWindow()
+wxString wxMenuBar::GetHelpString (int Id) const
{
- return m_invokingWindow;
-};
+ int i;
+ for (i = 0; i < m_menuCount; i++)
+ {
+ if (m_menus[i]->FindItemForId (Id))
+ eturn wxString(m_menus[i]->GetHelpString (Id));
+ }
+ return wxString("");
+}
-/////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
// Name: notebook.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: implementation of wxNotebook
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "notebook.h"
#endif
-#include "wx/notebook.h"
-#include "wx/panel.h"
-#include "wx/utils.h"
-#include "wx/imaglist.h"
-#include "wx/log.h"
-
-//-----------------------------------------------------------------------------
-// wxNotebookPage
-//-----------------------------------------------------------------------------
-
-class wxNotebookPage: public wxObject
-{
-public:
- wxNotebookPage()
- {
- m_id = -1;
- m_text = "";
- m_image = -1;
- m_page = NULL;
- m_client = NULL;
- m_parent = NULL;
- };
-
-//private:
- int m_id;
- wxString m_text;
- int m_image;
- wxWindow *m_client;
-};
-
-//-----------------------------------------------------------------------------
-// wxNotebook
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxControl)
+#include <wx/string.h>
+#include <wx/log.h>
+#include <wx/imaglist.h>
+#include <wx/notebook.h>
+
+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------
+
+// check that the page index is valid
+#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
+
+// ----------------------------------------------------------------------------
+// event table
+// ----------------------------------------------------------------------------
+
+#if !USE_SHARED_LIBRARIES
+BEGIN_EVENT_TABLE(wxNotebook, wxControl)
+ EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
+
+ EVT_SIZE(wxNotebook::OnSize)
+ EVT_SET_FOCUS(wxNotebook::OnSetFocus)
+ EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
+END_EVENT_TABLE()
+
+IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
+#endif
+
+// ============================================================================
+// implementation
+// ============================================================================
+// ----------------------------------------------------------------------------
+// wxNotebook construction
+// ----------------------------------------------------------------------------
+
+// common part of all ctors
void wxNotebook::Init()
{
- m_imageList = NULL;
- m_pages.DeleteContents( TRUE );
+ m_pImageList = NULL;
+ m_nSelection = -1;
}
+// default for dynamic class
wxNotebook::wxNotebook()
{
- Init();
-};
+ Init();
+}
-wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name )
+// the same arguments as for wxControl
+wxNotebook::wxNotebook(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
- Init();
- Create( parent, id, pos, size, style, name );
-};
+ Init();
-wxNotebook::~wxNotebook()
-{
- DeleteAllPages();
-};
+ Create(parent, id, pos, size, style, name);
+}
-bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name )
+// Create() function
+bool wxNotebook::Create(wxWindow *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
- PreCreation( parent, id, pos, size, style, name );
+ // base init
+ SetName(name);
+ SetParent(parent);
- PostCreation();
+ m_windowId = id == -1 ? NewControlId() : id;
- Show( TRUE );
+ // colors and font
+ m_backgroundColour = wxColour(GetSysColor(COLOR_BTNFACE));
+ m_foregroundColour = *wxBLACK ;
- return TRUE;
-};
+ // style
+ m_windowStyle = style;
+
+ if ( parent != NULL )
+ parent->AddChild(this);
+
+ // TODO
+
+ return FALSE;
+}
-int wxNotebook::GetSelection() const
+// dtor
+wxNotebook::~wxNotebook()
{
-};
+}
+// ----------------------------------------------------------------------------
+// wxNotebook accessors
+// ----------------------------------------------------------------------------
int wxNotebook::GetPageCount() const
{
-};
+ return m_aPages.Count();
+}
int wxNotebook::GetRowCount() const
{
-};
+ // TODO
+ return 0;
+}
-wxString wxNotebook::GetPageText( int page ) const
+int wxNotebook::SetSelection(int nPage)
{
-};
+ wxASSERT( IS_VALID_PAGE(nPage) );
-int wxNotebook::GetPageImage( int page ) const
-{
-};
+ ChangePage(m_nSelection, nPage);
-wxNotebookPage* wxNotebook::GetNotebookPage(int page) const
+ // TODO
+ return 0;
+}
+
+void wxNotebook::AdvanceSelection(bool bForward)
{
- return NULL;
-};
+ int nSel = GetSelection();
+ int nMax = GetPageCount() - 1;
+ if ( bForward )
+ SetSelection(nSel == nMax ? 0 : nSel + 1);
+ else
+ SetSelection(nSel == 0 ? nMax : nSel - 1);
+}
-int wxNotebook::SetSelection( int page )
+bool wxNotebook::SetPageText(int nPage, const wxString& strText)
{
-};
+ wxASSERT( IS_VALID_PAGE(nPage) );
-void wxNotebook::AdvanceSelection(bool bForward)
+ // TODO
+ return FALSE;
+}
+
+wxString wxNotebook::GetPageText(int nPage) const
{
+ wxASSERT( IS_VALID_PAGE(nPage) );
+
+ // TODO
+ return wxString("");
}
-void wxNotebook::SetImageList( wxImageList* imageList )
+int wxNotebook::GetPageImage(int nPage) const
{
- m_imageList = imageList;
-};
+ wxASSERT( IS_VALID_PAGE(nPage) );
-bool wxNotebook::SetPageText( int page, const wxString &text )
+ // TODO
+ return 0;
+}
+
+bool wxNotebook::SetPageImage(int nPage, int nImage)
{
- return TRUE;
-};
+ wxASSERT( IS_VALID_PAGE(nPage) );
+
+ // TODO
+ return FALSE;
+}
+
+void wxNotebook::SetImageList(wxImageList* imageList)
+{
+ m_pImageList = imageList;
+ // TODO
+}
+
+// ----------------------------------------------------------------------------
+// wxNotebook operations
+// ----------------------------------------------------------------------------
-bool wxNotebook::SetPageImage( int page, int image )
+// remove one page from the notebook
+bool wxNotebook::DeletePage(int nPage)
{
- return TRUE;
-};
+ wxCHECK( IS_VALID_PAGE(nPage), FALSE );
+
+ // TODO: delete native widget page
+
+ delete m_aPages[nPage];
+ m_aPages.Remove(nPage);
+
+ return TRUE;
+}
-void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
+// remove all pages
+bool wxNotebook::DeleteAllPages()
{
-};
+ // TODO: delete native widget pages
+
+ int nPageCount = GetPageCount();
+ int nPage;
+ for ( nPage = 0; nPage < nPageCount; nPage++ )
+ delete m_aPages[nPage];
-void wxNotebook::SetPadding( const wxSize &WXUNUSED(padding) )
+ m_aPages.Clear();
+
+ return TRUE;
+}
+
+// add a page to the notebook
+bool wxNotebook::AddPage(wxNotebookPage *pPage,
+ const wxString& strText,
+ bool bSelect,
+ int imageId)
{
-};
+ return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId);
+}
-bool wxNotebook::DeleteAllPages()
+// same as AddPage() but does it at given position
+bool wxNotebook::InsertPage(int nPage,
+ wxNotebookPage *pPage,
+ const wxString& strText,
+ bool bSelect,
+ int imageId)
{
- return TRUE;
-};
+ wxASSERT( pPage != NULL );
+ wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE );
+
+ // TODO: insert native widget page
+
+ // save the pointer to the page
+ m_aPages.Insert(pPage, nPage);
+
+ // some page must be selected: either this one or the first one if there is
+ // still no selection
+ if ( bSelect )
+ m_nSelection = nPage;
+ else if ( m_nSelection == -1 )
+ m_nSelection = 0;
+
+ return TRUE;
+}
+
+// ----------------------------------------------------------------------------
+// wxNotebook callbacks
+// ----------------------------------------------------------------------------
-bool wxNotebook::DeletePage( int page )
+// @@@ OnSize() is used for setting the font when it's called for the first
+// time because doing it in ::Create() doesn't work (for unknown reasons)
+void wxNotebook::OnSize(wxSizeEvent& event)
{
- return TRUE;
-};
+ static bool s_bFirstTime = TRUE;
+ if ( s_bFirstTime ) {
+ // TODO: any first-time-size processing.
+ s_bFirstTime = FALSE;
+ }
+
+ // TODO: all this may or may not be necessary for your platform
+
+ // emulate page change (it's esp. important to do it first time because
+ // otherwise our page would stay invisible)
+ int nSel = m_nSelection;
+ m_nSelection = -1;
+ SetSelection(nSel);
+
+ // fit the notebook page to the tab control's display area
+ int w, hl
+ GetSize(&w, &h);
+
+ uint nCount = m_aPages.Count();
+ for ( uint nPage = 0; nPage < nCount; nPage++ ) {
+ wxNotebookPage *pPage = m_aPages[nPage];
+ pPage->SetSize(0, 0, w, h);
+ if ( pPage->GetAutoLayout() )
+ pPage->Layout();
+ }
+
+ // Processing continues to next OnSize
+ event.Skip();
+}
-bool wxNotebook::AddPage(wxWindow* win, const wxString& text,
- bool bSelect, int imageId)
+void wxNotebook::OnSelChange(wxNotebookEvent& event)
{
- return TRUE;
-};
+ // is it our tab control?
+ if ( event.GetEventObject() == this )
+ ChangePage(event.GetOldSelection(), event.GetSelection());
+
+ // we want to give others a chance to process this message as well
+ event.Skip();
+}
-wxWindow *wxNotebook::GetPage( int page ) const
+void wxNotebook::OnSetFocus(wxFocusEvent& event)
{
- return NULL;
-};
+ // set focus to the currently selected page if any
+ if ( m_nSelection != -1 )
+ m_aPages[m_nSelection]->SetFocus();
+
+ event.Skip();
+}
-void wxNotebook::AddChild( wxWindow *win )
+void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
{
-};
+ if ( event.IsWindowChange() ) {
+ // change pages
+ AdvanceSelection(event.GetDirection());
+ }
+ else {
+ // pass to the parent
+ if ( GetParent() ) {
+ event.SetCurrentFocus(this);
+ GetParent()->ProcessEvent(event);
+ }
+ }
+}
+
+// ----------------------------------------------------------------------------
+// wxNotebook base class virtuals
+// ----------------------------------------------------------------------------
// override these 2 functions to do nothing: everything is done in OnSize
-void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
+
+void wxNotebook::SetConstraintSizes(bool /* recurse */)
+{
+ // don't set the sizes of the pages - their correct size is not yet known
+ wxControl::SetConstraintSizes(FALSE);
+}
+
+bool wxNotebook::DoPhase(int /* nPhase */)
{
- // don't set the sizes of the pages - their correct size is not yet known
- wxControl::SetConstraintSizes(FALSE);
+ return TRUE;
}
-bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
+void wxNotebook::Command(wxCommandEvent& event)
{
- return TRUE;
+ wxFAIL_MSG("wxNotebook::Command not implemented");
}
-//-----------------------------------------------------------------------------
-// wxNotebookEvent
-//-----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxNotebook helper functions
+// ----------------------------------------------------------------------------
+
+// hide the currently active panel and show the new one
+void wxNotebook::ChangePage(int nOldSel, int nSel)
+{
+ wxASSERT( nOldSel != nSel ); // impossible
+
+ if ( nOldSel != -1 ) {
+ m_aPages[nOldSel]->Show(FALSE);
+ }
+
+ wxNotebookPage *pPage = m_aPages[nSel];
+ pPage->Show(TRUE);
+ pPage->SetFocus();
+
+ m_nSelection = nSel;
+}
-IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
/////////////////////////////////////////////////////////////////////////////
// Name: palette.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxPalette
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "palette.h"
#endif
#include "wx/palette.h"
-//-----------------------------------------------------------------------------
-// wxPalette
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
+#endif
-class wxPaletteRefData: public wxObjectRefData
-{
- public:
-
- wxPaletteRefData(void);
- ~wxPaletteRefData(void);
-
-};
-
-wxPaletteRefData::wxPaletteRefData(void)
-{
-};
+/*
+ * Palette
+ *
+ */
-wxPaletteRefData::~wxPaletteRefData(void)
+wxPaletteRefData::wxPaletteRefData()
{
-};
+ // TODO
+}
-//-----------------------------------------------------------------------------
-
-#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
-
-IMPLEMENT_DYNAMIC_CLASS(wxPalette,wxGDIObject)
+wxPaletteRefData::~wxPaletteRefData()
+{
+ // TODO
+}
-wxPalette::wxPalette(void)
+wxPalette::wxPalette()
{
-};
+}
-wxPalette::wxPalette( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue )
+wxPalette::wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
- m_refData = new wxPaletteRefData();
- Create( n, red, green, blue );
-};
+ Create(n, red, green, blue);
+}
-wxPalette::wxPalette( const wxPalette& palette )
+wxPalette::~wxPalette()
{
- Ref( palette );
-};
+}
-wxPalette::wxPalette( const wxPalette* palette )
+bool wxPalette::FreeResource(bool force)
+{
+ if ( M_PALETTEDATA && M_PALETTEDATA->m_hPalette)
+ {
+ DeleteObject((HPALETTE)M_PALETTEDATA->m_hPalette);
+ }
+ return TRUE;
+}
+
+bool wxPalette::Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
UnRef();
- if (palette) Ref( *palette );
-};
-wxPalette::~wxPalette(void)
-{
-};
+ m_refData = new wxPaletteRefData;
-wxPalette& wxPalette::operator = ( const wxPalette& palette )
-{
- if (*this == palette) return (*this);
- Ref( palette );
- return *this;
-};
+ // TODO
-bool wxPalette::operator == ( const wxPalette& palette )
-{
- return m_refData == palette.m_refData;
-};
+ return FALSE;
+}
-bool wxPalette::operator != ( const wxPalette& palette )
+int wxPalette::GetPixel(const unsigned char red, const unsigned char green, const unsigned char blue) const
{
- return m_refData != palette.m_refData;
-};
+ if ( !m_refData )
+ return FALSE;
-bool wxPalette::Ok(void) const
-{
- return (m_refData);
-};
+ // TODO
+ return FALSE;
+}
-bool wxPalette::Create( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
+bool wxPalette::GetRGB(int index, unsigned char *red, unsigned char *green, unsigned char *blue) const
{
-};
+ if ( !m_refData )
+ return FALSE;
-int wxPalette::GetPixel( const unsigned char red, const unsigned char green, const unsigned char blue ) const
-{
-};
+ if (index < 0 || index > 255)
+ return FALSE;
+
+ // TODO
+ return FALSE;
+}
-bool wxPalette::GetRGB( int pixel, unsigned char *red, unsigned char *green, unsigned char *blue ) const
-{
-};
/////////////////////////////////////////////////////////////////////////////
// Name: pen.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxPen
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "pen.h"
#endif
+#include "wx/setup.h"
+#include "wx/utils.h"
#include "wx/pen.h"
-//-----------------------------------------------------------------------------
-// wxPen
-//-----------------------------------------------------------------------------
-
-class wxPenRefData: public wxObjectRefData
-{
- public:
-
- wxPenRefData(void);
-
- int m_width;
- int m_style;
- int m_joinStyle;
- int m_capStyle;
- wxColour m_colour;
-};
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
+#endif
-wxPenRefData::wxPenRefData(void)
+wxPenRefData::wxPenRefData()
{
- m_width = 1;
- m_style = wxSOLID;
- m_joinStyle = wxJOIN_ROUND;
- m_capStyle = wxCAP_ROUND;
-};
+ m_style = wxSOLID;
+ m_width = 1;
+ m_join = wxJOIN_ROUND ;
+ m_cap = wxCAP_ROUND ;
+ m_nbDash = 0 ;
+ m_dash = 0 ;
+/* TODO: null data
+ m_hPen = 0;
+*/
+}
-//-----------------------------------------------------------------------------
+wxPenRefData::wxPenRefData(const wxPenRefData& data)
+{
+ m_style = data.m_style;
+ m_width = data.m_width;
+ m_join = data.m_join;
+ m_cap = data.m_cap;
+ m_nbDash = data.m_nbDash;
+ m_dash = data.m_dash;
+ m_colour = data.m_colour;
+/* TODO: null data
+ m_hPen = 0;
+*/
+}
-#define M_PENDATA ((wxPenRefData *)m_refData)
+wxPenRefData::~wxPenRefData()
+{
+ // TODO: delete data
+}
-IMPLEMENT_DYNAMIC_CLASS(wxPen,wxGDIObject)
+// Pens
-wxPen::wxPen(void)
+wxPen::wxPen()
{
- if (wxThePenList) wxThePenList->AddPen( this );
-};
+ if ( wxThePenList )
+ wxThePenList->AddPen(this);
+}
-wxPen::wxPen( const wxColour &colour, int width, int style )
+wxPen::~wxPen()
{
- m_refData = new wxPenRefData();
- M_PENDATA->m_width = width;
- M_PENDATA->m_style = style;
- M_PENDATA->m_colour = colour;
- if (wxThePenList) wxThePenList->AddPen( this );
-};
+ if (wxThePenList)
+ wxThePenList->RemovePen(this);
+}
-wxPen::wxPen( const wxString &colourName, int width, int style )
+// Should implement Create
+wxPen::wxPen(const wxColour& col, int Width, int Style)
{
- m_refData = new wxPenRefData();
- M_PENDATA->m_width = width;
- M_PENDATA->m_style = style;
- M_PENDATA->m_colour = colourName;
- if (wxThePenList) wxThePenList->AddPen( this );
-};
+ m_refData = new wxPenRefData;
-wxPen::wxPen( const wxPen& pen )
-{
- Ref( pen );
- if (wxThePenList) wxThePenList->AddPen( this );
-};
+ M_PENDATA->m_colour = col;
+ M_PENDATA->m_width = Width;
+ M_PENDATA->m_style = Style;
+ M_PENDATA->m_join = wxJOIN_ROUND ;
+ M_PENDATA->m_cap = wxCAP_ROUND ;
+ M_PENDATA->m_nbDash = 0 ;
+ M_PENDATA->m_dash = 0 ;
-wxPen::wxPen( const wxPen* pen )
-{
- UnRef();
- if (pen) Ref( *pen );
- if (wxThePenList) wxThePenList->AddPen( this );
-};
+ RealizeResource();
-wxPen::~wxPen(void)
-{
- if (wxThePenList) wxThePenList->RemovePen( this );
-};
+ if ( wxThePenList )
+ wxThePenList->AddPen(this);
+}
-wxPen& wxPen::operator = ( const wxPen& pen )
+wxPen::wxPen(const wxBitmap& stipple, int Width)
{
- if (*this == pen) return (*this);
- Ref( pen );
- return *this;
-};
+ m_refData = new wxPenRefData;
+
+ M_PENDATA->m_stipple = stipple;
+ M_PENDATA->m_width = Width;
+ M_PENDATA->m_style = wxSTIPPLE;
+ M_PENDATA->m_join = wxJOIN_ROUND ;
+ M_PENDATA->m_cap = wxCAP_ROUND ;
+ M_PENDATA->m_nbDash = 0 ;
+ M_PENDATA->m_dash = 0 ;
-bool wxPen::operator == ( const wxPen& pen )
+ RealizeResource();
+
+ if ( wxThePenList )
+ wxThePenList->AddPen(this);
+}
+
+wxPen::wxPen(const wxString& col, int Width, int Style)
{
- return m_refData == pen.m_refData;
-};
+ m_refData = new wxPenRefData;
+
+ M_PENDATA->m_colour = col;
+ M_PENDATA->m_width = Width;
+ M_PENDATA->m_style = Style;
+ M_PENDATA->m_join = wxJOIN_ROUND ;
+ M_PENDATA->m_cap = wxCAP_ROUND ;
+ M_PENDATA->m_nbDash = 0 ;
+ M_PENDATA->m_dash = 0 ;
-bool wxPen::operator != ( const wxPen& pen )
+ RealizeResource();
+
+ if ( wxThePenList )
+ wxThePenList->AddPen(this);
+}
+
+void wxPen::Unshare()
{
- return m_refData != pen.m_refData;
-};
+ // Don't change shared data
+ if (!m_refData)
+ {
+ m_refData = new wxPenRefData();
+ }
+ else
+ {
+ wxPenRefData* ref = new wxPenRefData(*(wxPenRefData*)m_refData);
+ UnRef();
+ m_refData = ref;
+ }
+}
-void wxPen::SetColour( const wxColour &colour )
+void wxPen::SetColour(const wxColour& col)
{
- if (!m_refData)
- m_refData = new wxPenRefData();
+ Unshare();
- M_PENDATA->m_colour = colour;
-};
+ M_PENDATA->m_colour = col;
+
+ RealizeResource();
+}
-void wxPen::SetColour( const wxString &colourName )
+void wxPen::SetColour(const wxString& col)
{
- if (!m_refData)
- m_refData = new wxPenRefData();
+ Unshare();
- M_PENDATA->m_colour = colourName;
-};
+ M_PENDATA->m_colour = col;
+
+ RealizeResource();
+}
-void wxPen::SetColour( int red, int green, int blue )
+void wxPen::SetColour(const unsigned char r, const unsigned char g, const unsigned char b)
{
- if (!m_refData)
- m_refData = new wxPenRefData();
+ Unshare();
- M_PENDATA->m_colour.Set( red, green, blue );
-};
+ M_PENDATA->m_colour.Set(r, g, b);
+
+ RealizeResource();
+}
-void wxPen::SetCap( int capStyle )
+void wxPen::SetWidth(int Width)
{
- if (!m_refData)
- m_refData = new wxPenRefData();
+ Unshare();
+
+ M_PENDATA->m_width = Width;
- M_PENDATA->m_capStyle = capStyle;
-};
+ RealizeResource();
+}
-void wxPen::SetJoin( int joinStyle )
+void wxPen::SetStyle(int Style)
{
- if (!m_refData)
- m_refData = new wxPenRefData();
+ Unshare();
+
+ M_PENDATA->m_style = Style;
- M_PENDATA->m_joinStyle = joinStyle;
-};
+ RealizeResource();
+}
-void wxPen::SetStyle( int style )
+void wxPen::SetStipple(const wxBitmap& Stipple)
{
- if (!m_refData)
- m_refData = new wxPenRefData();
+ Unshare();
- M_PENDATA->m_style = style;
-};
+ M_PENDATA->m_stipple = Stipple;
+ M_PENDATA->m_style = wxSTIPPLE;
+
+ RealizeResource();
+}
-void wxPen::SetWidth( int width )
+void wxPen::SetDashes(int nb_dashes, const wxDash *Dash)
{
- if (!m_refData)
- m_refData = new wxPenRefData();
+ Unshare();
- M_PENDATA->m_width = width;
-};
+ M_PENDATA->m_nbDash = nb_dashes;
+ M_PENDATA->m_dash = (wxDash *)Dash;
+
+ RealizeResource();
+}
-int wxPen::GetCap(void) const
+void wxPen::SetJoin(int Join)
{
- return M_PENDATA->m_capStyle;
-};
+ Unshare();
-int wxPen::GetJoin(void) const
-{
- if (!m_refData)
- return 0;
- else
- return M_PENDATA->m_joinStyle;
-};
+ M_PENDATA->m_join = Join;
-int wxPen::GetStyle(void) const
-{
- if (!m_refData)
- return 0;
- else
- return M_PENDATA->m_style;
-};
+ RealizeResource();
+}
-int wxPen::GetWidth(void) const
+void wxPen::SetCap(int Cap)
{
- if (!m_refData)
- return 0;
- else
- return M_PENDATA->m_width;
-};
+ Unshare();
-wxColour &wxPen::GetColour(void) const
-{
- if (!m_refData)
- return wxNullColour;
- else
- return M_PENDATA->m_colour;
-};
+ M_PENDATA->m_cap = Cap;
+
+ RealizeResource();
+}
-bool wxPen::Ok(void) const
+bool wxPen::RealizeResource()
{
- return (m_refData);
-};
+ // TODO: create actual pen
+ return FALSE;
+}
+
/////////////////////////////////////////////////////////////////////////////
// Name: radiobox.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxRadioBox
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "radiobox.h"
#endif
#include "wx/radiobox.h"
-#include "wx/dialog.h"
-#include "wx/frame.h"
-//-----------------------------------------------------------------------------
-// data
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
+#endif
+
+// Radio box item
+wxRadioBox::wxRadioBox()
+{
+ m_selectedButton = -1;
+ m_noItems = 0;
+ m_noRowsOrCols = 0;
+ m_majorDim = 0 ;
+}
+
+bool wxRadioBox::Create(wxWindow *parent, wxWindowID id, const wxString& title,
+ const wxPoint& pos, const wxSize& size,
+ int n, const wxString choices[],
+ int majorDim, long style,
+ const wxValidator& val, const wxString& name)
+{
+ m_selectedButton = -1;
+ m_noItems = n;
+
+ SetName(name);
+ SetValidator(val);
-extern bool g_blockEventsOnDrag;
+ parent->AddChild(this);
-//-----------------------------------------------------------------------------
+ m_windowStyle = (long&)style;
-IMPLEMENT_DYNAMIC_CLASS(wxRadioBox,wxControl)
+ if (id == -1)
+ m_windowId = NewControlId();
+ else
+ m_windowId = id;
-wxRadioBox::wxRadioBox(void)
-{
-};
+ m_noRowsOrCols = majorDim;
-wxRadioBox::wxRadioBox( wxWindow *parent, wxWindowID id, const wxString& title,
- const wxPoint &pos, const wxSize &size,
- int n, const wxString choices[],
- int majorDim, long style,
- const wxString &name )
+ if (majorDim==0)
+ m_majorDim = n ;
+ else
+ m_majorDim = majorDim ;
+
+
+ // TODO create radiobox
+ return FALSE;
+}
+
+
+wxRadioBox::~wxRadioBox()
{
- Create( parent, id, title, pos, size, n, choices, majorDim, style, name );
-};
+ // TODO
+}
-bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
- const wxPoint &pos, const wxSize &size,
- int n, const wxString choices[],
- int WXUNUSED(majorDim), long style,
- const wxString &name )
+wxString wxRadioBox::GetLabel(int item) const
{
- return TRUE;
-};
+ // TODO
+ return wxString("");
+}
-bool wxRadioBox::Show( bool show )
+void wxRadioBox::SetLabel(int item, const wxString& label)
{
- wxWindow::Show( show );
- return TRUE;
-};
+ // TODO
+}
-int wxRadioBox::FindString( const wxString &s ) const
+int wxRadioBox::FindString(const wxString& s) const
{
- return -1;
-};
+ // TODO
+ return -1;
+}
-void wxRadioBox::SetSelection( int n )
+void wxRadioBox::SetSelection(int n)
{
-};
+ if ((n < 0) || (n >= m_noItems))
+ return;
+ // TODO
-int wxRadioBox::GetSelection(void) const
+ m_selectedButton = n;
+}
+
+// Get single selection, for single choice list items
+int wxRadioBox::GetSelection() const
{
- return -1;
-};
+ return m_selectedButton;
+}
-wxString wxRadioBox::GetString( int n ) const
+// Find string for position
+wxString wxRadioBox::GetString(int n) const
{
-};
+ // TODO
+ return wxString("");
+}
-wxString wxRadioBox::GetLabel(void) const
+void wxRadioBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
- return wxControl::GetLabel();
-};
+ // TODO
+}
-void wxRadioBox::SetLabel( const wxString& WXUNUSED(label) )
+void wxRadioBox::GetSize(int *width, int *height) const
{
-};
+ // TODO
+}
-void wxRadioBox::SetLabel( int WXUNUSED(item), const wxString& WXUNUSED(label) )
+void wxRadioBox::GetPosition(int *x, int *y) const
{
-};
+ // TODO
+}
-void wxRadioBox::SetLabel( int WXUNUSED(item), wxBitmap *WXUNUSED(bitmap) )
+wxString wxRadioBox::GetLabel() const
{
-};
+ // TODO
+ return wxString("");
+}
-wxString wxRadioBox::GetLabel( int WXUNUSED(item) ) const
+void wxRadioBox::SetLabel(const wxString& label)
{
- return "";
-};
+ // TODO
+}
-void wxRadioBox::Enable( bool WXUNUSED(enable) )
+void wxRadioBox::SetFocus()
{
-};
+ // TODO
+}
-void wxRadioBox::Enable( int WXUNUSED(item), bool WXUNUSED(enable) )
+bool wxRadioBox::Show(bool show)
{
-};
+ // TODO
+ return FALSE;
+}
-void wxRadioBox::Show( int WXUNUSED(item), bool WXUNUSED(show) )
+// Enable a specific button
+void wxRadioBox::Enable(int item, bool enable)
{
-};
+ // TODO
+}
-wxString wxRadioBox::GetStringSelection(void) const
+// Enable all controls
+void wxRadioBox::Enable(bool enable)
{
- return "";
-};
+ wxControl::Enable(enable);
+
+ // TODO
+}
-bool wxRadioBox::SetStringSelection( const wxString&s )
+// Show a specific button
+void wxRadioBox::Show(int item, bool show)
{
- return TRUE;
-};
+ // TODO
+}
-int wxRadioBox::Number(void) const
+// For single selection items only
+wxString wxRadioBox::GetStringSelection () const
{
- return 0;
-};
+ int sel = GetSelection ();
+ if (sel > -1)
+ return this->GetString (sel);
+ else
+ return wxString("");
+}
-int wxRadioBox::GetNumberOfRowsOrCols(void) const
+bool wxRadioBox::SetStringSelection (const wxString& s)
{
- return 1;
-};
+ int sel = FindString (s);
+ if (sel > -1)
+ {
+ SetSelection (sel);
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
-void wxRadioBox::SetNumberOfRowsOrCols( int WXUNUSED(n) )
+void wxRadioBox::Command (wxCommandEvent & event)
{
-};
+ SetSelection (event.m_commandInt);
+ ProcessCommand (event);
+}
+
/////////////////////////////////////////////////////////////////////////////
// Name: radiobut.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxRadioButton
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "radiobut.h"
#endif
#include "wx/radiobut.h"
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxRadioButton, wxControl)
+#endif
+
+bool wxRadioButton::Create(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator,
+ const wxString& name)
+{
+ SetName(name);
+ SetValidator(validator);
+
+ if (parent) parent->AddChild(this);
+
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
+
+ m_windowStyle = style ;
+
+ // TODO create radiobutton
+ return FALSE;
+}
+
+void wxRadioButton::SetLabel(const wxString& label)
+{
+ // TODO
+}
+
+void wxRadioButton::SetValue(bool value)
+{
+ // TODO
+}
+
+// Get single selection, for single choice list items
+bool wxRadioButton::GetValue() const
+{
+ // TODO
+ return FALSE;
+}
+
+void wxRadioButton::Command (wxCommandEvent & event)
+{
+ SetValue ( (event.m_commandInt != 0) );
+ ProcessCommand (event);
+}
+
+
/////////////////////////////////////////////////////////////////////////////
-// Name: region.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/98
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// File: region.cpp
+// Purpose: Region class
+// Author: Markus Holzem/Julian Smart/AUTHOR
+// Created: Fri Oct 24 10:46:34 MET 1997
+// RCS-ID: $Id$
+// Copyright: (c) 1997 Markus Holzem/Julian Smart/AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "region.h"
#endif
-#include "wx/region.h"
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "wx/msw/region.h"
+#include "wx/gdicmn.h"
+
+#include <windows.h>
+
+#if !USE_SHARED_LIBRARY
+ IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
+ IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
+#endif
//-----------------------------------------------------------------------------
-// wxRegion
+// wxRegionRefData implementation
//-----------------------------------------------------------------------------
-class wxRegionRefData: public wxObjectRefData
-{
- public:
-
- wxRegionRefData(void);
- ~wxRegionRefData(void);
-
- public:
+class WXDLLEXPORT wxRegionRefData : public wxGDIRefData {
+public:
+ wxRegionRefData()
+ {
+ }
-};
+ wxRegionRefData(const wxRegionRefData& data)
+ {
+ // TODO
+ }
-wxRegionRefData::wxRegionRefData(void)
-{
-};
+ ~wxRegionRefData()
+ {
+ // TODO
+ }
-wxRegionRefData::~wxRegionRefData(void)
-{
+ HRGN m_region;
};
-//-----------------------------------------------------------------------------
-#define M_REGIONDATA ((wxRegionRefData *)m_refData)
+//-----------------------------------------------------------------------------
+// wxRegion
+//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxRegion,wxGDIObject);
-
-wxRegion::wxRegion( long x, long y, long w, long h )
+/*!
+ * Create an empty region.
+ */
+wxRegion::wxRegion()
{
- m_refData = new wxRegionRefData();
-};
+ m_refData = new wxRegionRefData;
+ // TODO create empty region
+}
-wxRegion::wxRegion( const wxPoint& topLeft, const wxPoint& bottomRight )
+wxRegion::wxRegion(long x, long y, long w, long h)
{
- m_refData = new wxRegionRefData();
-};
+ m_refData = new wxRegionRefData;
+ // TODO create rect region
+}
-wxRegion::wxRegion( const wxRect& rect )
+wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
{
- m_refData = new wxRegionRefData();
-};
+ m_refData = new wxRegionRefData;
+ // TODO create rect region
+}
-wxRegion::wxRegion(void)
+wxRegion::wxRegion(const wxRect& rect)
{
- m_refData = new wxRegionRefData();
-};
-
-wxRegion::~wxRegion(void)
+ m_refData = new wxRegionRefData;
+ // TODO create rect region
+}
+
+/*!
+ * Destroy the region.
+ */
+wxRegion::~wxRegion()
{
-};
+ // m_refData unrefed in ~wxObject
+}
-void wxRegion::Clear(void)
-{
- UnRef();
- m_refData = new wxRegionRefData();
-};
+//-----------------------------------------------------------------------------
+//# Modify region
+//-----------------------------------------------------------------------------
-bool wxRegion::Union( long x, long y, long width, long height )
+//! Clear current region
+void wxRegion::Clear()
{
- return TRUE;
-};
+ UnRef();
+}
-bool wxRegion::Union( const wxRect& rect )
+//! Combine rectangle (x, y, w, h) with this.
+bool wxRegion::Combine(long x, long y, long width, long height, wxRegionOp op)
{
- return TRUE;
-};
-
-bool wxRegion::Union( const wxRegion& region )
+ // Don't change shared data
+ if (!m_refData) {
+ m_refData = new wxRegionRefData();
+ } else if (m_refData->GetRefCount() > 1) {
+ wxRegionRefData* ref = (wxRegionRefData*)m_refData;
+ UnRef();
+ m_refData = new wxRegionRefData(*ref);
+ }
+ // If ref count is 1, that means it's 'ours' anyway so no action.
+
+ // TODO create rect region
+
+ int mode = 0; // TODO platform-specific code
+ switch (op)
+ {
+ case wxRGN_AND:
+ // TODO
+ break ;
+ case wxRGN_OR:
+ // TODO
+ break ;
+ case wxRGN_XOR:
+ // TODO
+ break ;
+ case wxRGN_DIFF:
+ // TODO
+ break ;
+ case wxRGN_COPY:
+ default:
+ // TODO
+ break ;
+ }
+
+ // TODO do combine region
+
+ return FALSE;
+}
+
+//! Union /e region with this.
+bool wxRegion::Combine(const wxRegion& region, wxRegionOp op)
{
- return TRUE;
-};
-
-bool wxRegion::Intersect( long x, long y, long width, long height )
+ if (region.Empty())
+ return FALSE;
+
+ // Don't change shared data
+ if (!m_refData) {
+ m_refData = new wxRegionRefData();
+ } else if (m_refData->GetRefCount() > 1) {
+ wxRegionRefData* ref = (wxRegionRefData*)m_refData;
+ UnRef();
+ m_refData = new wxRegionRefData(*ref);
+ }
+
+ int mode = 0; // TODO platform-specific code
+ switch (op)
+ {
+ case wxRGN_AND:
+ // TODO
+ break ;
+ case wxRGN_OR:
+ // TODO
+ break ;
+ case wxRGN_XOR:
+ // TODO
+ break ;
+ case wxRGN_DIFF:
+ // TODO
+ break ;
+ case wxRGN_COPY:
+ default:
+ // TODO
+ break ;
+ }
+
+ // TODO combine region
+
+ return FALSE;
+}
+
+bool wxRegion::Combine(const wxRect& rect, wxRegionOp op)
{
- return TRUE;
-};
+ return Combine(rect.GetLeft(), rect.GetTop(), rect.GetWidth(), rect.GetHeight(), op);
+}
-bool wxRegion::Intersect( const wxRect& rect )
-{
- return TRUE;
-};
+//-----------------------------------------------------------------------------
+//# Information on region
+//-----------------------------------------------------------------------------
-bool wxRegion::Intersect( const wxRegion& region )
+// Outer bounds of region
+void wxRegion::GetBox(long& x, long& y, long&w, long &h) const
{
- return TRUE;
-};
-
-bool wxRegion::Subtract( long x, long y, long width, long height )
+ if (m_refData) {
+ // TODO get box
+ } else {
+ x = y = w = h = 0;
+ }
+}
+
+wxRect wxRegion::GetBox() const
{
- return TRUE;
-};
+ long x, y, w, h;
+ GetBox(x, y, w, h);
+ return wxRect(x, y, w, h);
+}
-bool wxRegion::Subtract( const wxRect& rect )
+// Is region empty?
+bool wxRegion::Empty() const
{
- return TRUE;
-};
+ // TODO
+ return FALSE;
+}
-bool wxRegion::Subtract( const wxRegion& region )
-{
- return TRUE;
-};
+//-----------------------------------------------------------------------------
+//# Tests
+//-----------------------------------------------------------------------------
-bool wxRegion::Xor( long x, long y, long width, long height )
+// Does the region contain the point (x,y)?
+wxRegionContain wxRegion::Contains(long x, long y) const
{
- return TRUE;
-};
+ if (!m_refData)
+ return wxOutRegion;
-bool wxRegion::Xor( const wxRect& rect )
+ // TODO. Return wxInRegion if within region.
+ if (0)
+ return wxInRegion;
+ return wxOutRegion;
+}
+
+// Does the region contain the point pt?
+wxRegionContain wxRegion::Contains(const wxPoint& pt) const
{
- return TRUE;
-};
+ if (!m_refData)
+ return wxOutRegion;
+
+ // TODO. Return wxInRegion if within region.
+ if (0)
+ return wxInRegion;
+ else
+ return wxOutRegion;
+}
+
+// Does the region contain the rectangle (x, y, w, h)?
+wxRegionContain wxRegion::Contains(long x, long y, long w, long h) const
+{
+ if (!m_refData)
+ return wxOutRegion;
+
+ // TODO. Return wxInRegion if within region.
+ if (0)
+ return wxInRegion;
+ else
+ return wxOutRegion;
+}
+
+// Does the region contain the rectangle rect
+wxRegionContain wxRegion::Contains(const wxRect& rect) const
+{
+ if (!m_refData)
+ return wxOutRegion;
+
+ long x, y, w, h;
+ x = rect.x;
+ y = rect.y;
+ w = rect.GetWidth();
+ h = rect.GetHeight();
+ return Contains(x, y, w, h);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// //
+// wxRegionIterator //
+// //
+///////////////////////////////////////////////////////////////////////////////
+
+/*!
+ * Initialize empty iterator
+ */
+wxRegionIterator::wxRegionIterator() : m_current(0), m_numRects(0), m_rects(NULL)
+{
+}
-bool wxRegion::Xor( const wxRegion& region )
+wxRegionIterator::~wxRegionIterator()
{
- return TRUE;
-};
+ if (m_rects)
+ delete[] m_rects;
+}
+
+/*!
+ * Initialize iterator for region
+ */
+wxRegionIterator::wxRegionIterator(const wxRegion& region)
+{
+ m_rects = NULL;
+
+ Reset(region);
+}
-void wxRegion::GetBox( long& x, long& y, long&w, long &h ) const
+/*!
+ * Reset iterator for a new /e region.
+ */
+void wxRegionIterator::Reset(const wxRegion& region)
{
- x = 0;
- y = 0;
- w = -1;
- h = -1;
-};
+ m_current = 0;
+ m_region = region;
+
+ if (m_rects)
+ delete[] m_rects;
+
+ m_rects = NULL;
+
+ if (m_region.Empty())
+ m_numRects = 0;
+ else
+ {
+ // TODO create m_rects and fill with rectangles for this region
+ m_numRects = 0;
+ }
+}
+
+/*!
+ * Increment iterator. The rectangle returned is the one after the
+ * incrementation.
+ */
+void wxRegionIterator::operator ++ ()
+{
+ if (m_current < m_numRects)
+ ++m_current;
+}
+
+/*!
+ * Increment iterator. The rectangle returned is the one before the
+ * incrementation.
+ */
+void wxRegionIterator::operator ++ (int)
+{
+ if (m_current < m_numRects)
+ ++m_current;
+}
-wxRect wxRegion::GetBox(void) const
+long wxRegionIterator::GetX() const
{
- return wxRect( 0, 0, -1, -1 );
-};
+ if (m_current < m_numRects)
+ return m_rects[m_current].x;
+ return 0;
+}
-bool wxRegion::Empty(void) const
+long wxRegionIterator::GetY() const
{
-};
+ if (m_current < m_numRects)
+ return m_rects[m_current].y;
+ return 0;
+}
-wxRegionContain wxRegion::Contains( long x, long y ) const
+long wxRegionIterator::GetW() const
{
- return wxOutRegion;
-};
+ if (m_current < m_numRects)
+ return m_rects[m_current].width ;
+ return 0;
+}
-wxRegionContain wxRegion::Contains( long x, long y, long w, long h ) const
+long wxRegionIterator::GetH() const
{
- return wxOutRegion;
-};
+ if (m_current < m_numRects)
+ return m_rects[m_current].height;
+ return 0;
+}
/////////////////////////////////////////////////////////////////////////////
// Name: scrolbar.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxScrollBar
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "scrolbar.h"
#endif
#include "wx/scrolbar.h"
-#include "wx/utils.h"
-
-//-----------------------------------------------------------------------------
-// wxScrollBar
-//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxScrollBar,wxControl)
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
-wxScrollBar::wxScrollBar(wxWindow *parent, wxWindowID id,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name )
-{
- Create( parent, id, pos, size, style, name );
-};
-
-wxScrollBar::~wxScrollBar(void)
-{
-};
+#endif
+// Scrollbar
bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
- const wxPoint& pos, const wxSize& size,
- long style, const wxString& name )
-{
- return TRUE;
-};
-
-int wxScrollBar::GetPosition(void) const
-{
-};
-
-int wxScrollBar::GetThumbSize() const
+ const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator,
+ const wxString& name)
{
-};
+ if (!parent)
+ return FALSE;
+ parent->AddChild(this);
+ SetName(name);
+ SetValidator(validator);
+
+ m_windowStyle = style;
-int wxScrollBar::GetPageSize() const
-{
-};
-
-int wxScrollBar::GetRange() const
-{
-};
-
-void wxScrollBar::SetPosition( int viewStart )
-{
-};
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
-void wxScrollBar::SetScrollbar( int position, int thumbSize, int range, int pageSize,
- bool WXUNUSED(refresh) )
-{
-};
+ // TODO create scrollbar
+ return TRUE;
+}
-// Backward compatibility
-int wxScrollBar::GetValue(void) const
+wxScrollBar::~wxScrollBar()
{
- return GetPosition();
-};
+}
-void wxScrollBar::SetValue( int viewStart )
+void wxScrollBar::SetPosition(int viewStart)
{
- SetPosition( viewStart );
-};
+ // TODO
+}
-void wxScrollBar::GetValues( int *viewStart, int *viewLength, int *objectLength, int *pageLength ) const
+int wxScrollBar::GetPosition() const
{
-};
+ // TODO
+ return 0;
+}
-int wxScrollBar::GetViewLength() const
+void wxScrollBar::SetScrollbar(int position, int thumbSize, int range, int pageSize,
+ bool refresh)
{
-};
+ m_viewSize = pageSize;
+ m_pageSize = thumbSize;
+ m_objectSize = range;
-int wxScrollBar::GetObjectLength() const
-{
-};
+ // TODO
+}
-void wxScrollBar::SetPageSize( int pageLength )
-{
-};
-
-void wxScrollBar::SetObjectLength( int objectLength )
-{
-};
-void wxScrollBar::SetViewLength( int viewLength )
+void wxScrollBar::Command(wxCommandEvent& event)
{
-};
+ SetValue(event.m_commandInt);
+ ProcessCommand(event);
+}
/////////////////////////////////////////////////////////////////////////////
// Name: settings.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxSettings
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "settings.h"
#endif
#include "wx/settings.h"
-/*
-#define wxSYS_COLOUR_SCROLLBAR 0
-#define wxSYS_COLOUR_BACKGROUND 1
-#define wxSYS_COLOUR_ACTIVECAPTION 2
-#define wxSYS_COLOUR_INACTIVECAPTION 3
-#define wxSYS_COLOUR_MENU 4
-#define wxSYS_COLOUR_WINDOW 5
-#define wxSYS_COLOUR_WINDOWFRAME 6
-#define wxSYS_COLOUR_MENUTEXT 7
-#define wxSYS_COLOUR_WINDOWTEXT 8
-#define wxSYS_COLOUR_CAPTIONTEXT 9
-#define wxSYS_COLOUR_ACTIVEBORDER 10
-#define wxSYS_COLOUR_INACTIVEBORDER 11
-#define wxSYS_COLOUR_APPWORKSPACE 12
-#define wxSYS_COLOUR_HIGHLIGHT 13
-#define wxSYS_COLOUR_HIGHLIGHTTEXT 14
-#define wxSYS_COLOUR_BTNFACE 15
-#define wxSYS_COLOUR_BTNSHADOW 16
-#define wxSYS_COLOUR_GRAYTEXT 17
-#define wxSYS_COLOUR_BTNTEXT 18
-#define wxSYS_COLOUR_INACTIVECAPTIONTEXT 19
-#define wxSYS_COLOUR_BTNHIGHLIGHT 20
-
-#define wxSYS_COLOUR_3DDKSHADOW 21
-#define wxSYS_COLOUR_3DLIGHT 22
-#define wxSYS_COLOUR_INFOTEXT 23
-#define wxSYS_COLOUR_INFOBK 24
-
-#define wxSYS_COLOUR_DESKTOP wxSYS_COLOUR_BACKGROUND
-#define wxSYS_COLOUR_3DFACE wxSYS_COLOUR_BTNFACE
-#define wxSYS_COLOUR_3DSHADOW wxSYS_COLOUR_BTNSHADOW
-#define wxSYS_COLOUR_3DHIGHLIGHT wxSYS_COLOUR_BTNHIGHLIGHT
-#define wxSYS_COLOUR_3DHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
-#define wxSYS_COLOUR_BTNHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
-*/
-
-#define SHIFT (8*(sizeof(short int)-sizeof(char)))
-
-wxColour *g_systemBtnFaceColour = NULL;
-wxColour *g_systemBtnShadowColour = NULL;
-wxColour *g_systemBtnHighlightColour = NULL;
-wxColour *g_systemHighlightColour = NULL;
-
-wxColour wxSystemSettings::GetSystemColour( int index )
+wxColour wxSystemSettings::GetSystemColour(int index)
{
- switch (index)
- {
- case wxSYS_COLOUR_SCROLLBAR:
- case wxSYS_COLOUR_BACKGROUND:
- case wxSYS_COLOUR_ACTIVECAPTION:
- case wxSYS_COLOUR_INACTIVECAPTION:
- case wxSYS_COLOUR_MENU:
- case wxSYS_COLOUR_WINDOW:
- case wxSYS_COLOUR_WINDOWFRAME:
- case wxSYS_COLOUR_ACTIVEBORDER:
- case wxSYS_COLOUR_INACTIVEBORDER:
- case wxSYS_COLOUR_BTNFACE:
- {
- return *g_systemBtnFaceColour;
- };
- case wxSYS_COLOUR_BTNSHADOW:
- {
- return *g_systemBtnShadowColour;
- };
- case wxSYS_COLOUR_GRAYTEXT:
- case wxSYS_COLOUR_BTNHIGHLIGHT:
- {
- return *g_systemBtnHighlightColour;
- };
- case wxSYS_COLOUR_HIGHLIGHT:
- {
- return *g_systemHighlightColour;
- };
- case wxSYS_COLOUR_MENUTEXT:
- case wxSYS_COLOUR_WINDOWTEXT:
- case wxSYS_COLOUR_CAPTIONTEXT:
- case wxSYS_COLOUR_INACTIVECAPTIONTEXT:
- case wxSYS_COLOUR_INFOTEXT:
- {
- return *wxBLACK;
- };
- case wxSYS_COLOUR_HIGHLIGHTTEXT:
- {
- return *wxWHITE;
- };
- case wxSYS_COLOUR_INFOBK:
- case wxSYS_COLOUR_APPWORKSPACE:
- {
- return *wxWHITE; // ?
- };
- };
- return *wxWHITE;
-};
-
-wxFont *g_systemFont = NULL;
+ // TODO
+ return col;
+}
-wxFont wxSystemSettings::GetSystemFont( int index )
+wxFont wxSystemSettings::GetSystemFont(int index)
{
- switch (index)
- {
- case wxSYS_OEM_FIXED_FONT:
- case wxSYS_ANSI_FIXED_FONT:
- case wxSYS_SYSTEM_FIXED_FONT:
- {
- return *wxNORMAL_FONT;
- };
- case wxSYS_ANSI_VAR_FONT:
- case wxSYS_SYSTEM_FONT:
- case wxSYS_DEVICE_DEFAULT_FONT:
- case wxSYS_DEFAULT_GUI_FONT:
- {
- return *g_systemFont;
- };
- };
- return wxNullFont;
-};
+ // TODO
+ return wxFont;
+}
-int wxSystemSettings::GetSystemMetric( int index )
+// Get a system metric, e.g. scrollbar size
+int wxSystemSettings::GetSystemMetric(int index)
{
- switch (index)
- {
- case wxSYS_SCREEN_X: return 0;
- case wxSYS_SCREEN_Y: return 0;
- };
- return 0;
-};
+ switch ( index)
+ {
+ case wxSYS_MOUSE_BUTTONS:
+ // TODO
+ return 0;
+ case wxSYS_BORDER_X:
+ // TODO
+ return 0;
+ case wxSYS_BORDER_Y:
+ // TODO
+ return 0;
+ case wxSYS_CURSOR_X:
+ // TODO
+ return 0;
+ case wxSYS_CURSOR_Y:
+ // TODO
+ return 0;
+ case wxSYS_DCLICK_X:
+ // TODO
+ return 0;
+ case wxSYS_DCLICK_Y:
+ // TODO
+ return 0;
+ case wxSYS_DRAG_X:
+ // TODO
+ return 0;
+ case wxSYS_DRAG_Y:
+ // TODO
+ return 0;
+ case wxSYS_EDGE_X:
+ // TODO
+ return 0;
+ case wxSYS_EDGE_Y:
+ // TODO
+ return 0;
+ case wxSYS_HSCROLL_ARROW_X:
+ // TODO
+ return 0;
+ case wxSYS_HSCROLL_ARROW_Y:
+ // TODO
+ return 0;
+ case wxSYS_HTHUMB_X:
+ // TODO
+ return 0;
+ case wxSYS_ICON_X:
+ // TODO
+ return 0;
+ case wxSYS_ICON_Y:
+ // TODO
+ return 0;
+ case wxSYS_ICONSPACING_X:
+ // TODO
+ return 0;
+ case wxSYS_ICONSPACING_Y:
+ // TODO
+ return 0;
+ case wxSYS_WINDOWMIN_X:
+ // TODO
+ return 0;
+ case wxSYS_WINDOWMIN_Y:
+ // TODO
+ return 0;
+ case wxSYS_SCREEN_X:
+ // TODO
+ return 0;
+ case wxSYS_SCREEN_Y:
+ // TODO
+ return 0;
+ case wxSYS_FRAMESIZE_X:
+ // TODO
+ return 0;
+ case wxSYS_FRAMESIZE_Y:
+ // TODO
+ return 0;
+ case wxSYS_SMALLICON_X:
+ // TODO
+ return 0;
+ case wxSYS_SMALLICON_Y:
+ // TODO
+ return 0;
+ case wxSYS_HSCROLL_Y:
+ // TODO
+ return 0;
+ case wxSYS_VSCROLL_X:
+ // TODO
+ return 0;
+ case wxSYS_VSCROLL_ARROW_X:
+ // TODO
+ return 0;
+ case wxSYS_VSCROLL_ARROW_Y:
+ // TODO
+ return 0;
+ case wxSYS_VTHUMB_Y:
+ // TODO
+ return 0;
+ case wxSYS_CAPTION_Y:
+ // TODO
+ return 0;
+ case wxSYS_MENU_Y:
+ // TODO
+ return 0;
+ case wxSYS_NETWORK_PRESENT:
+ // TODO
+ return 0;
+ case wxSYS_PENWINDOWS_PRESENT:
+ // TODO
+ return 0;
+ case wxSYS_SHOW_SOUNDS:
+ // TODO
+ return 0;
+ case wxSYS_SWAP_BUTTONS:
+ // TODO
+ return 0;
+ default:
+ return 0;
+ }
+ return 0;
+}
/////////////////////////////////////////////////////////////////////////////
// Name: slider.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxSlider
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "slider.h"
#endif
-#include "wx/slider.h"
-#include "wx/utils.h"
-
-//-----------------------------------------------------------------------------
-// wxSlider
-//-----------------------------------------------------------------------------
+#include "wx/msw/slider.h"
-IMPLEMENT_DYNAMIC_CLASS(wxSlider,wxControl)
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl)
+#endif
-wxSlider::wxSlider(void)
+// Slider
+wxSlider::wxSlider()
{
-};
+ m_pageSize = 1;
+ m_lineSize = 1;
+ m_rangeMax = 0;
+ m_rangeMin = 0;
+ m_tickFreq = 0;
+}
-wxSlider::wxSlider( wxWindow *parent, wxWindowID id,
- int value, int minValue, int maxValue,
- const wxPoint& pos, const wxSize& size,
- long style,
-/* const wxValidator& validator = wxDefaultValidator, */
- const wxString& name )
+bool wxSlider::Create(wxWindow *parent, wxWindowID id,
+ int value, int minValue, int maxValue,
+ const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator,
+ const wxString& name)
{
- Create( parent, id, value, minValue, maxValue,
- pos, size, style, name );
-};
+ SetName(name);
+ SetValidator(validator);
-wxSlider::~wxSlider(void)
-{
-};
+ if (parent) parent->AddChild(this);
-bool wxSlider::Create(wxWindow *parent, wxWindowID id,
- int value, int minValue, int maxValue,
- const wxPoint& pos, const wxSize& size,
- long style,
-/* const wxValidator& validator = wxDefaultValidator, */
- const wxString& name )
-{
- return TRUE;
-};
+ m_lineSize = 1;
+ m_windowStyle = style;
+ m_tickFreq = 0;
-int wxSlider::GetValue(void) const
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
+
+ m_rangeMax = maxValue;
+ m_rangeMin = minValue;
+
+ m_pageSize = (int)((maxValue-minValue)/10);
+
+ // TODO create slider
+
+ return FALSE;
+}
+
+wxSlider::~wxSlider()
{
-};
+}
-void wxSlider::SetValue( int value )
+int wxSlider::GetValue() const
{
-};
+ // TODO
+ return 0;
+}
-void wxSlider::SetRange( int minValue, int maxValue )
+void wxSlider::SetValue(int value)
{
-};
+ // TODO
+}
-int wxSlider::GetMin(void) const
+void wxSlider::GetSize(int *width, int *height) const
{
-};
+ // TODO
+}
-int wxSlider::GetMax(void) const
+void wxSlider::GetPosition(int *x, int *y) const
{
-};
+ // TODO
+}
-void wxSlider::SetPageSize( int pageSize )
+void wxSlider::SetSize(int x, int y, int width, int height, int sizeFlags)
{
-};
+ // TODO
+}
-int wxSlider::GetPageSize(void) const
+void wxSlider::SetRange(int minValue, int maxValue)
{
-};
+ m_rangeMin = minValue;
+ m_rangeMax = maxValue;
+
+ // TODO
+}
-void wxSlider::SetThumbLength( int len )
+// For trackbars only
+void wxSlider::SetTickFreq(int n, int pos)
{
-};
+ // TODO
+ m_tickFreq = n;
+}
-int wxSlider::GetThumbLength(void) const
+void wxSlider::SetPageSize(int pageSize)
{
-};
+ // TODO
+ m_pageSize = pageSize;
+}
-void wxSlider::SetLineSize( int WXUNUSED(lineSize) )
+int wxSlider::GetPageSize() const
{
-};
+ return m_pageSize;
+}
-int wxSlider::GetLineSize(void) const
+void wxSlider::ClearSel()
{
-};
+ // TODO
+}
-void wxSlider::GetSize( int *x, int *y ) const
+void wxSlider::ClearTicks()
{
- wxWindow::GetSize( x, y );
-};
+ // TODO
+}
-void wxSlider::SetSize( int x, int y, int width, int height, int sizeFlags )
+void wxSlider::SetLineSize(int lineSize)
{
- wxWindow::SetSize( x, y, width, height, sizeFlags );
-};
+ m_lineSize = lineSize;
+ // TODO
+}
-void wxSlider::GetPosition( int *x, int *y ) const
+int wxSlider::GetLineSize() const
{
- wxWindow::GetPosition( x, y );
-};
+ // TODO
+ return 0;
+}
-void wxSlider::SetTick( int WXUNUSED(tickPos) )
+int wxSlider::GetSelEnd() const
{
-};
+ // TODO
+ return 0;
+}
-void wxSlider::SetTickFreq( int WXUNUSED(n), int WXUNUSED(pos) )
+int wxSlider::GetSelStart() const
{
-};
+ // TODO
+ return 0;
+}
-int wxSlider::GetTickFreq(void) const
+void wxSlider::SetSelection(int minPos, int maxPos)
{
- return 0;
-};
+ // TODO
+}
-void wxSlider::ClearTicks(void)
+void wxSlider::SetThumbLength(int len)
{
-};
+ // TODO
+}
-void wxSlider::SetSelection( int WXUNUSED(minPos), int WXUNUSED(maxPos) )
+int wxSlider::GetThumbLength() const
{
-};
+ // TODO
+ return 0;
+}
-int wxSlider::GetSelEnd(void) const
+void wxSlider::SetTick(int tickPos)
{
- return 0;
-};
+ // TODO
+}
-int wxSlider::GetSelStart(void) const
+void wxSlider::Command (wxCommandEvent & event)
{
- return 0;
-};
+ SetValue (event.GetInt());
+ ProcessCommand (event);
+}
-void wxSlider::ClearSel(void)
+bool wxSlider::Show(bool show)
{
-};
+ // TODO
+ return TRUE;
+}
/////////////////////////////////////////////////////////////////////////////
// Name: statbmp.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxStaticBitmap
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/statbmp.h"
-//-----------------------------------------------------------------------------
-// wxStaticBitmap
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
+#endif
-IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap,wxControl)
+/*
+ * wxStaticBitmap
+ */
-wxStaticBitmap::wxStaticBitmap(void)
+bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
+ const wxBitmap& bitmap,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
-};
+ m_messageBitmap = bitmap;
+ SetName(name);
+ if (parent) parent->AddChild(this);
-wxStaticBitmap::wxStaticBitmap( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
-{
- Create( parent, id, bitmap, pos, size, style, name );
-};
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
+
+ m_windowStyle = style;
-bool wxStaticBitmap::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+ // TODO: create static bitmap control
+ return FALSE;
+}
+
+void wxStaticBitmap::SetSize(int x, int y, int width, int height, int sizeFlags)
{
- return TRUE;
-};
+ // TODO
+}
-void wxStaticBitmap::SetBitmap( const wxBitmap &bitmap )
+void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
{
-};
+ m_messageBitmap = bitmap;
+
+ // TODO: redraw bitmap
+}
/////////////////////////////////////////////////////////////////////////////
// Name: statbox.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxStaticBox
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#include "wx/statbox.h"
-//-----------------------------------------------------------------------------
-// wxStaticBox
-//-----------------------------------------------------------------------------
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxStaticBox, wxControl)
-IMPLEMENT_DYNAMIC_CLASS(wxStaticBox,wxControl)
+BEGIN_EVENT_TABLE(wxStaticBox, wxControl)
+ EVT_ERASE_BACKGROUND(wxStaticBox::OnEraseBackground)
+END_EVENT_TABLE()
-wxStaticBox::wxStaticBox(void)
+#endif
+
+/*
+ * Static box
+ */
+
+bool wxStaticBox::Create(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
-};
+ SetName(name);
+
+ if (parent) parent->AddChild(this);
+
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
-wxStaticBox::wxStaticBox( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+ m_windowStyle = style;
+
+ // TODO: create static box
+ return FALSE;
+}
+
+void wxStaticBox::SetLabel(const wxString& label)
{
- Create( parent, id, label, pos, size, style, name );
-};
+ // TODO
+}
-bool wxStaticBox::Create( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+void wxStaticBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
-};
+ // TODO
+}
+
/////////////////////////////////////////////////////////////////////////////
// Name: stattext.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxStaticText
+// Author: AUTHOR
+// Modified by:
+// Created: 04/01/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "stattext.h"
#endif
-#include "wx/stattext.h"
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
-//-----------------------------------------------------------------------------
-// wxStaticText
-//-----------------------------------------------------------------------------
+#ifndef WX_PRECOMP
+#include "wx/app.h"
+#endif
-IMPLEMENT_DYNAMIC_CLASS(wxStaticText,wxControl)
+#include "wx/stattext.h"
+#include "wx/msw/private.h"
+#include <stdio.h>
-wxStaticText::wxStaticText(void)
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl)
+#endif
+
+bool wxStaticText::Create(wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
-};
+ SetName(name);
+ if (parent) parent->AddChild(this);
+
+ SetBackgroundColour(parent->GetDefaultBackgroundColour()) ;
+ SetForegroundColour(parent->GetDefaultForegroundColour()) ;
+
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
+
+ int x = pos.x;
+ int y = pos.y;
+ int width = size.x;
+ int height = size.y;
+
+ m_windowStyle = style;
+
+ long msStyle = WS_CHILD|WS_VISIBLE;
+ if (m_windowStyle & wxALIGN_CENTRE)
+ msStyle |= SS_CENTER;
+ else if (m_windowStyle & wxALIGN_RIGHT)
+ msStyle |= SS_RIGHT;
+ else
+ msStyle |= SS_LEFT;
+
+ // Even with extended styles, need to combine with WS_BORDER
+ // for them to look right.
+ if ((m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
+ (m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
+ msStyle |= WS_BORDER;
+
+ HWND static_item = CreateWindowEx(MakeExtendedStyle(m_windowStyle), "STATIC", (const char *)label,
+ msStyle,
+ 0, 0, 0, 0, (HWND) parent->GetHWND(), (HMENU)m_windowId,
+ wxGetInstance(), NULL);
+
+#if CTL3D
+/*
+ if (!(GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS))
+ Ctl3dSubclassCtl(static_item);
+*/
+#endif
+
+ m_hWnd = (WXHWND)static_item;
+
+ SubclassWin((WXHWND)static_item);
+
+ SetFont(* parent->GetFont());
+ SetSize(x, y, width, height);
+ return TRUE;
+}
-wxStaticText::wxStaticText( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+void wxStaticText::SetSize(int x, int y, int width, int height, int sizeFlags)
{
- Create( parent, id, label, pos, size, style, name );
-};
+ int currentX, currentY;
+ GetPosition(¤tX, ¤tY);
+ int x1 = x;
+ int y1 = y;
-bool wxStaticText::Create( wxWindow *parent, wxWindowID id, const wxString &label,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+ if (x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+ x1 = currentX;
+ if (y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+ y1 = currentY;
+
+ AdjustForParentClientOrigin(x1, y1, sizeFlags);
+
+ int actualWidth = width;
+ int actualHeight = height;
+
+ char buf[300];
+ int current_width;
+ int cyf;
+
+ ::GetWindowText((HWND) GetHWND(), buf, 300);
+ GetTextExtent(buf, ¤t_width, &cyf, NULL, NULL,GetFont());
+
+ int ww, hh;
+ GetSize(&ww, &hh);
+
+ // If we're prepared to use the existing width, then...
+ if (width == -1 && ((sizeFlags & wxSIZE_AUTO_WIDTH) != wxSIZE_AUTO_WIDTH))
+ actualWidth = ww;
+ else if (width == -1)
+ {
+ int cx;
+ int cy;
+ wxGetCharSize(GetHWND(), &cx, &cy,GetFont());
+ actualWidth = (int)(current_width + cx) ;
+ }
+
+ // If we're prepared to use the existing height, then...
+ if (height == -1 && ((sizeFlags & wxSIZE_AUTO_HEIGHT) != wxSIZE_AUTO_HEIGHT))
+ actualHeight = hh;
+ else if (height == -1)
+ {
+ actualHeight = (int)(cyf) ;
+ }
+
+ MoveWindow((HWND) GetHWND(), x1, y1, actualWidth, actualHeight, TRUE);
+}
+
+void wxStaticText::SetLabel(const wxString& label)
{
- return TRUE;
-};
+ int w, h;
+ RECT rect;
+
+ wxWindow *parent = GetParent();
+ GetWindowRect((HWND) GetHWND(), &rect);
-wxString wxStaticText::GetLabel(void) const
+ // Since we now have the absolute screen coords,
+ // if there's a parent we must subtract its top left corner
+ POINT point;
+ point.x = rect.left;
+ point.y = rect.top;
+ if (parent)
+ {
+ ::ScreenToClient((HWND) parent->GetHWND(), &point);
+ }
+
+ GetTextExtent(label, &w, &h, NULL, NULL, GetFont());
+ MoveWindow((HWND) GetHWND(), point.x, point.y, (int)(w + 10), (int)h,
+ TRUE);
+ SetWindowText((HWND) GetHWND(), (const char *)label);
+}
+
+WXHBRUSH wxStaticText::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
+ WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
-};
+/*
+#if CTL3D
+ if ( m_useCtl3D )
+ {
+ HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
+
+ if (hbrush != (HBRUSH) 0)
+ return hbrush;
+ else
+ return (HBRUSH)MSWDefWindowProc(message, wParam, lParam);
+ }
+#endif
+*/
+
+ if (GetParent()->GetTransparentBackground())
+ SetBkMode((HDC) pDC, TRANSPARENT);
+ else
+ SetBkMode((HDC) pDC, OPAQUE);
+
+ ::SetBkColor((HDC) pDC, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
+ ::SetTextColor((HDC) pDC, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue()));
-void wxStaticText::SetLabel( const wxString &label )
+ wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID);
+
+ // Note that this will be cleaned up in wxApp::OnIdle, if backgroundBrush
+ // has a zero usage count.
+// backgroundBrush->RealizeResource();
+ return (WXHBRUSH) backgroundBrush->GetResourceHandle();
+}
+
+long wxStaticText::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
- wxControl::SetLabel(label);
-};
+ // Ensure that static items get messages. Some controls don't like this
+ // message to be intercepted (e.g. RichEdit), hence the tests.
+ if (nMsg == WM_NCHITTEST)
+ return (long)HTCLIENT;
+
+ return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
+}
+
+
/////////////////////////////////////////////////////////////////////////////
// Name: textctrl.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Purpose: wxTextCtrl
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "textctrl.h"
#endif
-#include "wx/textctrl.h"
-#include "wx/utils.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fstream.h>
-//-----------------------------------------------------------------------------
-// wxTextCtrl
-//-----------------------------------------------------------------------------
+#include "wx/textctrl.h"
+#include "wx/settings.h"
-IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
+#if defined(__BORLANDC__) && !defined(__WIN32__)
+#include <alloc.h>
+#else
+#ifndef __GNUWIN32__
+#include <malloc.h>
+#endif
+#endif
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
-// EVT_CHAR(wxTextCtrl::OnChar)
+ EVT_CHAR(wxTextCtrl::OnChar)
+ EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
+ EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
END_EVENT_TABLE()
+#endif
-wxTextCtrl::wxTextCtrl(void) : streambuf()
+// Text item
+wxTextCtrl::wxTextCtrl()
+#ifndef NO_TEXT_WINDOW_STREAM
+ :streambuf()
+#endif
{
- if( allocate() )
- setp(base(),ebuf());
-
- m_modified = FALSE;
-};
+ m_fileName = "";
+}
-wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
- const wxPoint &pos, const wxSize &size,
- int style, const wxString &name ) : streambuf()
+bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
+ const wxString& value,
+ const wxPoint& pos,
+ const wxSize& size, long style,
+ const wxValidator& validator,
+ const wxString& name)
{
- if( allocate() )
- setp(base(),ebuf());
+ m_fileName = "";
+ SetName(name);
+ SetValidator(validator);
+ if (parent) parent->AddChild(this);
+
+ m_windowStyle = style;
- m_modified = FALSE;
- Create( parent, id, value, pos, size, style, name );
-};
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
-bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
- const wxPoint &pos, const wxSize &size,
- int style, const wxString &name )
+ return TRUE;
+}
+
+wxString wxTextCtrl::GetValue() const
{
- return TRUE;
-};
+ // TODO
+ return wxString("");
+}
-wxString wxTextCtrl::GetValue(void) const
+void wxTextCtrl::SetValue(const wxString& value)
{
- return tmp;
-};
+ // TODO
+}
-void wxTextCtrl::SetValue( const wxString &value )
+void wxTextCtrl::SetSize(int x, int y, int width, int height, int sizeFlags)
{
-};
+ // TODO
+}
-void wxTextCtrl::WriteText( const wxString &text )
+// Clipboard operations
+void wxTextCtrl::Copy()
{
-};
+ // TODO
+}
-bool wxTextCtrl::LoadFile( const wxString &WXUNUSED(file) )
+void wxTextCtrl::Cut()
{
- return FALSE;
-};
+ // TODO
+}
-bool wxTextCtrl::SaveFile( const wxString &WXUNUSED(file) )
+void wxTextCtrl::Paste()
{
- return FALSE;
-};
+ // TODO
+}
-/*
-wxString wxTextCtrl::GetLineText( long lineNo ) const
+void wxTextCtrl::SetEditable(bool editable)
{
-};
+ // TODO
+}
+void wxTextCtrl::SetInsertionPoint(long pos)
+{
+ // TODO
+}
-void wxTextCtrl::OnDropFiles( wxDropFilesEvent &event )
+void wxTextCtrl::SetInsertionPointEnd()
{
-};
+ long pos = GetLastPosition();
+ SetInsertionPoint(pos);
+}
-long wxTextCtrl::PositionToXY( long pos, long *x, long *y ) const
+long wxTextCtrl::GetInsertionPoint() const
{
-};
+ // TODO
+ return 0;
+}
-long wxTextCtrl::XYToPosition( long x, long y )
+long wxTextCtrl::GetLastPosition() const
{
-};
+ // TODO
+ return 0;
+}
-int wxTextCtrl::GetNumberOfLines(void)
+void wxTextCtrl::Replace(long from, long to, const wxString& value)
{
-};
+ // TODO
+ return 0;
+}
-*/
-void wxTextCtrl::SetInsertionPoint( long pos )
+void wxTextCtrl::Remove(long from, long to)
{
-};
+ // TODO
+}
-void wxTextCtrl::SetInsertionPointEnd(void)
+void wxTextCtrl::SetSelection(long from, long to)
{
-};
+ // TODO
+}
+
+bool wxTextCtrl::LoadFile(const wxString& file)
+{
+ if (!wxFileExists(file))
+ return FALSE;
+
+ m_fileName = file;
+
+ Clear();
+
+ ifstream input((char*) (const char*) file, ios::nocreate | ios::in);
+
+ if (!input.bad())
+ {
+ struct stat stat_buf;
+ if (stat(file, &stat_buf) < 0)
+ return FALSE;
+ // This may need to be a bigger buffer than the file size suggests,
+ // if it's a UNIX file. Give it an extra 1000 just in case.
+ char *tmp_buffer = (char*)malloc((size_t)(stat_buf.st_size+1+1000));
+ long no_lines = 0;
+ long pos = 0;
+ while (!input.eof() && input.peek() != EOF)
+ {
+ input.getline(wxBuffer, 500);
+ int len = strlen(wxBuffer);
+ wxBuffer[len] = 13;
+ wxBuffer[len+1] = 10;
+ wxBuffer[len+2] = 0;
+ strcpy(tmp_buffer+pos, wxBuffer);
+ pos += strlen(wxBuffer);
+ no_lines++;
+ }
+
+ // TODO add line
+
+ free(tmp_buffer);
+
+ return TRUE;
+ }
+ return FALSE;
+}
-void wxTextCtrl::SetEditable( bool editable )
+// If file is null, try saved file name first
+// Returns TRUE if succeeds.
+bool wxTextCtrl::SaveFile(const wxString& file)
{
-};
+ wxString theFile(file);
+ if (theFile == "")
+ theFile = m_fileName;
+ if (theFile == "")
+ return FALSE;
+ m_fileName = theFile;
+
+ ofstream output((char*) (const char*) theFile);
+ if (output.bad())
+ return FALSE;
+
+ // TODO get and save text
+
+ return FALSE;
+}
-void wxTextCtrl::SetSelection( long from, long to )
+void wxTextCtrl::WriteText(const wxString& text)
{
-};
+ // TODO write text to control
+}
-void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
+void wxTextCtrl::Clear()
{
-};
+ // TODO
+}
-long wxTextCtrl::GetInsertionPoint(void) const
+bool wxTextCtrl::IsModified() const
{
-};
+ // TODO
+ return FALSE;
+}
-long wxTextCtrl::GetLastPosition(void) const
+// Makes 'unmodified'
+void wxTextCtrl::DiscardEdits()
{
-};
+ // TODO
+}
-void wxTextCtrl::Remove( long from, long to )
+int wxTextCtrl::GetNumberOfLines() const
{
-};
+ // TODO
+ return 0;
+}
-void wxTextCtrl::Replace( long from, long to, const wxString &value )
+long wxTextCtrl::XYToPosition(long x, long y) const
{
-};
+ // TODO
+ return 0;
+}
-void wxTextCtrl::Cut(void)
+void wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
{
-};
+ // TODO
+}
-void wxTextCtrl::Copy(void)
+void wxTextCtrl::ShowPosition(long pos)
{
-};
+ // TODO
+}
-void wxTextCtrl::Paste(void)
+int wxTextCtrl::GetLineLength(long lineNo) const
{
-};
+ // TODO
+ return 0;
+}
-void wxTextCtrl::Delete(void)
+wxString wxTextCtrl::GetLineText(long lineNo) const
{
-};
+ // TODO
+ return wxString("");
+}
-void wxTextCtrl::OnChar( wxKeyEvent &WXUNUSED(event) )
+/*
+ * Text item
+ */
+
+void wxTextCtrl::Command(wxCommandEvent & event)
{
-};
+ SetValue (event.GetString());
+ ProcessCommand (event);
+}
-int wxTextCtrl::overflow( int WXUNUSED(c) )
+void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
{
- int len = pptr() - pbase();
- char *txt = new char[len+1];
- strncpy(txt, pbase(), len);
- txt[len] = '\0';
- (*this) << txt;
+ // By default, load the first file into the text window.
+ if (event.GetNumberOfFiles() > 0)
+ {
+ LoadFile(event.GetFiles()[0]);
+ }
+}
+
+// The streambuf code was partly taken from chapter 3 by Jerry Schwarz of
+// AT&T's "C++ Lanuage System Release 3.0 Library Manual" - Stein Somers
+
+//=========================================================================
+// Called then the buffer is full (gcc 2.6.3)
+// or when "endl" is output (Borland 4.5)
+//=========================================================================
+// Class declaration using multiple inheritance doesn't work properly for
+// Borland. See note in wb_text.h.
+#ifndef NO_TEXT_WINDOW_STREAM
+int wxTextCtrl::overflow(int c)
+{
+ // Make sure there is a holding area
+ if ( allocate()==EOF )
+ {
+ wxError("Streambuf allocation failed","Internal error");
+ return EOF;
+ }
+
+ // Verify that there are no characters in get area
+ if ( gptr() && gptr() < egptr() )
+ {
+ wxError("Who's trespassing my get area?","Internal error");
+ return EOF;
+ }
+
+ // Reset get area
+ setg(0,0,0);
+
+ // Make sure there is a put area
+ if ( ! pptr() )
+ {
+/* This doesn't seem to be fatal so comment out error message */
+// wxError("Put area not opened","Internal error");
+ setp( base(), base() );
+ }
+
+ // Determine how many characters have been inserted but no consumed
+ int plen = pptr() - pbase();
+
+ // Now Jerry relies on the fact that the buffer is at least 2 chars
+ // long, but the holding area "may be as small as 1" ???
+ // And we need an additional \0, so let's keep this inefficient but
+ // safe copy.
+
+ // If c!=EOF, it is a character that must also be comsumed
+ int xtra = c==EOF? 0 : 1;
+
+ // Write temporary C-string to wxTextWindow
+ {
+ char *txt = new char[plen+xtra+1];
+ memcpy(txt, pbase(), plen);
+ txt[plen] = (char)c; // append c
+ txt[plen+xtra] = '\0'; // append '\0' or overwrite c
+ // If the put area already contained \0, output will be truncated there
+ WriteText(txt);
+ delete[] txt;
+ }
+
+ // Reset put area
setp(pbase(), epptr());
- delete[] txt;
- return EOF;
-};
-int wxTextCtrl::sync(void)
+#if defined(__WATCOMC__)
+ return __NOT_EOF;
+#elif defined(zapeof) // HP-UX (all cfront based?)
+ return zapeof(c);
+#else
+ return c!=EOF ? c : 0; // this should make everybody happy
+#endif
+}
+
+//=========================================================================
+// called then "endl" is output (gcc) or then explicit sync is done (Borland)
+//=========================================================================
+int wxTextCtrl::sync()
{
+ // Verify that there are no characters in get area
+ if ( gptr() && gptr() < egptr() )
+ {
+ wxError("Who's trespassing my get area?","Internal error");
+ return EOF;
+ }
+
+ if ( pptr() && pptr() > pbase() ) return overflow(EOF);
+
+ return 0;
+/* OLD CODE
int len = pptr() - pbase();
char *txt = new char[len+1];
strncpy(txt, pbase(), len);
setp(pbase(), epptr());
delete[] txt;
return 0;
-};
+*/
+}
-int wxTextCtrl::underflow(void)
+//=========================================================================
+// Should not be called by a "ostream". Used by a "istream"
+//=========================================================================
+int wxTextCtrl::underflow()
{
return EOF;
-};
+}
+#endif
wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
{
- WriteText(s);
- return *this;
+ WriteText(s);
+ return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(float f)
{
- static char buf[100];
- sprintf(buf, "%.2f", f);
- WriteText(buf);
- return *this;
+ wxString str;
+ str.Printf("%.2f", f);
+ WriteText(str);
+ return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(double d)
{
- static char buf[100];
- sprintf(buf, "%.2f", d);
- WriteText(buf);
- return *this;
+ wxString str;
+ str.Printf("%.2f", d);
+ WriteText(str);
+ return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(int i)
{
- static char buf[100];
- sprintf(buf, "%i", i);
- WriteText(buf);
- return *this;
+ wxString str;
+ str.Printf("%d", i);
+ WriteText(str);
+ return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(long i)
{
- static char buf[100];
- sprintf(buf, "%ld", i);
- WriteText(buf);
- return *this;
+ wxString str;
+ str.Printf("%ld", i);
+ WriteText(str);
+ return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(const char c)
{
- char buf[2];
+ char buf[2];
- buf[0] = c;
- buf[1] = 0;
- WriteText(buf);
- return *this;
+ buf[0] = c;
+ buf[1] = 0;
+ WriteText(buf);
+ return *this;
}
-
-
/////////////////////////////////////////////////////////////////////////////
// Name: timer.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Purpose: wxTimer implementation
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "timer.h"
#endif
#include "wx/timer.h"
-//-----------------------------------------------------------------------------
-// wxTimer
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxTimer,wxObject)
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
+#endif
-gint timeout_callback( gpointer data )
+wxTimer::wxTimer()
{
- wxTimer *timer = (wxTimer*)data;
- timer->Notify();
- if (timer->OneShot()) timer->Stop();
- return TRUE;
-};
+ m_milli = 0 ;
+ m_lastMilli = -1 ;
+ m_id = 0;
+ m_oneShot = FALSE;
+}
-wxTimer::wxTimer(void)
+wxTimer::~wxTimer()
{
- m_time = 1000;
- m_oneShot = FALSE;
-};
+ Stop();
+}
-wxTimer::~wxTimer(void)
+bool wxTimer::Start(int milliseconds,bool mode)
{
- Stop();
-};
+ m_oneShot = mode ;
+ if (m_milliseconds < 0)
+ m_milliseconds = lastMilli;
-int wxTimer::Interval(void)
-{
- return m_time;
-};
+ if (m_milliseconds <= 0)
+ return FALSE;
-bool wxTimer::OneShot(void)
-{
- return m_oneShot;
-};
+ m_lastMilli = m_milli = m_milliseconds;
-void wxTimer::Notify(void)
-{
-};
+ // TODO: set the timer going.
+ return FALSE;
+}
-void wxTimer::Start( int millisecs, bool oneShot )
+void wxTimer::Stop()
{
- if (millisecs != -1) m_time = millisecs;
- m_oneShot = oneShot;
-};
+ m_id = 0 ;
+ m_milli = 0 ;
+}
-void wxTimer::Stop(void)
-{
-};
/////////////////////////////////////////////////////////////////////////////
-// Name: window.cpp
-// Purpose:
-// Author: Robert Roebling
-// Created: 01/02/97
-// Id:
-// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
-// Licence: wxWindows licence
+// Name: windows.cpp
+// Purpose: wxWindow
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-
#ifdef __GNUG__
#pragma implementation "window.h"
#endif
-#include "wx/defs.h"
-#include "wx/window.h"
+#include "wx/setup.h"
+#include "wx/menu.h"
#include "wx/dc.h"
-#include "wx/frame.h"
+#include "wx/dcclient.h"
+#include "wx/utils.h"
#include "wx/app.h"
+#include "wx/panel.h"
#include "wx/layout.h"
-#include "wx/utils.h"
#include "wx/dialog.h"
+#include "wx/listbox.h"
+#include "wx/button.h"
+#include "wx/settings.h"
#include "wx/msgdlg.h"
-#include "wx/dcclient.h"
+
+#include "wx/menuitem.h"
+#include "wx/log.h"
+
+#if USE_DRAG_AND_DROP
#include "wx/dnd.h"
-#include "wx/mdi.h"
-#include "wx/notebook.h"
-#include "wx/statusbr.h"
-#include <math.h>
+#endif
-//-----------------------------------------------------------------------------
-// data
-//-----------------------------------------------------------------------------
+#include <string.h>
extern wxList wxPendingDelete;
-extern wxList wxTopLevelWindows;
-//-----------------------------------------------------------------------------
-// wxWindow implementation
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
+#if !USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
- EVT_SIZE(wxWindow::OnSize)
+ EVT_CHAR(wxWindow::OnChar)
+ EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindow::OnInitDialog)
EVT_IDLE(wxWindow::OnIdle)
END_EVENT_TABLE()
+#endif
+
+
+// Constructor
wxWindow::wxWindow()
{
- m_parent = NULL;
- m_children.DeleteContents( FALSE );
- m_x = 0;
- m_y = 0;
- m_width = 0;
- m_height = 0;
- m_retCode = 0;
- m_eventHandler = this;
- m_windowValidator = NULL;
- m_windowId = -1;
- m_cursor = new wxCursor( wxCURSOR_ARROW );
- m_font = *wxSWISS_FONT;
- m_windowStyle = 0;
- m_windowName = "noname";
- m_constraints = NULL;
- m_constraintsInvolvedIn = NULL;
- m_windowSizer = NULL;
- m_sizerParent = NULL;
- m_autoLayout = FALSE;
- m_pDropTarget = NULL;
-};
-
-wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
-{
- Create( parent, id, pos, size, style, name );
-};
-
-bool wxWindow::Create( wxWindow *parent, wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
-{
- return TRUE;
-};
-
-wxWindow::~wxWindow(void)
-{
- DestroyChildren();
-
-// delete m_cursor;
-
- DeleteRelatedConstraints();
- if (m_constraints)
- {
- // This removes any dangling pointers to this window
- // in other windows' constraintsInvolvedIn lists.
- UnsetConstraints(m_constraints);
- delete m_constraints;
+ // Generic
+ m_windowId = 0;
+ m_windowStyle = 0;
+ m_windowParent = NULL;
+ m_windowEventHandler = this;
+ m_windowName = "";
+ m_windowCursor = *wxSTANDARD_CURSOR;
+ m_children = new wxList;
m_constraints = NULL;
- }
- if (m_windowSizer)
- {
- delete m_windowSizer;
+ m_constraintsInvolvedIn = NULL;
m_windowSizer = NULL;
- }
- // If this is a child of a sizer, remove self from parent
- if (m_sizerParent)
- m_sizerParent->RemoveChild((wxWindow *)this);
-
- // Just in case the window has been Closed, but
- // we're then deleting immediately: don't leave
- // dangling pointers.
- wxPendingDelete.DeleteObject(this);
-
- // Just in case we've loaded a top-level window via
- // wxWindow::LoadNativeDialog but we weren't a dialog
- // class
- wxTopLevelWindows.DeleteObject(this);
-
-};
+ m_sizerParent = NULL;
+ m_autoLayout = FALSE;
+ m_windowValidator = NULL;
+ m_defaultItem = NULL;
+ m_returnCode = 0;
+ m_caretWidth = 0; m_caretHeight = 0;
+ m_caretEnabled = FALSE;
+ m_caretShown = FALSE;
+ m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
+ m_foregroundColour = *wxBLACK;
+ m_defaultForegroundColour = *wxBLACK ;
+ m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
+
+#if USE_DRAG_AND_DROP
+ m_pDropTarget = NULL;
+#endif
+}
-bool wxWindow::Close( bool force )
+// Destructor
+wxWindow::~wxWindow()
{
- wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
- event.SetEventObject(this);
- event.SetForce(force);
+ // Have to delete constraints/sizer FIRST otherwise
+ // sizers may try to look at deleted windows as they
+ // delete themselves.
+#if USE_CONSTRAINTS
+ DeleteRelatedConstraints();
+ if (m_constraints)
+ {
+ // This removes any dangling pointers to this window
+ // in other windows' constraintsInvolvedIn lists.
+ UnsetConstraints(m_constraints);
+ delete m_constraints;
+ m_constraints = NULL;
+ }
+ if (m_windowSizer)
+ {
+ delete m_windowSizer;
+ m_windowSizer = NULL;
+ }
+ // If this is a child of a sizer, remove self from parent
+ if (m_sizerParent)
+ m_sizerParent->RemoveChild((wxWindow *)this);
+#endif
- return GetEventHandler()->ProcessEvent(event);
-};
+ if (m_windowParent)
+ m_windowParent->RemoveChild(this);
-bool wxWindow::Destroy(void)
-{
- m_hasVMT = FALSE;
- delete this;
- return TRUE;
-};
+ DestroyChildren();
+
+ // TODO: destroy the window
-bool wxWindow::DestroyChildren(void)
+ delete m_children;
+ m_children = NULL;
+
+ // Just in case the window has been Closed, but
+ // we're then deleting immediately: don't leave
+ // dangling pointers.
+ wxPendingDelete.DeleteObject(this);
+
+ if ( m_windowValidator )
+ delete m_windowValidator;
+}
+
+// Destroy the window (delayed, if a managed window)
+bool wxWindow::Destroy()
{
- if (GetChildren())
- {
- wxNode *node;
- while ((node = GetChildren()->First()) != (wxNode *)NULL)
- {
- wxWindow *child;
- if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
- {
- delete child;
- if (GetChildren()->Member(child)) delete node;
- };
- };
- };
- return TRUE;
-};
+ delete this;
+ return TRUE;
+}
+
+// Constructor
+bool wxWindow::Create(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
+{
+ // Generic
+ m_windowId = 0;
+ m_windowStyle = 0;
+ m_windowParent = NULL;
+ m_windowEventHandler = this;
+ m_windowName = "";
+ m_windowCursor = *wxSTANDARD_CURSOR;
+ m_constraints = NULL;
+ m_constraintsInvolvedIn = NULL;
+ m_windowSizer = NULL;
+ m_sizerParent = NULL;
+ m_autoLayout = FALSE;
+ m_windowValidator = NULL;
+
+#if USE_DRAG_AND_DROP
+ m_pDropTarget = NULL;
+#endif
+
+ m_caretWidth = 0; m_caretHeight = 0;
+ m_caretEnabled = FALSE;
+ m_caretShown = FALSE;
+ m_minSizeX = -1;
+ m_minSizeY = -1;
+ m_maxSizeX = -1;
+ m_maxSizeY = -1;
+ m_defaultItem = NULL;
+ m_windowParent = NULL;
+ if (!parent)
+ return FALSE;
+
+ if (parent) parent->AddChild(this);
+
+ m_returnCode = 0;
+
+ SetName(name);
+
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
+
+ m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
+ m_foregroundColour = *wxBLACK;
+ m_defaultForegroundColour = *wxBLACK ;
+ m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
+
+ m_windowStyle = style;
-void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
+ if ( id == -1 )
+ m_windowId = (int)NewControlId();
+ else
+ m_windowId = id;
+
+ // TODO: create the window
+
+ return TRUE;
+}
+
+void wxWindow::SetFocus()
{
- // are we to set fonts here ?
-};
+ // TODO
+}
-void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
+void wxWindow::Enable(bool enable)
{
-
- int newX = x;
- int newY = y;
- int newW = width;
- int newH = height;
-
- if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
- {
- if (newX == -1) newX = m_x;
- if (newY == -1) newY = m_y;
- if (newW == -1) newW = m_width;
- if (newH == -1) newH = m_height;
- };
-
- if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
- {
- if (newW == -1) newW = 80;
- };
-
- if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
- {
- if (newH == -1) newH = 26;
- };
-
- if ((m_x != newX) || (m_y != newY) || (!m_sizeSet))
- {
- m_x = newX;
- m_y = newY;
- //
- };
- if ((m_width != newW) || (m_height != newH) || (!m_sizeSet))
- {
- m_width = newW;
- m_height = newH;
- //
- };
-
- wxSizeEvent event( wxSize(m_width,m_height), GetId() );
- event.SetEventObject( this );
- ProcessEvent( event );
-};
+ // TODO
+}
-void wxWindow::SetSize( int width, int height )
+void wxWindow::CaptureMouse()
{
- SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
-};
+ // TODO
+}
-void wxWindow::Move( int x, int y )
+void wxWindow::ReleaseMouse()
{
- SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
-};
+ // TODO
+}
-void wxWindow::GetSize( int *width, int *height ) const
+// Push/pop event handler (i.e. allow a chain of event handlers
+// be searched)
+void wxWindow::PushEventHandler(wxEvtHandler *handler)
{
- if (width) (*width) = m_width;
- if (height) (*height) = m_height;
-};
+ handler->SetNextHandler(GetEventHandler());
+ SetEventHandler(handler);
+}
-void wxWindow::SetClientSize( int width, int height )
+wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
+{
+ if ( GetEventHandler() )
+ {
+ wxEvtHandler *handlerA = GetEventHandler();
+ wxEvtHandler *handlerB = handlerA->GetNextHandler();
+ handlerA->SetNextHandler(NULL);
+ SetEventHandler(handlerB);
+ if ( deleteHandler )
+ {
+ delete handlerA;
+ return NULL;
+ }
+ else
+ return handlerA;
+ }
+ else
+ return NULL;
+}
+
+#if USE_DRAG_AND_DROP
+
+void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
{
-};
+ if ( m_pDropTarget != 0 ) {
+ m_pDropTarget->Revoke(m_hWnd);
+ delete m_pDropTarget;
+ }
-void wxWindow::GetClientSize( int *width, int *height ) const
+ m_pDropTarget = pDropTarget;
+ if ( m_pDropTarget != 0 )
+ m_pDropTarget->Register(m_hWnd);
+}
+
+#endif
+
+// Old style file-manager drag&drop
+void wxWindow::DragAcceptFiles(bool accept)
{
-};
+ // TODO
+}
-void wxWindow::GetPosition( int *x, int *y ) const
+// Get total size
+void wxWindow::GetSize(int *x, int *y) const
{
- if (x) (*x) = m_x;
- if (y) (*y) = m_y;
-};
+ // TODO
+}
-void wxWindow::ClientToScreen( int *x, int *y )
+void wxWindow::GetPosition(int *x, int *y) const
{
-};
+ // TODO
+}
-void wxWindow::ScreenToClient( int *x, int *y )
+void wxWindow::ScreenToClient(int *x, int *y) const
{
-};
+ // TODO
+}
-void wxWindow::Centre( int direction )
+void wxWindow::ClientToScreen(int *x, int *y) const
{
-};
+ // TODO
+}
-void wxWindow::Fit(void)
+void wxWindow::SetCursor(const wxCursor& cursor)
{
- int maxX = 0;
- int maxY = 0;
- wxNode *node = GetChildren()->First();
- while ( node )
+ m_windowCursor = cursor;
+ if (m_windowCursor.Ok())
{
- wxWindow *win = (wxWindow *)node->Data();
- int wx, wy, ww, wh;
- win->GetPosition(&wx, &wy);
- win->GetSize(&ww, &wh);
- if ( wx + ww > maxX )
- maxX = wx + ww;
- if ( wy + wh > maxY )
- maxY = wy + wh;
-
- node = node->Next();
+ // TODO
}
- SetClientSize(maxX + 5, maxY + 10);
-};
+}
-void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
-{
- //if (GetAutoLayout()) Layout();
-};
-bool wxWindow::Show( bool show )
+// Get size *available for subwindows* i.e. excluding menu bar etc.
+void wxWindow::GetClientSize(int *x, int *y) const
{
- return TRUE;
-};
+ // TODO
+}
-void wxWindow::Enable( bool enable )
+void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags)
{
- m_isEnabled = enable;
-};
+ // TODO
+}
-void wxWindow::MakeModal( bool modal )
+void wxWindow::SetClientSize(int width, int height)
{
+ // TODO
}
-void wxWindow::SetFocus(void)
+// For implementation purposes - sometimes decorations make the client area
+// smaller
+wxPoint wxWindow::GetClientAreaOrigin() const
{
-};
+ return wxPoint(0, 0);
+}
-bool wxWindow::OnClose(void)
+// Makes an adjustment to the window position (for example, a frame that has
+// a toolbar that it manages itself).
+void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
{
- return TRUE;
-};
+ if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
+ {
+ wxPoint pt(GetParent()->GetClientAreaOrigin());
+ x += pt.x; y += pt.y;
+ }
+}
-void wxWindow::AddChild( wxWindow *child )
+bool wxWindow::Show(bool show)
{
-};
+ // TODO
+ return FALSE;
+}
-wxList *wxWindow::GetChildren(void)
+bool wxWindow::IsShown() const
{
- return (&m_children);
-};
+ // TODO
+ return FALSE;
+}
-void wxWindow::RemoveChild( wxWindow *child )
+int wxWindow::GetCharHeight() const
{
- if (GetChildren())
- GetChildren()->DeleteObject( child );
- child->m_parent = NULL;
-};
+ // TODO
+ return 0;
+}
-void wxWindow::SetReturnCode( int retCode )
+int wxWindow::GetCharWidth() const
{
- m_retCode = retCode;
-};
+ // TODO
+ return 0;
+}
-int wxWindow::GetReturnCode(void)
+void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
+ int *descent, int *externalLeading, const wxFont *theFont, bool) const
{
- return m_retCode;
-};
+ wxFont *fontToUse = (wxFont *)theFont;
+ if (!fontToUse)
+ fontToUse = (wxFont *) & m_windowFont;
-wxWindow *wxWindow::GetParent(void)
-{
- return m_parent;
-};
+ // TODO
+}
-wxEvtHandler *wxWindow::GetEventHandler(void)
+void wxWindow::Refresh(bool eraseBack, const wxRectangle *rect)
{
- return m_eventHandler;
-};
+ // TODO
+}
-void wxWindow::SetEventhandler( wxEvtHandler *handler )
+// Responds to colour changes: passes event on to children.
+void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
{
- m_eventHandler = handler;
-};
+ wxNode *node = GetChildren()->First();
+ while ( node )
+ {
+ // Only propagate to non-top-level windows
+ wxWindow *win = (wxWindow *)node->Data();
+ if ( win->GetParent() )
+ {
+ wxSysColourChangedEvent event2;
+ event.m_eventObject = win;
+ win->GetEventHandler()->ProcessEvent(event2);
+ }
-wxValidator *wxWindow::GetValidator(void)
-{
- return m_windowValidator;
-};
+ node = node->Next();
+ }
+}
-void wxWindow::SetValidator( wxValidator *validator )
+// This can be called by the app (or wxWindows) to do default processing for the current
+// event. Save message/event info in wxWindow so they can be used in this function.
+long wxWindow::Default()
{
- m_windowValidator = validator;
-};
+ // TODO
+ return 0;
+}
-bool wxWindow::IsBeingDeleted(void)
+void wxWindow::InitDialog()
{
- return FALSE;
-};
+ wxInitDialogEvent event(GetId());
+ event.SetEventObject( this );
+ GetEventHandler()->ProcessEvent(event);
+}
-void wxWindow::SetId( wxWindowID id )
+// Default init dialog behaviour is to transfer data to window
+void wxWindow::OnInitDialog(wxInitDialogEvent& event)
{
- m_windowId = id;
-};
+ TransferDataToWindow();
+}
-wxWindowID wxWindow::GetId(void)
+// Caret manipulation
+void wxWindow::CreateCaret(int w, int h)
{
- return m_windowId;
-};
+ m_caretWidth = w;
+ m_caretHeight = h;
+ m_caretEnabled = TRUE;
+}
-void wxWindow::SetCursor( const wxCursor &cursor )
+void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
{
- if (*m_cursor == cursor) return;
- (*m_cursor) = cursor;
-};
+ // TODO
+}
-void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
+void wxWindow::ShowCaret(bool show)
{
-};
+ // TODO
+}
-bool wxWindow::IsExposed( long x, long y )
+void wxWindow::DestroyCaret()
{
- return (m_updateRegion.Contains( x, y ) != wxOutRegion );
-};
+ // TODO
+ m_caretEnabled = FALSE;
+}
-bool wxWindow::IsExposed( long x, long y, long width, long height )
+void wxWindow::SetCaretPos(int x, int y)
{
- return (m_updateRegion.Contains( x, y, width, height ) != wxOutRegion );
-};
+ // TODO
+}
-void wxWindow::Clear(void)
+void wxWindow::GetCaretPos(int *x, int *y) const
{
-};
+ // TODO
+}
-wxColour wxWindow::GetBackgroundColour(void) const
+wxWindow *wxGetActiveWindow()
{
- return m_backgroundColour;
-};
+ // TODO
+ return NULL;
+}
-void wxWindow::SetBackgroundColour( const wxColour &colour )
+void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH))
{
- m_backgroundColour = colour;
-};
+ m_minSizeX = minW;
+ m_minSizeY = minH;
+ m_maxSizeX = maxW;
+ m_maxSizeY = maxH;
+}
-bool wxWindow::Validate(void)
+void wxWindow::Centre(int direction)
{
- wxNode *node = GetChildren()->First();
- while (node)
- {
- wxWindow *child = (wxWindow *)node->Data();
- if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
- { return FALSE; }
- node = node->Next();
- };
- return TRUE;
-};
+ int x, y, width, height, panel_width, panel_height, new_x, new_y;
-bool wxWindow::TransferDataToWindow(void)
-{
- wxNode *node = GetChildren()->First();
- while (node)
- {
- wxWindow *child = (wxWindow *)node->Data();
- if (child->GetValidator() && /* child->GetValidator()->Ok() && */
- !child->GetValidator()->TransferToWindow() )
- {
- wxMessageBox( "Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION );
- return FALSE;
- };
- node = node->Next();
- };
- return TRUE;
-};
+ wxWindow *father = (wxWindow *)GetParent();
+ if (!father)
+ return;
-bool wxWindow::TransferDataFromWindow(void)
-{
- wxNode *node = GetChildren()->First();
- while (node)
- {
- wxWindow *child = (wxWindow *)node->Data();
- if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
- { return FALSE; }
- node = node->Next();
- }
- return TRUE;
-};
+ father->GetClientSize(&panel_width, &panel_height);
+ GetSize(&width, &height);
+ GetPosition(&x, &y);
-void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
-{
- TransferDataToWindow();
-};
+ new_x = -1;
+ new_y = -1;
-void wxWindow::InitDialog(void)
-{
- wxInitDialogEvent event(GetId());
- event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(event);
-};
+ if (direction & wxHORIZONTAL)
+ new_x = (int)((panel_width - width)/2);
-void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
-{
- if (m_pDropTarget)
- {
- m_pDropTarget->UnregisterWidget( dnd_widget );
- delete m_pDropTarget;
- };
- m_pDropTarget = dropTarget;
- if (m_pDropTarget)
- {
- };
-};
+ if (direction & wxVERTICAL)
+ new_y = (int)((panel_height - height)/2);
-wxDropTarget *wxWindow::GetDropTarget() const
-{
- return m_pDropTarget;
-};
+ SetSize(new_x, new_y, -1, -1);
-void wxWindow::SetFont( const wxFont &font )
-{
- m_font = font;
-/*
- ...
-*/
-};
+}
-wxFont *wxWindow::GetFont(void)
+// Coordinates relative to the window
+void wxWindow::WarpPointer (int x_pos, int y_pos)
{
- return &m_font;
-};
+ // TODO
+}
-void wxWindow::SetWindowStyleFlag( long flag )
+void wxWindow::OnEraseBackground(wxEraseEvent& event)
{
- m_windowStyle = flag;
-};
+ // TODO
+ Default();
+}
-long wxWindow::GetWindowStyleFlag(void) const
+int wxWindow::GetScrollPos(int orient) const
{
- return m_windowStyle;
-};
+ // TODO
+ return 0;
+}
-void wxWindow::CaptureMouse(void)
+// This now returns the whole range, not just the number
+// of positions that we can scroll.
+int wxWindow::GetScrollRange(int orient) const
{
-};
+ // TODO
+ return 0;
+}
-void wxWindow::ReleaseMouse(void)
+int wxWindow::GetScrollThumb(int orient) const
{
-};
+ // TODO
+ return 0;
+}
-void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
+void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
{
-};
+ // TODO
+ return 0;
+}
-wxString wxWindow::GetTitle(void) const
+// New function that will replace some of the above.
+void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
+ int range, bool refresh)
{
- return (wxString&)m_windowName;
-};
+ // TODO
+}
-wxString wxWindow::GetLabel(void) const
+// Does a physical scroll
+void wxWindow::ScrollWindow(int dx, int dy, const wxRectangle *rect)
{
- return GetTitle();
-};
+ // TODO
+ return 0;
+}
-void wxWindow::SetName( const wxString &name )
+void wxWindow::SetFont(const wxFont& font)
{
- m_windowName = name;
-};
+ m_windowFont = font;
-wxString wxWindow::GetName(void) const
-{
- return (wxString&)m_windowName;
-};
+ if (!m_windowFont.Ok())
+ return;
+ // TODO
+}
-bool wxWindow::IsShown(void) const
+void wxWindow::OnChar(wxKeyEvent& event)
{
- return m_isShown;
-};
+ if ( event.KeyCode() == WXK_TAB ) {
+ // propagate the TABs to the parent - it's up to it to decide what
+ // to do with it
+ if ( GetParent() ) {
+ if ( GetParent()->ProcessEvent(event) )
+ return;
+ }
+ }
+}
-bool wxWindow::IsRetained(void)
+void wxWindow::OnPaint(wxPaintEvent& event)
{
- return FALSE;
-};
+ Default();
+}
-wxWindow *wxWindow::FindWindow( long id )
+bool wxWindow::IsEnabled() const
{
- if (id == m_windowId) return this;
- wxNode *node = m_children.First();
- while (node)
- {
- wxWindow *child = (wxWindow*)node->Data();
- wxWindow *res = child->FindWindow( id );
- if (res) return res;
- node = node->Next();
- };
- return NULL;
-};
+ // TODO
+ return FALSE;
+}
-wxWindow *wxWindow::FindWindow( const wxString& name )
-{
- if (name == m_windowName) return this;
- wxNode *node = m_children.First();
- while (node)
- {
- wxWindow *child = (wxWindow*)node->Data();
- wxWindow *res = child->FindWindow( name );
- if (res) return res;
- node = node->Next();
- };
- return NULL;
-};
+// Dialog support: override these and call
+// base class members to add functionality
+// that can't be done using validators.
+// NOTE: these functions assume that controls
+// are direct children of this window, not grandchildren
+// or other levels of descendant.
+
+// Transfer values to controls. If returns FALSE,
+// it's an application error (pops up a dialog)
+bool wxWindow::TransferDataToWindow()
+{
+ wxNode *node = GetChildren()->First();
+ while ( node )
+ {
+ wxWindow *child = (wxWindow *)node->Data();
+ if ( child->GetValidator() &&
+ !child->GetValidator()->TransferToWindow() )
+ {
+ wxMessageBox("Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION);
+ return FALSE;
+ }
+
+ node = node->Next();
+ }
+ return TRUE;
+}
-void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
- int range, bool WXUNUSED(refresh) )
+// Transfer values from controls. If returns FALSE,
+// validation failed: don't quit
+bool wxWindow::TransferDataFromWindow()
+{
+ wxNode *node = GetChildren()->First();
+ while ( node )
+ {
+ wxWindow *child = (wxWindow *)node->Data();
+ if ( child->GetValidator() && !child->GetValidator()->TransferFromWindow() )
+ {
+ return FALSE;
+ }
+
+ node = node->Next();
+ }
+ return TRUE;
+}
+
+bool wxWindow::Validate()
{
-};
+ wxNode *node = GetChildren()->First();
+ while ( node )
+ {
+ wxWindow *child = (wxWindow *)node->Data();
+ if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) )
+ {
+ return FALSE;
+ }
-void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
+ node = node->Next();
+ }
+ return TRUE;
+}
+
+// Get the window with the focus
+wxWindow *wxWindow::FindFocus()
{
-};
+ // TODO
+ return NULL;
+}
-int wxWindow::GetScrollThumb( int orient ) const
+void wxWindow::AddChild(wxWindow *child)
{
-};
+ GetChildren()->Append(child);
+ child->m_windowParent = this;
+}
-int wxWindow::GetScrollPos( int orient ) const
+void wxWindow::RemoveChild(wxWindow *child)
{
-};
+ if (GetChildren())
+ GetChildren()->DeleteObject(child);
+ child->m_windowParent = NULL;
+}
-int wxWindow::GetScrollRange( int orient ) const
+void wxWindow::DestroyChildren()
{
-};
+ if (GetChildren()) {
+ wxNode *node;
+ while ((node = GetChildren()->First()) != (wxNode *)NULL) {
+ wxWindow *child;
+ if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
+ delete child;
+ if ( GetChildren()->Member(child) )
+ delete node;
+ }
+ } /* while */
+ }
+}
-void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
+void wxWindow::MakeModal(bool modal)
{
-};
+ // Disable all other windows
+ if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
+ {
+ wxNode *node = wxTopLevelWindows.First();
+ while (node)
+ {
+ wxWindow *win = (wxWindow *)node->Data();
+ if (win != this)
+ win->Enable(!modal);
-//-------------------------------------------------------------------------------------
-// Layout
-//-------------------------------------------------------------------------------------
+ node = node->Next();
+ }
+ }
+}
-wxLayoutConstraints *wxWindow::GetConstraints(void) const
+// If nothing defined for this, try the parent.
+// E.g. we may be a button loaded from a resource, with no callback function
+// defined.
+void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
{
- return m_constraints;
-};
+ if (GetEventHandler()->ProcessEvent(event) )
+ return;
+ if (m_windowParent)
+ m_windowParent->GetEventHandler()->OnCommand(win, event);
+}
-void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
+void wxWindow::SetConstraints(wxLayoutConstraints *c)
{
if (m_constraints)
{
UnsetConstraints(m_constraints);
delete m_constraints;
}
- m_constraints = constraints;
+ m_constraints = c;
if (m_constraints)
{
// Make sure other windows know they're part of a 'meaningful relationship'
if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
}
-;
}
-;
-
-void wxWindow::SetAutoLayout( bool autoLayout )
-{
- m_autoLayout = autoLayout;
-};
-
-bool wxWindow::GetAutoLayout(void) const
-{
- return m_autoLayout;
-};
-
-wxSizer *wxWindow::GetSizer(void) const
-{
- return m_windowSizer;
-};
-
-void wxWindow::SetSizerParent( wxWindow *win )
-{
- m_sizerParent = win;
-};
-
-wxWindow *wxWindow::GetSizerParent(void) const
-{
- return m_sizerParent;
-};
// This removes any dangling pointers to this window
// in other windows' constraintsInvolvedIn lists.
}
// Reset any constraints that mention this window
-void wxWindow::DeleteRelatedConstraints(void)
+void wxWindow::DeleteRelatedConstraints()
{
if (m_constraintsInvolvedIn)
{
* New version
*/
-bool wxWindow::Layout(void)
+bool wxWindow::Layout()
{
if (GetConstraints())
{
return TRUE;
}
-void wxWindow::ResetConstraints(void)
+void wxWindow::ResetConstraints()
{
wxLayoutConstraints *constr = GetConstraints();
if (constr)
char *windowClass = this->GetClassInfo()->GetClassName();
wxString winName;
- if (GetName() == "")
- winName = "unnamed";
- else
- winName = GetName();
+ if (GetName() == "")
+ winName = "unnamed";
+ else
+ winName = GetName();
wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
if (!constr->left.GetDone())
wxDebugMsg(" unsatisfied 'left' constraint.\n");
void wxWindow::TransformSizerToActual(int *x, int *y) const
{
if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
- m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
+ m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
return;
int xp, yp;
void wxWindow::SizerSetSize(int x, int y, int w, int h)
{
- int xx = x;
- int yy = y;
+ int xx = x;
+ int yy = y;
TransformSizerToActual(&xx, &yy);
SetSize(xx, yy, w, h);
}
void wxWindow::SizerMove(int x, int y)
{
- int xx = x;
- int yy = y;
+ int xx = x;
+ int yy = y;
TransformSizerToActual(&xx, &yy);
Move(xx, yy);
}
GetPosition(x, y);
}
+bool wxWindow::Close(bool force)
+{
+ wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
+ event.SetEventObject(this);
+ event.SetForce(force);
+
+ return GetEventHandler()->ProcessEvent(event);
+}
+
+wxObject* wxWindow::GetChild(int number) const
+{
+ // Return a pointer to the Nth object in the window
+ if (!GetChildren())
+ return(NULL) ;
+ wxNode *node = GetChildren()->First();
+ int n = number;
+ while (node && n--)
+ node = node->Next() ;
+ if (node)
+ {
+ wxObject *obj = (wxObject *)node->Data();
+ return(obj) ;
+ }
+ else
+ return NULL ;
+}
+
+void wxWindow::OnDefaultAction(wxControl *initiatingItem)
+{
+ // Obsolete function
+}
+
+void wxWindow::Clear()
+{
+ wxClientDC dc(this);
+ wxBrush brush(GetBackgroundColour(), wxSOLID);
+ dc.SetBackground(brush);
+ dc.Clear();
+}
+
+// Fits the panel around the items
+void wxWindow::Fit()
+{
+ int maxX = 0;
+ int maxY = 0;
+ wxNode *node = GetChildren()->First();
+ while ( node )
+ {
+ wxWindow *win = (wxWindow *)node->Data();
+ int wx, wy, ww, wh;
+ win->GetPosition(&wx, &wy);
+ win->GetSize(&ww, &wh);
+ if ( wx + ww > maxX )
+ maxX = wx + ww;
+ if ( wy + wh > maxY )
+ maxY = wy + wh;
+
+ node = node->Next();
+ }
+ SetClientSize(maxX + 5, maxY + 5);
+}
+
+void wxWindow::SetValidator(const wxValidator& validator)
+{
+ if ( m_windowValidator )
+ delete m_windowValidator;
+ m_windowValidator = validator.Clone();
+
+ if ( m_windowValidator )
+ m_windowValidator->SetWindow(this) ;
+}
+
+// Find a window by id or name
+wxWindow *wxWindow::FindWindow(long id)
+{
+ if ( GetId() == id)
+ return this;
+
+ wxNode *node = GetChildren()->First();
+ while ( node )
+ {
+ wxWindow *child = (wxWindow *)node->Data();
+ wxWindow *found = child->FindWindow(id);
+ if ( found )
+ return found;
+ node = node->Next();
+ }
+ return NULL;
+}
+
+wxWindow *wxWindow::FindWindow(const wxString& name)
+{
+ if ( GetName() == name)
+ return this;
+
+ wxNode *node = GetChildren()->First();
+ while ( node )
+ {
+ wxWindow *child = (wxWindow *)node->Data();
+ wxWindow *found = child->FindWindow(name);
+ if ( found )
+ return found;
+ node = node->Next();
+ }
+ return NULL;
+}
+
+void wxWindow::OnIdle(wxIdleEvent& event)
+{
+/* TODO: you may need to do something like this
+ * if your GUI doesn't generate enter/leave events
+
+ // Check if we need to send a LEAVE event
+ if (m_mouseInWindow)
+ {
+ POINT pt;
+ ::GetCursorPos(&pt);
+ if (::WindowFromPoint(pt) != (HWND) GetHWND())
+ {
+ // Generate a LEAVE event
+ m_mouseInWindow = FALSE;
+ MSWOnMouseLeave(pt.x, pt.y, 0);
+ }
+ }
+*/
+
+ // This calls the UI-update mechanism (querying windows for
+ // menu/toolbar/control state information)
+ UpdateWindowUI();
+}
+
+// Raise the window to the top of the Z order
+void wxWindow::Raise()
+{
+ // TODO
+}
+
+// Lower the window to the bottom of the Z order
+void wxWindow::Lower()
+{
+ // TODO
+}
+
bool wxWindow::AcceptsFocus() const
{
- return IsEnabled() && IsShown();
+ return IsShown() && IsEnabled();
+}
+
+// Update region access
+wxRegion wxWindow::GetUpdateRegion() const
+{
+ return m_updateRegion;
}
-void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )
+bool wxWindow::IsExposed(int x, int y, int w, int h) const
{
- UpdateWindowUI();
+ return (m_updateRegion.Contains(x, y, w, h) != wxOutRegion);
}
+
+bool wxWindow::IsExposed(const wxPoint& pt) const
+{
+ return (m_updateRegion.Contains(pt) != wxOutRegion);
+}
+
+bool wxWindow::IsExposed(const wxRect& rect) const
+{
+ return (m_updateRegion.Contains(rect) != wxOutRegion);
+}
+
+
projects / wxWidgets.git / commitdiff
