From 7c23a0b01b3fb667ec41fc8271ce1ee5b5aa4e19 Mon Sep 17 00:00:00 2001 From: Julian Smart Date: Sat, 8 Aug 1998 09:19:47 +0000 Subject: [PATCH] Added stub include files; also a couple more Dialog Editor files. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@475 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/stubs/accel.h | 80 +++++ include/wx/stubs/app.h | 154 +++++++++ include/wx/stubs/bitmap.h | 197 +++++++++++ include/wx/stubs/bmpbuttn.h | 83 +++++ include/wx/stubs/brush.h | 76 +++++ include/wx/stubs/button.h | 53 +++ include/wx/stubs/checkbox.h | 81 +++++ include/wx/stubs/checklst.h | 62 ++++ include/wx/stubs/choice.h | 72 ++++ include/wx/stubs/clipbrd.h | 104 ++++++ include/wx/stubs/colordlg.h | 45 +++ include/wx/stubs/colour.h | 68 ++++ include/wx/stubs/combobox.h | 78 +++++ include/wx/stubs/control.h | 50 +++ include/wx/stubs/cursor.h | 73 +++++ include/wx/stubs/dc.h | 294 +++++++++++++++++ include/wx/stubs/dcclient.h | 61 ++++ include/wx/stubs/dcmemory.h | 35 ++ include/wx/stubs/dcprint.h | 34 ++ include/wx/stubs/dcscreen.h | 39 +++ include/wx/stubs/dialog.h | 101 ++++++ include/wx/stubs/dirdlg.h | 47 +++ include/wx/stubs/filedlg.h | 89 +++++ include/wx/stubs/font.h | 86 +++++ include/wx/stubs/fontdlg.h | 45 +++ include/wx/stubs/frame.h | 156 +++++++++ include/wx/stubs/gauge.h | 69 ++++ include/wx/stubs/gdiobj.h | 48 +++ include/wx/stubs/helpxxxx.h | 52 +++ include/wx/stubs/icon.h | 107 ++++++ include/wx/stubs/imaglist.h | 143 ++++++++ include/wx/stubs/joystick.h | 93 ++++++ include/wx/stubs/listbox.h | 97 ++++++ include/wx/stubs/listctrl.h | 455 ++++++++++++++++++++++++++ include/wx/stubs/mdi.h | 160 +++++++++ include/wx/stubs/menu.h | 158 +++++++++ include/wx/stubs/metafile.h | 100 ++++++ include/wx/stubs/minifram.h | 45 +++ include/wx/stubs/msgdlg.h | 49 +++ include/wx/stubs/notebook.h | 202 ++++++++++++ include/wx/stubs/palette.h | 66 ++++ include/wx/stubs/pen.h | 92 ++++++ include/wx/stubs/print.h | 56 ++++ include/wx/stubs/printdlg.h | 72 ++++ include/wx/stubs/private.h | 21 ++ include/wx/stubs/radiobox.h | 92 ++++++ include/wx/stubs/radiobut.h | 92 ++++++ include/wx/stubs/region.h | 140 ++++++++ include/wx/stubs/scrolbar.h | 68 ++++ include/wx/stubs/settings.h | 129 ++++++++ include/wx/stubs/setup.h | 115 +++++++ include/wx/stubs/slider.h | 91 ++++++ include/wx/stubs/spinbutt.h | 97 ++++++ include/wx/stubs/statbmp.h | 64 ++++ include/wx/stubs/statbox.h | 57 ++++ include/wx/stubs/statbrxx.h | 48 +++ include/wx/stubs/stattext.h | 56 ++++ include/wx/stubs/tabctrl.h | 138 ++++++++ include/wx/stubs/taskbar.h | 72 ++++ include/wx/stubs/textctrl.h | 141 ++++++++ include/wx/stubs/timer.h | 57 ++++ include/wx/stubs/toolbar.h | 78 +++++ include/wx/stubs/treectrl.h | 295 +++++++++++++++++ include/wx/stubs/wave.h | 44 +++ include/wx/stubs/window.h | 559 ++++++++++++++++++++++++++++++++ utils/dialoged/src/winstyle.cpp | 378 +++++++++++++++++++++ utils/dialoged/src/winstyle.h | 77 +++++ 67 files changed, 7236 insertions(+) create mode 100644 include/wx/stubs/accel.h create mode 100644 include/wx/stubs/app.h create mode 100644 include/wx/stubs/bitmap.h create mode 100644 include/wx/stubs/bmpbuttn.h create mode 100644 include/wx/stubs/brush.h create mode 100644 include/wx/stubs/button.h create mode 100644 include/wx/stubs/checkbox.h create mode 100644 include/wx/stubs/checklst.h create mode 100644 include/wx/stubs/choice.h create mode 100644 include/wx/stubs/clipbrd.h create mode 100644 include/wx/stubs/colordlg.h create mode 100644 include/wx/stubs/colour.h create mode 100644 include/wx/stubs/combobox.h create mode 100644 include/wx/stubs/control.h create mode 100644 include/wx/stubs/cursor.h create mode 100644 include/wx/stubs/dc.h create mode 100644 include/wx/stubs/dcclient.h create mode 100644 include/wx/stubs/dcmemory.h create mode 100644 include/wx/stubs/dcprint.h create mode 100644 include/wx/stubs/dcscreen.h create mode 100644 include/wx/stubs/dialog.h create mode 100644 include/wx/stubs/dirdlg.h create mode 100644 include/wx/stubs/filedlg.h create mode 100644 include/wx/stubs/font.h create mode 100644 include/wx/stubs/fontdlg.h create mode 100644 include/wx/stubs/frame.h create mode 100644 include/wx/stubs/gauge.h create mode 100644 include/wx/stubs/gdiobj.h create mode 100644 include/wx/stubs/helpxxxx.h create mode 100644 include/wx/stubs/icon.h create mode 100644 include/wx/stubs/imaglist.h create mode 100644 include/wx/stubs/joystick.h create mode 100644 include/wx/stubs/listbox.h create mode 100644 include/wx/stubs/listctrl.h create mode 100644 include/wx/stubs/mdi.h create mode 100644 include/wx/stubs/menu.h create mode 100644 include/wx/stubs/metafile.h create mode 100644 include/wx/stubs/minifram.h create mode 100644 include/wx/stubs/msgdlg.h create mode 100644 include/wx/stubs/notebook.h create mode 100644 include/wx/stubs/palette.h create mode 100644 include/wx/stubs/pen.h create mode 100644 include/wx/stubs/print.h create mode 100644 include/wx/stubs/printdlg.h create mode 100644 include/wx/stubs/private.h create mode 100644 include/wx/stubs/radiobox.h create mode 100644 include/wx/stubs/radiobut.h create mode 100644 include/wx/stubs/region.h create mode 100644 include/wx/stubs/scrolbar.h create mode 100644 include/wx/stubs/settings.h create mode 100644 include/wx/stubs/setup.h create mode 100644 include/wx/stubs/slider.h create mode 100644 include/wx/stubs/spinbutt.h create mode 100644 include/wx/stubs/statbmp.h create mode 100644 include/wx/stubs/statbox.h create mode 100644 include/wx/stubs/statbrxx.h create mode 100644 include/wx/stubs/stattext.h create mode 100644 include/wx/stubs/tabctrl.h create mode 100644 include/wx/stubs/taskbar.h create mode 100644 include/wx/stubs/textctrl.h create mode 100644 include/wx/stubs/timer.h create mode 100644 include/wx/stubs/toolbar.h create mode 100644 include/wx/stubs/treectrl.h create mode 100644 include/wx/stubs/wave.h create mode 100644 include/wx/stubs/window.h create mode 100644 utils/dialoged/src/winstyle.cpp create mode 100644 utils/dialoged/src/winstyle.h diff --git a/include/wx/stubs/accel.h b/include/wx/stubs/accel.h new file mode 100644 index 0000000000..3b8d3379f9 --- /dev/null +++ b/include/wx/stubs/accel.h @@ -0,0 +1,80 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: accel.h +// Purpose: wxAcceleratorTable class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_ACCEL_H_ +#define _WX_ACCEL_H_ + +#ifdef __GNUG__ +#pragma interface "accel.h" +#endif + +#include "wx/object.h" + +class WXDLLEXPORT wxAcceleratorTable; + +// Hold Ctrl key down +#define wxACCEL_ALT 0x01 + +// Hold Ctrl key down +#define wxACCEL_CTRL 0x02 + + // Hold Shift key down +#define wxACCEL_SHIFT 0x04 + +class WXDLLEXPORT wxAcceleratorEntry +{ +public: + wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0) + { + m_flags = flags; m_keyCode = keyCode; m_command = cmd; + } + + inline void Set(int flags, int keyCode, int cmd) + { m_flags = flags; m_keyCode = keyCode; m_command = cmd; } + + inline int GetFlags() const { return m_flags; } + inline int GetKeyCode() const { return m_keyCode; } + inline int GetCommand() const { return m_command; } + + int m_flags; + int m_keyCode; // ASCII or virtual keycode + int m_command; // Command id to generate +}; + +class WXDLLEXPORT wxAcceleratorTable: public wxObject +{ +DECLARE_DYNAMIC_CLASS(wxAcceleratorTable) +public: + wxAcceleratorTable(); + wxAcceleratorTable(const wxString& resource); // Load from .rc resource + wxAcceleratorTable(int n, wxAcceleratorEntry entries[]); // Load from array + + // Copy constructors + inline wxAcceleratorTable(const wxAcceleratorTable& accel) { Ref(accel); } + inline wxAcceleratorTable(const wxAcceleratorTable* accel) { if (accel) Ref(*accel); } + + ~wxAcceleratorTable(); + + inline wxAcceleratorTable& operator = (const wxAcceleratorTable& accel) { if (*this == accel) return (*this); Ref(accel); return *this; } + inline bool operator == (const wxAcceleratorTable& accel) { return m_refData == accel.m_refData; } + inline bool operator != (const wxAcceleratorTable& accel) { return m_refData != accel.m_refData; } + + bool Ok() const; +/* TODO: Accessors for your GUI + void SetHACCEL(WXHACCEL hAccel); + WXHACCEL GetHACCEL() const; +*/ +}; + +WXDLLEXPORT_DATA(extern wxAcceleratorTable) wxNullAcceleratorTable; + +#endif + // _WX_ACCEL_H_ diff --git a/include/wx/stubs/app.h b/include/wx/stubs/app.h new file mode 100644 index 0000000000..2eafa1f15f --- /dev/null +++ b/include/wx/stubs/app.h @@ -0,0 +1,154 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: app.h +// Purpose: wxApp class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_APP_H_ +#define _WX_APP_H_ + +#ifdef __GNUG__ +#pragma interface "app.h" +#endif + +#include "wx/defs.h" +#include "wx/object.h" + +class WXDLLEXPORT wxFrame; +class WXDLLEXPORT wxWindow; +class WXDLLEXPORT wxApp ; +class WXDLLEXPORT wxKeyEvent; +class WXDLLEXPORT wxLog; + +#define wxPRINT_WINDOWS 1 +#define wxPRINT_POSTSCRIPT 2 + +WXDLLEXPORT_DATA(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 + +// Force an exit from main loop +void WXDLLEXPORT wxExit(); + +// Yield to other apps/messages +bool WXDLLEXPORT wxYield(); + +// 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() {} + + static void SetInitializerFunction(wxAppInitializerFunction fn) { m_appInitFn = fn; } + static wxAppInitializerFunction GetInitializerFunction() { return m_appInitFn; } + + virtual int MainLoop(); + void ExitMainLoop(); + bool Initialized(); + virtual bool Pending() ; + virtual void Dispatch() ; + + virtual void OnIdle(wxIdleEvent& event); + +// Generic + virtual bool OnInit() { return FALSE; }; + + // No specific tasks to do here. + virtual bool OnInitGui() { return TRUE; } + + // Called to set off the main loop + virtual int OnRun() { return MainLoop(); }; + virtual int OnExit() { return 0; } + + 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() 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 CleanUp(); + static void CommonCleanUp(); + void DeletePendingObjects(); + bool ProcessIdle(); + +public: + static long sm_lastMessageTime; + int m_nCmdShow; + +protected: + bool m_keepGoing ; + +DECLARE_EVENT_TABLE() +}; + +// TODO: add platform-specific arguments, e.g. int argc, char* argv[] +int WXDLLEXPORT wxEntry(); + +#endif + // _WX_APP_H_ + diff --git a/include/wx/stubs/bitmap.h b/include/wx/stubs/bitmap.h new file mode 100644 index 0000000000..f01c6a2de3 --- /dev/null +++ b/include/wx/stubs/bitmap.h @@ -0,0 +1,197 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: bitmap.h +// Purpose: wxBitmap class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_BITMAP_H_ +#define _WX_BITMAP_H_ + +#ifdef __GNUG__ +#pragma interface "bitmap.h" +#endif + +#include "wx/gdiobj.h" +#include "wx/gdicmn.h" +#include "wx/palette.h" + +// 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) + +public: + wxMask(); + + // Construct a mask from a bitmap and a colour indicating + // the transparent area + wxMask(const wxBitmap& bitmap, const wxColour& colour); + + // Construct a mask from a bitmap and a palette index indicating + // the transparent area + wxMask(const wxBitmap& bitmap, int paletteIndex); + + // Construct a mask from a mono bitmap (copies the bitmap). + 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); + +/* TODO: platform-specific data access + // Implementation + inline WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; } + inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; } +protected: + WXHBITMAP m_maskBitmap; +*/ +}; + +class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData +{ + 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 +}; + +#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; +}; +#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData()) + +class WXDLLEXPORT wxBitmap: public wxGDIObject +{ + DECLARE_DYNAMIC_CLASS(wxBitmap) + + 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 + // _WX_BITMAP_H_ diff --git a/include/wx/stubs/bmpbuttn.h b/include/wx/stubs/bmpbuttn.h new file mode 100644 index 0000000000..defe39e438 --- /dev/null +++ b/include/wx/stubs/bmpbuttn.h @@ -0,0 +1,83 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: bmpbuttn.h +// Purpose: wxBitmapButton class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_BMPBUTTN_H_ +#define _WX_BMPBUTTN_H_ + +#ifdef __GNUG__ +#pragma interface "bmpbuttn.h" +#endif + +#include "wx/button.h" + +WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr; + +#define wxDEFAULT_BUTTON_MARGIN 4 + +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); + } + + 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); + + virtual void SetLabel(const wxBitmap& bitmap) + { + SetBitmapLabel(bitmap); + } + + virtual void SetBitmapLabel(const wxBitmap& bitmap); + + 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; } + + 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 + // _WX_BMPBUTTN_H_ diff --git a/include/wx/stubs/brush.h b/include/wx/stubs/brush.h new file mode 100644 index 0000000000..cdedb4045e --- /dev/null +++ b/include/wx/stubs/brush.h @@ -0,0 +1,76 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: brush.h +// Purpose: wxBrush class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_BRUSH_H_ +#define _WX_BRUSH_H_ + +#ifdef __GNUG__ +#pragma interface "brush.h" +#endif + +#include "wx/gdicmn.h" +#include "wx/gdiobj.h" +#include "wx/bitmap.h" + +class WXDLLEXPORT wxBrush; + +class WXDLLEXPORT wxBrushRefData: public wxGDIRefData +{ + friend class WXDLLEXPORT wxBrush; +public: + wxBrushRefData(); + ~wxBrushRefData(); + +protected: + int m_style; + wxBitmap m_stipple ; + wxColour m_colour; + +/* TODO: implementation + WXHBRUSH m_hBrush; +*/ +}; + +#define M_BRUSHDATA ((wxBrushRefData *)m_refData) + +// Brush +class WXDLLEXPORT wxBrush: public wxGDIObject +{ + DECLARE_DYNAMIC_CLASS(wxBrush) + +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(const unsigned char r, const unsigned char g, const 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) ; } +}; + +#endif + // _WX_BRUSH_H_ diff --git a/include/wx/stubs/button.h b/include/wx/stubs/button.h new file mode 100644 index 0000000000..68b67d8c96 --- /dev/null +++ b/include/wx/stubs/button.h @@ -0,0 +1,53 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: button.h +// Purpose: wxButton class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_BUTTON_H_ +#define _WX_BUTTON_H_ + +#ifdef __GNUG__ +#pragma interface "button.h" +#endif + +#include "wx/control.h" +#include "wx/gdicmn.h" + +WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr; + +// Pushbutton +class WXDLLEXPORT wxButton: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxButton) + 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 + // _WX_BUTTON_H_ diff --git a/include/wx/stubs/checkbox.h b/include/wx/stubs/checkbox.h new file mode 100644 index 0000000000..8bf41d9958 --- /dev/null +++ b/include/wx/stubs/checkbox.h @@ -0,0 +1,81 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: checkbox.h +// Purpose: wxCheckBox class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CHECKBOX_H_ +#define _WX_CHECKBOX_H_ + +#ifdef __GNUG__ +#pragma interface "checkbox.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxCheckBoxNameStr; + +// Checkbox item (single checkbox) +class WXDLLEXPORT wxBitmap; +class WXDLLEXPORT wxCheckBox: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxCheckBox) + + 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); + } + + 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 WXDLLEXPORT wxBitmapCheckBox: public wxCheckBox +{ + DECLARE_DYNAMIC_CLASS(wxBitmapCheckBox) + + 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); + } + + 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_ diff --git a/include/wx/stubs/checklst.h b/include/wx/stubs/checklst.h new file mode 100644 index 0000000000..fb623cec0f --- /dev/null +++ b/include/wx/stubs/checklst.h @@ -0,0 +1,62 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: checklst.h +// Purpose: wxCheckListBox class - a listbox with checkable items +// Note: this is an optional class. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CHECKLST_H_ +#define _WX_CHECKLST_H_ + +#ifdef __GNUG__ +#pragma interface "checklst.h" +#endif + +typedef unsigned int uint; + +class wxCheckListBoxItem; // fwd decl, define in checklst.cpp + +class wxCheckListBox : public wxListBox +{ + DECLARE_DYNAMIC_CLASS(wxCheckListBox) +public: + // ctors + wxCheckListBox(); + wxCheckListBox(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + int nStrings = 0, + const wxString choices[] = NULL, + long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxListBoxNameStr); + + // items may be checked + bool IsChecked(uint uiIndex) const; + void Check(uint uiIndex, bool bCheck = TRUE); + + // accessors + uint GetItemHeight() const { return m_nItemHeight; } + +protected: + // we create our items ourselves and they have non-standard size, + // so we need to override these functions + virtual wxOwnerDrawn *CreateItem(uint n); + + // pressing space or clicking the check box toggles the item + void OnChar(wxKeyEvent& event); + void OnLeftClick(wxMouseEvent& event); + +private: + uint m_nItemHeight; // height of checklistbox items (the same for all) + + DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_CHECKLST_H_ diff --git a/include/wx/stubs/choice.h b/include/wx/stubs/choice.h new file mode 100644 index 0000000000..7f360ed5cc --- /dev/null +++ b/include/wx/stubs/choice.h @@ -0,0 +1,72 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: choice.h +// Purpose: wxChoice class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CHOICE_H_ +#define _WX_CHOICE_H_ + +#ifdef __GNUG__ +#pragma interface "choice.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxChoiceNameStr; + +// Choice item +class WXDLLEXPORT wxChoice: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxChoice) + + public: + inline wxChoice() { m_noStrings = 0; } + + 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); + } + + 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); + + 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); + + virtual inline void SetColumns(int WXUNUSED(n) = 1 ) { /* No effect */ } ; + virtual inline int GetColumns() const { return 1 ; }; + +protected: + int m_noStrings; +}; + +#endif + // _WX_CHOICE_H_ diff --git a/include/wx/stubs/clipbrd.h b/include/wx/stubs/clipbrd.h new file mode 100644 index 0000000000..3b1c5957b5 --- /dev/null +++ b/include/wx/stubs/clipbrd.h @@ -0,0 +1,104 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: clipbrd.h +// Purpose: Clipboard functionality. +// Note: this functionality is under review, and +// is derived from wxWindows 1.xx code. Please contact +// the wxWindows developers for further information. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CLIPBRD_H_ +#define _WX_CLIPBRD_H_ + +#ifdef __GNUG__ +#pragma interface "clipbrd.h" +#endif + +#include "wx/defs.h" +#include "wx/setup.h" + +#include "wx/list.h" + +bool WXDLLEXPORT wxOpenClipboard(); +bool WXDLLEXPORT wxClipboardOpen(); +bool WXDLLEXPORT wxCloseClipboard(); +bool WXDLLEXPORT wxEmptyClipboard(); +bool WXDLLEXPORT wxIsClipboardFormatAvailable(int dataFormat); +bool WXDLLEXPORT wxSetClipboardData(int dataFormat, wxObject *obj, int width = 0, int height = 0); +wxObject* WXDLLEXPORT wxGetClipboardData(int dataFormat, long *len = NULL); +int WXDLLEXPORT wxEnumClipboardFormats(int dataFormat); +int WXDLLEXPORT wxRegisterClipboardFormat(char *formatName); +bool WXDLLEXPORT wxGetClipboardFormatName(int dataFormat, char *formatName, int maxCount); + +/* A clipboard client holds data belonging to the clipboard. + For plain text, a client is not necessary. */ +class WXDLLEXPORT wxClipboardClient : public wxObject +{ + DECLARE_ABSTRACT_CLASS(wxClipboardClient) + + public: + /* This list should be filled in with strings indicating the formats + this client can provide. Almost all clients will provide "TEXT". + Format names should be 4 characters long, so things will work + out on the Macintosh */ + wxStringList formats; + + /* This method is called when the client is losing the selection. */ + virtual void BeingReplaced() = 0; + + /* This method is called when someone wants the data this client is + supplying to the clipboard. "format" is a string indicating the + format of the data - one of the strings from the "formats" + list. "*size" should be filled with the size of the resulting + data. In the case of text, "*size" does not count the + NULL terminator. */ + virtual char *GetData(char *format, long *size) = 0; +}; + +/* ONE instance of this class: */ +class WXDLLEXPORT wxClipboard : public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxClipboard) + + public: + wxClipboardClient *clipOwner; + char *cbString, *sentString, *receivedString; + void *receivedTargets; + long receivedLength; + + wxClipboard(); + ~wxClipboard(); + + /* Set the clipboard data owner. "time" comes from the event record. */ + void SetClipboardClient(wxClipboardClient *, long time); + + /* Set the clipboard string; does not require a client. */ + void SetClipboardString(char *, long time); + + /* Get data from the clipboard in the format "TEXT". */ + char *GetClipboardString(long time); + + /* Get data from the clipboard */ + char *GetClipboardData(char *format, long *length, long time); + + /* Get the clipboard client directly. Will be NULL if clipboard data + is a string, or if some other application owns the clipboard. + This can be useful for shortcutting data translation, if the + clipboard user can check for a specific client. (This is used + by the wxMediaEdit class.) */ + wxClipboardClient *GetClipboardClient(); +}; + +/* Initialize wxTheClipboard. Can be called repeatedly */ +void WXDLLEXPORT wxInitClipboard(); + +/* The clipboard */ +extern wxClipboard* WXDLLEXPORT wxTheClipboard; + +#endif + // _WX_CLIPBRD_H_ diff --git a/include/wx/stubs/colordlg.h b/include/wx/stubs/colordlg.h new file mode 100644 index 0000000000..7e2e8f60f4 --- /dev/null +++ b/include/wx/stubs/colordlg.h @@ -0,0 +1,45 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: colordlg.h +// Purpose: wxColourDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_COLORDLG_H_ +#define _WX_COLORDLG_H_ + +#ifdef __GNUG__ +#pragma interface "colordlg.h" +#endif + +#include "wx/setup.h" +#include "wx/dialog.h" +#include "wx/cmndata.h" + +/* + * Platform-specific colour dialog implementation + */ + +class WXDLLEXPORT wxColourDialog: public wxDialog +{ +DECLARE_DYNAMIC_CLASS(wxColourDialog) +public: + wxColourDialog(); + wxColourDialog(wxWindow *parent, wxColourData *data = NULL); + + bool Create(wxWindow *parent, wxColourData *data = NULL); + + int ShowModal(); + wxColourData& GetColourData() { return m_colourData; } + +protected: + wxColourData m_colourData; + wxWindow* m_dialogParent; +}; + +#endif + // _WX_COLORDLG_H_ diff --git a/include/wx/stubs/colour.h b/include/wx/stubs/colour.h new file mode 100644 index 0000000000..19c7cd9ee0 --- /dev/null +++ b/include/wx/stubs/colour.h @@ -0,0 +1,68 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: colour.h +// Purpose: wxColour class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_COLOUR_H_ +#define _WX_COLOUR_H_ + +#ifdef __GNUG__ +#pragma interface "colour.h" +#endif + +// Colour +class WXDLLEXPORT wxColour: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxColour) +public: + wxColour(); + wxColour(const unsigned char r, const unsigned char g, const 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) ; } + + 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)); + } + + inline unsigned char Red() const { return m_red; } + inline unsigned char Green() const { return m_green; } + inline unsigned char Blue() const { return m_blue; } + + inline bool operator == (const wxColour& colour) { return (m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue); } + + inline bool operator != (const wxColour& colour) { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); } + + WXCOLORREF GetPixel() const { return m_pixel; }; + + private: + bool m_isInit; + unsigned char m_red; + unsigned char m_blue; + unsigned char m_green; + public: +/* TODO: implementation + WXCOLORREF m_pixel ; +*/ +}; + +#define wxColor wxColour + +#endif + // _WX_COLOUR_H_ diff --git a/include/wx/stubs/combobox.h b/include/wx/stubs/combobox.h new file mode 100644 index 0000000000..86895e561c --- /dev/null +++ b/include/wx/stubs/combobox.h @@ -0,0 +1,78 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: combobox.h +// Purpose: wxComboBox class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_COMBOBOX_H_ +#define _WX_COMBOBOX_H_ + +#ifdef __GNUG__ +#pragma interface "combobox.h" +#endif + +#include "wx/choice.h" + +WXDLLEXPORT_DATA(extern const char*) wxComboBoxNameStr; +WXDLLEXPORT_DATA(extern const char*) wxEmptyString; + +// Combobox item +class WXDLLEXPORT wxComboBox: public wxChoice +{ + DECLARE_DYNAMIC_CLASS(wxComboBox) + + public: + inline wxComboBox() {} + + inline wxComboBox(wxWindow *parent, wxWindowID id, + const wxString& value = wxEmptyString, + 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 = wxComboBoxNameStr) + { + Create(parent, id, value, pos, size, n, choices, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, + const wxString& value = wxEmptyString, + 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 = wxComboBoxNameStr); + + // List functions: see wxChoice + + // Text field functions + virtual wxString GetValue() const ; + virtual void SetValue(const wxString& value); + + // 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(int n) + { + wxChoice::SetSelection(n); + } + virtual void SetSelection(long from, long to); + virtual void SetEditable(bool editable); +}; + +#endif + // _WX_COMBOBOX_H_ diff --git a/include/wx/stubs/control.h b/include/wx/stubs/control.h new file mode 100644 index 0000000000..5432b5c5e7 --- /dev/null +++ b/include/wx/stubs/control.h @@ -0,0 +1,50 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: control.h +// Purpose: wxControl class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CONTROL_H_ +#define _WX_CONTROL_H_ + +#ifdef __GNUG__ +#pragma interface "control.h" +#endif + +#include "wx/window.h" +#include "wx/list.h" +#include "wx/validate.h" + +// General item class +class WXDLLEXPORT wxControl: public wxWindow +{ + DECLARE_ABSTRACT_CLASS(wxControl) +public: + 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 ; + + // 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 + + inline wxFunction GetCallback() { return m_callback; } + +protected: + wxFunction m_callback; // Callback associated with the window + +DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_CONTROL_H_ diff --git a/include/wx/stubs/cursor.h b/include/wx/stubs/cursor.h new file mode 100644 index 0000000000..5484414e7b --- /dev/null +++ b/include/wx/stubs/cursor.h @@ -0,0 +1,73 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: cursor.h +// Purpose: wxCursor class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CURSOR_H_ +#define _WX_CURSOR_H_ + +#ifdef __GNUG__ +#pragma interface "cursor.h" +#endif + +#include "wx/bitmap.h" + +class WXDLLEXPORT wxCursorRefData: public wxBitmapRefData +{ + friend class WXDLLEXPORT wxBitmap; + friend class WXDLLEXPORT wxCursor; +public: + wxCursorRefData(); + ~wxCursorRefData(); + +protected: +/* TODO: implementation + WXHCURSOR m_hCursor; +*/ +}; + +#define M_CURSORDATA ((wxCursorRefData *)m_refData) +#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData) + +// Cursor +class WXDLLEXPORT wxCursor: public wxBitmap +{ + DECLARE_DYNAMIC_CLASS(wxCursor) + +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 + // _WX_CURSOR_H_ diff --git a/include/wx/stubs/dc.h b/include/wx/stubs/dc.h new file mode 100644 index 0000000000..65743ae368 --- /dev/null +++ b/include/wx/stubs/dc.h @@ -0,0 +1,294 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dc.h +// Purpose: wxDC class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_DC_H_ +#define _WX_DC_H_ + +#ifdef __GNUG__ +#pragma interface "dc.h" +#endif + +#include "wx/pen.h" +#include "wx/brush.h" +#include "wx/icon.h" +#include "wx/font.h" +#include "wx/gdicmn.h" + +class WXDLLEXPORT wxDC: public wxObject +{ +DECLARE_ABSTRACT_CLASS(wxDC) +public: + wxDC(); + ~wxDC(); + + // Compatibility (obsolete) + inline void wxDC::BeginDrawing() {} + inline void wxDC::EndDrawing() {} + + virtual void FloodFill(long x1, long y1, const wxColour& col, int style=wxFLOOD_SURFACE) ; + 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 ; + 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); + 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) ; + virtual 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); + 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 w, long h, double sa, double ea); + 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); + inline void DrawPoint(const wxPoint& pt) + { + DrawPoint(pt.x, pt.y); + } + + virtual void DrawLines(int n, wxPoint points[], long xoffset = 0, long yoffset = 0); + + virtual void DrawPolygon(int n, wxPoint points[], long xoffset = 0, long yoffset = 0, int fillStyle=wxODDEVEN_RULE); + + virtual void DrawRectangle(long x, long y, long width, long height); + 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); + 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); + 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); + inline void DrawIcon(const wxIcon& icon, const wxPoint& pt) + { + DrawIcon(icon, pt.x, pt.y); + } + + inline void DrawPoint(wxPoint& point) { DrawPoint(point.x, point.y); } + virtual void DrawLines(wxList *list, long xoffset = 0, long yoffset = 0); + virtual void DrawPolygon(wxList *list, long xoffset = 0, long yoffset = 0, int fillStyle=wxODDEVEN_RULE); + + virtual void DrawText(const wxString& text, long x, long y, bool use16bit = FALSE); + inline void DrawText(const wxString& text, const wxPoint& pt, bool use16bit = FALSE) + { + DrawText(text, pt.x, pt.y, use16bit); + } + + virtual bool Blit(long xdest, long ydest, long width, long height, + wxDC *source, long xsrc, long ysrc, int rop = wxCOPY, bool useMask = FALSE); + 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); + } + +#if USE_SPLINES + // Splines + // 3-point spline + virtual void DrawSpline(long x1, long y1, long x2, long y2, long x3, long y3); + // Any number of control points - a list of pointers to wxPoints + virtual void DrawSpline(wxList *points); + virtual void DrawSpline(int n, wxPoint points[]); +#endif + virtual void Clear(); + virtual void SetFont(const wxFont& font); + virtual void SetPen(const wxPen& pen); + virtual void SetBrush(const wxBrush& brush); + virtual void SetLogicalFunction(int function); + virtual void SetBackground(const wxBrush& brush); + virtual void SetBackgroundMode(int mode); + + virtual void SetClippingRegion(long x, long y, long width, long height); + inline void SetClippingRegion(const wxPoint& pt, const wxSize& sz) + { + SetClippingRegion(pt.x, pt.y, sz.x, sz.y); + } + inline void SetClippingRegion(const wxRect& rect) + { + SetClippingRegion(rect.x, rect.y, rect.width, rect.height); + } + + virtual void SetPalette(const wxPalette& palette); + virtual void DestroyClippingRegion(); + virtual long GetCharHeight() const; + virtual long GetCharWidth() const; + virtual void GetTextExtent(const wxString& string, long *x, long *y, + long *descent = NULL, long *externalLeading = NULL, + wxFont *theFont = NULL, bool use16bit = FALSE) const; + + // Size in device units + virtual void GetSize(int* width, int* height) const; + inline wxSize GetSize() const { int w, h; GetSize(&w, &h); return wxSize(w, h); } + + // Size in mm + virtual void GetSizeMM(long* width, long* height) const ; + + virtual bool StartDoc(const wxString& message); + virtual void EndDoc(); + virtual void StartPage(); + virtual void EndPage(); + virtual void SetMapMode(int mode); + virtual void SetUserScale(double x, double y); + virtual void SetSystemScale(double x, double y); + virtual void SetLogicalOrigin(long x, long y); + virtual void SetDeviceOrigin(long x, long y); + virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp); + + // This group of functions does actual conversion + // of the input, as you'd expect. + + long DeviceToLogicalX(long x) const; + long DeviceToLogicalY(long y) const; + long DeviceToLogicalXRel(long x) const; + long DeviceToLogicalYRel(long y) const; + long LogicalToDeviceX(long x) const; + long LogicalToDeviceY(long y) const; + long LogicalToDeviceXRel(long x) const; + long LogicalToDeviceYRel(long y) const; + + virtual bool CanDrawBitmap() const; + virtual bool CanGetTextExtent() const; + + virtual void SetTextForeground(const wxColour& colour); + virtual void SetTextBackground(const wxColour& colour); + inline virtual bool Ok() const {return m_ok;}; + inline virtual int GetMapMode() const {return m_mappingMode;}; + + inline virtual wxBrush *GetBackground() const { return (wxBrush*) &m_backgroundBrush ;} + inline virtual wxBrush *GetBrush() const { return (wxBrush*) &m_brush ;} + inline virtual wxFont *GetFont() const { return (wxFont*) &m_font ;} + inline virtual int GetLogicalFunction() const { return m_logicalFunction ;} + inline virtual wxPen *GetPen() const { return (wxPen*) &m_pen ;} + inline virtual wxColour&GetTextBackground() const { return (wxColour&) m_textBackgroundColour ;} + inline virtual wxColour&GetTextForeground() const { return (wxColour&) m_textForegroundColour ;} + + virtual void SetLogicalScale(double x, double y); + virtual inline void GetUserScale(double* x, double *y) const { *x = m_userScaleX; *y = m_userScaleY; } + virtual void CalcBoundingBox(long x, long y); + // Get the final bounding box of the PostScript or Metafile picture. + virtual inline long MinX() const { return m_minX; } + virtual inline long MaxX() const { return m_maxX; } + virtual inline long MinY() const { return m_minY; } + virtual inline long MaxY() const { return m_maxY; } + + // Sometimes we need to override optimization, e.g. + // if other software is drawing onto our surface and we + // can't be sure of who's done what. + virtual inline void SetOptimization(bool WXUNUSED(opt)) { } + virtual inline bool GetOptimization() { return FALSE; } + + virtual void GetClippingBox(long *x,long *y,long *w,long *h) const ; + inline void GetClippingBox(wxRect& rect) const + { + long x, y, w, h; + GetClippingBox(&x, &y, &w, &h); rect.x = x; rect.y = y; rect.width = w; rect.height = h; + } + + inline wxWindow *GetWindow() const { return m_canvas; } + inline void SetWindow(wxWindow *win) { m_canvas = win; } + +protected: + bool m_colour; + bool m_ok; + bool m_clipping; + bool m_isInteractive; + + // Coordinate system variables + long m_logicalOriginX; + long m_logicalOriginY; + + long m_deviceOriginX; + long m_deviceOriginY; + + double m_logicalScaleX; + double m_logicalScaleY; + + double m_userScaleX; + double m_userScaleY; + + int m_signX; // Used by SetAxisOrientation() to + int m_signY; // invert the axes + + int m_mappingMode; + + long m_minX; // bounding box + long m_minY; + long m_maxX; + long m_maxY; + + int m_logicalFunction; + int m_backgroundMode; + + wxPen m_pen; + wxBrush m_brush; + wxBrush m_backgroundBrush; + wxColour m_textForegroundColour; + wxColour m_textBackgroundColour; + wxFont m_font; + wxPalette m_palette; + int m_clipX1; + int m_clipY1; + int m_clipX2; + int m_clipY2; + double m_systemScaleX; + double m_systemScaleY; + + wxWindow * m_canvas; + wxBitmap m_selectedBitmap; + wxString m_filename; + +}; + +#endif + // _WX_DC_H_ diff --git a/include/wx/stubs/dcclient.h b/include/wx/stubs/dcclient.h new file mode 100644 index 0000000000..3265026677 --- /dev/null +++ b/include/wx/stubs/dcclient.h @@ -0,0 +1,61 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcclient.h +// Purpose: wxClientDC class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_DCCLIENT_H_ +#define _WX_DCCLIENT_H_ + +#ifdef __GNUG__ +#pragma interface "dcclient.h" +#endif + +#include "wx/dc.h" + +class WXDLLEXPORT wxClientDC: public wxDC +{ + DECLARE_DYNAMIC_CLASS(wxClientDC) + + public: + wxClientDC(); + + // Create a DC corresponding to a canvas + wxClientDC(wxWindow *win); + + ~wxClientDC(); +}; + +class WXDLLEXPORT wxWindowDC: public wxDC +{ + DECLARE_DYNAMIC_CLASS(wxWindowDC) + + public: + wxWindowDC(); + + // Create a DC corresponding to a canvas + wxWindowDC(wxWindow *win); + + ~wxWindowDC(); +}; + +class WXDLLEXPORT wxPaintDC: public wxDC +{ + DECLARE_DYNAMIC_CLASS(wxPaintDC) + + public: + wxPaintDC(); + + // Create a DC corresponding to a canvas + wxPaintDC(wxWindow *win); + + ~wxPaintDC(); +}; + +#endif + // _WX_DCCLIENT_H_ diff --git a/include/wx/stubs/dcmemory.h b/include/wx/stubs/dcmemory.h new file mode 100644 index 0000000000..dfcd7adda4 --- /dev/null +++ b/include/wx/stubs/dcmemory.h @@ -0,0 +1,35 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcmemory.h +// Purpose: wxMemoryDC class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_DCMEMORY_H_ +#define _WX_DCMEMORY_H_ + +#ifdef __GNUG__ +#pragma interface "dcmemory.h" +#endif + +#include "wx/dcclient.h" + +class WXDLLEXPORT wxMemoryDC: public wxDC +{ + DECLARE_DYNAMIC_CLASS(wxMemoryDC) + + public: + wxMemoryDC(); + wxMemoryDC(wxDC *dc); // Create compatible DC + + ~wxMemoryDC(); + virtual void SelectObject(const wxBitmap& bitmap); + virtual void GetSize(int* width, int* height) const; +}; + +#endif + // _WX_DCMEMORY_H_ diff --git a/include/wx/stubs/dcprint.h b/include/wx/stubs/dcprint.h new file mode 100644 index 0000000000..2ea66d15bf --- /dev/null +++ b/include/wx/stubs/dcprint.h @@ -0,0 +1,34 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcprint.h +// Purpose: wxPrinterDC class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_DCPRINT_H_ +#define _WX_DCPRINT_H_ + +#ifdef __GNUG__ +#pragma interface "dcprint.h" +#endif + +#include "wx/dc.h" + +class WXDLLEXPORT wxPrinterDC: public wxDC +{ + public: + DECLARE_CLASS(wxPrinterDC) + + // Create a printer DC + wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output, bool interactive = TRUE, int orientation = wxPORTRAIT); + + ~wxPrinterDC(); +}; + +#endif + // _WX_DCPRINT_H_ + diff --git a/include/wx/stubs/dcscreen.h b/include/wx/stubs/dcscreen.h new file mode 100644 index 0000000000..78ded86d8a --- /dev/null +++ b/include/wx/stubs/dcscreen.h @@ -0,0 +1,39 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcscreen.h +// 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_ + +#ifdef __GNUG__ +#pragma interface "dcscreen.h" +#endif + +#include "wx/dc.h" + +class WXDLLEXPORT wxScreenDC: public wxDC +{ + DECLARE_DYNAMIC_CLASS(wxScreenDC) + + public: + // 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 + // _WX_DCSCREEN_H_ + diff --git a/include/wx/stubs/dialog.h b/include/wx/stubs/dialog.h new file mode 100644 index 0000000000..678ba2518d --- /dev/null +++ b/include/wx/stubs/dialog.h @@ -0,0 +1,101 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dialog.h +// Purpose: wxDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_DIALOG_H_ +#define _WX_DIALOG_H_ + +#ifdef __GNUG__ +#pragma interface "dialog.h" +#endif + +#include "wx/panel.h" + +WXDLLEXPORT_DATA(extern const char*) wxDialogNameStr; + +// Dialog boxes +class WXDLLEXPORT wxDialog: public wxPanel +{ + DECLARE_DYNAMIC_CLASS(wxDialog) +public: + + 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); + } + + // 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); + } + + 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(); + + virtual bool Destroy(); + void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + void SetClientSize(int width, int height); + void GetPosition(int *x, int *y) const; + bool Show(bool show); + bool IsShown() const ; + void Iconize(bool iconize); + + virtual bool IsIconized() const; + void Fit(); + + void SetTitle(const wxString& title); + wxString GetTitle() const ; + + bool OnClose(); + void OnCharHook(wxKeyEvent& event); + void OnPaint(wxPaintEvent& 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 + // _WX_DIALOG_H_ diff --git a/include/wx/stubs/dirdlg.h b/include/wx/stubs/dirdlg.h new file mode 100644 index 0000000000..fe36bb7fec --- /dev/null +++ b/include/wx/stubs/dirdlg.h @@ -0,0 +1,47 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dirdlg.h +// Purpose: wxDirDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_DIRDLG_H_ +#define _WX_DIRDLG_H_ + +#ifdef __GNUG__ +#pragma interface "dirdlg.h" +#endif + +#include "wx/dialog.h" + +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; } + + inline wxString GetMessage() const { return m_message; } + inline wxString GetPath() const { return m_path; } + inline long GetStyle() const { return m_dialogStyle; } + + int ShowModal(); + +protected: + wxString m_message; + long m_dialogStyle; + wxWindow * m_parent; + wxString m_path; +}; + +#endif + // _WX_DIRDLG_H_ diff --git a/include/wx/stubs/filedlg.h b/include/wx/stubs/filedlg.h new file mode 100644 index 0000000000..0259f2d943 --- /dev/null +++ b/include/wx/stubs/filedlg.h @@ -0,0 +1,89 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: filedlg.h +// Purpose: wxFileDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_FILEDLG_H_ +#define _WX_FILEDLG_H_ + +#ifdef __GNUG__ +#pragma interface "filedlg.h" +#endif + +#include "wx/dialog.h" + +/* + * File selector + */ + +WXDLLEXPORT_DATA(extern const char*) wxFileSelectorPromptStr; +WXDLLEXPORT_DATA(extern const char*) wxFileSelectorDefaultWildcardStr; + +class WXDLLEXPORT wxFileDialog: public wxDialog +{ +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, + 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 SetDirectory(const wxString& dir) { m_dir = dir; } + inline void SetFilename(const wxString& name) { m_fileName = name; } + inline void SetWildcard(const wxString& wildCard) { m_wildCard = wildCard; } + inline void SetStyle(long style) { m_dialogStyle = style; } + inline void SetFilterIndex(int filterIndex) { m_filterIndex = 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(); +}; + +#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); + +// 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 + // _WX_FILEDLG_H_ diff --git a/include/wx/stubs/font.h b/include/wx/stubs/font.h new file mode 100644 index 0000000000..4241a37393 --- /dev/null +++ b/include/wx/stubs/font.h @@ -0,0 +1,86 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: font.h +// Purpose: wxFont class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_FONT_H_ +#define _WX_FONT_H_ + +#ifdef __GNUG__ +#pragma interface "font.h" +#endif + +#include "wx/gdiobj.h" + +class WXDLLEXPORT wxFont; + +class WXDLLEXPORT wxFontRefData: public wxGDIRefData +{ + friend class WXDLLEXPORT wxFont; +public: + wxFontRefData(); + ~wxFontRefData(); +protected: + int m_pointSize; + int m_family; + int m_fontId; + int m_style; + int m_weight; + bool m_underlined; + wxString m_faceName; +/* TODO: implementation + WXHFONT m_hFont; +*/ +}; + +#define M_FONTDATA ((wxFontRefData *)m_refData) + +WXDLLEXPORT_DATA(extern const char*) wxEmptyString; + +// Font +class WXDLLEXPORT wxFont: public wxGDIObject +{ + DECLARE_DYNAMIC_CLASS(wxFont) +public: + wxFont(); + wxFont(int PointSize, int Family, int Style, int Weight, bool underlined = FALSE, const wxString& Face = wxEmptyString); + inline wxFont(const wxFont& font) { Ref(font); } + inline wxFont(const wxFont* font) { /* UnRef(); */ if (font) Ref(*font); } + + ~wxFont(); + + bool Create(int PointSize, int Family, int Style, int Weight, bool underlined = FALSE, const wxString& Face = 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 GetFontId() const { return M_FONTDATA->m_fontId; } /* New font system */ + 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; } +}; + +#endif + // _WX_FONT_H_ diff --git a/include/wx/stubs/fontdlg.h b/include/wx/stubs/fontdlg.h new file mode 100644 index 0000000000..943a06f767 --- /dev/null +++ b/include/wx/stubs/fontdlg.h @@ -0,0 +1,45 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: fontdlg.h +// Purpose: wxFontDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_FONTDLG_H_ +#define _WX_FONTDLG_H_ + +#ifdef __GNUG__ +#pragma interface "fontdlg.h" +#endif + +#include "wx/dialog.h" +#include "wx/cmndata.h" + +/* + * Font dialog + */ + +class WXDLLEXPORT wxFontDialog: public wxDialog +{ +DECLARE_DYNAMIC_CLASS(wxFontDialog) +public: + wxFontDialog(); + wxFontDialog(wxWindow *parent, wxFontData *data = NULL); + + bool Create(wxWindow *parent, wxFontData *data = NULL); + + int ShowModal(); + wxFontData& GetFontData() { return m_fontData; } + +protected: + wxWindow* m_dialogParent; + wxFontData m_fontData; +}; + +#endif + // _WX_FONTDLG_H_ + diff --git a/include/wx/stubs/frame.h b/include/wx/stubs/frame.h new file mode 100644 index 0000000000..70247ae171 --- /dev/null +++ b/include/wx/stubs/frame.h @@ -0,0 +1,156 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: frame.h +// Purpose: wxFrame class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_FRAME_H_ +#define _WX_FRAME_H_ + +#ifdef __GNUG__ +#pragma interface "frame.h" +#endif + +#include "wx/window.h" +#include "wx/toolbar.h" +#include "wx/accel.h" + +WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr; +WXDLLEXPORT_DATA(extern const char*) wxToolBarNameStr; + +class WXDLLEXPORT wxMenuBar; +class WXDLLEXPORT wxStatusBar; + +class WXDLLEXPORT wxFrame: public wxWindow { + + DECLARE_DYNAMIC_CLASS(wxFrame) + +public: + wxFrame(); + 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 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 ; + + 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"); + 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(); + + // Iconize + virtual void Iconize(bool iconize); + + 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); + + // 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 + // _WX_FRAME_H_ diff --git a/include/wx/stubs/gauge.h b/include/wx/stubs/gauge.h new file mode 100644 index 0000000000..ce19d9ef1f --- /dev/null +++ b/include/wx/stubs/gauge.h @@ -0,0 +1,69 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: gauge.h +// Purpose: wxGauge class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_GAUGE_H_ +#define _WX_GAUGE_H_ + +#ifdef __GNUG__ +#pragma interface "gauge.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxGaugeNameStr; + +// Group box +class WXDLLEXPORT wxGauge: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxGauge) + 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, validator, name); + } + + bool Create(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); + + void SetShadowWidth(int w); + void SetBezelFace(int w); + void SetRange(int r); + void SetValue(int pos); + + int GetShadowWidth() const ; + int GetBezelFace() const ; + int GetRange() const ; + int GetValue() const ; + + 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; +}; + +#endif + // _WX_GAUGE_H_ diff --git a/include/wx/stubs/gdiobj.h b/include/wx/stubs/gdiobj.h new file mode 100644 index 0000000000..9263d4d6ad --- /dev/null +++ b/include/wx/stubs/gdiobj.h @@ -0,0 +1,48 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: gdiobj.h +// 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 _WX_GDIOBJ_H_ +#define _WX_GDIOBJ_H_ + +#include "wx/object.h" + +#ifdef __GNUG__ +#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() { m_visible = FALSE; }; + inline ~wxGDIObject() {}; + + inline bool IsNull() const { return (m_refData == 0); } + + virtual bool GetVisible() { return m_visible; } + virtual void SetVisible(bool v) { m_visible = v; } + +protected: + bool m_visible; // Can a pointer to this object be safely taken? + // - only if created within FindOrCreate... +}; + +#endif + // _WX_GDIOBJ_H_ diff --git a/include/wx/stubs/helpxxxx.h b/include/wx/stubs/helpxxxx.h new file mode 100644 index 0000000000..d53c28b7e4 --- /dev/null +++ b/include/wx/stubs/helpxxxx.h @@ -0,0 +1,52 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: helpxxxx.h +// Purpose: Help system: native implementation for your system. Replace +// XXXX with suitable name. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_HELPXXXX_H_ +#define _WX_HELPXXXX_H_ + +#ifdef __GNUG__ +#pragma interface "helpxxxx.h" +#endif + +#include "wx/wx.h" + +#include "wx/helpbase.h" + +class WXDLLEXPORT wxXXXXHelpController: public wxHelpControllerBase +{ + DECLARE_CLASS(wxXXXXHelpController) + + public: + wxXXXXHelpController(); + ~wxXXXXHelpController(); + + // Must call this to set the filename and server name + virtual bool Initialize(const wxString& file); + + // If file is "", reloads file given in Initialize + virtual bool LoadFile(const wxString& file = ""); + virtual bool DisplayContents(); + virtual bool DisplaySection(int sectionNo); + virtual bool DisplayBlock(long blockNo); + virtual bool KeywordSearch(const wxString& k); + + virtual bool Quit(); + virtual void OnQuit(); + + inline wxString GetHelpFile() const { return m_helpFile; } + +protected: + wxString m_helpFile; +}; + +#endif + // _WX_HELPXXXX_H_ diff --git a/include/wx/stubs/icon.h b/include/wx/stubs/icon.h new file mode 100644 index 0000000000..f68c23154b --- /dev/null +++ b/include/wx/stubs/icon.h @@ -0,0 +1,107 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: icon.h +// Purpose: wxIcon class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_ICON_H_ +#define _WX_ICON_H_ + +#ifdef __GNUG__ +#pragma interface "icon.h" +#endif + +#include "wx/bitmap.h" + +class WXDLLEXPORT wxIconRefData: public wxBitmapRefData +{ + friend class WXDLLEXPORT wxBitmap; + friend class WXDLLEXPORT wxIcon; +public: + wxIconRefData(); + ~wxIconRefData(); + +public: +/* TODO: whatever your actual icon handle is + WXHICON m_hIcon; +*/ +}; + +#define M_ICONDATA ((wxIconRefData *)m_refData) +#define M_ICONHANDLERDATA ((wxIconRefData *)bitmap->GetRefData()) + +// Icon +class WXDLLEXPORT wxIcon: public wxBitmap +{ + DECLARE_DYNAMIC_CLASS(wxIcon) + +public: + wxIcon(); + + // Copy constructors + inline wxIcon(const wxIcon& icon) { Ref(icon); } + inline wxIcon(const wxIcon* icon) { if (icon) Ref(*icon); } + + 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 + // _WX_ICON_H_ diff --git a/include/wx/stubs/imaglist.h b/include/wx/stubs/imaglist.h new file mode 100644 index 0000000000..52784ddd4b --- /dev/null +++ b/include/wx/stubs/imaglist.h @@ -0,0 +1,143 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: imaglist.h +// Purpose: wxImageList class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_IMAGLIST_H_ +#define _WX_IMAGLIST_H_ + +#ifdef __GNUG__ +#pragma interface "imaglist.h" +#endif + +#include "wx/bitmap.h" + +/* + * wxImageList is used for wxListCtrl, wxTreeCtrl. These controls refer to + * images for their items by an index into an image list. + * A wxImageList is capable of creating images with optional masks from + * a variety of sources - a single bitmap plus a colour to indicate the mask, + * two bitmaps, or an icon. + * + */ + +// Flags for Draw +#define wxIMAGELIST_DRAW_NORMAL 0x0001 +#define wxIMAGELIST_DRAW_TRANSPARENT 0x0002 +#define wxIMAGELIST_DRAW_SELECTED 0x0004 +#define wxIMAGELIST_DRAW_FOCUSED 0x0008 + +// Flag values for Set/GetImageList +enum { + wxIMAGE_LIST_NORMAL, // Normal icons + wxIMAGE_LIST_SMALL, // Small icons + wxIMAGE_LIST_STATE // State icons: unimplemented (see WIN32 documentation) +}; + +// Eventually we'll make this a reference-counted wxGDIObject. For +// now, the app must take care of ownership issues. That is, the +// image lists must be explicitly deleted after the control(s) that uses them +// is (are) deleted, or when the app exits. +class WXDLLEXPORT wxImageList: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxImageList) + public: + /* + * Public interface + */ + + wxImageList(); + + // Creates an image list. + // Specify the width and height of the images in the list, + // whether there are masks associated with them (e.g. if creating images + // from icons), and the initial size of the list. + inline wxImageList(int width, int height, bool mask = TRUE, int initialCount = 1) + { + Create(width, height, mask, initialCount); + } + ~wxImageList(); + + + // Attributes + //////////////////////////////////////////////////////////////////////////// + + // Returns the number of images in the image list. + int GetImageCount() const; + + // Operations + //////////////////////////////////////////////////////////////////////////// + + // Creates an image list + // width, height specify the size of the images in the list (all the same). + // mask specifies whether the images have masks or not. + // initialNumber is the initial number of images to reserve. + bool Create(int width, int height, bool mask = TRUE, int initialNumber = 1); + + // Adds a bitmap, and optionally a mask bitmap. + // Note that wxImageList creates *new* bitmaps, so you may delete + // 'bitmap' and 'mask' after calling Add. + int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap); + + // Adds a bitmap, using the specified colour to create the mask bitmap + // Note that wxImageList creates *new* bitmaps, so you may delete + // 'bitmap' after calling Add. + int Add(const wxBitmap& bitmap, const wxColour& maskColour); + + // Adds a bitmap and mask from an icon. + int Add(const wxIcon& icon); + + // Replaces a bitmap, optionally passing a mask bitmap. + // Note that wxImageList creates new bitmaps, so you may delete + // 'bitmap' and 'mask' after calling Replace. + bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap); + +/* Not supported by Win95 + // Replacing a bitmap, using the specified colour to create the mask bitmap + // Note that wxImageList creates new bitmaps, so you may delete + // 'bitmap'. + bool Replace(int index, const wxBitmap& bitmap, const wxColour& maskColour); +*/ + + // Replaces a bitmap and mask from an icon. + // You can delete 'icon' after calling Replace. + bool Replace(int index, const wxIcon& icon); + + // Removes the image at the given index. + bool Remove(int index); + + // Remove all images + bool RemoveAll(); + + // Draws the given image on a dc at the specified position. + // If 'solidBackground' is TRUE, Draw sets the image list background + // colour to the background colour of the wxDC, to speed up + // drawing by eliminating masked drawing where possible. + bool Draw(int index, wxDC& dc, int x, int y, + int flags = wxIMAGELIST_DRAW_NORMAL, bool solidBackground = FALSE); + +/* TODO (optional?) + wxIcon *MakeIcon(int index); +*/ + +/* TODO + // Implementation + //////////////////////////////////////////////////////////////////////////// + + // Returns the native image list handle + inline WXHIMAGELIST GetHIMAGELIST() const { return m_hImageList; } + +protected: + WXHIMAGELIST m_hImageList; +*/ + +}; + +#endif + // _WX_IMAGLIST_H_ diff --git a/include/wx/stubs/joystick.h b/include/wx/stubs/joystick.h new file mode 100644 index 0000000000..30324fc035 --- /dev/null +++ b/include/wx/stubs/joystick.h @@ -0,0 +1,93 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: joystick.h +// Purpose: wxJoystick class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_JOYSTICK_H_ +#define _WX_JOYSTICK_H_ + +#ifdef __GNUG__ +#pragma interface "joystick.h" +#endif + +#include "wx/event.h" + +class WXDLLEXPORT wxJoystick: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxJoystick) + public: + /* + * Public interface + */ + + wxJoystick(int joystick = wxJOYSTICK1) { m_joystick = joystick; }; + + // Attributes + //////////////////////////////////////////////////////////////////////////// + + 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() 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(); + +protected: + int m_joystick; +}; + +#endif + // _WX_JOYSTICK_H_ diff --git a/include/wx/stubs/listbox.h b/include/wx/stubs/listbox.h new file mode 100644 index 0000000000..d95db4379b --- /dev/null +++ b/include/wx/stubs/listbox.h @@ -0,0 +1,97 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: listbox.h +// Purpose: wxListBox class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_LISTBOX_H_ +#define _WX_LISTBOX_H_ + +#ifdef __GNUG__ +#pragma interface "listbox.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxListBoxNameStr; + +// forward decl for GetSelections() +class WXDLLEXPORT wxArrayInt; + +WXDLLEXPORT_DATA(extern const char*) wxEmptyString; + +// 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); + + 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 + // _WX_LISTBOX_H_ diff --git a/include/wx/stubs/listctrl.h b/include/wx/stubs/listctrl.h new file mode 100644 index 0000000000..76a6433e0e --- /dev/null +++ b/include/wx/stubs/listctrl.h @@ -0,0 +1,455 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: listctrl.h +// Purpose: wxListCtrl class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_LISTCTRL_H_ +#define _WX_LISTCTRL_H_ + +#ifdef __GNUG__ +#pragma interface "listctrl.h" +#endif + +#include "wx/control.h" +#include "wx/event.h" +#include "wx/imaglist.h" + +/* + The wxListCtrl can show lists of items in four different modes: + wxLC_LIST: multicolumn list view, with optional small icons (icons could be + optional for some platforms). Columns are computed automatically, + i.e. you don't set columns as in wxLC_REPORT. In other words, + the list wraps, unlike a wxListBox. + wxLC_REPORT: single or multicolumn report view (with optional header) + wxLC_ICON: large icon view, with optional labels + wxLC_SMALL_ICON: small icon view, with optional labels + + You can change the style dynamically, either with SetSingleStyle or + SetWindowStyleFlag. + + Further window styles: + + wxLC_ALIGN_TOP icons align to the top (default) + wxLC_ALIGN_LEFT icons align to the left + wxLC_AUTOARRANGE icons arrange themselves + wxLC_USER_TEXT the app provides label text on demand, except for column headers + wxLC_EDIT_LABELS labels are editable: app will be notified. + wxLC_NO_HEADER no header in report mode + wxLC_NO_SORT_HEADER can't click on header + wxLC_SINGLE_SEL single selection + wxLC_SORT_ASCENDING sort ascending (must still supply a comparison callback in SortItems) + wxLC_SORT_DESCENDING sort descending (ditto) + + Items are referred to by their index (position in the list starting from zero). + + Label text is supplied via insertion/setting functions and is stored by the + control, unless the wxLC_USER_TEXT style has been specified, in which case + the app will be notified when text is required (see sample). + + Images are dealt with by (optionally) associating 3 image lists with the control. + Zero-based indexes into these image lists indicate which image is to be used for + which item. Each image in an image list can contain a mask, and can be made out + of either a bitmap, two bitmaps or an icon. See ImagList.h for more details. + + Notifications are passed via the wxWindows 2.0 event system. + + See the sample wxListCtrl app for API usage. + + */ + +// Mask flags to tell app/GUI what fields of wxListItem are valid +#define wxLIST_MASK_STATE 0x0001 +#define wxLIST_MASK_TEXT 0x0002 +#define wxLIST_MASK_IMAGE 0x0004 +#define wxLIST_MASK_DATA 0x0008 +#define wxLIST_SET_ITEM 0x0010 +#define wxLIST_MASK_WIDTH 0x0020 +#define wxLIST_MASK_FORMAT 0x0040 + +// State flags for indicating the state of an item +#define wxLIST_STATE_DONTCARE 0x0000 +#define wxLIST_STATE_DROPHILITED 0x0001 +#define wxLIST_STATE_FOCUSED 0x0002 +#define wxLIST_STATE_SELECTED 0x0004 +#define wxLIST_STATE_CUT 0x0008 + +// Hit test flags, used in HitTest +#define wxLIST_HITTEST_ABOVE 0x0001 // Above the client area. +#define wxLIST_HITTEST_BELOW 0x0002 // Below the client area. +#define wxLIST_HITTEST_NOWHERE 0x0004 // In the client area but below the last item. +#define wxLIST_HITTEST_ONITEMICON 0x0020 // On the bitmap associated with an item. +#define wxLIST_HITTEST_ONITEMLABEL 0x0080 // On the label (string) associated with an item. +#define wxLIST_HITTEST_ONITEMRIGHT 0x0100 // In the area to the right of an item. +#define wxLIST_HITTEST_ONITEMSTATEICON 0x0200 // On the state icon for a tree view item that is in a user-defined state. +#define wxLIST_HITTEST_TOLEFT 0x0400 // To the left of the client area. +#define wxLIST_HITTEST_TORIGHT 0x0800 // To the right of the client area. + +#define wxLIST_HITTEST_ONITEM (wxLIST_HITTEST_ONITEMICON | wxLIST_HITTEST_ONITEMLABEL wxLIST_HITTEST_ONITEMSTATEICON) + +// Flags for GetNextItem +enum { + wxLIST_NEXT_ABOVE, // Searches for an item above the specified item + wxLIST_NEXT_ALL, // Searches for subsequent item by index + wxLIST_NEXT_BELOW, // Searches for an item below the specified item + wxLIST_NEXT_LEFT, // Searches for an item to the left of the specified item + wxLIST_NEXT_RIGHT, // Searches for an item to the right of the specified item +}; + +// Alignment flags for Arrange +enum { + wxLIST_ALIGN_DEFAULT, + wxLIST_ALIGN_LEFT, + wxLIST_ALIGN_TOP, + wxLIST_ALIGN_SNAP_TO_GRID +}; + +// Column format +enum { + wxLIST_FORMAT_LEFT, + wxLIST_FORMAT_RIGHT, + wxLIST_FORMAT_CENTRE, + wxLIST_FORMAT_CENTER = wxLIST_FORMAT_CENTRE +}; + +// Autosize values for SetColumnWidth +enum { + wxLIST_AUTOSIZE = -1, + wxLIST_AUTOSIZE_USEHEADER = -2 +}; + +// Flag values for GetItemRect +enum { + wxLIST_RECT_BOUNDS, + wxLIST_RECT_ICON, + wxLIST_RECT_LABEL +}; + +// Flag values for FindItem +enum { + wxLIST_FIND_UP, + wxLIST_FIND_DOWN, + wxLIST_FIND_LEFT, + wxLIST_FIND_RIGHT +}; + +// wxListItem: data representing an item, or report field. +// It also doubles up to represent entire column information +// when inserting or setting a column. +class WXDLLEXPORT wxListItem: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxListItem) +public: + long m_mask; // Indicates what fields are valid + long m_itemId; // The zero-based item position + int m_col; // Zero-based column, if in report mode + long m_state; // The state of the item + long m_stateMask; // Which flags of m_state are valid (uses same flags) + wxString m_text; // The label/header text + int m_image; // The zero-based index into an image list + long m_data; // App-defined data + + // For columns only + int m_format; // left, right, centre + int m_width; // width of column + + wxListItem(); +}; + +// type of compare function for wxListCtrl sort operation +typedef int (*wxListCtrlCompare)(long item1, long item2, long sortData); + +class WXDLLEXPORT wxListCtrl: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxListCtrl) + public: + /* + * Public interface + */ + + wxListCtrl(); + + inline wxListCtrl(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxLC_ICON, const wxValidator& validator = wxDefaultValidator, + const wxString& name = "listCtrl") + { + Create(parent, id, pos, size, style, validator, name); + } + ~wxListCtrl(); + + bool Create(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxLC_ICON, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxListCtrl"); + + + // Attributes + //////////////////////////////////////////////////////////////////////////// + + // Sets the background colour (GetBackgroundColour already implicit in + // wxWindow class) + void SetBackgroundColour(const wxColour& col); + + // Gets information about this column + bool GetColumn(int col, wxListItem& item) const; + + // Sets information about this column + bool SetColumn(int col, wxListItem& item) ; + + // Gets the column width + int GetColumnWidth(int col) const; + + // Sets the column width + bool SetColumnWidth(int col, int width) ; + + // Gets the number of items that can fit vertically in the + // visible area of the list control (list or report view) + // or the total number of items in the list control (icon + // or small icon view) + int GetCountPerPage() const; + + // Gets the edit control for editing labels. + wxTextCtrl* GetEditControl() const; + + // Gets information about the item + bool GetItem(wxListItem& info) const ; + + // Sets information about the item + bool SetItem(wxListItem& info) ; + + // Sets a string field at a particular column + long SetItem(long index, int col, const wxString& label, int imageId = -1); + + // Gets the item state + int GetItemState(long item, long stateMask) const ; + + // Sets the item state + bool SetItemState(long item, long state, long stateMask) ; + + // Sets the item image + bool SetItemImage(long item, int image, int selImage) ; + + // Gets the item text + wxString GetItemText(long item) const ; + + // Sets the item text + void SetItemText(long item, const wxString& str) ; + + // Gets the item data + long GetItemData(long item) const ; + + // Sets the item data + bool SetItemData(long item, long data) ; + + // Gets the item rectangle + bool GetItemRect(long item, wxRectangle& rect, int code = wxLIST_RECT_BOUNDS) const ; + + // Gets the item position + bool GetItemPosition(long item, wxPoint& pos) const ; + + // Sets the item position + bool SetItemPosition(long item, const wxPoint& pos) ; + + // Gets the number of items in the list control + int GetItemCount() const; + + // Gets the number of columns in the list control + int GetColumnCount() const; + + // Retrieves the spacing between icons in pixels. + // If small is TRUE, gets the spacing for the small icon + // view, otherwise the large icon view. + int GetItemSpacing(bool isSmall) const; + + // Gets the number of selected items in the list control + int GetSelectedItemCount() const; + + // Gets the text colour of the listview + wxColour GetTextColour() const; + + // Sets the text colour of the listview + void SetTextColour(const wxColour& col); + + // Gets the index of the topmost visible item when in + // list or report view + long GetTopItem() const ; + + // Add or remove a single window style + void SetSingleStyle(long style, bool add = TRUE) ; + + // Set the whole window style + void SetWindowStyleFlag(long style) ; + + // Searches for an item, starting from 'item'. + // item can be -1 to find the first item that matches the + // specified flags. + // Returns the item or -1 if unsuccessful. + long GetNextItem(long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE) const ; + + // Implementation: converts wxWindows style to MSW style. + // Can be a single style flag or a bit list. + // oldStyle is 'normalised' so that it doesn't contain + // conflicting styles. + long ConvertToMSWStyle(long& oldStyle, long style) const; + + // Gets one of the three image lists + wxImageList *GetImageList(int which) const ; + + // Sets the image list + // N.B. There's a quirk in the Win95 list view implementation. + // If in wxLC_LIST mode, it'll *still* display images by the labels if + // there's a small-icon image list set for the control - even though you + // haven't specified wxLIST_MASK_IMAGE when inserting. + // So you have to set a NULL small-icon image list to be sure that + // the wxLC_LIST mode works without icons. Of course, you may want icons... + void SetImageList(wxImageList *imageList, int which) ; + + // Operations + //////////////////////////////////////////////////////////////////////////// + + // Arranges the items + bool Arrange(int flag = wxLIST_ALIGN_DEFAULT); + + // Deletes an item + bool DeleteItem(long item); + + // Deletes all items + bool DeleteAllItems() ; + + // Deletes a column + bool DeleteColumn(int col); + + // Deletes all columns + bool DeleteAllColumns(); + + // Clears items, and columns if there are any. + void ClearAll(); + + // Edit the label + wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl)); + + // End label editing, optionally cancelling the edit + bool EndEditLabel(bool cancel); + + // Ensures this item is visible + bool EnsureVisible(long item) ; + + // Find an item whose label matches this string, starting from the item after 'start' + // or the beginning if 'start' is -1. + long FindItem(long start, const wxString& str, bool partial = FALSE); + + // Find an item whose data matches this data, starting from the item after 'start' + // or the beginning if 'start' is -1. + long FindItem(long start, long data); + + // Find an item nearest this position in the specified direction, starting from + // the item after 'start' or the beginning if 'start' is -1. + long FindItem(long start, const wxPoint& pt, int direction); + + // Determines which item (if any) is at the specified point, + // giving details in 'flags' (see wxLIST_HITTEST_... flags above) + long HitTest(const wxPoint& point, int& flags); + + // Inserts an item, returning the index of the new item if successful, + // -1 otherwise. + // TOD: Should also have some further convenience functions + // which don't require setting a wxListItem object + long InsertItem(wxListItem& info); + + // Insert a string item + long InsertItem(long index, const wxString& label); + + // Insert an image item + long InsertItem(long index, int imageIndex); + + // Insert an image/string item + long InsertItem(long index, const wxString& label, int imageIndex); + + // For list view mode (only), inserts a column. + long InsertColumn(long col, wxListItem& info); + + long InsertColumn(long col, const wxString& heading, int format = wxLIST_FORMAT_LEFT, + int width = -1); + + // Scrolls the list control. If in icon, small icon or report view mode, + // x specifies the number of pixels to scroll. If in list view mode, x + // specifies the number of columns to scroll. + // If in icon, small icon or list view mode, y specifies the number of pixels + // to scroll. If in report view mode, y specifies the number of lines to scroll. + bool ScrollList(int dx, int dy); + + // Sort items. + + // fn is a function which takes 3 long arguments: item1, item2, data. + // item1 is the long data associated with a first item (NOT the index). + // item2 is the long data associated with a second item (NOT the index). + // data is the same value as passed to SortItems. + // The return value is a negative number if the first item should precede the second + // item, a positive number of the second item should precede the first, + // or zero if the two items are equivalent. + + // data is arbitrary data to be passed to the sort function. + bool SortItems(wxListCtrlCompare fn, long data); + +/* Why should we need this function? Leave for now. + * We might need it because item data may have changed, + * but the display needs refreshing (in string callback mode) + // Updates an item. If the list control has the wxLI_AUTO_ARRANGE style, + // the items will be rearranged. + bool Update(long item); +*/ + + void Command(wxCommandEvent& event) { ProcessCommand(event); }; + +protected: + wxTextCtrl* m_textCtrl; // The control used for editing a label + wxImageList * m_imageListNormal; // The image list for normal icons + wxImageList * m_imageListSmall; // The image list for small icons + wxImageList * m_imageListState; // The image list state icons (not implemented yet) + + long m_baseStyle; // Basic Windows style flags, for recreation purposes + wxStringList m_stringPool; // Pool of 3 strings to satisfy Windows callback + // requirements + int m_colCount; // Windows doesn't have GetColumnCount so must + // keep track of inserted/deleted columns + +}; + +class WXDLLEXPORT wxListEvent: public wxCommandEvent +{ + DECLARE_DYNAMIC_CLASS(wxListEvent) + + public: + wxListEvent(wxEventType commandType = wxEVT_NULL, int id = 0); + + int m_code; + long m_itemIndex; + long m_oldItemIndex; + int m_col; + bool m_cancelled; + wxPoint m_pointDrag; + + wxListItem m_item; +}; + +typedef void (wxEvtHandler::*wxListEventFunction)(wxListEvent&); + +#define EVT_LIST_BEGIN_DRAG(id, fn) { wxEVT_COMMAND_LIST_BEGIN_DRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_BEGIN_RDRAG(id, fn) { wxEVT_COMMAND_LIST_BEGIN_RDRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_BEGIN_LABEL_EDIT(id, fn) { wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_END_LABEL_EDIT(id, fn) { wxEVT_COMMAND_LIST_END_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_DELETE_ITEM(id, fn) { wxEVT_COMMAND_LIST_DELETE_ITEM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_DELETE_ALL_ITEMS(id, fn) { wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_GET_INFO(id, fn) { wxEVT_COMMAND_LIST_GET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_SET_INFO(id, fn) { wxEVT_COMMAND_LIST_SET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_ITEM_SELECTED(id, fn) { wxEVT_COMMAND_LIST_ITEM_SELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_ITEM_DESELECTED(id, fn) { wxEVT_COMMAND_LIST_ITEM_DESELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_KEY_DOWN(id, fn) { wxEVT_COMMAND_LIST_KEY_DOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_INSERT_ITEM(id, fn) { wxEVT_COMMAND_LIST_INSERT_ITEM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_COL_CLICK(id, fn) { wxEVT_COMMAND_LIST_COL_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, + +#endif + // _WX_LISTCTRL_H_ diff --git a/include/wx/stubs/mdi.h b/include/wx/stubs/mdi.h new file mode 100644 index 0000000000..1daec94008 --- /dev/null +++ b/include/wx/stubs/mdi.h @@ -0,0 +1,160 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: mdi.h +// 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 _WX_MDI_H_ +#define _WX_MDI_H_ + +#ifdef __GNUG__ +#pragma interface "mdi.h" +#endif + +#include "wx/frame.h" + +WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr; +WXDLLEXPORT_DATA(extern const char*) wxStatusLineNameStr; + +class WXDLLEXPORT wxMDIClientWindow; +class WXDLLEXPORT wxMDIChildFrame; + +class WXDLLEXPORT wxMDIParentFrame: public wxFrame +{ +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() +}; + +class WXDLLEXPORT wxMDIChildFrame: public wxFrame +{ +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(); +}; + +/* 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 WXDLLEXPORT wxMDIClientWindow: public wxWindow +{ + DECLARE_DYNAMIC_CLASS(wxMDIClientWindow) + public: + + wxMDIClientWindow() ; + inline wxMDIClientWindow(wxMDIParentFrame *parent, long style = 0) + { + CreateClient(parent, style); + } + + ~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_ diff --git a/include/wx/stubs/menu.h b/include/wx/stubs/menu.h new file mode 100644 index 0000000000..f663631da5 --- /dev/null +++ b/include/wx/stubs/menu.h @@ -0,0 +1,158 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: menu.h +// Purpose: wxMenu, wxMenuBar classes +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_MENU_H_ +#define _WX_MENU_H_ + +#ifdef __GNUG__ +#pragma interface "menu.h" +#endif + +#include "wx/defs.h" +#include "wx/event.h" + +class WXDLLEXPORT wxMenuItem; +class WXDLLEXPORT wxMenuBar; +class WXDLLEXPORT wxMenu; + +WXDLLEXPORT_DATA(extern const char*) wxEmptyString; + +// ---------------------------------------------------------------------------- +// Menu +// ---------------------------------------------------------------------------- +class WXDLLEXPORT wxMenu: public wxEvtHandler +{ + DECLARE_DYNAMIC_CLASS(wxMenu) + +public: + // ctor & dtor + wxMenu(const wxString& title = wxEmptyString, const wxFunction func = NULL); + ~wxMenu(); + + // 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); /* If it's a submenu, menu is not destroyed. VZ: why? */ + + // 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, NOT_FOUND 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: + wxFunction m_callback; + + int m_noItems; + wxString m_title; + wxMenu * m_topLevelMenu; + wxMenuBar * m_menuBar; + wxList m_menuItems; + wxEvtHandler * m_parent; + wxEvtHandler * m_eventHandler; +}; + +// ---------------------------------------------------------------------------- +// Menu Bar (a la Windows) +// ---------------------------------------------------------------------------- +class WXDLLEXPORT wxFrame; +class WXDLLEXPORT wxMenuBar: public wxEvtHandler +{ + DECLARE_DYNAMIC_CLASS(wxMenuBar) + + 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 // _WX_MENU_H_ diff --git a/include/wx/stubs/metafile.h b/include/wx/stubs/metafile.h new file mode 100644 index 0000000000..f4d04bcb63 --- /dev/null +++ b/include/wx/stubs/metafile.h @@ -0,0 +1,100 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: metafile.h +// Purpose: wxMetaFile, wxMetaFileDC classes. +// This probably should be restricted to Windows platforms, +// but if there is an equivalent on your platform, great. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + + +#ifndef _WX_METAFIILE_H_ +#define _WX_METAFIILE_H_ + +#ifdef __GNUG__ +#pragma interface "metafile.h" +#endif + +#include "wx/setup.h" + +/* + * Metafile and metafile device context classes - work in Windows 3.1 only + * + */ + +class WXDLLEXPORT wxDC; +class WXDLLEXPORT wxMetaFile: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxMetaFile) + public: + wxMetaFile(const wxString& file = ""); + ~wxMetaFile(); + + // After this is called, the metafile cannot be used for anything + // since it is now owned by the clipboard. + virtual bool SetClipboard(int width = 0, int height = 0); + + virtual bool Play(wxDC *dc); + inline bool Ok() { return m_metaFile != 0; }; + +/* TODO: Implementation + inline WXHANDLE GetHMETAFILE() { return m_metaFile; } + inline void SetHMETAFILE(WXHANDLE mf) { m_metaFile = mf; } + +protected: + WXHANDLE m_metaFile; +*/ +}; + +class WXDLLEXPORT wxMetaFileDC: public wxDC +{ + DECLARE_DYNAMIC_CLASS(wxMetaFileDC) + + public: + // Don't supply origin and extent + // Supply them to wxMakeMetaFilePlaceable instead. + wxMetaFileDC(const wxString& file = ""); + + // Supply origin and extent (recommended). + // Then don't need to supply them to wxMakeMetaFilePlaceable. + wxMetaFileDC(const wxString& file, int xext, int yext, int xorg, int yorg); + + ~wxMetaFileDC(); + + // Should be called at end of drawing + virtual wxMetaFile *Close(); + virtual void SetMapMode(int mode); + virtual void GetTextExtent(const wxString& string, float *x, float *y, + float *descent = NULL, float *externalLeading = NULL, + wxFont *theFont = NULL, bool use16bit = FALSE); + + // Implementation + inline wxMetaFile *GetMetaFile() { return m_metaFile; } + inline void SetMetaFile(wxMetaFile *mf) { m_metaFile = mf; } + inline int GetWindowsMappingMode() { return m_windowsMappingMode; } + inline void SetWindowsMappingMode(int mm) { m_windowsMappingMode = mm; } + +protected: + int m_windowsMappingMode; + wxMetaFile *m_metaFile; +}; + +/* + * Pass filename of existing non-placeable metafile, and bounding box. + * Adds a placeable metafile header, sets the mapping mode to anisotropic, + * and sets the window origin and extent to mimic the MM_TEXT mapping mode. + * + */ + +// No origin or extent +bool WXDLLEXPORT wxMakeMetaFilePlaceable(const wxString& filename, float scale = 1.0); + +// Optional origin and extent +bool WXDLLEXPORT wxMakeMetaFilePlaceable(const wxString& filename, int x1, int y1, int x2, int y2, float scale = 1.0, bool useOriginAndExtent = TRUE); + +#endif + // _WX_METAFIILE_H_ diff --git a/include/wx/stubs/minifram.h b/include/wx/stubs/minifram.h new file mode 100644 index 0000000000..12f485097b --- /dev/null +++ b/include/wx/stubs/minifram.h @@ -0,0 +1,45 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: minifram.h +// Purpose: wxMiniFrame class. A small frame for e.g. floating toolbars. +// If there is no equivalent on your platform, just make it a +// normal frame. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_MINIFRAM_H_ +#define _WX_MINIFRAM_H_ + +#ifdef __GNUG__ +#pragma interface "minifram.h" +#endif + +#include "wx/frame.h" + +class WXDLLEXPORT wxMiniFrame: public wxFrame { + + DECLARE_DYNAMIC_CLASS(wxMiniFrame) + +public: + inline wxMiniFrame() {} + inline wxMiniFrame(wxWindow *parent, + wxWindowID id, + const wxString& title, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxDEFAULT_FRAME_STYLE|wxTINY_CAPTION_HORIZ, + const wxString& name = wxFrameNameStr) + { + Create(parent, id, title, pos, size, style, name); + } + + ~wxMiniFrame(); +protected: +}; + +#endif + // _WX_MINIFRAM_H_ diff --git a/include/wx/stubs/msgdlg.h b/include/wx/stubs/msgdlg.h new file mode 100644 index 0000000000..d885345dfb --- /dev/null +++ b/include/wx/stubs/msgdlg.h @@ -0,0 +1,49 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: msgdlg.h +// Purpose: wxMessageDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_MSGBOXDLG_H_ +#define _WX_MSGBOXDLG_H_ + +#ifdef __GNUG__ +#pragma interface "msgdlg.h" +#endif + +#include "wx/setup.h" +#include "wx/dialog.h" + +/* + * Message box dialog + */ + +WXDLLEXPORT_DATA(extern const char*) wxMessageBoxCaptionStr; + +class WXDLLEXPORT wxMessageDialog: public wxDialog +{ +DECLARE_DYNAMIC_CLASS(wxMessageDialog) +protected: + wxString m_caption; + wxString m_message; + long m_dialogStyle; + wxWindow * m_parent; +public: + wxMessageDialog(wxWindow *parent, const wxString& message, const wxString& caption = wxMessageBoxCaptionStr, + long style = wxOK|wxCENTRE, const wxPoint& pos = wxDefaultPosition); + + int ShowModal(); +}; + + +int WXDLLEXPORT wxMessageBox(const wxString& message, const wxString& caption = wxMessageBoxCaptionStr, + long style = wxOK|wxCENTRE, + wxWindow *parent = NULL, int x = -1, int y = -1); + +#endif + // _WX_MSGBOXDLG_H_ diff --git a/include/wx/stubs/notebook.h b/include/wx/stubs/notebook.h new file mode 100644 index 0000000000..b5834ec181 --- /dev/null +++ b/include/wx/stubs/notebook.h @@ -0,0 +1,202 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: notebook.h +// Purpose: MSW/GTK compatible notebook (a.k.a. property sheet) +// Author: AUTHOR +// Modified by: +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_NOTEBOOK_H_ +#define _WX_NOTEBOOK_H_ + +#ifdef __GNUG__ +#pragma interface "notebook.h" +#endif + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- +#include + +// ---------------------------------------------------------------------------- +// types +// ---------------------------------------------------------------------------- + +// fwd declarations +class WXDLLEXPORT wxImageList; +class WXDLLEXPORT wxWindow; + +// array of notebook pages +typedef wxWindow wxNotebookPage; // so far, any window can be a page +WX_DEFINE_ARRAY(wxNotebookPage *, wxArrayPages); + +// ---------------------------------------------------------------------------- +// notebook events +// ---------------------------------------------------------------------------- +class WXDLLEXPORT wxNotebookEvent : public wxCommandEvent +{ +public: + wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0, + int nSel = -1, int nOldSel = -1) + : wxCommandEvent(commandType, id) { m_nSel = nSel; m_nOldSel = nOldSel; } + + // accessors + int GetSelection() const { return m_nSel; } + int GetOldSelection() const { return m_nOldSel; } + +private: + int m_nSel, // currently selected page + m_nOldSel; // previously selected page + + 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: + // ctors + // ----- + // default for dynamic class + wxNotebook(); + // the same arguments as for wxControl (@@@ any special styles?) + wxNotebook(wxWindow *parent, + 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, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = "notebook"); + // dtor + ~wxNotebook(); + + // accessors + // --------- + // get number of pages in the dialog + int GetPageCount() const; + + // set the currently selected page, return the index of the previously + // selected one (or -1 on error) + // NB: this function will _not_ generate wxEVT_NOTEBOOK_PAGE_xxx events + int SetSelection(int nPage); + // cycle thru the tabs + void AdvanceSelection(bool bForward = TRUE); + // get the currently selected page + int GetSelection() const { return m_nSelection; } + + // set/get the title of a page + bool SetPageText(int nPage, const wxString& strText); + wxString GetPageText(int nPage) const; + + // image list stuff: each page may have an image associated with it. All + // the images belong to an image list, so you have to + // 1) create an image list + // 2) associate it with the notebook + // 3) set for each page it's image + // 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_pImageList; } + + // sets/returns item's image index in the current image list + int GetPageImage(int nPage) const; + bool SetPageImage(int nPage, int nImage); + + // currently it's always 1 because wxGTK doesn't support multi-row + // tab controls + int GetRowCount() const; + + // control the appearance of the notebook pages + // set the size (the same for all pages) + void SetPageSize(const wxSize& size); + // set the padding between tabs (in pixels) + void SetPadding(const wxSize& padding); + + // operations + // ---------- + // remove one page from the notebook + bool DeletePage(int nPage); + // remove all pages + 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(wxNotebookPage *pPage, + const wxString& strText, + bool bSelect = FALSE, + int imageId = -1); + // 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 + wxNotebookPage *GetPage(int nPage) { return m_aPages[nPage]; } + + // 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(); + + // 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() +}; + +// ---------------------------------------------------------------------------- +// event macros +// ---------------------------------------------------------------------------- +typedef void (wxEvtHandler::*wxNotebookEventFunction)(wxNotebookEvent&); + +#define EVT_NOTEBOOK_PAGE_CHANGED(id, fn) \ + { \ + wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, \ + id, \ + -1, \ + (wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \ + NULL \ + }, + +#define EVT_NOTEBOOK_PAGE_CHANGING(id, fn) \ + { \ + wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, \ \ + id, \ + -1, \ + (wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \ + NULL \ + }, + +#endif // _WX_NOTEBOOK_H_ diff --git a/include/wx/stubs/palette.h b/include/wx/stubs/palette.h new file mode 100644 index 0000000000..a5c85bb1d0 --- /dev/null +++ b/include/wx/stubs/palette.h @@ -0,0 +1,66 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: palette.h +// Purpose: wxPalette class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PALETTE_H_ +#define _WX_PALETTE_H_ + +#ifdef __GNUG__ +#pragma interface "palette.h" +#endif + +#include "wx/gdiobj.h" + +class WXDLLEXPORT wxPalette; + +class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData +{ + friend class WXDLLEXPORT wxPalette; +public: + wxPaletteRefData(); + ~wxPaletteRefData(); +/* TODO: implementation +protected: + WXHPALETTE m_hPalette; +*/ +}; + +#define M_PALETTEDATA ((wxPaletteRefData *)m_refData) + +class WXDLLEXPORT wxPalette: public wxGDIObject +{ + DECLARE_DYNAMIC_CLASS(wxPalette) + +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; + + virtual bool Ok() const { return (m_refData != NULL) ; } + + 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_ diff --git a/include/wx/stubs/pen.h b/include/wx/stubs/pen.h new file mode 100644 index 0000000000..74e961c1d3 --- /dev/null +++ b/include/wx/stubs/pen.h @@ -0,0 +1,92 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: pen.h +// Purpose: wxPen class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PEN_H_ +#define _WX_PEN_H_ + +#ifdef __GNUG__ +#pragma interface "pen.h" +#endif + +#include "wx/gdiobj.h" + +typedef WXDWORD wxDash ; + +class WXDLLEXPORT wxPen; + +class WXDLLEXPORT wxPenRefData: public wxGDIRefData +{ + friend class WXDLLEXPORT wxPen; +public: + wxPenRefData(); + ~wxPenRefData(); + +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; +*/ +}; + +#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) ; } + + // 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); }; +}; + +#endif + // _WX_PEN_H_ diff --git a/include/wx/stubs/print.h b/include/wx/stubs/print.h new file mode 100644 index 0000000000..bac3703496 --- /dev/null +++ b/include/wx/stubs/print.h @@ -0,0 +1,56 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: print.h +// Purpose: wxPrinter, wxPrintPreview classes +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PRINT_H_ +#define _WX_PRINT_H_ + +#ifdef __GNUG__ +#pragma interface "print.h" +#endif + +#include "wx/prntbase.h" + +/* + * Represents the printer: manages printing a wxPrintout object + */ + +class WXDLLEXPORT wxPrinter: public wxPrinterBase +{ + DECLARE_DYNAMIC_CLASS(wxPrinter) + + public: + wxPrinter(wxPrintData *data = NULL); + ~wxPrinter(); + + virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = TRUE); + virtual bool PrintDialog(wxWindow *parent); + virtual bool Setup(wxWindow *parent); +}; + +/* + * wxPrintPreview + * Programmer creates an object of this class to preview a wxPrintout. + */ + +class WXDLLEXPORT wxPrintPreview: public wxPrintPreviewBase +{ + DECLARE_CLASS(wxPrintPreview) + + public: + wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting = NULL, wxPrintData *data = NULL); + ~wxPrintPreview(); + + virtual bool Print(bool interactive); + virtual void DetermineScaling(); +}; + +#endif + // _WX_PRINT_H_ diff --git a/include/wx/stubs/printdlg.h b/include/wx/stubs/printdlg.h new file mode 100644 index 0000000000..d6ee60ff46 --- /dev/null +++ b/include/wx/stubs/printdlg.h @@ -0,0 +1,72 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: printdlg.h +// Purpose: wxPrintDialog, wxPageSetupDialog classes +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PRINTDLG_H_ +#define _WX_PRINTDLG_H_ + +#ifdef __GNUG__ +#pragma interface "printdlg.h" +#endif + +#include "wx/dialog.h" +#include "wx/cmndata.h" + +/* + * wxPrinterDialog + * The common dialog for printing. + */ + +class WXDLLEXPORT wxDC; +class WXDLLEXPORT wxPrintDialog: public wxDialog +{ + DECLARE_DYNAMIC_CLASS(wxPrintDialog) + + public: + wxPrintDialog(); + wxPrintDialog(wxWindow *parent, wxPrintData* data = NULL); + ~wxPrintDialog(); + + bool Create(wxWindow *parent, wxPrintData* data = NULL); + virtual int ShowModal(); + + inline wxPrintData& GetPrintData() { return m_printData; } + virtual wxDC *GetPrintDC(); + + private: + wxPrintData m_printData; + wxDC* m_printerDC; + bool m_destroyDC; + char* m_deviceName; + char* m_driverName; + char* m_portName; + wxWindow* m_dialogParent; +}; + +class WXDLLEXPORT wxPageSetupDialog: public wxDialog +{ + DECLARE_DYNAMIC_CLASS(wxPageSetupDialog) + + private: + wxPageSetupData m_pageSetupData; + wxWindow* m_dialogParent; + public: + wxPageSetupDialog(); + wxPageSetupDialog(wxWindow *parent, wxPageSetupData *data = NULL); + ~wxPageSetupDialog(); + + bool Create(wxWindow *parent, wxPageSetupData *data = NULL); + virtual int ShowModal(); + + inline wxPageSetupData& GetPageSetupData() { return m_pageSetupData; } +}; + +#endif + // _WX_PRINTDLG_H_ diff --git a/include/wx/stubs/private.h b/include/wx/stubs/private.h new file mode 100644 index 0000000000..922c172436 --- /dev/null +++ b/include/wx/stubs/private.h @@ -0,0 +1,21 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: private.h +// Purpose: Private declarations +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PRIVATE_H_ +#define _WX_PRIVATE_H_ + +#include "wx/defs.h" + +/* TODO: put any private declarations here. + */ + +#endif + // _WX_PRIVATE_H_ diff --git a/include/wx/stubs/radiobox.h b/include/wx/stubs/radiobox.h new file mode 100644 index 0000000000..d70548dfa3 --- /dev/null +++ b/include/wx/stubs/radiobox.h @@ -0,0 +1,92 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: radiobox.h +// Purpose: wxRadioBox class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_RADIOBOX_H_ +#define _WX_RADIOBOX_H_ + +#ifdef __GNUG__ +#pragma interface "radiobox.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxRadioBoxNameStr; + +// List box item +class WXDLLEXPORT wxBitmap ; + +class WXDLLEXPORT wxRadioBox: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxRadioBox) +public: + wxRadioBox(); + + 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(); + + 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); + + 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) ; + void SetLabel(int item, wxBitmap *bitmap) ; + 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); + + 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_radioWidth ; // for bitmaps (not implemented) + int * m_radioHeight ; + + int m_noItems; + int m_noRowsOrCols; + int m_selectedButton; + +}; + +#endif + // _WX_RADIOBOX_H_ diff --git a/include/wx/stubs/radiobut.h b/include/wx/stubs/radiobut.h new file mode 100644 index 0000000000..7a4ce62d50 --- /dev/null +++ b/include/wx/stubs/radiobut.h @@ -0,0 +1,92 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: radiobut.h +// Purpose: wxRadioButton class +// Author: AUTHOR +// Modified by: +// Created: 01/02/97 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_RADIOBUT_H_ +#define _WX_RADIOBUT_H_ + +#ifdef __GNUG__ +#pragma interface "radiobut.h" +#endif + +#include "wx/control.h" + +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); +}; + +// Not implemented +#if 0 +class WXDLLEXPORT wxBitmap ; + +WXDLLEXPORT_DATA(extern const char*) wxBitmapRadioButtonNameStr; + +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_ diff --git a/include/wx/stubs/region.h b/include/wx/stubs/region.h new file mode 100644 index 0000000000..02bf97845f --- /dev/null +++ b/include/wx/stubs/region.h @@ -0,0 +1,140 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: region.h +// Purpose: wxRegion class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_REGION_H_ +#define _WX_REGION_H_ + +#ifdef __GNUG__ +#pragma interface "region.h" +#endif + +#include "wx/list.h" +#include "wx/gdiobj.h" + +class WXDLLEXPORT wxRect; +class WXDLLEXPORT wxPoint; + +enum wxRegionContain { + wxOutRegion = 0, wxPartRegion = 1, wxInRegion = 2 +}; + +// So far, for internal use only +enum wxRegionOp { +wxRGN_AND, // Creates the intersection of the two combined regions. +wxRGN_COPY, // Creates a copy of the region identified by hrgnSrc1. +wxRGN_DIFF, // Combines the parts of hrgnSrc1 that are not part of hrgnSrc2. +wxRGN_OR, // Creates the union of two combined regions. +wxRGN_XOR // Creates the union of two combined regions except for any overlapping areas. +}; + +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 + // _WX_REGION_H_ diff --git a/include/wx/stubs/scrolbar.h b/include/wx/stubs/scrolbar.h new file mode 100644 index 0000000000..eeef6727c5 --- /dev/null +++ b/include/wx/stubs/scrolbar.h @@ -0,0 +1,68 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: scrollbar.h +// Purpose: wxScrollBar class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SCROLBAR_H_ +#define _WX_SCROLBAR_H_ + +#ifdef __GNUG__ +#pragma interface "scrolbar.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxScrollBarNameStr; + +// Scrollbar item +class WXDLLEXPORT wxScrollBar: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxScrollBar) + +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 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() 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 + // _WX_SCROLBAR_H_ diff --git a/include/wx/stubs/settings.h b/include/wx/stubs/settings.h new file mode 100644 index 0000000000..7cd3cbe19e --- /dev/null +++ b/include/wx/stubs/settings.h @@ -0,0 +1,129 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: settings.h +// Purpose: wxSystemSettings class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SETTINGS_H_ +#define _WX_SETTINGS_H_ + +#ifdef __GNUG__ +#pragma interface "settings.h" +#endif + +#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() {} + + // Get a system colour + static wxColour GetSystemColour(int index); + + // Get a system font + static wxFont GetSystemFont(int index); + + // Get a system metric, e.g. scrollbar size + static int GetSystemMetric(int index); +}; + +#endif + // _WX_SETTINGS_H_ diff --git a/include/wx/stubs/setup.h b/include/wx/stubs/setup.h new file mode 100644 index 0000000000..d28d09e43c --- /dev/null +++ b/include/wx/stubs/setup.h @@ -0,0 +1,115 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: setup.h +// Purpose: Configuration for the library +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SETUP_H_ +#define _WX_SETUP_H_ + +/* + * General features + * + */ + +#define USE_CONFIG 1 + // Use wxConfig, with CreateConfig in wxApp +#define _WX_GOODCOMPILER__ + // gcc can have problems, but Windows compilers + // are generally OK. +#define WXWIN_COMPATIBILITY 1 + // Compatibility with 1.66 API. + // Level 0: no backward compatibility, all new features + // Level 1: wxDC, OnSize (etc.) compatibility, but + // some new features such as event tables + +#define USE_POSTSCRIPT 1 + // 0 for no PostScript device context +#define USE_AFM_FOR_POSTSCRIPT 0 + // 1 to use font metric files in GetTextExtent +#define USE_METAFILE 1 + // 0 for no Metafile and metafile device context +#define USE_IPC 1 + // 0 for no interprocess comms +#define USE_HELP 1 + // 0 for no help facility +#define USE_RESOURCES 1 + // 0 for no wxGetResource/wxWriteResource +#define USE_CLIPBOARD 1 + // 0 for no clipboard functions +#define USE_SPLINES 1 + // 0 for no splines +#define USE_XFIG_SPLINE_CODE 1 + // 1 for XFIG spline code, 0 for AIAI spline code. +// AIAI spline code is slower, but freer of copyright issues. + +#define USE_DRAG_AND_DROP 1 + // 0 for no drag and drop + +#define USE_WX_RESOURCES 1 + // Use .wxr resource mechanism (requires PrologIO library) + +#define USE_DOC_VIEW_ARCHITECTURE 1 + // Set to 0 to disable document/view architecture +#define USE_PRINTING_ARCHITECTURE 1 + // Set to 0 to disable print/preview architecture code +#define USE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1 + // Set to 0 to disable PostScript print/preview architecture code + // under Windows (just use Windows printing). +#define USE_DYNAMIC_CLASSES 1 + // If 1, enables provision of run-time type information. + // NOW MANDATORY: don't change. +#define USE_MEMORY_TRACING 1 + // If 1, enables debugging versions of wxObject::new and + // wxObject::delete *IF* WXDEBUG is also defined. + // WARNING: this code may not work with all architectures, especially + // if alignment is an issue. +#define USE_DEBUG_CONTEXT 1 + // If 1, enables wxDebugContext, for + // writing error messages to file, etc. + // If WXDEBUG is not defined, will still use + // normal memory operators. + // It's recommended to set this to 1, + // since you may well need to output + // an error log in a production + // version (or non-debugging beta) +#define USE_GLOBAL_MEMORY_OPERATORS 1 + // In debug mode, cause new and delete to be redefined globally. + // If this causes problems (e.g. link errors), set this to 0. + +#define REMOVE_UNUSED_ARG 1 + // Set this to 0 if your compiler can't cope + // with omission of prototype parameters. + +#define USE_C_MAIN 0 + // Set to 1 to use main.c instead of main.cpp (UNIX only) + +#define USE_ODBC 1 + // Define 1 to use ODBC classes + +#define USE_IOSTREAMH 1 + // VC++ 4.2 and above allows and + // but you can't mix them. Set to 1 for , + // 0 for + +#define USE_WXCONFIG 1 + // if enabled, compiles built-in OS independent wxConfig + // class and it's file (any platform) and registry (Win) + // based implementations +/* + * Finer detail + * + */ + +#define USE_APPLE_IEEE 1 + // if enabled, the float codec written by Apple + // will be used to write, in a portable way, + // float on the disk + +#endif + // _WX_SETUP_H_ diff --git a/include/wx/stubs/slider.h b/include/wx/stubs/slider.h new file mode 100644 index 0000000000..239e914e5c --- /dev/null +++ b/include/wx/stubs/slider.h @@ -0,0 +1,91 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: slider.h +// Purpose: wxSlider class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SLIDER_H_ +#define _WX_SLIDER_H_ + +#ifdef __GNUG__ +#pragma interface "slider.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxSliderNameStr; + +// Slider +class WXDLLEXPORT wxSlider: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxSlider) + +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) + { + 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 wxString& name = wxSliderNameStr); + + 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 + // _WX_SLIDER_H_ diff --git a/include/wx/stubs/spinbutt.h b/include/wx/stubs/spinbutt.h new file mode 100644 index 0000000000..afdb978c3f --- /dev/null +++ b/include/wx/stubs/spinbutt.h @@ -0,0 +1,97 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: spinbutt.h +// Purpose: wxSpinButton class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SPINBUTT_H_ +#define _WX_SPINBUTT_H_ + +#ifdef __GNUG__ +#pragma interface "spinbutt.h" +#endif + +#include "wx/control.h" +#include "wx/event.h" + +/* + The wxSpinButton is like a small scrollbar than is often placed next + to a text control. + + wxSP_HORIZONTAL: horizontal spin button + wxSP_VERTICAL: vertical spin button (the default) + wxSP_ARROW_KEYS: arrow keys increment/decrement value + wxSP_WRAP: value wraps at either end + */ + +class WXDLLEXPORT wxSpinButton: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxSpinButton) + public: + /* + * Public interface + */ + + wxSpinButton(); + + inline wxSpinButton(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxSP_VERTICAL, const wxString& name = "wxSpinButton") + { + Create(parent, id, pos, size, style, name); + } + ~wxSpinButton(); + + bool Create(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxSP_VERTICAL, const wxString& name = "wxSpinButton"); + + + // Attributes + //////////////////////////////////////////////////////////////////////////// + + int GetValue() const ; + void SetValue(int val) ; + void SetRange(int minVal, int maxVal) ; + inline int GetMin() const { return m_min; } + inline int GetMax() const { return m_max; } + + // Operations + //////////////////////////////////////////////////////////////////////////// + + void Command(wxCommandEvent& event) { ProcessCommand(event); }; + +protected: + int m_min; + int m_max; +}; + +class WXDLLEXPORT wxSpinEvent: public wxScrollEvent +{ + DECLARE_DYNAMIC_CLASS(wxSpinEvent) + + public: + wxSpinEvent(wxEventType commandType = wxEVT_NULL, int id = 0); +}; + +typedef void (wxEvtHandler::*wxSpinEventFunction)(wxSpinEvent&); + +// Spin events + +#define EVT_SPIN_UP(id, func) { wxEVT_SCROLL_LINEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func } +#define EVT_SPIN_DOWN(id, func) { wxEVT_SCROLL_LINEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func } + +#define EVT_SPIN(id, func) \ + { wxEVT_SCROLL_TOP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_BOTTOM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_LINEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_LINEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_PAGEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_PAGEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_THUMBTRACK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func }, + +#endif + // _WX_SPINBUTT_H_ diff --git a/include/wx/stubs/statbmp.h b/include/wx/stubs/statbmp.h new file mode 100644 index 0000000000..f371fddd2d --- /dev/null +++ b/include/wx/stubs/statbmp.h @@ -0,0 +1,64 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: statbmp.h +// Purpose: wxStaticBitmap class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_STATBMP_H_ +#define _WX_STATBMP_H_ + +#ifdef __GNUG__ +#pragma interface "statbmp.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxStaticBitmapNameStr; + +class WXDLLEXPORT wxStaticBitmap: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxStaticBitmap) + public: + inline 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); + } + + 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); + + 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; + +}; + +#endif + // _WX_STATBMP_H_ diff --git a/include/wx/stubs/statbox.h b/include/wx/stubs/statbox.h new file mode 100644 index 0000000000..1aa4a6f88a --- /dev/null +++ b/include/wx/stubs/statbox.h @@ -0,0 +1,57 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: statbox.h +// Purpose: wxStaticBox class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_STATBOX_H_ +#define _WX_STATBOX_H_ + +#ifdef __GNUG__ +#pragma interface "statbox.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxStaticBoxNameStr; + +// Group box +class WXDLLEXPORT wxStaticBox: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxStaticBox) + + 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 + // _WX_STATBOX_H_ diff --git a/include/wx/stubs/statbrxx.h b/include/wx/stubs/statbrxx.h new file mode 100644 index 0000000000..75005057f5 --- /dev/null +++ b/include/wx/stubs/statbrxx.h @@ -0,0 +1,48 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: msw/statbrxx.h +// Purpose: native implementation of wxStatusBar. Optional. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_STATBRXX_H +#define _WX_STATBRXX_H + +#ifdef __GNUG__ +#pragma interface "statbrxx.h" +#endif + +class WXDLLEXPORT wxStatusBarXX : public wxStatusBar +{ + DECLARE_DYNAMIC_CLASS(wxStatusBarXX); + +public: + // ctors + wxStatusBarXX(); + wxStatusBarXX(wxWindow *parent, wxWindowID id = -1, long style = wxST_SIZEGRIP); + + // create status line + bool Create(wxWindow *parent, wxWindowID id = -1, long style = wxST_SIZEGRIP); + + // a status line can have several (<256) fields numbered from 0 + virtual void SetFieldsCount(int number = 1, const int widths[] = NULL); + + // each field of status line has it's own text + virtual void SetStatusText(const wxString& text, int number = 0); + virtual wxString GetStatusText(int number = 0) const; + + // set status line fields' widths + virtual void SetStatusWidths(int n, const int widths_field[]); + + // we're going to process WM_SIZE (of the parent window) + void OnSize(wxSizeEvent& event); + + DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_STATBRXX_H \ No newline at end of file diff --git a/include/wx/stubs/stattext.h b/include/wx/stubs/stattext.h new file mode 100644 index 0000000000..aa8eaf229e --- /dev/null +++ b/include/wx/stubs/stattext.h @@ -0,0 +1,56 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: stattext.h +// Purpose: wxStaticText class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_STATTEXT_H_ +#define _WX_STATTEXT_H_ + +#ifdef __GNUG__ +#pragma interface "stattext.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxStaticTextNameStr; + +class WXDLLEXPORT wxStaticText: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxStaticText) + 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 + // _WX_STATTEXT_H_ diff --git a/include/wx/stubs/tabctrl.h b/include/wx/stubs/tabctrl.h new file mode 100644 index 0000000000..80740019b4 --- /dev/null +++ b/include/wx/stubs/tabctrl.h @@ -0,0 +1,138 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: tabctrl.h +// Purpose: wxTabCtrl class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TABCTRL_H_ +#define _WX_TABCTRL_H_ + +#ifdef __GNUG__ +#pragma interface "tabctrl.h" +#endif + +class wxImageList; + +/* + * Flags returned by HitTest + */ + +#define wxTAB_HITTEST_NOWHERE 1 +#define wxTAB_HITTEST_ONICON 2 +#define wxTAB_HITTEST_ONLABEL 4 +#define wxTAB_HITTEST_ONITEM 6 + +class WXDLLEXPORT wxTabCtrl: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxTabCtrl) + public: + /* + * Public interface + */ + + wxTabCtrl(); + + inline wxTabCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = 0, const wxString& name = "tabCtrl") + { + Create(parent, id, pos, size, style, name); + } + ~wxTabCtrl(); + +// Accessors + + // Get the selection + int GetSelection() const; + + // Get the tab with the current keyboard focus + int GetCurFocus() const; + + // Get the associated image list + wxImageList* GetImageList() const; + + // Get the number of items + int GetItemCount() const; + + // Get the rect corresponding to the tab + bool GetItemRect(int item, wxRect& rect) const; + + // Get the number of rows + int GetRowCount() const; + + // Get the item text + wxString GetItemText(int item) const ; + + // Get the item image + int GetItemImage(int item) const; + + // Get the item data + void* GetItemData(int item) const; + + // Set the selection + int SetSelection(int item); + + // Set the image list + void SetImageList(wxImageList* imageList); + + // Set the text for an item + bool SetItemText(int item, const wxString& text); + + // Set the image for an item + bool SetItemImage(int item, int image); + + // Set the data for an item + bool SetItemData(int item, void* data); + + // Set the size for a fixed-width tab control + void SetItemSize(const wxSize& size); + + // Set the padding between tabs + void SetPadding(const wxSize& padding); + +// Operations + + bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = 0, const wxString& name = "tabCtrl"); + + // Delete all items + bool DeleteAllItems(); + + // Delete an item + bool DeleteItem(int item); + + // Hit test + int HitTest(const wxPoint& pt, long& flags); + + // Insert an item + bool InsertItem(int item, const wxString& text, int imageId = -1, void* data = NULL); + + void Command(wxCommandEvent& event); + +protected: + wxImageList* m_imageList; + +DECLARE_EVENT_TABLE() +}; + +class WXDLLEXPORT wxTabEvent: public wxCommandEvent +{ + DECLARE_DYNAMIC_CLASS(wxTabEvent) + + public: + wxTabEvent(wxEventType commandType = wxEVT_NULL, int id = 0); +}; + +typedef void (wxEvtHandler::*wxTabEventFunction)(wxTabEvent&); + +#define EVT_TAB_SEL_CHANGED(id, fn) { wxEVT_COMMAND_TAB_SEL_CHANGED, \ + id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTabEventFunction) & fn, NULL }, +#define EVT_TAB_SEL_CHANGING(id, fn) { wxEVT_COMMAND_TAB_SEL_CHANGING, \ + id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTabEventFunction) & fn, NULL }, + +#endif + // _WX_TABCTRL_H_ diff --git a/include/wx/stubs/taskbar.h b/include/wx/stubs/taskbar.h new file mode 100644 index 0000000000..7dad1538e1 --- /dev/null +++ b/include/wx/stubs/taskbar.h @@ -0,0 +1,72 @@ +///////////////////////////////////////////////////////////////////////// +// File: taskbar.h +// Purpose: Defines wxTaskBarIcon class for manipulating icons on the +// task bar. Optional. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TASKBAR_H_ +#define _WX_TASKBAR_H_ + +#ifdef __GNUG__ +#pragma interface "taskbar.h" +#endif + +#include +#include + +class wxTaskBarIcon: public wxObject +{ +public: + wxTaskBarIcon(); + virtual ~wxTaskBarIcon(); + +// Accessors +/* TODO: implementation + inline WXHWND GetHWND() const { return m_hWnd; } + inline bool IsOK() const { return (m_hWnd != 0) ; } + inline bool IsIconInstalled() const { return m_iconAdded; } +*/ + +// Operations + bool SetIcon(const wxIcon& icon, const wxString& tooltip = ""); + bool RemoveIcon(); + +// Overridables + virtual void OnMouseMove(); + virtual void OnLButtonDown(); + virtual void OnLButtonUp(); + virtual void OnRButtonDown(); + virtual void OnRButtonUp(); + virtual void OnLButtonDClick(); + virtual void OnRButtonDClick(); + +/* TODO +// Implementation + static wxTaskBarIcon* FindObjectForHWND(WXHWND hWnd); + static void AddObject(wxTaskBarIcon* obj); + static void RemoveObject(wxTaskBarIcon* obj); + static bool RegisterWindowClass(); + static WXHWND CreateTaskBarWindow(); + long WindowProc( WXHWND hWnd, unsigned int msg, unsigned int wParam, long lParam ); +*/ + +// Data members +protected: +/* TODO: implementation + WXHWND m_hWnd; + static bool sm_registeredClass; + static unsigned int sm_taskbarMsg; + static wxList sm_taskBarIcons; +*/ + + bool m_iconAdded; +}; + +#endif + // _WX_TASKBAR_H_ diff --git a/include/wx/stubs/textctrl.h b/include/wx/stubs/textctrl.h new file mode 100644 index 0000000000..a4efeba67c --- /dev/null +++ b/include/wx/stubs/textctrl.h @@ -0,0 +1,141 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: textctrl.h +// Purpose: wxTextCtrl class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TEXTCTRL_H_ +#define _WX_TEXTCTRL_H_ + +#ifdef __GNUG__ +#pragma interface "textctrl.h" +#endif + +#include "wx/control.h" + +#if USE_IOSTREAMH +#include +#else +#include +#endif + +WXDLLEXPORT_DATA(extern const char*) wxTextCtrlNameStr; +WXDLLEXPORT_DATA(extern const char*) wxEmptyString; + +// Single-line text item +class WXDLLEXPORT wxTextCtrl: public wxControl + +// 16-bit Borland 4.0 doesn't seem to allow multiple inheritance with wxWindow and streambuf: +// it complains about deriving a huge class from the huge class streambuf. !! +// Also, can't use streambuf if making or using a DLL :-( + +#if (defined(__BORLANDC__) && !defined(__WIN32__)) || defined(__MWERKS__) +#define NO_TEXT_WINDOW_STREAM +#endif + +#ifndef NO_TEXT_WINDOW_STREAM +, public streambuf +#endif + +{ + DECLARE_DYNAMIC_CLASS(wxTextCtrl) + +public: + // 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 fileName; + + DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_TEXTCTRL_H_ diff --git a/include/wx/stubs/timer.h b/include/wx/stubs/timer.h new file mode 100644 index 0000000000..22fa2eed59 --- /dev/null +++ b/include/wx/stubs/timer.h @@ -0,0 +1,57 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: timer.h +// Purpose: wxTimer class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TIMER_H_ +#define _WX_TIMER_H_ + +#ifdef __GNUG__ +#pragma interface "timer.h" +#endif + +#include "wx/object.h" + +class WXDLLEXPORT wxTimer: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxTimer) + + 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; + +}; + +/* 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_ diff --git a/include/wx/stubs/toolbar.h b/include/wx/stubs/toolbar.h new file mode 100644 index 0000000000..68ad607708 --- /dev/null +++ b/include/wx/stubs/toolbar.h @@ -0,0 +1,78 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: toolbar.h +// Purpose: wxToolBar class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TOOLBAR_H_ +#define _WX_TOOLBAR_H_ + +#ifdef __GNUG__ +#pragma interface "toolbar.h" +#endif + +#include "wx/tbarbase.h" + +WXDLLEXPORT_DATA(extern const char*) wxToolBarNameStr; + +class WXDLLEXPORT wxToolBar: public wxToolBarBase +{ + DECLARE_DYNAMIC_CLASS(wxToolBar) + public: + /* + * Public interface + */ + + wxToolBar(); + + inline wxToolBar(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxNO_BORDER|wxTB_HORIZONTAL, + const wxString& name = wxToolBarNameStr) + { + Create(parent, id, pos, size, style, name); + } + ~wxToolBar(); + + bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxNO_BORDER|wxTB_HORIZONTAL, + const wxString& name = wxToolBarNameStr); + + // If pushedBitmap is NULL, a reversed version of bitmap is + // created and used as the pushed/toggled image. + // If toggle is TRUE, the button toggles between the two states. + wxToolBarTool *AddTool(int toolIndex, const wxBitmap& bitmap, const wxBitmap& pushedBitmap = wxNullBitmap, + bool toggle = FALSE, long xPos = -1, long yPos = -1, wxObject *clientData = NULL, + const wxString& helpString1 = "", const wxString& helpString2 = ""); + + // Set default bitmap size + void SetToolBitmapSize(const wxSize& size); + void EnableTool(int toolIndex, bool enable); // additional drawing on enabling + void ToggleTool(int toolIndex, bool toggle); // toggle is TRUE if toggled on + void ClearTools(); + + // The button size is bigger than the bitmap size + wxSize GetToolSize() const; + + wxSize GetMaxSize() const; + void GetSize(int *w, int *y) const; + + // Add all the buttons: required for Win. + virtual bool CreateTools(); + virtual void SetRows(int nRows); + virtual void Layout() {} + + // The post-tool-addition call + bool Realize() { return CreateTools(); }; + +protected: + +DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_TOOLBAR_H_ diff --git a/include/wx/stubs/treectrl.h b/include/wx/stubs/treectrl.h new file mode 100644 index 0000000000..c107fdc8ba --- /dev/null +++ b/include/wx/stubs/treectrl.h @@ -0,0 +1,295 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: treectrl.h +// Purpose: wxTreeCtrl class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TREECTRL_H_ +#define _WX_TREECTRL_H_ + +#ifdef __GNUG__ +#pragma interface "treectrl.h" +#endif + +#include "wx/control.h" +#include "wx/event.h" +#include "wx/imaglist.h" + +#define wxTREE_MASK_HANDLE 0x0001 +#define wxTREE_MASK_STATE 0x0002 +#define wxTREE_MASK_TEXT 0x0004 +#define wxTREE_MASK_IMAGE 0x0008 +#define wxTREE_MASK_SELECTED_IMAGE 0x0010 +#define wxTREE_MASK_CHILDREN 0x0020 +#define wxTREE_MASK_DATA 0x0040 + +#define wxTREE_STATE_BOLD 0x0001 +#define wxTREE_STATE_DROPHILITED 0x0002 +#define wxTREE_STATE_EXPANDED 0x0004 +#define wxTREE_STATE_EXPANDEDONCE 0x0008 +#define wxTREE_STATE_FOCUSED 0x0010 +#define wxTREE_STATE_SELECTED 0x0020 +#define wxTREE_STATE_CUT 0x0040 + +#define wxTREE_HITTEST_ABOVE 0x0001 // Above the client area. +#define wxTREE_HITTEST_BELOW 0x0002 // Below the client area. +#define wxTREE_HITTEST_NOWHERE 0x0004 // In the client area but below the last item. +#define wxTREE_HITTEST_ONITEMBUTTON 0x0010 // On the button associated with an item. +#define wxTREE_HITTEST_ONITEMICON 0x0020 // On the bitmap associated with an item. +#define wxTREE_HITTEST_ONITEMINDENT 0x0040 // In the indentation associated with an item. +#define wxTREE_HITTEST_ONITEMLABEL 0x0080 // On the label (string) associated with an item. +#define wxTREE_HITTEST_ONITEMRIGHT 0x0100 // In the area to the right of an item. +#define wxTREE_HITTEST_ONITEMSTATEICON 0x0200 // On the state icon for a tree view item that is in a user-defined state. +#define wxTREE_HITTEST_TOLEFT 0x0400 // To the right of the client area. +#define wxTREE_HITTEST_TORIGHT 0x0800 // To the left of the client area. + +#define wxTREE_HITTEST_ONITEM (wxTREE_HITTEST_ONITEMICON | wxTREE_HITTEST_ONITEMLABEL | wxTREE_HITTEST_ONITEMSTATEICON) + +// Flags for GetNextItem +enum { + wxTREE_NEXT_CARET, // Retrieves the currently selected item. + wxTREE_NEXT_CHILD, // Retrieves the first child item. The hItem parameter must be NULL. + wxTREE_NEXT_DROPHILITE, // Retrieves the item that is the target of a drag-and-drop operation. + wxTREE_NEXT_FIRSTVISIBLE, // Retrieves the first visible item. + wxTREE_NEXT_NEXT, // Retrieves the next sibling item. + wxTREE_NEXT_NEXTVISIBLE, // Retrieves the next visible item that follows the specified item. + wxTREE_NEXT_PARENT, // Retrieves the parent of the specified item. + wxTREE_NEXT_PREVIOUS, // Retrieves the previous sibling item. + wxTREE_NEXT_PREVIOUSVISIBLE, // Retrieves the first visible item that precedes the specified item. + wxTREE_NEXT_ROOT // Retrieves the first child item of the root item of which the specified item is a part. +}; + +// Flags for ExpandItem +enum { + wxTREE_EXPAND_EXPAND, + wxTREE_EXPAND_COLLAPSE, + wxTREE_EXPAND_COLLAPSE_RESET, + wxTREE_EXPAND_TOGGLE +}; + +// Flags for InsertItem +enum { + wxTREE_INSERT_LAST = -1, + wxTREE_INSERT_FIRST = -2, + wxTREE_INSERT_SORT = -3 +}; + +class WXDLLEXPORT wxTreeItem: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxTreeItem) +public: + long m_mask; + long m_itemId; + long m_state; + long m_stateMask; + wxString m_text; + int m_image; + int m_selectedImage; + int m_children; + long m_data; + + wxTreeItem(); + +// Accessors + inline long GetMask() const { return m_mask; } + inline long GetItemId() const { return m_itemId; } + inline long GetState() const { return m_state; } + inline long GetStateMask() const { return m_stateMask; } + inline wxString GetText() const { return m_text; } + inline int GetImage() const { return m_image; } + inline int GetSelectedImage() const { return m_selectedImage; } + inline int GetChildren() const { return m_children; } + inline long GetData() const { return m_data; } + + inline void SetMask(long mask) { m_mask = mask; } + inline void SetItemId(long id) { m_itemId = m_itemId = id; } + inline void SetState(long state) { m_state = state; } + inline void SetStateMask(long stateMask) { m_stateMask = stateMask; } + inline void GetText(const wxString& text) { m_text = text; } + inline void SetImage(int image) { m_image = image; } + inline void GetSelectedImage(int selImage) { m_selectedImage = selImage; } + inline void SetChildren(int children) { m_children = children; } + inline void SetData(long data) { m_data = data; } +}; + +class WXDLLEXPORT wxTreeCtrl: public wxControl +{ +public: + /* + * Public interface + */ + + // creation + // -------- + wxTreeCtrl(); + + inline wxTreeCtrl(wxWindow *parent, wxWindowID id = -1, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxTR_HAS_BUTTONS|wxTR_LINES_AT_ROOT, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = "wxTreeCtrl") + { + Create(parent, id, pos, size, style, validator, name); + } + ~wxTreeCtrl(); + + bool Create(wxWindow *parent, wxWindowID id = -1, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxTR_HAS_BUTTONS|wxTR_LINES_AT_ROOT, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = "wxTreeCtrl"); + + // accessors + // --------- + // + int GetCount() const; + + // indent + int GetIndent() const; + void SetIndent(int indent); + // image list + wxImageList *GetImageList(int which = wxIMAGE_LIST_NORMAL) const; + void SetImageList(wxImageList *imageList, int which = wxIMAGE_LIST_NORMAL); + + // navigation inside the tree + long GetNextItem(long item, int code) const; + bool ItemHasChildren(long item) const; + long GetChild(long item) const; + long GetParent(long item) const; + long GetFirstVisibleItem() const; + long GetNextVisibleItem(long item) const; + long GetSelection() const; + long GetRootItem() const; + + // generic function for (g|s)etting item attributes + bool GetItem(wxTreeItem& info) const; + bool SetItem(wxTreeItem& info); + // item state + int GetItemState(long item, long stateMask) const; + bool SetItemState(long item, long state, long stateMask); + // item image + bool SetItemImage(long item, int image, int selImage); + // item text + wxString GetItemText(long item) const; + void SetItemText(long item, const wxString& str); + // custom data associated with the item + long GetItemData(long item) const; + bool SetItemData(long item, long data); + // convenience function + bool IsItemExpanded(long item) + { + return (GetItemState(item, wxTREE_STATE_EXPANDED) & + wxTREE_STATE_EXPANDED) != 0; + } + + // bounding rect + bool GetItemRect(long item, wxRectangle& rect, bool textOnly = FALSE) const; + // + wxTextCtrl* GetEditControl() const; + + // operations + // ---------- + // adding/deleting items + bool DeleteItem(long item); + long InsertItem(long parent, wxTreeItem& info, + long insertAfter = wxTREE_INSERT_LAST); + // If image > -1 and selImage == -1, the same image is used for + // both selected and unselected items. + long InsertItem(long parent, const wxString& label, + int image = -1, int selImage = -1, + long insertAfter = wxTREE_INSERT_LAST); + + // changing item state + bool ExpandItem(long item) { return ExpandItem(item, wxTREE_EXPAND_EXPAND); } + bool CollapseItem(long item) { return ExpandItem(item, wxTREE_EXPAND_COLLAPSE); } + bool ToggleItem(long item) { return ExpandItem(item, wxTREE_EXPAND_TOGGLE); } + // common interface for {Expand|Collapse|Toggle}Item + bool ExpandItem(long item, int action); + + // + bool SelectItem(long item); + bool ScrollTo(long item); + bool DeleteAllItems(); + + // Edit the label (tree must have the focus) + wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl)); + + // End label editing, optionally cancelling the edit + bool EndEditLabel(bool cancel); + + long HitTest(const wxPoint& point, int& flags); + // wxImageList *CreateDragImage(long item); + bool SortChildren(long item); + bool EnsureVisible(long item); + + void Command(wxCommandEvent& event) { ProcessCommand(event); }; + +protected: + wxTextCtrl* m_textCtrl; + wxImageList* m_imageListNormal; + wxImageList* m_imageListState; + + DECLARE_DYNAMIC_CLASS(wxTreeCtrl) +}; + +/* + wxEVT_COMMAND_TREE_BEGIN_DRAG, + wxEVT_COMMAND_TREE_BEGIN_RDRAG, + wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, + wxEVT_COMMAND_TREE_END_LABEL_EDIT, + wxEVT_COMMAND_TREE_DELETE_ITEM, + wxEVT_COMMAND_TREE_GET_INFO, + wxEVT_COMMAND_TREE_SET_INFO, + wxEVT_COMMAND_TREE_ITEM_EXPANDED, + wxEVT_COMMAND_TREE_ITEM_EXPANDING, + wxEVT_COMMAND_TREE_ITEM_COLLAPSED, + wxEVT_COMMAND_TREE_ITEM_COLLAPSING, + wxEVT_COMMAND_TREE_SEL_CHANGED, + wxEVT_COMMAND_TREE_SEL_CHANGING, + wxEVT_COMMAND_TREE_KEY_DOWN +*/ + +class WXDLLEXPORT wxTreeEvent: public wxCommandEvent +{ + DECLARE_DYNAMIC_CLASS(wxTreeEvent) + + public: + wxTreeEvent(wxEventType commandType = wxEVT_NULL, int id = 0); + + int m_code; + wxTreeItem m_item; + long m_oldItem; + wxPoint m_pointDrag; + + inline long GetOldItem() const { return m_oldItem; } + inline wxTreeItem& GetItem() const { return (wxTreeItem&) m_item; } + inline wxPoint GetPoint() const { return m_pointDrag; } + inline int GetCode() const { return m_code; } +}; + +typedef void (wxEvtHandler::*wxTreeEventFunction)(wxTreeEvent&); + +#define EVT_TREE_BEGIN_DRAG(id, fn) { wxEVT_COMMAND_TREE_BEGIN_DRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_BEGIN_RDRAG(id, fn) { wxEVT_COMMAND_TREE_BEGIN_RDRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_BEGIN_LABEL_EDIT(id, fn) { wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_END_LABEL_EDIT(id, fn) { wxEVT_COMMAND_TREE_END_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_DELETE_ITEM(id, fn) { wxEVT_COMMAND_TREE_DELETE_ITEM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_GET_INFO(id, fn) { wxEVT_COMMAND_TREE_GET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_SET_INFO(id, fn) { wxEVT_COMMAND_TREE_SET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_ITEM_EXPANDED(id, fn) { wxEVT_COMMAND_TREE_ITEM_EXPANDED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_ITEM_EXPANDING(id, fn) { wxEVT_COMMAND_TREE_ITEM_EXPANDING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_ITEM_COLLAPSED(id, fn) { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_ITEM_COLLAPSING(id, fn) { wxEVT_COMMAND_TREE_ITEM_COLLAPSING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_SEL_CHANGED(id, fn) { wxEVT_COMMAND_TREE_SEL_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_SEL_CHANGING(id, fn) { wxEVT_COMMAND_TREE_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, +#define EVT_TREE_KEY_DOWN(id, fn) { wxEVT_COMMAND_TREE_KEY_DOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, + +#endif + // _WX_TREECTRL_H_ diff --git a/include/wx/stubs/wave.h b/include/wx/stubs/wave.h new file mode 100644 index 0000000000..485ead936d --- /dev/null +++ b/include/wx/stubs/wave.h @@ -0,0 +1,44 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wave.h +// Purpose: wxWave class (loads and plays short Windows .wav files). +// Optional on non-Windows platforms. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_WAVE_H_ +#define _WX_WAVE_H_ + +#ifdef __GNUG__ +#pragma interface "wave.h" +#endif + +#include "wx/object.h" + +class wxWave : public wxObject +{ +public: + wxWave(); + wxWave(const wxString& fileName, bool isResource = FALSE); + ~wxWave(); + +public: + bool Create(const wxString& fileName, bool isResource = FALSE); + bool IsOk() const { return (m_waveData ? TRUE : FALSE); }; + bool Play(bool async = TRUE, bool looped = FALSE) const; + +protected: + bool Free(); + +private: + byte* m_waveData; + int m_waveLength; + bool m_isResource; +}; + +#endif + // _WX_WAVE_H_ diff --git a/include/wx/stubs/window.h b/include/wx/stubs/window.h new file mode 100644 index 0000000000..28c3441317 --- /dev/null +++ b/include/wx/stubs/window.h @@ -0,0 +1,559 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: window.h +// Purpose: wxWindow class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_WINDOW_H_ +#define _WX_WINDOW_H_ + +#ifdef __GNUG__ +#pragma interface "window.h" +#endif + +#include "wx/gdicmn.h" +#include "wx/icon.h" +#include "wx/cursor.h" +#include "wx/pen.h" +#include "wx/font.h" +#include "wx/validate.h" +#include "wx/event.h" +#include "wx/string.h" +#include "wx/list.h" +#include "wx/region.h" + +#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 wxDropTarget; +#endif + +#if USE_WX_RESOURCES +class WXDLLEXPORT wxResourceTable; +class WXDLLEXPORT wxItemResource; +#endif + +WXDLLEXPORT_DATA(extern const char*) wxPanelNameStr; + +WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize; +WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition; + +class WXDLLEXPORT wxWindow: public wxEvtHandler +{ + DECLARE_ABSTRACT_CLASS(wxWindow) + + friend class wxDC; + friend class wxPaintDC; + +public: + wxWindow(); + 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 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(); + + // Show or hide the window + virtual bool Show(bool show); + + // Is the window shown? + virtual bool IsShown() const; + + // Raise the window to the top of the Z order + virtual void Raise(); + + // Lower the window to the bottom of the Z order + virtual void Lower(); + + // Is the window enabled? + virtual bool IsEnabled() const; + + // For compatibility + inline bool Enabled() const { return IsEnabled(); } + + // Dialog support: override these and call + // base class members to add functionality + // that can't be done using validators. + + // Transfer values to controls. If returns FALSE, + // it's an application error (pops up a dialog) + virtual bool TransferDataToWindow(); + + // 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(); + + // Enable or disable the window + virtual void Enable(bool enable); + +#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 + + // 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) ; + + // 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; + + // 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; + + // 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 + + // 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: implement your own data access + virtual WXHWND GetHWND() const ; + virtual void SetHWND(WXHWND hWnd); +*/ + +/* 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 ; + + 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; + bool m_inOnSize; // Protection against OnSize reentry + bool m_winEnabled; + 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 + bool m_isShown; + wxCursor m_windowCursor; // Window's cursor + wxString m_windowName; // Window name + + wxButton * m_defaultItem; + + wxColour m_backgroundColour ; + wxColour m_foregroundColour ; + bool m_backgroundTransparent; + + int m_xThumbSize; + int m_yThumbSize; + + float m_lastXPos; + float m_lastYPos; + int m_lastEvent; + + bool m_mouseInWindow; + +#if USE_DRAG_AND_DROP + wxDropTarget *m_pDropTarget; // the current drop target or NULL +#endif //USE_DRAG_AND_DROP + +public: +/* TODO: implementation of window handle, note of last message, etc. + WXHWND m_hWnd; // MS Windows window handle + WXUINT m_lastMsg; + WXWPARAM m_lastWParam; + WXLPARAM m_lastLParam; + WXHMENU m_hMenu; // Menu, if any + +*/ + + wxRegion m_updateRegion; + wxList * m_children; // Window's children + int m_returnCode; + +DECLARE_EVENT_TABLE() +}; + +//////////////////////////////////////////////////////////////////////// +//// 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 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_ diff --git a/utils/dialoged/src/winstyle.cpp b/utils/dialoged/src/winstyle.cpp new file mode 100644 index 0000000000..de568dd4d1 --- /dev/null +++ b/utils/dialoged/src/winstyle.cpp @@ -0,0 +1,378 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: winstyle.cpp +// Purpose: Window styles +// Author: Julian Smart +// Modified by: +// Created: 04/01/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "winstyle.h" +#endif + +// For compilers that support precompilation, includes "wx/wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +#ifndef WX_PRECOMP +#include "wx/wx.h" +#endif + +#include +#include +#include +#include + +#include "winstyle.h" + +/* + * Styles + */ + + /* wxListBox */ +static wxWindowStylePair g_WindowStylesListBox[] = { + { "wxLB_SINGLE", wxLB_SINGLE }, + { "wxLB_MULTIPLE", wxLB_MULTIPLE }, + { "wxLB_EXTENDED", wxLB_EXTENDED }, + { "wxLB_NEEDED_SB", wxLB_NEEDED_SB }, + { "wxLB_ALWAYS_SB", wxLB_ALWAYS_SB }, + { "wxLB_SORT", wxLB_SORT }, + { "wxLB_OWNERDRAW", wxLB_OWNERDRAW }, + { "wxLB_HSCROLL", wxLB_HSCROLL } +}; + +int g_WindowStylesListBoxCount = sizeof(g_WindowStylesListBox)/sizeof(wxWindowStylePair) ; + + /* wxComboxBox */ +static wxWindowStylePair g_WindowStylesComboBox[] = { + { "wxCB_SIMPLE", wxCB_SIMPLE }, + { "wxCB_DROPDOWN", wxCB_DROPDOWN }, + { "wxCB_READONLY", wxCB_READONLY }, + { "wxCB_SORT", wxCB_SORT } +}; + +int g_WindowStylesComboBoxCount = sizeof(g_WindowStylesComboBox)/sizeof(wxWindowStylePair) ; + +#if 0 + /* wxChoice */ +static wxWindowStylePair g_WindowStylesChoice[] = { +}; + +int g_WindowStylesChoiceCount = sizeof(g_WindowStylesChoice)/sizeof(wxWindowStylePair) ; +#endif + + /* wxGauge */ +static wxWindowStylePair g_WindowStylesGauge[] = { + { "wxGA_PROGRESSBAR", wxGA_PROGRESSBAR }, + { "wxGA_HORIZONTAL", wxGA_HORIZONTAL }, + { "wxGA_VERTICAL", wxGA_VERTICAL } +}; + +int g_WindowStylesGaugeCount = sizeof(g_WindowStylesGauge)/sizeof(wxWindowStylePair) ; + + /* wxTextCtrl */ +static wxWindowStylePair g_WindowStylesTextCtrl[] = { + { "wxPASSWORD", wxPASSWORD}, + { "wxPROCESS_ENTER", wxPROCESS_ENTER}, + { "wxTE_PASSWORD", wxTE_PASSWORD}, + { "wxTE_READONLY", wxTE_READONLY}, + { "wxTE_PROCESS_ENTER", wxTE_PROCESS_ENTER}, + { "wxTE_MULTILINE", wxTE_MULTILINE} +}; + +int g_WindowStylesTextCtrlCount = sizeof(g_WindowStylesTextCtrl)/sizeof(wxWindowStylePair) ; + + /* wxRadioButton */ +static wxWindowStylePair g_WindowStylesRadioButton[] = { + { "wxRB_GROUP", wxRB_GROUP } +}; + +int g_WindowStylesRadioButtonCount = sizeof(g_WindowStylesRadioButton)/sizeof(wxWindowStylePair) ; + + /* wxRadioBox */ +static wxWindowStylePair g_WindowStylesRadioBox[] = { + { "wxRA_HORIZONTAL", wxRA_HORIZONTAL }, + { "wxRA_VERTICAL", wxRA_VERTICAL } +}; + +int g_WindowStylesRadioBoxCount = sizeof(g_WindowStylesRadioBox)/sizeof(wxWindowStylePair) ; + + /* wxSlider */ +static wxWindowStylePair g_WindowStylesSlider[] = { + { "wxSL_HORIZONTAL", wxSL_HORIZONTAL }, + { "wxSL_VERTICAL", wxSL_VERTICAL }, + { "wxSL_AUTOTICKS", wxSL_AUTOTICKS }, + { "wxSL_LABELS", wxSL_LABELS }, + { "wxSL_LEFT", wxSL_LEFT }, + { "wxSL_TOP", wxSL_TOP }, + { "wxSL_RIGHT", wxSL_RIGHT }, + { "wxSL_BOTTOM", wxSL_BOTTOM }, + { "wxSL_BOTH", wxSL_BOTH }, + { "wxSL_SELRANGE", wxSL_SELRANGE } +}; + +int g_WindowStylesSliderCount = sizeof(g_WindowStylesSlider)/sizeof(wxWindowStylePair) ; + + /* wxScrollBar */ +static wxWindowStylePair g_WindowStylesScrollBar[] = { + { "wxSB_HORIZONTAL", wxSB_HORIZONTAL }, + { "wxSB_VERTICAL", wxSB_VERTICAL } +}; + +int g_WindowStylesScrollBarCount = sizeof(g_WindowStylesScrollBar)/sizeof(wxWindowStylePair) ; + + /* wxButton */ +static wxWindowStylePair g_WindowStylesButton[] = { + { "wxBU_AUTODRAW", wxBU_AUTODRAW }, + { "wxBU_NOAUTODRAW", wxBU_NOAUTODRAW } +}; + +int g_WindowStylesButtonCount = sizeof(g_WindowStylesButton)/sizeof(wxWindowStylePair) ; + + /* wxTreeCtrl */ +static wxWindowStylePair g_WindowStylesTreeCtrl[] = { + { "wxTR_HAS_BUTTONS", wxTR_HAS_BUTTONS }, + { "wxTR_EDIT_LABELS", wxTR_EDIT_LABELS }, + { "wxTR_LINES_AT_ROOT", wxTR_LINES_AT_ROOT } +}; + +int g_WindowStylesTreeCtrlCount = sizeof(g_WindowStylesTreeCtrl)/sizeof(wxWindowStylePair) ; + + /* wxListCtrl */ +static wxWindowStylePair g_WindowStylesListCtrl[] = { + { "wxLC_ICON", wxLC_ICON }, + { "wxLC_SMALL_ICON", wxLC_SMALL_ICON }, + { "wxLC_LIST", wxLC_LIST }, + { "wxLC_REPORT", wxLC_REPORT }, + { "wxLC_ALIGN_TOP", wxLC_ALIGN_TOP }, + { "wxLC_ALIGN_LEFT", wxLC_ALIGN_LEFT }, + { "wxLC_AUTOARRANGE", wxLC_AUTOARRANGE }, + { "wxLC_USER_TEXT", wxLC_USER_TEXT }, + { "wxLC_EDIT_LABELS", wxLC_EDIT_LABELS }, + { "wxLC_NO_HEADER", wxLC_NO_HEADER }, + { "wxLC_NO_SORT_HEADER", wxLC_NO_SORT_HEADER }, + { "wxLC_SINGLE_SEL", wxLC_SINGLE_SEL }, + { "wxLC_SORT_ASCENDING", wxLC_SORT_ASCENDING }, + { "wxLC_SORT_DESCENDING", wxLC_SORT_DESCENDING } +}; + +int g_WindowStylesListCtrlCount = sizeof(g_WindowStylesListCtrl)/sizeof(wxWindowStylePair) ; + + /* wxSpinButton */ +static wxWindowStylePair g_WindowStylesSpinButton[] = { + { "wxSP_VERTICAL", wxSP_VERTICAL}, + { "wxSP_HORIZONTAL", wxSP_HORIZONTAL}, + { "wxSP_ARROW_KEYS", wxSP_ARROW_KEYS}, + { "wxSP_WRAP", wxSP_WRAP} +}; + +int g_WindowStylesSpinButtonCount = sizeof(g_WindowStylesSpinButton)/sizeof(wxWindowStylePair) ; + + /* wxSplitterWindow */ +static wxWindowStylePair g_WindowStylesSplitterWindow[] = { + { "wxSP_NOBORDER", wxSP_NOBORDER}, + { "wxSP_3D", wxSP_3D}, + { "wxSP_BORDER", wxSP_BORDER} +}; + +int g_WindowStylesSplitterWindowCount = sizeof(g_WindowStylesSplitterWindow)/sizeof(wxWindowStylePair) ; + + /* wxTabCtrl */ +static wxWindowStylePair g_WindowStylesTabCtrl[] = { + { "wxTC_MULTILINE", wxTC_MULTILINE}, + { "wxTC_RIGHTJUSTIFY", wxTC_RIGHTJUSTIFY}, + { "wxTC_FIXEDWIDTH", wxTC_FIXEDWIDTH}, + { "wxTC_OWNERDRAW", wxTC_OWNERDRAW} +}; + +int g_WindowStylesTabCtrlCount = sizeof(g_WindowStylesTabCtrl)/sizeof(wxWindowStylePair) ; + + /* wxStatusBar95 */ +static wxWindowStylePair g_WindowStylesStatusBar[] = { + { "wxST_SIZEGRIP", wxST_SIZEGRIP} +}; + +int g_WindowStylesStatusBarCount = sizeof(g_WindowStylesStatusBar)/sizeof(wxWindowStylePair) ; + + /* wxControl */ +static wxWindowStylePair g_WindowStylesControl[] = { + { "wxFIXED_LENGTH", wxFIXED_LENGTH}, + { "wxALIGN_LEFT", wxALIGN_LEFT}, + { "wxALIGN_CENTRE", wxALIGN_CENTRE}, + { "wxALIGN_RIGHT", wxALIGN_RIGHT}, + { "wxCOLOURED", wxCOLOURED} +}; + +int g_WindowStylesControlCount = sizeof(g_WindowStylesControl)/sizeof(wxWindowStylePair) ; + + /* wxToolBar */ +static wxWindowStylePair g_WindowStylesToolBar[] = { + { "wxTB_3DBUTTONS", wxTB_3DBUTTONS}, + { "wxTB_HORIZONTAL", wxTB_HORIZONTAL}, + { "wxTB_VERTICAL", wxTB_VERTICAL}, + { "wxTB_FLAT", wxTB_FLAT} +}; + +int g_WindowStylesToolBarCount = sizeof(g_WindowStylesToolBar)/sizeof(wxWindowStylePair) ; + + /* Frame/dialog */ +static wxWindowStylePair g_WindowStylesDialog[] = { + { "wxSTAY_ON_TOP", wxSTAY_ON_TOP}, + { "wxCAPTION", wxCAPTION}, + { "wxICONIZE", wxICONIZE}, + { "wxMINIMIZE", wxICONIZE}, + { "wxMAXIMIZE", wxMAXIMIZE}, + { "wxTHICK_FRAME", wxTHICK_FRAME}, + { "wxRESIZE_BORDER", wxRESIZE_BORDER}, + { "wxSYSTEM_MENU", wxSYSTEM_MENU}, + { "wxMINIMIZE_BOX", wxMINIMIZE_BOX}, + { "wxMAXIMIZE_BOX", wxMAXIMIZE_BOX}, + { "wxRESIZE_BOX", wxRESIZE_BOX} +}; + +int g_WindowStylesDialogCount = sizeof(g_WindowStylesDialog)/sizeof(wxWindowStylePair) ; + + /* Generic */ +static wxWindowStylePair g_WindowStylesWindow[] = { + { "wxBORDER", wxBORDER}, + { "wxDOUBLE_BORDER", wxDOUBLE_BORDER}, + { "wxSUNKEN_BORDER", wxSUNKEN_BORDER}, + { "wxRAISED_BORDER", wxRAISED_BORDER}, + { "wxSIMPLE_BORDER", wxSIMPLE_BORDER}, + { "wxSTATIC_BORDER", wxSTATIC_BORDER}, + { "wxTRANSPARENT_WINDOW", wxTRANSPARENT_WINDOW}, + { "wxNO_BORDER", wxNO_BORDER}, + { "wxCLIP_CHILDREN", wxCLIP_CHILDREN}, + { "wxRETAINED", wxRETAINED}, + { "wxVSCROLL", wxVSCROLL }, + { "wxHSCROLL", wxHSCROLL } +}; + +int g_WindowStylesWindowCount = sizeof(g_WindowStylesWindow)/sizeof(wxWindowStylePair) ; + +/* + * A table holding all class style objects + */ + + +wxWindowStyleTable::wxWindowStyleTable(): + m_classes(wxKEY_STRING) +{ +} + +wxWindowStyleTable::~wxWindowStyleTable() +{ + ClearTable(); +} + +void wxWindowStyleTable::Init() +{ + AddStyles("wxWindow", g_WindowStylesWindowCount, g_WindowStylesWindow); + AddStyles("wxDialog", g_WindowStylesDialogCount, g_WindowStylesDialog); + AddStyles("wxButton", g_WindowStylesButtonCount, g_WindowStylesButton); + AddStyles("wxTextCtrl", g_WindowStylesTextCtrlCount, g_WindowStylesTextCtrl); + AddStyles("wxSpinButton", g_WindowStylesSpinButtonCount, g_WindowStylesSpinButton); + AddStyles("wxListBox", g_WindowStylesListBoxCount, g_WindowStylesListBox); + AddStyles("wxRadioButton", g_WindowStylesRadioButtonCount, g_WindowStylesRadioButton); + AddStyles("wxRadioBox", g_WindowStylesRadioBoxCount, g_WindowStylesRadioBox); + AddStyles("wxControl", g_WindowStylesControlCount, g_WindowStylesControl); + AddStyles("wxListCtrl", g_WindowStylesListCtrlCount, g_WindowStylesListCtrl); + AddStyles("wxTreeCtrl", g_WindowStylesTreeCtrlCount, g_WindowStylesTreeCtrl); + AddStyles("wxSlider", g_WindowStylesSliderCount, g_WindowStylesSlider); + AddStyles("wxGauge", g_WindowStylesGaugeCount, g_WindowStylesGauge); + AddStyles("wxComboBox", g_WindowStylesComboBoxCount, g_WindowStylesComboBox); +// AddStyles("wxChoice", g_WindowStylesChoice, g_WindowStylesChoice); + AddStyles("wxScrollBar", g_WindowStylesScrollBarCount, g_WindowStylesScrollBar); +} + +// Operations +void wxWindowStyleTable::ClearTable() +{ + wxNode* node = m_classes.First(); + while (node) + { + wxWindowStyleClass* styleClass = (wxWindowStyleClass*) node->Data(); + delete styleClass; + node = node->Next(); + } + m_classes.Clear(); +} + +void wxWindowStyleTable::AddStyles(const wxString& className, int n, wxWindowStylePair *styles) +{ + wxWindowStyleClass* styleClass = new wxWindowStyleClass(n, styles); + m_classes.Append(className, styleClass); +} + +wxWindowStyleClass* wxWindowStyleTable::FindClass(const wxString& className) +{ + wxNode* node = m_classes.Find(className); + if (node) + { + wxWindowStyleClass* styleClass = (wxWindowStyleClass*) node->Data(); + return styleClass; + } + else + return NULL; +} + +bool wxWindowStyleTable::GenerateStyleStrings(const wxString& className, long windowStyle, char *buf) +{ + wxWindowStyleClass* styleClass = FindClass(className); + if (!styleClass) + return FALSE; + + styleClass->GenerateStyleStrings(windowStyle, buf); + return TRUE; +} + +/* + * Holds all the styles for a particular class + */ + +wxWindowStyleClass::wxWindowStyleClass(int n, wxWindowStylePair *styles) +{ + m_styleCount = n; + m_styles = styles; +/* + m_styles = new wxWindowStylePair[n]; + int i; + for (i = 0; i < n; i++) + m_styles[i] = styles[i]; +*/ +} + +wxWindowStyleClass::~wxWindowStyleClass() +{ +} + +void wxWindowStyleClass::GenerateStyleStrings(long windowStyle, char *buf) +{ + int i; + for (i = 0; i < m_styleCount; i++) + GenerateStyle(buf, windowStyle, m_styles[i].m_styleId, m_styles[i].m_styleName); +} + +bool wxWindowStyleClass::GenerateStyle(char *buf, long windowStyle, long flag, const wxString& strStyle) +{ + // Ignore zero flags + if (flag == 0) + return TRUE; + + if ((windowStyle & flag) == flag) + { + if (strlen(buf) > 0) + strcat(buf, " | "); + strcat(buf, (const char*) strStyle); + return TRUE; + } + else + return FALSE; +} + diff --git a/utils/dialoged/src/winstyle.h b/utils/dialoged/src/winstyle.h new file mode 100644 index 0000000000..d7aaf063f4 --- /dev/null +++ b/utils/dialoged/src/winstyle.h @@ -0,0 +1,77 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: winstyle.h +// Purpose: Window styles +// Author: Julian Smart +// Modified by: +// Created: 04/01/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _DE_WINSTYLE_H_ +#define _DE_WINSTYLE_H_ + +#ifdef __GNUG__ +#pragma interface "winstyle.h" +#endif + +#include "wx/wx.h" + +/* + * A class for storing/generating window styles. + */ + +class wxWindowStyleClass; + +class wxWindowStylePair +{ + friend class wxWindowStyleClass; +public: + char* m_styleName; + long m_styleId; +}; + +class wxWindowStyleTable: public wxObject +{ +public: + wxWindowStyleTable(); + ~wxWindowStyleTable(); + +// Operations + void ClearTable(); + void AddStyles(const wxString& className, int n, wxWindowStylePair *styles); + wxWindowStyleClass* FindClass(const wxString& className) ; + bool GenerateStyleStrings(const wxString& className, long windowStyle, char *buf); + + // Initialise with all possible styles + void Init(); + +// Members +protected: + wxList m_classes; // A list of wxWindowStyleClass objects, indexed by class name + +}; + +/* + * Classes for storing all the window style identifiers associated with a particular class + */ + +class wxWindowStyleClass: public wxObject +{ +public: + wxWindowStyleClass(int n, wxWindowStylePair *styles); + ~wxWindowStyleClass(); + +// Operations + void GenerateStyleStrings(long windowStyle, char *buf); + bool GenerateStyle(char *buf, long windowStyle, long flag, const wxString& strStyle); + +// Members +protected: + wxWindowStylePair* m_styles; // An array of wxWindowStylePair objects + int m_styleCount; +}; + +#endif + // _DE_WINSTYLE_H_ -- 2.45.2