From 9b6dbb09746f8f5ee0549a2ff39ae0ac4c725898 Mon Sep 17 00:00:00 2001 From: Julian Smart Date: Fri, 18 Sep 1998 10:19:10 +0000 Subject: [PATCH] Added Motif files. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@751 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/motif/accel.h | 80 +++++ include/wx/motif/app.h | 166 +++++++++++ include/wx/motif/bitmap.h | 198 +++++++++++++ include/wx/motif/bmpbuttn.h | 83 ++++++ include/wx/motif/brush.h | 86 ++++++ include/wx/motif/button.h | 53 ++++ include/wx/motif/checkbox.h | 81 +++++ include/wx/motif/checklst.h | 47 +++ include/wx/motif/choice.h | 72 +++++ include/wx/motif/clipbrd.h | 104 +++++++ include/wx/motif/colordlg.h | 46 +++ include/wx/motif/colour.h | 73 +++++ include/wx/motif/combobox.h | 78 +++++ include/wx/motif/control.h | 50 ++++ include/wx/motif/cursor.h | 76 +++++ include/wx/motif/dc.h | 376 ++++++++++++++++++++++++ include/wx/motif/dcclient.h | 101 +++++++ include/wx/motif/dcmemory.h | 38 +++ include/wx/motif/dcprint.h | 34 +++ include/wx/motif/dcscreen.h | 39 +++ include/wx/motif/dialog.h | 98 +++++++ include/wx/motif/dirdlg.h | 49 ++++ include/wx/motif/dnd.h | 238 +++++++++++++++ include/wx/motif/filedlg.h | 89 ++++++ include/wx/motif/font.h | 90 ++++++ include/wx/motif/fontdlg.h | 46 +++ include/wx/motif/frame.h | 179 +++++++++++ include/wx/motif/gauge.h | 69 +++++ include/wx/motif/gdiobj.h | 48 +++ include/wx/motif/helpxxxx.h | 52 ++++ include/wx/motif/icon.h | 107 +++++++ include/wx/motif/imaglist.h | 145 +++++++++ include/wx/motif/joystick.h | 93 ++++++ include/wx/motif/listbox.h | 97 ++++++ include/wx/motif/listctrl.h | 451 ++++++++++++++++++++++++++++ include/wx/motif/mdi.h | 164 +++++++++++ include/wx/motif/menu.h | 170 +++++++++++ include/wx/motif/metafile.h | 101 +++++++ include/wx/motif/minifram.h | 46 +++ include/wx/motif/msgdlg.h | 50 ++++ include/wx/motif/notebook.h | 204 +++++++++++++ include/wx/motif/palette.h | 65 ++++ include/wx/motif/pen.h | 104 +++++++ include/wx/motif/print.h | 56 ++++ include/wx/motif/printdlg.h | 70 +++++ include/wx/motif/private.h | 28 ++ include/wx/motif/radiobox.h | 88 ++++++ include/wx/motif/radiobut.h | 90 ++++++ include/wx/motif/region.h | 135 +++++++++ include/wx/motif/scrolbar.h | 68 +++++ include/wx/motif/settings.h | 133 +++++++++ include/wx/motif/setup.h | 120 ++++++++ include/wx/motif/slider.h | 91 ++++++ include/wx/motif/spinbutt.h | 97 ++++++ include/wx/motif/statbmp.h | 64 ++++ include/wx/motif/statbox.h | 57 ++++ include/wx/motif/stattext.h | 56 ++++ include/wx/motif/statusbr.h | 54 ++++ include/wx/motif/tabctrl.h | 138 +++++++++ include/wx/motif/taskbar.h | 49 ++++ include/wx/motif/textctrl.h | 139 +++++++++ include/wx/motif/timer.h | 57 ++++ include/wx/motif/toolbar.h | 77 +++++ include/wx/motif/treectrl.h | 295 +++++++++++++++++++ include/wx/motif/wave.h | 44 +++ include/wx/motif/window.h | 570 ++++++++++++++++++++++++++++++++++++ 66 files changed, 7212 insertions(+) create mode 100644 include/wx/motif/accel.h create mode 100644 include/wx/motif/app.h create mode 100644 include/wx/motif/bitmap.h create mode 100644 include/wx/motif/bmpbuttn.h create mode 100644 include/wx/motif/brush.h create mode 100644 include/wx/motif/button.h create mode 100644 include/wx/motif/checkbox.h create mode 100644 include/wx/motif/checklst.h create mode 100644 include/wx/motif/choice.h create mode 100644 include/wx/motif/clipbrd.h create mode 100644 include/wx/motif/colordlg.h create mode 100644 include/wx/motif/colour.h create mode 100644 include/wx/motif/combobox.h create mode 100644 include/wx/motif/control.h create mode 100644 include/wx/motif/cursor.h create mode 100644 include/wx/motif/dc.h create mode 100644 include/wx/motif/dcclient.h create mode 100644 include/wx/motif/dcmemory.h create mode 100644 include/wx/motif/dcprint.h create mode 100644 include/wx/motif/dcscreen.h create mode 100644 include/wx/motif/dialog.h create mode 100644 include/wx/motif/dirdlg.h create mode 100644 include/wx/motif/dnd.h create mode 100644 include/wx/motif/filedlg.h create mode 100644 include/wx/motif/font.h create mode 100644 include/wx/motif/fontdlg.h create mode 100644 include/wx/motif/frame.h create mode 100644 include/wx/motif/gauge.h create mode 100644 include/wx/motif/gdiobj.h create mode 100644 include/wx/motif/helpxxxx.h create mode 100644 include/wx/motif/icon.h create mode 100644 include/wx/motif/imaglist.h create mode 100644 include/wx/motif/joystick.h create mode 100644 include/wx/motif/listbox.h create mode 100644 include/wx/motif/listctrl.h create mode 100644 include/wx/motif/mdi.h create mode 100644 include/wx/motif/menu.h create mode 100644 include/wx/motif/metafile.h create mode 100644 include/wx/motif/minifram.h create mode 100644 include/wx/motif/msgdlg.h create mode 100644 include/wx/motif/notebook.h create mode 100644 include/wx/motif/palette.h create mode 100644 include/wx/motif/pen.h create mode 100644 include/wx/motif/print.h create mode 100644 include/wx/motif/printdlg.h create mode 100644 include/wx/motif/private.h create mode 100644 include/wx/motif/radiobox.h create mode 100644 include/wx/motif/radiobut.h create mode 100644 include/wx/motif/region.h create mode 100644 include/wx/motif/scrolbar.h create mode 100644 include/wx/motif/settings.h create mode 100644 include/wx/motif/setup.h create mode 100644 include/wx/motif/slider.h create mode 100644 include/wx/motif/spinbutt.h create mode 100644 include/wx/motif/statbmp.h create mode 100644 include/wx/motif/statbox.h create mode 100644 include/wx/motif/stattext.h create mode 100644 include/wx/motif/statusbr.h create mode 100644 include/wx/motif/tabctrl.h create mode 100644 include/wx/motif/taskbar.h create mode 100644 include/wx/motif/textctrl.h create mode 100644 include/wx/motif/timer.h create mode 100644 include/wx/motif/toolbar.h create mode 100644 include/wx/motif/treectrl.h create mode 100644 include/wx/motif/wave.h create mode 100644 include/wx/motif/window.h diff --git a/include/wx/motif/accel.h b/include/wx/motif/accel.h new file mode 100644 index 0000000000..3e8da6784a --- /dev/null +++ b/include/wx/motif/accel.h @@ -0,0 +1,80 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: accel.h +// Purpose: wxAcceleratorTable class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_NONE 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_ diff --git a/include/wx/motif/app.h b/include/wx/motif/app.h new file mode 100644 index 0000000000..1c7035aa08 --- /dev/null +++ b/include/wx/motif/app.h @@ -0,0 +1,166 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: app.h +// Purpose: wxApp class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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; }; + + // Create an application context + virtual bool OnInitGui(); + + // 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(); + + // Motif-specific + inline WXAppContext GetAppContext() const { return m_appContext; } + inline WXWidget GetTopLevelWidget() const { return m_topLevelWidget; } + WXColormap GetMainColormap(WXDisplay* display) ; + inline long GetMaxRequestSize() const { return m_maxRequestSize; } + + // This handler is called when a property change event occurs + virtual void HandlePropertyChange(WXEvent *event); + +public: + static long sm_lastMessageTime; + int m_nCmdShow; + +protected: + bool m_keepGoing ; + +// Motif-specific + WXAppContext m_appContext; + WXWidget m_topLevelWidget; + WXColormap m_mainColormap; + long m_maxRequestSize; + +DECLARE_EVENT_TABLE() +}; + +int WXDLLEXPORT wxEntry( int argc, char *argv[] ); + +#endif + // _WX_APP_H_ + diff --git a/include/wx/motif/bitmap.h b/include/wx/motif/bitmap.h new file mode 100644 index 0000000000..104ec5beb3 --- /dev/null +++ b/include/wx/motif/bitmap.h @@ -0,0 +1,198 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: bitmap.h +// Purpose: wxBitmap class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_BITMAP_H_ +#define _WX_BITMAP_H_ + +#ifdef __GNUG__ +#pragma interface "bitmap.h" +#endif + +#include "wx/gdiobj.h" +#include "wx/gdicmn.h" +#include "wx/palette.h" + +// Bitmap +class WXDLLEXPORT wxDC; +class WXDLLEXPORT wxControl; +class WXDLLEXPORT wxBitmap; +class WXDLLEXPORT wxBitmapHandler; +class WXDLLEXPORT wxIcon; +class WXDLLEXPORT wxCursor; + +// A mask is a mono bitmap used for drawing bitmaps +// transparently. +class WXDLLEXPORT wxMask: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxMask) + +public: + wxMask(); + + // Construct a mask from a bitmap and a colour indicating + // the transparent area + wxMask(const wxBitmap& bitmap, const wxColour& colour); + + // Construct a mask from a bitmap and a palette index indicating + // the transparent area + wxMask(const wxBitmap& bitmap, int paletteIndex); + + // Construct a mask from a mono bitmap (copies the bitmap). + wxMask(const wxBitmap& bitmap); + + ~wxMask(); + + bool Create(const wxBitmap& bitmap, const wxColour& colour); + bool Create(const wxBitmap& bitmap, int paletteIndex); + bool Create(const wxBitmap& bitmap); + +/* TODO: platform-specific data access + // Implementation + inline WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; } + inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; } +protected: + WXHBITMAP m_maskBitmap; +*/ +}; + +class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData +{ + friend class WXDLLEXPORT wxBitmap; + friend class WXDLLEXPORT wxIcon; + friend class WXDLLEXPORT wxCursor; +public: + wxBitmapRefData(); + ~wxBitmapRefData(); + +public: + int m_width; + int m_height; + int m_depth; + bool m_ok; + int m_numColors; + wxPalette m_bitmapPalette; + int m_quality; + +/* WXHBITMAP m_hBitmap; TODO: platform-specific handle */ + wxMask * m_bitmapMask; // Optional mask +}; + +#define M_BITMAPDATA ((wxBitmapRefData *)m_refData) + +class WXDLLEXPORT wxBitmapHandler: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxBitmapHandler) +public: + wxBitmapHandler() { m_name = ""; m_extension = ""; m_type = 0; }; + + virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1); + virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, + int desiredWidth, int desiredHeight); + virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL); + + inline void SetName(const wxString& name) { m_name = name; } + inline void SetExtension(const wxString& ext) { m_extension = ext; } + inline void SetType(long type) { m_type = type; } + inline wxString GetName() const { return m_name; } + inline wxString GetExtension() const { return m_extension; } + inline long GetType() const { return m_type; } +protected: + wxString m_name; + wxString m_extension; + long m_type; +}; + +#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData()) + +class WXDLLEXPORT wxBitmap: public wxGDIObject +{ + DECLARE_DYNAMIC_CLASS(wxBitmap) + + friend class WXDLLEXPORT wxBitmapHandler; + +public: + wxBitmap(); // Platform-specific + + // Copy constructors + inline wxBitmap(const wxBitmap& bitmap) + { Ref(bitmap); if ( wxTheBitmapList ) wxTheBitmapList->AddBitmap(this); } + inline wxBitmap(const wxBitmap* bitmap) { if (bitmap) Ref(*bitmap); if ( wxTheBitmapList ) wxTheBitmapList->AddBitmap(this); } + + // Initialize with raw data. + wxBitmap(const char bits[], int width, int height, int depth = 1); + +/* TODO: maybe implement XPM reading + // Initialize with XPM data + wxBitmap(const char **data); +*/ + + // Load a file or resource + // TODO: make default type whatever's appropriate for the platform. + wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE); + + // Constructor for generalised creation from data + wxBitmap(void *data, long type, int width, int height, int depth = 1); + + // If depth is omitted, will create a bitmap compatible with the display + wxBitmap(int width, int height, int depth = -1); + ~wxBitmap(); + + virtual bool Create(int width, int height, int depth = -1); + virtual bool Create(void *data, long type, int width, int height, int depth = 1); + virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE); + virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL); + + inline bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); } + inline int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); } + inline int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); } + inline int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); } + inline int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); } + void SetWidth(int w); + void SetHeight(int h); + void SetDepth(int d); + void SetQuality(int q); + void SetOk(bool isOk); + + inline wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (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_ diff --git a/include/wx/motif/bmpbuttn.h b/include/wx/motif/bmpbuttn.h new file mode 100644 index 0000000000..8dcb69598f --- /dev/null +++ b/include/wx/motif/bmpbuttn.h @@ -0,0 +1,83 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: bmpbuttn.h +// Purpose: wxBitmapButton class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_BMPBUTTN_H_ +#define _WX_BMPBUTTN_H_ + +#ifdef __GNUG__ +#pragma interface "bmpbuttn.h" +#endif + +#include "wx/button.h" + +WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr; + +#define wxDEFAULT_BUTTON_MARGIN 4 + +class WXDLLEXPORT wxBitmapButton: public wxButton +{ + DECLARE_DYNAMIC_CLASS(wxBitmapButton) + public: + inline wxBitmapButton() { m_marginX = wxDEFAULT_BUTTON_MARGIN; m_marginY = wxDEFAULT_BUTTON_MARGIN; } + inline wxBitmapButton(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxButtonNameStr) + { + Create(parent, id, bitmap, pos, size, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxButtonNameStr); + + virtual void SetLabel(const wxBitmap& bitmap) + { + SetBitmapLabel(bitmap); + } + + virtual void SetBitmapLabel(const wxBitmap& bitmap); + + inline wxBitmap& GetBitmapLabel() const { return (wxBitmap&) m_buttonBitmap; } + inline wxBitmap& GetBitmapSelected() const { return (wxBitmap&) m_buttonBitmapSelected; } + inline wxBitmap& GetBitmapFocus() const { return (wxBitmap&) m_buttonBitmapFocus; } + inline wxBitmap& GetBitmapDisabled() const { return (wxBitmap&) m_buttonBitmapDisabled; } + + inline void SetBitmapSelected(const wxBitmap& sel) { m_buttonBitmapSelected = sel; }; + inline void SetBitmapFocus(const wxBitmap& focus) { m_buttonBitmapFocus = focus; }; + inline void SetBitmapDisabled(const wxBitmap& disabled) { m_buttonBitmapDisabled = disabled; }; + + inline void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; } + inline int GetMarginX() { return m_marginX; } + inline int GetMarginY() { return m_marginY; } + +/* + // TODO: Implementation + virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item); + virtual void DrawFace( WXHDC dc, int left, int top, int right, int bottom, bool sel ); + virtual void DrawButtonFocus( WXHDC dc, int left, int top, int right, int bottom, bool sel ); + virtual void DrawButtonDisable( WXHDC dc, int left, int top, int right, int bottom, bool with_marg ); +*/ + + protected: + wxBitmap m_buttonBitmap; + wxBitmap m_buttonBitmapSelected; + wxBitmap m_buttonBitmapFocus; + wxBitmap m_buttonBitmapDisabled; + int m_marginX; + int m_marginY; +}; + +#endif + // _WX_BMPBUTTN_H_ diff --git a/include/wx/motif/brush.h b/include/wx/motif/brush.h new file mode 100644 index 0000000000..388604a61d --- /dev/null +++ b/include/wx/motif/brush.h @@ -0,0 +1,86 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: brush.h +// Purpose: wxBrush class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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 wxString& col, int style); + wxBrush(const wxBitmap& stipple); + inline wxBrush(const wxBrush& brush) { Ref(brush); } + inline wxBrush(const wxBrush* brush) { if (brush) Ref(*brush); } + ~wxBrush(); + + virtual void SetColour(const wxColour& col) ; + virtual void SetColour(const wxString& col) ; + virtual void SetColour(unsigned char r, unsigned char g, unsigned char b) ; + virtual void SetStyle(int style) ; + virtual void SetStipple(const wxBitmap& stipple) ; + + inline wxBrush& operator = (const wxBrush& brush) { if (*this == brush) return (*this); Ref(brush); return *this; } + inline bool operator == (const wxBrush& brush) { return m_refData == brush.m_refData; } + inline bool operator != (const wxBrush& brush) { return m_refData != brush.m_refData; } + + inline wxColour& GetColour() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_colour : wxNullColour); }; + inline int GetStyle() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_style : 0); }; + inline wxBitmap *GetStipple() const { return (M_BRUSHDATA ? & M_BRUSHDATA->m_stipple : 0); }; + + virtual bool Ok() const { return (m_refData != NULL) ; } + +// Implementation + + // Useful helper: create the brush resource + void RealizeResource(); + + // When setting properties, we must make sure we're not changing + // another object + void Unshare(); +}; + +#endif + // _WX_BRUSH_H_ diff --git a/include/wx/motif/button.h b/include/wx/motif/button.h new file mode 100644 index 0000000000..427b96d63b --- /dev/null +++ b/include/wx/motif/button.h @@ -0,0 +1,53 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: button.h +// Purpose: wxButton class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_BUTTON_H_ +#define _WX_BUTTON_H_ + +#ifdef __GNUG__ +#pragma interface "button.h" +#endif + +#include "wx/control.h" +#include "wx/gdicmn.h" + +WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr; + +// Pushbutton +class WXDLLEXPORT wxButton: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxButton) + public: + inline wxButton() {} + inline wxButton(wxWindow *parent, wxWindowID id, const wxString& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxButtonNameStr) + { + Create(parent, id, label, pos, size, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, const wxString& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxButtonNameStr); + + virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + virtual void SetDefault(); + virtual void SetLabel(const wxString& label); + virtual wxString GetLabel() const ; + virtual void Command(wxCommandEvent& event); +}; + +#endif + // _WX_BUTTON_H_ diff --git a/include/wx/motif/checkbox.h b/include/wx/motif/checkbox.h new file mode 100644 index 0000000000..a115d5befc --- /dev/null +++ b/include/wx/motif/checkbox.h @@ -0,0 +1,81 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: checkbox.h +// Purpose: wxCheckBox class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CHECKBOX_H_ +#define _WX_CHECKBOX_H_ + +#ifdef __GNUG__ +#pragma interface "checkbox.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxCheckBoxNameStr; + +// Checkbox item (single checkbox) +class WXDLLEXPORT wxBitmap; +class WXDLLEXPORT wxCheckBox: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxCheckBox) + + public: + inline wxCheckBox() { } + inline wxCheckBox(wxWindow *parent, wxWindowID id, const wxString& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxCheckBoxNameStr) + { + Create(parent, id, label, pos, size, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, const wxString& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxCheckBoxNameStr); + virtual void SetValue(bool); + virtual bool GetValue() const ; + virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + virtual void SetLabel(const wxString& label); + virtual void Command(wxCommandEvent& event); +}; + +class WXDLLEXPORT wxBitmapCheckBox: public wxCheckBox +{ + DECLARE_DYNAMIC_CLASS(wxBitmapCheckBox) + + public: + int checkWidth ; + int checkHeight ; + + inline wxBitmapCheckBox() { checkWidth = -1; checkHeight = -1; } + inline wxBitmapCheckBox(wxWindow *parent, wxWindowID id, const wxBitmap *label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxCheckBoxNameStr) + { + Create(parent, id, label, pos, size, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, const wxBitmap *bitmap, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxCheckBoxNameStr); + virtual void SetValue(bool); + virtual bool GetValue() const ; + virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + virtual void SetLabel(const wxBitmap *bitmap); +}; +#endif + // _WX_CHECKBOX_H_ diff --git a/include/wx/motif/checklst.h b/include/wx/motif/checklst.h new file mode 100644 index 0000000000..392737ccc1 --- /dev/null +++ b/include/wx/motif/checklst.h @@ -0,0 +1,47 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: checklst.h +// Purpose: wxCheckListBox class - a listbox with checkable items +// Note: this is an optional class. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CHECKLST_H_ +#define _WX_CHECKLST_H_ + +#ifdef __GNUG__ +#pragma interface "checklst.h" +#endif + +#include "wx/listbox.h" + +typedef unsigned int size_t; + +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_ diff --git a/include/wx/motif/choice.h b/include/wx/motif/choice.h new file mode 100644 index 0000000000..7db33d7ad4 --- /dev/null +++ b/include/wx/motif/choice.h @@ -0,0 +1,72 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: choice.h +// Purpose: wxChoice class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CHOICE_H_ +#define _WX_CHOICE_H_ + +#ifdef __GNUG__ +#pragma interface "choice.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxChoiceNameStr; + +// Choice item +class WXDLLEXPORT wxChoice: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxChoice) + + public: + inline wxChoice() { m_noStrings = 0; } + + inline wxChoice(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + int n = 0, const wxString choices[] = NULL, + long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxChoiceNameStr) + { + Create(parent, id, pos, size, n, choices, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + int n = 0, const wxString choices[] = NULL, + long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxChoiceNameStr); + + virtual void Append(const wxString& item); + virtual void Delete(int n); + virtual void Clear(); + virtual int GetSelection() const ; + virtual void SetSelection(int n); + virtual int FindString(const wxString& s) const; + virtual wxString GetString(int n) const ; + virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + virtual wxString GetStringSelection() const ; + virtual bool SetStringSelection(const wxString& sel); + + virtual inline int Number() const { return m_noStrings; } + virtual void Command(wxCommandEvent& event); + + virtual inline void SetColumns(int WXUNUSED(n) = 1 ) { /* No effect */ } ; + virtual inline int GetColumns() const { return 1 ; }; + +protected: + int m_noStrings; +}; + +#endif + // _WX_CHOICE_H_ diff --git a/include/wx/motif/clipbrd.h b/include/wx/motif/clipbrd.h new file mode 100644 index 0000000000..5c33021f49 --- /dev/null +++ b/include/wx/motif/clipbrd.h @@ -0,0 +1,104 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: clipbrd.h +// Purpose: Clipboard functionality. +// Note: this functionality is under review, and +// is derived from wxWindows 1.xx code. Please contact +// the wxWindows developers for further information. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/colordlg.h b/include/wx/motif/colordlg.h new file mode 100644 index 0000000000..58cbb11e0a --- /dev/null +++ b/include/wx/motif/colordlg.h @@ -0,0 +1,46 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: colordlg.h +// Purpose: wxColourDialog class. Use generic version if no +// platform-specific implementation. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_COLORDLG_H_ +#define _WX_COLORDLG_H_ + +#ifdef __GNUG__ +#pragma interface "colordlg.h" +#endif + +#include "wx/setup.h" +#include "wx/dialog.h" +#include "wx/cmndata.h" + +/* + * Platform-specific colour dialog implementation + */ + +class WXDLLEXPORT wxColourDialog: public wxDialog +{ +DECLARE_DYNAMIC_CLASS(wxColourDialog) +public: + wxColourDialog(); + wxColourDialog(wxWindow *parent, wxColourData *data = NULL); + + bool Create(wxWindow *parent, wxColourData *data = NULL); + + int ShowModal(); + wxColourData& GetColourData() { return m_colourData; } + +protected: + wxColourData m_colourData; + wxWindow* m_dialogParent; +}; + +#endif + // _WX_COLORDLG_H_ diff --git a/include/wx/motif/colour.h b/include/wx/motif/colour.h new file mode 100644 index 0000000000..28cd535080 --- /dev/null +++ b/include/wx/motif/colour.h @@ -0,0 +1,73 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: colour.h +// Purpose: wxColour class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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 +{ + DECLARE_DYNAMIC_CLASS(wxColour) +public: + wxColour(); + wxColour(unsigned char r, unsigned char g, unsigned char b); + wxColour(unsigned long colRGB) { Set(colRGB); } + wxColour(const wxColour& col); + wxColour(const wxString& col); + ~wxColour() ; + wxColour& operator =(const wxColour& src) ; + wxColour& operator =(const wxString& src) ; + inline int Ok() const { return (m_isInit) ; } + + void Set(unsigned char r, unsigned char g, unsigned char b); + void Set(unsigned long colRGB) + { + // we don't need to know sizeof(long) here because we assume that the three + // least significant bytes contain the R, G and B values + Set((unsigned char)colRGB, + (unsigned char)(colRGB >> 8), + (unsigned char)(colRGB >> 16)); + } + + inline unsigned char Red() const { return m_red; } + inline unsigned char Green() const { return m_green; } + inline unsigned char Blue() const { return m_blue; } + + inline bool operator == (const wxColour& colour) { return (m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue); } + + inline bool operator != (const wxColour& colour) { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); } + +/* 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 ; +*/ +}; + +#define wxColor wxColour + +#endif + // _WX_COLOUR_H_ diff --git a/include/wx/motif/combobox.h b/include/wx/motif/combobox.h new file mode 100644 index 0000000000..885d461be0 --- /dev/null +++ b/include/wx/motif/combobox.h @@ -0,0 +1,78 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: combobox.h +// Purpose: wxComboBox class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_COMBOBOX_H_ +#define _WX_COMBOBOX_H_ + +#ifdef __GNUG__ +#pragma interface "combobox.h" +#endif + +#include "wx/choice.h" + +WXDLLEXPORT_DATA(extern const char*) wxComboBoxNameStr; +WXDLLEXPORT_DATA(extern const char*) wxEmptyString; + +// Combobox item +class WXDLLEXPORT wxComboBox: public wxChoice +{ + DECLARE_DYNAMIC_CLASS(wxComboBox) + + public: + inline wxComboBox() {} + + inline wxComboBox(wxWindow *parent, wxWindowID id, + const wxString& value = wxEmptyString, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + int n = 0, const wxString choices[] = NULL, + long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxComboBoxNameStr) + { + Create(parent, id, value, pos, size, n, choices, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, + const wxString& value = wxEmptyString, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + int n = 0, const wxString choices[] = NULL, + long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxComboBoxNameStr); + + // List functions: see wxChoice + + // Text field functions + virtual wxString GetValue() const ; + virtual void SetValue(const wxString& value); + + // Clipboard operations + virtual void Copy(); + virtual void Cut(); + virtual void Paste(); + virtual void SetInsertionPoint(long pos); + virtual void SetInsertionPointEnd(); + virtual long GetInsertionPoint() const ; + virtual long GetLastPosition() const ; + virtual void Replace(long from, long to, const wxString& value); + virtual void Remove(long from, long to); + virtual void SetSelection(int n) + { + wxChoice::SetSelection(n); + } + virtual void SetSelection(long from, long to); + virtual void SetEditable(bool editable); +}; + +#endif + // _WX_COMBOBOX_H_ diff --git a/include/wx/motif/control.h b/include/wx/motif/control.h new file mode 100644 index 0000000000..4913175b71 --- /dev/null +++ b/include/wx/motif/control.h @@ -0,0 +1,50 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: control.h +// Purpose: wxControl class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/cursor.h b/include/wx/motif/cursor.h new file mode 100644 index 0000000000..3db0a16fe7 --- /dev/null +++ b/include/wx/motif/cursor.h @@ -0,0 +1,76 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: cursor.h +// Purpose: wxCursor class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_CURSOR_H_ +#define _WX_CURSOR_H_ + +#ifdef __GNUG__ +#pragma interface "cursor.h" +#endif + +#include "wx/bitmap.h" + +class WXDLLEXPORT wxCursorRefData: public wxBitmapRefData +{ + friend class WXDLLEXPORT wxBitmap; + friend class WXDLLEXPORT wxCursor; +public: + wxCursorRefData(); + ~wxCursorRefData(); + +protected: +/* TODO: implementation + WXHCURSOR m_hCursor; +*/ +}; + +#define M_CURSORDATA ((wxCursorRefData *)m_refData) +#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData) + +// Cursor +class WXDLLEXPORT wxCursor: public wxBitmap +{ + DECLARE_DYNAMIC_CLASS(wxCursor) + +public: + wxCursor(); + + // Copy constructors + inline wxCursor(const wxCursor& cursor) { Ref(cursor); } + inline wxCursor(const wxCursor* cursor) { if (cursor) Ref(*cursor); } + + wxCursor(const char bits[], int width, int height, int hotSpotX = -1, int hotSpotY = -1, + const char maskBits[] = NULL); + + /* TODO: make default type suit platform */ + wxCursor(const wxString& name, long flags = wxBITMAP_TYPE_CUR_RESOURCE, + int hotSpotX = 0, int hotSpotY = 0); + + wxCursor(int cursor_type); + ~wxCursor(); + + // 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_ diff --git a/include/wx/motif/dc.h b/include/wx/motif/dc.h new file mode 100644 index 0000000000..3b668ce02d --- /dev/null +++ b/include/wx/motif/dc.h @@ -0,0 +1,376 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dc.h +// Purpose: wxDC class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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, 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, (wxColour*) & 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 ); + 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); + } + + virtual void DrawOpenSpline( wxList *points ) = 0; + + 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_ diff --git a/include/wx/motif/dcclient.h b/include/wx/motif/dcclient.h new file mode 100644 index 0000000000..ed895a982b --- /dev/null +++ b/include/wx/motif/dcclient.h @@ -0,0 +1,101 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcclient.h +// Purpose: wxClientDC, wxPaintDC and wxWindowDC classes +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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. + +typedef wxPaintDC wxClientDC; +typedef wxPaintDC wxWindowDC; + +//----------------------------------------------------------------------------- +// wxPaintDC +//----------------------------------------------------------------------------- + +class WXDLLEXPORT wxPaintDC: public wxDC +{ + DECLARE_DYNAMIC_CLASS(wxPaintDC) + + public: + + wxPaintDC(void); + wxPaintDC( wxWindow *win ); + + ~wxPaintDC(void); + + virtual void FloodFill( long x1, long y1, 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 DestroyClippingRegion(void); + + virtual void DrawOpenSpline( wxList *points ); +}; + +#endif + // _WX_DCCLIENT_H_ diff --git a/include/wx/motif/dcmemory.h b/include/wx/motif/dcmemory.h new file mode 100644 index 0000000000..c576655b05 --- /dev/null +++ b/include/wx/motif/dcmemory.h @@ -0,0 +1,38 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcmemory.h +// Purpose: wxMemoryDC class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/dcprint.h b/include/wx/motif/dcprint.h new file mode 100644 index 0000000000..d46260ffce --- /dev/null +++ b/include/wx/motif/dcprint.h @@ -0,0 +1,34 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcprint.h +// Purpose: wxPrinterDC class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_DCPRINT_H_ +#define _WX_DCPRINT_H_ + +#ifdef __GNUG__ +#pragma interface "dcprint.h" +#endif + +#include "wx/dc.h" + +class WXDLLEXPORT wxPrinterDC: public wxDC +{ + public: + DECLARE_CLASS(wxPrinterDC) + + // Create a printer DC + wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output, bool interactive = TRUE, int orientation = wxPORTRAIT); + + ~wxPrinterDC(); +}; + +#endif + // _WX_DCPRINT_H_ + diff --git a/include/wx/motif/dcscreen.h b/include/wx/motif/dcscreen.h new file mode 100644 index 0000000000..ebd022e76b --- /dev/null +++ b/include/wx/motif/dcscreen.h @@ -0,0 +1,39 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcscreen.h +// Purpose: wxScreenDC class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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 wxPaintDC +{ + DECLARE_DYNAMIC_CLASS(wxScreenDC) + + public: + // Create a DC representing the whole screen + wxScreenDC(); + ~wxScreenDC(); + + // Compatibility with X's requirements for + // drawing on top of all windows + static bool StartDrawingOnTop(wxWindow* WXUNUSED(window)) { return TRUE; } + static bool StartDrawingOnTop(wxRectangle* WXUNUSED(rect) = NULL) { return TRUE; } + static bool EndDrawingOnTop() { return TRUE; } +}; + +#endif + // _WX_DCSCREEN_H_ + diff --git a/include/wx/motif/dialog.h b/include/wx/motif/dialog.h new file mode 100644 index 0000000000..49abbd23d0 --- /dev/null +++ b/include/wx/motif/dialog.h @@ -0,0 +1,98 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dialog.h +// Purpose: wxDialog class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/dirdlg.h b/include/wx/motif/dirdlg.h new file mode 100644 index 0000000000..b27cb74466 --- /dev/null +++ b/include/wx/motif/dirdlg.h @@ -0,0 +1,49 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dirdlg.h +// Purpose: wxDirDialog class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/dnd.h b/include/wx/motif/dnd.h new file mode 100644 index 0000000000..73a97d253c --- /dev/null +++ b/include/wx/motif/dnd.h @@ -0,0 +1,238 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: dnd.h +// Purpose: Declaration of the wxDropTarget, wxDropSource class etc. +// Author: Julian Smart +// RCS-ID: $Id$ +// Copyright: (c) 1998 Julian Smart +// 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_ + diff --git a/include/wx/motif/filedlg.h b/include/wx/motif/filedlg.h new file mode 100644 index 0000000000..d7f59d44f0 --- /dev/null +++ b/include/wx/motif/filedlg.h @@ -0,0 +1,89 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: filedlg.h +// Purpose: wxFileDialog class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_FILEDLG_H_ +#define _WX_FILEDLG_H_ + +#ifdef __GNUG__ +#pragma interface "filedlg.h" +#endif + +#include "wx/dialog.h" + +/* + * File selector + */ + +WXDLLEXPORT_DATA(extern const char*) wxFileSelectorPromptStr; +WXDLLEXPORT_DATA(extern const char*) wxFileSelectorDefaultWildcardStr; + +class WXDLLEXPORT wxFileDialog: public wxDialog +{ +DECLARE_DYNAMIC_CLASS(wxFileDialog) +protected: + wxString m_message; + long m_dialogStyle; + wxWindow * m_parent; + wxString m_dir; + wxString m_path; // Full path + wxString m_fileName; + wxString m_wildCard; + int m_filterIndex; +public: + wxFileDialog(wxWindow *parent, const wxString& message = wxFileSelectorPromptStr, + const wxString& defaultDir = "", const wxString& defaultFile = "", const wxString& wildCard = wxFileSelectorDefaultWildcardStr, + long style = 0, const wxPoint& pos = wxDefaultPosition); + + inline void SetMessage(const wxString& message) { m_message = message; } + inline void SetPath(const wxString& path) { m_path = path; } + inline void SetDirectory(const wxString& dir) { m_dir = dir; } + inline void SetFilename(const wxString& name) { m_fileName = name; } + inline void SetWildcard(const wxString& wildCard) { m_wildCard = wildCard; } + inline void SetStyle(long style) { m_dialogStyle = style; } + inline void SetFilterIndex(int filterIndex) { m_filterIndex = filterIndex; } + + inline wxString GetMessage() const { return m_message; } + inline wxString GetPath() const { return m_path; } + inline wxString GetDirectory() const { return m_dir; } + inline wxString GetFilename() const { return m_fileName; } + inline wxString GetWildcard() const { return m_wildCard; } + inline long GetStyle() const { return m_dialogStyle; } + inline int GetFilterIndex() const { return m_filterIndex ; } + + int ShowModal(); +}; + +#define wxOPEN 0x0001 +#define wxSAVE 0x0002 +#define wxOVERWRITE_PROMPT 0x0004 +#define wxHIDE_READONLY 0x0008 +#define wxFILE_MUST_EXIST 0x0010 + +// File selector - backward compatibility +char* WXDLLEXPORT wxFileSelector(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL, + const char *default_filename = NULL, const char *default_extension = NULL, + const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0, + wxWindow *parent = NULL, int x = -1, int y = -1); + +// An extended version of wxFileSelector +char* WXDLLEXPORT wxFileSelectorEx(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL, + const char *default_filename = NULL, int *indexDefaultExtension = NULL, + const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0, + wxWindow *parent = NULL, int x = -1, int y = -1); + +// Generic file load dialog +char* WXDLLEXPORT wxLoadFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL); + +// Generic file save dialog +char* WXDLLEXPORT wxSaveFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL); + +#endif + // _WX_FILEDLG_H_ diff --git a/include/wx/motif/font.h b/include/wx/motif/font.h new file mode 100644 index 0000000000..8fb340bbb6 --- /dev/null +++ b/include/wx/motif/font.h @@ -0,0 +1,90 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: font.h +// Purpose: wxFont class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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); } + inline wxFont(const wxFont* font) { if (font) Ref(*font); } + + ~wxFont(); + + bool Create(int pointSize, int family, int style, int weight, bool underlined = FALSE, const wxString& faceName = wxEmptyString); + + virtual bool Ok() const { return (m_refData != NULL) ; } + + inline int GetPointSize() const { return M_FONTDATA->m_pointSize; } + inline int GetFamily() const { return M_FONTDATA->m_family; } + inline int GetStyle() const { return M_FONTDATA->m_style; } + inline int GetWeight() const { return M_FONTDATA->m_weight; } + wxString GetFamilyString() const ; + wxString GetFaceName() const ; + wxString GetStyleString() const ; + wxString GetWeightString() const ; + inline bool GetUnderlined() const { return M_FONTDATA->m_underlined; } + + void SetPointSize(int pointSize); + void SetFamily(int family); + void SetStyle(int style); + void SetWeight(int weight); + void SetFaceName(const wxString& faceName); + void SetUnderlined(bool underlined); + + inline wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; } + inline bool operator == (const wxFont& font) { return m_refData == font.m_refData; } + inline bool operator != (const wxFont& font) { return m_refData != font.m_refData; } + + // Implementation +protected: + bool RealizeResource(); + void Unshare(); +}; + +#endif + // _WX_FONT_H_ diff --git a/include/wx/motif/fontdlg.h b/include/wx/motif/fontdlg.h new file mode 100644 index 0000000000..ca799d759a --- /dev/null +++ b/include/wx/motif/fontdlg.h @@ -0,0 +1,46 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: fontdlg.h +// Purpose: wxFontDialog class. Use generic version if no +// platform-specific implementation. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_FONTDLG_H_ +#define _WX_FONTDLG_H_ + +#ifdef __GNUG__ +#pragma interface "fontdlg.h" +#endif + +#include "wx/dialog.h" +#include "wx/cmndata.h" + +/* + * Font dialog + */ + +class WXDLLEXPORT wxFontDialog: public wxDialog +{ +DECLARE_DYNAMIC_CLASS(wxFontDialog) +public: + wxFontDialog(); + wxFontDialog(wxWindow *parent, wxFontData *data = NULL); + + bool Create(wxWindow *parent, wxFontData *data = NULL); + + int ShowModal(); + wxFontData& GetFontData() { return m_fontData; } + +protected: + wxWindow* m_dialogParent; + wxFontData m_fontData; +}; + +#endif + // _WX_FONTDLG_H_ + diff --git a/include/wx/motif/frame.h b/include/wx/motif/frame.h new file mode 100644 index 0000000000..bb719ddac5 --- /dev/null +++ b/include/wx/motif/frame.h @@ -0,0 +1,179 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: frame.h +// Purpose: wxFrame class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_FRAME_H_ +#define _WX_FRAME_H_ + +#ifdef __GNUG__ +#pragma interface "frame.h" +#endif + +#include "wx/window.h" +#include "wx/toolbar.h" +#include "wx/accel.h" + +WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr; +WXDLLEXPORT_DATA(extern const char*) wxToolBarNameStr; + +class WXDLLEXPORT wxMenuBar; +class WXDLLEXPORT wxStatusBar; + +class WXDLLEXPORT wxFrame: public wxWindow { + + DECLARE_DYNAMIC_CLASS(wxFrame) + +public: + wxFrame(); + inline wxFrame(wxWindow *parent, + wxWindowID id, + const wxString& title, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxDEFAULT_FRAME_STYLE, + const wxString& name = wxFrameNameStr) + { + Create(parent, id, title, pos, size, style, name); + } + + ~wxFrame(); + + bool Create(wxWindow *parent, + wxWindowID id, + const wxString& title, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxDEFAULT_FRAME_STYLE, + const wxString& name = wxFrameNameStr); + + virtual bool Destroy(); + void SetClientSize(int width, int height); + void GetClientSize(int *width, int *height) const; + + void GetSize(int *width, int *height) const ; + void GetPosition(int *x, int *y) const ; + void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + + virtual bool OnClose(); + + void OnSize(wxSizeEvent& event); + void OnMenuHighlight(wxMenuEvent& event); + void OnActivate(wxActivateEvent& event); + void OnIdle(wxIdleEvent& event); + void OnCloseWindow(wxCloseEvent& event); + + bool Show(bool show); + + // Set menu bar + void SetMenuBar(wxMenuBar *menu_bar); + virtual wxMenuBar *GetMenuBar() const ; + + // Set title + void SetTitle(const wxString& title); + inline wxString GetTitle() const { return m_title; } + + 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 void SetToolBar(wxToolBar *toolbar) ; + virtual wxToolBar *GetToolBar() const ; + virtual void PositionToolBar(); + + // Set status line text + virtual void SetStatusText(const wxString& text, int number = 0); + + // Set status line widths + virtual void SetStatusWidths(int n, const int widths_field[]); + + // Hint to tell framework which status bar to use + // TODO: should this go into a wxFrameworkSettings class perhaps? + static void UseNativeStatusBar(bool useNative) { m_useNativeStatusBar = useNative; }; + static bool UsesNativeStatusBar() { return m_useNativeStatusBar; }; + + // Fit frame around subwindows + virtual void Fit(); + + // Iconize + virtual void Iconize(bool iconize); + + virtual bool IsIconized() const ; + + // Compatibility + inline bool Iconized() const { return IsIconized(); } + + virtual void Maximize(bool maximize); + + // 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; + + virtual void Raise(); + virtual void Lower(); + + virtual void CaptureMouse(); + virtual void ReleaseMouse(); + + //// Motif-specific + + WXWidget GetMenuBarWidget() const ; + WXWidget GetShellWidget() const { return m_frameShell; } + WXWidget GetWorkAreaWidget() const { return m_workArea; } + WXWidget GetClientAreaWidget() const { return m_clientArea; } + bool GetVisibleStatus() const { return m_visibleStatus; } + + bool PreResize(); + +protected: + wxMenuBar * m_frameMenuBar; + wxStatusBar * m_frameStatusBar; + wxIcon m_icon; + bool m_iconized; + static bool m_useNativeStatusBar; + wxToolBar * m_frameToolBar ; + + //// Motif-specific + + WXWidget m_frameShell; + WXWidget m_frameWidget; + WXWidget m_workArea; + WXWidget m_clientArea; +// WXWidget m_menuBarWidget; + bool m_visibleStatus; + wxString m_title; + + DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_FRAME_H_ diff --git a/include/wx/motif/gauge.h b/include/wx/motif/gauge.h new file mode 100644 index 0000000000..13eddaecae --- /dev/null +++ b/include/wx/motif/gauge.h @@ -0,0 +1,69 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: gauge.h +// Purpose: wxGauge class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_GAUGE_H_ +#define _WX_GAUGE_H_ + +#ifdef __GNUG__ +#pragma interface "gauge.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxGaugeNameStr; + +// Group box +class WXDLLEXPORT wxGauge: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxGauge) + public: + inline wxGauge() { m_rangeMax = 0; m_gaugePos = 0; } + + inline wxGauge(wxWindow *parent, wxWindowID id, + int range, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxGA_HORIZONTAL, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxGaugeNameStr) + { + Create(parent, id, range, pos, size, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, + int range, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxGA_HORIZONTAL, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxGaugeNameStr); + + void SetShadowWidth(int w); + void SetBezelFace(int w); + void SetRange(int r); + void SetValue(int pos); + + int GetShadowWidth() const ; + int GetBezelFace() const ; + int GetRange() const ; + int GetValue() const ; + + void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + + virtual void Command(wxCommandEvent& WXUNUSED(event)) {} ; + + protected: + int m_rangeMax; + int m_gaugePos; +}; + +#endif + // _WX_GAUGE_H_ diff --git a/include/wx/motif/gdiobj.h b/include/wx/motif/gdiobj.h new file mode 100644 index 0000000000..c25575dffc --- /dev/null +++ b/include/wx/motif/gdiobj.h @@ -0,0 +1,48 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: gdiobj.h +// Purpose: wxGDIObject class: base class for other GDI classes +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_GDIOBJ_H_ +#define _WX_GDIOBJ_H_ + +#include "wx/object.h" + +#ifdef __GNUG__ +#pragma interface "gdiobj.h" +#endif + +class WXDLLEXPORT wxGDIRefData: public wxObjectRefData { +public: + inline wxGDIRefData() + { + } +}; + +#define M_GDIDATA ((wxGDIRefData *)m_refData) + +class WXDLLEXPORT wxGDIObject: public wxObject +{ +DECLARE_DYNAMIC_CLASS(wxGDIObject) + public: + inline wxGDIObject() { m_visible = FALSE; }; + inline ~wxGDIObject() {}; + + inline bool IsNull() const { return (m_refData == 0); } + + virtual bool GetVisible() { return m_visible; } + virtual void SetVisible(bool v) { m_visible = v; } + +protected: + bool m_visible; // Can a pointer to this object be safely taken? + // - only if created within FindOrCreate... +}; + +#endif + // _WX_GDIOBJ_H_ diff --git a/include/wx/motif/helpxxxx.h b/include/wx/motif/helpxxxx.h new file mode 100644 index 0000000000..fc991a93b3 --- /dev/null +++ b/include/wx/motif/helpxxxx.h @@ -0,0 +1,52 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: helpxxxx.h +// Purpose: Help system: native implementation for your system. Replace +// XXXX with suitable name. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_HELPXXXX_H_ +#define _WX_HELPXXXX_H_ + +#ifdef __GNUG__ +#pragma interface "helpxxxx.h" +#endif + +#include "wx/wx.h" + +#include "wx/helpbase.h" + +class WXDLLEXPORT wxXXXXHelpController: public wxHelpControllerBase +{ + DECLARE_CLASS(wxXXXXHelpController) + + public: + wxXXXXHelpController(); + ~wxXXXXHelpController(); + + // Must call this to set the filename and server name + virtual bool Initialize(const wxString& file); + + // If file is "", reloads file given in Initialize + virtual bool LoadFile(const wxString& file = ""); + virtual bool DisplayContents(); + virtual bool DisplaySection(int sectionNo); + virtual bool DisplayBlock(long blockNo); + virtual bool KeywordSearch(const wxString& k); + + virtual bool Quit(); + virtual void OnQuit(); + + inline wxString GetHelpFile() const { return m_helpFile; } + +protected: + wxString m_helpFile; +}; + +#endif + // _WX_HELPXXXX_H_ diff --git a/include/wx/motif/icon.h b/include/wx/motif/icon.h new file mode 100644 index 0000000000..48ebe34c5e --- /dev/null +++ b/include/wx/motif/icon.h @@ -0,0 +1,107 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: icon.h +// Purpose: wxIcon class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_ICON_H_ +#define _WX_ICON_H_ + +#ifdef __GNUG__ +#pragma interface "icon.h" +#endif + +#include "wx/bitmap.h" + +class WXDLLEXPORT wxIconRefData: public wxBitmapRefData +{ + friend class WXDLLEXPORT wxBitmap; + friend class WXDLLEXPORT wxIcon; +public: + wxIconRefData(); + ~wxIconRefData(); + +public: +/* TODO: whatever your actual icon handle is + WXHICON m_hIcon; +*/ +}; + +#define M_ICONDATA ((wxIconRefData *)m_refData) +#define M_ICONHANDLERDATA ((wxIconRefData *)bitmap->GetRefData()) + +// Icon +class WXDLLEXPORT wxIcon: public wxBitmap +{ + DECLARE_DYNAMIC_CLASS(wxIcon) + +public: + wxIcon(); + + // Copy constructors + inline wxIcon(const wxIcon& icon) { Ref(icon); } + inline wxIcon(const wxIcon* icon) { if (icon) Ref(*icon); } + + wxIcon(const char bits[], int width, int height); + wxIcon(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE, + int desiredWidth = -1, int desiredHeight = -1); + ~wxIcon(); + + bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE, + int desiredWidth = -1, int desiredHeight = -1); + + inline wxIcon& operator = (const wxIcon& icon) { if (*this == icon) return (*this); Ref(icon); return *this; } + inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; } + inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; } + +/* TODO: implementation + void SetHICON(WXHICON ico); + inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); } +*/ + +/* TODO */ + virtual bool Ok() const { return (m_refData != NULL) ; } +}; + +/* Example handlers. TODO: write your own handlers for relevant types. + +class WXDLLEXPORT wxICOFileHandler: public wxBitmapHandler +{ + DECLARE_DYNAMIC_CLASS(wxICOFileHandler) +public: + inline wxICOFileHandler() + { + m_name = "ICO icon file"; + m_extension = "ico"; + m_type = wxBITMAP_TYPE_ICO; + }; + + virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, + int desiredWidth = -1, int desiredHeight = -1); +}; + +class WXDLLEXPORT wxICOResourceHandler: public wxBitmapHandler +{ + DECLARE_DYNAMIC_CLASS(wxICOResourceHandler) +public: + inline wxICOResourceHandler() + { + m_name = "ICO resource"; + m_extension = "ico"; + m_type = wxBITMAP_TYPE_ICO_RESOURCE; + }; + + virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, + int desiredWidth = -1, int desiredHeight = -1); + +}; + +*/ + +#endif + // _WX_ICON_H_ diff --git a/include/wx/motif/imaglist.h b/include/wx/motif/imaglist.h new file mode 100644 index 0000000000..37bd8ec64b --- /dev/null +++ b/include/wx/motif/imaglist.h @@ -0,0 +1,145 @@ +///////////////////////////////////////////////////////////////////////////// +// 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: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_IMAGLIST_H_ +#define _WX_IMAGLIST_H_ + +#ifdef __GNUG__ +#pragma interface "imaglist.h" +#endif + +#include "wx/bitmap.h" + +/* + * wxImageList is used for wxListCtrl, wxTreeCtrl. These controls refer to + * images for their items by an index into an image list. + * A wxImageList is capable of creating images with optional masks from + * a variety of sources - a single bitmap plus a colour to indicate the mask, + * two bitmaps, or an icon. + * + */ + +// Flags for Draw +#define wxIMAGELIST_DRAW_NORMAL 0x0001 +#define wxIMAGELIST_DRAW_TRANSPARENT 0x0002 +#define wxIMAGELIST_DRAW_SELECTED 0x0004 +#define wxIMAGELIST_DRAW_FOCUSED 0x0008 + +// Flag values for Set/GetImageList +enum { + wxIMAGE_LIST_NORMAL, // Normal icons + wxIMAGE_LIST_SMALL, // Small icons + wxIMAGE_LIST_STATE // State icons: unimplemented (see WIN32 documentation) +}; + +// Eventually we'll make this a reference-counted wxGDIObject. For +// now, the app must take care of ownership issues. That is, the +// image lists must be explicitly deleted after the control(s) that uses them +// is (are) deleted, or when the app exits. +class WXDLLEXPORT wxImageList: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxImageList) + public: + /* + * Public interface + */ + + wxImageList(); + + // Creates an image list. + // Specify the width and height of the images in the list, + // whether there are masks associated with them (e.g. if creating images + // from icons), and the initial size of the list. + inline wxImageList(int width, int height, bool mask = TRUE, int initialCount = 1) + { + Create(width, height, mask, initialCount); + } + ~wxImageList(); + + + // Attributes + //////////////////////////////////////////////////////////////////////////// + + // Returns the number of images in the image list. + int GetImageCount() const; + + // Operations + //////////////////////////////////////////////////////////////////////////// + + // Creates an image list + // width, height specify the size of the images in the list (all the same). + // mask specifies whether the images have masks or not. + // initialNumber is the initial number of images to reserve. + bool Create(int width, int height, bool mask = TRUE, int initialNumber = 1); + + // Adds a bitmap, and optionally a mask bitmap. + // Note that wxImageList creates *new* bitmaps, so you may delete + // 'bitmap' and 'mask' after calling Add. + int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap); + + // Adds a bitmap, using the specified colour to create the mask bitmap + // Note that wxImageList creates *new* bitmaps, so you may delete + // 'bitmap' after calling Add. + int Add(const wxBitmap& bitmap, const wxColour& maskColour); + + // Adds a bitmap and mask from an icon. + int Add(const wxIcon& icon); + + // Replaces a bitmap, optionally passing a mask bitmap. + // Note that wxImageList creates new bitmaps, so you may delete + // 'bitmap' and 'mask' after calling Replace. + bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap); + +/* Not supported by Win95 + // Replacing a bitmap, using the specified colour to create the mask bitmap + // Note that wxImageList creates new bitmaps, so you may delete + // 'bitmap'. + bool Replace(int index, const wxBitmap& bitmap, const wxColour& maskColour); +*/ + + // Replaces a bitmap and mask from an icon. + // You can delete 'icon' after calling Replace. + bool Replace(int index, const wxIcon& icon); + + // Removes the image at the given index. + bool Remove(int index); + + // Remove all images + bool RemoveAll(); + + // Draws the given image on a dc at the specified position. + // If 'solidBackground' is TRUE, Draw sets the image list background + // colour to the background colour of the wxDC, to speed up + // drawing by eliminating masked drawing where possible. + bool Draw(int index, wxDC& dc, int x, int y, + int flags = wxIMAGELIST_DRAW_NORMAL, bool solidBackground = FALSE); + +/* TODO (optional?) + wxIcon *MakeIcon(int index); +*/ + +/* TODO + // Implementation + //////////////////////////////////////////////////////////////////////////// + + // Returns the native image list handle + inline WXHIMAGELIST GetHIMAGELIST() const { return m_hImageList; } + +protected: + WXHIMAGELIST m_hImageList; +*/ + +}; + +#endif + // _WX_IMAGLIST_H_ diff --git a/include/wx/motif/joystick.h b/include/wx/motif/joystick.h new file mode 100644 index 0000000000..cc544c4d93 --- /dev/null +++ b/include/wx/motif/joystick.h @@ -0,0 +1,93 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: joystick.h +// Purpose: wxJoystick class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_JOYSTICK_H_ +#define _WX_JOYSTICK_H_ + +#ifdef __GNUG__ +#pragma interface "joystick.h" +#endif + +#include "wx/event.h" + +class WXDLLEXPORT wxJoystick: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxJoystick) + public: + /* + * Public interface + */ + + wxJoystick(int joystick = wxJOYSTICK1) { m_joystick = joystick; }; + + // Attributes + //////////////////////////////////////////////////////////////////////////// + + wxPoint GetPosition() const; + int GetZPosition() const; + int GetButtonState() const; + int GetPOVPosition() const; + int GetPOVCTSPosition() const; + int GetRudderPosition() const; + int GetUPosition() const; + int GetVPosition() const; + int GetMovementThreshold() const; + void SetMovementThreshold(int threshold) ; + + // Capabilities + //////////////////////////////////////////////////////////////////////////// + + bool IsOk() const; // Checks that the joystick is functioning + int GetNumberJoysticks() const ; + int GetManufacturerId() const ; + int GetProductId() const ; + wxString GetProductName() const ; + int GetXMin() const; + int GetYMin() const; + int GetZMin() const; + int GetXMax() const; + int GetYMax() const; + int GetZMax() const; + int GetNumberButtons() const; + int GetNumberAxes() const; + int GetMaxButtons() const; + int GetMaxAxes() const; + int GetPollingMin() const; + int GetPollingMax() const; + int GetRudderMin() const; + int GetRudderMax() const; + int GetUMin() const; + int GetUMax() const; + int GetVMin() const; + int GetVMax() const; + + bool HasRudder() const; + bool HasZ() const; + bool HasU() const; + bool HasV() const; + bool HasPOV() const; + bool HasPOV4Dir() const; + bool HasPOVCTS() const; + + // Operations + //////////////////////////////////////////////////////////////////////////// + + // pollingFreq = 0 means that movement events are sent when above the threshold. + // If pollingFreq > 0, events are received every this many milliseconds. + bool SetCapture(wxWindow* win, int pollingFreq = 0); + bool ReleaseCapture(); + +protected: + int m_joystick; +}; + +#endif + // _WX_JOYSTICK_H_ diff --git a/include/wx/motif/listbox.h b/include/wx/motif/listbox.h new file mode 100644 index 0000000000..5ba7762189 --- /dev/null +++ b/include/wx/motif/listbox.h @@ -0,0 +1,97 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: listbox.h +// Purpose: wxListBox class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_LISTBOX_H_ +#define _WX_LISTBOX_H_ + +#ifdef __GNUG__ +#pragma interface "listbox.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxListBoxNameStr; + +// forward decl for GetSelections() +class WXDLLEXPORT wxArrayInt; + +WXDLLEXPORT_DATA(extern const char*) wxEmptyString; + +// List box item +class WXDLLEXPORT wxListBox: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxListBox) + public: + + wxListBox(); + inline wxListBox(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + int n = 0, const wxString choices[] = NULL, + long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxListBoxNameStr) + { + Create(parent, id, pos, size, n, choices, style, validator, name); + } + + bool Create(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + int n = 0, const wxString choices[] = NULL, + long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxListBoxNameStr); + + ~wxListBox(); + + virtual void Append(const wxString& item); + virtual void Append(const wxString& item, char *clientData); + virtual void Set(int n, const wxString* choices, char **clientData = NULL); + virtual int FindString(const wxString& s) const ; + virtual void Clear(); + virtual void SetSelection(int n, bool select = TRUE); + + virtual void Deselect(int n); + + // For single choice list item only + virtual int GetSelection() const ; + virtual void Delete(int n); + virtual char *GetClientData(int n) const ; + virtual void SetClientData(int n, char *clientData); + virtual void SetString(int n, const wxString& s); + + // For single or multiple choice list item + virtual int GetSelections(wxArrayInt& aSelections) const; + virtual bool Selected(int n) const ; + virtual wxString GetString(int n) const ; + virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + + // Set the specified item at the first visible item + // or scroll to max range. + virtual void SetFirstItem(int n) ; + virtual void SetFirstItem(const wxString& s) ; + + virtual void InsertItems(int nItems, const wxString items[], int pos); + + virtual wxString GetStringSelection() const ; + virtual bool SetStringSelection(const wxString& s, bool flag = TRUE); + virtual int Number() const ; + + void Command(wxCommandEvent& event); + + protected: + int m_noItems; + int m_selected; +}; + +#endif + // _WX_LISTBOX_H_ diff --git a/include/wx/motif/listctrl.h b/include/wx/motif/listctrl.h new file mode 100644 index 0000000000..5dd61342e9 --- /dev/null +++ b/include/wx/motif/listctrl.h @@ -0,0 +1,451 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: listctrl.h +// Purpose: wxListCtrl class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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, wxRectangle& rect, int code = wxLIST_RECT_BOUNDS) const ; + + // Gets the item position + bool GetItemPosition(long item, wxPoint& pos) const ; + + // Sets the item position + bool SetItemPosition(long item, const wxPoint& pos) ; + + // Gets the number of items in the list control + int GetItemCount() const; + + // Gets the number of columns in the list control + int GetColumnCount() const; + + // Retrieves the spacing between icons in pixels. + // If small is TRUE, gets the spacing for the small icon + // view, otherwise the large icon view. + int GetItemSpacing(bool isSmall) const; + + // Gets the number of selected items in the list control + int GetSelectedItemCount() const; + + // Gets the text colour of the listview + wxColour GetTextColour() const; + + // Sets the text colour of the listview + void SetTextColour(const wxColour& col); + + // Gets the index of the topmost visible item when in + // list or report view + long GetTopItem() const ; + + // Add or remove a single window style + void SetSingleStyle(long style, bool add = TRUE) ; + + // Set the whole window style + void SetWindowStyleFlag(long style) ; + + // Searches for an item, starting from 'item'. + // item can be -1 to find the first item that matches the + // specified flags. + // Returns the item or -1 if unsuccessful. + long GetNextItem(long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE) const ; + + // Implementation: converts wxWindows style to MSW style. + // Can be a single style flag or a bit list. + // oldStyle is 'normalised' so that it doesn't contain + // conflicting styles. + long ConvertToMSWStyle(long& oldStyle, long style) const; + + // Gets one of the three image lists + wxImageList *GetImageList(int which) const ; + + // Sets the image list + // N.B. There's a quirk in the Win95 list view implementation. + // If in wxLC_LIST mode, it'll *still* display images by the labels if + // there's a small-icon image list set for the control - even though you + // haven't specified wxLIST_MASK_IMAGE when inserting. + // So you have to set a NULL small-icon image list to be sure that + // the wxLC_LIST mode works without icons. Of course, you may want icons... + void SetImageList(wxImageList *imageList, int which) ; + + // Operations + //////////////////////////////////////////////////////////////////////////// + + // Arranges the items + bool Arrange(int flag = wxLIST_ALIGN_DEFAULT); + + // Deletes an item + bool DeleteItem(long item); + + // Deletes all items + bool DeleteAllItems() ; + + // Deletes a column + bool DeleteColumn(int col); + + // Deletes all columns + bool DeleteAllColumns(); + + // Clears items, and columns if there are any. + void ClearAll(); + + // Edit the label + wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl)); + + // End label editing, optionally cancelling the edit + bool EndEditLabel(bool cancel); + + // Ensures this item is visible + bool EnsureVisible(long item) ; + + // Find an item whose label matches this string, starting from the item after 'start' + // or the beginning if 'start' is -1. + long FindItem(long start, const wxString& str, bool partial = FALSE); + + // Find an item whose data matches this data, starting from the item after 'start' + // or the beginning if 'start' is -1. + long FindItem(long start, long data); + + // Find an item nearest this position in the specified direction, starting from + // the item after 'start' or the beginning if 'start' is -1. + long FindItem(long start, const wxPoint& pt, int direction); + + // Determines which item (if any) is at the specified point, + // giving details in 'flags' (see wxLIST_HITTEST_... flags above) + long HitTest(const wxPoint& point, int& flags); + + // Inserts an item, returning the index of the new item if successful, + // -1 otherwise. + // TOD: Should also have some further convenience functions + // which don't require setting a wxListItem object + long InsertItem(wxListItem& info); + + // Insert a string item + long InsertItem(long index, const wxString& label); + + // Insert an image item + long InsertItem(long index, int imageIndex); + + // Insert an image/string item + long InsertItem(long index, const wxString& label, int imageIndex); + + // For list view mode (only), inserts a column. + long InsertColumn(long col, wxListItem& info); + + long InsertColumn(long col, const wxString& heading, int format = wxLIST_FORMAT_LEFT, + int width = -1); + + // Scrolls the list control. If in icon, small icon or report view mode, + // x specifies the number of pixels to scroll. If in list view mode, x + // specifies the number of columns to scroll. + // If in icon, small icon or list view mode, y specifies the number of pixels + // to scroll. If in report view mode, y specifies the number of lines to scroll. + bool ScrollList(int dx, int dy); + + // Sort items. + + // fn is a function which takes 3 long arguments: item1, item2, data. + // item1 is the long data associated with a first item (NOT the index). + // item2 is the long data associated with a second item (NOT the index). + // data is the same value as passed to SortItems. + // The return value is a negative number if the first item should precede the second + // item, a positive number of the second item should precede the first, + // or zero if the two items are equivalent. + + // data is arbitrary data to be passed to the sort function. + bool SortItems(wxListCtrlCompare fn, long data); + +/* Why should we need this function? Leave for now. + * We might need it because item data may have changed, + * but the display needs refreshing (in string callback mode) + // Updates an item. If the list control has the wxLI_AUTO_ARRANGE style, + // the items will be rearranged. + bool Update(long item); +*/ + + void Command(wxCommandEvent& event) { ProcessCommand(event); }; + +protected: + wxTextCtrl* m_textCtrl; // The control used for editing a label + wxImageList * m_imageListNormal; // The image list for normal icons + wxImageList * m_imageListSmall; // The image list for small icons + wxImageList * m_imageListState; // The image list state icons (not implemented yet) + + long m_baseStyle; // Basic Windows style flags, for recreation purposes + wxStringList m_stringPool; // Pool of 3 strings to satisfy Windows callback + // requirements + int m_colCount; // Windows doesn't have GetColumnCount so must + // keep track of inserted/deleted columns + +}; + +class WXDLLEXPORT wxListEvent: public wxCommandEvent +{ + DECLARE_DYNAMIC_CLASS(wxListEvent) + + public: + wxListEvent(wxEventType commandType = wxEVT_NULL, int id = 0); + + int m_code; + long m_itemIndex; + long m_oldItemIndex; + int m_col; + bool m_cancelled; + wxPoint m_pointDrag; + + wxListItem m_item; +}; + +typedef void (wxEvtHandler::*wxListEventFunction)(wxListEvent&); + +#define EVT_LIST_BEGIN_DRAG(id, fn) { wxEVT_COMMAND_LIST_BEGIN_DRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_BEGIN_RDRAG(id, fn) { wxEVT_COMMAND_LIST_BEGIN_RDRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_BEGIN_LABEL_EDIT(id, fn) { wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_END_LABEL_EDIT(id, fn) { wxEVT_COMMAND_LIST_END_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_DELETE_ITEM(id, fn) { wxEVT_COMMAND_LIST_DELETE_ITEM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_DELETE_ALL_ITEMS(id, fn) { wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_GET_INFO(id, fn) { wxEVT_COMMAND_LIST_GET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_SET_INFO(id, fn) { wxEVT_COMMAND_LIST_SET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_ITEM_SELECTED(id, fn) { wxEVT_COMMAND_LIST_ITEM_SELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_ITEM_DESELECTED(id, fn) { wxEVT_COMMAND_LIST_ITEM_DESELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_KEY_DOWN(id, fn) { wxEVT_COMMAND_LIST_KEY_DOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_INSERT_ITEM(id, fn) { wxEVT_COMMAND_LIST_INSERT_ITEM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, +#define EVT_LIST_COL_CLICK(id, fn) { wxEVT_COMMAND_LIST_COL_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxListEventFunction) & fn, NULL }, + +#endif + // _WX_LISTCTRL_H_ diff --git a/include/wx/motif/mdi.h b/include/wx/motif/mdi.h new file mode 100644 index 0000000000..fa1db5314c --- /dev/null +++ b/include/wx/motif/mdi.h @@ -0,0 +1,164 @@ +///////////////////////////////////////////////////////////////////////////// +// 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: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/menu.h b/include/wx/motif/menu.h new file mode 100644 index 0000000000..dd34942155 --- /dev/null +++ b/include/wx/motif/menu.h @@ -0,0 +1,170 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: menu.h +// Purpose: wxMenu, wxMenuBar classes +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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); }; + + // 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; } + + //// Motif-specific + inline WXWidget GetButtonWidget() const { return m_buttonWidget; } + inline WXWidget GetMainWidget() const { return m_menuWidget; } +public: + wxFunction m_callback; + + int m_noItems; + wxString m_title; + wxMenuBar * m_menuBar; + wxList m_menuItems; + wxEvtHandler * m_parent; + wxEvtHandler * m_eventHandler; + + //// Motif-specific + int m_numColumns; + WXWidget m_menuWidget; + WXWidget m_popupShell; // For holding the popup shell widget + WXWidget m_buttonWidget; // The actual string, so we can grey it etc. + int m_menuId; + wxMenu* m_topMenu ; + wxMenu* m_menuParent; + bool m_ownedByMenuBar; +}; + +// ---------------------------------------------------------------------------- +// Menu Bar (a la Windows) +// ---------------------------------------------------------------------------- +class WXDLLEXPORT wxFrame; +class WXDLLEXPORT wxMenuBar: public wxEvtHandler +{ + DECLARE_DYNAMIC_CLASS(wxMenuBar) + + wxMenuBar(); + wxMenuBar(int n, wxMenu *menus[], const wxString titles[]); + ~wxMenuBar(); + + void Append(wxMenu *menu, const wxString& title); + // Must only be used AFTER menu has been attached to frame, + // otherwise use individual menus to enable/disable items + void Enable(int Id, bool Flag); + bool Enabled(int Id) const ; + inline bool IsEnabled(int Id) const { return Enabled(Id); }; + void EnableTop(int pos, bool Flag); + void Check(int id, bool Flag); + bool Checked(int id) const ; + inline bool IsChecked(int Id) const { return Checked(Id); }; + void SetLabel(int id, const wxString& label) ; + wxString GetLabel(int id) const ; + void SetLabelTop(int pos, const wxString& label) ; + wxString GetLabelTop(int pos) const ; + virtual void Delete(wxMenu *menu, int index = 0); /* Menu not destroyed */ + virtual bool OnAppend(wxMenu *menu, const char *title); + virtual bool OnDelete(wxMenu *menu, int index); + + virtual void SetHelpString(int Id, const wxString& helpString); + virtual wxString GetHelpString(int Id) const ; + + virtual int FindMenuItem(const wxString& menuString, const wxString& itemString) const ; + + // Find wxMenuItem for item ID, and return item's + // menu too if itemMenu is non-NULL. + wxMenuItem *FindItemForId(int itemId, wxMenu **menuForItem = NULL) const ; + + inline void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; } + inline wxEvtHandler *GetEventHandler() { return m_eventHandler; } + + inline int GetMenuCount() const { return m_menuCount; } + inline wxMenu* GetMenu(int i) const { return m_menus[i]; } + + public: + wxEvtHandler * m_eventHandler; + int m_menuCount; + wxMenu ** m_menus; + wxString * m_titles; + wxFrame * m_menuBarFrame; +/* TODO: data that represents the actual menubar when created. + */ +}; + +#endif // _WX_MENU_H_ diff --git a/include/wx/motif/metafile.h b/include/wx/motif/metafile.h new file mode 100644 index 0000000000..2a8843952c --- /dev/null +++ b/include/wx/motif/metafile.h @@ -0,0 +1,101 @@ +///////////////////////////////////////////////////////////////////////////// +// 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: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/minifram.h b/include/wx/motif/minifram.h new file mode 100644 index 0000000000..07d9fff441 --- /dev/null +++ b/include/wx/motif/minifram.h @@ -0,0 +1,46 @@ +///////////////////////////////////////////////////////////////////////////// +// 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: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/msgdlg.h b/include/wx/motif/msgdlg.h new file mode 100644 index 0000000000..4e8b790290 --- /dev/null +++ b/include/wx/motif/msgdlg.h @@ -0,0 +1,50 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: msgdlg.h +// Purpose: wxMessageDialog class. Use generic version if no +// platform-specific implementation. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_MSGBOXDLG_H_ +#define _WX_MSGBOXDLG_H_ + +#ifdef __GNUG__ +#pragma interface "msgdlg.h" +#endif + +#include "wx/setup.h" +#include "wx/dialog.h" + +/* + * Message box dialog + */ + +WXDLLEXPORT_DATA(extern const char*) wxMessageBoxCaptionStr; + +class WXDLLEXPORT wxMessageDialog: public wxDialog +{ +DECLARE_DYNAMIC_CLASS(wxMessageDialog) +protected: + wxString m_caption; + wxString m_message; + long m_dialogStyle; + wxWindow * m_parent; +public: + wxMessageDialog(wxWindow *parent, const wxString& message, const wxString& caption = wxMessageBoxCaptionStr, + long style = wxOK|wxCENTRE, const wxPoint& pos = wxDefaultPosition); + + int ShowModal(); +}; + + +int WXDLLEXPORT wxMessageBox(const wxString& message, const wxString& caption = wxMessageBoxCaptionStr, + long style = wxOK|wxCENTRE, + wxWindow *parent = NULL, int x = -1, int y = -1); + +#endif + // _WX_MSGBOXDLG_H_ diff --git a/include/wx/motif/notebook.h b/include/wx/motif/notebook.h new file mode 100644 index 0000000000..e5bd1d6c71 --- /dev/null +++ b/include/wx/motif/notebook.h @@ -0,0 +1,204 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: notebook.h +// Purpose: MSW/GTK compatible notebook (a.k.a. property sheet) +// Author: Julian Smart +// Modified by: +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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 all pages + bool DeleteAllPages(); + // adds a new page to the notebook (it will be deleted ny the notebook, + // don't delete it yourself). If bSelect, this page becomes active. + bool AddPage(wxNotebookPage *pPage, + const wxString& strText, + bool bSelect = FALSE, + int imageId = -1); + // the same as AddPage(), but adds it at the specified position + bool InsertPage(int nPage, + wxNotebookPage *pPage, + const wxString& strText, + bool bSelect = FALSE, + int imageId = -1); + // get the panel which represents the given page + wxNotebookPage *GetPage(int nPage) { return m_aPages[nPage]; } + + // callbacks + // --------- + void OnSize(wxSizeEvent& event); + void OnSelChange(wxNotebookEvent& event); + void OnSetFocus(wxFocusEvent& event); + void OnNavigationKey(wxNavigationKeyEvent& event); + + // base class virtuals + // ------------------- + virtual void Command(wxCommandEvent& event); + virtual void SetConstraintSizes(bool recurse = TRUE); + virtual bool DoPhase(int nPhase); + +protected: + // common part of all ctors + void Init(); + + // helper functions + void ChangePage(int nOldSel, int nSel); // change pages + + wxImageList *m_pImageList; // we can have an associated image list + wxArrayPages m_aPages; // array of pages + + int m_nSelection; // the current selection (-1 if none) + + DECLARE_DYNAMIC_CLASS(wxNotebook) + DECLARE_EVENT_TABLE() +}; + +// ---------------------------------------------------------------------------- +// event macros +// ---------------------------------------------------------------------------- +typedef void (wxEvtHandler::*wxNotebookEventFunction)(wxNotebookEvent&); + +#define EVT_NOTEBOOK_PAGE_CHANGED(id, fn) \ + { \ + wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, \ + id, \ + -1, \ + (wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \ + NULL \ + }, + +#define EVT_NOTEBOOK_PAGE_CHANGING(id, fn) \ + { \ + wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, \ \ + id, \ + -1, \ + (wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \ + NULL \ + }, + +#endif // _WX_NOTEBOOK_H_ diff --git a/include/wx/motif/palette.h b/include/wx/motif/palette.h new file mode 100644 index 0000000000..6364d677d9 --- /dev/null +++ b/include/wx/motif/palette.h @@ -0,0 +1,65 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: palette.h +// Purpose: wxPalette class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PALETTE_H_ +#define _WX_PALETTE_H_ + +#ifdef __GNUG__ +#pragma interface "palette.h" +#endif + +#include "wx/gdiobj.h" + +class WXDLLEXPORT wxPalette; + +class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData +{ + friend class WXDLLEXPORT wxPalette; +public: + wxPaletteRefData(); + ~wxPaletteRefData(); +/* TODO: implementation +protected: + WXHPALETTE m_hPalette; +*/ +}; + +#define M_PALETTEDATA ((wxPaletteRefData *)m_refData) + +class WXDLLEXPORT wxPalette: public wxGDIObject +{ + DECLARE_DYNAMIC_CLASS(wxPalette) + +public: + wxPalette(); + inline wxPalette(const wxPalette& palette) { Ref(palette); } + inline wxPalette(const wxPalette* palette) { UnRef(); if (palette) Ref(*palette); } + + wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue); + ~wxPalette(); + bool Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue); + int GetPixel(const unsigned char red, const unsigned char green, const unsigned char blue) const; + bool GetRGB(int pixel, unsigned char *red, unsigned char *green, unsigned char *blue) const; + + virtual bool Ok() const { return (m_refData != NULL) ; } + + inline wxPalette& operator = (const wxPalette& palette) { if (*this == palette) return (*this); Ref(palette); return *this; } + inline bool operator == (const wxPalette& palette) { return m_refData == palette.m_refData; } + inline bool operator != (const wxPalette& palette) { return m_refData != palette.m_refData; } + +/* TODO: implementation + inline WXHPALETTE GetHPALETTE() const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); } + void SetHPALETTE(WXHPALETTE pal); +*/ +}; + +#endif + // _WX_PALETTE_H_ diff --git a/include/wx/motif/pen.h b/include/wx/motif/pen.h new file mode 100644 index 0000000000..ea8e8079fb --- /dev/null +++ b/include/wx/motif/pen.h @@ -0,0 +1,104 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: pen.h +// Purpose: wxPen class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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 wxString& col, int width, int style); + wxPen(const wxBitmap& stipple, int width); + inline wxPen(const wxPen& pen) { Ref(pen); } + inline wxPen(const wxPen* pen) { if (pen) Ref(*pen); } + ~wxPen(); + + inline wxPen& operator = (const wxPen& pen) { if (*this == pen) return (*this); Ref(pen); return *this; } + inline bool operator == (const wxPen& pen) { return m_refData == pen.m_refData; } + inline bool operator != (const wxPen& pen) { return m_refData != pen.m_refData; } + + virtual bool Ok() const { return (m_refData != NULL) ; } + + // Override in order to recreate the pen + void SetColour(const wxColour& col) ; + void SetColour(const wxString& col) ; + void SetColour(const unsigned char r, const unsigned char g, const unsigned char b) ; + + void SetWidth(int width) ; + void SetStyle(int style) ; + void SetStipple(const wxBitmap& stipple) ; + void SetDashes(int nb_dashes, const wxDash *dash) ; + void SetJoin(int join) ; + void SetCap(int cap) ; + + inline wxColour& GetColour() const { return (M_PENDATA ? M_PENDATA->m_colour : wxNullColour); }; + inline int GetWidth() const { return (M_PENDATA ? M_PENDATA->m_width : 0); }; + inline int GetStyle() const { return (M_PENDATA ? M_PENDATA->m_style : 0); }; + inline int GetJoin() const { return (M_PENDATA ? M_PENDATA->m_join : 0); }; + inline int GetCap() const { return (M_PENDATA ? M_PENDATA->m_cap : 0); }; + inline int GetDashes(wxDash **ptr) const { + *ptr = (M_PENDATA ? M_PENDATA->m_dash : (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_ diff --git a/include/wx/motif/print.h b/include/wx/motif/print.h new file mode 100644 index 0000000000..3f4b4a6b7d --- /dev/null +++ b/include/wx/motif/print.h @@ -0,0 +1,56 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: print.h +// Purpose: wxPrinter, wxPrintPreview classes +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PRINT_H_ +#define _WX_PRINT_H_ + +#ifdef __GNUG__ +#pragma interface "print.h" +#endif + +#include "wx/prntbase.h" + +/* + * Represents the printer: manages printing a wxPrintout object + */ + +class WXDLLEXPORT wxPrinter: public wxPrinterBase +{ + DECLARE_DYNAMIC_CLASS(wxPrinter) + + public: + wxPrinter(wxPrintData *data = NULL); + ~wxPrinter(); + + virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = TRUE); + virtual bool PrintDialog(wxWindow *parent); + virtual bool Setup(wxWindow *parent); +}; + +/* + * wxPrintPreview + * Programmer creates an object of this class to preview a wxPrintout. + */ + +class WXDLLEXPORT wxPrintPreview: public wxPrintPreviewBase +{ + DECLARE_CLASS(wxPrintPreview) + + public: + wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting = NULL, wxPrintData *data = NULL); + ~wxPrintPreview(); + + virtual bool Print(bool interactive); + virtual void DetermineScaling(); +}; + +#endif + // _WX_PRINT_H_ diff --git a/include/wx/motif/printdlg.h b/include/wx/motif/printdlg.h new file mode 100644 index 0000000000..81d630d5b2 --- /dev/null +++ b/include/wx/motif/printdlg.h @@ -0,0 +1,70 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: printdlg.h +// Purpose: wxPrintDialog, wxPageSetupDialog classes. +// Use generic, PostScript version if no +// platform-specific implementation. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/private.h b/include/wx/motif/private.h new file mode 100644 index 0000000000..7a05f643bb --- /dev/null +++ b/include/wx/motif/private.h @@ -0,0 +1,28 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: private.h +// Purpose: Private declarations +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PRIVATE_H_ +#define _WX_PRIVATE_H_ + +#include "wx/defs.h" + +/* Put any private declarations here. + */ + +extern void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args); + +extern wxHashTable *wxWidgetHashTable; +extern void wxDeleteWindowFromTable(Widget w); +extern wxWindow *wxGetWindowFromTable(Widget w); +extern bool wxAddWindowToTable(Widget w, wxWindow *win); + +#endif + // _WX_PRIVATE_H_ diff --git a/include/wx/motif/radiobox.h b/include/wx/motif/radiobox.h new file mode 100644 index 0000000000..f46b0a265a --- /dev/null +++ b/include/wx/motif/radiobox.h @@ -0,0 +1,88 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: radiobox.h +// Purpose: wxRadioBox class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/radiobut.h b/include/wx/motif/radiobut.h new file mode 100644 index 0000000000..582eb470f1 --- /dev/null +++ b/include/wx/motif/radiobut.h @@ -0,0 +1,90 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: radiobut.h +// Purpose: wxRadioButton class +// Author: Julian Smart +// Modified by: +// Created: 01/02/97 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/region.h b/include/wx/motif/region.h new file mode 100644 index 0000000000..99a2ef63f9 --- /dev/null +++ b/include/wx/motif/region.h @@ -0,0 +1,135 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: region.h +// Purpose: wxRegion class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_REGION_H_ +#define _WX_REGION_H_ + +#ifdef __GNUG__ +#pragma interface "region.h" +#endif + +#include "wx/list.h" +#include "wx/gdiobj.h" + +class WXDLLEXPORT wxRect; +class WXDLLEXPORT wxPoint; + +enum wxRegionContain { + wxOutRegion = 0, wxPartRegion = 1, wxInRegion = 2 +}; + +// So far, for internal use only +enum wxRegionOp { +wxRGN_AND, // Creates the intersection of the two combined regions. +wxRGN_COPY, // Creates a copy of the region identified by hrgnSrc1. +wxRGN_DIFF, // Combines the parts of hrgnSrc1 that are not part of hrgnSrc2. +wxRGN_OR, // Creates the union of two combined regions. +wxRGN_XOR // Creates the union of two combined regions except for any overlapping areas. +}; + +class WXDLLEXPORT wxRegion : public wxGDIObject { +DECLARE_DYNAMIC_CLASS(wxRegion); + friend class WXDLLEXPORT wxRegionIterator; +public: + wxRegion(long x, long y, long w, long h); + wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight); + wxRegion(const wxRect& rect); + wxRegion(); + ~wxRegion(); + + //# Copying + inline wxRegion(const wxRegion& r) + { Ref(r); } + inline wxRegion& operator = (const wxRegion& r) + { Ref(r); return (*this); } + + //# Modify region + // Clear current region + void Clear(); + + // Union rectangle or region with this. + inline bool Union(long x, long y, long width, long height) { return Combine(x, y, width, height, wxRGN_OR); } + inline bool Union(const wxRect& rect) { return Combine(rect, wxRGN_OR); } + inline bool Union(const wxRegion& region) { return Combine(region, wxRGN_OR); } + + // Intersect rectangle or region with this. + inline bool Intersect(long x, long y, long width, long height) { return Combine(x, y, width, height, wxRGN_AND); } + inline bool Intersect(const wxRect& rect) { return Combine(rect, wxRGN_AND); } + inline bool Intersect(const wxRegion& region) { return Combine(region, wxRGN_AND); } + + // Subtract rectangle or region from this: + // Combines the parts of 'this' that are not part of the second region. + inline bool Subtract(long x, long y, long width, long height) { return Combine(x, y, width, height, wxRGN_DIFF); } + inline bool Subtract(const wxRect& rect) { return Combine(rect, wxRGN_DIFF); } + inline bool Subtract(const wxRegion& region) { return Combine(region, wxRGN_DIFF); } + + // XOR: the union of two combined regions except for any overlapping areas. + inline bool Xor(long x, long y, long width, long height) { return Combine(x, y, width, height, wxRGN_XOR); } + inline bool Xor(const wxRect& rect) { return Combine(rect, wxRGN_XOR); } + inline bool Xor(const wxRegion& region) { return Combine(region, wxRGN_XOR); } + + //# Information on region + // Outer bounds of region + void GetBox(long& x, long& y, long&w, long &h) const; + wxRect GetBox() const ; + + // Is region empty? + bool Empty() const; + inline bool IsEmpty() const { return Empty(); } + + //# Tests + // Does the region contain the point (x,y)? + wxRegionContain Contains(long x, long y) const; + // Does the region contain the point pt? + wxRegionContain Contains(const wxPoint& pt) const; + // Does the region contain the rectangle (x, y, w, h)? + wxRegionContain Contains(long x, long y, long w, long h) const; + // Does the region contain the rectangle rect? + wxRegionContain Contains(const wxRect& rect) const; + +// Internal + bool Combine(long x, long y, long width, long height, wxRegionOp op); + bool Combine(const wxRegion& region, wxRegionOp op); + bool Combine(const wxRect& rect, wxRegionOp op); +}; + +class WXDLLEXPORT wxRegionIterator : public wxObject { +DECLARE_DYNAMIC_CLASS(wxRegionIterator); +public: + wxRegionIterator(); + wxRegionIterator(const wxRegion& region); + ~wxRegionIterator(); + + void Reset() { m_current = 0; } + void Reset(const wxRegion& region); + + operator bool () const { return m_current < m_numRects; } + bool HaveRects() const { return m_current < m_numRects; } + + void operator ++ (); + void operator ++ (int); + + long GetX() const; + long GetY() const; + long GetW() const; + long GetWidth() const { return GetW(); } + long GetH() const; + long GetHeight() const { return GetH(); } + +private: + long m_current; + long m_numRects; + wxRegion m_region; + wxRect* m_rects; +}; + +#endif + // _WX_REGION_H_ diff --git a/include/wx/motif/scrolbar.h b/include/wx/motif/scrolbar.h new file mode 100644 index 0000000000..95343b50ca --- /dev/null +++ b/include/wx/motif/scrolbar.h @@ -0,0 +1,68 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: scrollbar.h +// Purpose: wxScrollBar class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SCROLBAR_H_ +#define _WX_SCROLBAR_H_ + +#ifdef __GNUG__ +#pragma interface "scrolbar.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxScrollBarNameStr; + +// Scrollbar item +class WXDLLEXPORT wxScrollBar: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxScrollBar) + +public: + inline wxScrollBar() { m_pageSize = 0; m_viewSize = 0; m_objectSize = 0; } + ~wxScrollBar(); + + inline wxScrollBar(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxSB_HORIZONTAL, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxScrollBarNameStr) + { + Create(parent, id, pos, size, style, validator, name); + } + bool Create(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxSB_HORIZONTAL, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxScrollBarNameStr); + + int GetPosition() const ; + inline int GetThumbSize() const { return m_pageSize; } + inline int GetPageSize() const { return m_viewSize; } + inline int GetRange() const { return m_objectSize; } + + virtual void SetPosition(int viewStart); + virtual void SetScrollbar(int position, int thumbSize, int range, int pageSize, + bool refresh = TRUE); + + void Command(wxCommandEvent& event); + +protected: + int m_pageSize; + int m_viewSize; + int m_objectSize; + +DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_SCROLBAR_H_ diff --git a/include/wx/motif/settings.h b/include/wx/motif/settings.h new file mode 100644 index 0000000000..435e30b53b --- /dev/null +++ b/include/wx/motif/settings.h @@ -0,0 +1,133 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: settings.h +// Purpose: wxSystemSettings class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/setup.h b/include/wx/motif/setup.h new file mode 100644 index 0000000000..0d2f83035d --- /dev/null +++ b/include/wx/motif/setup.h @@ -0,0 +1,120 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: setup.h +// Purpose: Configuration for the library +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SETUP_H_ +#define _WX_SETUP_H_ + +/* + * General features + * + */ + +#define USE_CONSTRAINTS 1 + // Use constraints mechanism +#define USE_CONFIG 1 + // Use wxConfig, with CreateConfig in wxApp +#define _WX_GOODCOMPILER__ + // gcc can have problems, but Windows compilers + // are generally OK. +#define WXWIN_COMPATIBILITY 1 + // Compatibility with 1.66 API. + // Level 0: no backward compatibility, all new features + // Level 1: wxDC, OnSize (etc.) compatibility, but + // some new features such as event tables + +#define USE_POSTSCRIPT 1 + // 0 for no PostScript device context +#define USE_AFM_FOR_POSTSCRIPT 0 + // 1 to use font metric files in GetTextExtent +#define USE_METAFILE 1 + // 0 for no Metafile and metafile device context +#define USE_IPC 1 + // 0 for no interprocess comms +#define USE_HELP 1 + // 0 for no help facility +#define USE_RESOURCES 1 + // 0 for no wxGetResource/wxWriteResource +#define USE_CLIPBOARD 1 + // 0 for no clipboard functions +#define USE_SPLINES 1 + // 0 for no splines +#define USE_XFIG_SPLINE_CODE 1 + // 1 for XFIG spline code, 0 for AIAI spline code. +// AIAI spline code is slower, but freer of copyright issues. + // 0 for no splines + +#define USE_TOOLBAR 1 + // Use toolbars +#define USE_DRAG_AND_DROP 1 + // 0 for no drag and drop + +#define USE_WX_RESOURCES 1 + // Use .wxr resource mechanism (requires PrologIO library) + +#define USE_DOC_VIEW_ARCHITECTURE 1 + // Set to 0 to disable document/view architecture +#define USE_PRINTING_ARCHITECTURE 1 + // Set to 0 to disable print/preview architecture code +#define USE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1 + // Set to 0 to disable PostScript print/preview architecture code + // under Windows (just use Windows printing). +#define USE_DYNAMIC_CLASSES 1 + // If 1, enables provision of run-time type information. + // NOW MANDATORY: don't change. +#define USE_MEMORY_TRACING 1 + // If 1, enables debugging versions of wxObject::new and + // wxObject::delete *IF* WXDEBUG is also defined. + // WARNING: this code may not work with all architectures, especially + // if alignment is an issue. +#define USE_DEBUG_CONTEXT 1 + // If 1, enables wxDebugContext, for + // writing error messages to file, etc. + // If WXDEBUG is not defined, will still use + // normal memory operators. + // It's recommended to set this to 1, + // since you may well need to output + // an error log in a production + // version (or non-debugging beta) +#define USE_GLOBAL_MEMORY_OPERATORS 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 REMOVE_UNUSED_ARG 1 + // Set this to 0 if your compiler can't cope + // with omission of prototype parameters. + +#define USE_C_MAIN 0 + // Set to 1 to use main.c instead of main.cpp (UNIX only) + +#define USE_ODBC 0 + // Define 1 to use ODBC classes + +#define USE_IOSTREAMH 1 + // VC++ 4.2 and above allows and + // but you can't mix them. Set to 1 for , + // 0 for + +#define USE_WXCONFIG 1 + // if enabled, compiles built-in OS independent wxConfig + // class and it's file (any platform) and registry (Win) + // based implementations +/* + * Finer detail + * + */ + +#define USE_APPLE_IEEE 1 + // if enabled, the float codec written by Apple + // will be used to write, in a portable way, + // float on the disk + +#endif + // _WX_SETUP_H_ diff --git a/include/wx/motif/slider.h b/include/wx/motif/slider.h new file mode 100644 index 0000000000..a11705040c --- /dev/null +++ b/include/wx/motif/slider.h @@ -0,0 +1,91 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: slider.h +// Purpose: wxSlider class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SLIDER_H_ +#define _WX_SLIDER_H_ + +#ifdef __GNUG__ +#pragma interface "slider.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxSliderNameStr; + +// Slider +class WXDLLEXPORT wxSlider: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxSlider) + +public: + wxSlider(); + + inline wxSlider(wxWindow *parent, wxWindowID id, + int value, int minValue, int maxValue, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxSL_HORIZONTAL, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxSliderNameStr) + { + Create(parent, id, value, minValue, maxValue, pos, size, style, validator, name); + } + + ~wxSlider(); + + bool Create(wxWindow *parent, wxWindowID id, + int value, int minValue, int maxValue, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxSL_HORIZONTAL, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxSliderNameStr); + + virtual int GetValue() const ; + virtual void SetValue(int); + void GetSize(int *x, int *y) const ; + void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + void GetPosition(int *x, int *y) const ; + bool Show(bool show); + + void SetRange(int minValue, int maxValue); + + inline int GetMin() const { return m_rangeMin; } + inline int GetMax() const { return m_rangeMax; } + + // For trackbars only + void SetTickFreq(int n, int pos); + inline int GetTickFreq() const { return m_tickFreq; } + void SetPageSize(int pageSize); + int GetPageSize() const ; + void ClearSel() ; + void ClearTicks() ; + void SetLineSize(int lineSize); + int GetLineSize() const ; + int GetSelEnd() const ; + int GetSelStart() const ; + void SetSelection(int minPos, int maxPos); + void SetThumbLength(int len) ; + int GetThumbLength() const ; + void SetTick(int tickPos) ; + + void Command(wxCommandEvent& event); + protected: + int m_rangeMin; + int m_rangeMax; + int m_pageSize; + int m_lineSize; + int m_tickFreq; +DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_SLIDER_H_ diff --git a/include/wx/motif/spinbutt.h b/include/wx/motif/spinbutt.h new file mode 100644 index 0000000000..ce5a75372c --- /dev/null +++ b/include/wx/motif/spinbutt.h @@ -0,0 +1,97 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: spinbutt.h +// Purpose: wxSpinButton class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_SPINBUTT_H_ +#define _WX_SPINBUTT_H_ + +#ifdef __GNUG__ +#pragma interface "spinbutt.h" +#endif + +#include "wx/control.h" +#include "wx/event.h" + +/* + The wxSpinButton is like a small scrollbar than is often placed next + to a text control. + + wxSP_HORIZONTAL: horizontal spin button + wxSP_VERTICAL: vertical spin button (the default) + wxSP_ARROW_KEYS: arrow keys increment/decrement value + wxSP_WRAP: value wraps at either end + */ + +class WXDLLEXPORT wxSpinButton: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxSpinButton) + public: + /* + * Public interface + */ + + wxSpinButton(); + + inline wxSpinButton(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxSP_VERTICAL, const wxString& name = "wxSpinButton") + { + Create(parent, id, pos, size, style, name); + } + ~wxSpinButton(); + + bool Create(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = wxSP_VERTICAL, const wxString& name = "wxSpinButton"); + + + // Attributes + //////////////////////////////////////////////////////////////////////////// + + int GetValue() const ; + void SetValue(int val) ; + void SetRange(int minVal, int maxVal) ; + inline int GetMin() const { return m_min; } + inline int GetMax() const { return m_max; } + + // Operations + //////////////////////////////////////////////////////////////////////////// + + void Command(wxCommandEvent& event) { ProcessCommand(event); }; + +protected: + int m_min; + int m_max; +}; + +class WXDLLEXPORT wxSpinEvent: public wxScrollEvent +{ + DECLARE_DYNAMIC_CLASS(wxSpinEvent) + + public: + wxSpinEvent(wxEventType commandType = wxEVT_NULL, int id = 0); +}; + +typedef void (wxEvtHandler::*wxSpinEventFunction)(wxSpinEvent&); + +// Spin events + +#define EVT_SPIN_UP(id, func) { wxEVT_SCROLL_LINEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func } +#define EVT_SPIN_DOWN(id, func) { wxEVT_SCROLL_LINEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func } + +#define EVT_SPIN(id, func) \ + { wxEVT_SCROLL_TOP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_BOTTOM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_LINEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_LINEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_PAGEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_PAGEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\ + { wxEVT_SCROLL_THUMBTRACK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func }, + +#endif + // _WX_SPINBUTT_H_ diff --git a/include/wx/motif/statbmp.h b/include/wx/motif/statbmp.h new file mode 100644 index 0000000000..8045813fc4 --- /dev/null +++ b/include/wx/motif/statbmp.h @@ -0,0 +1,64 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: statbmp.h +// Purpose: wxStaticBitmap class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_STATBMP_H_ +#define _WX_STATBMP_H_ + +#ifdef __GNUG__ +#pragma interface "statbmp.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxStaticBitmapNameStr; + +class WXDLLEXPORT wxStaticBitmap: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxStaticBitmap) + public: + inline wxStaticBitmap() { } + + inline wxStaticBitmap(wxWindow *parent, wxWindowID id, + const wxBitmap& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxStaticBitmapNameStr) + { + Create(parent, id, label, pos, size, style, name); + } + + bool Create(wxWindow *parent, wxWindowID id, + const wxBitmap& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxStaticBitmapNameStr); + + virtual void SetBitmap(const wxBitmap& bitmap); + + virtual void Command(wxCommandEvent& WXUNUSED(event)) {}; + virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {}; + + void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + + inline wxBitmap& GetBitmap() const { return (wxBitmap&) m_messageBitmap; } + + // overriden base class virtuals + virtual bool AcceptsFocus() const { return FALSE; } + + protected: + wxBitmap m_messageBitmap; + +}; + +#endif + // _WX_STATBMP_H_ diff --git a/include/wx/motif/statbox.h b/include/wx/motif/statbox.h new file mode 100644 index 0000000000..e16cd330d2 --- /dev/null +++ b/include/wx/motif/statbox.h @@ -0,0 +1,57 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: statbox.h +// Purpose: wxStaticBox class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_STATBOX_H_ +#define _WX_STATBOX_H_ + +#ifdef __GNUG__ +#pragma interface "statbox.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxStaticBoxNameStr; + +// Group box +class WXDLLEXPORT wxStaticBox: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxStaticBox) + + public: + inline wxStaticBox() {} + inline wxStaticBox(wxWindow *parent, wxWindowID id, + const wxString& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxStaticBoxNameStr) + { + Create(parent, id, label, pos, size, style, name); + } + + bool Create(wxWindow *parent, wxWindowID id, + const wxString& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxStaticBoxNameStr); + + virtual void Command(wxCommandEvent& WXUNUSED(event)) {}; + virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {}; + + void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + void SetLabel(const wxString& label); + +DECLARE_EVENT_TABLE() +}; + +#endif + // _WX_STATBOX_H_ diff --git a/include/wx/motif/stattext.h b/include/wx/motif/stattext.h new file mode 100644 index 0000000000..9dfa9d23e0 --- /dev/null +++ b/include/wx/motif/stattext.h @@ -0,0 +1,56 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: stattext.h +// Purpose: wxStaticText class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_STATTEXT_H_ +#define _WX_STATTEXT_H_ + +#ifdef __GNUG__ +#pragma interface "stattext.h" +#endif + +#include "wx/control.h" + +WXDLLEXPORT_DATA(extern const char*) wxStaticTextNameStr; + +class WXDLLEXPORT wxStaticText: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxStaticText) + public: + inline wxStaticText() { } + + inline wxStaticText(wxWindow *parent, wxWindowID id, + const wxString& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxStaticTextNameStr) + { + Create(parent, id, label, pos, size, style, name); + } + + bool Create(wxWindow *parent, wxWindowID id, + const wxString& label, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxStaticTextNameStr); + + // accessors + void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + void SetLabel(const wxString&); + + // operations + virtual void Command(wxCommandEvent& WXUNUSED(event)) {}; + virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {}; +}; + +#endif + // _WX_STATTEXT_H_ diff --git a/include/wx/motif/statusbr.h b/include/wx/motif/statusbr.h new file mode 100644 index 0000000000..b9ad928bed --- /dev/null +++ b/include/wx/motif/statusbr.h @@ -0,0 +1,54 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: statusbr.h +// Purpose: native implementation of wxStatusBar. Optional; can use generic +// version instead. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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 diff --git a/include/wx/motif/tabctrl.h b/include/wx/motif/tabctrl.h new file mode 100644 index 0000000000..c7ffd57bf7 --- /dev/null +++ b/include/wx/motif/tabctrl.h @@ -0,0 +1,138 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: tabctrl.h +// Purpose: wxTabCtrl class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TABCTRL_H_ +#define _WX_TABCTRL_H_ + +#ifdef __GNUG__ +#pragma interface "tabctrl.h" +#endif + +class wxImageList; + +/* + * Flags returned by HitTest + */ + +#define wxTAB_HITTEST_NOWHERE 1 +#define wxTAB_HITTEST_ONICON 2 +#define wxTAB_HITTEST_ONLABEL 4 +#define wxTAB_HITTEST_ONITEM 6 + +class WXDLLEXPORT wxTabCtrl: public wxControl +{ + DECLARE_DYNAMIC_CLASS(wxTabCtrl) + public: + /* + * Public interface + */ + + wxTabCtrl(); + + inline wxTabCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = 0, const wxString& name = "tabCtrl") + { + Create(parent, id, pos, size, style, name); + } + ~wxTabCtrl(); + +// Accessors + + // Get the selection + int GetSelection() const; + + // Get the tab with the current keyboard focus + int GetCurFocus() const; + + // Get the associated image list + wxImageList* GetImageList() const; + + // Get the number of items + int GetItemCount() const; + + // Get the rect corresponding to the tab + bool GetItemRect(int item, wxRect& rect) const; + + // Get the number of rows + int GetRowCount() const; + + // Get the item text + wxString GetItemText(int item) const ; + + // Get the item image + int GetItemImage(int item) const; + + // Get the item data + void* GetItemData(int item) const; + + // Set the selection + int SetSelection(int item); + + // Set the image list + void SetImageList(wxImageList* imageList); + + // Set the text for an item + bool SetItemText(int item, const wxString& text); + + // Set the image for an item + bool SetItemImage(int item, int image); + + // Set the data for an item + bool SetItemData(int item, void* data); + + // Set the size for a fixed-width tab control + void SetItemSize(const wxSize& size); + + // Set the padding between tabs + void SetPadding(const wxSize& padding); + +// Operations + + bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, + long style = 0, const wxString& name = "tabCtrl"); + + // Delete all items + bool DeleteAllItems(); + + // Delete an item + bool DeleteItem(int item); + + // Hit test + int HitTest(const wxPoint& pt, long& flags); + + // Insert an item + bool InsertItem(int item, const wxString& text, int imageId = -1, void* data = NULL); + + void Command(wxCommandEvent& event); + +protected: + wxImageList* m_imageList; + +DECLARE_EVENT_TABLE() +}; + +class WXDLLEXPORT wxTabEvent: public wxCommandEvent +{ + DECLARE_DYNAMIC_CLASS(wxTabEvent) + + public: + wxTabEvent(wxEventType commandType = wxEVT_NULL, int id = 0); +}; + +typedef void (wxEvtHandler::*wxTabEventFunction)(wxTabEvent&); + +#define EVT_TAB_SEL_CHANGED(id, fn) { wxEVT_COMMAND_TAB_SEL_CHANGED, \ + id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTabEventFunction) & fn, NULL }, +#define EVT_TAB_SEL_CHANGING(id, fn) { wxEVT_COMMAND_TAB_SEL_CHANGING, \ + id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTabEventFunction) & fn, NULL }, + +#endif + // _WX_TABCTRL_H_ diff --git a/include/wx/motif/taskbar.h b/include/wx/motif/taskbar.h new file mode 100644 index 0000000000..d9453f7033 --- /dev/null +++ b/include/wx/motif/taskbar.h @@ -0,0 +1,49 @@ +///////////////////////////////////////////////////////////////////////// +// File: taskbar.h +// Purpose: Defines wxTaskBarIcon class for manipulating icons on the +// task bar. Optional. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TASKBAR_H_ +#define _WX_TASKBAR_H_ + +#ifdef __GNUG__ +#pragma interface "taskbar.h" +#endif + +#include +#include + +class wxTaskBarIcon: public wxObject +{ +public: + wxTaskBarIcon(); + virtual ~wxTaskBarIcon(); + +// Accessors + +// 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_ diff --git a/include/wx/motif/textctrl.h b/include/wx/motif/textctrl.h new file mode 100644 index 0000000000..6cc2b83033 --- /dev/null +++ b/include/wx/motif/textctrl.h @@ -0,0 +1,139 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: textctrl.h +// Purpose: wxTextCtrl class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TEXTCTRL_H_ +#define _WX_TEXTCTRL_H_ + +#ifdef __GNUG__ +#pragma interface "textctrl.h" +#endif + +#include "wx/control.h" + +#if USE_IOSTREAMH +#include +#else +#include +#endif + +WXDLLEXPORT_DATA(extern const char*) wxTextCtrlNameStr; +WXDLLEXPORT_DATA(extern const char*) wxEmptyString; + +// Single-line text item +class WXDLLEXPORT wxTextCtrl: public wxControl + +// 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_ diff --git a/include/wx/motif/timer.h b/include/wx/motif/timer.h new file mode 100644 index 0000000000..60a9f166ff --- /dev/null +++ b/include/wx/motif/timer.h @@ -0,0 +1,57 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: timer.h +// Purpose: wxTimer class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TIMER_H_ +#define _WX_TIMER_H_ + +#ifdef __GNUG__ +#pragma interface "timer.h" +#endif + +#include "wx/object.h" + +class WXDLLEXPORT wxTimer: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxTimer) + + public: + wxTimer(); + ~wxTimer(); + virtual bool Start(int milliseconds = -1,bool one_shot = FALSE); // Start timer + virtual void Stop(); // Stop timer + virtual void Notify() = 0; // Override this member + inline int Interval() { return m_milli ; }; // Returns the current interval time (0 if stop) + +protected: + bool m_oneShot ; + int m_milli ; + int m_lastMilli ; + long m_id; + +}; + +/* Note: these are implemented in common/timercmn.cpp, so need to implement them separately. + * But you may need to modify timercmn.cpp. + */ + +// Timer functions (milliseconds) +void WXDLLEXPORT wxStartTimer(); +// Gets time since last wxStartTimer or wxGetElapsedTime +long WXDLLEXPORT wxGetElapsedTime(bool resetTimer = TRUE); + +// EXPERIMENTAL: comment this out if it doesn't compile. +bool WXDLLEXPORT wxGetLocalTime(long *timeZone, int *dstObserved); + +// Get number of seconds since 00:00:00 GMT, Jan 1st 1970. +long WXDLLEXPORT wxGetCurrentTime(); + +#endif + // _WX_TIMER_H_ diff --git a/include/wx/motif/toolbar.h b/include/wx/motif/toolbar.h new file mode 100644 index 0000000000..4ccb016fb9 --- /dev/null +++ b/include/wx/motif/toolbar.h @@ -0,0 +1,77 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: toolbar.h +// Purpose: wxToolBar class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/treectrl.h b/include/wx/motif/treectrl.h new file mode 100644 index 0000000000..4a20b0cb8b --- /dev/null +++ b/include/wx/motif/treectrl.h @@ -0,0 +1,295 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: treectrl.h +// Purpose: wxTreeCtrl class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TREECTRL_H_ +#define _WX_TREECTRL_H_ + +#ifdef __GNUG__ +#pragma interface "treectrl.h" +#endif + +#include "wx/control.h" +#include "wx/event.h" +#include "wx/imaglist.h" + +#define wxTREE_MASK_HANDLE 0x0001 +#define wxTREE_MASK_STATE 0x0002 +#define wxTREE_MASK_TEXT 0x0004 +#define wxTREE_MASK_IMAGE 0x0008 +#define wxTREE_MASK_SELECTED_IMAGE 0x0010 +#define wxTREE_MASK_CHILDREN 0x0020 +#define wxTREE_MASK_DATA 0x0040 + +#define wxTREE_STATE_BOLD 0x0001 +#define wxTREE_STATE_DROPHILITED 0x0002 +#define wxTREE_STATE_EXPANDED 0x0004 +#define wxTREE_STATE_EXPANDEDONCE 0x0008 +#define wxTREE_STATE_FOCUSED 0x0010 +#define wxTREE_STATE_SELECTED 0x0020 +#define wxTREE_STATE_CUT 0x0040 + +#define wxTREE_HITTEST_ABOVE 0x0001 // Above the client area. +#define wxTREE_HITTEST_BELOW 0x0002 // Below the client area. +#define wxTREE_HITTEST_NOWHERE 0x0004 // In the client area but below the last item. +#define wxTREE_HITTEST_ONITEMBUTTON 0x0010 // On the button associated with an item. +#define wxTREE_HITTEST_ONITEMICON 0x0020 // On the bitmap associated with an item. +#define wxTREE_HITTEST_ONITEMINDENT 0x0040 // In the indentation associated with an item. +#define wxTREE_HITTEST_ONITEMLABEL 0x0080 // On the label (string) associated with an item. +#define wxTREE_HITTEST_ONITEMRIGHT 0x0100 // In the area to the right of an item. +#define wxTREE_HITTEST_ONITEMSTATEICON 0x0200 // On the state icon for a tree view item that is in a user-defined state. +#define wxTREE_HITTEST_TOLEFT 0x0400 // To the right of the client area. +#define wxTREE_HITTEST_TORIGHT 0x0800 // To the left of the client area. + +#define wxTREE_HITTEST_ONITEM (wxTREE_HITTEST_ONITEMICON | wxTREE_HITTEST_ONITEMLABEL | wxTREE_HITTEST_ONITEMSTATEICON) + +// Flags for GetNextItem +enum { + wxTREE_NEXT_CARET, // Retrieves the currently selected item. + wxTREE_NEXT_CHILD, // Retrieves the first child item. The hItem parameter must be NULL. + wxTREE_NEXT_DROPHILITE, // Retrieves the item that is the target of a drag-and-drop operation. + wxTREE_NEXT_FIRSTVISIBLE, // Retrieves the first visible item. + wxTREE_NEXT_NEXT, // Retrieves the next sibling item. + wxTREE_NEXT_NEXTVISIBLE, // Retrieves the next visible item that follows the specified item. + wxTREE_NEXT_PARENT, // Retrieves the parent of the specified item. + wxTREE_NEXT_PREVIOUS, // Retrieves the previous sibling item. + wxTREE_NEXT_PREVIOUSVISIBLE, // Retrieves the first visible item that precedes the specified item. + wxTREE_NEXT_ROOT // Retrieves the first child item of the root item of which the specified item is a part. +}; + +// Flags for ExpandItem +enum { + wxTREE_EXPAND_EXPAND, + wxTREE_EXPAND_COLLAPSE, + wxTREE_EXPAND_COLLAPSE_RESET, + wxTREE_EXPAND_TOGGLE +}; + +// Flags for InsertItem +enum { + wxTREE_INSERT_LAST = -1, + wxTREE_INSERT_FIRST = -2, + wxTREE_INSERT_SORT = -3 +}; + +class WXDLLEXPORT wxTreeItem: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxTreeItem) +public: + long m_mask; + long m_itemId; + long m_state; + long m_stateMask; + wxString m_text; + int m_image; + int m_selectedImage; + int m_children; + long m_data; + + wxTreeItem(); + +// Accessors + inline long GetMask() const { return m_mask; } + inline long GetItemId() const { return m_itemId; } + inline long GetState() const { return m_state; } + inline long GetStateMask() const { return m_stateMask; } + inline wxString GetText() const { return m_text; } + inline int GetImage() const { return m_image; } + inline int GetSelectedImage() const { return m_selectedImage; } + inline int GetChildren() const { return m_children; } + inline long GetData() const { return m_data; } + + inline void SetMask(long mask) { m_mask = mask; } + inline void SetItemId(long id) { m_itemId = m_itemId = id; } + inline void SetState(long state) { m_state = state; } + inline void SetStateMask(long stateMask) { m_stateMask = stateMask; } + inline void GetText(const wxString& text) { m_text = text; } + inline void SetImage(int image) { m_image = image; } + inline void GetSelectedImage(int selImage) { m_selectedImage = selImage; } + inline void SetChildren(int children) { m_children = children; } + inline void SetData(long data) { m_data = data; } +}; + +class WXDLLEXPORT wxTreeCtrl: public wxControl +{ +public: + /* + * Public interface + */ + + // creation + // -------- + wxTreeCtrl(); + + inline wxTreeCtrl(wxWindow *parent, wxWindowID id = -1, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxTR_HAS_BUTTONS|wxTR_LINES_AT_ROOT, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = "wxTreeCtrl") + { + Create(parent, id, pos, size, style, validator, name); + } + ~wxTreeCtrl(); + + bool Create(wxWindow *parent, wxWindowID id = -1, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxTR_HAS_BUTTONS|wxTR_LINES_AT_ROOT, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = "wxTreeCtrl"); + + // accessors + // --------- + // + int GetCount() const; + + // indent + int GetIndent() const; + void SetIndent(int indent); + // image list + wxImageList *GetImageList(int which = wxIMAGE_LIST_NORMAL) const; + void SetImageList(wxImageList *imageList, int which = wxIMAGE_LIST_NORMAL); + + // navigation inside the tree + long GetNextItem(long item, int code) const; + bool ItemHasChildren(long item) const; + long GetChild(long item) const; + long GetParent(long item) const; + long GetFirstVisibleItem() const; + long GetNextVisibleItem(long item) const; + long GetSelection() const; + long GetRootItem() const; + + // generic function for (g|s)etting item attributes + bool GetItem(wxTreeItem& info) const; + bool SetItem(wxTreeItem& info); + // item state + int GetItemState(long item, long stateMask) const; + bool SetItemState(long item, long state, long stateMask); + // item image + bool SetItemImage(long item, int image, int selImage); + // item text + wxString GetItemText(long item) const; + void SetItemText(long item, const wxString& str); + // custom data associated with the item + long GetItemData(long item) const; + bool SetItemData(long item, long data); + // convenience function + bool IsItemExpanded(long item) + { + return (GetItemState(item, wxTREE_STATE_EXPANDED) & + wxTREE_STATE_EXPANDED) != 0; + } + + // bounding rect + bool GetItemRect(long item, wxRectangle& rect, bool textOnly = FALSE) const; + // + wxTextCtrl* GetEditControl() const; + + // operations + // ---------- + // adding/deleting items + bool DeleteItem(long item); + long InsertItem(long parent, wxTreeItem& info, + long insertAfter = wxTREE_INSERT_LAST); + // If image > -1 and selImage == -1, the same image is used for + // both selected and unselected items. + long InsertItem(long parent, const wxString& label, + int image = -1, int selImage = -1, + long insertAfter = wxTREE_INSERT_LAST); + + // changing item state + bool ExpandItem(long item) { return ExpandItem(item, wxTREE_EXPAND_EXPAND); } + bool CollapseItem(long item) { return ExpandItem(item, wxTREE_EXPAND_COLLAPSE); } + bool ToggleItem(long item) { return ExpandItem(item, wxTREE_EXPAND_TOGGLE); } + // common interface for {Expand|Collapse|Toggle}Item + bool ExpandItem(long item, int action); + + // + bool SelectItem(long item); + bool ScrollTo(long item); + bool DeleteAllItems(); + + // Edit the label (tree must have the focus) + wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl)); + + // End label editing, optionally cancelling the edit + bool EndEditLabel(bool cancel); + + long HitTest(const wxPoint& point, int& flags); + // wxImageList *CreateDragImage(long item); + bool SortChildren(long item); + bool EnsureVisible(long item); + + void Command(wxCommandEvent& event) { ProcessCommand(event); }; + +protected: + wxTextCtrl* m_textCtrl; + wxImageList* m_imageListNormal; + wxImageList* m_imageListState; + + DECLARE_DYNAMIC_CLASS(wxTreeCtrl) +}; + +/* + wxEVT_COMMAND_TREE_BEGIN_DRAG, + wxEVT_COMMAND_TREE_BEGIN_RDRAG, + wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, + wxEVT_COMMAND_TREE_END_LABEL_EDIT, + wxEVT_COMMAND_TREE_DELETE_ITEM, + wxEVT_COMMAND_TREE_GET_INFO, + wxEVT_COMMAND_TREE_SET_INFO, + wxEVT_COMMAND_TREE_ITEM_EXPANDED, + wxEVT_COMMAND_TREE_ITEM_EXPANDING, + wxEVT_COMMAND_TREE_ITEM_COLLAPSED, + wxEVT_COMMAND_TREE_ITEM_COLLAPSING, + wxEVT_COMMAND_TREE_SEL_CHANGED, + wxEVT_COMMAND_TREE_SEL_CHANGING, + wxEVT_COMMAND_TREE_KEY_DOWN +*/ + +class WXDLLEXPORT wxTreeEvent: public wxCommandEvent +{ + DECLARE_DYNAMIC_CLASS(wxTreeEvent) + + public: + wxTreeEvent(wxEventType commandType = wxEVT_NULL, int id = 0); + + int m_code; + wxTreeItem m_item; + long m_oldItem; + wxPoint m_pointDrag; + + inline long GetOldItem() const { return m_oldItem; } + inline wxTreeItem& GetItem() const { return (wxTreeItem&) m_item; } + inline wxPoint GetPoint() const { return m_pointDrag; } + inline int GetCode() const { return m_code; } +}; + +typedef void (wxEvtHandler::*wxTreeEventFunction)(wxTreeEvent&); + +#define EVT_TREE_BEGIN_DRAG(id, fn) { wxEVT_COMMAND_TREE_BEGIN_DRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, (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_ diff --git a/include/wx/motif/wave.h b/include/wx/motif/wave.h new file mode 100644 index 0000000000..272b152aa3 --- /dev/null +++ b/include/wx/motif/wave.h @@ -0,0 +1,44 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wave.h +// Purpose: wxWave class (loads and plays short Windows .wav files). +// Optional on non-Windows platforms. +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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_ diff --git a/include/wx/motif/window.h b/include/wx/motif/window.h new file mode 100644 index 0000000000..9510f97fd0 --- /dev/null +++ b/include/wx/motif/window.h @@ -0,0 +1,570 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: window.h +// Purpose: wxWindow class +// Author: Julian Smart +// Modified by: +// Created: 17/09/98 +// RCS-ID: $Id$ +// Copyright: (c) Julian Smart +// 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 wxRectangle; +class WXDLLEXPORT wxBitmap; +class WXDLLEXPORT wxSizer; +class WXDLLEXPORT wxList; +class WXDLLEXPORT wxLayoutConstraints; +class WXDLLEXPORT wxMouseEvent; +class WXDLLEXPORT wxButton; +class WXDLLEXPORT wxColour; +class WXDLLEXPORT wxBrush; +class WXDLLEXPORT wxPen; +class WXDLLEXPORT wxIcon; +class WXDLLEXPORT wxDC; +class WXDLLEXPORT wxValidator; + +#if USE_DRAG_AND_DROP +class WXDLLEXPORT wxDropTarget; +#endif + +#if USE_WX_RESOURCES +class WXDLLEXPORT wxResourceTable; +class WXDLLEXPORT wxItemResource; +#endif + +WXDLLEXPORT_DATA(extern const char*) wxPanelNameStr; + +WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize; +WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition; + +class WXDLLEXPORT wxWindow: public wxEvtHandler +{ + DECLARE_ABSTRACT_CLASS(wxWindow) + + friend class wxDC; + friend class wxPaintDC; + +public: + wxWindow(); + inline wxWindow(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxPanelNameStr) + { + m_children = new wxList; + Create(parent, id, pos, size, style, name); + } + + virtual ~wxWindow(); + + bool Create(wxWindow *parent, wxWindowID id, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxPanelNameStr); + + // Fit the window around the items + virtual void Fit(); + + // Show or hide the window + virtual bool Show(bool show); + + // Is the window shown? + virtual bool IsShown() const; + + // Raise the window to the top of the Z order + virtual void Raise(); + + // Lower the window to the bottom of the Z order + virtual void Lower(); + + // Is the window enabled? + virtual bool IsEnabled() const; + + // For compatibility + inline bool Enabled() const { return IsEnabled(); } + + // Dialog support: override these and call + // base class members to add functionality + // that can't be done using validators. + + // Transfer values to controls. If returns FALSE, + // it's an application error (pops up a dialog) + virtual bool TransferDataToWindow(); + + // Transfer values from controls. If returns FALSE, + // transfer failed: don't quit + virtual bool TransferDataFromWindow(); + + // Validate controls. If returns FALSE, + // validation failed: don't quit + virtual bool Validate(); + + // Return code for dialogs + inline void SetReturnCode(int retCode); + inline int GetReturnCode(); + + // Set the cursor + virtual void SetCursor(const wxCursor& cursor); + inline virtual wxCursor *GetCursor() const { return (wxCursor *)& m_windowCursor; }; + + // Get the window with the focus + static wxWindow *FindFocus(); + + // Get character size + virtual int GetCharHeight() const; + virtual int GetCharWidth() const; + + // Get overall window size + virtual void GetSize(int *width, int *height) const; + + // Get window position, relative to parent (or screen if no parent) + virtual void GetPosition(int *x, int *y) const; + + // Get client (application-useable) size + virtual void GetClientSize(int *width, int *height) const; + + // Set overall size and position + virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO); + inline virtual void SetSize(int width, int height) { SetSize(-1, -1, width, height, wxSIZE_USE_EXISTING); } + inline virtual void Move(int x, int y) { SetSize(x, y, -1, -1, wxSIZE_USE_EXISTING); } + + // Set client size + virtual void SetClientSize(int width, int size); + + // Convert client to screen coordinates + virtual void ClientToScreen(int *x, int *y) const; + + // Convert screen to client coordinates + virtual void ScreenToClient(int *x, int *y) const; + + // Set the focus to this window + virtual void SetFocus(); + + // Capture/release mouse + virtual void CaptureMouse(); + virtual void ReleaseMouse(); + + // Enable or disable the window + virtual void Enable(bool enable); + +#if USE_DRAG_AND_DROP + // Associate a drop target with this window (if the window already had a drop + // target, it's deleted!) and return the current drop target (may be NULL). + void SetDropTarget(wxDropTarget *pDropTarget); + wxDropTarget *GetDropTarget() const { return m_pDropTarget; } +#endif + + // Accept files for dragging + virtual void DragAcceptFiles(bool accept); + + // Update region access + virtual wxRegion GetUpdateRegion() const; + virtual bool IsExposed(int x, int y, int w, int h) const; + virtual bool IsExposed(const wxPoint& pt) const; + virtual bool IsExposed(const wxRect& rect) const; + + // Set/get the window title + virtual inline void SetTitle(const wxString& WXUNUSED(title)) {}; + inline virtual wxString GetTitle() const { return wxString(""); }; + // Most windows have the concept of a label; for frames, this is the + // title; for items, this is the label or button text. + inline virtual wxString GetLabel() const { return GetTitle(); } + + // Set/get the window name (used for resource setting in X) + inline virtual wxString GetName() const; + inline virtual void SetName(const wxString& name); + + // Centre the window + virtual void Centre(int direction) ; + inline void Center(int direction = wxHORIZONTAL) { Centre(direction); } + + // Popup a menu + virtual bool PopupMenu(wxMenu *menu, int x, int y); + + // Send the window a refresh event + virtual void Refresh(bool eraseBack = TRUE, const wxRectangle *rect = NULL); + + // New functions that will replace the above. + virtual void SetScrollbar(int orient, int pos, int thumbVisible, + int range, bool refresh = TRUE); + + virtual void SetScrollPos(int orient, int pos, bool refresh = TRUE); + virtual int GetScrollPos(int orient) const; + virtual int GetScrollRange(int orient) const; + virtual int GetScrollThumb(int orient) const; + + virtual void ScrollWindow(int dx, int dy, const wxRectangle *rect = NULL); + + // Caret manipulation + virtual void CreateCaret(int w, int h); + virtual void CreateCaret(const wxBitmap *bitmap); + virtual void DestroyCaret(); + virtual void ShowCaret(bool show); + virtual void SetCaretPos(int x, int y); + virtual void GetCaretPos(int *x, int *y) const; + + // Tell window how much it can be sized + virtual void SetSizeHints(int minW = -1, int minH = -1, int maxW = -1, int maxH = -1, int incW = -1, int incH = -1); + + // Set/get the window's identifier + inline int GetId() const; + inline void SetId(int id); + + 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; + + // 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; + + // Set/get window default background colour (for children to inherit). + // NOTE: these may be removed in later revisions. + inline virtual void SetDefaultBackgroundColour(const wxColour& col); + inline virtual wxColour GetDefaultBackgroundColour(void) const; + + // Set/get window default foreground colour (for children to inherit) + inline virtual void SetDefaultForegroundColour(const wxColour& col); + inline virtual wxColour GetDefaultForegroundColour(void) const; + + // Get the default button, if there is one + inline virtual wxButton *GetDefaultItem() const; + inline virtual void SetDefaultItem(wxButton *but); + + // Override to define new behaviour for default action (e.g. double clicking + // on a listbox) + virtual void OnDefaultAction(wxControl *initiatingItem); + + // Resource loading +#if USE_WX_RESOURCES + virtual bool LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table = NULL); + virtual wxControl *CreateItem(const wxItemResource *childResource, const wxResourceTable *table = NULL); +#endif + + 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 ; + + 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(); + + /// MOTIF-specific + + // Gives window a chance to do something in response to a size + // message, e.g. arrange status bar, toolbar etc. + virtual bool PreResize() { return TRUE; } + + // Get main widget for this window + virtual WXWidget GetMainWidget() const; + virtual void SetMainWidget(WXWidget w) { m_mainWidget = w; } + + // Get the underlying X window and display + virtual WXWindow GetXWindow() const; + virtual WXDisplay *GetXDisplay() const; + + //////////////////////////////////////////////////////////////////////// + //// PROTECTED DATA +protected: + int m_windowId; + long m_windowStyle; // Store the window's style + wxEvtHandler * m_windowEventHandler; // Usually is 'this' + wxLayoutConstraints * m_constraints; // Constraints for this window + wxList * m_constraintsInvolvedIn; // List of constraints we're involved in + wxSizer * m_windowSizer; // Window's top-level sizer (if any) + wxWindow * m_sizerParent; // Window's parent sizer (if any) + bool m_autoLayout; // Whether to call Layout() in OnSize + wxWindow * m_windowParent; // Each window always knows its parent + wxValidator * m_windowValidator; + int m_minSizeX; + int m_minSizeY; + int m_maxSizeX; + int m_maxSizeY; + + // Caret data + int m_caretWidth; + int m_caretHeight; + bool m_caretEnabled; + bool m_caretShown; + wxFont m_windowFont; // Window's font + wxCursor m_windowCursor; // Window's cursor + wxString m_windowName; // Window name + + wxButton * m_defaultItem; + + wxColour m_backgroundColour ; + wxColour m_foregroundColour ; + wxColour m_defaultBackgroundColour; + wxColour m_defaultForegroundColour; + wxAcceleratorTable m_acceleratorTable; + +#if USE_DRAG_AND_DROP + wxDropTarget *m_pDropTarget; // the current drop target or NULL +#endif //USE_DRAG_AND_DROP + +public: + wxRegion m_updateRegion; + wxList * m_children; // Window's children + int m_returnCode; + +public: + /// MOTIF-specific + bool m_button1Pressed; + bool m_button2Pressed; + bool m_button3Pressed; + +protected: + WXWidget m_mainWidget; + bool m_winCaptured; + bool m_isShown; + +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 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 void wxWindow::SetDefaultForegroundColour(const wxColour& col) { m_defaultForegroundColour = col; }; +inline wxColour wxWindow::GetDefaultForegroundColour(void) const { return m_defaultForegroundColour; }; +inline void wxWindow::SetDefaultBackgroundColour(const wxColour& col) { m_defaultBackgroundColour = col; }; +inline wxColour wxWindow::GetDefaultBackgroundColour(void) const { return m_defaultBackgroundColour; }; + +inline wxButton *wxWindow::GetDefaultItem() const { return m_defaultItem; } +inline void wxWindow::SetDefaultItem(wxButton *but) { m_defaultItem = but; } +inline bool wxWindow::IsRetained() const { return ((m_windowStyle & wxRETAINED) == wxRETAINED); } + +inline 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_ -- 2.45.2