--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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"
+#include "wx/string.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
+
+ // Hold no key down
+#define wxACCEL_NORMAL 0x00
+
+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;
+};
+
+WXDLLEXPORT_DATA(extern wxAcceleratorTable) wxNullAcceleratorTable;
+
+#endif
+ // _WX_ACCEL_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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"
+#include "wx/gdicmn.h"
+#include "wx/event.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;
+
+// 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() ;
+
+ 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 bool Initialize();
+ static void CleanUp();
+
+ void DeletePendingObjects();
+ bool ProcessIdle();
+
+public:
+ static long sm_lastMessageTime;
+ int m_nCmdShow;
+
+protected:
+ bool m_keepGoing ;
+
+DECLARE_EVENT_TABLE()
+};
+
+// TODO: add platform-specific arguments
+int WXDLLEXPORT wxEntry( int argc, char *argv[] );
+
+#endif
+ // _WX_APP_H_
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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); }
+
+ // 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) : (wxPalette*) NULL); }
+ void SetPalette(const wxPalette& palette);
+
+ inline wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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(const wxBrushRefData& data);
+ ~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 wxBitmap& stipple);
+ inline wxBrush(const wxBrush& brush) { Ref(brush); }
+ ~wxBrush();
+
+ virtual void SetColour(const wxColour& col) ;
+ virtual void SetColour(unsigned char r, unsigned char g, unsigned char b) ;
+ virtual void SetStyle(int style) ;
+ virtual void SetStipple(const wxBitmap& stipple) ;
+
+ inline wxBrush& operator = (const wxBrush& brush) { if (*this == brush) return (*this); Ref(brush); return *this; }
+ inline bool operator == (const wxBrush& brush) { return m_refData == brush.m_refData; }
+ inline bool operator != (const wxBrush& brush) { return m_refData != brush.m_refData; }
+
+ inline wxColour& GetColour() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_colour : wxNullColour); };
+ inline int GetStyle() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_style : 0); };
+ inline wxBitmap *GetStipple() const { return (M_BRUSHDATA ? & M_BRUSHDATA->m_stipple : 0); };
+
+ virtual bool Ok() const { return (m_refData != NULL) ; }
+
+// Implementation
+
+ // Useful helper: create the brush resource
+ bool RealizeResource();
+
+ // When setting properties, we must make sure we're not changing
+ // another object
+ void Unshare();
+};
+
+#endif
+ // _WX_BRUSH_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// 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
+
+#include "wx/listbox.h"
+
+#ifndef __MWERKS__
+typedef unsigned int size_t;
+#endif
+
+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(size_t uiIndex) const;
+ void Check(size_t uiIndex, bool bCheck = TRUE);
+
+ DECLARE_EVENT_TABLE()
+};
+
+#endif
+ // _WX_CHECKLST_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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 */
+WXDLLEXPORT_DATA(extern wxClipboard*) wxTheClipboard;
+
+#endif
+ // _WX_CLIPBRD_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: colordlg.h
+// Purpose: wxColourDialog class. Use generic version if no
+// platform-specific implementation.
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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
+
+#include "wx/object.h"
+#include "wx/string.h"
+
+// Colour
+class WXDLLEXPORT wxColour: public wxObject
+{
+public:
+ // ctors
+ // default
+ wxColour();
+ // from RGB
+ wxColour( unsigned char red, unsigned char green, unsigned char blue );
+ // implicit conversion from the colour name
+ wxColour( const wxString &colourName ) { InitFromName(colourName); }
+ wxColour( const char *colourName ) { InitFromName(colourName); }
+
+ // copy ctors and assignment operators
+ wxColour( const wxColour& col );
+ wxColour( const wxColour* col );
+ wxColour& operator = ( const wxColour& col );
+
+ // dtor
+ ~wxColour();
+
+ // Set() functions
+ void Set( unsigned char red, unsigned char green, unsigned char blue );
+ 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));
+ }
+
+ // accessors
+ bool Ok() const {return m_isInit; }
+
+ // Let's remove this inelegant function
+#if WXWIN_COMPATIBILITY
+ void Get(unsigned char *r, unsigned char *g, unsigned char *b) const;
+#endif
+
+ unsigned char Red() const { return m_red; }
+ unsigned char Green() const { return m_green; }
+ unsigned char Blue() const { return m_blue; }
+
+ // comparison
+ bool operator == (const wxColour& colour)
+ {
+ return (m_red == colour.m_red &&
+ m_green == colour.m_green &&
+ m_blue == colour.m_blue);
+ }
+ bool operator != (const wxColour& colour) { return !(*this == colour); }
+
+ void InitFromName(const wxString& col);
+
+/* TODO
+ 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 ;
+ */
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxColour)
+};
+
+#endif
+ // _WX_COLOUR_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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
+ 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 wxString GetStringSelection() const ;
+ virtual bool SetStringSelection(const wxString& sel);
+ virtual inline int Number() const { return m_noStrings; }
+
+ // 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(long from, long to);
+ virtual void SetEditable(bool editable);
+};
+
+#endif
+ // _WX_COMBOBOX_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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)) {}; // 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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); }
+
+ 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();
+
+ // TODO: also verify the internal cursor handle
+ virtual bool Ok() const { return (m_refData != NULL) ; }
+
+ 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); }
+*/
+};
+
+extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);
+
+#endif
+ // _WX_CURSOR_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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"
+
+//-----------------------------------------------------------------------------
+// constants
+//-----------------------------------------------------------------------------
+
+#ifndef MM_TEXT
+#define MM_TEXT 0
+#define MM_ISOTROPIC 1
+#define MM_ANISOTROPIC 2
+#define MM_LOMETRIC 3
+#define MM_HIMETRIC 4
+#define MM_TWIPS 5
+#define MM_POINTS 6
+#define MM_METRIC 7
+#endif
+
+//-----------------------------------------------------------------------------
+// global variables
+//-----------------------------------------------------------------------------
+
+extern int wxPageNumber;
+
+//-----------------------------------------------------------------------------
+// wxDC
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxDC: public wxObject
+{
+ DECLARE_ABSTRACT_CLASS(wxDC)
+
+ public:
+
+ wxDC(void);
+ ~wxDC(void);
+
+ void BeginDrawing(void) {};
+ void EndDrawing(void) {};
+
+ virtual bool Ok(void) const { return m_ok; };
+
+ virtual void FloodFill( long x1, long y1, const wxColour& col, int style=wxFLOOD_SURFACE ) = 0;
+ inline void FloodFill(const wxPoint& pt, const wxColour& col, int style=wxFLOOD_SURFACE)
+ {
+ FloodFill(pt.x, pt.y, col, style);
+ }
+
+ virtual bool GetPixel( long x1, long y1, wxColour *col ) const = 0;
+ inline bool GetPixel(const wxPoint& pt, wxColour *col) const
+ {
+ return GetPixel(pt.x, pt.y, col);
+ }
+
+ virtual void DrawLine( long x1, long y1, long x2, long y2 ) = 0;
+ inline void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
+ {
+ DrawLine(pt1.x, pt1.y, pt2.x, pt2.y);
+ }
+
+ virtual void CrossHair( long x, long y ) = 0;
+ inline void CrossHair(const wxPoint& pt)
+ {
+ CrossHair(pt.x, pt.y);
+ }
+
+ virtual void DrawArc( long x1, long y1, long x2, long y2, long xc, long yc ) = 0;
+ inline void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
+ {
+ DrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y);
+ }
+
+ virtual void DrawEllipticArc( long x, long y, long width, long height, double sa, double ea ) = 0;
+ virtual void DrawEllipticArc (const wxPoint& pt, const wxSize& sz, double sa, double ea)
+ {
+ DrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea);
+ }
+
+ virtual void DrawPoint( long x, long y ) = 0;
+ virtual void DrawPoint( wxPoint& point );
+
+ virtual void DrawLines( int n, wxPoint points[], long xoffset = 0, long yoffset = 0 ) = 0;
+ virtual void DrawLines( wxList *points, long xoffset = 0, long yoffset = 0 );
+ virtual void DrawPolygon( int n, wxPoint points[], long xoffset = 0, long yoffset = 0,
+ int fillStyle=wxODDEVEN_RULE ) = 0;
+ virtual void DrawPolygon( wxList *lines, long xoffset = 0, long yoffset = 0,
+ int fillStyle=wxODDEVEN_RULE );
+
+ virtual void DrawRectangle( long x, long y, long width, long height ) = 0;
+ inline void DrawRectangle(const wxPoint& pt, const wxSize& sz)
+ {
+ DrawRectangle(pt.x, pt.y, sz.x, sz.y);
+ }
+ inline void DrawRectangle(const wxRect& rect)
+ {
+ DrawRectangle(rect.x, rect.y, rect.width, rect.height);
+ }
+ virtual void DrawRoundedRectangle( long x, long y, long width, long height, double radius = 20.0 ) = 0;
+ inline void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius = 20.0)
+ {
+ DrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius);
+ }
+ inline void DrawRoundedRectangle(const wxRect& rect, double radius = 20.0)
+ {
+ DrawRoundedRectangle(rect.x, rect.y, rect.width, rect.height, radius);
+ }
+
+ virtual void DrawEllipse( long x, long y, long width, long height ) = 0;
+ inline void DrawEllipse(const wxPoint& pt, const wxSize& sz)
+ {
+ DrawEllipse(pt.x, pt.y, sz.x, sz.y);
+ }
+ inline void DrawEllipse(const wxRect& rect)
+ {
+ DrawEllipse(rect.x, rect.y, rect.width, rect.height);
+ }
+
+ virtual void DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 );
+ virtual void DrawSpline( wxList *points ) = 0;
+ virtual void DrawSpline( int n, wxPoint points[] );
+
+ virtual bool CanDrawBitmap(void) const = 0;
+
+ virtual void DrawIcon( const wxIcon &icon, long x, long y, bool useMask=FALSE );
+ inline void DrawIcon(const wxIcon& icon, const wxPoint& pt)
+ {
+ DrawIcon(icon, pt.x, pt.y);
+ }
+
+ // TODO DrawBitmap is not always the same as DrawIcon, especially if bitmaps and
+ // icons are implemented differently.
+ void DrawBitmap( const wxBitmap &bmp, long x, long y, bool useMask=FALSE )
+ { DrawIcon( *((wxIcon*)(&bmp)), x, y, useMask ); }
+
+ virtual bool Blit( long xdest, long ydest, long width, long height,
+ wxDC *source, long xsrc, long ysrc, int logical_func = wxCOPY, bool useMask=FALSE ) = 0;
+ inline bool Blit(const wxPoint& destPt, const wxSize& sz,
+ wxDC *source, const wxPoint& srcPt, int rop = wxCOPY, bool useMask = FALSE)
+ {
+ return Blit(destPt.x, destPt.y, sz.x, sz.y, source, srcPt.x, srcPt.y, rop, useMask);
+ }
+
+ virtual void DrawText( const wxString &text, long x, long y, bool use16 = FALSE ) = 0;
+ inline void DrawText(const wxString& text, const wxPoint& pt, bool use16bit = FALSE)
+ {
+ DrawText(text, pt.x, pt.y, use16bit);
+ }
+
+ virtual bool CanGetTextExtent(void) const = 0;
+ virtual void GetTextExtent( const wxString &string, long *width, long *height,
+ long *descent = NULL, long *externalLeading = NULL,
+ wxFont *theFont = NULL, bool use16 = FALSE ) = 0;
+ virtual long GetCharWidth(void) = 0;
+ virtual long GetCharHeight(void) = 0;
+
+ virtual void Clear(void) = 0;
+
+ virtual void SetFont( const wxFont &font ) = 0;
+ virtual wxFont& GetFont(void) const { return (wxFont&) m_font; };
+
+ virtual void SetPen( const wxPen &pen ) = 0;
+ virtual wxPen& GetPen(void) const { return (wxPen&) m_pen; };
+
+ virtual void SetBrush( const wxBrush &brush ) = 0;
+ virtual wxBrush& GetBrush(void) const { return (wxBrush&) m_brush; };
+
+ virtual void SetBackground( const wxBrush &brush ) = 0;
+ virtual wxBrush& GetBackground(void) const { return (wxBrush&) m_backgroundBrush; };
+
+ virtual void SetLogicalFunction( int function ) = 0;
+ virtual int GetLogicalFunction(void) const { return m_logicalFunction; };
+
+ virtual void SetTextForeground( const wxColour &col );
+ virtual void SetTextBackground( const wxColour &col );
+ virtual wxColour& GetTextBackground(void) const { return (wxColour&)m_textBackgroundColour; };
+ virtual wxColour& GetTextForeground(void) const { return (wxColour&)m_textForegroundColour; };
+
+ virtual void SetBackgroundMode( int mode ) = 0;
+ virtual int GetBackgroundMode(void) const { return m_backgroundMode; };
+
+ virtual void SetPalette( const wxPalette& palette ) = 0;
+ void SetColourMap( const wxPalette& palette ) { SetPalette(palette); };
+
+ // the first two must be overridden and called
+ virtual void SetClippingRegion( long x, long y, long width, long height );
+ virtual void DestroyClippingRegion(void);
+ virtual void GetClippingBox( long *x, long *y, long *width, long *height ) const;
+
+ virtual inline long MinX(void) const { return m_minX; }
+ virtual inline long MaxX(void) const { return m_maxX; }
+ virtual inline long MinY(void) const { return m_minY; }
+ virtual inline long MaxY(void) const { return m_maxY; }
+
+ virtual void GetSize( int* width, int* height ) const;
+ inline wxSize GetSize(void) const { int w, h; GetSize(&w, &h); return wxSize(w, h); }
+ virtual void GetSizeMM( long* width, long* height ) const;
+
+ virtual bool StartDoc( const wxString& WXUNUSED(message) ) { return TRUE; };
+ virtual void EndDoc(void) {};
+ virtual void StartPage(void) {};
+ virtual void EndPage(void) {};
+
+ virtual void SetMapMode( int mode );
+ virtual int GetMapMode(void) const { return m_mappingMode; };
+
+ virtual void SetUserScale( double x, double y );
+ virtual void GetUserScale( double *x, double *y );
+ virtual void SetLogicalScale( double x, double y );
+ virtual void GetLogicalScale( double *x, double *y );
+
+ virtual void SetLogicalOrigin( long x, long y );
+ virtual void GetLogicalOrigin( long *x, long *y );
+ virtual void SetDeviceOrigin( long x, long y );
+ virtual void GetDeviceOrigin( long *x, long *y );
+ virtual void SetInternalDeviceOrigin( long x, long y );
+ virtual void GetInternalDeviceOrigin( long *x, long *y );
+
+ virtual void SetAxisOrientation( bool xLeftRight, bool yBottomUp );
+
+ virtual void SetOptimization( bool WXUNUSED(optimize) ) {};
+ virtual bool GetOptimization(void) { return m_optimize; };
+
+ virtual long DeviceToLogicalX(long x) const;
+ virtual long DeviceToLogicalY(long y) const;
+ virtual long DeviceToLogicalXRel(long x) const;
+ virtual long DeviceToLogicalYRel(long y) const;
+ virtual long LogicalToDeviceX(long x) const;
+ virtual long LogicalToDeviceY(long y) const;
+ virtual long LogicalToDeviceXRel(long x) const;
+ virtual long LogicalToDeviceYRel(long y) const;
+
+ public:
+
+ void CalcBoundingBox( long x, long y );
+ void ComputeScaleAndOrigin(void);
+
+ long XDEV2LOG(long x) const
+ {
+ long new_x = x - m_deviceOriginX;
+ if (new_x > 0)
+ return (long)((double)(new_x) / m_scaleX + 0.5) * m_signX + m_logicalOriginX;
+ else
+ return (long)((double)(new_x) / m_scaleX - 0.5) * m_signX + m_logicalOriginX;
+ }
+ long XDEV2LOGREL(long x) const
+ {
+ if (x > 0)
+ return (long)((double)(x) / m_scaleX + 0.5);
+ else
+ return (long)((double)(x) / m_scaleX - 0.5);
+ }
+ long YDEV2LOG(long y) const
+ {
+ long new_y = y - m_deviceOriginY;
+ if (new_y > 0)
+ return (long)((double)(new_y) / m_scaleY + 0.5) * m_signY + m_logicalOriginY;
+ else
+ return (long)((double)(new_y) / m_scaleY - 0.5) * m_signY + m_logicalOriginY;
+ }
+ long YDEV2LOGREL(long y) const
+ {
+ if (y > 0)
+ return (long)((double)(y) / m_scaleY + 0.5);
+ else
+ return (long)((double)(y) / m_scaleY - 0.5);
+ }
+ long XLOG2DEV(long x) const
+ {
+ long new_x = x - m_logicalOriginX;
+ if (new_x > 0)
+ return (long)((double)(new_x) * m_scaleX + 0.5) * m_signX + m_deviceOriginX;
+ else
+ return (long)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
+ }
+ long XLOG2DEVREL(long x) const
+ {
+ if (x > 0)
+ return (long)((double)(x) * m_scaleX + 0.5);
+ else
+ return (long)((double)(x) * m_scaleX - 0.5);
+ }
+ long YLOG2DEV(long y) const
+ {
+ long new_y = y - m_logicalOriginY;
+ if (new_y > 0)
+ return (long)((double)(new_y) * m_scaleY + 0.5) * m_signY + m_deviceOriginY;
+ else
+ return (long)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
+ }
+ long YLOG2DEVREL(long y) const
+ {
+ if (y > 0)
+ return (long)((double)(y) * m_scaleY + 0.5);
+ else
+ return (long)((double)(y) * m_scaleY - 0.5);
+ }
+
+ public:
+
+ bool m_ok;
+ bool m_colour;
+
+ // not sure, what these mean
+ bool m_clipping; // Is clipping on right now ?
+ bool m_isInteractive; // Is GetPixel possible ?
+ bool m_autoSetting; // wxMSW only ?
+ bool m_dontDelete; // wxMSW only ?
+ bool m_optimize; // wxMSW only ?
+ wxString m_filename; // Not sure where this belongs.
+
+ wxPen m_pen;
+ wxBrush m_brush;
+ wxBrush m_backgroundBrush;
+ wxColour m_textForegroundColour;
+ wxColour m_textBackgroundColour;
+ wxFont m_font;
+
+ int m_logicalFunction;
+ int m_backgroundMode;
+ int m_textAlignment; // gone in wxWin 2.0 ?
+
+ int m_mappingMode;
+
+ // not sure what for, but what is a mm on a screen you don't know the size of?
+ double m_mm_to_pix_x,m_mm_to_pix_y;
+
+ long m_internalDeviceOriginX,m_internalDeviceOriginY; // If un-scrolled is non-zero or
+ // d.o. changes with scrolling.
+ // Set using SetInternalDeviceOrigin().
+
+ long m_externalDeviceOriginX,m_externalDeviceOriginY; // To be set by external classes
+ // such as wxScrolledWindow
+ // using SetDeviceOrigin()
+
+ long m_deviceOriginX,m_deviceOriginY; // Sum of the two above.
+
+ long m_logicalOriginX,m_logicalOriginY; // User defined.
+
+ double m_scaleX,m_scaleY;
+ double m_logicalScaleX,m_logicalScaleY;
+ double m_userScaleX,m_userScaleY;
+ long m_signX,m_signY;
+
+ bool m_needComputeScaleX,m_needComputeScaleY; // not yet used
+
+ float m_scaleFactor; // wxPSDC wants to have this. Will disappear.
+
+ long m_clipX1,m_clipY1,m_clipX2,m_clipY2;
+ long m_minX,m_maxX,m_minY,m_maxY;
+};
+
+#endif
+ // _WX_DC_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: dcclient.h
+// Purpose: wxClientDC, wxPaintDC and wxWindowDC classes
+// 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"
+
+//-----------------------------------------------------------------------------
+// classes
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPaintDC;
+class WXDLLEXPORT wxWindow;
+
+// Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented differently.
+// On many platforms, however, they will be the same.
+
+class WXDLLEXPORT wxWindowDC: public wxDC
+{
+ DECLARE_DYNAMIC_CLASS(wxWindowDC)
+
+ public:
+
+ wxWindowDC(void);
+ wxWindowDC( wxWindow *win );
+
+ ~wxWindowDC(void);
+
+ virtual void FloodFill( long x1, long y1, const wxColour& col, int style=wxFLOOD_SURFACE );
+ virtual bool GetPixel( long x1, long y1, wxColour *col ) const;
+
+ virtual void DrawLine( long x1, long y1, long x2, long y2 );
+ virtual void CrossHair( long x, long y );
+ virtual void DrawArc( long x1, long y1, long x2, long y2, long xc, long yc );
+ virtual void DrawEllipticArc( long x, long y, long width, long height, double sa, double ea );
+ virtual void DrawPoint( long x, long y );
+
+ virtual void DrawLines( int n, wxPoint points[], long xoffset = 0, long yoffset = 0 );
+ virtual void DrawLines( wxList *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 DrawPolygon( wxList *lines, long xoffset = 0, long yoffset = 0,
+ int fillStyle=wxODDEVEN_RULE );
+
+ virtual void DrawRectangle( long x, long y, long width, long height );
+ virtual void DrawRoundedRectangle( long x, long y, long width, long height, double radius = 20.0 );
+ virtual void DrawEllipse( long x, long y, long width, long height );
+
+ virtual bool CanDrawBitmap(void) const;
+ virtual void DrawIcon( const wxIcon &icon, long x, long y, bool useMask=FALSE );
+ virtual bool Blit( long xdest, long ydest, long width, long height,
+ wxDC *source, long xsrc, long ysrc, int logical_func = wxCOPY, bool useMask=FALSE );
+
+ virtual void DrawText( const wxString &text, long x, long y, bool use16 = FALSE );
+ virtual bool CanGetTextExtent(void) const;
+ virtual void GetTextExtent( const wxString &string, long *width, long *height,
+ long *descent = NULL, long *externalLeading = NULL,
+ wxFont *theFont = NULL, bool use16 = FALSE );
+ virtual long GetCharWidth(void);
+ virtual long GetCharHeight(void);
+
+ virtual void Clear(void);
+
+ virtual void SetFont( const wxFont &font );
+ virtual void SetPen( const wxPen &pen );
+ virtual void SetBrush( const wxBrush &brush );
+ virtual void SetBackground( const wxBrush &brush );
+ virtual void SetLogicalFunction( int function );
+ virtual void SetTextForeground( const wxColour &col );
+ virtual void SetTextBackground( const wxColour &col );
+ virtual void SetBackgroundMode( int mode );
+ virtual void SetPalette( const wxPalette& palette );
+
+ virtual void SetClippingRegion( long x, long y, long width, long height );
+ virtual void SetClippingRegion( const wxRegion& region ) ;
+ virtual void DestroyClippingRegion(void);
+
+ virtual void DrawSpline( wxList *points );
+};
+
+//-----------------------------------------------------------------------------
+// wxPaintDC
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxPaintDC: public wxWindowDC
+{
+ DECLARE_DYNAMIC_CLASS(wxPaintDC)
+
+ public:
+
+ wxPaintDC(void):wxWindowDC() {};
+ wxPaintDC( wxWindow *win ): wxWindowDC(win) {};
+
+};
+
+//-----------------------------------------------------------------------------
+// wxClientDC
+//-----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxClientDC: public wxWindowDC
+{
+ DECLARE_DYNAMIC_CLASS(wxClientDC)
+
+ public:
+
+ wxClientDC(void):wxWindowDC() {};
+ wxClientDC( wxWindow *win ): wxWindowDC(win) {};
+
+};
+
+#endif
+ // _WX_DCCLIENT_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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 wxPaintDC
+{
+ DECLARE_DYNAMIC_CLASS(wxMemoryDC)
+
+ public:
+ wxMemoryDC(void);
+ wxMemoryDC( wxDC *dc ); // Create compatible DC
+ ~wxMemoryDC(void);
+ virtual void SelectObject( const wxBitmap& bitmap );
+ void GetSize( int *width, int *height ) const;
+
+ private:
+ friend wxPaintDC;
+ wxBitmap m_selected;
+};
+
+#endif
+ // _WX_DCMEMORY_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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/dcclient.h"
+
+class WXDLLEXPORT wxScreenDC: public wxWindowDC
+{
+ 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(wxRect* WXUNUSED(rect) = NULL) { return TRUE; }
+ static bool EndDrawingOnTop() { return TRUE; }
+};
+
+#endif
+ // _WX_DCSCREEN_H_
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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 SetClientSize(int width, int height);
+ void GetPosition(int *x, int *y) const;
+ bool Show(bool show);
+ void Iconize(bool iconize);
+
+ virtual bool IsIconized() const;
+ void Fit();
+
+ void SetTitle(const wxString& title);
+ wxString GetTitle() const ;
+
+ bool OnClose();
+ void OnCharHook(wxKeyEvent& event);
+ void OnCloseWindow(wxCloseEvent& event);
+
+ void SetModal(bool flag);
+
+ virtual void Centre(int direction = wxBOTH);
+ virtual bool IsModal() const { return ((GetWindowStyleFlag() & wxDIALOG_MODAL) == wxDIALOG_MODAL); }
+
+ virtual int ShowModal();
+ virtual void EndModal(int retCode);
+
+ // Standard buttons
+ void OnOK(wxCommandEvent& event);
+ void OnApply(wxCommandEvent& event);
+ void OnCancel(wxCommandEvent& event);
+
+ // Responds to colour changes
+ void OnSysColourChanged(wxSysColourChangedEvent& event);
+
+DECLARE_EVENT_TABLE()
+};
+
+#endif
+ // _WX_DIALOG_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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"
+
+WXDLLEXPORT_DATA(extern const char*) wxFileSelectorPromptStr;
+
+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_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: dnd.h
+// Purpose: Declaration of the wxDropTarget, wxDropSource class etc.
+// Author: AUTHOR
+// RCS-ID: $Id$
+// Copyright: (c) 1998 AUTHOR
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DND_H_
+#define _WX_DND_H_
+
+#ifdef __GNUG__
+#pragma interface "dnd.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/object.h"
+#include "wx/string.h"
+#include "wx/cursor.h"
+
+//-------------------------------------------------------------------------
+// classes
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxWindow;
+
+class WXDLLEXPORT wxDataObject;
+class WXDLLEXPORT wxTextDataObject;
+class WXDLLEXPORT wxFileDataObject;
+
+class WXDLLEXPORT wxDropTarget;
+class WXDLLEXPORT wxTextDropTarget;
+class WXDLLEXPORT wxFileDropTarget;
+
+class WXDLLEXPORT wxDropSource;
+
+//-------------------------------------------------------------------------
+// wxDataObject
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxDataObject: public wxObject
+{
+public:
+ // all data formats (values are the same as in windows.h, do not change!)
+ enum StdFormat
+ {
+ Invalid,
+ Text,
+ Bitmap,
+ MetafilePict,
+ Sylk,
+ Dif,
+ Tiff,
+ OemText,
+ Dib,
+ Palette,
+ Pendata,
+ Riff,
+ Wave,
+ UnicodeText,
+ EnhMetafile,
+ Hdrop,
+ Locale,
+ Max
+ };
+
+ // function to return symbolic name of clipboard format (debug messages)
+ static const char *GetFormatName(wxDataFormat format);
+
+ // ctor & dtor
+ wxDataObject() {};
+ ~wxDataObject() {};
+
+ // pure virtuals to override
+ // get the best suited format for our data
+ virtual wxDataFormat GetPreferredFormat() const = 0;
+ // decide if we support this format (should be one of values of
+ // StdFormat enumerations or a user-defined format)
+ virtual bool IsSupportedFormat(wxDataFormat format) const = 0;
+ // get the (total) size of data
+ virtual size_t GetDataSize() const = 0;
+ // copy raw data to provided pointer
+ virtual void GetDataHere(void *pBuf) const = 0;
+
+};
+
+// ----------------------------------------------------------------------------
+// wxTextDataObject is a specialization of wxDataObject for text data
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxTextDataObject : public wxDataObject
+{
+public:
+ // ctors
+ wxTextDataObject() { }
+ wxTextDataObject(const wxString& strText) : m_strText(strText) { }
+ void Init(const wxString& strText) { m_strText = strText; }
+
+ // implement base class pure virtuals
+ virtual wxDataFormat GetPreferredFormat() const
+ { return wxDF_TEXT; }
+ virtual bool IsSupportedFormat(wxDataFormat format) const
+ { return format == wxDF_TEXT; }
+ virtual size_t GetDataSize() const
+ { return m_strText.Len() + 1; } // +1 for trailing '\0'of course
+ virtual void GetDataHere(void *pBuf) const
+ { memcpy(pBuf, m_strText.c_str(), GetDataSize()); }
+
+private:
+ wxString m_strText;
+
+};
+
+// ----------------------------------------------------------------------------
+// wxFileDataObject is a specialization of wxDataObject for file names
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxFileDataObject : public wxDataObject
+{
+public:
+
+ wxFileDataObject(void) { }
+ void AddFile( const wxString &file )
+ { m_files += file; m_files += ";"; }
+
+ // implement base class pure virtuals
+ virtual wxDataFormat GetPreferredFormat() const
+ { return wxDF_FILENAME; }
+ virtual bool IsSupportedFormat(wxDataFormat format) const
+ { return format == wxDF_FILENAME; }
+ virtual size_t GetDataSize() const
+ { return m_files.Len() + 1; } // +1 for trailing '\0'of course
+ virtual void GetDataHere(void *pBuf) const
+ { memcpy(pBuf, m_files.c_str(), GetDataSize()); }
+
+private:
+ wxString m_files;
+
+};
+//-------------------------------------------------------------------------
+// wxDropTarget
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxDropTarget: public wxObject
+{
+ public:
+
+ wxDropTarget();
+ ~wxDropTarget();
+
+ virtual void OnEnter() { }
+ virtual void OnLeave() { }
+ virtual bool OnDrop( long x, long y, const void *pData ) = 0;
+
+// protected:
+
+ friend wxWindow;
+
+ // Override these to indicate what kind of data you support:
+
+ virtual size_t GetFormatCount() const = 0;
+ virtual wxDataFormat GetFormat(size_t n) const = 0;
+};
+
+//-------------------------------------------------------------------------
+// wxTextDropTarget
+//-------------------------------------------------------------------------
+
+class WXDLLEXPORT wxTextDropTarget: public wxDropTarget
+{
+ public:
+
+ wxTextDropTarget() {};
+ virtual bool OnDrop( long x, long y, const void *pData );
+ virtual bool OnDropText( long x, long y, const char *psz );
+
+ protected:
+
+ virtual size_t GetFormatCount() const;
+ virtual wxDataFormat GetFormat(size_t n) const;
+};
+
+// ----------------------------------------------------------------------------
+// A drop target which accepts files (dragged from File Manager or Explorer)
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxFileDropTarget: public wxDropTarget
+{
+ public:
+
+ wxFileDropTarget() {};
+
+ virtual bool OnDrop(long x, long y, const void *pData);
+ virtual bool OnDropFiles( long x, long y,
+ size_t nFiles, const char * const aszFiles[]);
+
+ protected:
+
+ virtual size_t GetFormatCount() const;
+ virtual wxDataFormat GetFormat(size_t n) const;
+};
+
+//-------------------------------------------------------------------------
+// wxDropSource
+//-------------------------------------------------------------------------
+
+enum wxDragResult
+ {
+ wxDragError, // error prevented the d&d operation from completing
+ wxDragNone, // drag target didn't accept the data
+ wxDragCopy, // the data was successfully copied
+ wxDragMove, // the data was successfully moved
+ wxDragCancel // the operation was cancelled by user (not an error)
+ };
+
+class WXDLLEXPORT wxDropSource: public wxObject
+{
+ public:
+
+ wxDropSource( wxWindow *win );
+ wxDropSource( wxDataObject &data, wxWindow *win );
+
+ ~wxDropSource(void);
+
+ void SetData( wxDataObject &data );
+ wxDragResult DoDragDrop( bool bAllowMove = FALSE );
+
+ virtual bool GiveFeedback( wxDragResult WXUNUSED(effect), bool WXUNUSED(bScrolling) ) { return TRUE; };
+
+ protected:
+
+ wxDataObject *m_data;
+};
+
+#endif
+ //_WX_DND_H_
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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(const wxFontRefData& data);
+ ~wxFontRefData();
+protected:
+ int m_pointSize;
+ int m_family;
+ int m_style;
+ int m_weight;
+ bool m_underlined;
+ wxString m_faceName;
+/* TODO: implementation
+ WXHFONT m_hFont;
+*/
+};
+
+#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& faceName = wxEmptyString);
+ inline wxFont(const wxFont& font) { Ref(font); }
+
+ ~wxFont();
+
+ bool Create(int pointSize, int family, int style, int weight, bool underlined = FALSE, const wxString& faceName = wxEmptyString);
+
+ virtual bool Ok() const { return (m_refData != NULL) ; }
+
+ inline int GetPointSize() const { return M_FONTDATA->m_pointSize; }
+ inline int GetFamily() const { return M_FONTDATA->m_family; }
+ inline int GetStyle() const { return M_FONTDATA->m_style; }
+ inline int GetWeight() const { return M_FONTDATA->m_weight; }
+ wxString GetFamilyString() const ;
+ wxString GetFaceName() const ;
+ wxString GetStyleString() const ;
+ wxString GetWeightString() const ;
+ inline bool GetUnderlined() const { return M_FONTDATA->m_underlined; }
+
+ void SetPointSize(int pointSize);
+ void SetFamily(int family);
+ void SetStyle(int style);
+ void SetWeight(int weight);
+ void SetFaceName(const wxString& faceName);
+ void SetUnderlined(bool underlined);
+
+ inline wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; }
+ inline bool operator == (const wxFont& font) { return m_refData == font.m_refData; }
+ inline bool operator != (const wxFont& font) { return m_refData != font.m_refData; }
+
+ // Implementation
+protected:
+ bool RealizeResource();
+ void Unshare();
+};
+
+#endif
+ // _WX_FONT_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: fontdlg.h
+// Purpose: wxFontDialog class. Use generic version if no
+// platform-specific implementation.
+// 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_
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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);
+ void ClientToScreen(int *x, int *y) const;
+ void ScreenToClient(int *x, int *y) const;
+
+ 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(); }
+
+ // Is the frame maximized?
+ virtual bool IsMaximized(void) const ;
+
+ virtual void Maximize(bool maximize);
+
+ // 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 ;
+
+ DECLARE_EVENT_TABLE()
+};
+
+#endif
+ // _WX_FRAME_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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); }
+
+ 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: imaglist.h
+// Purpose: wxImageList class. Note: if your GUI doesn't have
+// an image list equivalent, you can use the generic class
+// in src/generic.
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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
+ ////////////////////////////////////////////////////////////////////////////
+
+ // 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, wxRect& 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_
--- /dev/null
+/*********************************************************************
+Project : GUSI - Grand Unified Socket Interface
+File : GUSI.h - Socket calls
+Author : Matthias Neeracher
+Language : MPW C/C++
+*********************************************************************/
+
+#ifndef _GUSI_
+#define _GUSI_
+
+#ifdef __MWERKS__
+ #ifndef macintosh
+ #define macintosh 1
+ #endif
+#endif
+
+#ifdef macintosh
+#include <errno.h>
+#else
+#ifndef KERNEL
+extern int errno; /* global error number */
+#endif
+#endif
+
+#define __P(protos) protos /* full-blown ANSI C */
+
+#define EPERM 1 /* Operation not permitted */
+/* MSL defines ENOMEM, EACCES, ENOENT, ENOSYS. We give in. */
+#ifndef ENOENT
+#define ENOENT 2 /* No such file or directory */
+#endif
+#define ESRCH 3 /* No such process */
+#define EINTR 4 /* Interrupted system call */
+#define EIO 5 /* Input/output error */
+#define ENXIO 6 /* Device not configured */
+#define E2BIG 7 /* Argument list too long */
+#define ENOEXEC 8 /* Exec format error */
+#define EBADF 9 /* Bad file descriptor */
+#define ECHILD 10 /* No child processes */
+#define EDEADLK 11 /* Resource deadlock avoided */
+ /* 11 was EAGAIN */
+#ifndef ENOMEM
+#define ENOMEM 12 /* Cannot allocate memory */
+#define EACCES 13 /* Permission denied */
+#endif
+#define EFAULT 14 /* Bad address */
+#ifndef _POSIX_SOURCE
+#define ENOTBLK 15 /* Block device required */
+#define EBUSY 16 /* Device busy */
+#endif
+#define EEXIST 17 /* File exists */
+#define EXDEV 18 /* Cross-device link */
+#define ENODEV 19 /* Operation not supported by device */
+#define ENOTDIR 20 /* Not a directory */
+#define EISDIR 21 /* Is a directory */
+#define EINVAL 22 /* Invalid argument */
+#define ENFILE 23 /* Too many open files in system */
+#define EMFILE 24 /* Too many open files */
+#define ENOTTY 25 /* Inappropriate ioctl for device */
+#ifndef _POSIX_SOURCE
+#define ETXTBSY 26 /* Text file busy */
+#endif
+#define EFBIG 27 /* File too large */
+#define ENOSPC 28 /* No space left on device */
+#define ESPIPE 29 /* Illegal seek */
+#define EROFS 30 /* Read-only file system */
+#define EMLINK 31 /* Too many links */
+#define EPIPE 32 /* Broken pipe */
+
+#ifndef __MWERKS__
+/* math software */
+#define EDOM 33 /* Numerical argument out of domain */
+#define ERANGE 34 /* Result too large */
+#endif
+
+/* non-blocking and interrupt i/o */
+#if defined(macintosh)
+#ifndef EAGAIN
+#define EAGAIN 11
+#endif
+#else
+#define EAGAIN 35 /* Resource temporarily unavailable */
+#endif
+#define EWOULDBLOCK EAGAIN /* Operation would block */
+#ifndef _POSIX_SOURCE
+/* Did I tell that MSL also occupies errnos 33-40? We give in. */
+#if ENOMEM==37
+#define EINPROGRESS 136 /* Operation now in progress */
+#define EALREADY 137 /* Operation already in progress */
+
+/* ipc/network software -- argument errors */
+#define ENOTSOCK 138 /* Socket operation on non-socket */
+#define EDESTADDRREQ 139 /* Destination address required */
+#define EMSGSIZE 140 /* Message too long */
+#else
+#define EINPROGRESS 36 /* Operation now in progress */
+#define EALREADY 37 /* Operation already in progress */
+
+/* ipc/network software -- argument errors */
+#define ENOTSOCK 38 /* Socket operation on non-socket */
+#define EDESTADDRREQ 39 /* Destination address required */
+#define EMSGSIZE 40 /* Message too long */
+#endif
+#define EPROTOTYPE 41 /* Protocol wrong type for socket */
+#define ENOPROTOOPT 42 /* Protocol not available */
+#define EPROTONOSUPPORT 43 /* Protocol not supported */
+#define ESOCKTNOSUPPORT 44 /* Socket type not supported */
+#define EOPNOTSUPP 45 /* Operation not supported on socket */
+#define EPFNOSUPPORT 46 /* Protocol family not supported */
+#define EAFNOSUPPORT 47 /* Address family not supported by protocol family */
+#define EADDRINUSE 48 /* Address already in use */
+#define EADDRNOTAVAIL 49 /* Can't assign requested address */
+
+/* ipc/network software -- operational errors */
+#define ENETDOWN 50 /* Network is down */
+#define ENETUNREACH 51 /* Network is unreachable */
+#define ENETRESET 52 /* Network dropped connection on reset */
+#define ECONNABORTED 53 /* Software caused connection abort */
+#define ECONNRESET 54 /* Connection reset by peer */
+#define ENOBUFS 55 /* No buffer space available */
+#define EISCONN 56 /* Socket is already connected */
+#define ENOTCONN 57 /* Socket is not connected */
+#define ESHUTDOWN 58 /* Can't send after socket shutdown */
+#define ETOOMANYREFS 59 /* Too many references: can't splice */
+#define ETIMEDOUT 60 /* Connection timed out */
+#define ECONNREFUSED 61 /* Connection refused */
+
+#define ELOOP 62 /* Too many levels of symbolic links */
+#endif /* _POSIX_SOURCE */
+#define ENAMETOOLONG 63 /* File name too long */
+
+/* should be rearranged */
+#ifndef _POSIX_SOURCE
+#define EHOSTDOWN 64 /* Host is down */
+#define EHOSTUNREACH 65 /* No route to host */
+#endif /* _POSIX_SOURCE */
+#define ENOTEMPTY 66 /* Directory not empty */
+
+/* quotas & mush */
+#ifndef _POSIX_SOURCE
+#define EPROCLIM 67 /* Too many processes */
+#define EUSERS 68 /* Too many users */
+#define EDQUOT 69 /* Disc quota exceeded */
+
+/* Network File System */
+#define ESTALE 70 /* Stale NFS file handle */
+#define EREMOTE 71 /* Too many levels of remote in path */
+#define EBADRPC 72 /* RPC struct is bad */
+#define ERPCMISMATCH 73 /* RPC version wrong */
+#define EPROGUNAVAIL 74 /* RPC prog. not avail */
+#define EPROGMISMATCH 75 /* Program version wrong */
+#define EPROCUNAVAIL 76 /* Bad procedure for program */
+#endif /* _POSIX_SOURCE */
+
+#define ENOLCK 77 /* No locks available */
+
+#ifndef ENOSYS
+#define ENOSYS 78 /* Function not implemented */
+#endif
+
+#define EFTYPE 79 /* Inappropriate file type or format */
+
+#ifdef KERNEL
+/* pseudo-errors returned inside kernel to modify return to process */
+#define ERESTART -1 /* restart syscall */
+#define EJUSTRETURN -2 /* don't modify regs, just return */
+#endif
+
+#define NBBY 8 /* number of bits in a byte */
+
+/*
+ * Select uses bit masks of file descriptors in longs. These macros
+ * manipulate such bit fields (the filesystem macros use chars).
+ * FD_SETSIZE may be defined by the user, but the default here should
+ * be enough for most uses.
+ */
+#ifndef FD_SETSIZE
+#ifdef macintosh
+#define FD_SETSIZE 64
+#else
+#define FD_SETSIZE 256
+#endif
+#endif
+
+typedef long fd_mask;
+#define NFDBITS (sizeof(fd_mask) * NBBY) /* bits per mask */
+
+#ifndef howmany
+#define howmany(x, y) (((x)+((y)-1))/(y))
+#endif
+
+typedef struct fd_set {
+ fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+} fd_set;
+
+#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
+#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
+#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
+#define FD_ZERO(p) bzero((char *)(p), sizeof(*(p)))
+
+// #include <sys/types.h>
+typedef unsigned char u_char;
+typedef unsigned short u_short;
+typedef unsigned int u_int;
+typedef unsigned long u_long;
+typedef unsigned short ushort; /* Sys V compatibility */
+
+typedef char * caddr_t; /* core address */
+typedef long daddr_t; /* disk address */
+typedef short dev_t; /* device number */
+typedef u_long ino_t; /* inode number */
+typedef long off_t; /* file offset (should be a quad) */
+typedef u_short nlink_t; /* link count */
+typedef long swblk_t; /* swap offset */
+typedef long segsz_t; /* segment size */
+typedef u_short uid_t; /* user id */
+typedef u_short gid_t; /* group id */
+typedef short pid_t; /* process id */
+typedef u_short mode_t; /* permissions */
+typedef u_long fixpt_t; /* fixed point number */
+
+
+// Feel free to increase FD_SETSIZE as needed
+#define GUSI_MAX_FD FD_SETSIZE
+
+//#include <sys/cdefs.h>
+
+#ifndef macintosh
+#ifdef __MWERKS__
+#define macintosh 1
+#endif
+#endif
+
+#if defined(__cplusplus)
+#define __BEGIN_DECLS extern "C" {
+#define __END_DECLS }
+#else
+#define __BEGIN_DECLS
+#define __END_DECLS
+#endif
+
+//#include <compat.h>
+//#include <sys/ioctl.h>
+#define IOCPARM_MASK 0x1fff /* parameter length, at most 13 bits */
+#define IOCPARM_LEN(x) (((x) >> 16) & IOCPARM_MASK)
+#define IOCBASECMD(x) ((x) & ~IOCPARM_MASK)
+#define IOCGROUP(x) (((x) >> 8) & 0xff)
+
+#define IOCPARM_MAX NBPG /* max size of ioctl, mult. of NBPG */
+#define IOC_VOID 0x20000000 /* no parameters */
+#define IOC_OUT 0x40000000 /* copy out parameters */
+#define IOC_IN 0x80000000 /* copy in parameters */
+#define IOC_INOUT (IOC_IN|IOC_OUT)
+#define IOC_DIRMASK 0xe0000000 /* mask for IN/OUT/VOID */
+
+#define _IOC(inout,group,num,len) \
+ (inout | ((len & IOCPARM_MASK) << 16) | ((group) << 8) | (num))
+#define _IO(g,n) _IOC(IOC_VOID, (g), (n), 0)
+#define _IOR(g,n,t) _IOC(IOC_OUT, (g), (n), sizeof(t))
+#define _IOW(g,n,t) _IOC(IOC_IN, (g), (n), sizeof(t))
+/* this should be _IORW, but stdio got there first */
+#define _IOWR(g,n,t) _IOC(IOC_INOUT, (g), (n), sizeof(t))
+
+#define FIOCLEX _IO('f', 1) /* set close on exec on fd */
+#define FIONCLEX _IO('f', 2) /* remove close on exec */
+#define FIONREAD _IOR('f', 127, int) /* get # bytes to read */
+#define FIONBIO _IOW('f', 126, int) /* set/clear non-blocking i/o */
+#define FIOASYNC _IOW('f', 125, int) /* set/clear async i/o */
+#define FIOSETOWN _IOW('f', 124, int) /* set owner */
+#define FIOGETOWN _IOR('f', 123, int) /* get owner */
+
+__BEGIN_DECLS
+#ifdef macintosh
+int ioctl(int fildes, unsigned int cmd, unsigned long *arg);
+#else
+int ioctl __P((int, unsigned long, ...));
+#endif
+__END_DECLS
+
+//#include <sys/fcntl.h>
+//#include <sys/stat.h>
+//#include <dirent.h>
+//#include <Types.h>
+//#include <Events.h>
+//#include <Files.h>
+//#include <AppleTalk.h>
+//#include <CTBUtilities.h>
+//#include <Packages.h>
+//#include <PPCToolBox.h>
+//#include <StandardFile.h>
+//#include <stdio.h>
+//#include <sys/time.h>
+
+
+/*
+ * Definitions for byte order, according to byte significance from low
+ * address to high.
+ */
+#define LITTLE_ENDIAN 1234 /* LSB first: i386, vax */
+#define BIG_ENDIAN 4321 /* MSB first: 68000, ibm, net */
+#define PDP_ENDIAN 3412 /* LSB first in word, MSW first in long */
+
+#define BYTE_ORDER BIG_ENDIAN
+
+__BEGIN_DECLS
+unsigned long htonl (unsigned long);
+unsigned short htons (unsigned short);
+unsigned long ntohl (unsigned long);
+unsigned short ntohs (unsigned short);
+__END_DECLS
+
+/*
+ * Macros for network/external number representation conversion.
+ */
+#if BYTE_ORDER == BIG_ENDIAN && !defined(lint)
+#define ntohl(x) (x)
+#define ntohs(x) (x)
+#define htonl(x) (x)
+#define htons(x) (x)
+
+#define NTOHL(x) (x)
+#define NTOHS(x) (x)
+#define HTONL(x) (x)
+#define HTONS(x) (x)
+
+#else
+
+#define NTOHL(x) (x) = ntohl((u_long)x)
+#define NTOHS(x) (x) = ntohs((u_short)x)
+#define HTONL(x) (x) = htonl((u_long)x)
+#define HTONS(x) (x) = htons((u_short)x)
+#endif
+
+
+
+/*
+ * Constants and structures defined by the internet system,
+ * Per RFC 790, September 1981.
+ */
+
+/*
+ * Protocols
+ */
+#define IPPROTO_IP 0 /* dummy for IP */
+#define IPPROTO_ICMP 1 /* control message protocol */
+#define IPPROTO_GGP 3 /* gateway^2 (deprecated) */
+#define IPPROTO_TCP 6 /* tcp */
+#define IPPROTO_EGP 8 /* exterior gateway protocol */
+#define IPPROTO_PUP 12 /* pup */
+#define IPPROTO_UDP 17 /* user datagram protocol */
+#define IPPROTO_IDP 22 /* xns idp */
+#define IPPROTO_TP 29 /* tp-4 w/ class negotiation */
+#define IPPROTO_EON 80 /* ISO cnlp */
+
+#define IPPROTO_RAW 255 /* raw IP packet */
+#define IPPROTO_MAX 256
+
+
+/*
+ * Local port number conventions:
+ * Ports < IPPORT_RESERVED are reserved for
+ * privileged processes (e.g. root).
+ * Ports > IPPORT_USERRESERVED are reserved
+ * for servers, not necessarily privileged.
+ */
+#define IPPORT_RESERVED 1024
+#define IPPORT_USERRESERVED 5000
+
+/*
+ * Internet address (a structure for historical reasons)
+ */
+struct in_addr {
+ u_long s_addr;
+};
+
+/*
+ * Definitions of bits in internet address integers.
+ * On subnets, the decomposition of addresses to host and net parts
+ * is done according to subnet mask, not the masks here.
+ */
+#define IN_CLASSA(i) (((long)(i) & 0x80000000) == 0)
+#define IN_CLASSA_NET 0xff000000
+#define IN_CLASSA_NSHIFT 24
+#define IN_CLASSA_HOST 0x00ffffff
+#define IN_CLASSA_MAX 128
+
+#define IN_CLASSB(i) (((long)(i) & 0xc0000000) == 0x80000000)
+#define IN_CLASSB_NET 0xffff0000
+#define IN_CLASSB_NSHIFT 16
+#define IN_CLASSB_HOST 0x0000ffff
+#define IN_CLASSB_MAX 65536
+
+#define IN_CLASSC(i) (((long)(i) & 0xe0000000) == 0xc0000000)
+#define IN_CLASSC_NET 0xffffff00
+#define IN_CLASSC_NSHIFT 8
+#define IN_CLASSC_HOST 0x000000ff
+
+#define IN_CLASSD(i) (((long)(i) & 0xf0000000) == 0xe0000000)
+#define IN_MULTICAST(i) IN_CLASSD(i)
+
+#define IN_EXPERIMENTAL(i) (((long)(i) & 0xe0000000) == 0xe0000000)
+#define IN_BADCLASS(i) (((long)(i) & 0xf0000000) == 0xf0000000)
+
+#define INADDR_ANY (u_long)0x00000000
+#define INADDR_BROADCAST (u_long)0xffffffff /* must be masked */
+#ifndef KERNEL
+#define INADDR_NONE 0xffffffff /* -1 return */
+#endif
+
+#define IN_LOOPBACKNET 127 /* official! */
+
+/*
+ * Socket address, internet style.
+ */
+struct sockaddr_in {
+ u_char sin_len;
+ u_char sin_family;
+ u_short sin_port;
+ struct in_addr sin_addr;
+ char sin_zero[8];
+};
+
+/*
+ * Structure used to describe IP options.
+ * Used to store options internally, to pass them to a process,
+ * or to restore options retrieved earlier.
+ * The ip_dst is used for the first-hop gateway when using a source route
+ * (this gets put into the header proper).
+ */
+#ifdef __MWERKS__
+#pragma cplusplus off
+#endif
+struct ip_opts {
+ struct in_addr ip_dst; /* first hop, 0 w/o src rt */
+ char ip_opts[40]; /* actually variable in size */
+};
+#ifdef __MWERKS__
+#pragma cplusplus reset
+#endif
+
+/*
+ * Options for use with [gs]etsockopt at the IP level.
+ * First word of comment is data type; bool is stored in int.
+ */
+#define IP_OPTIONS 1 /* buf/ip_opts; set/get IP per-packet options */
+#define IP_HDRINCL 2 /* int; header is included with data (raw) */
+#define IP_TOS 3 /* int; IP type of service and precedence */
+#define IP_TTL 4 /* int; IP time to live */
+#define IP_RECVOPTS 5 /* bool; receive all IP options w/datagram */
+#define IP_RECVRETOPTS 6 /* bool; receive IP options for response */
+#define IP_RECVDSTADDR 7 /* bool; receive IP dst addr w/datagram */
+#define IP_RETOPTS 8 /* ip_opts; set/get IP per-packet options */
+
+/*
+ * Structure returned by gettimeofday(2) system call,
+ * and used in other calls.
+ */
+struct timeval {
+ long tv_sec; /* seconds */
+ long tv_usec; /* and microseconds */
+};
+
+struct timezone {
+ int tz_minuteswest; /* minutes west of Greenwich */
+ int tz_dsttime; /* type of dst correction */
+};
+#define DST_NONE 0 /* not on dst */
+#define DST_USA 1 /* USA style dst */
+#define DST_AUST 2 /* Australian style dst */
+#define DST_WET 3 /* Western European dst */
+#define DST_MET 4 /* Middle European dst */
+#define DST_EET 5 /* Eastern European dst */
+#define DST_CAN 6 /* Canada */
+//#include <sys/socket.h>
+
+/*
+ * Definitions related to sockets: types, address families, options.
+ */
+
+/*
+ * Types
+ */
+#define SOCK_STREAM 1 /* stream socket */
+#define SOCK_DGRAM 2 /* datagram socket */
+#define SOCK_RAW 3 /* raw-protocol interface */
+#define SOCK_RDM 4 /* reliably-delivered message */
+#define SOCK_SEQPACKET 5 /* sequenced packet stream */
+
+/*
+ * Option flags per-socket.
+ */
+#define SO_DEBUG 0x0001 /* turn on debugging info recording */
+#define SO_ACCEPTCONN 0x0002 /* socket has had listen() */
+#define SO_REUSEADDR 0x0004 /* allow local address reuse */
+#define SO_KEEPALIVE 0x0008 /* keep connections alive */
+#define SO_DONTROUTE 0x0010 /* just use interface addresses */
+#define SO_BROADCAST 0x0020 /* permit sending of broadcast msgs */
+#define SO_USELOOPBACK 0x0040 /* bypass hardware when possible */
+#define SO_LINGER 0x0080 /* linger on close if data present */
+#define SO_OOBINLINE 0x0100 /* leave received OOB data in line */
+
+/*
+ * Additional options, not kept in so_options.
+ */
+#define SO_SNDBUF 0x1001 /* send buffer size */
+#define SO_RCVBUF 0x1002 /* receive buffer size */
+#define SO_SNDLOWAT 0x1003 /* send low-water mark */
+#define SO_RCVLOWAT 0x1004 /* receive low-water mark */
+#define SO_SNDTIMEO 0x1005 /* send timeout */
+#define SO_RCVTIMEO 0x1006 /* receive timeout */
+#define SO_ERROR 0x1007 /* get error status and clear */
+#define SO_TYPE 0x1008 /* get socket type */
+
+/*
+ * Structure used for manipulating linger option.
+ */
+struct linger {
+ int l_onoff; /* option on/off */
+ int l_linger; /* linger time */
+};
+
+/*
+ * Level number for (get/set)sockopt() to apply to socket itself.
+ */
+#define SOL_SOCKET 0xffff /* options for socket level */
+
+/*
+ * Address families.
+ */
+#ifdef macintosh
+#define AF_UNSPEC 0 /* unspecified */
+#define AF_UNIX 1 /* local to host (pipes, portals) */
+#define AF_INET 2 /* internetwork: UDP, TCP, etc. */
+#define AF_CTB 3 /* Apple Comm Toolbox (not yet supported) */
+#define AF_FILE 4 /* Normal File I/O (used internally) */
+#define AF_PPC 5 /* PPC Toolbox */
+#define AF_PAP 6 /* Printer Access Protocol (client only) */
+#define AF_APPLETALK 16 /* Apple Talk */
+
+#define AF_MAX 20
+#else
+#define ATALK_SYMADDR 272 /* Symbolic Address for AppleTalk */
+#define AF_UNSPEC 0 /* unspecified */
+#define AF_UNIX 1 /* local to host (pipes, portals) */
+#define AF_INET 2 /* internetwork: UDP, TCP, etc. */
+#define AF_IMPLINK 3 /* arpanet imp addresses */
+#define AF_PUP 4 /* pup protocols: e.g. BSP */
+#define AF_CHAOS 5 /* mit CHAOS protocols */
+#define AF_NS 6 /* XEROX NS protocols */
+#define AF_ISO 7 /* ISO protocols */
+#define AF_OSI AF_ISO
+#define AF_ECMA 8 /* european computer manufacturers */
+#define AF_DATAKIT 9 /* datakit protocols */
+#define AF_CCITT 10 /* CCITT protocols, X.25 etc */
+#define AF_SNA 11 /* IBM SNA */
+#define AF_DECnet 12 /* DECnet */
+#define AF_DLI 13 /* DEC Direct data link interface */
+#define AF_LAT 14 /* LAT */
+#define AF_HYLINK 15 /* NSC Hyperchannel */
+#define AF_APPLETALK16 /* Apple Talk */
+#define AF_ROUTE 17 /* Internal Routing Protocol */
+#define AF_LINK 18 /* Link layer interface */
+#define pseudo_AF_XTP 19 /* eXpress Transfer Protocol (no AF) */
+
+#define AF_MAX 20
+#endif
+
+/*
+ * Structure used by kernel to store most
+ * addresses.
+ */
+#if defined(powerc) || defined (__powerc)
+#pragma options align=mac68k
+#endif
+struct sockaddr {
+ u_char sa_len; /* total length */
+ u_char sa_family; /* address family */
+ char sa_data[14]; /* actually longer; address value */
+};
+#if defined(powerc) || defined (__powerc)
+#pragma options align=reset
+#endif
+
+/*
+ * Structure used by kernel to pass protocol
+ * information in raw sockets.
+ */
+struct sockproto {
+ u_short sp_family; /* address family */
+ u_short sp_protocol; /* protocol */
+};
+
+/*
+ * Protocol families, same as address families for now.
+ */
+#ifdef macintosh
+#define PF_UNSPEC AF_UNSPEC /* unspecified */
+#define PF_UNIX AF_UNIX /* local to host (pipes, portals) */
+#define PF_INET AF_INET /* internetwork: UDP, TCP, etc. */
+#define PF_CTB AF_CTB /* Apple Comm Toolbox (not yet supported) */
+#define PF_FILE AF_FILE /* Normal File I/O (used internally) */
+#define PF_PPC AF_PPC /* PPC Toolbox */
+#define PF_PAP AF_PAP /* Printer Access Protocol (client only) */
+#define PF_APPLETALK AF_APPLETALK /* Apple Talk */
+#else
+#define PF_UNSPEC AF_UNSPEC
+#define PF_UNIX AF_UNIX
+#define PF_INET AF_INET
+#define PF_IMPLINK AF_IMPLINK
+#define PF_PUP AF_PUP
+#define PF_CHAOS AF_CHAOS
+#define PF_NS AF_NS
+#define PF_ISO AF_ISO
+#define PF_OSI AF_ISO
+#define PF_ECMA AF_ECMA
+#define PF_DATAKIT AF_DATAKIT
+#define PF_CCITT AF_CCITT
+#define PF_SNA AF_SNA
+#define PF_DECnet AF_DECnet
+#define PF_DLI AF_DLI
+#define PF_LAT AF_LAT
+#define PF_HYLINK AF_HYLINK
+#define PF_APPLETALK AF_APPLETALK
+#define PF_ROUTE AF_ROUTE
+#define PF_LINK AF_LINK
+#define PF_XTP pseudo_AF_XTP /* really just proto family, no AF */
+#endif
+
+#define PF_MAX AF_MAX
+
+/*
+ * Maximum queue length specifiable by listen.
+ */
+#define SOMAXCONN 5
+
+/*
+ * Message header for recvmsg and sendmsg calls.
+ * Used value-result for recvmsg, value only for sendmsg.
+ */
+struct msghdr {
+ caddr_t msg_name; /* optional address */
+ u_int msg_namelen; /* size of address */
+ struct iovec *msg_iov; /* scatter/gather array */
+ u_int msg_iovlen; /* # elements in msg_iov */
+ caddr_t msg_control; /* ancillary data, see below */
+ u_int msg_controllen; /* ancillary data buffer len */
+ int msg_flags; /* flags on received message */
+};
+
+#define MSG_OOB 0x1 /* process out-of-band data */
+#define MSG_PEEK 0x2 /* peek at incoming message */
+#define MSG_DONTROUTE 0x4 /* send without using routing tables */
+#define MSG_EOR 0x8 /* data completes record */
+#define MSG_TRUNC 0x10 /* data discarded before delivery */
+#define MSG_CTRUNC 0x20 /* control data lost before delivery */
+#define MSG_WAITALL 0x40 /* wait for full request or error */
+
+/*
+ * Header for ancillary data objects in msg_control buffer.
+ * Used for additional information with/about a datagram
+ * not expressible by flags. The format is a sequence
+ * of message elements headed by cmsghdr structures.
+ */
+struct cmsghdr {
+ u_int cmsg_len; /* data byte count, including hdr */
+ int cmsg_level; /* originating protocol */
+ int cmsg_type; /* protocol-specific type */
+/* followed by u_char cmsg_data[]; */
+};
+
+/* given pointer to struct adatahdr, return pointer to data */
+#define CMSG_DATA(cmsg) ((u_char *)((cmsg) + 1))
+
+/* given pointer to struct adatahdr, return pointer to next adatahdr */
+#define CMSG_NXTHDR(mhdr, cmsg) \
+ (((caddr_t)(cmsg) + (cmsg)->cmsg_len + sizeof(struct cmsghdr) > \
+ (mhdr)->msg_control + (mhdr)->msg_controllen) ? \
+ (struct cmsghdr *)NULL : \
+ (struct cmsghdr *)((caddr_t)(cmsg) + ALIGN((cmsg)->cmsg_len)))
+
+#define CMSG_FIRSTHDR(mhdr) ((struct cmsghdr *)(mhdr)->msg_control)
+
+/* "Socket"-level control message types: */
+#define SCM_RIGHTS 0x01 /* access rights (array of int) */
+
+/*
+ * 4.3 compat sockaddr, move to compat file later
+ */
+struct osockaddr {
+ u_short sa_family; /* address family */
+ char sa_data[14]; /* up to 14 bytes of direct address */
+};
+
+/*
+ * 4.3-compat message header (move to compat file later).
+ */
+struct omsghdr {
+ caddr_t msg_name; /* optional address */
+ int msg_namelen; /* size of address */
+ struct iovec *msg_iov; /* scatter/gather array */
+ int msg_iovlen; /* # elements in msg_iov */
+ caddr_t msg_accrights; /* access rights sent/received */
+ int msg_accrightslen;
+};
+
+//#include <string.h>
+//#include <netinet/in.h>
+//#include <netdb.h>
+//#include <sys/un.h>
+//#include <unistd.h>
+//#include <machine/endian.h>
+//
+
+typedef enum spin_msg {
+ SP_MISC, /* some weird thing, usually just return immediately if you get this */
+ SP_SELECT, /* in a select call */
+ SP_NAME, /* getting a host by name */
+ SP_ADDR, /* getting a host by address */
+ SP_STREAM_READ, /* Stream read call */
+ SP_STREAM_WRITE, /* Stream write call */
+ SP_DGRAM_READ, /* Datagram read call */
+ SP_DGRAM_WRITE, /* Datagram write call */
+ SP_SLEEP, /* sleeping, passes ticks left to sleep */
+ SP_AUTO_SPIN /* Autospin, passes argument to SpinCursor */
+} spin_msg;
+
+typedef int (*GUSISpinFn)(spin_msg msg, long param);
+typedef void (*GUSIEvtHandler)(EventRecord * ev);
+typedef GUSIEvtHandler GUSIEvtTable[24];
+
+/*
+ * Address families, defined in sys/socket.h
+ *
+
+#define AF_UNSPEC 0 // unspecified
+#define AF_UNIX 1 // local to host (pipes, portals)
+#define AF_INET 2 // internetwork: UDP, TCP, etc.
+#define AF_CTB 3 // Apple Comm Toolbox (not yet supported)
+#define AF_FILE 4 // Normal File I/O (used internally)
+#define AF_PPC 5 // PPC Toolbox
+#define AF_PAP 6 // Printer Access Protocol (client only)
+#define AF_APPLETALK 16 // Apple Talk
+
+*/
+
+#define ATALK_SYMADDR 272 /* Symbolic Address for AppleTalk */
+
+/*
+ * Some Implementations of GUSI require you to call GUSISetup for the
+ * socket families you'd like to have defined. It's a good idea to call
+ * this for *all* implementations.
+ *
+ * GUSIDefaultSetup() will include all socket families.
+ *
+ * Never call any of the GUSIwithXXX routines directly.
+ */
+
+__BEGIN_DECLS
+void GUSIwithAppleTalkSockets();
+void GUSIwithInternetSockets();
+void GUSIwithPAPSockets();
+void GUSIwithPPCSockets();
+void GUSIwithUnixSockets();
+void GUSIwithSIOUXSockets();
+void GUSIwithMPWSockets();
+
+void GUSISetup(void (*socketfamily)());
+void GUSIDefaultSetup();
+__END_DECLS
+/*
+ * Types, defined in sys/socket.h
+ *
+
+#define SOCK_STREAM 1 // stream socket
+#define SOCK_DGRAM 2 // datagram socket
+
+*/
+
+/*
+ * Defined in sys/un.h
+ *
+
+struct sockaddr_un {
+ short sun_family;
+ char sun_path[108];
+};
+
+*/
+
+#ifndef PRAGMA_ALIGN_SUPPORTED
+#error Apple had some fun with the conditional macros again
+#endif
+
+#if PRAGMA_ALIGN_SUPPORTED
+#pragma options align=mac68k
+#endif
+
+/*
+struct sockaddr_atlk {
+ short family;
+ AddrBlock addr;
+};
+
+struct sockaddr_atlk_sym {
+ short family;
+ EntityName name;
+};
+
+struct sockaddr_ppc {
+ short family;
+ LocationNameRec location;
+ PPCPortRec port;
+};
+
+// Definitions for choose()
+
+#define CHOOSE_DEFAULT 1
+#define CHOOSE_NEW 2
+#define CHOOSE_DIR 4
+
+typedef struct {
+ short numTypes;
+ SFTypeList types;
+} sa_constr_file;
+
+typedef struct {
+ short numTypes;
+ NLType types;
+} sa_constr_atlk;
+
+
+// Definitions for sa_constr_ppc
+
+#define PPC_CON_NEWSTYLE 0x8000
+#define PPC_CON_MATCH_NAME 0x0001
+#define PPC_CON_MATCH_TYPE 0x0002
+#define PPC_CON_MATCH_NBP 0x0004
+
+typedef struct {
+ short flags;
+ Str32 nbpType;
+ PPCPortRec match;
+} sa_constr_ppc;
+
+*/
+
+#if PRAGMA_ALIGN_SUPPORTED
+#pragma options align=reset
+#endif
+
+__BEGIN_DECLS
+/*
+ * IO/Socket stuff, defined elsewhere (unistd.h, sys/socket.h
+ *
+*/
+int socket(int domain, int type, short protocol);
+int bind(int s, void *name, int namelen);
+int connect(int s, void *addr, int addrlen);
+int listen(int s, int qlen);
+int accept(int s, void *addr, int *addrlen);
+int close(int s);
+int read(int s, char *buffer, unsigned buflen);
+int readv(int s, struct iovec *iov, int count);
+int recv(int s, void *buffer, int buflen, int flags);
+int recvfrom(int s, void *buffer, int buflen, int flags, void *from, int *fromlen);
+int recvmsg(int s,struct msghdr *msg,int flags);
+int write(int s, const char *buffer, unsigned buflen);
+int writev(int s, struct iovec *iov, int count);
+int send(int s, void *buffer, int buflen, int flags);
+int sendto (int s, void *buffer, int buflen, int flags, void *to, int tolen);
+int sendmsg(int s,struct msghdr *msg,int flags);
+int select(int width, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int getdtablesize(void);
+int getsockname(int s, void *name, int *namelen);
+int getpeername(int s, struct sockaddr *name, int *namelen);
+int shutdown(int s, int how);
+int fcntl(int s, unsigned int cmd, int arg);
+int dup(int s);
+int dup2(int s, int s1);
+//int ioctl(int d, unsigned int request, long *argp);
+int getsockopt(int s, int level, int optname, char *optval, int * optlen);
+int setsockopt(int s, int level, int optname, char *optval, int optlen);
+int isatty(int);
+int remove(const char *filename);
+int rename(const char *oldname, const char *newname);
+int creat(const char*);
+int faccess(char*, unsigned int, long*);
+long lseek(int, long, int);
+int open(const char*, int);
+int unlink(char*);
+int symlink(char* linkto, char* linkname);
+int readlink(char* path, char* buf, int bufsiz);
+int truncate(char *path, long length);
+int ftruncate(int fd, long length);
+int chdir(char * path);
+int mkdir(char * path);
+int rmdir(char * path);
+char * getcwd(char * buf, int size);
+
+
+/*
+ * Defined in stdio.h
+ */
+
+#ifdef __MWERKS__
+void fsetfileinfo (char *filename, unsigned long newcreator, unsigned long newtype);
+#endif
+
+void fgetfileinfo (char *filename, unsigned long * creator, unsigned long * type);
+
+#ifdef __MWERKS__
+FILE *fdopen(int fd, const char *mode);
+int fwalk(int (*func)(FILE * stream));
+#endif
+
+int choose(
+ int domain,
+ int type,
+ char * prompt,
+ void * constraint,
+ int flags,
+ void * name,
+ int * namelen);
+
+/*
+ * Hostname routines, defined in netdb.h
+ *
+*/
+
+/*
+ * Structures returned by network data base library. All addresses are
+ * supplied in host order, and returned in network order (suitable for
+ * use in system calls).
+ */
+struct hostent {
+ char *h_name; /* official name of host */
+ char **h_aliases; /* alias list */
+ int h_addrtype; /* host address type */
+ int h_length; /* length of address */
+ char **h_addr_list; /* list of addresses from name server */
+#define h_addr h_addr_list[0] /* address, for backward compatiblity */
+};
+
+/*
+ * Assumption here is that a network number
+ * fits in 32 bits -- probably a poor one.
+ */
+struct netent {
+ char *n_name; /* official name of net */
+ char **n_aliases; /* alias list */
+ int n_addrtype; /* net address type */
+ unsigned long n_net; /* network # */
+};
+
+struct servent {
+ char *s_name; /* official service name */
+ char **s_aliases; /* alias list */
+ int s_port; /* port # */
+ char *s_proto; /* protocol to use */
+};
+
+struct protoent {
+ char *p_name; /* official protocol name */
+ char **p_aliases; /* alias list */
+ int p_proto; /* protocol # */
+};
+
+/*
+ * Error return codes from gethostbyname() and gethostbyaddr()
+ * (left in extern int h_errno).
+ */
+
+#define HOST_NOT_FOUND 1 /* Authoritative Answer Host not found */
+#define TRY_AGAIN 2 /* Non-Authoritive Host not found, or SERVERFAIL */
+#define NO_RECOVERY 3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP */
+#define NO_DATA 4 /* Valid name, no data record of requested type */
+#define NO_ADDRESS NO_DATA /* no address, look for MX record */
+
+int gethostname(char *machname, long buflen);
+
+void endhostent __P((void));
+void endnetent __P((void));
+void endprotoent __P((void));
+void endservent __P((void));
+struct hostent *gethostbyaddr __P((const char *, int, int));
+struct hostent *gethostbyname __P((const char *));
+struct hostent *gethostent __P((void));
+struct netent *getnetbyaddr __P((long, int)); /* u_long? */
+struct netent *getnetbyname __P((const char *));
+struct netent *getnetent __P((void));
+struct protoent *getprotobyname __P((const char *));
+struct protoent *getprotobynumber __P((int));
+struct protoent *getprotoent __P((void));
+struct servent *getservbyname __P((const char *, const char *));
+struct servent *getservbyport __P((int, const char *));
+struct servent *getservent __P((void));
+void herror __P((const char *));
+void sethostent __P((int));
+/* void sethostfile __P((const char *)); */
+void setnetent __P((int));
+void setprotoent __P((int));
+void setservent __P((int));
+
+
+char * inet_ntoa(struct in_addr inaddr);
+struct in_addr inet_addr(const char *address);
+
+/*
+ * GUSI supports a number of hooks. Every one of them has a different prototype, but needs
+ * to be passed as a GUSIHook
+ */
+
+typedef enum {
+ GUSI_SpinHook, /* A GUSISpinFn, to be called when a call blocks */
+ GUSI_ExecHook, /* Boolean (*hook)(const GUSIFileRef & ref), decides if file is executable */
+ GUSI_FTypeHook,/* Boolean (*hook)(const FSSpec & spec) sets a default file type */
+ GUSI_SpeedHook /* A long integer, to be added to the cursor spin variable */
+} GUSIHookCode;
+
+typedef void (*GUSIHook)(void);
+void GUSISetHook(GUSIHookCode code, GUSIHook hook);
+GUSIHook GUSIGetHook(GUSIHookCode code);
+
+/*
+ * What to do when a routine blocks
+ */
+
+/* Defined for compatibility */
+#define GUSISetSpin(routine) GUSISetHook(GUSI_SpinHook, (GUSIHook)routine)
+#define GUSIGetSpin() (GUSISpinFn) GUSIGetHook(GUSI_SpinHook)
+
+int GUSISetEvents(GUSIEvtTable table);
+GUSIEvtHandler * GUSIGetEvents(void);
+
+extern GUSIEvtHandler GUSISIOWEvents[];
+
+#define SIGPIPE 13
+#define SIGALRM 14
+
+/*
+ * BSD memory routines, defined in compat.h
+ *
+*/
+#define index(a, b) strchr(a, b)
+#define rindex(a, b) strrchr(a, b)
+#define bzero(from, len) memset(from, 0, len)
+#define bcopy(from, to, len) memcpy(to, from, len)
+#define bcmp(s1, s2, len) memcmp(s1, s2, len)
+#define bfill(from, len, x) memset(from, x, len)
+
+
+__END_DECLS
+
+ typedef struct wxSockInternal
+ {
+ long nothing ;
+ } ;
+
+#endif /* !_GUSI_ */
\ No newline at end of file
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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 OnSysColourChanged(wxSysColourChangedEvent& 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:
+
+ // TODO maybe have this member
+ wxMDIClientWindow *m_clientWindow;
+
+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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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);
+
+ // 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); };
+
+ // Client data
+ inline void SetClientData(void* clientData) { m_clientData = clientData; }
+ inline void* GetClientData() const { return m_clientData; }
+
+ // item properties
+ // title
+ void SetTitle(const wxString& label);
+ const wxString GetTitle() const;
+ // label
+ void SetLabel(int id, const wxString& label);
+ wxString GetLabel(int id) const;
+ // help string
+ virtual void SetHelpString(int id, const wxString& helpString);
+ virtual wxString GetHelpString(int id) const ;
+
+ // find item
+ // Finds the item id matching the given string, -1 if not found.
+ virtual int FindItem(const wxString& itemString) const ;
+ // Find wxMenuItem by ID, and item's menu too if itemMenu is !NULL.
+ wxMenuItem *FindItemForId(int itemId, wxMenu **itemMenu = NULL) const;
+
+ void ProcessCommand(wxCommandEvent& event);
+ inline void Callback(const wxFunction func) { m_callback = func; }
+
+ virtual void SetParent(wxEvtHandler *parent) { m_parent = parent; }
+ inline void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; }
+ inline wxEvtHandler *GetEventHandler() { return m_eventHandler; }
+
+ inline wxList& GetItems() const { return (wxList&) m_menuItems; }
+
+public:
+ wxFunction m_callback;
+
+ int m_noItems;
+ wxString m_title;
+ wxMenuBar * m_menuBar;
+ wxList m_menuItems;
+ wxEvtHandler * m_parent;
+ wxEvtHandler * m_eventHandler;
+ void* m_clientData;
+};
+
+// ----------------------------------------------------------------------------
+// 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_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: menuitem.h
+// Purpose: wxMenuItem class
+// Author: Vadim Zeitlin
+// Modified by:
+// Created: 11.11.97
+// RCS-ID: $Id$
+// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Licence: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MENUITEM_H
+#define _MENUITEM_H
+
+#ifdef __GNUG__
+#pragma interface "menuitem.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/setup.h"
+
+// an exception to the general rule that a normal header doesn't include other
+// headers - only because ownerdrw.h is not always included and I don't want
+// to write #ifdef's everywhere...
+#if wxUSE_OWNER_DRAWN
+#include "wx/ownerdrw.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+// id for a separator line in the menu (invalid for normal item)
+#define ID_SEPARATOR (-1)
+
+// ----------------------------------------------------------------------------
+// wxMenuItem: an item in the menu, optionally implements owner-drawn behaviour
+// ----------------------------------------------------------------------------
+class WXDLLEXPORT wxMenuItem: public wxObject
+#if wxUSE_OWNER_DRAWN
+ , public wxOwnerDrawn
+#endif
+{
+DECLARE_DYNAMIC_CLASS(wxMenuItem)
+
+public:
+ // ctor & dtor
+ wxMenuItem(wxMenu *pParentMenu = NULL, int id = ID_SEPARATOR,
+ const wxString& strName = "", const wxString& wxHelp = "",
+ bool bCheckable = FALSE, wxMenu *pSubMenu = NULL);
+ virtual ~wxMenuItem();
+
+ // accessors (some more are inherited from wxOwnerDrawn or are below)
+ bool IsSeparator() const { return m_idItem == ID_SEPARATOR; }
+ bool IsEnabled() const { return m_bEnabled; }
+ bool IsChecked() const { return m_bChecked; }
+
+ int GetId() const { return m_idItem; }
+ const wxString& GetHelp() const { return m_strHelp; }
+ wxMenu *GetSubMenu() const { return m_pSubMenu; }
+
+ // operations
+ void SetName(const wxString& strName) { m_strName = strName; }
+ void SetHelp(const wxString& strHelp) { m_strHelp = strHelp; }
+
+ void Enable(bool bDoEnable = TRUE);
+ void Check(bool bDoCheck = TRUE);
+
+ void DeleteSubMenu();
+
+private:
+ int m_idItem; // numeric id of the item
+ wxString m_strHelp; // associated help string
+ wxMenu *m_pSubMenu, // may be NULL
+ *m_pParentMenu; // menu this item is contained in
+ bool m_bEnabled, // enabled or greyed?
+ m_bChecked; // checked? (only if checkable)
+
+#if wxUSE_OWNER_DRAWN
+ // wxOwnerDrawn base class already has these variables - nothing to do
+
+#else //!owner drawn
+ bool m_bCheckable; // can be checked?
+ wxString m_strName; // name or label of the item
+
+public:
+ const wxString& GetName() const { return m_strName; }
+ bool IsCheckable() const { return m_bCheckable; }
+#endif //owner drawn
+};
+
+#endif //_MENUITEM_H
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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);
+ // TODO
+ inline bool Ok() { return FALSE; };
+
+/* 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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)
+ {
+ // Use wxFrame constructor in absence of more specific code.
+ Create(parent, id, title, pos, size, style, name);
+ }
+
+ ~wxMiniFrame() {}
+protected:
+};
+
+#endif
+ // _WX_MINIFRAM_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: msgdlg.h
+// Purpose: wxMessageDialog class. Use generic version if no
+// platform-specific implementation.
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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 "wx/dynarray.h"
+#include "wx/event.h"
+#include "wx/control.h"
+
+// ----------------------------------------------------------------------------
+// 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 one page from the notebook, without deleting
+ bool RemovePage(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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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); }
+
+ 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; }
+
+/* TODO: implementation
+ inline WXHPALETTE GetHPALETTE() const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
+ void SetHPALETTE(WXHPALETTE pal);
+*/
+};
+
+#endif
+ // _WX_PALETTE_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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"
+#include "wx/colour.h"
+#include "wx/bitmap.h"
+
+typedef long wxDash ;
+
+class WXDLLEXPORT wxPen;
+
+class WXDLLEXPORT wxPenRefData: public wxGDIRefData
+{
+ friend class WXDLLEXPORT wxPen;
+public:
+ wxPenRefData();
+ wxPenRefData(const wxPenRefData& data);
+ ~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 wxBitmap& stipple, int width);
+ inline wxPen(const wxPen& 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(unsigned char r, unsigned char g, 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 : (wxDash*) NULL); return (M_PENDATA ? M_PENDATA->m_nbDash : 0);
+ }
+
+ inline wxBitmap *GetStipple() const { return (M_PENDATA ? (& M_PENDATA->m_stipple) : (wxBitmap*) NULL); };
+
+// Implementation
+
+ // Useful helper: create the brush resource
+ bool RealizeResource();
+
+ // When setting properties, we must make sure we're not changing
+ // another object
+ void Unshare();
+};
+
+#endif
+ // _WX_PEN_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: printdlg.h
+// Purpose: wxPrintDialog, wxPageSetupDialog classes.
+// Use generic, PostScript version if no
+// platform-specific implementation.
+// 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;
+ 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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) ;
+ 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_noItems;
+ int m_noRowsOrCols;
+ int m_selectedButton;
+
+};
+
+#endif
+ // _WX_RADIOBOX_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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);
+};
+
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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"
+#include "wx/gdicmn.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);
+ 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(); }
+ wxRect GetRect() const { return wxRect(GetX(), GetY(), GetWidth(), GetHeight()); }
+
+private:
+ long m_current;
+ long m_numRects;
+ wxRegion m_region;
+ wxRect* m_rects;
+};
+
+#endif
+ // _WX_REGION_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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 GetThumbPosition() const ;
+ inline int GetThumbSize() const { return m_pageSize; }
+ inline int GetPageSize() const { return m_viewSize; }
+ inline int GetRange() const { return m_objectSize; }
+
+ virtual void SetThumbPosition(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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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"
+#include "wx/defs.h"
+#include "wx/object.h"
+#include "wx/colour.h"
+#include "wx/font.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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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 wxUSE_CONSTRAINTS 1
+ // Use constraints mechanism
+#define wxUSE_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 wxUSE_POSTSCRIPT 1
+ // 0 for no PostScript device context
+#define wxUSE_AFM_FOR_POSTSCRIPT 0
+ // 1 to use font metric files in GetTextExtent
+#define wxUSE_METAFILE 1
+ // 0 for no Metafile and metafile device context
+#define wxUSE_IPC 1
+ // 0 for no interprocess comms
+#define wxUSE_HELP 1
+ // 0 for no help facility
+#define wxUSE_RESOURCES 1
+ // 0 for no wxGetResource/wxWriteResource
+#define wxUSE_CLIPBOARD 1
+ // 0 for no clipboard functions
+#define wxUSE_SPLINES 1
+ // 0 for no splines
+#define wxUSE_XFIG_SPLINE_CODE 1
+ // 1 for XFIG spline code, 0 for AIAI spline code.
+// AIAI spline code is slower, but freer of copyright issues.
+ // 0 for no splines
+
+#define wxUSE_TOOLBAR 1
+ // Use toolbars
+#define wxUSE_DRAG_AND_DROP 1
+ // 0 for no drag and drop
+
+#define wxUSE_WX_RESOURCES 1
+ // Use .wxr resource mechanism (requires PrologIO library)
+
+#define wxUSE_DOC_VIEW_ARCHITECTURE 1
+ // Set to 0 to disable document/view architecture
+#define wxUSE_PRINTING_ARCHITECTURE 1
+ // Set to 0 to disable print/preview architecture code
+#define wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1
+ // Set to 0 to disable PostScript print/preview architecture code
+ // under Windows (just use Windows printing).
+#define wxUSE_DYNAMIC_CLASSES 1
+ // If 1, enables provision of run-time type information.
+ // NOW MANDATORY: don't change.
+#define wxUSE_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 wxUSE_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 wxUSE_GLOBAL_MEMORY_OPERATORS 0
+ // In debug mode, cause new and delete to be redefined globally.
+ // If this causes problems (e.g. link errors), set this to 0.
+
+#define wxUSE_DEBUG_NEW_ALWAYS 1
+ // In debug mode, causes new to be defined to
+ // be WXDEBUG_NEW (see object.h).
+ // 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 wxUSE_C_MAIN 0
+ // Set to 1 to use main.c instead of main.cpp (UNIX only)
+
+#define wxUSE_ODBC 0
+ // Define 1 to use ODBC classes
+
+#define wxUSE_IOSTREAMH 0
+ // VC++ 4.2 and above allows <iostream> and <iostream.h>
+ // but you can't mix them. Set to 1 for <iostream.h>,
+ // 0 for <iostream>
+
+#define wxUSE_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 wxUSE_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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: statusbr.h
+// Purpose: native implementation of wxStatusBar. Optional; can use generic
+// version instead.
+// Author: AUTHOR
+// Modified by:
+// Created: ??/??/98
+// RCS-ID: $Id$
+// Copyright: (c) AUTHOR
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_STATBAR_H_
+#define _WX_STATBAR_H_
+
+#ifdef __GNUG__
+#pragma interface "statbar.h"
+#endif
+
+#include "wx/generic/statusbr.h"
+
+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 its 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[]);
+
+ void OnSize(wxSizeEvent& event);
+
+ DECLARE_EVENT_TABLE()
+
+protected:
+ void CopyFieldsWidth(const int widths[]);
+ void SetFieldsWidth();
+};
+
+#endif
+ // _WX_STATBAR_H_
\ No newline at end of file
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////
+// 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 <wx/list.h>
+#include <wx/icon.h>
+
+class wxTaskBarIcon: public wxObject
+{
+public:
+ wxTaskBarIcon();
+ virtual ~wxTaskBarIcon();
+
+// Accessors
+
+// 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();
+
+// Data members
+protected:
+};
+
+#endif
+ // _WX_TASKBAR_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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 wxUSE_IOSTREAMH
+#include <iostream.h>
+#else
+#include <iostream>
+#endif
+
+WXDLLEXPORT_DATA(extern const char*) wxTextCtrlNameStr;
+WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
+
+// Single-line text item
+class WXDLLEXPORT wxTextCtrl: public wxControl
+
+// TODO Some platforms/compilers don't like inheritance from streambuf.
+
+#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 m_fileName;
+
+ DECLARE_EVENT_TABLE()
+};
+
+#endif
+ // _WX_TEXTCTRL_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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
+{
+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
+
+ // Returns the current interval time (0 if stop)
+ int Interval() const { return m_milli; };
+ bool OneShot() const { return m_oneShot; }
+
+protected:
+ bool m_oneShot ;
+ int m_milli ;
+ int m_lastMilli ;
+
+ long m_id;
+
+private:
+ DECLARE_ABSTRACT_CLASS(wxTimer)
+};
+
+/* 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_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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;
+
+ // Add all the buttons
+ virtual bool CreateTools();
+ virtual void Layout() {}
+
+ // The post-tool-addition call. TODO: do here whatever's
+ // necessary for completing the toolbar construction.
+ bool Realize() { return CreateTools(); };
+
+protected:
+
+DECLARE_EVENT_TABLE()
+};
+
+#endif
+ // _WX_TOOLBAR_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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, wxRect& 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, (wxObject *) NULL },
+#define EVT_TREE_BEGIN_RDRAG(id, fn) { wxEVT_COMMAND_TREE_BEGIN_RDRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_BEGIN_LABEL_EDIT(id, fn) { wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_END_LABEL_EDIT(id, fn) { wxEVT_COMMAND_TREE_END_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_DELETE_ITEM(id, fn) { wxEVT_COMMAND_TREE_DELETE_ITEM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_GET_INFO(id, fn) { wxEVT_COMMAND_TREE_GET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_SET_INFO(id, fn) { wxEVT_COMMAND_TREE_SET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_ITEM_EXPANDED(id, fn) { wxEVT_COMMAND_TREE_ITEM_EXPANDED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_ITEM_EXPANDING(id, fn) { wxEVT_COMMAND_TREE_ITEM_EXPANDING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_ITEM_COLLAPSED(id, fn) { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_ITEM_COLLAPSING(id, fn) { wxEVT_COMMAND_TREE_ITEM_COLLAPSING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_SEL_CHANGED(id, fn) { wxEVT_COMMAND_TREE_SEL_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_SEL_CHANGING(id, fn) { wxEVT_COMMAND_TREE_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+#define EVT_TREE_KEY_DOWN(id, fn) { wxEVT_COMMAND_TREE_KEY_DOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (wxObject *) NULL },
+
+#endif
+ // _WX_TREECTRL_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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:
+ char* m_waveData;
+ int m_waveLength;
+ bool m_isResource;
+};
+
+#endif
+ // _WX_WAVE_H_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// 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"
+#include "wx/accel.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 wxRect;
+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 wxUSE_DRAG_AND_DROP
+class WXDLLEXPORT wxDropTarget;
+#endif
+
+#if wxUSE_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;
+
+//-----------------------------------------------------------------------------
+// wxClientData
+//-----------------------------------------------------------------------------
+
+class wxClientData
+{
+public:
+ wxClientData() { }
+ virtual ~wxClientData() { }
+};
+
+//-----------------------------------------------------------------------------
+// wxStringClientData
+//-----------------------------------------------------------------------------
+
+class wxStringClientData: public wxClientData
+{
+public:
+ wxStringClientData() { }
+ wxStringClientData( wxString &data ) { m_data = data; }
+ void SetData( wxString &data ) { m_data = data; }
+ wxString GetData() const { return m_data; }
+
+private:
+ wxString m_data;
+};
+
+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 wxUSE_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 wxRect *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 wxRect *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);
+
+ virtual void SetAcceleratorTable(const wxAcceleratorTable& accel);
+ inline virtual wxAcceleratorTable& GetAcceleratorTable() const { return (wxAcceleratorTable&) m_acceleratorTable; }
+
+ // 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;
+
+ // Handle a control command
+ virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
+
+ // 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 wxUSE_WX_RESOURCES
+ virtual bool LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table = NULL);
+ virtual wxControl *CreateItem(const wxItemResource* childResource, const wxItemResource* parentResource,
+ const wxResourceTable *table = (const wxResourceTable *) NULL);
+#endif
+
+ 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;
+
+ virtual void PrepareDC( wxDC &dc ) {};
+
+
+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: 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
+
+ inline bool IsBeingDeleted() const { return FALSE; } // TODO: Should probably eliminate this
+
+ // 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 ;
+
+ // Dialog units translations. Implemented in wincmn.cpp.
+ wxPoint ConvertPixelsToDialog(const wxPoint& pt) ;
+ wxPoint ConvertDialogToPixels(const wxPoint& pt) ;
+ inline wxSize ConvertPixelsToDialog(const wxSize& sz)
+ { wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
+ inline wxSize ConvertDialogToPixels(const wxSize& sz)
+ { wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); }
+
+ wxObject *GetChild(int number) const ;
+
+ // Generates a new id for controls
+ static int NewControlId();
+
+ // Responds to colour changes: passes event on to children.
+ void OnSysColourChanged(wxSysColourChangedEvent& event);
+
+ // Transfers data to any child controls
+ void OnInitDialog(wxInitDialogEvent& event);
+
+ // Sends an OnInitDialog event, which in turns transfers data to
+ // to the window via validators.
+ virtual void InitDialog();
+
+ ////////////////////////////////////////////////////////////////////////
+ //// PROTECTED DATA
+protected:
+ int m_windowId;
+ long m_windowStyle; // Store the window's style
+ wxEvtHandler * m_windowEventHandler; // Usually is 'this'
+ wxLayoutConstraints * m_constraints; // Constraints for this window
+ wxList * m_constraintsInvolvedIn; // List of constraints we're involved in
+ wxSizer * m_windowSizer; // Window's top-level sizer (if any)
+ wxWindow * m_sizerParent; // Window's parent sizer (if any)
+ bool m_autoLayout; // Whether to call Layout() in OnSize
+ wxWindow * m_windowParent; // Each window always knows its parent
+ wxValidator * m_windowValidator;
+ int m_minSizeX;
+ int m_minSizeY;
+ int m_maxSizeX;
+ int m_maxSizeY;
+
+ // Caret data
+ int m_caretWidth;
+ int m_caretHeight;
+ bool m_caretEnabled;
+ bool m_caretShown;
+ wxFont m_windowFont; // Window's font
+ wxCursor m_windowCursor; // Window's cursor
+ wxString m_windowName; // Window name
+
+ wxButton * m_defaultItem;
+
+ wxColour m_backgroundColour ;
+ wxColour m_foregroundColour ;
+ wxAcceleratorTable m_acceleratorTable;
+
+#if wxUSE_DRAG_AND_DROP
+ wxDropTarget *m_pDropTarget; // the current drop target or NULL
+#endif //USE_DRAG_AND_DROP
+
+public:
+ wxRegion m_updateRegion;
+ wxList * m_children; // Window's children
+ int m_returnCode;
+
+DECLARE_EVENT_TABLE()
+};
+
+////////////////////////////////////////////////////////////////////////
+//// 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 : (wxWindow*) NULL); }
+inline wxList& wxWindow::GetChildren() const { return (wxList&) * 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::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 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 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_
projects / wxWidgets.git / commitdiff
