Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replaced by stubs files

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@509 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Karsten Ballüder
1998-08-12 09:16:21 +00:00
parent 0acb94947f
commit 01b2eeec59
85 changed files with 9910 additions and 7156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
include/wx/qt/app.h
View File

@@ -1,138 +1,153 @@
/////////////////////////////////////////////////////////////////////////////
// Name: app.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxApp class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKAPPH__
#define __GTKAPPH__
#ifndef _WX_APP_H_
#define _WX_APP_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "app.h"
#endif
#include "wx/window.h"
#include "wx/frame.h"
#include "wx/defs.h"
#include "wx/object.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxApp;
class wxLog;
class wxConfig; // it's not used #if !USE_WXCONFIG, but fwd decl doesn't harm
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern wxApp *wxTheApp;
//-----------------------------------------------------------------------------
// global functions
//-----------------------------------------------------------------------------
void wxExit(void);
bool wxYield(void);
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxFrame;
class WXDLLEXPORT wxWindow;
class WXDLLEXPORT wxApp ;
class WXDLLEXPORT wxKeyEvent;
class WXDLLEXPORT wxLog;
#define wxPRINT_WINDOWS 1
#define wxPRINT_POSTSCRIPT 2
//-----------------------------------------------------------------------------
// wxApp
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
class wxApp: public wxEvtHandler
void WXDLLEXPORT wxCleanUp();
void WXDLLEXPORT wxCommonCleanUp(); // Call this from the platform's wxCleanUp()
void WXDLLEXPORT wxCommonInit(); // Call this from the platform's initialization
// Force an exit from main loop
void WXDLLEXPORT wxExit();
// Yield to other apps/messages
bool WXDLLEXPORT wxYield();
// Represents the application. Derive OnInit and declare
// a new App object to start application
class WXDLLEXPORT wxApp: public wxEvtHandler
{
DECLARE_DYNAMIC_CLASS(wxApp)
public:
wxApp(void);
~wxApp(void);
wxApp();
inline ~wxApp() {}
static void SetInitializerFunction(wxAppInitializerFunction fn) { m_appInitFn = fn; }
static wxAppInitializerFunction GetInitializerFunction(void) { return m_appInitFn; }
static wxAppInitializerFunction GetInitializerFunction() { return m_appInitFn; }
virtual bool OnInit(void);
virtual bool OnInitGui(void);
virtual int OnRun(void);
virtual int OnExit(void);
virtual int MainLoop();
void ExitMainLoop();
bool Initialized();
virtual bool Pending() ;
virtual void Dispatch() ;
wxWindow *GetTopWindow(void);
void SetTopWindow( wxWindow *win );
virtual int MainLoop(void);
void ExitMainLoop(void);
bool Initialized(void);
virtual bool Pending(void);
virtual void Dispatch(void);
virtual void OnIdle(wxIdleEvent& event);
inline void SetWantDebugOutput(bool flag) { m_wantDebugOutput = flag; }
inline bool GetWantDebugOutput(void) { return m_wantDebugOutput; }
// Generic
virtual bool OnInit() { return FALSE; };
void OnIdle( wxIdleEvent &event );
bool SendIdleEvents(void);
bool SendIdleEvents( wxWindow* win );
// No specific tasks to do here.
virtual bool OnInitGui() { return TRUE; }
inline wxString GetAppName(void) const {
// Called to set off the main loop
virtual int OnRun() { return MainLoop(); };
virtual int OnExit() { return 0; }
inline void SetPrintMode(int mode) { m_printMode = mode; }
inline int GetPrintMode() const { return m_printMode; }
inline void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; }
inline bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; }
inline wxString GetAppName() const {
if (m_appName != "")
return m_appName;
else return m_className;
}
inline void SetAppName(const wxString& name) { m_appName = name; };
inline wxString GetClassName(void) const { return m_className; }
inline 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; }
void SetVendorName(const wxString& name) { m_vendorName = name; }
inline void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; }
inline bool GetExitOnFrameDelete(void) const { return m_exitOnFrameDelete; }
wxWindow *GetTopWindow() const ;
inline void SetTopWindow(wxWindow *win) { m_topWindow = win; }
void SetPrintMode(int WXUNUSED(mode) ) {};
int GetPrintMode(void) const { return wxPRINT_POSTSCRIPT; };
inline void SetWantDebugOutput(bool flag) { m_wantDebugOutput = flag; }
inline bool GetWantDebugOutput() { return m_wantDebugOutput; }
// override this function to create default log target of arbitrary
// user-defined classv (default implementation creates a wxLogGui object)
// 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();
#if USE_WXCONFIG
// override this function to create a global wxConfig object of different
// than default type (right now the default implementation returns NULL)
virtual wxConfig *CreateConfig() { return NULL; }
#endif
// GTK implementation
static void CommonInit(void);
static void CommonCleanUp(void);
bool ProcessIdle(void);
void DeletePendingObjects(void);
bool m_initialized;
bool m_exitOnFrameDelete;
bool m_wantDebugOutput;
wxWindow *m_topWindow;
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;
private:
wxString m_vendorName,
m_appName,
m_className;
public:
// Implementation
static void CommonInit();
static void CommonCleanUp();
void DeletePendingObjects();
bool ProcessIdle();
public:
static long sm_lastMessageTime;
int m_nCmdShow;
protected:
bool m_keepGoing ;
DECLARE_EVENT_TABLE()
};
#endif // __GTKAPPH__
// TODO: add platform-specific arguments
int WXDLLEXPORT wxEntry( int argc, char *argv[] );
#endif
// _WX_APP_H_

235
include/wx/qt/bitmap.h
View File

@@ -1,125 +1,198 @@
/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Purpose: wxBitmap class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKBITMAPH__
#define __GTKBITMAPH__
#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "bitmap.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
#include "wx/palette.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
// Bitmap
class WXDLLEXPORT wxDC;
class WXDLLEXPORT wxControl;
class WXDLLEXPORT wxBitmap;
class WXDLLEXPORT wxBitmapHandler;
class WXDLLEXPORT wxIcon;
class WXDLLEXPORT wxCursor;
class wxDC;
class wxPaintDC;
class wxMemoryDC;
class wxToolBar;
class wxBitmapButton;
class wxStaticBitmap;
class wxFrame;
class wxMask;
class wxBitmap;
//-----------------------------------------------------------------------------
// wxMask
//-----------------------------------------------------------------------------
class wxMask: public wxObject
// 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();
private:
friend wxBitmap;
friend wxDC;
friend wxPaintDC;
friend wxToolBar;
friend wxBitmapButton;
friend wxStaticBitmap;
friend wxFrame;
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;
*/
};
//-----------------------------------------------------------------------------
// wxBitmap
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
{
friend class WXDLLEXPORT wxBitmap;
friend class WXDLLEXPORT wxIcon;
friend class WXDLLEXPORT wxCursor;
public:
wxBitmapRefData();
~wxBitmapRefData();
// CMB 20/5/98: added xbm constructor and GetBitmap() method
class wxBitmap: public wxObject
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
wxBitmap();
wxBitmap( int width, int height, int depth = -1 );
// 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);
wxBitmap( char **bits );
wxBitmap( const wxBitmap& bmp );
wxBitmap( const wxBitmap* bmp );
wxBitmap( const wxString &filename, int type = wxBITMAP_TYPE_XPM);
/* 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();
wxBitmap& operator = ( const wxBitmap& bmp );
bool operator == ( const wxBitmap& bmp );
bool operator != ( const wxBitmap& bmp );
bool Ok() const;
int GetHeight() const;
int GetWidth() const;
int GetDepth() const;
void SetHeight( int height );
void SetWidth( int width );
void SetDepth( int depth );
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);
wxMask *GetMask() const;
inline bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
inline int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
inline int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
inline int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
inline int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); }
void SetWidth(int w);
void SetHeight(int h);
void SetDepth(int d);
void SetQuality(int q);
void SetOk(bool isOk);
inline wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : NULL); }
void SetPalette(const wxPalette& palette);
inline wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : NULL); }
void SetMask(wxMask *mask) ;
void Resize( int height, int width );
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; }
bool SaveFile( const wxString &name, int type, wxPalette *palette = NULL );
bool LoadFile( const wxString &name, int type = wxBITMAP_TYPE_XPM);
// 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);
wxPalette *GetPalette() const;
wxPalette *GetColourMap() const
{ return GetPalette(); };
static void InitStandardHandlers();
static void CleanUpHandlers();
protected:
static wxList sm_handlers;
private:
/*
// TODO: Implementation
public:
void SetHBITMAP(WXHBITMAP bmp);
inline WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
bool FreeResource(bool force = FALSE);
*/
friend wxDC;
friend wxPaintDC;
friend wxMemoryDC;
friend wxToolBar;
friend wxBitmapButton;
friend wxStaticBitmap;
friend wxFrame;
// no data :-)
};
#endif // __GTKBITMAPH__
#endif
// _WX_BITMAP_H_

105
include/wx/qt/bmpbuttn.h
View File

@@ -1,62 +1,83 @@
/////////////////////////////////////////////////////////////////////////////
// Name: bmpbutton.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Name: bmpbuttn.h
// Purpose: wxBitmapButton class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __BMPBUTTONH__
#define __BMPBUTTONH__
#ifndef _WX_BMPBUTTN_H_
#define _WX_BMPBUTTN_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "bmpbuttn.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/button.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr;
class wxBitmapButton;
#define wxDEFAULT_BUTTON_MARGIN 4
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxButtonNameStr;
//-----------------------------------------------------------------------------
// wxBitmapButton
//-----------------------------------------------------------------------------
class wxBitmapButton: public wxControl
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);
}
wxBitmapButton(void);
wxBitmapButton( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxButtonNameStr );
bool Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxButtonNameStr );
void SetDefault(void);
void SetLabel( const wxString &label );
wxString GetLabel(void) const;
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
public:
virtual void SetLabel(const wxBitmap& bitmap)
{
SetBitmapLabel(bitmap);
}
wxBitmap m_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 // __BMPBUTTONH__
#endif
// _WX_BMPBUTTN_H_

98
include/wx/qt/brush.h
View File

@@ -1,60 +1,86 @@
/////////////////////////////////////////////////////////////////////////////
// Name: brush.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxBrush class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKBRUSHH__
#define __GTKBRUSHH__
#ifndef _WX_BRUSH_H_
#define _WX_BRUSH_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "brush.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/gdicmn.h"
#include "wx/gdiobj.h"
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxBrush;
class wxBrush;
class WXDLLEXPORT wxBrushRefData: public wxGDIRefData
{
friend class WXDLLEXPORT wxBrush;
public:
wxBrushRefData();
wxBrushRefData(const wxBrushRefData& data);
~wxBrushRefData();
//-----------------------------------------------------------------------------
// wxBrush
//-----------------------------------------------------------------------------
protected:
int m_style;
wxBitmap m_stipple ;
wxColour m_colour;
class wxBrush: public wxGDIObject
/* 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();
wxBrush(void);
wxBrush( const wxColour &colour, int style );
wxBrush( const wxString &colourName, int style );
wxBrush( const wxBitmap &stippleBitmap );
wxBrush( const wxBrush &brush );
wxBrush( const wxBrush *brush );
~wxBrush(void);
wxBrush& operator = ( const wxBrush& brush );
bool operator == ( const wxBrush& brush );
bool operator != ( const wxBrush& brush );
bool Ok(void) const;
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) ;
int GetStyle(void) const;
wxColour &GetColour(void) const;
wxBitmap *GetStipple(void) const;
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; }
// no data :-)
inline wxColour& GetColour() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_colour : wxNullColour); };
inline int GetStyle() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_style : 0); };
inline wxBitmap *GetStipple() const { return (M_BRUSHDATA ? & M_BRUSHDATA->m_stipple : 0); };
virtual bool Ok() const { return (m_refData != NULL) ; }
// Implementation
// Useful helper: create the brush resource
void RealizeResource();
// When setting properties, we must make sure we're not changing
// another object
void Unshare();
};
#endif // __GTKBRUSHH__
#endif
// _WX_BRUSH_H_

73
include/wx/qt/button.h
View File

@@ -1,58 +1,53 @@
/////////////////////////////////////////////////////////////////////////////
// Name: button.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxButton class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKBUTTONH__
#define __GTKBUTTONH__
#ifndef _WX_BUTTON_H_
#define _WX_BUTTON_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "button.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/gdicmn.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxButtonNameStr;
class wxButton;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxButtonNameStr;
//-----------------------------------------------------------------------------
// wxButton
//-----------------------------------------------------------------------------
class wxButton: public wxControl
// 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);
}
wxButton(void);
wxButton( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxButtonNameStr );
bool Create(wxWindow *parent, wxWindowID id, const wxString& label,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxButtonNameStr );
void SetDefault(void);
void SetLabel( const wxString &label );
wxString GetLabel(void) const;
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
virtual void SetDefault();
virtual void SetLabel(const wxString& label);
virtual wxString GetLabel() const ;
virtual void Command(wxCommandEvent& event);
};
#endif // __GTKBUTTONH__
#endif
// _WX_BUTTON_H_

98
include/wx/qt/checkbox.h
View File

@@ -1,57 +1,81 @@
/////////////////////////////////////////////////////////////////////////////
// Name: checkbox.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxCheckBox class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCHECKBOXH__
#define __GTKCHECKBOXH__
#ifndef _WX_CHECKBOX_H_
#define _WX_CHECKBOX_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "checkbox.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxCheckBoxNameStr;
class wxCheckBox;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxCheckBoxNameStr;
//-----------------------------------------------------------------------------
// wxCheckBox
//-----------------------------------------------------------------------------
class wxCheckBox: public wxControl
// 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);
}
wxCheckBox(void);
wxCheckBox( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxCheckBoxNameStr );
bool Create(wxWindow *parent, wxWindowID id, const wxString& label,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxCheckBoxNameStr );
void SetValue( bool state );
bool GetValue(void) const;
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);
};
#endif // __GTKCHECKBOXH__
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_

96
include/wx/qt/choice.h
View File

@@ -1,68 +1,72 @@
/////////////////////////////////////////////////////////////////////////////
// Name: choice.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxChoice class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCHOICEH__
#define __GTKCHOICEH__
#ifndef _WX_CHOICE_H_
#define _WX_CHOICE_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "choice.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxChoiceNameStr;
class wxChoice;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxChoiceNameStr;
//-----------------------------------------------------------------------------
// wxChoice
//-----------------------------------------------------------------------------
class wxChoice: public wxControl
// Choice item
class WXDLLEXPORT wxChoice: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxChoice)
public:
inline wxChoice() { m_noStrings = 0; }
wxChoice(void);
wxChoice( wxWindow *parent, wxWindowID id,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
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 wxString &name = wxChoiceNameStr );
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,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0, const wxString &name = wxChoiceNameStr );
void Append( const wxString &item );
void Clear(void);
int FindString( const wxString &string ) const;
int GetColumns(void) const;
int GetSelection(void);
wxString GetString( int n ) const;
wxString GetStringSelection(void) const;
int Number(void) const;
void SetColumns( int n = 1 );
void SetSelection( int n );
void SetStringSelection( const wxString &string );
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 // __GTKCHOICEH__
#endif
// _WX_CHOICE_H_

107
include/wx/qt/colour.h
View File

@@ -1,75 +1,68 @@
/////////////////////////////////////////////////////////////////////////////
// Name: colour.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxColour class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCOLOURH__
#define __GTKCOLOURH__
#ifndef _WX_COLOUR_H_
#define _WX_COLOUR_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "colour.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/gdiobj.h"
#include "wx/palette.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxDC;
class wxPaintDC;
class wxBitmap;
class wxWindow;
class wxColour;
//-----------------------------------------------------------------------------
// wxColour
//-----------------------------------------------------------------------------
class wxColour: public wxGDIObject
// Colour
class WXDLLEXPORT wxColour: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxColour)
public:
wxColour(void);
wxColour( char red, char green, char blue );
wxColour( const wxString &colourName );
wxColour();
wxColour(unsigned char r, unsigned char g, unsigned char b);
wxColour(unsigned long colRGB) { Set(colRGB); }
wxColour(const wxColour& col);
wxColour( const wxColour* col );
~wxColour(void);
wxColour& operator = ( const wxColour& col );
wxColour& operator = ( const wxString& colourName );
bool operator == ( const wxColour& col );
bool operator != ( const wxColour& col );
void Set( const unsigned char red, const unsigned char green, const unsigned char blue );
unsigned char Red(void) const;
unsigned char Green(void) const;
unsigned char Blue(void) const;
bool Ok(void) const;
wxColour(const wxString& col);
~wxColour() ;
wxColour& operator =(const wxColour& src) ;
wxColour& operator =(const wxString& src) ;
inline int Ok() const { return (m_isInit) ; }
void Set(unsigned char r, unsigned char g, unsigned char b);
void Set(unsigned long colRGB)
{
// we don't need to know sizeof(long) here because we assume that the three
// least significant bytes contain the R, G and B values
Set((unsigned char)colRGB,
(unsigned char)(colRGB >> 8),
(unsigned char)(colRGB >> 16));
}
inline unsigned char Red() const { return m_red; }
inline unsigned char Green() const { return m_green; }
inline unsigned char Blue() const { return m_blue; }
inline bool operator == (const wxColour& colour) { return (m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue); }
inline bool operator != (const wxColour& colour) { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); }
WXCOLORREF GetPixel() const { return m_pixel; };
private:
bool m_isInit;
unsigned char m_red;
unsigned char m_blue;
unsigned char m_green;
public:
friend wxDC;
friend wxPaintDC;
friend wxBitmap;
friend wxWindow;
int GetPixel(void);
// no data :-)
/* TODO: implementation
WXCOLORREF m_pixel ;
*/
};
#endif // __GTKCOLOURH__
#define wxColor wxColour
#endif
// _WX_COLOUR_H_

96
include/wx/qt/combobox.h
View File

@@ -1,48 +1,33 @@
/////////////////////////////////////////////////////////////////////////////
// Name: combobox.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxComboBox class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCOMBOBOXH__
#define __GTKCOMBOBOXH__
#ifndef _WX_COMBOBOX_H_
#define _WX_COMBOBOX_H_
#ifdef __GNUG__
#pragma interface "combobox.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/control.h"
#include "wx/choice.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxComboBoxNameStr;
WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
class wxComboBox;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char* wxComboBoxNameStr;
extern const char* wxEmptyString;
//-----------------------------------------------------------------------------
// wxComboBox
//-----------------------------------------------------------------------------
class wxComboBox: public wxControl
// Combobox item
class WXDLLEXPORT wxComboBox: public wxChoice
{
DECLARE_DYNAMIC_CLASS(wxComboBox)
public:
inline wxComboBox(void) {}
inline wxComboBox() {}
inline wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
@@ -50,9 +35,10 @@ class wxComboBox: public wxControl
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
Create(parent, id, value, pos, size, n, choices, style, name);
Create(parent, id, value, pos, size, n, choices, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
@@ -61,40 +47,32 @@ class wxComboBox: public wxControl
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
// List functions
void Clear(void);
void Append( const wxString &item );
void Append( const wxString &item, char* clientData );
void Delete( int n );
int FindString( const wxString &item );
char* GetClientData( int n );
void SetClientData( int n, char * clientData );
int GetSelection(void) const;
wxString GetString( int n ) const;
wxString GetStringSelection(void) const;
int Number(void) const;
void SetSelection( int n );
void SetStringSelection( const wxString &string );
// List functions: see wxChoice
// Text field functions
wxString GetValue(void) const ;
void SetValue(const wxString& value);
virtual wxString GetValue() const ;
virtual void SetValue(const wxString& value);
// Clipboard operations
void Copy(void);
void Cut(void);
void Paste(void);
void SetInsertionPoint(long pos);
void SetInsertionPointEnd(void);
long GetInsertionPoint(void) const ;
long GetLastPosition(void) const ;
void Replace(long from, long to, const wxString& value);
void Remove(long from, long to);
void SetSelection(long from, long to);
void SetEditable(bool editable);
virtual void Copy();
virtual void Cut();
virtual void Paste();
virtual void SetInsertionPoint(long pos);
virtual void SetInsertionPointEnd();
virtual long GetInsertionPoint() const ;
virtual long GetLastPosition() const ;
virtual void Replace(long from, long to, const wxString& value);
virtual void Remove(long from, long to);
virtual void SetSelection(int n)
{
wxChoice::SetSelection(n);
}
virtual void SetSelection(long from, long to);
virtual void SetEditable(bool editable);
};
#endif // __GTKCOMBOBOXH__
#endif
// _WX_COMBOBOX_H_

68
include/wx/qt/control.h
View File

@@ -1,60 +1,50 @@
/////////////////////////////////////////////////////////////////////////////
// Name: control.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxControl class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCONTROLH__
#define __GTKCONTROLH__
#ifndef _WX_CONTROL_H_
#define _WX_CONTROL_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "control.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/window.h"
#include "wx/list.h"
#include "wx/validate.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxControl;
//-----------------------------------------------------------------------------
// wxControl
//-----------------------------------------------------------------------------
class wxControl: public wxWindow
// General item class
class WXDLLEXPORT wxControl: public wxWindow
{
DECLARE_DYNAMIC_CLASS(wxControl)
DECLARE_ABSTRACT_CLASS(wxControl)
public:
// construction
wxControl();
wxControl( wxWindow *parent, wxWindowID id,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxPanelNameStr );
~wxControl();
// overridables
virtual void Command( wxCommandEvent &event );
// accessors
// this function will filter out '&' characters and will put the accelerator
// char (the one immediately after '&') into m_chAccel (@@ not yet)
virtual void Command(wxCommandEvent& WXUNUSED(event)) = 0; // Simulates an event
virtual void ProcessCommand(wxCommandEvent& event); // Calls the callback and
// appropriate event handlers
virtual void SetLabel(const wxString& label);
virtual wxString GetLabel() const ;
// Places item in centre of panel - so can't be used BEFORE panel->Fit()
void Centre(int direction = wxHORIZONTAL);
inline void Callback(const wxFunction function) { m_callback = function; }; // Adds callback
inline wxFunction GetCallback() { return m_callback; }
protected:
wxString m_label;
// when we implement keyboard interface we will make use of this, but not yet
//char m_chAccel;
wxFunction m_callback; // Callback associated with the window
DECLARE_EVENT_TABLE()
};
#endif // __GTKCONTROLH__
#endif
// _WX_CONTROL_H_

88
include/wx/qt/cursor.h
View File

@@ -1,59 +1,75 @@
/////////////////////////////////////////////////////////////////////////////
// Name: cursor.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxCursor class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCURSORH__
#define __GTKCURSORH__
#ifndef _WX_CURSOR_H_
#define _WX_CURSOR_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "cursor.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/gdicmn.h"
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxCursorRefData: public wxBitmapRefData
{
friend class WXDLLEXPORT wxBitmap;
friend class WXDLLEXPORT wxCursor;
public:
wxCursorRefData();
~wxCursorRefData();
class wxWindow;
protected:
/* TODO: implementation
WXHCURSOR m_hCursor;
*/
};
class wxCursor;
#define M_CURSORDATA ((wxCursorRefData *)m_refData)
#define M_CURSORHANDLERDATA ((wxCursorRefData *)bitmap->m_refData)
//-----------------------------------------------------------------------------
// wxCursor
//-----------------------------------------------------------------------------
class wxCursor: public wxObject
// Cursor
class WXDLLEXPORT wxCursor: public wxBitmap
{
DECLARE_DYNAMIC_CLASS(wxCursor)
public:
wxCursor();
wxCursor(void);
wxCursor( int cursorId );
wxCursor( const wxCursor &cursor );
wxCursor( const wxCursor *cursor );
~wxCursor(void);
wxCursor& operator = ( const wxCursor& cursor );
bool operator == ( const wxCursor& cursor );
bool operator != ( const wxCursor& cursor );
bool Ok(void) const;
// Copy constructors
inline wxCursor(const wxCursor& cursor) { Ref(cursor); }
inline wxCursor(const wxCursor* cursor) { if (cursor) Ref(*cursor); }
private:
public:
wxCursor(const char bits[], int width, int height, int hotSpotX = -1, int hotSpotY = -1,
const char maskBits[] = NULL);
friend wxWindow;
/* TODO: make default type suit platform */
wxCursor(const wxString& name, long flags = wxBITMAP_TYPE_CUR_RESOURCE,
int hotSpotX = 0, int hotSpotY = 0);
// no data :-)
wxCursor(int cursor_type);
~wxCursor();
virtual bool Ok() const { return (m_refData != NULL && M_CURSORDATA->m_hCursor) ; }
inline wxCursor& operator = (const wxCursor& cursor) { if (*this == cursor) return (*this); Ref(cursor); return *this; }
inline bool operator == (const wxCursor& cursor) { return m_refData == cursor.m_refData; }
inline bool operator != (const wxCursor& cursor) { return m_refData != cursor.m_refData; }
/* TODO: implementation
void SetHCURSOR(WXHCURSOR cursor);
inline WXHCURSOR GetHCURSOR() const { return (M_CURSORDATA ? M_CURSORDATA->m_hCursor : 0); }
*/
};
#endif // __GTKCURSORH__
extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);
#endif
// _WX_CURSOR_H_

120
include/wx/qt/dc.h
View File

@@ -1,36 +1,27 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dc.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxDC class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKDCH__
#define __GTKDCH__
#ifndef _WX_DC_H_
#define _WX_DC_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "dc.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/gdicmn.h"
#include "wx/pen.h"
#include "wx/brush.h"
#include "wx/icon.h"
#include "wx/font.h"
#include "wx/gdicmn.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxDC;
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
@@ -54,7 +45,7 @@ extern int wxPageNumber;
// wxDC
//-----------------------------------------------------------------------------
class wxDC: public wxObject
class WXDLLEXPORT wxDC: public wxObject
{
DECLARE_ABSTRACT_CLASS(wxDC)
@@ -69,12 +60,40 @@ class wxDC: public wxObject
virtual bool Ok(void) const { return m_ok; };
virtual void FloodFill( long x1, long y1, wxColour *col, int style=wxFLOOD_SURFACE ) = 0;
inline void FloodFill(const wxPoint& pt, const wxColour& col, int style=wxFLOOD_SURFACE)
{
FloodFill(pt.x, pt.y, col, style);
}
virtual bool GetPixel( long x1, long y1, wxColour *col ) const = 0;
inline bool GetPixel(const wxPoint& pt, wxColour *col) const
{
return GetPixel(pt.x, pt.y, col);
}
virtual void DrawLine( long x1, long y1, long x2, long y2 ) = 0;
inline void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
{
DrawLine(pt1.x, pt1.y, pt2.x, pt2.y);
}
virtual void CrossHair( long x, long y ) = 0;
virtual void DrawArc( long x1, long y1, long x2, long y2, double xc, double yc );
inline void CrossHair(const wxPoint& pt)
{
CrossHair(pt.x, pt.y);
}
virtual void DrawArc( long x1, long y1, long x2, long y2, double xc, double yc ) = 0;
inline void DrawArc(const wxPoint& pt1, const wxPoint& pt2, double xc, double yc)
{
DrawArc(pt1.x, pt1.y, pt2.x, pt2.y, xc, yc);
}
virtual void DrawEllipticArc( long x, long y, long width, long height, double sa, double ea ) = 0;
virtual void DrawEllipticArc (const wxPoint& pt, const wxSize& sz, double sa, double ea)
{
DrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea);
}
virtual void DrawPoint( long x, long y ) = 0;
virtual void DrawPoint( wxPoint& point );
@@ -86,21 +105,67 @@ class wxDC: public wxObject
int fillStyle=wxODDEVEN_RULE );
virtual void DrawRectangle( long x, long y, long width, long height ) = 0;
inline void DrawRectangle(const wxPoint& pt, const wxSize& sz)
{
DrawRectangle(pt.x, pt.y, sz.x, sz.y);
}
inline void DrawRectangle(const wxRect& rect)
{
DrawRectangle(rect.x, rect.y, rect.width, rect.height);
}
virtual void DrawRoundedRectangle( long x, long y, long width, long height, double radius = 20.0 ) = 0;
inline void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius = 20.0)
{
DrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius);
}
inline void DrawRoundedRectangle(const wxRect& rect, double radius = 20.0)
{
DrawRoundedRectangle(rect.x, rect.y, rect.width, rect.height, radius);
}
virtual void DrawEllipse( long x, long y, long width, long height ) = 0;
inline void DrawEllipse(const wxPoint& pt, const wxSize& sz)
{
DrawEllipse(pt.x, pt.y, sz.x, sz.y);
}
inline void DrawEllipse(const wxRect& rect)
{
DrawEllipse(rect.x, rect.y, rect.width, rect.height);
}
virtual void DrawIcon(const wxIcon& icon, long x, long y) = 0;
virtual void DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 );
virtual void DrawSpline( wxList *points );
virtual void DrawSpline( int n, wxPoint points[] );
virtual bool CanDrawBitmap(void) const = 0;
virtual void DrawIcon( const wxIcon &icon, long x, long y, bool useMask=FALSE );
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,
@@ -111,19 +176,19 @@ class wxDC: public wxObject
virtual void Clear(void) = 0;
virtual void SetFont( const wxFont &font ) = 0;
virtual wxFont *GetFont(void) { return &m_font; };
virtual wxFont *GetFont(void) const { return &m_font; };
virtual void SetPen( const wxPen &pen ) = 0;
virtual wxPen *GetPen(void) { return &m_pen; };
virtual wxPen *GetPen(void) const { return &m_pen; };
virtual void SetBrush( const wxBrush &brush ) = 0;
virtual wxBrush *GetBrush(void) { return &m_brush; };
virtual wxBrush *GetBrush(void) const { return &m_brush; };
virtual void SetBackground( const wxBrush &brush ) = 0;
virtual wxBrush *GetBackground(void) { return &m_backgroundBrush; };
virtual wxBrush *GetBackground(void) const { return &m_backgroundBrush; };
virtual void SetLogicalFunction( int function ) = 0;
virtual int GetLogicalFunction(void) { return m_logicalFunction; };
virtual int GetLogicalFunction(void) const { return m_logicalFunction; };
virtual void SetTextForeground( const wxColour &col );
virtual void SetTextBackground( const wxColour &col );
@@ -131,7 +196,7 @@ class wxDC: public wxObject
virtual wxColour& GetTextForeground(void) const { return (wxColour&)m_textForegroundColour; };
virtual void SetBackgroundMode( int mode ) = 0;
virtual int GetBackgroundMode(void) { return m_backgroundMode; };
virtual int GetBackgroundMode(void) const { return m_backgroundMode; };
virtual void SetPalette( const wxPalette& palette ) = 0;
void SetColourMap( const wxPalette& palette ) { SetPalette(palette); };
@@ -306,4 +371,5 @@ class wxDC: public wxObject
long m_minX,m_maxX,m_minY,m_maxY;
};
#endif // __GTKDCH__
#endif
// _WX_DC_H_

31
include/wx/qt/dcclient.h
View File

@@ -1,29 +1,32 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcclient.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxClientDC, wxPaintDC and wxWindowDC classes
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKDCCLIENTH__
#define __GTKDCCLIENTH__
#ifndef _WX_DCCLIENT_H_
#define _WX_DCCLIENT_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "dcclient.h"
#endif
#include "wx/dc.h"
#include "wx/window.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxPaintDC;
class WXDLLEXPORT wxPaintDC;
// Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented differently.
// On many platforms, however, they will be the same.
typedef wxPaintDC wxClientDC;
typedef wxPaintDC wxWindowDC;
@@ -31,7 +34,7 @@ typedef wxPaintDC wxWindowDC;
// wxPaintDC
//-----------------------------------------------------------------------------
class wxPaintDC: public wxDC
class WXDLLEXPORT wxPaintDC: public wxDC
{
DECLARE_DYNAMIC_CLASS(wxPaintDC)
@@ -91,7 +94,7 @@ class wxPaintDC: public wxDC
virtual void DestroyClippingRegion(void);
virtual void DrawOpenSpline( wxList *points );
};
#endif // __GTKDCCLIENTH__
#endif
// _WX_DCCLIENT_H_

30
include/wx/qt/dcmemory.h
View File

@@ -1,34 +1,23 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcmemory.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Purpose: wxMemoryDC class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKDCMEMORYH__
#define __GTKDCMEMORYH__
#ifndef _WX_DCMEMORY_H_
#define _WX_DCMEMORY_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "dcmemory.h"
#endif
#include "wx/defs.h"
#include "wx/dcclient.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxMemoryDC;
//-----------------------------------------------------------------------------
// wxMemoryDC
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxMemoryDC: public wxPaintDC
{
DECLARE_DYNAMIC_CLASS(wxMemoryDC)
@@ -46,5 +35,4 @@ class WXDLLEXPORT wxMemoryDC: public wxPaintDC
};
#endif
// __GTKDCMEMORYH__
// _WX_DCMEMORY_H_

33
include/wx/qt/dcscreen.h
View File

@@ -1,16 +1,20 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcscreen.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxScreenDC class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCSCREEN_H_
#define _WX_DCSCREEN_H_
#ifndef __GTKDCSCREENH__
#define __GTKDCSCREENH__
#ifdef __GNUG__
#pragma interface "dcscreen.h"
#endif
#include "wx/dcclient.h"
@@ -19,14 +23,17 @@ class WXDLLEXPORT wxScreenDC: public wxPaintDC
DECLARE_DYNAMIC_CLASS(wxScreenDC)
public:
wxScreenDC(void);
~wxScreenDC(void);
// Create a DC representing the whole screen
wxScreenDC();
~wxScreenDC();
static bool StartDrawingOnTop( wxWindow *window );
static bool StartDrawingOnTop( wxRectangle *rect = NULL );
static bool EndDrawingOnTop(void);
// Compatibility with X's requirements for
// drawing on top of all windows
static bool StartDrawingOnTop(wxWindow* WXUNUSED(window)) { return TRUE; }
static bool StartDrawingOnTop(wxRectangle* WXUNUSED(rect) = NULL) { return TRUE; }
static bool EndDrawingOnTop() { return TRUE; }
};
#endif
// __GTKDCSCREENH__
// _WX_DCSCREEN_H_

143
include/wx/qt/dialog.h
View File

@@ -1,91 +1,98 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dialog.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxDialog class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKDIALOGH__
#define __GTKDIALOGH__
#ifndef _WX_DIALOG_H_
#define _WX_DIALOG_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "dialog.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/event.h"
#include "wx/window.h"
#include "wx/panel.h"
//-----------------------------------------------------------------------------
// forward decls
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxDialogNameStr;
class wxRadioBox;
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxDialog;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxDialogNameStr;
//-----------------------------------------------------------------------------
// wxDialog
//-----------------------------------------------------------------------------
class wxDialog: public wxWindow
// Dialog boxes
class WXDLLEXPORT wxDialog: public wxPanel
{
DECLARE_DYNAMIC_CLASS(wxDialog)
public:
wxDialog(void);
wxDialog( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE, const wxString &name = wxDialogNameStr );
bool Create( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE, const wxString &name = wxDialogNameStr );
~wxDialog(void);
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(void) const;
bool OnClose(void);
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);
void OnOk( wxCommandEvent &event );
void OnPaint(wxPaintEvent& event);
bool Destroy(void);
void OnCloseWindow(wxCloseEvent& event);
/*
void OnCharHook(wxKeyEvent& event);
*/
virtual bool Show( bool show );
virtual int ShowModal(void);
virtual void EndModal(int retCode);
virtual bool IsModal(void) const { return ((GetWindowStyleFlag() & wxDIALOG_MODAL) == wxDIALOG_MODAL); }
virtual void InitDialog(void);
private:
friend wxWindow;
friend wxDC;
friend wxRadioBox;
bool m_modalShowing;
wxString m_title;
// Responds to colour changes
void OnSysColourChanged(wxSysColourChangedEvent& event);
DECLARE_EVENT_TABLE()
};
#endif // __GTKDIALOGH__
#endif
// _WX_DIALOG_H_

54
include/wx/qt/dirdlg.h
View File

@@ -1,35 +1,47 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dirdlg.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxDirDialog class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __DIRDIALOGH__
#define __DIRDIALOGH__
#ifndef _WX_DIRDLG_H_
#define _WX_DIRDLG_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "dirdlg.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/dialog.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxDirDialog: public wxDialog
{
DECLARE_DYNAMIC_CLASS(wxDirDialog)
public:
wxDirDialog(wxWindow *parent, const wxString& message = wxFileSelectorPromptStr,
const wxString& defaultPath = "",
long style = 0, const wxPoint& pos = wxDefaultPosition);
class wxDirDialog;
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; }
//-----------------------------------------------------------------------------
// wxDirDialog
//-----------------------------------------------------------------------------
inline wxString GetMessage() const { return m_message; }
inline wxString GetPath() const { return m_path; }
inline long GetStyle() const { return m_dialogStyle; }
#endif // __DIRDIALOGH__
int ShowModal();
protected:
wxString m_message;
long m_dialogStyle;
wxWindow * m_parent;
wxString m_path;
};
#endif
// _WX_DIRDLG_H_

103
include/wx/qt/filedlg.h
View File

@@ -1,42 +1,45 @@
/////////////////////////////////////////////////////////////////////////////
// Name: filedlg.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxFileDialog class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFILEDLGH__
#define __GTKFILEDLGH__
#ifndef _WX_FILEDLG_H_
#define _WX_FILEDLG_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "filedlg.h"
#endif
#include "wx/dialog.h"
//-------------------------------------------------------------------------
// File selector
//-------------------------------------------------------------------------
/*
* File selector
*/
extern const char *wxFileSelectorPromptStr;
extern const char *wxFileSelectorDefaultWildcardStr;
WXDLLEXPORT_DATA(extern const char*) wxFileSelectorPromptStr;
WXDLLEXPORT_DATA(extern const char*) wxFileSelectorDefaultWildcardStr;
class wxFileDialog: public wxDialog
class WXDLLEXPORT wxFileDialog: public wxDialog
{
DECLARE_DYNAMIC_CLASS(wxFileDialog)
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() {};
wxFileDialog(wxWindow *parent, const wxString& message = wxFileSelectorPromptStr,
const wxString& defaultDir = "", const wxString& defaultFile = "",
const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
const wxString& defaultDir = "", const wxString& defaultFile = "", const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = 0, const wxPoint& pos = wxDefaultPosition);
inline void SetMessage(const wxString& message) { m_message = message; }
@@ -47,48 +50,40 @@ class wxFileDialog: public wxDialog
inline void SetStyle(long style) { m_dialogStyle = style; }
inline void SetFilterIndex(int filterIndex) { m_filterIndex = filterIndex; }
inline wxString GetMessage(void) const { return m_message; }
inline wxString GetPath(void) const { return m_path; }
inline wxString GetDirectory(void) const { return m_dir; }
inline wxString GetFilename(void) const { return m_fileName; }
inline wxString GetWildcard(void) const { return m_wildCard; }
inline long GetStyle(void) const { return m_dialogStyle; }
inline int GetFilterIndex(void) const { return m_filterIndex ; }
inline wxString GetMessage() const { return m_message; }
inline wxString GetPath() const { return m_path; }
inline wxString GetDirectory() const { return m_dir; }
inline wxString GetFilename() const { return m_fileName; }
inline wxString GetWildcard() const { return m_wildCard; }
inline long GetStyle() const { return m_dialogStyle; }
inline int GetFilterIndex() const { return m_filterIndex ; }
int ShowModal(void);
protected:
wxString m_message;
long m_dialogStyle;
wxWindow * m_parent;
wxString m_dir;
wxString m_path; // Full path
wxString m_fileName;
wxString m_wildCard;
int m_filterIndex;
int ShowModal();
};
#define wxOPEN 1
#define wxSAVE 2
#define wxOVERWRITE_PROMPT 4
#define wxHIDE_READONLY 8
#define wxFILE_MUST_EXIST 16
#define wxOPEN 0x0001
#define wxSAVE 0x0002
#define wxOVERWRITE_PROMPT 0x0004
#define wxHIDE_READONLY 0x0008
#define wxFILE_MUST_EXIST 0x0010
// File selector - backward compatibility
char* wxFileSelector(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
char* WXDLLEXPORT wxFileSelector(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
const char *default_filename = NULL, const char *default_extension = NULL,
const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
wxWindow *parent = NULL, int x = -1, int y = -1);
char* wxLoadFileSelector(const char *what, const char *extension, const char *default_name = NULL,
wxWindow *parent = NULL);
char* wxSaveFileSelector(const char *what, const char *extension, const char *default_name = NULL,
wxWindow *parent = NULL);
// An extended version of wxFileSelector
char* WXDLLEXPORT wxFileSelectorEx(const char *message = wxFileSelectorPromptStr, const char *default_path = NULL,
const char *default_filename = NULL, int *indexDefaultExtension = NULL,
const char *wildcard = wxFileSelectorDefaultWildcardStr, int flags = 0,
wxWindow *parent = NULL, int x = -1, int y = -1);
// Generic file load dialog
char* WXDLLEXPORT wxLoadFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL);
// Generic file save dialog
char* WXDLLEXPORT wxSaveFileSelector(const char *what, const char *extension, const char *default_name = NULL, wxWindow *parent = NULL);
#endif
// __GTKFILEDLGH__
// _WX_FILEDLG_H_

143
include/wx/qt/font.h
View File

@@ -1,87 +1,88 @@
/////////////////////////////////////////////////////////////////////////////
// Name: font.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxFont class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFONTH__
#define __GTKFONTH__
#ifndef _WX_FONT_H_
#define _WX_FONT_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "font.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/hash.h"
#include "wx/gdiobj.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxFont;
class wxDC;
class wxPaintDC;
class wxWindow;
class wxFont;
class wxFontNameDirectory;
//-----------------------------------------------------------------------------
// global variables
//-----------------------------------------------------------------------------
// extern wxFontNameDirectory wxTheFontNameDirectory; // defined below
//-----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
class wxFont: public wxGDIObject
class WXDLLEXPORT wxFontRefData: public wxGDIRefData
{
DECLARE_DYNAMIC_CLASS(wxFont)
friend class WXDLLEXPORT wxFont;
public:
wxFont(void);
wxFont( int PointSize, int FontIdOrFamily, int Style, int Weight,
bool underlined = FALSE, const char *Face=NULL );
wxFont( int PointSize, const char *Face, int Family, int Style, int Weight,
bool underlined = FALSE );
wxFont( const wxFont& font );
wxFont( const wxFont* font );
~wxFont(void);
wxFont& operator = ( const wxFont& font );
bool operator == ( const wxFont& font );
bool operator != ( const wxFont& font );
bool Ok();
int GetPointSize(void) const;
wxString GetFaceName(void) const;
int GetFamily(void) const;
wxString GetFamilyString(void) const;
int GetFontId(void) const;
wxString GetFaceString(void) const;
int GetStyle(void) const;
wxString GetStyleString(void) const;
int GetWeight(void) const;
wxString GetWeightString(void) const;
bool GetUnderlined(void) const;
wxFont( char *xFontName );
private:
friend wxDC;
friend wxPaintDC;
friend wxWindow;
// no data :-)
wxFontRefData();
~wxFontRefData();
protected:
int m_pointSize;
int m_family;
int m_style;
int m_weight;
bool m_underlined;
wxString m_faceName;
/* TODO: implementation
WXHFONT m_hFont;
*/
};
#endif // __GTKFONTH__
#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:
void Unshare();
};
#endif
// _WX_FONT_H_

188
include/wx/qt/frame.h
View File

@@ -1,112 +1,156 @@
/////////////////////////////////////////////////////////////////////////////
// Name: frame.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxFrame class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFRAMEH__
#define __GTKFRAMEH__
#ifndef _WX_FRAME_H_
#define _WX_FRAME_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "frame.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/window.h"
#include "wx/toolbar.h"
#include "wx/accel.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr;
WXDLLEXPORT_DATA(extern const char*) wxToolBarNameStr;
class wxMDIChildFrame;
class wxMDIClientWindow;
class wxMenu;
class wxMenuBar;
class wxToolBar;
class wxStatusBar;
class WXDLLEXPORT wxMenuBar;
class WXDLLEXPORT wxStatusBar;
class wxFrame;
class WXDLLEXPORT wxFrame: public wxWindow {
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxFrameNameStr;
extern const char *wxToolBarNameStr;
//-----------------------------------------------------------------------------
// wxFrame
//-----------------------------------------------------------------------------
class wxFrame: public wxWindow
{
DECLARE_DYNAMIC_CLASS(wxFrame)
public:
wxFrame();
wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE, const wxString &name = wxFrameNameStr );
bool Create( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE, const wxString &name = wxFrameNameStr );
inline wxFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Create(parent, id, title, pos, size, style, name);
}
~wxFrame();
bool Destroy();
virtual bool Show( bool show );
virtual void Enable( bool enable );
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual void GetClientSize( int *width, int *height ) const;
virtual bool Destroy();
void SetClientSize(int width, int height);
void GetClientSize(int *width, int *height) const;
// set minimal/maxmimal size for the frame
virtual void SetSizeHints( int minW, int minH, int maxW, int maxH, int incW = -1 );
void 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 wxStatusBar* CreateStatusBar(int number=1, long style = wxST_SIZEGRIP, wxWindowID id = 0,
const wxString& name = "statusBar");
virtual wxStatusBar *GetStatusBar();
virtual void SetStatusText( const wxString &text, int number = 0 );
virtual void SetStatusWidths( int n, int *width );
virtual bool OnClose();
virtual wxToolBar* CreateToolBar( long style = wxNO_BORDER|wxTB_HORIZONTAL, wxWindowID id = -1,
const wxString& name = wxToolBarNameStr);
virtual wxToolBar *GetToolBar();
void OnSize(wxSizeEvent& event);
void OnMenuHighlight(wxMenuEvent& event);
void OnActivate(wxActivateEvent& event);
void OnIdle(wxIdleEvent& event);
void OnCloseWindow(wxCloseEvent& event);
virtual void SetMenuBar( wxMenuBar *menuBar );
virtual wxMenuBar *GetMenuBar();
bool Show(bool show);
virtual void SetTitle( const wxString &title );
virtual wxString GetTitle() const { return m_title; }
// Set menu bar
void SetMenuBar(wxMenuBar *menu_bar);
virtual wxMenuBar *GetMenuBar() const ;
// Set title
void SetTitle(const wxString& title);
wxString GetTitle() const ;
void Centre(int direction = wxBOTH);
// Call this to simulate a menu command
virtual void Command(int id);
virtual void ProcessCommand(int id);
// Set icon
virtual void SetIcon(const wxIcon& icon);
void OnActivate( wxActivateEvent &WXUNUSED(event) ) { } // called from docview.cpp
void OnSize( wxSizeEvent &event );
void OnCloseWindow( wxCloseEvent& event );
void OnIdle(wxIdleEvent& event);
// 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);
private:
friend wxWindow;
friend wxMDIChildFrame;
friend wxMDIClientWindow;
// Create toolbar
virtual wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL, wxWindowID id = -1, const wxString& name = wxToolBarNameStr);
virtual wxToolBar *OnCreateToolBar(long style, wxWindowID id, const wxString& name);
// If made known to the frame, the frame will manage it automatically.
virtual inline void SetToolBar(wxToolBar *toolbar) { m_frameToolBar = toolbar; }
virtual inline wxToolBar *GetToolBar() const { return m_frameToolBar; }
virtual void PositionToolBar();
// update frame's menus (called from OnIdle)
// Set status line text
virtual void SetStatusText(const wxString& text, int number = 0);
// Set status line widths
virtual void SetStatusWidths(int n, const int widths_field[]);
// Hint to tell framework which status bar to use
// TODO: should this go into a wxFrameworkSettings class perhaps?
static void UseNativeStatusBar(bool useNative) { m_useNativeStatusBar = useNative; };
static bool UsesNativeStatusBar() { return m_useNativeStatusBar; };
// Fit frame around subwindows
virtual void Fit();
// Iconize
virtual void Iconize(bool iconize);
virtual bool IsIconized() const ;
// Compatibility
inline bool Iconized() const { return IsIconized(); }
virtual void Maximize(bool maximize);
virtual void SetAcceleratorTable(const wxAcceleratorTable& accel);
// Responds to colour changes
void OnSysColourChanged(wxSysColourChangedEvent& event);
// Query app for menu item updates (called from OnIdle)
void DoMenuUpdates();
void DoMenuUpdates(wxMenu* menu);
// Checks if there is a toolbar, and returns the first free client position
virtual wxPoint GetClientAreaOrigin() const;
protected:
wxMenuBar * m_frameMenuBar;
wxStatusBar * m_frameStatusBar;
wxToolBar *m_frameToolBar;
int m_toolBarHeight;
wxString m_title;
wxIcon m_icon;
bool m_iconized;
static bool m_useNativeStatusBar;
wxToolBar * m_frameToolBar ;
wxAcceleratorTable m_acceleratorTable;
DECLARE_EVENT_TABLE()
};
#endif // __GTKFRAMEH__
#endif
// _WX_FRAME_H_

72
include/wx/qt/gauge.h
View File

@@ -1,83 +1,69 @@
/////////////////////////////////////////////////////////////////////////////
// Name: gauge.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxGauge class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKGAUGEH__
#define __GTKGAUGEH__
#ifndef _WX_GAUGE_H_
#define _WX_GAUGE_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "gauge.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxGaugeNameStr;
class wxGauge;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char* wxGaugeNameStr;
//-----------------------------------------------------------------------------
// wxGaugeBox
//-----------------------------------------------------------------------------
class wxGauge: public wxControl
// Group box
class WXDLLEXPORT wxGauge: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxGauge)
public:
inline wxGauge(void) { m_rangeMax = 0; m_gaugePos = 0; m_useProgressBar = TRUE; }
inline wxGauge() { m_rangeMax = 0; m_gaugePos = 0; }
inline wxGauge(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr)
{
Create(parent, id, range, pos, size, style, name);
};
Create(parent, id, range, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr);
void SetShadowWidth( int WXUNUSED(w) ) {};
void SetBezelFace( int WXUNUSED(w) ) {};
void SetShadowWidth(int w);
void SetBezelFace(int w);
void SetRange(int r);
void SetValue(int pos);
int GetShadowWidth(void) const { return 0; };
int GetBezelFace(void) const { return 0; };
int GetRange(void) const;
int GetValue(void) const;
// Are we a Win95/GTK progress bar, or a normal gauge?
inline bool GetProgressBar(void) const { return m_useProgressBar; }
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;
bool m_useProgressBar;
};
#endif // __GTKGAUGEH__
#endif
// _WX_GAUGE_H_

37
include/wx/qt/gdiobj.h
View File

@@ -1,31 +1,42 @@
/////////////////////////////////////////////////////////////////////////////
// Name: gdiobj.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxGDIObject class: base class for other GDI classes
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GDIOBJH__
#define __GDIOBJH__
#ifndef _WX_GDIOBJ_H_
#define _WX_GDIOBJ_H_
#include "wx/object.h"
#ifdef __GNUG__
#pragma interface
#pragma interface "gdiobj.h"
#endif
class WXDLLEXPORT wxGDIRefData: public wxObjectRefData {
public:
inline wxGDIRefData()
{
}
};
#define M_GDIDATA ((wxGDIRefData *)m_refData)
class WXDLLEXPORT wxGDIObject: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxGDIObject)
public:
inline wxGDIObject(void) { m_visible = FALSE; };
inline ~wxGDIObject(void) {};
inline wxGDIObject() { m_visible = FALSE; };
inline ~wxGDIObject() {};
virtual bool GetVisible(void) { return m_visible; }
inline bool IsNull() const { return (m_refData == 0); }
virtual bool GetVisible() { return m_visible; }
virtual void SetVisible(bool v) { m_visible = v; }
protected:
@@ -34,4 +45,4 @@ protected:
};
#endif
// __GDIOBJH__
// _WX_GDIOBJ_H_

102
include/wx/qt/icon.h
View File

@@ -1,51 +1,107 @@
/////////////////////////////////////////////////////////////////////////////
// Name: icon.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxIcon class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKICONH__
#define __GTKICONH__
#ifndef _WX_ICON_H_
#define _WX_ICON_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "icon.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxIconRefData: public wxBitmapRefData
{
friend class WXDLLEXPORT wxBitmap;
friend class WXDLLEXPORT wxIcon;
public:
wxIconRefData();
~wxIconRefData();
class wxIcon;
public:
/* TODO: whatever your actual icon handle is
WXHICON m_hIcon;
*/
};
//-----------------------------------------------------------------------------
// wxIcon
//-----------------------------------------------------------------------------
#define M_ICONDATA ((wxIconRefData *)m_refData)
#define M_ICONHANDLERDATA ((wxIconRefData *)bitmap->GetRefData())
class wxIcon: public wxBitmap
// Icon
class WXDLLEXPORT wxIcon: public wxBitmap
{
DECLARE_DYNAMIC_CLASS(wxIcon)
public:
wxIcon();
wxIcon(void) {};
// Copy constructors
inline wxIcon(const wxIcon& icon) { Ref(icon); }
inline wxIcon(const wxIcon* icon) { if (icon) Ref(*icon); }
wxIcon( char **bits, int width=-1, int height=-1 );
wxIcon(const char bits[], int width, int height);
wxIcon(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE,
int desiredWidth = -1, int desiredHeight = -1);
~wxIcon();
bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE,
int desiredWidth = -1, int desiredHeight = -1);
inline wxIcon& operator = (const wxIcon& icon) { if (*this == icon) return (*this); Ref(icon); return *this; }
inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; }
inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; }
/* TODO: implementation
void SetHICON(WXHICON ico);
inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); }
*/
/* TODO */
virtual bool Ok() const { return (m_refData != NULL) ; }
};
/* Example handlers. TODO: write your own handlers for relevant types.
#endif // __GTKICONH__
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_

105
include/wx/qt/joystick.h
View File

@@ -1,25 +1,24 @@
/////////////////////////////////////////////////////////////////////////////
// Name: joystick.h
// Purpose: wxJoystick class
// Author: Guilhem Lavaux
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright:
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __JOYSTICKH__
#define __JOYSTICKH__
#ifndef _WX_JOYSTICK_H_
#define _WX_JOYSTICK_H_
#ifdef __GNUG__
#pragma interface "joystick.h"
#endif
#include "wx/event.h"
#include "wx/thread.h"
class WXDLLEXPORT wxJoystick: public wxObject, public wxThread
class WXDLLEXPORT wxJoystick: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxJoystick)
public:
@@ -27,56 +26,56 @@ class WXDLLEXPORT wxJoystick: public wxObject, public wxThread
* Public interface
*/
wxJoystick(int joystick = wxJOYSTICK1);
wxJoystick(int joystick = wxJOYSTICK1) { m_joystick = joystick; };
// Attributes
////////////////////////////////////////////////////////////////////////////
wxPoint GetPosition(void) const;
int GetZPosition(void) const;
int GetButtonState(void) const;
int GetPOVPosition(void) const;
int GetPOVCTSPosition(void) const;
int GetRudderPosition(void) const;
int GetUPosition(void) const;
int GetVPosition(void) const;
int GetMovementThreshold(void) const;
wxPoint GetPosition() const;
int GetZPosition() const;
int GetButtonState() const;
int GetPOVPosition() const;
int GetPOVCTSPosition() const;
int GetRudderPosition() const;
int GetUPosition() const;
int GetVPosition() const;
int GetMovementThreshold() const;
void SetMovementThreshold(int threshold) ;
// Capabilities
////////////////////////////////////////////////////////////////////////////
bool IsOk(void) const; // Checks that the joystick is functioning
int GetNumberJoysticks(void) const ;
int GetManufacturerId(void) const ;
int GetProductId(void) const ;
wxString GetProductName(void) const ;
int GetXMin(void) const;
int GetYMin(void) const;
int GetZMin(void) const;
int GetXMax(void) const;
int GetYMax(void) const;
int GetZMax(void) const;
int GetNumberButtons(void) const;
int GetNumberAxes(void) const;
int GetMaxButtons(void) const;
int GetMaxAxes(void) const;
int GetPollingMin(void) const;
int GetPollingMax(void) const;
int GetRudderMin(void) const;
int GetRudderMax(void) const;
int GetUMin(void) const;
int GetUMax(void) const;
int GetVMin(void) const;
int GetVMax(void) const;
bool 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(void) const;
bool HasZ(void) const;
bool HasU(void) const;
bool HasV(void) const;
bool HasPOV(void) const;
bool HasPOV4Dir(void) const;
bool HasPOVCTS(void) const;
bool HasRudder() const;
bool HasZ() const;
bool HasU() const;
bool HasV() const;
bool HasPOV() const;
bool HasPOV4Dir() const;
bool HasPOVCTS() const;
// Operations
////////////////////////////////////////////////////////////////////////////
@@ -84,19 +83,11 @@ class WXDLLEXPORT wxJoystick: public wxObject, public wxThread
// pollingFreq = 0 means that movement events are sent when above the threshold.
// If pollingFreq > 0, events are received every this many milliseconds.
bool SetCapture(wxWindow* win, int pollingFreq = 0);
bool ReleaseCapture(void);
bool ReleaseCapture();
protected:
int m_joystick;
wxPoint m_lastposition;
int m_axe[15];
int m_buttons;
wxWindow *m_catchwin;
int m_polling;
void *Entry(void);
};
#endif
// __JOYSTICKH__
// _WX_JOYSTICK_H_

131
include/wx/qt/listbox.h
View File

@@ -1,78 +1,97 @@
/////////////////////////////////////////////////////////////////////////////
// Name: listbox.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxListBox class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKLISTBOXH__
#define __GTKLISTBOXH__
#ifndef _WX_LISTBOX_H_
#define _WX_LISTBOX_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "listbox.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxListBoxNameStr;
class wxListBox;
// forward decl for GetSelections()
class WXDLLEXPORT wxArrayInt;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
extern const char *wxListBoxNameStr;
//-----------------------------------------------------------------------------
// wxListBox
//-----------------------------------------------------------------------------
class wxListBox: public wxControl
// List box item
class WXDLLEXPORT wxListBox: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxListBox)
public:
wxListBox(void);
wxListBox( wxWindow *parent, wxWindowID id,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
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 wxString &name = wxListBoxNameStr );
bool Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0, const wxString &name = wxListBoxNameStr );
void Append( const wxString &item );
void Append( const wxString &item, char *clientData );
void Clear(void);
void Delete( int n );
void Deselect( int n );
int FindString( const wxString &item ) const;
char *GetClientData( int n ) const;
int GetSelection(void) const;
int GetSelections( class wxArrayInt &) const;
wxString GetString( int n ) const;
wxString GetStringSelection(void) const;
int Number(void);
bool Selected( int n );
void Set( int n, const wxString *choices );
void SetClientData( int n, char *clientData );
void SetFirstItem( int n );
void SetFirstItem( const wxString &item );
void SetSelection( int n, bool select = TRUE );
void SetString( int n, const wxString &string );
void SetStringSelection( const wxString &string, bool select = TRUE );
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 // __GTKLISTBOXH__
#endif
// _WX_LISTBOX_H_

247
include/wx/qt/mdi.h
View File

@@ -1,181 +1,160 @@
/////////////////////////////////////////////////////////////////////////////
// Name: mdi.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: MDI (Multiple Document Interface) classes.
// This doesn't have to be implemented just like Windows,
// it could be a tabbed design as in wxGTK.
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __MDIH__
#define __MDIH__
#ifndef _WX_MDI_H_
#define _WX_MDI_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "mdi.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/panel.h"
#include "wx/frame.h"
#include "wx/toolbar.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr;
WXDLLEXPORT_DATA(extern const char*) wxStatusLineNameStr;
class wxMDIParentFrame;
class wxMDIClientWindow;
class wxMDIChildFrame;
class WXDLLEXPORT wxMDIClientWindow;
class WXDLLEXPORT wxMDIChildFrame;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char* wxFrameNameStr;
extern const char* wxStatusLineNameStr;
//-----------------------------------------------------------------------------
// wxMDIParentFrame
//-----------------------------------------------------------------------------
class wxMDIParentFrame: public wxFrame
class WXDLLEXPORT wxMDIParentFrame: public wxFrame
{
DECLARE_DYNAMIC_CLASS(wxMDIParentFrame)
friend class wxMDIChildFrame;
friend class WXDLLEXPORT wxMDIChildFrame;
public:
wxMDIParentFrame(void);
wxMDIParentFrame( wxWindow *parent,
wxWindowID id, const wxString& title,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
const wxString& name = wxFrameNameStr );
~wxMDIParentFrame(void);
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,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
const wxString& name = wxFrameNameStr);
void GetClientSize(int *width, int *height) const;
wxMDIChildFrame *GetActiveChild(void) const;
wxMDIClientWindow *GetClientWindow(void) const;
virtual wxMDIClientWindow *OnCreateClient(void);
virtual void Cascade(void) {};
virtual void Tile(void) {};
virtual void ArrangeIcons(void) {};
virtual void ActivateNext(void);
virtual void ActivatePrevious(void);
void OnSize(wxSizeEvent& event);
void OnActivate(wxActivateEvent& event);
void OnSysColourChanged( wxSysColourChangedEvent& event );
//private:
void SetMenuBar(wxMenuBar *menu_bar);
wxMDIChildFrame *m_currentChild;
// 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;
void SetMDIMenuBar( wxMenuBar *menu_bar );
// Get the active MDI child window (Windows only)
wxMDIChildFrame *GetActiveChild() const ;
private:
// Get the client window
inline wxMDIClientWindow *GetClientWindow() const { return m_clientWindow; };
wxMDIClientWindow *m_clientWindow;
bool m_parentFrameActive;
wxMenuBar *m_mdiMenuBar;
// Create the client window class (don't Create the window,
// just return a new class)
virtual wxMDIClientWindow *OnCreateClient() ;
// MDI operations
virtual void Cascade();
virtual void Tile();
virtual void ArrangeIcons();
virtual void ActivateNext();
virtual void ActivatePrevious();
protected:
DECLARE_EVENT_TABLE()
};
//-----------------------------------------------------------------------------
// wxMDIChildFrame
//-----------------------------------------------------------------------------
class wxMDIChildFrame: public wxFrame
class WXDLLEXPORT wxMDIChildFrame: public wxFrame
{
DECLARE_DYNAMIC_CLASS(wxMDIChildFrame)
public:
wxMDIChildFrame(void);
wxMDIChildFrame( wxMDIParentFrame *parent,
wxWindowID id, const wxString& title,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE, const wxString& name = wxFrameNameStr );
~wxMDIChildFrame(void);
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 );
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual void SetMenuBar( wxMenuBar *menu_bar );
virtual wxMenuBar *GetMenuBar();
// Set menu bar
void SetMenuBar(wxMenuBar *menu_bar);
void SetClientSize(int width, int height);
void GetPosition(int *x, int *y) const ;
virtual void GetClientSize( int *width, int *height ) const;
virtual void AddChild( wxWindow *child );
// MDI operations
virtual void Maximize();
virtual void Restore();
virtual void Activate();
};
virtual void Activate(void);
// no status bars
virtual wxStatusBar* CreateStatusBar( int WXUNUSED(number), long WXUNUSED(style),
wxWindowID WXUNUSED(id), const wxString& WXUNUSED(name) ) {return (wxStatusBar*)NULL; }
virtual wxStatusBar *GetStatusBar() { return (wxStatusBar*)NULL; }
virtual void SetStatusText( const wxString &WXUNUSED(text), int WXUNUSED(number) ) {}
virtual void SetStatusWidths( int WXUNUSED(n), int *WXUNUSED(width) ) {}
// no size hints
virtual void SetSizeHints( int WXUNUSED(minW), int WXUNUSED(minH), int WXUNUSED(maxW),
int WXUNUSED(maxH), int WXUNUSED(incW) ) {}
// no toolbar bars
virtual wxToolBar* CreateToolBar( long WXUNUSED(style), wxWindowID WXUNUSED(id),
const wxString& WXUNUSED(name) ) { return (wxToolBar*)NULL; }
virtual wxToolBar *GetToolBar() { return (wxToolBar*)NULL; }
// no icon
void SetIcon( const wxIcon &icon ) { m_icon = icon; }
// no title
void SetTitle( const wxString &title ) { m_title = title; }
wxString GetTitle() const { return m_title; }
// no maximize etc
virtual void Maximize(void) {}
virtual void Restore(void) {}
void OnActivate( wxActivateEvent &event );
/* 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:
wxMenuBar *m_menuBar;
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()
};
//-----------------------------------------------------------------------------
// wxMDIClientWindow
//-----------------------------------------------------------------------------
class wxMDIClientWindow: public wxWindow
{
DECLARE_DYNAMIC_CLASS(wxMDIClientWindow)
public:
wxMDIClientWindow(void);
wxMDIClientWindow( wxMDIParentFrame *parent, long style = 0 );
~wxMDIClientWindow(void);
virtual bool CreateClient( wxMDIParentFrame *parent, long style = wxVSCROLL | wxHSCROLL );
void AddChild( wxWindow *child );
};
#endif // __MDIH__
#endif
// _WX_MDI_H_

254
include/wx/qt/menu.h
View File

@@ -1,155 +1,157 @@
/////////////////////////////////////////////////////////////////////////////
// Name: menu.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxMenu, wxMenuBar classes
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKMENUH__
#define __GTKMENUH__
#ifndef _WX_MENU_H_
#define _WX_MENU_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "menu.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/window.h"
#include "wx/event.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxMenuItem;
class WXDLLEXPORT wxMenuBar;
class WXDLLEXPORT wxMenu;
class wxMenuBar;
class wxMenuItem;
class wxMenu;
WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
//-----------------------------------------------------------------------------
// const
//-----------------------------------------------------------------------------
#define ID_SEPARATOR (-1)
//-----------------------------------------------------------------------------
// wxMenuBar
//-----------------------------------------------------------------------------
class wxMenuBar: public wxWindow
{
DECLARE_DYNAMIC_CLASS(wxMenuBar)
public:
wxMenuBar();
void Append( wxMenu *menu, const wxString &title );
int FindMenuItem( const wxString &menuString, const wxString &itemString ) const;
wxMenuItem* FindMenuItemById( int id ) const;
void Check( int id, bool check );
bool Checked( int id ) const;
void Enable( int id, bool enable );
bool Enabled( int id ) const;
inline bool IsEnabled(int Id) const { return Enabled(Id); };
inline bool IsChecked(int Id) const { return Checked(Id); };
int GetMenuCount() const { return m_menus.Number(); }
wxMenu *GetMenu(int n) const { return (wxMenu *)m_menus.Nth(n)->Data(); }
wxList m_menus;
};
//-----------------------------------------------------------------------------
// wxMenu
//-----------------------------------------------------------------------------
class wxMenuItem: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxMenuItem)
public:
wxMenuItem();
// accessors
// id
void SetId(int id) { m_id = id; }
int GetId() const { return m_id; }
bool IsSeparator() const { return m_id == ID_SEPARATOR; }
// the item's text
void SetText(const wxString& str);
const wxString& GetText() const { return m_text; }
// what kind of menu item we are
void SetCheckable(bool checkable) { m_isCheckMenu = checkable; }
bool IsCheckable() const { return m_isCheckMenu; }
void SetSubMenu(wxMenu *menu) { m_subMenu = menu; }
wxMenu *GetSubMenu() const { return m_subMenu; }
bool IsSubMenu() const { return m_subMenu != NULL; }
// state
void Enable(bool enable = TRUE) { m_isEnabled = enable; }
bool IsEnabled() const { return m_isEnabled; }
void Check(bool check = TRUE);
bool IsChecked() const;
// help string (displayed in the status bar by default)
void SetHelpString(const wxString& str) { m_helpStr = str; }
private:
int m_id;
wxString m_text;
bool m_isCheckMenu;
bool m_isChecked;
bool m_isEnabled;
wxMenu *m_subMenu;
wxString m_helpStr;
};
class wxMenu: public wxEvtHandler
// ----------------------------------------------------------------------------
// Menu
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxMenu: public wxEvtHandler
{
DECLARE_DYNAMIC_CLASS(wxMenu)
public:
// construction
wxMenu( const wxString &title = "" );
// ctor & dtor
wxMenu(const wxString& title = wxEmptyString, const wxFunction func = NULL);
~wxMenu();
// operations
// menu creation
// construct menu
// append items to the menu
// separator line
void AppendSeparator();
void Append(int id, const wxString &item,
const wxString &helpStr = "", bool checkable = FALSE);
void Append(int id, const wxString &item,
wxMenu *subMenu, const wxString &helpStr = "" );
void Break() {};
// 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);
// find item by name/id
int FindItem( const wxString itemString ) const;
wxMenuItem *FindItem(int id) const;
// get/set item's state
void Enable( int id, bool enable );
bool IsEnabled( int id ) const;
void Check( int id, bool check );
bool IsChecked( int id ) const;
// 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 ;
// accessors
wxList& GetItems() { return m_items; }
// find item
// Finds the item id matching the given string, -1 if not found.
virtual int FindItem(const wxString& itemString) const ;
// Find wxMenuItem by ID, and item's menu too if itemMenu is !NULL.
wxMenuItem *FindItemForId(int itemId, wxMenu **itemMenu = NULL) const;
void ProcessCommand(wxCommandEvent& event);
inline void Callback(const wxFunction func) { m_callback = func; }
virtual void SetParent(wxEvtHandler *parent) { m_parent = parent; }
inline void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; }
inline wxEvtHandler *GetEventHandler() { return m_eventHandler; }
inline wxList& GetItems() const { return (wxList&) m_menuItems; }
public:
void SetInvokingWindow( wxWindow *win );
wxWindow *GetInvokingWindow();
wxFunction m_callback;
int m_noItems;
wxString m_title;
wxList m_items;
wxWindow *m_invokingWindow;
wxMenuBar * m_menuBar;
wxList m_menuItems;
wxEvtHandler * m_parent;
wxEvtHandler * m_eventHandler;
};
#endif // __GTKMENUH__
// ----------------------------------------------------------------------------
// 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_

93
include/wx/qt/notebook.h
View File

@@ -1,38 +1,41 @@
/////////////////////////////////////////////////////////////////////////////
// Name: notebook.h
// Purpose: wxNotebook class
// Author: Robert Roebling
// Purpose: MSW/GTK compatible notebook (a.k.a. property sheet)
// Author: AUTHOR
// Modified by:
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __NOTEBOOKH__
#define __NOTEBOOKH__
#ifndef _WX_NOTEBOOK_H_
#define _WX_NOTEBOOK_H_
#ifdef __GNUG__
#pragma interface "notebook.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/control.h"
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include <wx/dynarray.h>
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// types
// ----------------------------------------------------------------------------
class wxImageList;
class wxNotebook;
class wxNotebookPage;
// 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 wxNotebookEvent : public wxCommandEvent
class WXDLLEXPORT wxNotebookEvent : public wxCommandEvent
{
public:
wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0,
@@ -50,10 +53,13 @@ private:
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:
@@ -90,7 +96,7 @@ public:
// cycle thru the tabs
void AdvanceSelection(bool bForward = TRUE);
// get the currently selected page
int GetSelection() const;
int GetSelection() const { return m_nSelection; }
// set/get the title of a page
bool SetPageText(int nPage, const wxString& strText);
@@ -104,7 +110,7 @@ public:
// associate image list with a control
void SetImageList(wxImageList* imageList);
// get pointer (may be NULL) to the associated image list
wxImageList* GetImageList() const { return m_imageList; }
wxImageList* GetImageList() const { return m_pImageList; }
// sets/returns item's image index in the current image list
int GetPageImage(int nPage) const;
@@ -128,30 +134,46 @@ public:
bool DeleteAllPages();
// adds a new page to the notebook (it will be deleted ny the notebook,
// don't delete it yourself). If bSelect, this page becomes active.
bool AddPage(wxWindow *pPage,
bool AddPage(wxNotebookPage *pPage,
const wxString& strText,
bool bSelect = FALSE,
int imageId = -1);
// 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);
// @@@@ VZ: I don't know how to implement InsertPage()
// get the panel which represents the given page
wxWindow *GetPage(int nPage) const;
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);
// implementation
// --------------
// base class virtuals
virtual void AddChild(wxWindow *child);
virtual void SetConstraintSizes(bool recurse);
virtual bool DoPhase(int phase);
// -------------------
virtual void Command(wxCommandEvent& event);
virtual void SetConstraintSizes(bool recurse = TRUE);
virtual bool DoPhase(int nPhase);
private:
protected:
// common part of all ctors
void Init();
wxImageList* m_imageList;
wxList m_pages;
// helper functions
void ChangePage(int nOldSel, int nSel); // change pages
wxImageList *m_pImageList; // we can have an associated image list
wxArrayPages m_aPages; // array of pages
int m_nSelection; // the current selection (-1 if none)
DECLARE_DYNAMIC_CLASS(wxNotebook)
DECLARE_EVENT_TABLE()
};
// ----------------------------------------------------------------------------
@@ -177,5 +199,4 @@ typedef void (wxEvtHandler::*wxNotebookEventFunction)(wxNotebookEvent&);
NULL \
},
#endif
// __NOTEBOOKH__
#endif // _WX_NOTEBOOK_H_

74
include/wx/qt/palette.h
View File

@@ -1,60 +1,66 @@
/////////////////////////////////////////////////////////////////////////////
// Name: palette.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxPalette class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKPALETTEH__
#define __GTKPALETTEH__
#ifndef _WX_PALETTE_H_
#define _WX_PALETTE_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "palette.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxPalette;
class wxPalette;
class WXDLLEXPORT wxPaletteRefData: public wxGDIRefData
{
friend class WXDLLEXPORT wxPalette;
public:
wxPaletteRefData();
~wxPaletteRefData();
/* TODO: implementation
protected:
WXHPALETTE m_hPalette;
*/
};
//-----------------------------------------------------------------------------
// wxPalette
//-----------------------------------------------------------------------------
#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
class wxPalette: public wxGDIObject
class WXDLLEXPORT wxPalette: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxPalette)
public:
wxPalette();
inline wxPalette(const wxPalette& palette) { Ref(palette); }
inline wxPalette(const wxPalette* palette) { UnRef(); if (palette) Ref(*palette); }
wxPalette(void);
wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
wxPalette( const wxPalette& palette );
wxPalette( const wxPalette* palette );
~wxPalette(void);
wxPalette& operator = ( const wxPalette& palette );
bool operator == ( const wxPalette& palette );
bool operator != ( const wxPalette& palette );
bool Ok(void) const;
~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;
// no data
virtual bool Ok() const { return (m_refData != NULL) ; }
inline wxPalette& operator = (const wxPalette& palette) { if (*this == palette) return (*this); Ref(palette); return *this; }
inline bool operator == (const wxPalette& palette) { return m_refData == palette.m_refData; }
inline bool operator != (const wxPalette& palette) { return m_refData != palette.m_refData; }
virtual bool FreeResource(bool force = FALSE);
/* TODO: implementation
inline WXHPALETTE GetHPALETTE() const { return (M_PALETTEDATA ? M_PALETTEDATA->m_hPalette : 0); }
void SetHPALETTE(WXHPALETTE pal);
*/
};
#define wxColorMap wxPalette
#define wxColourMap wxPalette
#endif // __GTKPALETTEH__
#endif
// _WX_PALETTE_H_

134
include/wx/qt/pen.h
View File

@@ -1,68 +1,102 @@
/////////////////////////////////////////////////////////////////////////////
// Name: pen.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxPen class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKPENH__
#define __GTKPENH__
#ifndef _WX_PEN_H_
#define _WX_PEN_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "pen.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
typedef WXDWORD wxDash ;
class wxPen;
class WXDLLEXPORT wxPen;
//-----------------------------------------------------------------------------
// wxPen
//-----------------------------------------------------------------------------
class wxPen: public wxGDIObject
class WXDLLEXPORT wxPenRefData: public wxGDIRefData
{
DECLARE_DYNAMIC_CLASS(wxPen)
friend class WXDLLEXPORT wxPen;
public:
wxPenRefData();
wxPenRefData(const wxPenRefData& data);
~wxPenRefData();
wxPen(void);
wxPen( const wxColour &colour, int width, int style );
wxPen( const wxString &colourName, int width, int style );
wxPen( const wxPen& pen );
wxPen( const wxPen* pen );
~wxPen(void);
wxPen& operator = ( const wxPen& pen );
bool operator == ( const wxPen& pen );
bool operator != ( const wxPen& pen );
void SetColour( const wxColour &colour );
void SetColour( const wxString &colourName );
void SetColour( int red, int green, int blue );
void SetCap( int capStyle );
void SetJoin( int joinStyle );
void SetStyle( int style );
void SetWidth( int width );
wxColour &GetColour(void) const;
int GetCap(void) const;
int GetJoin(void) const;
int GetStyle(void) const;
int GetWidth(void) const;
bool Ok(void) const;
// no data :-)
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;
*/
};
#endif // __GTKPENH__
#define M_PENDATA ((wxPenRefData *)m_refData)
// Pen
class WXDLLEXPORT wxPen: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxPen)
public:
wxPen();
wxPen(const wxColour& col, int width, int style);
wxPen(const wxString& col, int width, int style);
wxPen(const wxBitmap& stipple, int width);
inline wxPen(const wxPen& pen) { Ref(pen); }
inline wxPen(const wxPen* pen) { if (pen) Ref(*pen); }
~wxPen();
inline wxPen& operator = (const wxPen& pen) { if (*this == pen) return (*this); Ref(pen); return *this; }
inline bool operator == (const wxPen& pen) { return m_refData == pen.m_refData; }
inline bool operator != (const wxPen& pen) { return m_refData != pen.m_refData; }
virtual bool Ok() const { return (m_refData != NULL) ; }
// Override in order to recreate the pen
void SetColour(const wxColour& col) ;
void SetColour(const wxString& col) ;
void SetColour(const unsigned char r, const unsigned char g, const unsigned char b) ;
void SetWidth(int width) ;
void SetStyle(int style) ;
void SetStipple(const wxBitmap& stipple) ;
void SetDashes(int nb_dashes, const wxDash *dash) ;
void SetJoin(int join) ;
void SetCap(int cap) ;
inline wxColour& GetColour() const { return (M_PENDATA ? M_PENDATA->m_colour : wxNullColour); };
inline int GetWidth() const { return (M_PENDATA ? M_PENDATA->m_width : 0); };
inline int GetStyle() const { return (M_PENDATA ? M_PENDATA->m_style : 0); };
inline int GetJoin() const { return (M_PENDATA ? M_PENDATA->m_join : 0); };
inline int GetCap() const { return (M_PENDATA ? M_PENDATA->m_cap : 0); };
inline int GetDashes(wxDash **ptr) const {
*ptr = (M_PENDATA ? M_PENDATA->m_dash : NULL); return (M_PENDATA ? M_PENDATA->m_nbDash : 0);
}
inline wxBitmap *GetStipple() const { return (M_PENDATA ? (& M_PENDATA->m_stipple) : NULL); };
// 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_PEN_H_

96
include/wx/qt/radiobox.h
View File

@@ -1,80 +1,88 @@
/////////////////////////////////////////////////////////////////////////////
// Name: radiobox.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxRadioBox class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKRADIOBOXH__
#define __GTKRADIOBOXH__
#ifndef _WX_RADIOBOX_H_
#define _WX_RADIOBOX_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "radiobox.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxRadioBoxNameStr;
class wxRadioBox;
// List box item
class WXDLLEXPORT wxBitmap ;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxRadioBoxNameStr;
//-----------------------------------------------------------------------------
// wxRadioBox
//-----------------------------------------------------------------------------
class wxRadioBox: public wxControl
class WXDLLEXPORT wxRadioBox: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxRadioBox)
public:
wxRadioBox();
wxRadioBox(void);
wxRadioBox( wxWindow *parent, wxWindowID id, const wxString& title,
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 wxString &name = wxRadioBoxNameStr );
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 wxString &name = wxRadioBoxNameStr );
const wxValidator& val = wxDefaultValidator, const wxString& name = wxRadioBoxNameStr);
int FindString(const wxString& s) const;
void SetSelection( int n );
int GetSelection(void) const;
wxString GetString( int n ) const;
wxString GetLabel(void) const;
void SetSelection(int N);
int GetSelection() const;
wxString GetString(int N) const;
void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
void GetSize(int *x, int *y) const;
void GetPosition(int *x, int *y) const;
wxString GetLabel() const;
void SetLabel(const wxString& label);
void SetLabel(int item, const wxString& label) ;
void SetLabel( int item, wxBitmap *bitmap );
wxString GetLabel(int item) const;
bool Show(bool show);
void SetFocus();
void Enable(bool enable);
void Enable(int item, bool enable);
void Show(int item, bool show) ;
virtual wxString GetStringSelection(void) const;
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);
virtual int Number(void) const;
int GetNumberOfRowsOrCols(void) const;
void SetNumberOfRowsOrCols( int n );
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 // __GTKRADIOBOXH__
#endif
// _WX_RADIOBOX_H_

93
include/wx/qt/radiobut.h
View File

@@ -1,31 +1,92 @@
/////////////////////////////////////////////////////////////////////////////
// Name: radiobut.h
// Purpose:
// Author: Robert Roebling
// Purpose: wxRadioButton class
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKRADIOBUTTONH__
#define __GTKRADIOBUTTONH__
#ifndef _WX_RADIOBUT_H_
#define _WX_RADIOBUT_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "radiobut.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxRadioButtonNameStr;
class wxRadioButton;
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);
#endif // __GTKRADIOBUTTONH__
virtual void SetLabel(const wxString& label);
virtual void SetValue(bool val);
virtual bool GetValue() const ;
void Command(wxCommandEvent& event);
virtual WXHBRUSH OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
};
// Not implemented
#if 0
class WXDLLEXPORT wxBitmap ;
WXDLLEXPORT_DATA(extern const char*) wxBitmapRadioButtonNameStr;
class WXDLLEXPORT wxBitmapRadioButton: public wxRadioButton
{
DECLARE_DYNAMIC_CLASS(wxBitmapRadioButton)
protected:
wxBitmap *theButtonBitmap;
public:
inline wxBitmapRadioButton() { theButtonBitmap = NULL; }
inline wxBitmapRadioButton(wxWindow *parent, wxWindowID id,
const wxBitmap *label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxBitmapRadioButtonNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxBitmap *label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxBitmapRadioButtonNameStr);
virtual void SetLabel(const wxBitmap *label);
virtual void SetValue(bool val) ;
virtual bool GetValue() const ;
};
#endif
#endif
// _WX_RADIOBUT_H_

136
include/wx/qt/region.h
View File

@@ -1,36 +1,28 @@
/////////////////////////////////////////////////////////////////////////////
// Name: region.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxRegion class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __REGIONH__
#define __REGIONH__
#ifndef _WX_REGION_H_
#define _WX_REGION_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "region.h"
#endif
#include "wx/list.h"
#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxRect;
class WXDLLEXPORT wxPoint;
class wxRegion;
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
enum wxRegionContain
{
enum wxRegionContain {
wxOutRegion = 0, wxPartRegion = 1, wxInRegion = 2
};
@@ -43,54 +35,106 @@ wxRGN_OR, // Creates the union of two combined regions.
wxRGN_XOR // Creates the union of two combined regions except for any overlapping areas.
};
//-----------------------------------------------------------------------------
// wxRegion
//-----------------------------------------------------------------------------
class wxRegion : public wxGDIObject
{
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(void);
~wxRegion(void);
/* TODO: implementation
wxRegion(WXHRGN hRegion); // Hangs on to this region
*/
wxRegion();
~wxRegion();
//# Copying
inline wxRegion(const wxRegion& r)
{ Ref(r); }
inline wxRegion& operator = (const wxRegion& r)
{ Ref(r); return (*this); }
void Clear(void);
//# Modify region
// Clear current region
void Clear();
bool Union( long x, long y, long width, long height );
bool Union( const wxRect& rect );
bool Union( const wxRegion& region );
// 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); }
bool Intersect( long x, long y, long width, long height );
bool Intersect( const wxRect& rect );
bool Intersect( const wxRegion& region );
// 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); }
bool Subtract( long x, long y, long width, long height );
bool Subtract( const wxRect& rect );
bool Subtract( const wxRegion& region );
// 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); }
bool Xor( long x, long y, long width, long height );
bool Xor( const wxRect& rect );
bool Xor( const wxRegion& region );
// 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(void) const ;
wxRect GetBox() const ;
bool Empty(void) const;
// Is region empty?
bool Empty() const;
inline bool IsEmpty() const { return Empty(); }
//# Tests
// Does the region contain the point (x,y)?
wxRegionContain Contains(long x, long y) const;
// Does the region contain the point pt?
wxRegionContain Contains(const wxPoint& pt) const;
// Does the region contain the rectangle (x, y, w, h)?
wxRegionContain Contains(long x, long y, long w, long h) const;
// Does the region contain the rectangle rect?
wxRegionContain Contains(const wxRect& rect) const;
// Internal
bool Combine(long x, long y, long width, long height, wxRegionOp op);
bool Combine(const wxRegion& region, wxRegionOp op);
bool Combine(const wxRect& rect, wxRegionOp op);
};
class WXDLLEXPORT wxRegionIterator : public wxObject {
DECLARE_DYNAMIC_CLASS(wxRegionIterator);
public:
wxRegionIterator();
wxRegionIterator(const wxRegion& region);
~wxRegionIterator();
void Reset() { m_current = 0; }
void Reset(const wxRegion& region);
operator bool () const { return m_current < m_numRects; }
bool HaveRects() const { return m_current < m_numRects; }
void operator ++ ();
void operator ++ (int);
long GetX() const;
long GetY() const;
long GetW() const;
long GetWidth() const { return GetW(); }
long GetH() const;
long GetHeight() const { return GetH(); }
private:
long m_current;
long m_numRects;
wxRegion m_region;
wxRect* m_rects;
};
#endif
// __REGIONH__
// _WX_REGION_H_

82
include/wx/qt/scrolbar.h
View File

@@ -1,78 +1,68 @@
/////////////////////////////////////////////////////////////////////////////
// Name: scrolbar.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Name: scrollbar.h
// Purpose: wxScrollBar class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSCROLLBARH__
#define __GTKSCROLLBARH__
#ifndef _WX_SCROLBAR_H_
#define _WX_SCROLBAR_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "scrolbar.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxScrollBarNameStr;
class wxScrollBar;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxScrollBarNameStr;
//-----------------------------------------------------------------------------
// wxScrollBar
//-----------------------------------------------------------------------------
class wxScrollBar: public wxControl
// Scrollbar item
class WXDLLEXPORT wxScrollBar: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxScrollBar)
public:
inline wxScrollBar() { m_pageSize = 0; m_viewSize = 0; m_objectSize = 0; }
~wxScrollBar();
wxScrollBar(void) { };
wxScrollBar(wxWindow *parent, wxWindowID id,
inline wxScrollBar(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxString& name = wxScrollBarNameStr );
~wxScrollBar(void);
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr)
{
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr);
int GetPosition(void) const;
int GetThumbSize() const;
int GetPageSize() const;
int GetRange() const;
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);
// Backward compatibility
int GetValue(void) const;
void SetValue( int viewStart );
void GetValues( int *viewStart, int *viewLength, int *objectLength, int *pageLength) const;
int GetViewLength() const;
int GetObjectLength() const;
void SetPageSize( int pageLength );
void SetObjectLength( int objectLength );
void SetViewLength( int viewLength );
void Command(wxCommandEvent& event);
protected:
int m_pageSize;
int m_viewSize;
int m_objectSize;
DECLARE_EVENT_TABLE()
};
#endif
// __GTKSCROLLBARH__
// _WX_SCROLBAR_H_

119
include/wx/qt/settings.h
View File

@@ -1,30 +1,119 @@
/////////////////////////////////////////////////////////////////////////////
// Name: settings.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxSystemSettings class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSETTINGSH__
#define __GTKSETTINGSH__
#ifndef _WX_SETTINGS_H_
#define _WX_SETTINGS_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "settings.h"
#endif
#include "wx/defs.h"
#include "wx/gdicmn.h"
#include "wx/pen.h"
#include "wx/font.h"
#include "wx/setup.h"
#define wxSYS_WHITE_BRUSH 0
#define wxSYS_LTGRAY_BRUSH 1
#define wxSYS_GRAY_BRUSH 2
#define wxSYS_DKGRAY_BRUSH 3
#define wxSYS_BLACK_BRUSH 4
#define wxSYS_NULL_BRUSH 5
#define wxSYS_HOLLOW_BRUSH wxSYS_NULL_BRUSH
#define wxSYS_WHITE_PEN 6
#define wxSYS_BLACK_PEN 7
#define wxSYS_NULL_PEN 8
#define wxSYS_OEM_FIXED_FONT 10
#define wxSYS_ANSI_FIXED_FONT 11
#define wxSYS_ANSI_VAR_FONT 12
#define wxSYS_SYSTEM_FONT 13
#define wxSYS_DEVICE_DEFAULT_FONT 14
#define wxSYS_DEFAULT_PALETTE 15
#define wxSYS_SYSTEM_FIXED_FONT 16 // Obsolete
#define wxSYS_DEFAULT_GUI_FONT 17
#define wxSYS_COLOUR_SCROLLBAR 0
#define wxSYS_COLOUR_BACKGROUND 1
#define wxSYS_COLOUR_ACTIVECAPTION 2
#define wxSYS_COLOUR_INACTIVECAPTION 3
#define wxSYS_COLOUR_MENU 4
#define wxSYS_COLOUR_WINDOW 5
#define wxSYS_COLOUR_WINDOWFRAME 6
#define wxSYS_COLOUR_MENUTEXT 7
#define wxSYS_COLOUR_WINDOWTEXT 8
#define wxSYS_COLOUR_CAPTIONTEXT 9
#define wxSYS_COLOUR_ACTIVEBORDER 10
#define wxSYS_COLOUR_INACTIVEBORDER 11
#define wxSYS_COLOUR_APPWORKSPACE 12
#define wxSYS_COLOUR_HIGHLIGHT 13
#define wxSYS_COLOUR_HIGHLIGHTTEXT 14
#define wxSYS_COLOUR_BTNFACE 15
#define wxSYS_COLOUR_BTNSHADOW 16
#define wxSYS_COLOUR_GRAYTEXT 17
#define wxSYS_COLOUR_BTNTEXT 18
#define wxSYS_COLOUR_INACTIVECAPTIONTEXT 19
#define wxSYS_COLOUR_BTNHIGHLIGHT 20
#define wxSYS_COLOUR_3DDKSHADOW 21
#define wxSYS_COLOUR_3DLIGHT 22
#define wxSYS_COLOUR_INFOTEXT 23
#define wxSYS_COLOUR_INFOBK 24
#define wxSYS_COLOUR_DESKTOP wxSYS_COLOUR_BACKGROUND
#define wxSYS_COLOUR_3DFACE wxSYS_COLOUR_BTNFACE
#define wxSYS_COLOUR_3DSHADOW wxSYS_COLOUR_BTNSHADOW
#define wxSYS_COLOUR_3DHIGHLIGHT wxSYS_COLOUR_BTNHIGHLIGHT
#define wxSYS_COLOUR_3DHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
#define wxSYS_COLOUR_BTNHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
// Metrics
#define wxSYS_MOUSE_BUTTONS 1
#define wxSYS_BORDER_X 2
#define wxSYS_BORDER_Y 3
#define wxSYS_CURSOR_X 4
#define wxSYS_CURSOR_Y 5
#define wxSYS_DCLICK_X 6
#define wxSYS_DCLICK_Y 7
#define wxSYS_DRAG_X 8
#define wxSYS_DRAG_Y 9
#define wxSYS_EDGE_X 10
#define wxSYS_EDGE_Y 11
#define wxSYS_HSCROLL_ARROW_X 12
#define wxSYS_HSCROLL_ARROW_Y 13
#define wxSYS_HTHUMB_X 14
#define wxSYS_ICON_X 15
#define wxSYS_ICON_Y 16
#define wxSYS_ICONSPACING_X 17
#define wxSYS_ICONSPACING_Y 18
#define wxSYS_WINDOWMIN_X 19
#define wxSYS_WINDOWMIN_Y 20
#define wxSYS_SCREEN_X 21
#define wxSYS_SCREEN_Y 22
#define wxSYS_FRAMESIZE_X 23
#define wxSYS_FRAMESIZE_Y 24
#define wxSYS_SMALLICON_X 25
#define wxSYS_SMALLICON_Y 26
#define wxSYS_HSCROLL_Y 27
#define wxSYS_VSCROLL_X 28
#define wxSYS_VSCROLL_ARROW_X 29
#define wxSYS_VSCROLL_ARROW_Y 30
#define wxSYS_VTHUMB_Y 31
#define wxSYS_CAPTION_Y 32
#define wxSYS_MENU_Y 33
#define wxSYS_NETWORK_PRESENT 34
#define wxSYS_PENWINDOWS_PRESENT 35
#define wxSYS_SHOW_SOUNDS 36
#define wxSYS_SWAP_BUTTONS 37
class WXDLLEXPORT wxSystemSettings: public wxObject
{
public:
inline wxSystemSettings(void) {}
inline wxSystemSettings() {}
// Get a system colour
static wxColour GetSystemColour(int index);
@@ -37,4 +126,4 @@ public:
};
#endif
// __GTKSETTINGSH__
// _WX_SETTINGS_H_

97
include/wx/qt/slider.h
View File

@@ -1,86 +1,91 @@
/////////////////////////////////////////////////////////////////////////////
// Name: slider.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxSlider class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSLIDERH__
#define __GTKSLIDERH__
#ifndef _WX_SLIDER_H_
#define _WX_SLIDER_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "slider.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxSliderNameStr;
class wxSlider;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxSliderNameStr;
//-----------------------------------------------------------------------------
// wxSlider
//-----------------------------------------------------------------------------
class wxSlider: public wxControl
// Slider
class WXDLLEXPORT wxSlider: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxSlider)
public:
wxSlider(void);
wxSlider( wxWindow *parent, wxWindowID id,
wxSlider();
inline wxSlider(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
/* const wxValidator& validator = wxDefaultValidator, */
const wxString& name = wxSliderNameStr);
~wxSlider(void);
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr)
{
Create(parent, id, value, minValue, maxValue, pos, size, style, validator, name);
}
~wxSlider();
bool Create(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
/* const wxValidator& validator = wxDefaultValidator, */
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
virtual int GetValue(void) const;
virtual 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);
int GetMin(void) const;
int GetMax(void) const;
inline int GetMin() const { return m_rangeMin; }
inline int GetMax() const { return m_rangeMax; }
// For trackbars only
void SetTickFreq(int n, int pos);
int GetTickFreq(void) const;
inline int GetTickFreq() const { return m_tickFreq; }
void SetPageSize(int pageSize);
int GetPageSize(void) const;
void ClearSel(void);
void ClearTicks(void);
int GetPageSize() const ;
void ClearSel() ;
void ClearTicks() ;
void SetLineSize(int lineSize);
int GetLineSize(void) const;
int GetSelEnd(void) const;
int GetSelStart(void) const;
int GetLineSize() const ;
int GetSelEnd() const ;
int GetSelStart() const ;
void SetSelection(int minPos, int maxPos);
void SetThumbLength(int len) ;
int GetThumbLength(void) const;
int GetThumbLength() const ;
void SetTick(int tickPos) ;
void Command(wxCommandEvent& event);
protected:
int m_rangeMin;
int m_rangeMax;
int m_pageSize;
int m_lineSize;
int m_tickFreq;
DECLARE_EVENT_TABLE()
};
#endif // __GTKSLIDERH__
#endif
// _WX_SLIDER_H_

82
include/wx/qt/statbmp.h
View File

@@ -1,60 +1,64 @@
/////////////////////////////////////////////////////////////////////////////
// Name: statbmp.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxStaticBitmap class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSTATICBITMAPH__
#define __GTKSTATICBITMAPH__
#ifndef _WX_STATBMP_H_
#define _WX_STATBMP_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "statbmp.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxStaticBitmapNameStr;
class wxStaticBitmap;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char* wxStaticBitmapNameStr;
//-----------------------------------------------------------------------------
// wxStaticBitmap
//-----------------------------------------------------------------------------
class wxStaticBitmap: public wxControl
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);
wxStaticBitmap(void);
wxStaticBitmap( wxWindow *parent, wxWindowID id, const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = 0, const wxString& name = wxStaticBitmapNameStr );
bool Create( wxWindow *parent, wxWindowID id, const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = 0, const wxString& name = wxStaticBitmapNameStr);
virtual void SetBitmap(const wxBitmap& bitmap);
wxBitmap& GetBitmap(void) const { return (wxBitmap&)m_bitmap; }
private:
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;
wxBitmap m_bitmap;
};
#endif // __GTKSTATICBITMAPH__
#endif
// _WX_STATBMP_H_

76
include/wx/qt/statbox.h
View File

@@ -1,55 +1,57 @@
/////////////////////////////////////////////////////////////////////////////
// Name: stabox.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Name: statbox.h
// Purpose: wxStaticBox class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSTATICBOXH__
#define __GTKSTATICBOXH__
#ifndef _WX_STATBOX_H_
#define _WX_STATBOX_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "statbox.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxStaticBoxNameStr;
class wxStaticBox;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxStaticBoxNameStr;
//-----------------------------------------------------------------------------
// wxStaticBox
//-----------------------------------------------------------------------------
class wxStaticBox: public wxControl
// 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);
}
wxStaticBox(void);
wxStaticBox( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxStaticBoxNameStr );
bool Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxStaticBoxNameStr );
bool Create(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr);
virtual void Command(wxCommandEvent& WXUNUSED(event)) {};
virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {};
void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
void SetLabel(const wxString& label);
DECLARE_EVENT_TABLE()
};
#endif // __GTKSTATICBOXH__
#endif
// _WX_STATBOX_H_

77
include/wx/qt/stattext.h
View File

@@ -1,57 +1,56 @@
/////////////////////////////////////////////////////////////////////////////
// Name: stattext.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxStaticText class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSTATICTEXTH__
#define __GTKSTATICTEXTH__
#ifndef _WX_STATTEXT_H_
#define _WX_STATTEXT_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "stattext.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxStaticTextNameStr;
class wxStaticText;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxStaticTextNameStr;
//-----------------------------------------------------------------------------
// wxStaticText
//-----------------------------------------------------------------------------
class wxStaticText: public wxControl
class WXDLLEXPORT wxStaticText: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxStaticText)
public:
inline wxStaticText() { }
wxStaticText(void);
wxStaticText( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxStaticTextNameStr );
bool Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxStaticTextNameStr );
wxString GetLabel(void) const;
void SetLabel( const wxString &label );
inline wxStaticText(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr);
// accessors
void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
void SetLabel(const wxString&);
// operations
virtual void Command(wxCommandEvent& WXUNUSED(event)) {};
virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {};
};
#endif // __GTKSTATICTEXTH__
#endif
// _WX_STATTEXT_H_

155
include/wx/qt/textctrl.h
View File

@@ -1,24 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
// Name: textctrl.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxTextCtrl class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKTEXTCTRLH__
#define __GTKTEXTCTRLH__
#ifndef _WX_TEXTCTRL_H_
#define _WX_TEXTCTRL_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "textctrl.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/control.h"
#if USE_IOSTREAMH
@@ -27,70 +24,82 @@
#include <iostream>
#endif
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const char*) wxTextCtrlNameStr;
WXDLLEXPORT_DATA(extern const char*) wxEmptyString;
class wxTextCtrl;
// Single-line text item
class WXDLLEXPORT wxTextCtrl: public wxControl
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
// TODO Some platforms/compilers don't like inheritance from streambuf.
extern const char *wxTextCtrlNameStr;
#if (defined(__BORLANDC__) && !defined(__WIN32__)) || defined(__MWERKS__)
#define NO_TEXT_WINDOW_STREAM
#endif
//-----------------------------------------------------------------------------
// wxTextCtrl
//-----------------------------------------------------------------------------
#ifndef NO_TEXT_WINDOW_STREAM
, public streambuf
#endif
class wxTextCtrl: public wxControl, public streambuf
{
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxTextCtrl);
DECLARE_DYNAMIC_CLASS(wxTextCtrl)
public:
// creation
// --------
wxTextCtrl();
wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value = "",
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
int style = 0, const wxString &name = wxTextCtrlNameStr );
bool Create( wxWindow *parent, wxWindowID id, const wxString &value = "",
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
int style = 0, const wxString &name = wxTextCtrlNameStr );
wxString GetValue() const;
void SetValue( const wxString &value );
void WriteText( const wxString &text );
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();
bool LoadFile( const wxString &file );
bool SaveFile( const wxString &file );
bool IsModified() const { return m_modified; }
void SetModified() { m_modified = TRUE; }
void DiscardEdits() { m_modified = FALSE; }
/*
wxString GetLineText( long lineNo ) const;
void OnDropFiles( wxDropFilesEvent &event );
long PositionToXY( long pos, long *x, long *y ) const;
long XYToPosition( long x, long y );
int GetNumberOfLines();
*/
virtual void SetInsertionPoint(long pos);
virtual void SetInsertionPointEnd();
virtual void SetEditable( bool editable );
virtual void SetSelection( long from, long to );
void ShowPosition( long pos );
virtual long GetInsertionPoint() const ;
virtual long GetLastPosition() const ;
virtual void Remove( long from, long to );
virtual void Replace(long from, long to, const wxString& value);
void Cut();
void Copy();
void Paste();
void Delete();
void OnChar( wxKeyEvent &event );
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);
@@ -99,10 +108,32 @@ public:
wxTextCtrl& operator<<(double d);
wxTextCtrl& operator<<(const char c);
private:
bool m_modified;
virtual bool LoadFile(const wxString& file);
virtual bool SaveFile(const wxString& file);
virtual void WriteText(const wxString& text);
virtual void DiscardEdits();
virtual bool IsModified() const;
virtual long XYToPosition(long x, long y) const ;
virtual void PositionToXY(long pos, long *x, long *y) const ;
virtual void ShowPosition(long pos);
virtual void Clear();
// callbacks
// ---------
void OnDropFiles(wxDropFilesEvent& event);
void OnChar(wxKeyEvent& event); // Process 'enter' if required
void OnEraseBackground(wxEraseEvent& event);
// Implementation
// --------------
virtual void Command(wxCommandEvent& event);
protected:
wxString m_fileName;
DECLARE_EVENT_TABLE()
};
#endif // __GTKTEXTCTRLH__
#endif
// _WX_TEXTCTRL_H_

71
include/wx/qt/timer.h
View File

@@ -1,52 +1,57 @@
/////////////////////////////////////////////////////////////////////////////
// Name: timer.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxTimer class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKTIMERH__
#define __GTKTIMERH__
#ifndef _WX_TIMER_H_
#define _WX_TIMER_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "timer.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
//-----------------------------------------------------------------------------
// derived classes
//-----------------------------------------------------------------------------
class wxTimer;
//-----------------------------------------------------------------------------
// wxTimer
//-----------------------------------------------------------------------------
class wxTimer: public wxObject
class WXDLLEXPORT wxTimer: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxTimer)
public:
wxTimer();
~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)
wxTimer(void);
~wxTimer(void);
int Interval(void);
bool OneShot(void);
virtual void Notify(void);
void Start( int millisecs = -1, bool oneShot = FALSE );
void Stop(void);
private:
int m_time;
protected:
bool m_oneShot ;
int m_milli ;
int m_lastMilli ;
long m_id;
};
#endif // __GTKTIMERH__
/* Note: these are implemented in common/timercmn.cpp, so need to implement them separately.
* But you may need to modify timercmn.cpp.
*/
// Timer functions (milliseconds)
void WXDLLEXPORT wxStartTimer();
// Gets time since last wxStartTimer or wxGetElapsedTime
long WXDLLEXPORT wxGetElapsedTime(bool resetTimer = TRUE);
// EXPERIMENTAL: comment this out if it doesn't compile.
bool WXDLLEXPORT wxGetLocalTime(long *timeZone, int *dstObserved);
// Get number of seconds since 00:00:00 GMT, Jan 1st 1970.
long WXDLLEXPORT wxGetCurrentTime();
#endif
// _WX_TIMER_H_

645
include/wx/qt/window.h
View File

@@ -1,252 +1,547 @@
/////////////////////////////////////////////////////////////////////////////
// Name: window.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxWindow class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKWINDOWH__
#define __GTKWINDOWH__
#ifndef _WX_WINDOW_H_
#define _WX_WINDOW_H_
#ifdef __GNUG__
#pragma interface
#pragma interface "window.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/event.h"
#include "wx/validate.h"
#include "wx/gdicmn.h"
#include "wx/icon.h"
#include "wx/cursor.h"
#include "wx/pen.h"
#include "wx/font.h"
#include "wx/dc.h"
#include "wx/validate.h"
#include "wx/event.h"
#include "wx/string.h"
#include "wx/list.h"
#include "wx/region.h"
#include "wx/dnd.h"
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
#define wxKEY_SHIFT 1
#define wxKEY_CTRL 2
extern const char *wxFrameNameStr;
extern wxList wxTopLevelWindows;
/*
* Base class for frame, panel, canvas, panel items, dialog box.
*
*/
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
/*
* 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 wxLayoutConstraints;
class wxSizer;
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;
class wxWindow;
class wxCanvas;
#if USE_DRAG_AND_DROP
class WXDLLEXPORT wxDropTarget;
#endif
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
#if USE_WX_RESOURCES
class WXDLLEXPORT wxResourceTable;
class WXDLLEXPORT wxItemResource;
#endif
extern const char *wxPanelNameStr;
extern const wxSize wxDefaultSize;
extern const wxPoint wxDefaultPosition;
WXDLLEXPORT_DATA(extern const char*) wxPanelNameStr;
//-----------------------------------------------------------------------------
// wxWindow
//-----------------------------------------------------------------------------
WXDLLEXPORT_DATA(extern const wxSize) wxDefaultSize;
WXDLLEXPORT_DATA(extern const wxPoint) wxDefaultPosition;
class wxWindow: public wxEvtHandler
class WXDLLEXPORT wxWindow: public wxEvtHandler
{
DECLARE_ABSTRACT_CLASS(wxWindow)
friend class wxDC;
friend class wxPaintDC;
public:
wxWindow();
wxWindow( wxWindow *parent, wxWindowID id,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxPanelNameStr );
bool Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
long style = 0, const wxString &name = wxPanelNameStr );
inline wxWindow(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
m_children = new wxList;
Create(parent, id, pos, size, style, name);
}
virtual ~wxWindow();
bool Close( bool force = FALSE );
virtual bool Destroy();
virtual bool DestroyChildren();
virtual void PrepareDC( wxDC &dc );
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
virtual void SetSize( int x, int y, int width, int height,
int sizeFlags = wxSIZE_AUTO );
virtual void SetSize( int width, int height );
virtual void Move( int x, int y );
virtual void GetSize( int *width, int *height ) const;
virtual void SetClientSize( int const width, int const height );
virtual void GetClientSize( int *width, int *height ) const;
virtual void GetPosition( int *x, int *y ) const;
virtual void Centre( int direction = wxHORIZONTAL );
// Fit the window around the items
virtual void Fit();
void OnSize( wxSizeEvent &event );
void OnIdle( wxIdleEvent& event );
// Show or hide the window
virtual bool Show(bool show);
virtual void Enable( bool enable );
virtual void MakeModal( bool modal );
virtual bool IsEnabled() const { return m_isEnabled; };
// 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();
virtual bool OnClose();
virtual void AddChild( wxWindow *child );
wxList *GetChildren();
virtual void RemoveChild( wxWindow *child );
void SetReturnCode( int retCode );
int GetReturnCode();
wxWindow *GetParent();
wxEvtHandler *GetEventHandler();
void SetEventhandler( wxEvtHandler *handler );
virtual wxValidator *GetValidator();
virtual void SetValidator( wxValidator *validator );
bool IsBeingDeleted();
void SetId( wxWindowID id );
wxWindowID GetId();
void SetCursor( const wxCursor &cursor );
virtual void Refresh( bool eraseBackground = TRUE, const wxRect *rect = NULL );
virtual void Clear();
virtual bool IsExposed( long x, long y );
virtual bool IsExposed( long x, long y, long width, long height );
virtual wxColour GetBackgroundColour() const;
virtual void SetBackgroundColour( const wxColour &colour );
virtual void SetDefaultBackgroundColour( const wxColour& col )
{ m_defaultBackgroundColour = col; };
virtual wxColour GetDefaultBackgroundColour() const
{ return m_defaultBackgroundColour; };
virtual void SetDefaultForegroundColour( const wxColour& col )
{ m_defaultForegroundColour = col; };
virtual wxColour GetDefaultForegroundColour() const
{ return m_defaultForegroundColour; };
virtual void SetFont( const wxFont &font );
virtual wxFont *GetFont();
// For backward compatibility
inline virtual void SetButtonFont(const wxFont& font) { SetFont(font); }
inline virtual void SetLabelFont(const wxFont& font) { SetFont(font); }
inline virtual wxFont *GetLabelFont() { return GetFont(); };
inline virtual wxFont *GetButtonFont() { return GetFont(); };
virtual void SetWindowStyleFlag( long flag );
virtual long GetWindowStyleFlag() const;
// Capture/release mouse
virtual void CaptureMouse();
virtual void ReleaseMouse();
virtual void SetTitle( const wxString &title );
virtual wxString GetTitle() const;
virtual void SetName( const wxString &name );
virtual wxString GetName() const;
virtual wxString GetLabel() const;
void OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) ) {};
// Enable or disable the window
virtual void Enable(bool enable);
virtual bool IsShown() const;
virtual bool IsRetained();
virtual wxWindow *FindWindow( long id );
virtual wxWindow *FindWindow( const wxString& name );
void AllowDoubleClick( bool WXUNUSED(allow) ) {};
void SetDoubleClick( bool WXUNUSED(allow) ) {};
virtual void ClientToScreen( int *x, int *y );
virtual void ScreenToClient( int *x, int *y );
#if USE_DRAG_AND_DROP
// Associate a drop target with this window (if the window already had a drop
// target, it's deleted!) and return the current drop target (may be NULL).
void SetDropTarget(wxDropTarget *pDropTarget);
wxDropTarget *GetDropTarget() const { return m_pDropTarget; }
#endif
virtual bool Validate();
virtual bool TransferDataToWindow();
virtual bool TransferDataFromWindow();
void OnInitDialog( wxInitDialogEvent &event );
virtual void InitDialog();
// Accept files for dragging
virtual void DragAcceptFiles(bool accept);
virtual void SetDropTarget( wxDropTarget *dropTarget );
virtual wxDropTarget *GetDropTarget() const;
// 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;
public:
// 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 GetScrollThumb( int orient ) const;
virtual int GetScrollRange(int orient) const;
virtual void ScrollWindow( int dx, int dy, const wxRect* rect = NULL );
virtual int GetScrollThumb(int orient) const;
// return FALSE from here if the window doesn't want the focus
virtual bool AcceptsFocus() const;
virtual void ScrollWindow(int dx, int dy, const wxRectangle *rect = NULL);
// update the UI state (called from OnIdle)
// Caret manipulation
virtual void CreateCaret(int w, int h);
virtual void CreateCaret(const wxBitmap *bitmap);
virtual void DestroyCaret();
virtual void ShowCaret(bool show);
virtual void SetCaretPos(int x, int y);
virtual void GetCaretPos(int *x, int *y) const;
// Tell window how much it can be sized
virtual void SetSizeHints(int minW = -1, int minH = -1, int maxW = -1, int maxH = -1, int incW = -1, int incH = -1);
// Set/get the window's identifier
inline int GetId() const;
inline void SetId(int id);
// Make the window modal (all other windows unresponsive)
virtual void MakeModal(bool modal);
// Get the private handle (platform-dependent)
inline void *GetHandle() const;
// Set/get the window's relatives
inline wxWindow *GetParent() const;
inline void SetParent(wxWindow *p) ;
inline wxWindow *GetGrandParent() const;
inline wxList *GetChildren() const;
// Set/get the window's font
virtual void SetFont(const wxFont& f);
inline virtual wxFont *GetFont() const;
// Set/get the window's validator
void SetValidator(const wxValidator& validator);
inline wxValidator *GetValidator() const;
// Set/get the window's style
inline void SetWindowStyleFlag(long flag);
inline long GetWindowStyleFlag() const;
// Set/get event handler
inline void SetEventHandler(wxEvtHandler *handler);
inline wxEvtHandler *GetEventHandler() const;
// Push/pop event handler (i.e. allow a chain of event handlers
// be searched)
void PushEventHandler(wxEvtHandler *handler) ;
wxEvtHandler *PopEventHandler(bool deleteHandler = FALSE) ;
// Close the window by calling OnClose, posting a deletion
virtual bool Close(bool force = FALSE);
// Destroy the window (delayed, if a managed window)
virtual bool Destroy() ;
// Mode for telling default OnSize members to
// call Layout(), if not using Sizers, just top-down constraints
inline void SetAutoLayout(bool a);
inline bool GetAutoLayout() const;
// Set/get constraints
inline wxLayoutConstraints *GetConstraints() const;
void SetConstraints(wxLayoutConstraints *c);
// Set/get window background colour
inline virtual void SetBackgroundColour(const wxColour& col);
inline virtual wxColour GetBackgroundColour() const;
// Set/get window foreground colour
inline virtual void SetForegroundColour(const wxColour& col);
inline virtual wxColour GetForegroundColour() const;
// Set/get window default background colour (for children to inherit).
// NOTE: these may be removed in later revisions.
inline virtual void SetDefaultBackgroundColour(const wxColour& col);
inline virtual wxColour GetDefaultBackgroundColour(void) const;
// Set/get window default foreground colour (for children to inherit)
inline virtual void SetDefaultForegroundColour(const wxColour& col);
inline virtual wxColour GetDefaultForegroundColour(void) const;
// Get the default button, if there is one
inline virtual wxButton *GetDefaultItem() const;
inline virtual void SetDefaultItem(wxButton *but);
// Override to define new behaviour for default action (e.g. double clicking
// on a listbox)
virtual void OnDefaultAction(wxControl *initiatingItem);
// Resource loading
#if USE_WX_RESOURCES
virtual bool LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table = NULL);
virtual wxControl *CreateItem(const wxItemResource *childResource, const wxResourceTable *table = NULL);
#endif
// Native resource loading
virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id);
virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name);
virtual wxWindow* GetWindowChild1(wxWindowID& id);
virtual wxWindow* GetWindowChild(wxWindowID& id);
virtual void GetTextExtent(const wxString& string, int *x, int *y,
int *descent = NULL,
int *externalLeading = NULL,
const wxFont *theFont = NULL, bool use16 = FALSE) const;
// Is the window retained?
inline bool IsRetained() const;
// 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);
public: // cannot get private going yet
// Does this window want to accept keyboard focus?
virtual bool AcceptsFocus() const;
public:
////////////////////////////////////////////////////////////////////////
//// IMPLEMENTATION
wxWindow *m_parent;
wxList m_children;
int m_x,m_y;
int m_width,m_height;
int m_retCode;
wxEvtHandler *m_eventHandler;
wxValidator *m_windowValidator;
wxDropTarget *m_pDropTarget;
wxWindowID m_windowId;
wxCursor *m_cursor;
wxFont m_font;
wxColour m_backgroundColour;
wxColour m_defaultBackgroundColour;
wxColour m_foregroundColour ;
wxColour m_defaultForegroundColour;
wxRegion m_updateRegion;
long m_windowStyle;
bool m_isShown;
bool m_isEnabled;
wxString m_windowName;
// 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);
public: // Layout section
// Executes the default message
virtual long Default();
wxLayoutConstraints * m_constraints;
wxList * m_constraintsInvolvedIn;
wxSizer * m_windowSizer;
wxWindow * m_sizerParent;
bool m_autoLayout;
/* TODO: you may need something like this
// Determine whether 3D effects are wanted
virtual WXDWORD Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D);
*/
wxLayoutConstraints *GetConstraints() const;
void SetConstraints( wxLayoutConstraints *constraints );
void SetAutoLayout( bool autoLayout );
bool GetAutoLayout() const;
bool Layout();
void SetSizer( wxSizer *sizer );
wxSizer *GetSizer() const;
void SetSizerParent( wxWindow *win );
wxWindow *GetSizerParent() const;
virtual void AddChild(wxWindow *child); // Adds reference to the child object
virtual void RemoveChild(wxWindow *child); // Removes reference to child
// (but doesn't delete the child object)
virtual void DestroyChildren(); // Removes and destroys all children
// Constraint implementation
void UnsetConstraints(wxLayoutConstraints *c);
inline wxList *GetConstraintsInvolvedIn() const ;
// Back-pointer to other windows we're involved with, so if we delete
// this window, we must delete any constraints we're involved with.
void AddConstraintReference(wxWindow *otherWin);
void RemoveConstraintReference(wxWindow *otherWin);
void DeleteRelatedConstraints();
virtual void ResetConstraints();
virtual void SetConstraintSizes(bool recurse = TRUE);
virtual bool LayoutPhase1(int *noChanges);
virtual bool LayoutPhase2(int *noChanges);
virtual bool DoPhase(int);
// Transforms from sizer coordinate space to actual
// parent coordinate space
virtual void TransformSizerToActual(int *x, int *y) const ;
// Set size with transformation to actual coordinates if nec.
virtual void SizerSetSize(int x, int y, int w, int h);
virtual void SizerMove(int x, int y);
// Only set/get the size/position of the constraint (if any)
virtual void SetSizeConstraint(int x, int y, int w, int h);
virtual void MoveConstraint(int x, int y);
virtual void GetSizeConstraint(int *w, int *h) const ;
virtual void GetClientSizeConstraint(int *w, int *h) const ;
virtual void GetPositionConstraint(int *x, int *y) const ;
DECLARE_DYNAMIC_CLASS(wxWindow)
wxObject *GetChild(int number) const ;
inline void SetShowing(bool show);
inline bool IsUserEnabled() const;
inline bool GetTransparentBackground() const ;
// Responds to colour changes: passes event on to children.
void OnSysColourChanged(wxSysColourChangedEvent& event);
// Transfers data to any child controls
void OnInitDialog(wxInitDialogEvent& event);
// Sends an OnInitDialog event, which in turns transfers data to
// to the window via validators.
virtual void InitDialog();
////////////////////////////////////////////////////////////////////////
//// PROTECTED DATA
protected:
int m_windowId;
long m_windowStyle; // Store the window's style
wxEvtHandler * m_windowEventHandler; // Usually is 'this'
wxLayoutConstraints * m_constraints; // Constraints for this window
wxList * m_constraintsInvolvedIn; // List of constraints we're involved in
wxSizer * m_windowSizer; // Window's top-level sizer (if any)
wxWindow * m_sizerParent; // Window's parent sizer (if any)
bool m_autoLayout; // Whether to call Layout() in OnSize
wxWindow * m_windowParent; // Each window always knows its parent
wxValidator * m_windowValidator;
int m_minSizeX;
int m_minSizeY;
int m_maxSizeX;
int m_maxSizeY;
// Caret data
int m_caretWidth;
int m_caretHeight;
bool m_caretEnabled;
bool m_caretShown;
wxFont m_windowFont; // Window's font
wxCursor m_windowCursor; // Window's cursor
wxString m_windowName; // Window name
wxButton * m_defaultItem;
wxColour m_backgroundColour ;
wxColour m_foregroundColour ;
wxColour m_defaultBackgroundColour;
wxColour m_defaultForegroundColour;
#if USE_DRAG_AND_DROP
wxDropTarget *m_pDropTarget; // the current drop target or NULL
#endif //USE_DRAG_AND_DROP
public:
wxRegion m_updateRegion;
wxList * m_children; // Window's children
int m_returnCode;
DECLARE_EVENT_TABLE()
};
#endif // __GTKWINDOWH__
////////////////////////////////////////////////////////////////////////
//// INLINES
inline void *wxWindow::GetHandle() const { return (void *)NULL; }
inline int wxWindow::GetId() const { return m_windowId; }
inline void wxWindow::SetId(int id) { m_windowId = id; }
inline wxWindow *wxWindow::GetParent() const { return m_windowParent; }
inline void wxWindow::SetParent(wxWindow *p) { m_windowParent = p; }
inline wxWindow *wxWindow::GetGrandParent() const { return (m_windowParent ? m_windowParent->m_windowParent : NULL); }
inline wxList *wxWindow::GetChildren() const { return m_children; }
inline wxFont *wxWindow::GetFont() const { return (wxFont *) & m_windowFont; }
inline wxString wxWindow::GetName() const { return m_windowName; }
inline void wxWindow::SetName(const wxString& name) { m_windowName = name; }
inline long wxWindow::GetWindowStyleFlag() const { return m_windowStyle; }
inline void wxWindow::SetWindowStyleFlag(long flag) { m_windowStyle = flag; }
inline void wxWindow::SetDoubleClick(bool flag) { m_doubleClickAllowed = flag; }
inline bool wxWindow::GetDoubleClick() const { return m_doubleClickAllowed; }
inline void wxWindow::SetEventHandler(wxEvtHandler *handler) { m_windowEventHandler = handler; }
inline wxEvtHandler *wxWindow::GetEventHandler() const { return m_windowEventHandler; }
inline void wxWindow::SetAutoLayout(bool a) { m_autoLayout = a; }
inline bool wxWindow::GetAutoLayout() const { return m_autoLayout; }
inline wxLayoutConstraints *wxWindow::GetConstraints() const { return m_constraints; }
inline void wxWindow::SetBackgroundColour(const wxColour& col) { m_backgroundColour = col; };
inline wxColour wxWindow::GetBackgroundColour() const { return m_backgroundColour; };
inline void wxWindow::SetForegroundColour(const wxColour& col) { m_foregroundColour = col; };
inline wxColour wxWindow::GetForegroundColour() const { return m_foregroundColour; };
inline void wxWindow::SetDefaultForegroundColour(const wxColour& col) { m_defaultForegroundColour = col; };
inline wxColour wxWindow::GetDefaultForegroundColour(void) const { return m_defaultForegroundColour; };
inline void wxWindow::SetDefaultBackgroundColour(const wxColour& col) { m_defaultBackgroundColour = col; };
inline wxColour wxWindow::GetDefaultBackgroundColour(void) const { return m_defaultBackgroundColour; };
inline wxButton *wxWindow::GetDefaultItem() const { return m_defaultItem; }
inline void wxWindow::SetDefaultItem(wxButton *but) { m_defaultItem = but; }
inline bool wxWindow::IsRetained() const { return ((m_windowStyle & wxRETAINED) == wxRETAINED); }
inline void wxWindow::SetShowing(bool show) { m_isShown = show; }
inline wxList *wxWindow::GetConstraintsInvolvedIn() const { return m_constraintsInvolvedIn; }
inline wxSizer *wxWindow::GetSizer() const { return m_windowSizer; }
inline wxWindow *wxWindow::GetSizerParent() const { return m_sizerParent; }
inline void wxWindow::SetSizerParent(wxWindow *win) { m_sizerParent = win; }
inline wxValidator *wxWindow::GetValidator() const { return m_windowValidator; }
inline bool wxWindow::IsUserEnabled() const { return m_winEnabled; }
inline bool wxWindow::GetTransparentBackground() const { return m_backgroundTransparent; }
inline void wxWindow::SetReturnCode(int retCode) { m_returnCode = retCode; }
inline int wxWindow::GetReturnCode() { return m_returnCode; }
// Get the active window.
wxWindow* WXDLLEXPORT wxGetActiveWindow();
WXDLLEXPORT_DATA(extern wxList) wxTopLevelWindows;
#endif
// _WX_WINDOW_H_

521
src/qt/app.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: app.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxApp
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -12,223 +13,60 @@
#pragma implementation "app.h"
#endif
#include "wx/frame.h"
#include "wx/app.h"
#include "wx/gdicmn.h"
#include "wx/utils.h"
#include "wx/postscrp.h"
#include "wx/intl.h"
#include "wx/gdicmn.h"
#include "wx/pen.h"
#include "wx/brush.h"
#include "wx/cursor.h"
#include "wx/icon.h"
#include "wx/palette.h"
#include "wx/dc.h"
#include "wx/dialog.h"
#include "wx/msgdlg.h"
#include "wx/log.h"
#include "wx/memory.h"
#include "wx/module.h"
#include "unistd.h"
#if USE_WX_RESOURCES
#include "wx/resource.h"
#endif
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
wxApp *wxTheApp = NULL;
wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
#include <string.h>
#if defined(__WIN95__) && !defined(__GNUWIN32__)
extern char *wxBuffer;
extern wxList wxPendingDelete;
//-----------------------------------------------------------------------------
// local functions
//-----------------------------------------------------------------------------
extern void wxFlushResources(void);
//-----------------------------------------------------------------------------
// global functions
//-----------------------------------------------------------------------------
void wxExit(void)
{
};
bool wxYield(void)
{
return TRUE;
};
//-----------------------------------------------------------------------------
// wxApp
//-----------------------------------------------------------------------------
wxApp *wxTheApp = NULL;
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
EVT_IDLE(wxApp::OnIdle)
END_EVENT_TABLE()
wxApp::wxApp()
{
m_topWindow = NULL;
m_exitOnFrameDelete = TRUE;
};
wxApp::~wxApp(void)
{
};
bool wxApp::OnInit(void)
{
return TRUE;
};
bool wxApp::OnInitGui(void)
{
return TRUE;
};
int wxApp::OnRun(void)
{
return MainLoop();
};
bool wxApp::ProcessIdle(void)
{
wxIdleEvent event;
event.SetEventObject( this );
ProcessEvent( event );
return event.MoreRequested();
};
void wxApp::OnIdle( wxIdleEvent &event )
{
static bool inOnIdle = FALSE;
// Avoid recursion (via ProcessEvent default case)
if (inOnIdle)
return;
inOnIdle = TRUE;
// 'Garbage' collection of windows deleted with Close().
DeletePendingObjects();
// flush the logged messages if any
wxLog *pLog = wxLog::GetActiveTarget();
if ( pLog != NULL && pLog->HasPendingMessages() )
pLog->Flush();
// Send OnIdle events to all windows
bool needMore = SendIdleEvents();
if (needMore)
event.RequestMore(TRUE);
inOnIdle = FALSE;
};
bool wxApp::SendIdleEvents(void)
{
bool needMore = FALSE;
wxNode* node = wxTopLevelWindows.First();
while (node)
{
wxWindow* win = (wxWindow*) node->Data();
if (SendIdleEvents(win))
needMore = TRUE;
node = node->Next();
}
return needMore;
};
bool wxApp::SendIdleEvents( wxWindow* win )
{
bool needMore = FALSE;
wxIdleEvent event;
event.SetEventObject(win);
win->ProcessEvent(event);
if (event.MoreRequested())
needMore = TRUE;
wxNode* node = win->GetChildren()->First();
while (node)
{
wxWindow* win = (wxWindow*) node->Data();
if (SendIdleEvents(win))
needMore = TRUE;
node = node->Next();
}
return needMore ;
};
int wxApp::OnExit(void)
{
return 0;
};
int wxApp::MainLoop(void)
{
return 0;
};
void wxApp::ExitMainLoop(void)
{
};
bool wxApp::Initialized(void)
{
return m_initialized;
};
bool wxApp::Pending(void)
{
return FALSE;
};
void wxApp::Dispatch(void)
{
};
void wxApp::DeletePendingObjects(void)
{
wxNode *node = wxPendingDelete.First();
while (node)
{
wxObject *obj = (wxObject *)node->Data();
delete obj;
if (wxPendingDelete.Member(obj))
delete node;
node = wxPendingDelete.First();
};
};
wxWindow *wxApp::GetTopWindow(void)
{
if (m_topWindow) return m_topWindow;
wxNode *node = wxTopLevelWindows.First();
if (!node) return NULL;
return (wxWindow*)node->Data();
};
void wxApp::SetTopWindow( wxWindow *win )
{
m_topWindow = win;
};
void wxApp::CommonInit(void)
{
/*
#if USE_RESOURCES
(void) wxGetResource("wxWindows", "OsVersion", &wxOsVersion);
#endif
*/
long wxApp::sm_lastMessageTime = 0;
void wxApp::CommonInit()
{
#ifdef __WXMSW__
wxBuffer = new char[1500];
#else
wxBuffer = new char[BUFSIZ + 512];
#endif
wxClassInfo::InitializeClasses();
wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
wxTheColourDatabase->Initialize();
wxInitializeStockObjects();
#if USE_WX_RESOURCES
wxInitializeResourceSystem();
#endif
// For PostScript printing
#if USE_POSTSCRIPT
wxInitializePrintSetupData();
@@ -236,36 +74,55 @@ void wxApp::CommonInit(void)
wxThePrintPaperDatabase->CreateDatabase();
#endif
/*
wxBitmap::InitStandardHandlers();
g_globalCursor = new wxCursor;
*/
wxInitializeStockObjects();
};
void wxApp::CommonCleanUp(void)
{
wxDeleteStockObjects();
wxFlushResources();
};
wxLog *wxApp::CreateLogTarget()
{
return new wxLogGui;
wxModule::RegisterModules();
wxASSERT( wxModule::InitializeModules() == TRUE );
}
//-----------------------------------------------------------------------------
// wxEntry
//-----------------------------------------------------------------------------
void wxApp::CommonCleanUp()
{
wxModule::CleanUpModules();
#if USE_WX_RESOURCES
wxCleanUpResourceSystem();
#endif
wxDeleteStockObjects() ;
// Destroy all GDI lists, etc.
delete wxTheBrushList;
wxTheBrushList = NULL;
delete wxThePenList;
wxThePenList = NULL;
delete wxTheFontList;
wxTheFontList = NULL;
delete wxTheBitmapList;
wxTheBitmapList = NULL;
delete wxTheColourDatabase;
wxTheColourDatabase = NULL;
#if USE_POSTSCRIPT
wxInitializePrintSetupData(FALSE);
delete wxThePrintPaperDatabase;
wxThePrintPaperDatabase = NULL;
#endif
wxBitmap::CleanUpHandlers();
delete[] wxBuffer;
wxBuffer = NULL;
// do it as the very last thing because everything else can log messages
delete wxLog::SetActiveTarget(NULL);
}
int wxEntry( int argc, char *argv[] )
{
wxBuffer = new char[BUFSIZ + 512];
wxClassInfo::InitializeClasses();
#if (WXDEBUG && USE_MEMORY_TRACING) || USE_DEBUG_CONTEXT
@@ -288,13 +145,7 @@ int wxEntry( int argc, char *argv[] )
return 0;
};
wxAppInitializerFunction app_ini = wxApp::GetInitializerFunction();
wxObject *test_app = app_ini();
wxTheApp = (wxApp*) test_app;
// wxTheApp = (wxApp*)( app_ini() );
wxTheApp = (* wxApp::GetInitializerFunction()) ();
};
if (!wxTheApp)
@@ -303,15 +154,14 @@ int wxEntry( int argc, char *argv[] )
return 0;
};
// printf( "Programmstart.\n" );
wxTheApp->argc = argc;
wxTheApp->argv = argv;
// Your init here !!!!
// TODO: your platform-specific initialization.
wxApp::CommonInit();
// GUI-specific initialization, such as creating an app context.
wxTheApp->OnInitGui();
// Here frames insert themselves automatically
@@ -349,18 +199,197 @@ int wxEntry( int argc, char *argv[] )
return retValue;
};
//-----------------------------------------------------------------------------
// main()
//-----------------------------------------------------------------------------
#if defined(AIX) || defined(AIX4) || defined(____HPUX__)
// main in IMPLEMENT_WX_MAIN in IMPLEMENT_APP in app.h
// Static member initialization
wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
wxApp::wxApp()
{
m_topWindow = NULL;
wxTheApp = this;
m_className = "";
m_wantDebugOutput = TRUE ;
m_appName = "";
argc = 0;
argv = NULL;
#ifdef __WXMSW__
m_printMode = wxPRINT_WINDOWS;
#else
int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
m_printMode = wxPRINT_POSTSCRIPT;
#endif
m_exitOnFrameDelete = TRUE;
m_auto3D = TRUE;
}
bool wxApp::Initialized()
{
if (GetTopWindow())
return TRUE;
else
return FALSE;
}
int wxApp::MainLoop()
{
m_keepGoing = TRUE;
/* TODO: implement your main loop here, calling ProcessIdle in idle time.
while (m_keepGoing)
{
while (!::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) &&
ProcessIdle()) {}
if (!DoMessage())
m_keepGoing = FALSE;
}
*/
return 0;
}
// Returns TRUE if more time is needed.
bool wxApp::ProcessIdle()
{
wxIdleEvent event;
event.SetEventObject(this);
ProcessEvent(event);
return event.MoreRequested();
}
void wxApp::ExitMainLoop()
{
m_keepGoing = FALSE;
}
// Is a message/event pending?
bool wxApp::Pending()
{
/* TODO.
*/
return FALSE;
}
// Dispatch a message.
void wxApp::Dispatch()
{
/* TODO.
*/
}
void wxApp::OnIdle(wxIdleEvent& event)
{
static bool inOnIdle = FALSE;
// Avoid recursion (via ProcessEvent default case)
if (inOnIdle)
return;
inOnIdle = TRUE;
// 'Garbage' collection of windows deleted with Close().
DeletePendingObjects();
// flush the logged messages if any
wxLog *pLog = wxLog::GetActiveTarget();
if ( pLog != NULL && pLog->HasPendingMessages() )
pLog->Flush();
// Send OnIdle events to all windows
bool needMore = SendIdleEvents();
if (needMore)
event.RequestMore(TRUE);
inOnIdle = FALSE;
}
// Send idle event to all top-level windows
bool wxApp::SendIdleEvents()
{
bool needMore = FALSE;
wxNode* node = wxTopLevelWindows.First();
while (node)
{
wxWindow* win = (wxWindow*) node->Data();
if (SendIdleEvents(win))
needMore = TRUE;
node = node->Next();
}
return needMore;
}
// Send idle event to window and all subwindows
bool wxApp::SendIdleEvents(wxWindow* win)
{
bool needMore = FALSE;
wxIdleEvent event;
event.SetEventObject(win);
win->ProcessEvent(event);
if (event.MoreRequested())
needMore = TRUE;
wxNode* node = win->GetChildren()->First();
while (node)
{
wxWindow* win = (wxWindow*) node->Data();
if (SendIdleEvents(win))
needMore = TRUE;
node = node->Next();
}
return needMore ;
}
void wxApp::DeletePendingObjects()
{
wxNode *node = wxPendingDelete.First();
while (node)
{
wxObject *obj = (wxObject *)node->Data();
delete obj;
if (wxPendingDelete.Member(obj))
delete node;
// Deleting one object may have deleted other pending
// objects, so start from beginning of list again.
node = wxPendingDelete.First();
}
}
wxLog* wxApp::CreateLogTarget()
{
return new wxLogGui;
}
wxWindow* wxApp::GetTopWindow() const
{
if (m_topWindow)
return m_topWindow;
else if (wxTopLevelWindows.Number() > 0)
return (wxWindow*) wxTopLevelWindows.First()->Data();
else
return NULL;
}
void wxExit()
{
wxApp::CommonCleanUp();
/*
* TODO: Exit in some platform-specific way. Not recommended that the app calls this:
* only for emergencies.
*/
}
// Yield to other processes
bool wxYield()
{
/*
* TODO
*/
return TRUE;
}

547
src/qt/bitmap.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Purpose: wxBitmap
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -12,226 +13,418 @@
#pragma implementation "bitmap.h"
#endif
#include "wx/setup.h"
#include "wx/utils.h"
#include "wx/palette.h"
#include "wx/bitmap.h"
#include "wx/icon.h"
#include "wx/log.h"
//-----------------------------------------------------------------------------
// wxMask
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
#endif
wxMask::wxMask(void)
wxBitmapRefData::wxBitmapRefData()
{
};
wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour) )
{
};
wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex) )
{
};
wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap) )
{
};
wxMask::~wxMask(void)
{
};
//-----------------------------------------------------------------------------
// wxBitmap
//-----------------------------------------------------------------------------
class wxBitmapRefData: public wxObjectRefData
{
public:
wxBitmapRefData(void);
~wxBitmapRefData(void);
wxMask *m_mask;
int m_width;
int m_height;
int m_bpp;
wxPalette *m_palette;
};
wxBitmapRefData::wxBitmapRefData(void)
{
m_mask = NULL;
m_ok = FALSE;
m_width = 0;
m_height = 0;
m_bpp = 0;
m_palette = NULL;
};
wxBitmapRefData::~wxBitmapRefData(void)
{
if (m_mask) delete m_mask;
if (m_palette) delete m_palette;
};
//-----------------------------------------------------------------------------
#define M_BMPDATA ((wxBitmapRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
wxBitmap::wxBitmap(void)
{
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( int width, int height, int depth )
{
m_refData = new wxBitmapRefData();
M_BMPDATA->m_mask = NULL;
M_BMPDATA->m_width = width;
M_BMPDATA->m_height = height;
M_BMPDATA->m_bpp = depth;
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( char **WXUNUSED(bits) )
{
m_refData = new wxBitmapRefData();
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( const wxBitmap& bmp )
{
Ref( bmp );
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( const wxBitmap* bmp )
{
if (bmp) Ref( *bmp );
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( const wxString &filename, int type )
{
LoadFile( filename, type );
};
wxBitmap::wxBitmap( const char WXUNUSED(bits)[], int width, int height, int WXUNUSED(depth))
{
m_refData = new wxBitmapRefData();
M_BMPDATA->m_mask = NULL;
M_BMPDATA->m_width = width;
M_BMPDATA->m_height = height;
M_BMPDATA->m_bpp = 1;
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
m_depth = 0;
m_quality = 0;
m_numColors = 0;
m_bitmapMask = NULL;
}
wxBitmap::~wxBitmap(void)
wxBitmapRefData::~wxBitmapRefData()
{
if (wxTheBitmapList) wxTheBitmapList->DeleteObject(this);
};
/*
* TODO: delete the bitmap data here.
*/
wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
if (m_bitmapMask)
delete m_bitmapMask;
m_bitmapMask = NULL;
}
wxList wxBitmap::sm_handlers;
wxBitmap::wxBitmap()
{
if (*this == bmp) return (*this);
Ref( bmp );
return *this;
};
m_refData = NULL;
bool wxBitmap::operator == ( const wxBitmap& bmp )
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
}
wxBitmap::~wxBitmap()
{
return m_refData == bmp.m_refData;
};
if (wxTheBitmapList)
wxTheBitmapList->DeleteObject(this);
}
bool wxBitmap::operator != ( const wxBitmap& bmp )
wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
{
return m_refData != bmp.m_refData;
};
m_refData = new wxBitmapRefData;
bool wxBitmap::Ok(void) const
M_BITMAPDATA->m_width = the_width ;
M_BITMAPDATA->m_height = the_height ;
M_BITMAPDATA->m_depth = no_bits ;
M_BITMAPDATA->m_numColors = 0;
/* TODO: create the bitmap from data */
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
}
wxBitmap::wxBitmap(int w, int h, int d)
{
return m_refData != NULL;
};
(void)Create(w, h, d);
int wxBitmap::GetHeight(void) const
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
}
wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
{
if (!Ok()) return 0;
return M_BMPDATA->m_height;
};
(void) Create(data, type, width, height, depth);
int wxBitmap::GetWidth(void) const
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
}
wxBitmap::wxBitmap(const wxString& filename, long type)
{
if (!Ok()) return 0;
return M_BMPDATA->m_width;
};
LoadFile(filename, (int)type);
int wxBitmap::GetDepth(void) const
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
}
/* TODO: maybe allow creation from XPM
// Create from data
wxBitmap::wxBitmap(const char **data)
{
if (!Ok()) return 0;
return M_BMPDATA->m_bpp;
};
(void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
}
*/
void wxBitmap::SetHeight( int height )
bool wxBitmap::Create(int w, int h, int d)
{
if (!Ok()) return;
M_BMPDATA->m_height = height;
};
UnRef();
void wxBitmap::SetWidth( int width )
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_width = w;
M_BITMAPDATA->m_height = h;
M_BITMAPDATA->m_depth = d;
/* TODO: create new bitmap */
return M_BITMAPDATA->m_ok;
}
bool wxBitmap::LoadFile(const wxString& filename, long type)
{
if (!Ok()) return;
M_BMPDATA->m_width = width;
};
UnRef();
void wxBitmap::SetDepth( int depth )
m_refData = new wxBitmapRefData;
wxBitmapHandler *handler = FindHandler(type);
if ( handler == NULL ) {
wxLogWarning("no bitmap handler for type %d defined.", type);
return FALSE;
}
return handler->LoadFile(this, filename, type, -1, -1);
}
bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
{
if (!Ok()) return;
M_BMPDATA->m_bpp = depth;
};
UnRef();
wxMask *wxBitmap::GetMask(void) const
m_refData = new wxBitmapRefData;
wxBitmapHandler *handler = FindHandler(type);
if ( handler == NULL ) {
wxLogWarning("no bitmap handler for type %d defined.", type);
return FALSE;
}
return handler->Create(this, data, type, width, height, depth);
}
bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
{
if (!Ok()) return NULL;
wxBitmapHandler *handler = FindHandler(type);
return M_BMPDATA->m_mask;
};
if ( handler == NULL ) {
wxLogWarning("no bitmap handler for type %d defined.", type);
return FALSE;
}
return handler->SaveFile(this, filename, type, palette);
}
void wxBitmap::SetWidth(int w)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_width = w;
}
void wxBitmap::SetHeight(int h)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_height = h;
}
void wxBitmap::SetDepth(int d)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_depth = d;
}
void wxBitmap::SetQuality(int q)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_quality = q;
}
void wxBitmap::SetOk(bool isOk)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_ok = isOk;
}
void wxBitmap::SetPalette(const wxPalette& palette)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_bitmapPalette = palette ;
}
void wxBitmap::SetMask(wxMask *mask)
{
if (!Ok()) return;
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
M_BMPDATA->m_mask = mask;
};
M_BITMAPDATA->m_bitmapMask = mask ;
}
void wxBitmap::Resize( int WXUNUSED(height), int WXUNUSED(width) )
void wxBitmap::AddHandler(wxBitmapHandler *handler)
{
if (!Ok()) return;
sm_handlers.Append(handler);
}
};
void wxBitmap::InsertHandler(wxBitmapHandler *handler)
{
sm_handlers.Insert(handler);
}
bool wxBitmap::SaveFile( const wxString &WXUNUSED(name), int WXUNUSED(type),
wxPalette *WXUNUSED(palette) )
bool wxBitmap::RemoveHandler(const wxString& name)
{
wxBitmapHandler *handler = FindHandler(name);
if ( handler )
{
sm_handlers.DeleteObject(handler);
return TRUE;
}
else
return FALSE;
}
wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
{
wxNode *node = sm_handlers.First();
while ( node )
{
wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
if ( handler->GetName() == name )
return handler;
node = node->Next();
}
return NULL;
}
wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
{
wxNode *node = sm_handlers.First();
while ( node )
{
wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
if ( handler->GetExtension() == extension &&
(bitmapType == -1 || handler->GetType() == bitmapType) )
return handler;
node = node->Next();
}
return NULL;
}
wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
{
wxNode *node = sm_handlers.First();
while ( node )
{
wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
if (handler->GetType() == bitmapType)
return handler;
node = node->Next();
}
return NULL;
}
/*
* wxMask
*/
wxMask::wxMask()
{
/* TODO
m_maskBitmap = 0;
*/
}
// Construct a mask from a bitmap and a colour indicating
// the transparent area
wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
{
/* TODO
m_maskBitmap = 0;
*/
Create(bitmap, colour);
}
// Construct a mask from a bitmap and a palette index indicating
// the transparent area
wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
{
/* TODO
m_maskBitmap = 0;
*/
Create(bitmap, paletteIndex);
}
// Construct a mask from a mono bitmap (copies the bitmap).
wxMask::wxMask(const wxBitmap& bitmap)
{
/* TODO
m_maskBitmap = 0;
*/
Create(bitmap);
}
wxMask::~wxMask()
{
// TODO: delete mask bitmap
}
// Create a mask from a mono bitmap (copies the bitmap).
bool wxMask::Create(const wxBitmap& bitmap)
{
// TODO
return FALSE;
}
// Create a mask from a bitmap and a palette index indicating
// the transparent area
bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
{
// TODO
return FALSE;
}
// Create a mask from a bitmap and a colour indicating
// the transparent area
bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
{
// TODO
return FALSE;
}
/*
* wxBitmapHandler
*/
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
{
return FALSE;
};
}
bool wxBitmap::LoadFile( const wxString &WXUNUSED(name), int WXUNUSED(type) )
bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type,
int desiredWidth, int desiredHeight)
{
return FALSE;
};
}
wxPalette *wxBitmap::GetPalette(void) const
bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
{
if (!Ok()) return NULL;
return M_BMPDATA->m_palette;
return FALSE;
}
/*
* Standard handlers
*/
/* TODO: bitmap handlers, a bit like this:
class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
{
DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
public:
inline wxBMPResourceHandler()
{
m_name = "Windows bitmap resource";
m_extension = "";
m_type = wxBITMAP_TYPE_BMP_RESOURCE;
};
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight);
};
IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
*/
void wxBitmap::CleanUpHandlers()
{
wxNode *node = sm_handlers.First();
while ( node )
{
wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
wxNode *next = node->Next();
delete handler;
delete node;
node = next;
}
}
void wxBitmap::InitStandardHandlers()
{
/* TODO: initialize all standard bitmap or derive class handlers here.
AddHandler(new wxBMPResourceHandler);
AddHandler(new wxBMPFileHandler);
AddHandler(new wxXPMFileHandler);
AddHandler(new wxXPMDataHandler);
AddHandler(new wxICOResourceHandler);
AddHandler(new wxICOFileHandler);
*/
}

95
src/qt/bmpbuttn.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: bmpbuttn.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxBitmapButton
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,65 +15,51 @@
#include "wx/bmpbuttn.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxBitmapButton;
//-----------------------------------------------------------------------------
// wxBitmapButton
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton,wxControl)
wxBitmapButton::wxBitmapButton(void)
{
};
wxBitmapButton::wxBitmapButton( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
Create( parent, id, bitmap, pos, size, style, name );
};
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxButton)
#endif
bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
m_needParent = TRUE;
m_buttonBitmap = bitmap;
SetName(name);
SetValidator(validator);
parent->AddChild(this);
wxSize newSize = size;
m_backgroundColour = parent->GetDefaultBackgroundColour() ;
m_foregroundColour = parent->GetDefaultForegroundColour() ;
m_windowStyle = style;
m_marginX = 0;
m_marginY = 0;
PreCreation( parent, id, pos, newSize, style, name );
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
m_bitmap = bitmap;
m_label = "";
if (id == -1)
m_windowId = NewControlId();
else
m_windowId = id;
if ( width == -1 && bitmap.Ok())
width = bitmap.GetWidth() + 2*m_marginX;
if (newSize.x == -1) newSize.x = m_bitmap.GetHeight()+10;
if (newSize.y == -1) newSize.y = m_bitmap.GetWidth()+10;
SetSize( newSize.x, newSize.y );
if ( height == -1 && bitmap.Ok())
height = bitmap.GetHeight() + 2*m_marginY;
/* TODO: create bitmap button
*/
PostCreation();
return FALSE;
}
Show( TRUE );
return TRUE;
};
void wxBitmapButton::SetDefault(void)
void wxBitmapButton::SetBitmapLabel(const wxBitmap& bitmap)
{
};
m_buttonBitmap = bitmap;
}
void wxBitmapButton::SetLabel( const wxString &label )
{
wxControl::SetLabel( label );
};
wxString wxBitmapButton::GetLabel(void) const
{
return wxControl::GetLabel();
};

216
src/qt/brush.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: brush.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxBrush
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -12,121 +13,150 @@
#pragma implementation "brush.h"
#endif
#include "wx/setup.h"
#include "wx/utils.h"
#include "wx/brush.h"
//-----------------------------------------------------------------------------
// wxBrush
//-----------------------------------------------------------------------------
class wxBrushRefData: public wxObjectRefData
{
public:
wxBrushRefData(void);
int m_style;
wxBitmap m_stipple;
wxColour m_colour;
};
wxBrushRefData::wxBrushRefData(void)
{
m_style = 0;
};
//-----------------------------------------------------------------------------
#define M_BRUSHDATA ((wxBrushRefData *)m_refData)
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject)
#endif
wxBrush::wxBrush(void)
wxBrushRefData::wxBrushRefData()
{
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
m_style = wxSOLID;
// TODO: null data
}
wxBrush::wxBrush( const wxColour &colour, int style )
wxBrushRefData::wxBrushRefData(const wxBrushRefData& data)
{
m_refData = new wxBrushRefData();
M_BRUSHDATA->m_style = style;
M_BRUSHDATA->m_colour = colour;
m_style = data.m_style;
m_stipple = data.m_stipple;
m_colour = data.m_colour;
/* TODO: null data
m_hBrush = 0;
*/
}
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
wxBrush::wxBrush( const wxString &colourName, int style )
wxBrushRefData::~wxBrushRefData()
{
m_refData = new wxBrushRefData();
M_BRUSHDATA->m_style = style;
M_BRUSHDATA->m_colour = colourName;
// TODO: delete data
}
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
wxBrush::wxBrush( const wxBitmap &stippleBitmap )
// Brushes
wxBrush::wxBrush()
{
m_refData = new wxBrushRefData();
if ( wxTheBrushList )
wxTheBrushList->AddBrush(this);
}
wxBrush::~wxBrush()
{
if ( wxTheBrushList )
wxTheBrushList->RemoveBrush(this);
}
wxBrush::wxBrush(const wxColour& col, int Style)
{
m_refData = new wxBrushRefData;
M_BRUSHDATA->m_colour = col;
M_BRUSHDATA->m_style = Style;
RealizeResource();
if ( wxTheBrushList )
wxTheBrushList->AddBrush(this);
}
wxBrush::wxBrush(const wxString& col, int Style)
{
m_refData = new wxBrushRefData;
// Implicit conversion from string to wxColour via colour database
M_BRUSHDATA->m_colour = col;
M_BRUSHDATA->m_style = Style;
RealizeResource();
if ( wxTheBrushList )
wxTheBrushList->AddBrush(this);
}
wxBrush::wxBrush(const wxBitmap& stipple)
{
m_refData = new wxBrushRefData;
M_BRUSHDATA->m_style = wxSTIPPLE;
M_BRUSHDATA->m_colour = *wxBLACK;
M_BRUSHDATA->m_stipple = stippleBitmap;
M_BRUSHDATA->m_stipple = stipple;
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
RealizeResource();
wxBrush::wxBrush( const wxBrush &brush )
if ( wxTheBrushList )
wxTheBrushList->AddBrush(this);
}
void wxBrush::Unshare()
{
Ref( brush );
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
wxBrush::wxBrush( const wxBrush *brush )
// Don't change shared data
if (!m_refData)
{
if (brush) Ref( *brush );
if (wxTheBrushList) wxTheBrushList->Append( this );
};
wxBrush::~wxBrush(void)
m_refData = new wxBrushRefData();
}
else
{
if (wxTheBrushList) wxTheBrushList->RemoveBrush( this );
};
wxBrushRefData* ref = new wxBrushRefData(*(wxBrushRefData*)m_refData);
UnRef();
m_refData = ref;
}
}
wxBrush& wxBrush::operator = ( const wxBrush& brush )
void wxBrush::SetColour(const wxColour& col)
{
if (*this == brush) return (*this);
Ref( brush );
return *this;
};
Unshare();
bool wxBrush::operator == ( const wxBrush& brush )
M_BRUSHDATA->m_colour = col;
RealizeResource();
}
void wxBrush::SetColour(const wxString& col)
{
return m_refData == brush.m_refData;
};
Unshare();
bool wxBrush::operator != ( const wxBrush& brush )
M_BRUSHDATA->m_colour = col;
RealizeResource();
}
void wxBrush::SetColour(const unsigned char r, const unsigned char g, const unsigned char b)
{
return m_refData != brush.m_refData;
};
Unshare();
bool wxBrush::Ok(void) const
M_BRUSHDATA->m_colour.Set(r, g, b);
RealizeResource();
}
void wxBrush::SetStyle(int Style)
{
return ((m_refData) && M_BRUSHDATA->m_colour.Ok());
};
Unshare();
int wxBrush::GetStyle(void) const
M_BRUSHDATA->m_style = Style;
RealizeResource();
}
void wxBrush::SetStipple(const wxBitmap& Stipple)
{
return M_BRUSHDATA->m_style;
};
Unshare();
wxColour &wxBrush::GetColour(void) const
M_BRUSHDATA->m_stipple = Stipple;
RealizeResource();
}
void wxBrush::RealizeResource()
{
return M_BRUSHDATA->m_colour;
};
wxBitmap *wxBrush::GetStipple(void) const
{
return &M_BRUSHDATA->m_stipple;
};
// TODO: create the brush
}

90
src/qt/button.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: button.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxButton
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,48 +15,61 @@
#include "wx/button.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxButton;
//-----------------------------------------------------------------------------
// wxButton
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
#endif
//-----------------------------------------------------------------------------
wxButton::wxButton(void)
{
};
wxButton::wxButton( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
Create( parent, id, label, pos, size, style, name );
};
// Button
bool wxButton::Create(wxWindow *parent, wxWindowID id, const wxString& label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
SetName(name);
SetValidator(validator);
m_windowStyle = style;
void wxButton::SetDefault(void)
parent->AddChild((wxButton *)this);
if (id == -1)
m_windowId = NewControlId();
else
m_windowId = id;
// TODO: create button
return FALSE;
}
void wxButton::SetSize(int x, int y, int width, int height, int sizeFlags)
{
};
// TODO
}
void wxButton::SetDefault()
{
wxWindow *parent = (wxWindow *)GetParent();
if (parent)
parent->SetDefaultItem(this);
// TODO: make button the default
}
wxString wxButton::GetLabel() const
{
// TODO
return wxString("");
}
void wxButton::SetLabel(const wxString& label)
{
wxControl::SetLabel( label );
};
// TODO
}
wxString wxButton::GetLabel(void) const
void wxButton::Command (wxCommandEvent & event)
{
return wxControl::GetLabel();
};
ProcessCommand (event);
}

129
src/qt/checkbox.cpp
View File

@@ -1,50 +1,117 @@
/////////////////////////////////////////////////////////////////////////////
// Name: checkbox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxCheckBox
// Author: AUTHOR
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "checkbox.h"
#endif
#include "wx/checkbox.h"
//-----------------------------------------------------------------------------
// wxCheckBox
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapCheckBox, wxCheckBox)
#endif
wxCheckBox::wxCheckBox(void)
{
};
wxCheckBox::wxCheckBox( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
Create( parent, id, label, pos, size, style, name );
};
// Single check box item
bool wxCheckBox::Create(wxWindow *parent, wxWindowID id, const wxString& label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
SetName(name);
SetValidator(validator);
m_windowStyle = style;
void wxCheckBox::SetValue( bool WXUNUSED(state) )
{
};
if (parent) parent->AddChild(this);
if ( id == -1 )
m_windowId = NewControlId();
else
m_windowId = id;
// TODO: create checkbox
bool wxCheckBox::GetValue(void) const
{
return FALSE;
};
}
void wxCheckBox::SetLabel(const wxString& label)
{
// TODO
}
void wxCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
// TODO
}
void wxCheckBox::SetValue(bool val)
{
// TODO
}
bool wxCheckBox::GetValue() const
{
// TODO
return FALSE;
}
void wxCheckBox::Command (wxCommandEvent & event)
{
SetValue ((event.GetInt() != 0));
ProcessCommand (event);
}
// Bitmap checkbox
bool wxBitmapCheckBox::Create(wxWindow *parent, wxWindowID id, const wxBitmap *label,
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
SetName(name);
SetValidator(validator);
m_windowStyle = style;
if (parent) parent->AddChild(this);
if ( id == -1 )
m_windowId = NewControlId();
else
m_windowId = id;
// TODO: Create the bitmap checkbox
return FALSE;
}
void wxBitmapCheckBox::SetLabel(const wxBitmap *bitmap)
{
// TODO
}
void wxBitmapCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
// TODO
}
void wxBitmapCheckBox::SetValue(bool val)
{
// TODO
}
bool wxBitmapCheckBox::GetValue() const
{
// TODOD
return FALSE;
}

146
src/qt/choice.cpp
View File

@@ -1,97 +1,119 @@
/////////////////////////////////////////////////////////////////////////////
// Name: choice.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxChoice
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "choice.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/choice.h"
//-----------------------------------------------------------------------------
// wxChoice
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
wxChoice::wxChoice(void)
{
};
wxChoice::wxChoice( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxString &name )
{
Create( parent, id, pos, size, n, choices, style, name );
};
#endif
bool wxChoice::Create(wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style, const wxString &name )
long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
SetName(name);
SetValidator(validator);
m_noStrings = n;
m_windowStyle = style;
void wxChoice::Append( const wxString &WXUNUSED(item) )
{
};
if (parent) parent->AddChild(this);
void wxChoice::Clear(void)
{
};
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
int wxChoice::FindString( const wxString &WXUNUSED(string) ) const
{
return -1;
};
// TODO: create choice control
return FALSE;
}
int wxChoice::GetColumns(void) const
void wxChoice::Append(const wxString& item)
{
return 1;
};
// TODO
m_noStrings ++;
}
int wxChoice::GetSelection(void)
void wxChoice::Delete(int n)
{
return -1;
};
// TODO
m_noStrings --;
}
wxString wxChoice::GetString( int WXUNUSED(n) ) const
void wxChoice::Clear()
{
return "";
};
// TODO
m_noStrings = 0;
}
wxString wxChoice::GetStringSelection(void) const
{
return "";
};
int wxChoice::Number(void) const
int wxChoice::GetSelection() const
{
// TODO
return 0;
};
}
void wxChoice::SetColumns( int WXUNUSED(n) )
void wxChoice::SetSelection(int n)
{
};
// TODO
}
void wxChoice::SetSelection( int WXUNUSED(n) )
int wxChoice::FindString(const wxString& s) const
{
};
// TODO
return 0;
}
void wxChoice::SetStringSelection( const wxString &string )
wxString wxChoice::GetString(int n) const
{
int n = FindString( string );
if (n != -1) SetSelection( n );
};
// TODO
return wxString("");
}
void wxChoice::SetSize(int x, int y, int width, int height, int sizeFlags)
{
// TODO
}
wxString wxChoice::GetStringSelection () const
{
int sel = GetSelection ();
if (sel > -1)
return wxString(this->GetString (sel));
else
return wxString("");
}
bool wxChoice::SetStringSelection (const wxString& s)
{
int sel = FindString (s);
if (sel > -1)
{
SetSelection (sel);
return TRUE;
}
else
return FALSE;
}
void wxChoice::Command(wxCommandEvent & event)
{
SetSelection (event.GetInt());
ProcessCommand (event);
}

218
src/qt/colour.cpp
View File

@@ -1,164 +1,126 @@
/////////////////////////////////////////////////////////////////////////////
// Name: colour.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxColour class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "colour.h"
#endif
#include "wx/gdicmn.h"
#include "wx/colour.h"
//-----------------------------------------------------------------------------
// wxColour
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject)
#endif
class wxColourRefData: public wxObjectRefData
// Colour
wxColour::wxColour ()
{
public:
wxColourRefData(void);
~wxColourRefData(void);
void FreeColour(void);
bool m_hasPixel;
friend wxColour;
};
wxColourRefData::wxColourRefData(void)
{
m_hasPixel = FALSE;
};
wxColourRefData::~wxColourRefData(void)
{
FreeColour();
};
void wxColourRefData::FreeColour(void)
{
};
//-----------------------------------------------------------------------------
#define M_COLDATA ((wxColourRefData *)m_refData)
#define SHIFT (8*(sizeof(short int)-sizeof(char)))
IMPLEMENT_DYNAMIC_CLASS(wxColour,wxGDIObject)
wxColour::wxColour(void)
{
};
wxColour::wxColour( char WXUNUSED(red), char WXUNUSED(green), char WXUNUSED(blue) )
{
m_refData = new wxColourRefData();
};
wxColour::wxColour( const wxString &colourName )
{
wxNode *node = NULL;
if ( (wxTheColourDatabase) && (node = wxTheColourDatabase->Find(colourName)) )
{
wxColour *col = (wxColour*)node->Data();
UnRef();
if (col) Ref( *col );
m_isInit = FALSE;
m_red = m_blue = m_green = 0;
/* TODO
m_pixel = 0;
*/
}
else
wxColour::wxColour (unsigned char r, unsigned char g, unsigned char b)
{
m_refData = new wxColourRefData();
};
};
m_red = r;
m_green = g;
m_blue = b;
m_isInit = TRUE;
/* TODO
m_pixel = PALETTERGB (m_red, m_green, m_blue);
*/
}
wxColour::wxColour (const wxColour& col)
{
Ref( col );
};
wxColour::wxColour( const wxColour* col )
{
if (col) Ref( *col );
};
wxColour::~wxColour(void)
{
};
m_red = col.m_red;
m_green = col.m_green;
m_blue = col.m_blue;
m_isInit = col.m_isInit;
/* TODO
m_pixel = col.m_pixel;
*/
}
wxColour& wxColour::operator =(const wxColour& col)
{
if (*this == col) return (*this);
Ref( col );
m_red = col.m_red;
m_green = col.m_green;
m_blue = col.m_blue;
m_isInit = col.m_isInit;
/* TODO
m_pixel = col.m_pixel;
*/
return *this;
};
}
wxColour& wxColour::operator = ( const wxString& colourName )
wxColour::wxColour (const wxString& col)
{
UnRef();
wxNode *node = NULL;
if ((wxTheColourDatabase) && (node = wxTheColourDatabase->Find(colourName)) )
wxColour *the_colour = wxTheColourDatabase->FindColour (col);
if (the_colour)
{
wxColour *col = (wxColour*)node->Data();
if (col) Ref( *col );
m_red = the_colour->Red ();
m_green = the_colour->Green ();
m_blue = the_colour->Blue ();
m_isInit = TRUE;
}
else
{
m_refData = new wxColourRefData();
};
return *this;
};
m_red = 0;
m_green = 0;
m_blue = 0;
m_isInit = FALSE;
}
/* TODO
m_pixel = PALETTERGB (m_red, m_green, m_blue);
*/
}
bool wxColour::operator == ( const wxColour& col )
wxColour::~wxColour ()
{
return m_refData == col.m_refData;
};
}
bool wxColour::operator != ( const wxColour& col)
wxColour& wxColour::operator = (const wxString& col)
{
return m_refData != col.m_refData;
};
void wxColour::Set( const unsigned char WXUNUSED(red), const unsigned char WXUNUSED(green),
const unsigned char WXUNUSED(blue) )
wxColour *the_colour = wxTheColourDatabase->FindColour (col);
if (the_colour)
{
UnRef();
m_refData = new wxColourRefData();
};
unsigned char wxColour::Red(void) const
m_red = the_colour->Red ();
m_green = the_colour->Green ();
m_blue = the_colour->Blue ();
m_isInit = TRUE;
}
else
{
if (!Ok()) return 0;
return 0;
};
m_red = 0;
m_green = 0;
m_blue = 0;
m_isInit = FALSE;
}
/* TODO
m_pixel = PALETTERGB (m_red, m_green, m_blue);
*/
return (*this);
}
unsigned char wxColour::Green(void) const
void wxColour::Set (unsigned char r, unsigned char g, unsigned char b)
{
if (!Ok()) return 0;
return 0;
};
unsigned char wxColour::Blue(void) const
{
if (!Ok()) return 0;
return 0;
};
bool wxColour::Ok(void) const
{
return (m_refData);
return 0;
};
int wxColour::GetPixel(void)
{
if (!Ok()) return 0;
return 0;
};
m_red = r;
m_green = g;
m_blue = b;
m_isInit = TRUE;
/* TODO
m_pixel = PALETTERGB (m_red, m_green, m_blue);
*/
}

177
src/qt/combobox.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: combobox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxComboBox class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,136 +15,102 @@
#include "wx/combobox.h"
//-----------------------------------------------------------------------------
// wxComboBox
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
#endif
bool wxComboBox::Create(wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size, int n, const wxString choices[],
long style, const wxString& name )
bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name)
{
SetName(name);
SetValidator(validator);
m_noStrings = n;
m_windowStyle = style;
if (parent) parent->AddChild(this);
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
// TODO: create combobox control
return TRUE;
};
}
void wxComboBox::Clear(void)
wxString wxComboBox::GetValue() const
{
};
// TODO
return wxString("");
}
void wxComboBox::Append( const wxString &item )
void wxComboBox::SetValue(const wxString& value)
{
Append( item, (char*)NULL );
};
// TODO
}
void wxComboBox::Append( const wxString &WXUNUSED(item), char *WXUNUSED(clientData) )
// Clipboard operations
void wxComboBox::Copy()
{
};
// TODO
}
void wxComboBox::Delete( int WXUNUSED(n) )
void wxComboBox::Cut()
{
};
// TODO
}
int wxComboBox::FindString( const wxString &WXUNUSED(item) )
void wxComboBox::Paste()
{
return -1;
};
// TODO
}
char* wxComboBox::GetClientData( int WXUNUSED(n) )
void wxComboBox::SetEditable(bool editable)
{
return (char*)NULL;
};
// TODO
}
void wxComboBox::SetClientData( int WXUNUSED(n), char *WXUNUSED(clientData) )
void wxComboBox::SetInsertionPoint(long pos)
{
};
// TODO
}
int wxComboBox::GetSelection(void) const
void wxComboBox::SetInsertionPointEnd()
{
return -1;
};
// TODO
}
wxString wxComboBox::GetString( int WXUNUSED(n) ) const
{
return "";
};
wxString wxComboBox::GetStringSelection(void) const
{
return "";
};
int wxComboBox::Number(void) const
long wxComboBox::GetInsertionPoint() const
{
// TODO
return 0;
};
}
void wxComboBox::SetSelection( int WXUNUSED(n) )
{
};
void wxComboBox::SetStringSelection( const wxString &string )
{
int res = FindString( string );
if (res == -1) return;
SetSelection( res );
};
wxString wxComboBox::GetValue(void) const
{
return "";
};
void wxComboBox::SetValue( const wxString& WXUNUSED(value) )
{
};
void wxComboBox::Copy(void)
{
};
void wxComboBox::Cut(void)
{
};
void wxComboBox::Paste(void)
{
};
void wxComboBox::SetInsertionPoint( long WXUNUSED(pos) )
{
};
void wxComboBox::SetInsertionPointEnd(void)
{
};
long wxComboBox::GetInsertionPoint(void) const
long wxComboBox::GetLastPosition() const
{
// TODO
return 0;
};
}
long wxComboBox::GetLastPosition(void) const
void wxComboBox::Replace(long from, long to, const wxString& value)
{
return 0;
};
// TODO
}
void wxComboBox::Replace( long WXUNUSED(from), long WXUNUSED(to), const wxString& WXUNUSED(value) )
void wxComboBox::Remove(long from, long to)
{
};
// TODO
}
void wxComboBox::Remove(long WXUNUSED(from), long WXUNUSED(to) )
void wxComboBox::SetSelection(long from, long to)
{
};
void wxComboBox::SetSelection( long WXUNUSED(from), long WXUNUSED(to) )
{
};
void wxComboBox::SetEditable( bool WXUNUSED(editable) )
{
};
// TODO
}

118
src/qt/control.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: control.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxControl class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,46 +15,97 @@
#include "wx/control.h"
//-----------------------------------------------------------------------------
// wxControl
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
IMPLEMENT_DYNAMIC_CLASS(wxControl,wxWindow)
BEGIN_EVENT_TABLE(wxControl, wxWindow)
END_EVENT_TABLE()
#endif
wxControl::wxControl(void)
// Item members
wxControl::wxControl()
{
};
m_backgroundColour = *wxWHITE;
m_foregroundColour = *wxBLACK;
m_callback = 0;
}
wxControl::wxControl( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name ) :
wxWindow( parent, id, pos, size, style, name )
wxControl::~wxControl()
{
};
void wxControl::Command( wxCommandEvent &WXUNUSED(event) )
// If we delete an item, we should initialize the parent panel,
// because it could now be invalid.
wxWindow *parent = (wxWindow *)GetParent();
if (parent)
{
};
if (parent->GetDefaultItem() == this)
parent->SetDefaultItem(NULL);
}
}
void wxControl::SetLabel(const wxString& label)
{
for ( const char *pc = label; *pc != '\0'; pc++ ) {
if ( *pc == '&' ) {
pc++; // skip it
#if 0 // it would be unused anyhow for now - kbd interface not done yet
if ( *pc != '&' )
m_chAccel = *pc;
#endif
// TODO
}
m_label << *pc;
}
};
wxString wxControl::GetLabel(void) const
wxString wxControl::GetLabel() const
{
return m_label;
};
// TODO
return wxString("");
}
/*
* Allocates control IDs within the appropriate range
*/
int NewControlId()
{
static int s_controlId = 0;
s_controlId ++;
return s_controlId;
}
void wxControl::ProcessCommand (wxCommandEvent & event)
{
// Tries:
// 1) A callback function (to become obsolete)
// 2) OnCommand, starting at this window and working up parent hierarchy
// 3) OnCommand then calls ProcessEvent to search the event tables.
if (m_callback)
{
(void) (*(m_callback)) (*this, event);
}
else
{
GetEventHandler()->OnCommand(*this, event);
}
}
void wxControl::SetClientSize (int width, int height)
{
SetSize (-1, -1, width, height);
}
void wxControl::Centre (int direction)
{
int x, y, width, height, panel_width, panel_height, new_x, new_y;
wxWindow *parent = (wxWindow *) GetParent ();
if (!parent)
return;
parent->GetClientSize (&panel_width, &panel_height);
GetSize (&width, &height);
GetPosition (&x, &y);
new_x = x;
new_y = y;
if (direction & wxHORIZONTAL)
new_x = (int) ((panel_width - width) / 2);
if (direction & wxVERTICAL)
new_y = (int) ((panel_height - height) / 2);
SetSize (new_x, new_y, width, height);
}

228
src/qt/cursor.cpp
View File

@@ -1,120 +1,186 @@
/////////////////////////////////////////////////////////////////////////////
// Name: cursor.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxCursor class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "cursor.h"
#endif
#include "wx/cursor.h"
//-----------------------------------------------------------------------------
// wxCursor
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
#endif
class wxCursorRefData: public wxObjectRefData
wxCursorRefData::wxCursorRefData()
{
public:
m_width = 32; m_height = 32;
wxCursorRefData(void);
~wxCursorRefData(void);
/* TODO
m_hCursor = 0 ;
*/
}
};
wxCursorRefData::wxCursorRefData(void)
wxCursorRefData::~wxCursorRefData()
{
};
// TODO: destroy cursor
}
wxCursorRefData::~wxCursorRefData(void)
// Cursors
wxCursor::wxCursor()
{
};
}
//-----------------------------------------------------------------------------
#define M_CURSORDATA ((wxCursorRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxCursor,wxObject)
wxCursor::wxCursor(void)
wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
{
};
}
wxCursor::wxCursor( int WXUNUSED(cursorId) )
wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
{
m_refData = new wxCursorRefData();
};
m_refData = new wxIconRefData;
wxCursor::wxCursor( const wxCursor &cursor )
// TODO: create cursor from a file
}
// Cursors by stock number
wxCursor::wxCursor(int cursor_type)
{
Ref( cursor );
};
m_refData = new wxIconRefData;
wxCursor::wxCursor( const wxCursor *cursor )
/* TODO
switch (cursor_type)
{
UnRef();
if (cursor) Ref( *cursor );
};
wxCursor::~wxCursor(void)
case wxCURSOR_WAIT:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_WAIT);
break;
case wxCURSOR_IBEAM:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_IBEAM);
break;
case wxCURSOR_CROSS:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_CROSS);
break;
case wxCURSOR_SIZENWSE:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENWSE);
break;
case wxCURSOR_SIZENESW:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENESW);
break;
case wxCURSOR_SIZEWE:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZEWE);
break;
case wxCURSOR_SIZENS:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENS);
break;
case wxCURSOR_CHAR:
{
};
wxCursor& wxCursor::operator = ( const wxCursor& cursor )
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
break;
}
case wxCURSOR_HAND:
{
if (*this == cursor) return (*this);
Ref( cursor );
return *this;
};
bool wxCursor::operator == ( const wxCursor& cursor )
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_HAND");
break;
}
case wxCURSOR_BULLSEYE:
{
return m_refData == cursor.m_refData;
};
bool wxCursor::operator != ( const wxCursor& cursor )
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BULLSEYE");
break;
}
case wxCURSOR_PENCIL:
{
return m_refData != cursor.m_refData;
};
bool wxCursor::Ok(void) const
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PENCIL");
break;
}
case wxCURSOR_MAGNIFIER:
{
return TRUE;
};
//-----------------------------------------------------------------------------
// busy cursor routines
//-----------------------------------------------------------------------------
bool g_isBusy = FALSE;
void wxEndBusyCursor(void)
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_MAGNIFIER");
break;
}
case wxCURSOR_NO_ENTRY:
{
g_isBusy = FALSE;
};
void wxBeginBusyCursor( wxCursor *WXUNUSED(cursor) )
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_NO_ENTRY");
break;
}
case wxCURSOR_LEFT_BUTTON:
{
g_isBusy = TRUE;
};
bool wxIsBusy(void)
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
break;
}
case wxCURSOR_RIGHT_BUTTON:
{
return g_isBusy;
};
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
break;
}
case wxCURSOR_MIDDLE_BUTTON:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
break;
}
case wxCURSOR_SIZING:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_SIZING");
break;
}
case wxCURSOR_WATCH:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_WATCH");
break;
}
case wxCURSOR_SPRAYCAN:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_ROLLER");
break;
}
case wxCURSOR_PAINT_BRUSH:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PBRUSH");
break;
}
case wxCURSOR_POINT_LEFT:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PLEFT");
break;
}
case wxCURSOR_POINT_RIGHT:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PRIGHT");
break;
}
case wxCURSOR_QUESTION_ARROW:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_QARROW");
break;
}
case wxCURSOR_BLANK:
{
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BLANK");
break;
}
default:
case wxCURSOR_ARROW:
M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW);
break;
}
*/
}
wxCursor::~wxCursor()
{
}
// Global cursor setting
void wxSetCursor(const wxCursor& cursor)
{
extern wxCursor *g_globalCursor;
if (g_globalCursor) (*g_globalCursor) = cursor;
if (cursor.Ok()) {};
};
// TODO (optional on platforms with no global cursor)
}

592
src/qt/data.cpp
View File

@@ -1,32 +1,23 @@
/////////////////////////////////////////////////////////////////////////////
// Name: data.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: Various data
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
// #pragma implementation
#pragma implementation
#endif
#include "wx/wx.h"
#define _MAXPATHLEN 500
// Used for X resources
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xresource.h>
wxList wxResourceCache(wxKEY_STRING);
XrmDatabase wxResourceDatabase;
// Useful buffer, initialized in wxCommonInit
// Useful buffer, initialized in CommonInit
char *wxBuffer = NULL;
// Windows List
@@ -35,44 +26,23 @@ wxList wxTopLevelWindows;
// List of windows pending deletion
wxList wxPendingDelete;
// Current cursor, in order to hang on to
// cursor handle when setting the cursor globally
wxCursor *g_globalCursor = NULL;
// Don't allow event propagation during drag
bool g_blockEventsOnDrag = FALSE;
// Message Strings for Internationalization
char **wx_msg_str = (char**)NULL;
// Custom OS version, as optionally placed in wx.ini/.wxrc
// Currently this can be Win95, Windows, Win32s, WinNT.
// For some systems, you can't tell until run-time what services you
// have. See wxGetOsVersion, which uses this string if present.
char *wxOsVersion = NULL;
// For printing several pages
int wxPageNumber;
wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL;
// GDI Object Lists
wxBrushList *wxTheBrushList = NULL;
wxPenList *wxThePenList = NULL;
wxFontList *wxTheFontList = NULL;
wxColourDatabase *wxTheColourDatabase = NULL;
wxBitmapList *wxTheBitmapList = NULL;
// X only font names
// wxFontNameDirectory wxTheFontNameDirectory;
wxColourDatabase *wxTheColourDatabase = NULL;
// Stock objects
wxFont *wxNORMAL_FONT;
wxFont *wxSMALL_FONT;
wxFont *wxITALIC_FONT;
wxFont *wxSWISS_FONT;
wxPen *wxRED_PEN;
wxPen *wxCYAN_PEN;
wxPen *wxGREEN_PEN;
wxPen *wxBLACK_PEN;
@@ -96,7 +66,6 @@ wxBrush *wxLIGHT_GREY_BRUSH;
wxColour *wxBLACK;
wxColour *wxWHITE;
wxColour *wxGREY; // Robert Roebling
wxColour *wxRED;
wxColour *wxBLUE;
wxColour *wxGREEN;
@@ -108,14 +77,15 @@ wxCursor *wxHOURGLASS_CURSOR = NULL;
wxCursor *wxCROSS_CURSOR = NULL;
// 'Null' objects
wxAcceleratorTable wxNullAcceleratorTable;
wxBitmap wxNullBitmap;
wxIcon wxNullIcon;
wxCursor wxNullCursor;
wxPen wxNullPen;
wxBrush wxNullBrush;
wxPalette wxNullPalette;
wxFont wxNullFont;
wxColour wxNullColour;
wxPalette wxNullPalette;
// Default window names
const char *wxButtonNameStr = "button";
@@ -157,391 +127,10 @@ const char *wxFatalErrorStr = "wxWindows Fatal Error";
const char *wxFloatToStringStr = "%.2f";
const char *wxDoubleToStringStr = "%.2f";
#ifdef wx_msw
const char *wxUserResourceStr = "TEXT";
#endif
#if USE_SHARED_LIBRARY
/*
* For wxWindows to be made into a dynamic library (e.g. Sun),
* all IMPLEMENT_... macros must be in one place.
* But normally, the definitions are in the appropriate places.
*/
// Hand-coded IMPLEMENT... macro for wxObject (define static data)
wxClassInfo wxObject::classwxObject("wxObject", NULL, NULL, sizeof(wxObject), NULL);
wxClassInfo *wxClassInfo::first = NULL;
#include "wx/button.h"
#include "wx/bmpbuttn.h"
IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxButton)
#include "wx/checkbox.h"
IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapCheckBox, wxCheckBox)
#include "wx/choice.h"
IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
#if USE_CLIPBOARD
#include "wx/clipbrd.h"
IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxClipboardClient, wxObject)
#endif
#if USE_COMBOBOX
#include "wx/combobox.h"
IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
#endif
#include "wx/dc.h"
#include "wx/dcmemory.h"
#include "wx/dcclient.h"
#include "wx/dcscreen.h"
IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
#if defined(wx_msw)
#include "wx/dcprint.h"
IMPLEMENT_CLASS(wxPrinterDC, wxDC)
#endif
#include "wx/dialog.h"
IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxWindow)
#include "wx/frame.h"
IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
#include "wx/mdi.h"
IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
#include "wx/cmndata.h"
IMPLEMENT_DYNAMIC_CLASS(wxColourData, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxFontData, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPrintData, wxObject)
#include "wx/colordlg.h"
#include "wx/fontdlg.h"
#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
#include "wx/generic/colordlg.h"
#include "wx/generic/fontdlg.h"
IMPLEMENT_DYNAMIC_CLASS(wxGenericColourDialog, wxDialog)
IMPLEMENT_DYNAMIC_CLASS(wxGenericFontDialog, wxDialog)
#endif
// X defines wxColourDialog to be wxGenericColourDialog
#ifndef wx_x
IMPLEMENT_DYNAMIC_CLASS(wxColourDialog, wxDialog)
IMPLEMENT_DYNAMIC_CLASS(wxFontDialog, wxDialog)
#endif
#include "wx/gdicmn.h"
#include "wx/pen.h"
#include "wx/brush.h"
#include "wx/font.h"
#include "wx/palette.h"
#include "wx/icon.h"
#include "wx/cursor.h"
IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject)
IMPLEMENT_CLASS(wxColourDatabase, wxList)
IMPLEMENT_DYNAMIC_CLASS(wxFontList, wxList)
IMPLEMENT_DYNAMIC_CLASS(wxPenList, wxList)
IMPLEMENT_DYNAMIC_CLASS(wxBrushList, wxList)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapList, wxList)
/*
#if (!USE_TYPEDEFS)
IMPLEMENT_DYNAMIC_CLASS(wxPoint, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxIntPoint, wxObject)
#endif
*/
#if defined(wx_x) || (defined(wx_msw) && USE_PORTABLE_FONTS_IN_MSW)
IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject)
#endif
#include "wx/hash.h"
IMPLEMENT_DYNAMIC_CLASS(wxHashTable, wxObject)
#include "wx/help.h"
IMPLEMENT_DYNAMIC_CLASS(wxHelpInstance, wxClient)
IMPLEMENT_CLASS(wxHelpConnection, wxConnection)
#include "wx/list.h"
IMPLEMENT_DYNAMIC_CLASS(wxNode, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxList, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxStringList, wxList)
#if USE_PRINTING_ARCHITECTURE
#include "wx/print.h"
IMPLEMENT_DYNAMIC_CLASS(wxPrintDialog, wxDialog)
IMPLEMENT_DYNAMIC_CLASS(wxPrinterBase, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPostScriptPrinter, wxPrinterBase)
IMPLEMENT_DYNAMIC_CLASS(wxWindowsPrinter, wxPrinterBase)
IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
IMPLEMENT_CLASS(wxPostScriptPrintPreview, wxPrintPreviewBase)
IMPLEMENT_CLASS(wxWindowsPrintPreview, wxPrintPreviewBase)
IMPLEMENT_CLASS(wxGenericPrintDialog, wxDialog)
IMPLEMENT_CLASS(wxGenericPrintSetupDialog, wxDialog)
#endif
#if USE_POSTSCRIPT
#include "wx/postscrp.h"
IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxPrintSetupData, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPageSetupData, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperType, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperDatabase, wxList)
wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL;
#endif
#if USE_WX_RESOURCES
#include "wx/resource.h"
IMPLEMENT_DYNAMIC_CLASS(wxItemResource, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxResourceTable, wxHashTable)
#endif
#include "wx/event.h"
IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxProcessEvent, wxEvent)
#include "wx/utils.h"
IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxList)
// IMPLEMENT_DYNAMIC_CLASS(wxRect, wxObject)
#include "wx/process.h"
IMPLEMENT_DYNAMIC_CLASS(wxProcess, wxEvtHandler)
#if USE_TIMEDATE
#include "wx/date.h"
IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
#endif
#if USE_DOC_VIEW_ARCHITECTURE
#include "wx/docview.h"
//IMPLEMENT_ABSTRACT_CLASS(wxDocItem, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxDocument, wxEvtHandler)
IMPLEMENT_ABSTRACT_CLASS(wxView, wxEvtHandler)
IMPLEMENT_ABSTRACT_CLASS(wxDocTemplate, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxDocManager, wxEvtHandler)
IMPLEMENT_CLASS(wxDocChildFrame, wxFrame)
IMPLEMENT_CLASS(wxDocParentFrame, wxFrame)
#if USE_PRINTING_ARCHITECTURE
IMPLEMENT_DYNAMIC_CLASS(wxDocPrintout, wxPrintout)
#endif
IMPLEMENT_CLASS(wxCommand, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxCommandProcessor, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxFileHistory, wxObject)
#endif
#if USE_CONSTRAINTS
#include "wx/layout.h"
IMPLEMENT_DYNAMIC_CLASS(wxIndividualLayoutConstraint, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxLayoutConstraints, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxSizer, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxRowColSizer, wxSizer)
#endif
#if USE_TOOLBAR
#include "wx/tbarbase.h"
IMPLEMENT_DYNAMIC_CLASS(wxToolBarTool, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxToolBarBase, wxControl)
#include "wx/tbarsmpl.h"
IMPLEMENT_DYNAMIC_CLASS(wxToolBarSimple, wxToolBarBase)
#ifdef wx_msw
#include "wx/tbarmsw.h"
IMPLEMENT_DYNAMIC_CLASS(wxToolBarMSW, wxToolBarBase)
#include "wx/tbar95.h"
IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase)
#endif
#endif
#include "wx/statusbr.h"
IMPLEMENT_DYNAMIC_CLASS(wxStatusBar, wxWindow)
BEGIN_EVENT_TABLE(wxStatusBar, wxWindow)
EVT_PAINT(wxStatusBar::OnPaint)
EVT_SYS_COLOUR_CHANGED(wxStatusBar::OnSysColourChanged)
END_EVENT_TABLE()
#if USE_TIMEDATE
#include "wx/time.h"
IMPLEMENT_DYNAMIC_CLASS(wxTime, wxObject)
#endif
#if !USE_GNU_WXSTRING
#include "wx/string.h"
IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
#endif
#ifdef wx_motif
IMPLEMENT_DYNAMIC_CLASS(wxXColormap, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxXFont, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxXCursor, wxObject)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
// This will presumably be implemented on other platforms too
#ifdef wx_msw
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
#endif
#include "wx/statbox.h"
IMPLEMENT_DYNAMIC_CLASS(wxStaticBox, wxControl)
#if USE_IPC
#include "wx/dde.h"
IMPLEMENT_ABSTRACT_CLASS(wxDDEObject, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxDDEServer, wxDDEObject)
IMPLEMENT_DYNAMIC_CLASS(wxDDEClient, wxDDEObject)
IMPLEMENT_CLASS(wxDDEConnection, wxObject)
#endif
IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
#include "wx/listbox.h"
IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
#include "wx/menu.h"
IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxWindow)
IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
#include "wx/stattext.h"
#include "wx/statbmp.h"
IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
#if USE_METAFILE
#include "wx/metafile.h"
IMPLEMENT_DYNAMIC_CLASS(wxMetaFile, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxMetaFileDC, wxDC)
#endif
#include "wx/radiobox.h"
#include "wx/radiobut.h"
IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxRadioButton, wxControl)
// IMPLEMENT_DYNAMIC_CLASS(wxBitmapRadioButton, wxRadioButton)
#include "wx/scrolbar.h"
IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
#if WXWIN_COMPATIBILITY
BEGIN_EVENT_TABLE(wxScrollBar, wxControl)
EVT_SCROLL(wxScrollBar::OnScroll)
END_EVENT_TABLE()
#endif
#include "wx/slider.h"
IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl)
#if WXWIN_COMPATIBILITY
BEGIN_EVENT_TABLE(wxSlider, wxControl)
EVT_SCROLL(wxSlider::OnScroll)
END_EVENT_TABLE()
#endif
#include "wx/timer.h"
IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
#include "wx/textctrl.h"
IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
#include "wx/window.h"
IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
#include "wx/scrolwin.h"
IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxWindow)
#include "wx/panel.h"
IMPLEMENT_DYNAMIC_CLASS(wxPanel, wxWindow)
#include "wx/msgbxdlg.h"
#include "wx/textdlg.h"
#include "wx/filedlg.h"
#include "wx/dirdlg.h"
#include "wx/choicdlg.h"
#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
#include "wx/generic/msgdlgg.h"
IMPLEMENT_CLASS(wxGenericMessageDialog, wxDialog)
#endif
IMPLEMENT_CLASS(wxTextEntryDialog, wxDialog)
IMPLEMENT_CLASS(wxSingleChoiceDialog, wxDialog)
IMPLEMENT_CLASS(wxFileDialog, wxDialog)
IMPLEMENT_CLASS(wxDirDialog, wxDialog)
#ifdef wx_msw
IMPLEMENT_CLASS(wxMessageDialog)
#endif
#if USE_GAUGE
#ifdef wx_motif
#include "../../contrib/xmgauge/gauge.h"
#endif
#include "wx_gauge.h"
IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
#endif
#include "wx/grid.h"
IMPLEMENT_DYNAMIC_CLASS(wxGenericGrid, wxPanel)
///// Event tables (also must be in one, statically-linked file for shared libraries)
// This is the base, wxEvtHandler 'bootstrap' code which is expanded manually here
@@ -552,160 +141,5 @@ const wxEventTable wxEvtHandler::sm_eventTable =
const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] = { { 0, 0, 0, NULL } };
BEGIN_EVENT_TABLE(wxFrame, wxWindow)
EVT_ACTIVATE(wxFrame::OnActivate)
EVT_SIZE(wxFrame::OnSize)
EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight)
EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
EVT_IDLE(wxFrame::OnIdle)
EVT_CLOSE(wxFrame::OnCloseWindow)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxDialog, wxPanel)
EVT_BUTTON(wxID_OK, wxDialog::OnOK)
EVT_BUTTON(wxID_APPLY, wxDialog::OnApply)
EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
EVT_CHAR_HOOK(wxDialog::OnCharHook)
EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged)
EVT_CLOSE(wxDialog::OnCloseWindow)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
EVT_CHAR(wxWindow::OnChar)
EVT_SIZE(wxWindow::Size)
EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindow::OnInitDialog)
EVT_IDLE(wxWindow::OnIdle)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxScrolledWindow, wxWindow)
EVT_SCROLL(wxScrolledWindow::OnScroll)
EVT_SIZE(wxScrolledWindow::OnSize)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxPanel, wxWindow)
EVT_SYS_COLOUR_CHANGED(wxPanel::OnSysColourChanged)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
EVT_CHAR(wxTextCtrl::OnChar)
EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
END_EVENT_TABLE()
#ifdef wx_msw
BEGIN_EVENT_TABLE(wxMDIParentWindow, wxFrame)
EVT_SIZE(wxMDIParentWindow::OnSize)
EVT_ACTIVATE(wxMDIParentWindow::OnActivate)
EVT_SYS_COLOUR_CHANGED(wxMDIParentWindow::OnSysColourChanged)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
EVT_SCROLL(wxMDIClientWindow::OnScroll)
END_EVENT_TABLE()
#endif
BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
EVT_SCROLL(wxToolBarBase::OnScroll)
EVT_SIZE(wxToolBarBase::OnSize)
EVT_IDLE(wxToolBarBase::OnIdle)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxToolBarSimple, wxToolBarBase)
EVT_SIZE(wxToolBarSimple::OnSize)
EVT_PAINT(wxToolBarSimple::OnPaint)
EVT_KILL_FOCUS(wxToolBarSimple::OnKillFocus)
EVT_MOUSE_EVENTS(wxToolBarSimple::OnMouseEvent)
END_EVENT_TABLE()
#ifdef wx_msw
BEGIN_EVENT_TABLE(wxToolBarMSW, wxToolBarBase)
EVT_SIZE(wxToolBarMSW::OnSize)
EVT_PAINT(wxToolBarMSW::OnPaint)
EVT_MOUSE_EVENTS(wxToolBarMSW::OnMouseEvent)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
EVT_SIZE(wxToolBar95::OnSize)
EVT_PAINT(wxToolBar95::OnPaint)
EVT_KILL_FOCUS(wxToolBar95::OnKillFocus)
EVT_MOUSE_EVENTS(wxToolBar95::OnMouseEvent)
EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged)
END_EVENT_TABLE()
#endif
BEGIN_EVENT_TABLE(wxGenericGrid, wxPanel)
EVT_SIZE(wxGenericGrid::OnSize)
EVT_PAINT(wxGenericGrid::OnPaint)
EVT_MOUSE_EVENTS(wxGenericGrid::OnMouseEvent)
EVT_TEXT(wxGRID_TEXT_CTRL, wxGenericGrid::OnText)
EVT_COMMAND_SCROLL(wxGRID_HSCROLL, wxGenericGrid::OnGridScroll)
EVT_COMMAND_SCROLL(wxGRID_VSCROLL, wxGenericGrid::OnGridScroll)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxControl, wxWindow)
EVT_ERASE_BACKGROUND(wxControl::OnEraseBackground)
END_EVENT_TABLE()
#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
BEGIN_EVENT_TABLE(wxGenericMessageDialog, wxDialog)
EVT_BUTTON(wxID_YES, wxGenericMessageDialog::OnYes)
EVT_BUTTON(wxID_NO, wxGenericMessageDialog::OnNo)
EVT_BUTTON(wxID_CANCEL, wxGenericMessageDialog::OnCancel)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxGenericColourDialog, wxDialog)
EVT_BUTTON(wxID_ADD_CUSTOM, wxGenericColourDialog::OnAddCustom)
EVT_SLIDER(wxID_RED_SLIDER, wxGenericColourDialog::OnRedSlider)
EVT_SLIDER(wxID_GREEN_SLIDER, wxGenericColourDialog::OnGreenSlider)
EVT_SLIDER(wxID_BLUE_SLIDER, wxGenericColourDialog::OnBlueSlider)
EVT_PAINT(wxGenericColourDialog::OnPaint)
EVT_MOUSE_EVENTS(wxGenericColourDialog::OnMouseEvent)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxGenericFontDialog, wxDialog)
EVT_CHECKBOX(wxID_FONT_UNDERLINE, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_STYLE, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_WEIGHT, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_FAMILY, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_COLOUR, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeFont)
EVT_PAINT(wxGenericFontDialog::OnPaint)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxGenericPrintDialog, wxDialog)
EVT_BUTTON(wxID_OK, wxGenericPrintDialog::OnOK)
EVT_BUTTON(wxPRINTID_SETUP, wxGenericPrintDialog::OnSetup)
EVT_RADIOBOX(wxPRINTID_RANGE, wxGenericPrintDialog::OnRange)
END_EVENT_TABLE()
#endif
BEGIN_EVENT_TABLE(wxTextEntryDialog, wxDialog)
EVT_BUTTON(wxID_OK, wxTextEntryDialog::OnOK)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxSingleChoiceDialog, wxDialog)
EVT_BUTTON(wxID_OK, wxSingleChoiceDialog::OnOK)
END_EVENT_TABLE()
#include "wx/prntbase.h"
BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxPreviewControlBar, wxWindow)
EVT_BUTTON(wxID_PREVIEW_CLOSE, wxPreviewControlBar::OnClose)
EVT_BUTTON(wxID_PREVIEW_PRINT, wxPreviewControlBar::OnPrint)
EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPrevious)
EVT_BUTTON(wxID_PREVIEW_NEXT, wxPreviewControlBar::OnNext)
EVT_CHOICE(wxID_PREVIEW_ZOOM, wxPreviewControlBar::OnZoom)
END_EVENT_TABLE()
#endif
const wxSize wxDefaultSize(-1, -1);
const wxPoint wxDefaultPosition(-1, -1);

17
src/qt/dc.cpp
View File

@@ -1,20 +1,24 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dc.cpp
// Purpose:
// Author: Robert Roebling
// Purpose: wxDC class
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "dc.h"
#endif
#include "wx/dc.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
#endif
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
@@ -87,11 +91,6 @@ wxDC::~wxDC(void)
{
};
void wxDC::DrawArc( long WXUNUSED(x1), long WXUNUSED(y1), long WXUNUSED(x2), long WXUNUSED(y2),
double WXUNUSED(xc), double WXUNUSED(yc) )
{
};
void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y), bool WXUNUSED(useMask) )
{
};

25
src/qt/dcclient.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcclient.cpp
// Purpose:
// Author: Robert Roebling
// Purpose: wxClientDC class
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -16,19 +17,6 @@
#include "wx/dcmemory.h"
#include <math.h>
//-----------------------------------------------------------------------------
// local data
//-----------------------------------------------------------------------------
#include "bdiag.xbm"
#include "fdiag.xbm"
#include "cdiag.xbm"
#include "horiz.xbm"
#include "verti.xbm"
#include "cross.xbm"
#define num_hatches 6
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
@@ -39,7 +27,12 @@
// wxPaintDC
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
//IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
//IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC)
#endif
wxPaintDC::wxPaintDC(void)
{

11
src/qt/dcmemory.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcmemory.cpp
// Purpose:
// Author: Robert Roebling
// Purpose: wxMemoryDC class
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,6 +15,10 @@
#include "wx/dcmemory.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
#endif
//-----------------------------------------------------------------------------
// wxMemoryDC
//-----------------------------------------------------------------------------

45
src/qt/dcscreen.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcscreen.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxScreenDC class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,35 +14,19 @@
#endif
#include "wx/dcscreen.h"
#include "wx/window.h"
//-----------------------------------------------------------------------------
// wxScreenDC
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxPaintDC)
#endif
wxScreenDC::wxScreenDC(void)
// Create a DC representing the whole screen
wxScreenDC::wxScreenDC()
{
m_ok = FALSE;
};
// TODO
}
wxScreenDC::~wxScreenDC(void)
wxScreenDC::~wxScreenDC()
{
EndDrawingOnTop();
};
// TODO
}
bool wxScreenDC::StartDrawingOnTop( wxWindow *WXUNUSED(window) )
{
return TRUE;
};
bool wxScreenDC::StartDrawingOnTop( wxRectangle *WXUNUSED(rect) )
{
return TRUE;
};
bool wxScreenDC::EndDrawingOnTop(void)
{
return TRUE;
};

331
src/qt/dialog.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dialog.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxDialog class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,179 +14,281 @@
#endif
#include "wx/dialog.h"
#include "wx/utils.h"
#include "wx/frame.h"
#include "wx/app.h"
#include "wx/settings.h"
//-----------------------------------------------------------------------------
// Lists to keep track of windows, so we can disable/enable them
// for modal dialogs
wxList wxModalDialogs;
wxList wxModelessWindows; // Frames and modeless dialogs
extern wxList wxPendingDelete;
//-----------------------------------------------------------------------------
// wxDialog
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxPanel)
BEGIN_EVENT_TABLE(wxDialog,wxWindow)
EVT_BUTTON (wxID_OK, wxDialog::OnOk)
EVT_BUTTON (wxID_CANCEL, wxDialog::OnCancel)
BEGIN_EVENT_TABLE(wxDialog, wxPanel)
EVT_BUTTON(wxID_OK, wxDialog::OnOK)
EVT_BUTTON(wxID_APPLY, wxDialog::OnApply)
EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
EVT_CHAR_HOOK(wxDialog::OnCharHook)
EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged)
EVT_CLOSE(wxDialog::OnCloseWindow)
END_EVENT_TABLE()
IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxWindow)
#endif
wxDialog::wxDialog(void)
wxDialog::wxDialog()
{
m_title = "";
m_modalShowing = FALSE;
wxTopLevelWindows.Insert( this );
};
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
}
wxDialog::wxDialog( wxWindow *parent,
wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
bool wxDialog::Create(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
m_modalShowing = FALSE;
wxTopLevelWindows.Insert( this );
Create( parent, id, title, pos, size, style, name );
};
m_windowStyle = style;
bool wxDialog::Create( wxWindow *parent,
wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
return TRUE;
};
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
SetName(name);
wxDialog::~wxDialog(void)
if (!parent)
wxTopLevelWindows.Append(this);
if (parent) parent->AddChild(this);
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
// TODO: create dialog
return FALSE;
}
void wxDialog::SetModal(bool flag)
{
if ( flag )
m_windowStyle |= wxDIALOG_MODAL ;
else
if ( m_windowStyle & wxDIALOG_MODAL )
m_windowStyle -= wxDIALOG_MODAL ;
wxModelessWindows.DeleteObject(this);
if (!flag)
wxModelessWindows.Append(this);
}
wxDialog::~wxDialog()
{
// TODO
wxTopLevelWindows.DeleteObject(this);
if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
};
if ( (GetWindowStyleFlag() & wxDIALOG_MODAL) != wxDIALOG_MODAL )
wxModelessWindows.DeleteObject(this);
// If this is the last top-level window, exit.
if (wxTheApp && (wxTopLevelWindows.Number() == 0))
{
wxTheApp->SetTopWindow(NULL);
if (wxTheApp->GetExitOnFrameDelete())
{
// TODO: exit
}
}
}
// By default, pressing escape cancels the dialog
void wxDialog::OnCharHook(wxKeyEvent& event)
{
if (GetHWND())
{
if (event.m_keyCode == WXK_ESCAPE)
{
// Behaviour changed in 2.0: we'll send a Cancel message
// to the dialog instead of Close.
wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
cancelEvent.SetEventObject( this );
GetEventHandler()->ProcessEvent(cancelEvent);
return;
}
}
// We didn't process this event.
event.Skip();
}
void wxDialog::Iconize(bool WXUNUSED(iconize))
{
// TODO
}
bool wxDialog::IsIconized() const
{
// TODO
return FALSE;
}
void wxDialog::SetClientSize(int width, int height)
{
// TODO
}
void wxDialog::GetPosition(int *x, int *y) const
{
// TODO
}
bool wxDialog::Show(bool show)
{
// TODO
return FALSE;
}
void wxDialog::SetTitle(const wxString& title)
{
m_title = title;
};
// TODO
}
wxString wxDialog::GetTitle(void) const
wxString wxDialog::GetTitle() const
{
return (wxString&)m_title;
};
// TODO
return wxString("");
}
void wxDialog::OnApply( wxCommandEvent &WXUNUSED(event) )
void wxDialog::Centre(int direction)
{
if (Validate()) TransferDataFromWindow();
};
void wxDialog::OnCancel( wxCommandEvent &WXUNUSED(event) )
int x_offset,y_offset ;
int display_width, display_height;
int width, height, x, y;
wxFrame *frame ;
if (direction & wxCENTER_FRAME)
{
if (IsModal())
frame = (wxFrame*)GetParent() ;
if (frame)
{
EndModal(wxID_CANCEL);
frame->GetPosition(&x_offset,&y_offset) ;
frame->GetSize(&display_width,&display_height) ;
}
}
else
{
SetReturnCode(wxID_CANCEL);
this->Show(FALSE);
};
};
frame = NULL ;
void wxDialog::OnOk( wxCommandEvent &WXUNUSED(event) )
if (frame==NULL)
{
wxDisplaySize(&display_width, &display_height);
x_offset = 0 ;
y_offset = 0 ;
}
GetSize(&width, &height);
GetPosition(&x, &y);
if (direction & wxHORIZONTAL)
x = (int)((display_width - width)/2);
if (direction & wxVERTICAL)
y = (int)((display_height - height)/2);
SetSize(x+x_offset, y+y_offset, width, height);
}
// Replacement for Show(TRUE) for modal dialogs - returns return code
int wxDialog::ShowModal()
{
m_windowStyle |= wxDIALOG_MODAL;
// TODO: modal showing
Show(TRUE);
return GetReturnCode();
}
void wxDialog::EndModal(int retCode)
{
SetReturnCode(retCode);
// TODO modal un-showing
Show(FALSE);
}
// Standard buttons
void wxDialog::OnOK(wxCommandEvent& event)
{
if ( Validate() && TransferDataFromWindow() )
{
if ( IsModal() )
{
EndModal(wxID_OK);
}
else
{
SetReturnCode(wxID_OK);
this->Show(FALSE);
};
};
};
}
}
}
void wxDialog::OnPaint( wxPaintEvent& WXUNUSED(event) )
void wxDialog::OnApply(wxCommandEvent& event)
{
// yes
};
if (Validate())
TransferDataFromWindow();
// TODO probably need to disable the Apply button until things change again
}
bool wxDialog::OnClose(void)
void wxDialog::OnCancel(wxCommandEvent& event)
{
if ( IsModal() )
EndModal(wxID_CANCEL);
else
{
SetReturnCode(wxID_CANCEL);
this->Show(FALSE);
}
}
bool wxDialog::OnClose()
{
// Behaviour changed in 2.0: we'll send a Cancel message by default,
// which may close the dialog.
// Check for looping if the Cancel event handler calls Close()
static wxList closing;
if (closing.Member(this)) return FALSE; // no loops
if ( closing.Member(this) )
return FALSE;
closing.Append(this);
wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
cancelEvent.SetEventObject( this );
GetEventHandler()->ProcessEvent(cancelEvent);
closing.DeleteObject(this);
return FALSE;
}
bool wxDialog::Destroy(void)
{
if (!wxPendingDelete.Member(this))
wxPendingDelete.Append(this);
return TRUE;
}
void wxDialog::OnCloseWindow(wxCloseEvent& event)
{
// Compatibility
if ( GetEventHandler()->OnClose() || event.GetForce())
{
this->Destroy();
};
};
}
}
bool wxDialog::Show( bool show )
// Destroy the window (delayed, if a managed window)
bool wxDialog::Destroy()
{
if (!show && IsModal() && m_modalShowing)
{
EndModal( wxID_CANCEL );
};
wxWindow::Show( show );
if (show) InitDialog();
if (!wxPendingDelete.Member(this))
wxPendingDelete.Append(this);
return TRUE;
};
}
int wxDialog::ShowModal(void)
void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& event)
{
if (m_modalShowing) return GetReturnCode();
Show( TRUE );
m_modalShowing = TRUE;
// grab here
// main here
// release here
return GetReturnCode();
};
void wxDialog::EndModal( int retCode )
{
SetReturnCode( retCode );
if (!m_modalShowing) return;
m_modalShowing = FALSE;
// quit main
};
void wxDialog::InitDialog(void)
{
wxWindow::InitDialog();
};
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
Refresh();
}

40
src/qt/dnd.cpp
View File

@@ -1,9 +1,12 @@
///////////////////////////////////////////////////////////////////////////////
// Name: dnd.cpp
// Purpose: wxDropTarget class
// Author: Robert Roebling
// Copyright: Robert Roebling
// Licence: wxWindows license
// Purpose: wxDropTarget, wxDropSource, wxDataObject implementation
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) 1998 AUTHOR
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
@@ -19,8 +22,6 @@
// global
// ----------------------------------------------------------------------------
extern bool g_blockEventsOnDrag;
// ----------------------------------------------------------------------------
// wxDropTarget
// ----------------------------------------------------------------------------
@@ -92,16 +93,27 @@ wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
// wxDropSource
//-------------------------------------------------------------------------
wxDropSource::wxDropSource( wxWindow *WXUNUSED(win) )
//-----------------------------------------------------------------------------
// drag request
wxDropSource::wxDropSource( wxWindow *win )
{
g_blockEventsOnDrag = TRUE;
// TODO
m_window = win;
m_data = NULL;
m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
wxDropSource::wxDropSource( wxDataObject &data, wxWindow *WXUNUSED(win) )
wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
{
g_blockEventsOnDrag = TRUE;
// TODO
m_window = win;
m_data = &data;
m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
void wxDropSource::SetData( wxDataObject &data )
@@ -111,13 +123,11 @@ void wxDropSource::SetData( wxDataObject &data )
wxDropSource::~wxDropSource(void)
{
// if (m_data) delete m_data;
g_blockEventsOnDrag = FALSE;
};
wxDropSource::DragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
{
return Copy;
// TODO
return Error;
};

147
src/qt/filedlg.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: filedlg.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxFileDialog
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -12,52 +13,23 @@
#pragma implementation "filedlg.h"
#endif
#include "wx/filedlg.h"
#include "wx/defs.h"
#include "wx/utils.h"
#include "wx/intl.h"
#include "wx/generic/msgdlgg.h"
//-----------------------------------------------------------------------------
// wxFileDialog
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxFileDialog,wxDialog)
wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
const wxString& defaultDir, const wxString& defaultFileName,
const wxString& wildCard,
long style, const wxPoint& pos )
{
m_message = message;
m_path = "";
m_fileName = defaultFileName;
m_dir = defaultDir;
m_wildCard = wildCard;
m_dialogStyle = style;
m_filterIndex = 1;
m_path.Append(m_dir);
if(! m_path.IsEmpty() && m_path.Last()!='/') m_path.Append('/');
m_path.Append(m_fileName);
};
int wxFileDialog::ShowModal(void)
{
int ret = wxDialog::ShowModal();
if (ret == wxID_OK)
{
};
return ret;
};
#include "wx/dialog.h"
#include "wx/filedlg.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_CLASS(wxFileDialog, wxDialog)
#endif
char *wxFileSelector(const char *title,
const char *defaultDir, const char *defaultFileName,
const char *defaultExtension, const char *filter, int flags,
wxWindow *parent, int x, int y)
{
// If there's a default extension specified but no filter, we create a suitable
// filter.
wxString filter2("");
if ( defaultExtension && !filter )
filter2 = wxString("*.") + wxString(defaultExtension) ;
@@ -76,8 +48,7 @@ char *wxFileSelector(const char *title,
else
defaultFilenameString = "";
wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString,
filter2, flags, wxPoint(x, y));
wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString, filter2, flags, wxPoint(x, y));
if ( fileDialog.ShowModal() == wxID_OK )
{
@@ -86,40 +57,86 @@ char *wxFileSelector(const char *title,
}
else
return NULL;
};
}
char* wxLoadFileSelector(const char *what, const char *extension, const char *default_name,
wxWindow *parent )
char *wxFileSelectorEx(const char *title,
const char *defaultDir,
const char *defaultFileName,
int* defaultFilterIndex,
const char *filter,
int flags,
wxWindow* parent,
int x,
int y)
{
wxFileDialog fileDialog(parent, title ? title : "", defaultDir ? defaultDir : "",
defaultFileName ? defaultFileName : "", filter ? filter : "", flags, wxPoint(x, y));
if ( fileDialog.ShowModal() == wxID_OK )
{
*defaultFilterIndex = fileDialog.GetFilterIndex();
strcpy(wxBuffer, (const char *)fileDialog.GetPath());
return wxBuffer;
}
else
return NULL;
}
wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
long style, const wxPoint& pos)
{
m_message = message;
m_dialogStyle = style;
m_parent = parent;
m_path = "";
m_fileName = defaultFileName;
m_dir = defaultDir;
m_wildCard = wildCard;
m_filterIndex = 1;
}
int wxFileDialog::ShowModal()
{
// TODO
wxID_CANCEL;
}
// Generic file load/save dialog
static char *
wxDefaultFileSelector(bool load, const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
char *ext = (char *)extension;
char prompt[50];
wxString str = _("Load %s file");
sprintf(prompt, str, what);
wxString str;
if (load)
str = "Load %s file";
else
str = "Save %s file";
sprintf(prompt, wxGetTranslation(str), what);
if (*ext == '.') ext++;
char wild[60];
sprintf(wild, "*.%s", ext);
return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
};
}
char* wxSaveFileSelector(const char *what, const char *extension, const char *default_name,
wxWindow *parent )
// Generic file load dialog
char *
wxLoadFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
char *ext = (char *)extension;
char prompt[50];
wxString str = _("Save %s file");
sprintf(prompt, str, what);
if (*ext == '.') ext++;
char wild[60];
sprintf(wild, "*.%s", ext);
return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
};
return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
}
// Generic file save dialog
char *
wxSaveFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
}

358
src/qt/font.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: font.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxFont class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,201 +14,228 @@
#endif
#include "wx/font.h"
#include "wx/utils.h"
#include <strings.h>
//-----------------------------------------------------------------------------
// local data
//-----------------------------------------------------------------------------
static char *wx_font_family [] = {
"wxDEFAULT", "wxDECORATIVE", "wxMODERN", "wxROMAN", "wxSCRIPT",
"wxSWISS", "wxTELETYPE",
};
static char *wx_font_style [] = {
"wxDEFAULT", "wxNORMAL", "wxSLANT", "wxITALIC",
};
static char *wx_font_weight [] = {
"wxDEFAULT", "wxNORMAL", "wxBOLD", "wxLIGHT",
};
extern wxFontNameDirectory wxTheFontNameDirectory;
//-----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
class wxFontRefData: public wxObjectRefData
{
public:
wxFontRefData(void);
~wxFontRefData(void);
wxList m_scaled_xfonts;
int m_pointSize;
int m_family, m_style, m_weight;
bool m_underlined;
int m_fontId;
char* m_faceName;
};
wxFontRefData::wxFontRefData(void) : m_scaled_xfonts(wxKEY_INTEGER)
{
m_pointSize = -1;
m_family = -1;
m_style = -1;
m_weight = -1;
m_underlined = FALSE;
m_fontId = 0;
m_faceName = NULL;
};
wxFontRefData::~wxFontRefData(void)
{
wxNode *node = m_scaled_xfonts.First();
while (node)
{
wxNode *next = node->Next();
node = next;
};
if (m_faceName)
{
delete m_faceName;
m_faceName = NULL;
};
};
//-----------------------------------------------------------------------------
#define M_FONTDATA ((wxFontRefData *)m_refData)
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
#endif
wxFont::wxFont(void)
wxFontRefData::wxFontRefData()
{
if (wxTheFontList) wxTheFontList->Append( this );
};
m_style = 0;
m_pointSize = 0;
m_family = 0;
m_style = 0;
m_weight = 0;
m_underlined = 0;
m_faceName = "";
/* TODO
m_hFont = 0;
*/
}
wxFont::wxFont( char *xFontName )
wxFontRefData::wxFontRefData(const wxFontRefData& data)
{
if (!xFontName) return;
m_style = data.m_style;
m_pointSize = data.m_pointSize;
m_family = data.m_family;
m_style = data.m_style;
m_weight = data.m_weight;
m_underlined = data.m_underlined;
m_faceName = data.m_faceName;
/* TODO
m_hFont = 0;
*/
}
m_refData = new wxFontRefData();
};
wxFont::wxFont(int PointSize, int FontIdOrFamily, int Style, int Weight,
bool Underlined, const char* Face)
wxFontRefData::~wxFontRefData()
{
m_refData = new wxFontRefData();
// TODO: delete font data
}
if (wxTheFontList) wxTheFontList->Append( this );
};
wxFont::wxFont(int PointSize, const char *Face, int Family, int Style,
int Weight, bool Underlined)
wxFont::wxFont()
{
m_refData = new wxFontRefData();
if ( wxTheFontList )
wxTheFontList->Append(this);
}
if (wxTheFontList) wxTheFontList->Append( this );
};
wxFont::wxFont( const wxFont& font )
wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
{
Ref( font );
};
Create(pointSize, family, style, weight, underlined, faceName);
wxFont::wxFont( const wxFont* font )
if ( wxTheFontList )
wxTheFontList->Append(this);
}
bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
{
UnRef();
if (font) Ref( *font );
};
m_refData = new wxFontRefData;
wxFont::~wxFont(void)
{
if (wxTheFontList) wxTheFontList->DeleteObject( this );
};
M_FONTDATA->m_family = family;
M_FONTDATA->m_style = style;
M_FONTDATA->m_weight = weight;
M_FONTDATA->m_pointSize = pointSize;
M_FONTDATA->m_underlined = underlined;
M_FONTDATA->m_faceName = faceName;
wxFont& wxFont::operator = ( const wxFont& font )
{
if (*this == font) return (*this);
Ref( font );
return *this;
};
RealizeResource();
bool wxFont::operator == ( const wxFont& font )
{
return m_refData == font.m_refData;
};
return TRUE;
}
bool wxFont::operator != ( const wxFont& font )
wxFont::~wxFont()
{
return m_refData != font.m_refData;
};
if (wxTheFontList)
wxTheFontList->DeleteObject(this);
}
bool wxFont::Ok()
bool wxFont::RealizeResource()
{
return (m_refData != NULL);
};
// TODO: create the font (if there is a native font object)
return FALSE;
}
int wxFont::GetPointSize(void) const
void wxFont::Unshare()
{
return M_FONTDATA->m_pointSize;
};
// Don't change shared data
if (!m_refData)
{
m_refData = new wxFontRefData();
}
else
{
wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
UnRef();
m_refData = ref;
}
}
wxString wxFont::GetFaceString(void) const
void wxFont::SetPointSize(int pointSize)
{
return "";
};
Unshare();
wxString wxFont::GetFaceName(void) const
{
return "";
};
M_FONTDATA->m_pointSize = pointSize;
int wxFont::GetFamily(void) const
{
return M_FONTDATA->m_family;
};
RealizeResource();
}
wxString wxFont::GetFamilyString(void) const
void wxFont::SetFamily(int family)
{
wxString s = wx_font_family[M_FONTDATA->m_family];
return s;
};
Unshare();
int wxFont::GetFontId(void) const
{
return M_FONTDATA->m_fontId; // stub
};
M_FONTDATA->m_family = family;
int wxFont::GetStyle(void) const
{
return M_FONTDATA->m_style;
};
RealizeResource();
}
wxString wxFont::GetStyleString(void) const
void wxFont::SetStyle(int style)
{
wxString s = wx_font_style[M_FONTDATA->m_style];
return s;
};
Unshare();
int wxFont::GetWeight(void) const
{
return M_FONTDATA->m_weight;
};
M_FONTDATA->m_style = style;
wxString wxFont::GetWeightString(void) const
{
wxString s = wx_font_weight[M_FONTDATA->m_weight];
return s;
};
RealizeResource();
}
bool wxFont::GetUnderlined(void) const
void wxFont::SetWeight(int weight)
{
return M_FONTDATA->m_underlined;
};
Unshare();
M_FONTDATA->m_weight = weight;
RealizeResource();
}
void wxFont::SetFaceName(const wxString& faceName)
{
Unshare();
M_FONTDATA->m_faceName = faceName;
RealizeResource();
}
void wxFont::SetUnderlined(bool underlined)
{
Unshare();
M_FONTDATA->m_underlined = underlined;
RealizeResource();
}
wxString wxFont::GetFamilyString() const
{
wxString fam("");
switch (GetFamily())
{
case wxDECORATIVE:
fam = "wxDECORATIVE";
break;
case wxROMAN:
fam = "wxROMAN";
break;
case wxSCRIPT:
fam = "wxSCRIPT";
break;
case wxSWISS:
fam = "wxSWISS";
break;
case wxMODERN:
fam = "wxMODERN";
break;
case wxTELETYPE:
fam = "wxTELETYPE";
break;
default:
fam = "wxDEFAULT";
break;
}
return fam;
}
/* New font system */
wxString wxFont::GetFaceName() const
{
wxString str("");
if (M_FONTDATA)
str = M_FONTDATA->m_faceName ;
return str;
}
wxString wxFont::GetStyleString() const
{
wxString styl("");
switch (GetStyle())
{
case wxITALIC:
styl = "wxITALIC";
break;
case wxSLANT:
styl = "wxSLANT";
break;
default:
styl = "wxNORMAL";
break;
}
return styl;
}
wxString wxFont::GetWeightString() const
{
wxString w("");
switch (GetWeight())
{
case wxBOLD:
w = "wxBOLD";
break;
case wxLIGHT:
w = "wxLIGHT";
break;
default:
w = "wxNORMAL";
break;
}
return w;
}

686
src/qt/frame.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: frame.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxFrame
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,240 +14,533 @@
#endif
#include "wx/frame.h"
#include "wx/dialog.h"
#include "wx/control.h"
#include "wx/app.h"
#include "wx/menu.h"
#include "wx/toolbar.h"
#include "wx/statusbr.h"
#include "wx/mdi.h"
#include "wx/toolbar.h"
#include "wx/menuitem.h"
const wxMENU_HEIGHT = 28;
const wxSTATUS_HEIGHT = 25;
extern wxList wxTopLevelWindows;
extern wxList wxModelessWindows;
extern wxList wxPendingDelete;
//-----------------------------------------------------------------------------
// wxFrame
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
BEGIN_EVENT_TABLE(wxFrame, wxWindow)
EVT_SIZE(wxFrame::OnSize)
EVT_CLOSE(wxFrame::OnCloseWindow)
EVT_ACTIVATE(wxFrame::OnActivate)
EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight)
EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
EVT_IDLE(wxFrame::OnIdle)
EVT_CLOSE(wxFrame::OnCloseWindow)
END_EVENT_TABLE()
IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
#endif
#if USE_NATIVE_STATUSBAR
bool wxFrame::m_useNativeStatusBar = TRUE;
#else
bool wxFrame::m_useNativeStatusBar = FALSE;
#endif
wxFrame::wxFrame()
{
wxTopLevelWindows.Insert( this );
};
m_frameToolBar = NULL ;
m_frameMenuBar = NULL;
m_frameStatusBar = NULL;
wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
m_windowParent = NULL;
m_iconized = FALSE;
}
bool wxFrame::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
Create( parent, id, title, pos, size, style, name );
wxTopLevelWindows.Insert( this );
};
if (!parent)
wxTopLevelWindows.Append(this);
bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
m_title = title;
SetName(name);
m_windowStyle = style;
m_frameMenuBar = NULL;
m_frameToolBar = NULL ;
m_frameStatusBar = NULL;
return TRUE;
};
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
if ( id > -1 )
m_windowId = id;
else
m_windowId = (int)NewControlId();
if (parent) parent->AddChild(this);
wxModelessWindows.Append(this);
// TODO: create frame.
return FALSE;
}
wxFrame::~wxFrame()
{
if (m_frameMenuBar) delete m_frameMenuBar;
if (m_frameStatusBar) delete m_frameStatusBar;
wxTopLevelWindows.DeleteObject(this);
if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
};
if (m_frameStatusBar)
delete m_frameStatusBar;
if (m_frameMenuBar)
delete m_frameMenuBar;
/* Check if it's the last top-level window */
if (wxTheApp && (wxTopLevelWindows.Number() == 0))
{
wxTheApp->SetTopWindow(NULL);
if (wxTheApp->GetExitOnFrameDelete())
{
// TODO signal to the app that we're going to close
}
}
wxModelessWindows.DeleteObject(this);
}
// Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
void wxFrame::GetClientSize(int *x, int *y) const
{
// TODO
}
// Set the client size (i.e. leave the calculation of borders etc.
// to wxWindows)
void wxFrame::SetClientSize(int width, int height)
{
// TODO
}
void wxFrame::GetSize(int *width, int *height) const
{
// TODO
}
void wxFrame::GetPosition(int *x, int *y) const
{
// TODO
}
void wxFrame::SetSize(int x, int y, int width, int height, int sizeFlags)
{
// TODO
}
bool wxFrame::Show(bool show)
{
if (show)
{
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
ProcessEvent( event );
};
return wxWindow::Show( show );
};
void wxFrame::Enable( bool enable )
{
wxWindow::Enable( enable );
};
void wxFrame::OnCloseWindow( wxCloseEvent &event )
{
if ( GetEventHandler()->OnClose() || event.GetForce())
{
this->Destroy();
}
};
bool wxFrame::Destroy()
{
if (!wxPendingDelete.Member(this))
wxPendingDelete.Append(this);
return TRUE;
// TODO
return FALSE;
}
void wxFrame::GetClientSize( int *width, int *height ) const
void wxFrame::Iconize(bool iconize)
{
wxWindow::GetClientSize( width, height );
if (height)
{
if (m_frameMenuBar) (*height) -= wxMENU_HEIGHT;
if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
if (m_frameToolBar)
{
int y = 0;
m_frameToolBar->GetSize( NULL, &y );
(*height) -= y;
// TODO
}
};
};
void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
// Equivalent to maximize/restore in Windows
void wxFrame::Maximize(bool maximize)
{
if ( GetAutoLayout() )
Layout();
else {
// no child: go out !
if (!GetChildren()->First())
return;
// do we have exactly one child?
wxWindow *child = NULL;
for(wxNode *node = GetChildren()->First(); node; node = node->Next())
{
wxWindow *win = (wxWindow *)node->Data();
if (!IS_KIND_OF(win,wxFrame) && !IS_KIND_OF(win,wxDialog)
#if 0 // not in m_children anyway
&& (win != m_frameMenuBar) &&
(win != m_frameToolBar) &&
(win != m_frameStatusBar)
#endif
)
{
if ( child ) // it's the second one: do nothing
return;
child = win;
};
};
// yes: set it's size to fill all the frame
int client_x, client_y;
GetClientSize(&client_x, &client_y);
child->SetSize( 1, 1, client_x-2, client_y);
// TODO
}
};
static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
bool wxFrame::IsIconized() const
{
menu->SetInvokingWindow( win );
wxNode *node = menu->m_items.First();
while (node)
{
wxMenuItem *menuitem = (wxMenuItem*)node->Data();
if (menuitem->IsSubMenu())
SetInvokingWindow( menuitem->GetSubMenu(), win );
node = node->Next();
};
};
void wxFrame::SetMenuBar( wxMenuBar *menuBar )
{
m_frameMenuBar = menuBar;
if (m_frameMenuBar)
{
if (m_frameMenuBar->m_parent != this)
{
wxNode *node = m_frameMenuBar->m_menus.First();
while (node)
{
wxMenu *menu = (wxMenu*)node->Data();
SetInvokingWindow( menu, this );
node = node->Next();
};
// TODO
return FALSE;
}
}
};
wxMenuBar *wxFrame::GetMenuBar(void)
{
return m_frameMenuBar;
};
wxToolBar *wxFrame::CreateToolBar( long style , wxWindowID id, const wxString& name )
{
m_frameToolBar = new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );
return m_frameToolBar;
};
wxToolBar *wxFrame::GetToolBar(void)
{
return m_frameToolBar;
};
wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
{
if (m_frameStatusBar)
delete m_frameStatusBar;
m_frameStatusBar = new wxStatusBar( this, id, wxPoint(0,0), wxSize(100,20), style, name );
m_frameStatusBar->SetFieldsCount( number );
return m_frameStatusBar;
};
void wxFrame::SetStatusText( const wxString &text, int number )
{
if (m_frameStatusBar) m_frameStatusBar->SetStatusText( text, number );
};
void wxFrame::SetStatusWidths( int n, int *width )
{
if (m_frameStatusBar) m_frameStatusBar->SetStatusWidths( n, width );
};
wxStatusBar *wxFrame::GetStatusBar(void)
{
return m_frameStatusBar;
};
void wxFrame::SetTitle(const wxString& title)
{
m_title = title;
};
// TODO
}
void wxFrame::SetSizeHints( int WXUNUSED(minW), int WXUNUSED(minH),
int WXUNUSED(maxW), int WXUNUSED(maxH), int WXUNUSED(incW) )
wxString wxFrame::GetTitle() const
{
// TODO
return wxString("");
}
void wxFrame::SetIcon(const wxIcon& icon)
{
m_icon = icon;
if (!icon.Ok()) return;
// TODO
}
void wxFrame::SetAcceleratorTable(const wxAcceleratorTable& accel)
{
m_acceleratorTable = accel;
}
wxStatusBar *wxFrame::OnCreateStatusBar(int number, long style, wxWindowID id,
const wxString& name)
{
wxStatusBar *statusBar = NULL;
statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20),
style, name);
// Set the height according to the font and the border size
wxClientDC dc(statusBar);
dc.SetFont(* statusBar->GetFont());
long x, y;
dc.GetTextExtent("X", &x, &y);
int height = (int)( (y * 1.1) + 2* statusBar->GetBorderY());
statusBar->SetSize(-1, -1, 100, height);
statusBar->SetFieldsCount(number);
return statusBar;
}
wxStatusBar* wxFrame::CreateStatusBar(int number, long style, wxWindowID id,
const wxString& name)
{
// Calling CreateStatusBar twice is an error.
wxCHECK_MSG( m_frameStatusBar == NULL, FALSE,
"recreating status bar in wxFrame" );
m_frameStatusBar = OnCreateStatusBar(number, style, id,
name);
if ( m_frameStatusBar )
{
PositionStatusBar();
return m_frameStatusBar;
}
else
return NULL;
}
void wxFrame::SetStatusText(const wxString& text, int number)
{
wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set text for" );
m_frameStatusBar->SetStatusText(text, number);
}
void wxFrame::SetStatusWidths(int n, const int widths_field[])
{
wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set widths for" );
m_frameStatusBar->SetStatusWidths(n, widths_field);
PositionStatusBar();
}
void wxFrame::PositionStatusBar()
{
int w, h;
GetClientSize(&w, &h);
int sw, sh;
m_frameStatusBar->GetSize(&sw, &sh);
// Since we wish the status bar to be directly under the client area,
// we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
m_frameStatusBar->SetSize(0, h, w, sh);
}
void wxFrame::SetMenuBar(wxMenuBar *menuBar)
{
if (!menuBar)
{
m_frameMenuBar = NULL;
return;
}
m_frameMenuBar = menuBar;
// TODO
}
void wxFrame::Fit()
{
// Work out max. size
wxNode *node = GetChildren()->First();
int max_width = 0;
int max_height = 0;
while (node)
{
// Find a child that's a subwindow, but not a dialog box.
wxWindow *win = (wxWindow *)node->Data();
if (!win->IsKindOf(CLASSINFO(wxFrame)) &&
!win->IsKindOf(CLASSINFO(wxDialog)))
{
int width, height;
int x, y;
win->GetSize(&width, &height);
win->GetPosition(&x, &y);
if ((x + width) > max_width)
max_width = x + width;
if ((y + height) > max_height)
max_height = y + height;
}
node = node->Next();
}
SetClientSize(max_width, max_height);
}
// Responds to colour changes, and passes event on to children.
void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
{
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
Refresh();
if ( m_frameStatusBar )
{
wxSysColourChangedEvent event2;
event2.SetEventObject( m_frameStatusBar );
m_frameStatusBar->ProcessEvent(event2);
}
// Propagate the event to the non-top-level children
wxWindow::OnSysColourChanged(event);
}
// Default resizing behaviour - if only ONE subwindow,
// resize to client rectangle size
void wxFrame::OnSize(wxSizeEvent& event)
{
// if we're using constraints - do use them
#if USE_CONSTRAINTS
if ( GetAutoLayout() ) {
Layout();
return;
}
#endif
// do we have _exactly_ one child?
wxWindow *child = NULL;
for ( wxNode *node = GetChildren()->First(); node; node = node->Next() )
{
wxWindow *win = (wxWindow *)node->Data();
if ( !win->IsKindOf(CLASSINFO(wxFrame)) &&
!win->IsKindOf(CLASSINFO(wxDialog)) &&
(win != GetStatusBar()) &&
(win != GetToolBar()) )
{
if ( child )
return; // it's our second subwindow - nothing to do
child = win;
}
}
if ( child ) {
// we have exactly one child - set it's size to fill the whole frame
int clientW, clientH;
GetClientSize(&clientW, &clientH);
int x = 0;
int y = 0;
child->SetSize(x, y, clientW, clientH);
}
}
// Default activation behaviour - set the focus for the first child
// subwindow found.
void wxFrame::OnActivate(wxActivateEvent& event)
{
for(wxNode *node = GetChildren()->First(); node; node = node->Next())
{
// Find a child that's a subwindow, but not a dialog box.
wxWindow *child = (wxWindow *)node->Data();
if (!child->IsKindOf(CLASSINFO(wxFrame)) &&
!child->IsKindOf(CLASSINFO(wxDialog)))
{
#if WXDEBUG > 1
wxDebugMsg("wxFrame::OnActivate: about to set the child's focus.\n");
#endif
child->SetFocus();
return;
}
}
}
// The default implementation for the close window event - calls
// OnClose for backward compatibility.
void wxFrame::OnCloseWindow(wxCloseEvent& event)
{
// Compatibility
if ( GetEventHandler()->OnClose() || event.GetForce())
{
this->Destroy();
}
}
bool wxFrame::OnClose()
{
return TRUE;
}
// Destroy the window (delayed, if a managed window)
bool wxFrame::Destroy()
{
if (!wxPendingDelete.Member(this))
wxPendingDelete.Append(this);
return TRUE;
}
// Default menu selection behaviour - display a help string
void wxFrame::OnMenuHighlight(wxMenuEvent& event)
{
if (GetStatusBar())
{
if (event.GetMenuId() == -1)
SetStatusText("");
else
{
wxMenuBar *menuBar = GetMenuBar();
if (menuBar)
{
wxString helpString(menuBar->GetHelpString(event.GetMenuId()));
if (helpString != "")
SetStatusText(helpString);
}
}
}
}
wxMenuBar *wxFrame::GetMenuBar() const
{
return m_frameMenuBar;
}
void wxFrame::Centre(int direction)
{
int display_width, display_height, width, height, x, y;
wxDisplaySize(&display_width, &display_height);
GetSize(&width, &height);
GetPosition(&x, &y);
if (direction & wxHORIZONTAL)
x = (int)((display_width - width)/2);
if (direction & wxVERTICAL)
y = (int)((display_height - height)/2);
SetSize(x, y, width, height);
}
// Call this to simulate a menu command
void wxFrame::Command(int id)
{
ProcessCommand(id);
}
void wxFrame::ProcessCommand(int id)
{
wxCommandEvent commandEvent(wxEVENT_TYPE_MENU_COMMAND, id);
commandEvent.SetInt( id );
commandEvent.SetEventObject( this );
wxMenuBar *bar = GetMenuBar() ;
if (!bar)
return;
/* TODO: check the menu item if required
wxMenuItem *item = bar->FindItemForId(id) ;
if (item && item->IsCheckable())
{
bar->Check(id,!bar->Checked(id)) ;
}
*/
GetEventHandler()->ProcessEvent(commandEvent);
}
// Checks if there is a toolbar, and returns the first free client position
wxPoint wxFrame::GetClientAreaOrigin() const
{
wxPoint pt(0, 0);
if (GetToolBar())
{
int w, h;
GetToolBar()->GetSize(& w, & h);
if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
{
pt.x += w;
}
else
{
pt.y += h;
}
}
return pt;
}
wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
{
wxCHECK_MSG( m_frameToolBar == NULL, FALSE,
"recreating toolbar in wxFrame" );
wxToolBar* toolBar = OnCreateToolBar(style, id, name);
if (toolBar)
{
SetToolBar(toolBar);
PositionToolBar();
return toolBar;
}
else
{
return NULL;
}
}
wxToolBar* wxFrame::OnCreateToolBar(long style, wxWindowID id, const wxString& name)
{
return new wxToolBar(this, id, wxDefaultPosition, wxDefaultSize, style, name);
}
void wxFrame::PositionToolBar()
{
int cw, ch;
// TODO: we actually need to use the low-level client size, before
// the toolbar/status bar were added.
// So DEFINITELY replace the line below with something appropriate.
wxCHECK_MSG( TRUE, FALSE,
"PositionToolBar not implemented properly, see frame.cpp" );
GetClientSize(& cw, &ch);
if ( GetStatusBar() )
{
int statusX, statusY;
GetStatusBar()->GetClientSize(&statusX, &statusY);
ch -= statusY;
}
if (GetToolBar())
{
int tw, th;
GetToolBar()->GetSize(& tw, & th);
if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
{
// Use the 'real' position. wxSIZE_NO_ADJUSTMENTS
// means, pretend we don't have toolbar/status bar, so we
// have the original client size.
GetToolBar()->SetSize(0, 0, tw, ch, wxSIZE_NO_ADJUSTMENTS);
}
else
{
// Use the 'real' position
GetToolBar()->SetSize(0, 0, cw, th, wxSIZE_NO_ADJUSTMENTS);
}
}
}

98
src/qt/gauge.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: gauge.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxGauge class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,38 +15,91 @@
#include "wx/gauge.h"
//-----------------------------------------------------------------------------
// wxGauge
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
#endif
bool wxGauge::Create( wxWindow *parent, wxWindowID id, int range,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
bool wxGauge::Create(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
SetName(name);
SetValidator(validator);
m_rangeMax = range;
m_windowStyle = style;
if (parent) parent->AddChild(this);
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
// TODO
return FALSE;
}
void wxGauge::SetSize(int x, int y, int width, int height, int sizeFlags)
{
// TODO
}
void wxGauge::SetShadowWidth(int w)
{
// TODO optional
}
void wxGauge::SetBezelFace(int w)
{
// TODO optional
}
void wxGauge::SetRange(int r)
{
m_rangeMax = r;
if (m_gaugePos > m_rangeMax) m_gaugePos = m_rangeMax;
};
// TODO
}
void wxGauge::SetValue(int pos)
{
m_gaugePos = pos;
if (m_gaugePos > m_rangeMax) m_gaugePos = m_rangeMax;
};
// TODO
}
int wxGauge::GetRange(void) const
int wxGauge::GetShadowWidth() const
{
// TODO optional
return 0;
}
int wxGauge::GetBezelFace() const
{
// TODO optional
return 0;
}
int wxGauge::GetRange() const
{
return m_rangeMax;
};
}
int wxGauge::GetValue(void) const
int wxGauge::GetValue() const
{
return m_gaugePos;
};
}
void wxGauge::SetForegroundColour(const wxColour& col)
{
m_foregroundColour = col ;
}
void wxGauge::SetBackgroundColour(const wxColour& col)
{
m_backgroundColour = col ;
}

7
src/qt/gdiobj.cpp
View File

@@ -1,11 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: gdiobj.cpp
// Purpose: wxGDIObject class
// Author: Julian Smart
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -19,3 +19,4 @@
IMPLEMENT_DYNAMIC_CLASS(wxGDIObject, wxObject)
#endif
// TODO: Nothing to do, unless you want to.

67
src/qt/icon.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: icon.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxIcon class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,14 +15,56 @@
#include "wx/icon.h"
//-----------------------------------------------------------------------------
// wxIcon
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
#endif
wxIcon::wxIcon( char **bits, int WXUNUSED(width), int WXUNUSED(height) ) :
wxBitmap( bits )
/*
* Icons
*/
wxIconRefData::wxIconRefData()
{
};
// TODO: init icon handle
}
wxIconRefData::~wxIconRefData()
{
// TODO: destroy icon handle
}
wxIcon::wxIcon()
{
}
wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height))
{
}
wxIcon::wxIcon(const wxString& icon_file, long flags,
int desiredWidth, int desiredHeight)
{
LoadFile(icon_file, flags, desiredWidth, desiredHeight);
}
wxIcon::~wxIcon()
{
}
bool wxIcon::LoadFile(const wxString& filename, long type,
int desiredWidth, int desiredHeight)
{
UnRef();
m_refData = new wxIconRefData;
wxBitmapHandler *handler = FindHandler(type);
if ( handler )
return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
else
return FALSE;
}

359
src/qt/joystick.cpp
View File

@@ -1,358 +1,279 @@
/////////////////////////////////////////////////////////////////////////////
// Name: joystick.cpp
// Purpose: wxJoystick class
// Author: Ported to Linux by Guilhem Lavaux
// Author: AUTHOR
// Modified by:
// Created: 05/23/98
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) Guilhem Lavaux
// Licence: wxWindows license
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "joystick.h"
#endif
#include <linux/joystick.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include "wx/event.h"
#include "wx/window.h"
#include "wx/gtk/joystick.h"
#define JOYSTICK_AXE_MAX 32767
#define JOYSTICK_AXE_MIN -32767
#include <wx/joystick.h>
IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)
wxJoystick::wxJoystick(int joystick)
{
wxString dev_name;
// Assume it's the same device name on all Linux systems ...
dev_name.Printf("/dev/js%d", (joystick == wxJOYSTICK1) ? 0 : 1);
m_joystick = open(dev_name, O_RDWR);
m_lastposition = wxPoint(-1, -1);
for (int i=0;i<15;i++)
m_axe[i] = 0;
if (m_joystick != -1)
Create();
}
////////////////////////////////////////////////////////////////////////////
// Background thread
////////////////////////////////////////////////////////////////////////////
void *wxJoystick::Entry(void)
{
struct js_event j_evt;
wxJoystickEvent jwx_event;
fd_set read_fds;
struct timeval time_out = {0, 0};
FD_ZERO(&read_fds);
DeferDestroy(TRUE);
while (1) {
TestDestroy();
if (m_polling) {
FD_SET(m_joystick, &read_fds);
select(m_joystick+1, &read_fds, NULL, NULL, &time_out);
if (FD_ISSET(m_joystick, &read_fds))
read(m_joystick, &j_evt, sizeof(j_evt));
else
j_evt.type = 0;
} else {
read(m_joystick, &j_evt, sizeof(j_evt));
}
if ((j_evt.type & JS_EVENT_AXIS) == JS_EVENT_AXIS) {
switch (j_evt.number) {
case 1:
m_lastposition.x = j_evt.value;
jwx_event.SetEventType(wxEVT_JOY_MOVE);
break;
case 2:
m_lastposition.y = j_evt.value;
jwx_event.SetEventType(wxEVT_JOY_MOVE);
break;
case 3:
m_axe[3] = j_evt.value;
jwx_event.SetEventType(wxEVT_JOY_ZMOVE);
break;
default:
m_axe[j_evt.number] = j_evt.value;
jwx_event.SetEventType(wxEVT_JOY_MOVE);
break;
}
jwx_event.SetPosition(m_lastposition);
jwx_event.SetZPosition(m_axe[3]);
}
if ((j_evt.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON) {
register int mask = 1 << j_evt.number;
char button = m_buttons & mask;
m_buttons &= ~mask;
if (button) {
jwx_event.SetEventType(wxEVT_JOY_BUTTON_UP);
} else {
jwx_event.SetEventType(wxEVT_JOY_BUTTON_DOWN);
m_buttons |= mask;
}
jwx_event.SetButtonState(m_buttons);
jwx_event.SetButtonChange(j_evt.number);
}
}
if (m_catchwin)
m_catchwin->ProcessEvent(jwx_event);
if (m_polling)
usleep(m_polling*1000);
}
////////////////////////////////////////////////////////////////////////////
// State
// Attributes
////////////////////////////////////////////////////////////////////////////
wxPoint wxJoystick::GetPosition(void) const
wxPoint wxJoystick::GetPosition() const
{
return m_lastposition;
// TODO
return wxPoint(0, 0);
}
int wxJoystick::GetZPosition(void) const
{
return m_axe[3];
}
int wxJoystick::GetButtonState(void) const
{
return m_buttons;
}
int wxJoystick::GetPOVPosition(void) const
int wxJoystick::GetZPosition() const
{
// TODO
return 0;
}
int wxJoystick::GetPOVCTSPosition(void) const
int wxJoystick::GetButtonState() const
{
// TODO
return 0;
}
int wxJoystick::GetRudderPosition(void) const
int wxJoystick::GetPOVPosition() const
{
return m_axe[4];
// TODO
return 0;
}
int wxJoystick::GetUPosition(void) const
int wxJoystick::GetPOVCTSPosition() const
{
return m_axe[5];
// TODO
return 0;
}
int wxJoystick::GetVPosition(void) const
int wxJoystick::GetRudderPosition() const
{
return m_axe[6];
// TODO
return 0;
}
int wxJoystick::GetMovementThreshold(void) const
int wxJoystick::GetUPosition() const
{
// TODO
return 0;
}
int wxJoystick::GetVPosition() const
{
// TODO
return 0;
}
int wxJoystick::GetMovementThreshold() const
{
// TODO
return 0;
}
void wxJoystick::SetMovementThreshold(int threshold)
{
// TODO
}
////////////////////////////////////////////////////////////////////////////
// Capabilities
////////////////////////////////////////////////////////////////////////////
bool wxJoystick::IsOk(void) const
bool wxJoystick::IsOk() const
{
return (m_joystick != -1);
// TODO
return FALSE;
}
int wxJoystick::GetNumberJoysticks(void) const
{
wxString dev_name;
int fd, j;
for (j=0;j<2;j++) {
dev_name.Printf("/dev/js%d", j);
fd = open(dev_name, O_RDONLY);
if (fd == -1)
return j;
close(fd);
}
return j;
}
int wxJoystick::GetManufacturerId(void) const
int wxJoystick::GetNumberJoysticks() const
{
// TODO
return 0;
}
int wxJoystick::GetProductId(void) const
int wxJoystick::GetManufacturerId() const
{
// TODO
return 0;
}
wxString wxJoystick::GetProductName(void) const
int wxJoystick::GetProductId() const
{
return "";
// TODO
return 0;
}
int wxJoystick::GetXMin(void) const
wxString wxJoystick::GetProductName() const
{
return JOYSTICK_AXE_MAX;
// TODO
return wxString("");
}
int wxJoystick::GetYMin(void) const
int wxJoystick::GetXMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetZMin(void) const
int wxJoystick::GetYMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetXMax(void) const
int wxJoystick::GetZMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetYMax(void) const
int wxJoystick::GetXMax() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetZMax(void) const
int wxJoystick::GetYMax() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetNumberButtons(void) const
int wxJoystick::GetZMax() const
{
int nb;
ioctl(m_joystick, JSIOCGBUTTONS, &nb);
return nb;
// TODO
return 0;
}
int wxJoystick::GetNumberAxes(void) const
int wxJoystick::GetNumberButtons() const
{
int nb;
ioctl(m_joystick, JSIOCGAXES, &nb);
return nb;
// TODO
return 0;
}
int wxJoystick::GetMaxButtons(void) const
int wxJoystick::GetNumberAxes() const
{
return 15; // internal
// TODO
return 0;
}
int wxJoystick::GetMaxAxes(void) const
int wxJoystick::GetMaxButtons() const
{
return 15; // internal
// TODO
return 0;
}
int wxJoystick::GetPollingMin(void) const
int wxJoystick::GetMaxAxes() const
{
return -1;
// TODO
return 0;
}
int wxJoystick::GetPollingMax(void) const
int wxJoystick::GetPollingMin() const
{
return -1;
// TODO
return 0;
}
int wxJoystick::GetRudderMin(void) const
int wxJoystick::GetPollingMax() const
{
return JOYSTICK_AXE_MIN;
// TODO
return 0;
}
int wxJoystick::GetRudderMax(void) const
int wxJoystick::GetRudderMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetUMin(void) const
int wxJoystick::GetRudderMax() const
{
return JOYSTICK_AXE_MIN;
// TODO
return 0;
}
int wxJoystick::GetUMax(void) const
int wxJoystick::GetUMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetVMin(void) const
int wxJoystick::GetUMax() const
{
return JOYSTICK_AXE_MIN;
// TODO
return 0;
}
int wxJoystick::GetVMax(void) const
int wxJoystick::GetVMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
bool wxJoystick::HasRudder(void) const
int wxJoystick::GetVMax() const
{
return GetNumberAxes() >= 4;
// TODO
return 0;
}
bool wxJoystick::HasZ(void) const
{
return GetNumberAxes() >= 3;
}
bool wxJoystick::HasU(void) const
{
return GetNumberAxes() >= 5;
}
bool wxJoystick::HasV(void) const
{
return GetNumberAxes() >= 6;
}
bool wxJoystick::HasPOV(void) const
bool wxJoystick::HasRudder() const
{
// TODO
return FALSE;
}
bool wxJoystick::HasPOV4Dir(void) const
bool wxJoystick::HasZ() const
{
// TODO
return FALSE;
}
bool wxJoystick::HasPOVCTS(void) const
bool wxJoystick::HasU() const
{
// TODO
return FALSE;
}
bool wxJoystick::HasV() const
{
// TODO
return FALSE;
}
bool wxJoystick::HasPOV() const
{
// TODO
return FALSE;
}
bool wxJoystick::HasPOV4Dir() const
{
// TODO
return FALSE;
}
bool wxJoystick::HasPOVCTS() const
{
// TODO
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
// Operations
////////////////////////////////////////////////////////////////////////////
bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq = 0)
bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
{
m_catchwin = win;
m_polling = pollingFreq;
return TRUE;
// TODO
return FALSE;
}
bool wxJoystick::ReleaseCapture(void)
bool wxJoystick::ReleaseCapture()
{
m_catchwin = NULL;
m_polling = 0;
return TRUE;
// TODO
return FALSE;
}

269
src/qt/listbox.cpp
View File

@@ -1,137 +1,240 @@
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Name: listbox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxListBox
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "listbox.h"
#endif
#include "wx/dynarray.h"
#include "wx/listbox.h"
#include "wx/utils.h"
//-----------------------------------------------------------------------------
// wxListBox
//-----------------------------------------------------------------------------
#include "wx/dynarray.h"
#include "wx/log.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
#endif
wxListBox::wxListBox(void)
{
};
// ============================================================================
// list box control implementation
// ============================================================================
wxListBox::wxListBox( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxString &name )
// Listbox item
wxListBox::wxListBox()
{
Create( parent, id, pos, size, n, choices, style, name );
};
m_noItems = 0;
m_selected = 0;
}
bool wxListBox::Create(wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style, const wxString &name )
long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
m_noItems = n;
m_selected = 0;
SetName(name);
SetValidator(validator);
if (parent) parent->AddChild(this);
wxSystemSettings settings;
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
m_windowId = ( id == -1 ) ? (int)NewControlId() : id;
// TODO create listbox
return FALSE;
}
wxListBox::~wxListBox()
{
}
void wxListBox::SetupColours()
{
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
}
void wxListBox::SetFirstItem(int N)
{
// TODO
}
void wxListBox::SetFirstItem(const wxString& s)
{
// TODO
}
void wxListBox::Delete(int N)
{
m_noItems --;
// TODO
}
void wxListBox::Append(const wxString& item)
{
Append( item, (char*)NULL );
};
m_noItems ++;
void wxListBox::Append( const wxString &WXUNUSED(item), char *WXUNUSED(clientData) )
{
};
// TODO
}
void wxListBox::Clear(void)
void wxListBox::Append(const wxString& item, char *Client_data)
{
};
m_noItems ++;
void wxListBox::Delete( int WXUNUSED(n) )
{
};
// TODO
}
void wxListBox::Deselect( int WXUNUSED(n) )
void wxListBox::Set(int n, const wxString *choices, char** clientData)
{
};
m_noItems = n;
int wxListBox::FindString( const wxString &WXUNUSED(item) ) const
// TODO
}
int wxListBox::FindString(const wxString& s) const
{
// TODO
return -1;
};
}
char *wxListBox::GetClientData( int WXUNUSED(n) ) const
void wxListBox::Clear()
{
return (char*)NULL;
};
m_noItems = 0;
// TODO
}
int wxListBox::GetSelection(void) const
void wxListBox::SetSelection(int N, bool select)
{
return -1;
};
// TODO
}
int wxListBox::GetSelections( wxArrayInt& WXUNUSED(aSelections) ) const
{
return 0;
};
wxString wxListBox::GetString( int WXUNUSED(n) ) const
{
return "";
};
wxString wxListBox::GetStringSelection(void) const
{
return "";
};
int wxListBox::Number(void)
{
return 0;
};
bool wxListBox::Selected( int WXUNUSED(n) )
bool wxListBox::Selected(int N) const
{
// TODO
return FALSE;
};
}
void wxListBox::Set( int WXUNUSED(n), const wxString *WXUNUSED(choices) )
void wxListBox::Deselect(int N)
{
};
// TODO
}
void wxListBox::SetClientData( int WXUNUSED(n), char *WXUNUSED(clientData) )
char *wxListBox::GetClientData(int N) const
{
};
// TODO
return (char *)NULL;
}
void wxListBox::SetFirstItem( int WXUNUSED(n) )
void wxListBox::SetClientData(int N, char *Client_data)
{
};
// TODO
}
void wxListBox::SetFirstItem( const wxString &WXUNUSED(item) )
// Return number of selections and an array of selected integers
int wxListBox::GetSelections(wxArrayInt& aSelections) const
{
};
aSelections.Empty();
void wxListBox::SetSelection( int WXUNUSED(n), bool WXUNUSED(select) )
/* TODO
if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED))
{
};
int no_sel = ??
for ( int n = 0; n < no_sel; n++ )
aSelections.Add(??);
void wxListBox::SetString( int WXUNUSED(n), const wxString &WXUNUSED(string) )
return no_sel;
}
else // single-selection listbox
{
};
aSelections.Add(??);
void wxListBox::SetStringSelection( const wxString &WXUNUSED(string), bool WXUNUSED(select) )
return 1;
}
*/
return 0;
}
// Get single selection, for single choice list items
int wxListBox::GetSelection() const
{
};
// TODO
return -1;
}
// Find string for position
wxString wxListBox::GetString(int N) const
{
// TODO
return wxString("");
}
void wxListBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
// TODO
}
void wxListBox::InsertItems(int nItems, const wxString items[], int pos)
{
m_noItems += nItems;
// TODO
}
void wxListBox::SetString(int N, const wxString& s)
{
// TODO
}
int wxListBox::Number () const
{
return m_noItems;
}
// For single selection items only
wxString wxListBox::GetStringSelection () const
{
int sel = GetSelection ();
if (sel > -1)
return this->GetString (sel);
else
return wxString("");
}
bool wxListBox::SetStringSelection (const wxString& s, bool flag)
{
int sel = FindString (s);
if (sel > -1)
{
SetSelection (sel, flag);
return TRUE;
}
else
return FALSE;
}
void wxListBox::Command (wxCommandEvent & event)
{
if (event.m_extraLong)
SetSelection (event.m_commandInt);
else
{
Deselect (event.m_commandInt);
return;
}
ProcessCommand (event);
}

332
src/qt/mdi.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: mdi.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: MDI classes
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,217 +14,250 @@
#endif
#include "wx/mdi.h"
#include "wx/dialog.h"
#include "wx/menu.h"
//-----------------------------------------------------------------------------
extern wxList wxPendingDelete;
//-----------------------------------------------------------------------------
// wxMDIParentFrame
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern wxList wxModelessWindows;
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
EVT_SIZE(wxMDIParentFrame::OnSize)
EVT_ACTIVATE(wxMDIParentFrame::OnActivate)
EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
END_EVENT_TABLE()
wxMDIParentFrame::wxMDIParentFrame(void)
{
m_clientWindow = NULL;
m_currentChild = NULL;
m_parentFrameActive = TRUE;
};
BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
EVT_SCROLL(wxMDIClientWindow::OnScroll)
END_EVENT_TABLE()
wxMDIParentFrame::wxMDIParentFrame( wxWindow *parent,
wxWindowID id, const wxString& title,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
m_clientWindow = NULL;
m_currentChild = NULL;
m_parentFrameActive = TRUE;
Create( parent, id, title, pos, size, style, name );
};
#endif
wxMDIParentFrame::~wxMDIParentFrame(void)
// Parent frame
wxMDIParentFrame::wxMDIParentFrame()
{
};
}
bool wxMDIParentFrame::Create(wxWindow *parent,
wxWindowID id, const wxString& title,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
wxFrame::Create( parent, id, title, pos, size, style, name );
if (!parent)
wxTopLevelWindows.Append(this);
OnCreateClient();
SetName(name);
m_windowStyle = style;
if (parent) parent->AddChild(this);
if ( id > -1 )
m_windowId = id;
else
m_windowId = (int)NewControlId();
// TODO: create MDI parent frame
wxModelessWindows.Append(this);
return TRUE;
};
}
void wxMDIParentFrame::GetClientSize(int *width, int *height ) const
wxMDIParentFrame::~wxMDIParentFrame()
{
wxFrame::GetClientSize( width, height );
};
}
wxMDIChildFrame *wxMDIParentFrame::GetActiveChild(void) const
// Get size *available for subwindows* i.e. excluding menu bar.
void wxMDIParentFrame::GetClientSize(int *x, int *y) const
{
return m_currentChild;
};
// TODO
}
wxMDIClientWindow *wxMDIParentFrame::GetClientWindow(void) const
void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar)
{
return m_clientWindow;
};
wxMDIClientWindow *wxMDIParentFrame::OnCreateClient(void)
// TODO
if (!menu_bar)
{
m_clientWindow = new wxMDIClientWindow( this );
return m_clientWindow;
};
m_frameMenuBar = NULL;
return;
}
void wxMDIParentFrame::ActivateNext(void)
if (menu_bar->m_menuBarFrame)
return;
m_frameMenuBar = menu_bar;
}
void wxMDIParentFrame::OnSize(wxSizeEvent& event)
{
};
#if USE_CONSTRAINTS
if (GetAutoLayout())
Layout();
#endif
int x = 0;
int y = 0;
int width, height;
GetClientSize(&width, &height);
void wxMDIParentFrame::ActivatePrevious(void)
if ( GetClientWindow() )
GetClientWindow()->SetSize(x, y, width, height);
}
void wxMDIParentFrame::OnActivate(wxActivateEvent& event)
{
};
// Do nothing
}
void wxMDIParentFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
// Returns the active MDI child window
wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
};
// TODO
return NULL;
}
void wxMDIParentFrame::OnSysColourChanged( wxSysColourChangedEvent& WXUNUSED(event) )
// Create the client window class (don't Create the window,
// just return a new class)
wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
{
};
return new wxMDIClientWindow ;
}
//-----------------------------------------------------------------------------
// wxMDIChildFrame
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
END_EVENT_TABLE()
wxMDIChildFrame::wxMDIChildFrame(void)
// Responds to colour changes, and passes event on to children.
void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
{
};
// TODO
wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
wxWindowID id, const wxString& title,
const wxPoint& WXUNUSED(pos), const wxSize& size,
long style, const wxString& name )
{
Create( parent, id, title, wxDefaultPosition, size, style, name );
};
// Propagate the event to the non-top-level children
wxFrame::OnSysColourChanged(event);
}
wxMDIChildFrame::~wxMDIChildFrame(void)
// MDI operations
void wxMDIParentFrame::Cascade()
{
};
// TODO
}
void wxMDIParentFrame::Tile()
{
// TODO
}
void wxMDIParentFrame::ArrangeIcons()
{
// TODO
}
void wxMDIParentFrame::ActivateNext()
{
// TODO
}
void wxMDIParentFrame::ActivatePrevious()
{
// TODO
}
// Child frame
wxMDIChildFrame::wxMDIChildFrame()
{
}
bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
wxWindowID id, const wxString& title,
const wxPoint& WXUNUSED(pos), const wxSize& size,
long style, const wxString& name )
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
m_title = title;
return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
};
SetName(name);
void wxMDIChildFrame::GetClientSize( int *width, int *height ) const
{
wxWindow::GetClientSize( width, height );
if ( id > -1 )
m_windowId = id;
else
m_windowId = (int)NewControlId();
if (parent) parent->AddChild(this);
// TODO: create child frame
wxModelessWindows.Append(this);
return FALSE;
}
void wxMDIChildFrame::AddChild( wxWindow *child )
wxMDIChildFrame::~wxMDIChildFrame()
{
wxWindow::AddChild( child );
}
static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
// Set the client size (i.e. leave the calculation of borders etc.
// to wxWindows)
void wxMDIChildFrame::SetClientSize(int width, int height)
{
menu->SetInvokingWindow( win );
wxNode *node = menu->m_items.First();
while (node)
// TODO
}
void wxMDIChildFrame::GetPosition(int *x, int *y) const
{
wxMenuItem *menuitem = (wxMenuItem*)node->Data();
if (menuitem->IsSubMenu())
SetInvokingWindow( menuitem->GetSubMenu(), win );
node = node->Next();
};
};
// TODO
}
void wxMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
{
m_menuBar = menu_bar;
if (m_menuBar)
// TODO
if (!menu_bar)
{
wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->m_parent;
if (m_menuBar->m_parent != this)
{
wxNode *node = m_menuBar->m_menus.First();
while (node)
{
wxMenu *menu = (wxMenu*)node->Data();
SetInvokingWindow( menu, this );
node = node->Next();
};
m_menuBar->m_parent = mdi_frame;
m_frameMenuBar = NULL;
return;
}
mdi_frame->SetMDIMenuBar( m_menuBar );
if (menu_bar->m_menuBarFrame)
return;
m_frameMenuBar = menu_bar;
}
};
wxMenuBar *wxMDIChildFrame::GetMenuBar()
// MDI operations
void wxMDIChildFrame::Maximize()
{
return m_menuBar;
};
// TODO
}
void wxMDIChildFrame::Activate(void)
void wxMDIChildFrame::Restore()
{
};
// TODO
}
void wxMDIChildFrame::OnActivate( wxActivateEvent &WXUNUSED(event) )
void wxMDIChildFrame::Activate()
{
};
// TODO
}
//-----------------------------------------------------------------------------
// wxMDIClientWindow
//-----------------------------------------------------------------------------
// Client window
IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
wxMDIClientWindow::wxMDIClientWindow(void)
wxMDIClientWindow::wxMDIClientWindow()
{
};
}
wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
wxMDIClientWindow::~wxMDIClientWindow()
{
CreateClient( parent, style );
};
}
wxMDIClientWindow::~wxMDIClientWindow(void)
bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
{
};
// TODO create client window
m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *WXUNUSED(parent), long WXUNUSED(style) )
return FALSE;
}
// Explicitly call default scroll behaviour
void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
{
return TRUE;
};
void wxMDIClientWindow::AddChild( wxWindow *WXUNUSED(child) )
{
};
Default(); // Default processing
}

747
src/qt/menu.cpp
View File

@@ -1,293 +1,568 @@
/////////////////////////////////////////////////////////////////////////////
// Name: menu.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxMenu, wxMenuBar, wxMenuItem
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// headers & declarations
// ============================================================================
// wxWindows headers
// -----------------
#ifdef __GNUG__
#pragma implementation "menu.h"
#pragma implementation "menuitem.h"
#endif
#include "wx/menu.h"
#include "wx/menuitem.h"
#include "wx/log.h"
//-----------------------------------------------------------------------------
// wxMenuBar
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow)
wxMenuBar::wxMenuBar()
{
};
void wxMenuBar::Append( wxMenu *menu, const wxString &title )
{
m_menus.Append( menu );
menu->m_title = title; // ??????
int pos;
do {
pos = menu->m_title.First( '&' );
if (pos != -1) menu->m_title.Remove( pos, 1 );
} while (pos != -1);
};
static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString )
{
if (menu->m_title == menuString)
{
int res = menu->FindItem( itemString );
if (res != -1) return res;
};
wxNode *node = menu->m_items.First();
while (node)
{
wxMenuItem *item = (wxMenuItem*)node->Data();
if (item->IsSubMenu())
return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString);
node = node->Next();
};
return -1;
};
int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const
{
wxNode *node = m_menus.First();
while (node)
{
wxMenu *menu = (wxMenu*)node->Data();
int res = FindMenuItemRecursive( menu, menuString, itemString);
if (res != -1) return res;
node = node->Next();
};
return -1;
};
// Find a wxMenuItem using its id. Recurses down into sub-menus
static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id)
{
wxMenuItem* result = menu->FindItem(id);
wxNode *node = menu->m_items.First();
while ( node && result == NULL ) {
wxMenuItem *item = (wxMenuItem*)node->Data();
if ( item->IsSubMenu() )
result = FindMenuItemByIdRecursive( item->GetSubMenu(), id );
node = node->Next();
};
return result;
};
wxMenuItem* wxMenuBar::FindMenuItemById( int id ) const
{
wxMenuItem* result = 0;
wxNode *node = m_menus.First();
while (node && result == 0)
{
wxMenu *menu = (wxMenu*)node->Data();
result = FindMenuItemByIdRecursive( menu, id );
node = node->Next();
}
return result;
}
void wxMenuBar::Check( int id, bool check )
{
wxMenuItem* item = FindMenuItemById( id );
if (item) item->Check(check);
};
bool wxMenuBar::Checked( int id ) const
{
wxMenuItem* item = FindMenuItemById( id );
if (item) return item->IsChecked();
return FALSE;
};
void wxMenuBar::Enable( int id, bool enable )
{
wxMenuItem* item = FindMenuItemById( id );
if (item) item->Enable(enable);
};
bool wxMenuBar::Enabled( int id ) const
{
wxMenuItem* item = FindMenuItemById( id );
if (item) return item->IsEnabled();
return FALSE;
};
//-----------------------------------------------------------------------------
// wxMenu
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMenuItem,wxObject)
wxMenuItem::wxMenuItem()
{
m_id = ID_SEPARATOR;
m_isCheckMenu = FALSE;
m_isChecked = FALSE;
m_isEnabled = TRUE;
m_subMenu = NULL;
};
void wxMenuItem::SetText(const wxString& str)
{
for ( const char *pc = str; *pc != '\0'; pc++ ) {
if ( *pc == '&' )
pc++; // skip it
m_text << *pc;
}
}
void wxMenuItem::Check( bool check )
{
wxCHECK_RET( IsCheckable(), "can't check uncheckable item!" )
m_isChecked = check;
}
bool wxMenuItem::IsChecked() const
{
wxCHECK( IsCheckable(), FALSE ); // can't get state of uncheckable item!
return FALSE;
}
// other standard headers
// ----------------------
#include <string.h>
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
#endif
wxMenu::wxMenu( const wxString &title )
// ============================================================================
// implementation
// ============================================================================
// Menus
// Construct a menu with optional title (then use append)
wxMenu::wxMenu(const wxString& title, const wxFunction func)
{
m_title = title;
m_items.DeleteContents( TRUE );
m_invokingWindow = NULL;
};
m_parent = NULL;
m_eventHandler = this;
m_noItems = 0;
m_menuBar = NULL;
if (m_title != "")
{
Append(-2, m_title) ;
AppendSeparator() ;
}
Callback(func);
// TODO create menu
}
// The wxWindow destructor will take care of deleting the submenus.
wxMenu::~wxMenu()
{
// TODO destroy menu and children
wxNode *node = m_menuItems.First();
while (node)
{
wxMenuItem *item = (wxMenuItem *)node->Data();
// Delete child menus.
// Beware: they must not be appended to children list!!!
// (because order of delete is significant)
if (item->GetSubMenu())
item->DeleteSubMenu();
wxNode *next = node->Next();
delete item;
delete node;
node = next;
}
}
void wxMenu::Break()
{
// TODO
}
// function appends a new item or submenu to the menu
void wxMenu::Append(wxMenuItem *pItem)
{
// TODO
wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );
m_menuItems.Append(pItem);
m_noItems++;
}
void wxMenu::AppendSeparator()
{
wxMenuItem *mitem = new wxMenuItem();
mitem->SetId(ID_SEPARATOR);
// TODO
Append(new wxMenuItem(this, ID_SEPARATOR));
}
m_items.Append( mitem );
};
void wxMenu::Append( int id, const wxString &item, const wxString &helpStr, bool checkable )
// Pullright item
void wxMenu::Append(int Id, const wxString& label, wxMenu *SubMenu,
const wxString& helpString)
{
wxMenuItem *mitem = new wxMenuItem();
mitem->SetId(id);
mitem->SetText(item);
mitem->SetHelpString(helpStr);
mitem->SetCheckable(checkable);
Append(new wxMenuItem(this, Id, label, helpString, FALSE, SubMenu));
}
m_items.Append( mitem );
};
void wxMenu::Append( int id, const wxString &text, wxMenu *subMenu, const wxString &helpStr )
// Ordinary menu item
void wxMenu::Append(int Id, const wxString& label,
const wxString& helpString, bool checkable)
{
wxMenuItem *mitem = new wxMenuItem();
mitem->SetId(id);
mitem->SetText(text);
mitem->SetHelpString(helpStr);
mitem->SetSubMenu(subMenu);
// 'checkable' parameter is useless for Windows.
Append(new wxMenuItem(this, Id, label, helpString, checkable));
}
m_items.Append( mitem );
};
int wxMenu::FindItem( const wxString itemString ) const
void wxMenu::Delete(int id)
{
wxString s( itemString );
wxNode *node;
wxMenuItem *item;
int pos;
do {
pos = s.First( '&' );
if (pos != -1) s.Remove( pos, 1 );
} while (pos != -1);
wxNode *node = m_items.First();
while (node)
for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++) {
item = (wxMenuItem *)node->Data();
if (item->GetId() == id)
break;
}
if (!node)
return;
m_menuItems.DeleteNode(node);
delete item;
// TODO
}
void wxMenu::Enable(int Id, bool Flag)
{
wxMenuItem *item = (wxMenuItem*)node->Data();
if (item->GetText() == s)
return item->GetId();
node = node->Next();
};
wxMenuItem *item = FindItemForId(Id);
wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );
return -1;
};
item->Enable(Flag);
}
void wxMenu::Enable( int id, bool enable )
bool wxMenu::Enabled(int Id) const
{
wxMenuItem *item = FindItem(id);
if ( item )
item->Enable(enable);
};
wxMenuItem *item = FindItemForId(Id);
wxCHECK( item != NULL, FALSE );
bool wxMenu::IsEnabled( int id ) const
{
wxMenuItem *item = FindItem(id);
if ( item )
return item->IsEnabled();
else
return FALSE;
};
}
void wxMenu::Check( int id, bool enable )
void wxMenu::Check(int Id, bool Flag)
{
wxMenuItem *item = FindItem(id);
if ( item )
item->Check(enable);
};
wxMenuItem *item = FindItemForId(Id);
wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );
bool wxMenu::IsChecked( int id ) const
item->Check(Flag);
}
bool wxMenu::Checked(int Id) const
{
wxMenuItem *item = FindItem(id);
if ( item )
wxMenuItem *item = FindItemForId(Id);
wxCHECK( item != NULL, FALSE );
return item->IsChecked();
else
return FALSE;
};
}
void wxMenu::SetTitle(const wxString& label)
{
m_title = label ;
// TODO
}
const wxString& wxMenu::GetTitle() const
{
return m_title;
}
void wxMenu::SetLabel(int id, const wxString& label)
{
wxMenuItem *item = FindItem(id);
if ( item )
item->SetText(label);
};
wxMenuItem *item = FindItemForId(id) ;
if (item==NULL)
return;
wxMenuItem *wxMenu::FindItem(int id) const
if (item->GetSubMenu()==NULL)
{
// TODO
}
else
{
// TODO
}
item->SetName(label);
}
wxString wxMenu::GetLabel(int Id) const
{
// TODO
return wxString("") ;
}
// Finds the item id matching the given string, -1 if not found.
int wxMenu::FindItem (const wxString& itemString) const
{
char buf1[200];
char buf2[200];
wxStripMenuCodes ((char *)(const char *)itemString, buf1);
for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
{
wxNode *node = m_items.First();
while (node) {
wxMenuItem *item = (wxMenuItem *) node->Data ();
if ( item->GetId() == id )
if (item->GetSubMenu())
{
int ans = item->GetSubMenu()->FindItem(itemString);
if (ans > -1)
return ans;
}
if ( !item->IsSeparator() )
{
wxStripMenuCodes((char *)item->GetName().c_str(), buf2);
if (strcmp(buf1, buf2) == 0)
return item->GetId();
}
}
return -1;
}
wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
{
if (itemMenu)
*itemMenu = NULL;
for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
{
wxMenuItem *item = (wxMenuItem *) node->Data ();
if (item->GetId() == itemId)
{
if (itemMenu)
*itemMenu = (wxMenu *) this;
return item;
node = node->Next();
};
}
wxLogDebug("wxMenu::FindItem: item %d not found.", id);
if (item->GetSubMenu())
{
wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu);
if (ans)
return ans;
}
}
if (itemMenu)
*itemMenu = NULL;
return NULL;
}
void wxMenu::SetInvokingWindow( wxWindow *win )
void wxMenu::SetHelpString(int itemId, const wxString& helpString)
{
m_invokingWindow = win;
};
wxMenuItem *item = FindItemForId (itemId);
if (item)
item->SetHelp(helpString);
}
wxWindow *wxMenu::GetInvokingWindow()
wxString wxMenu::GetHelpString (int itemId) const
{
return m_invokingWindow;
};
wxMenuItem *item = FindItemForId (itemId);
wxString str("");
return (item == NULL) ? str : item->GetHelp();
}
void wxMenu::ProcessCommand(wxCommandEvent & event)
{
bool processed = FALSE;
// Try a callback
if (m_callback)
{
(void) (*(m_callback)) (*this, event);
processed = TRUE;
}
// Try the menu's event handler
if ( !processed && GetEventHandler())
{
processed = GetEventHandler()->ProcessEvent(event);
}
// Try the window the menu was popped up from (and up
// through the hierarchy)
if ( !processed && GetInvokingWindow())
processed = GetInvokingWindow()->ProcessEvent(event);
}
bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
{
// TODO
return FALSE;
}
// Menu Bar
wxMenuBar::wxMenuBar()
{
m_eventHandler = this;
m_menuCount = 0;
m_menus = NULL;
m_titles = NULL;
m_menuBarFrame = NULL;
// TODO
}
wxMenuBar::wxMenuBar(int n, wxMenu *Mmnus[], const wxString titles[])
{
m_eventHandler = this;
m_menuCount = n;
m_menus = menus;
m_titles = new wxString[n];
int i;
for ( i = 0; i < n; i++ )
m_titles[i] = titles[i];
m_menuBarFrame = NULL;
// TODO
}
wxMenuBar::~wxMenuBar()
{
int i;
for (i = 0; i < m_menuCount; i++)
{
delete m_menus[i];
}
delete[] m_menus;
delete[] m_titles;
// TODO
}
// Must only be used AFTER menu has been attached to frame,
// otherwise use individual menus to enable/disable items
void wxMenuBar::Enable(int id, bool flag)
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return;
// TODO
}
void wxMenuBar::EnableTop(int pos, bool flag)
{
// TODO
}
// Must only be used AFTER menu has been attached to frame,
// otherwise use individual menus
void wxMenuBar::Check(int id, bool flag)
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return;
if (!item->IsCheckable())
return ;
// TODO
}
bool wxMenuBar::Checked(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return FALSE;
// TODO
return FALSE;
}
bool wxMenuBar::Enabled(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return FALSE;
// TODO
return FALSE ;
}
void wxMenuBar::SetLabel(int id, const wxString& label)
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return;
// TODO
}
wxString wxMenuBar::GetLabel(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return wxString("");
// TODO
return wxString("") ;
}
void wxMenuBar::SetLabelTop(int pos, const wxString& label)
{
// TODO
}
wxString wxMenuBar::GetLabelTop(int pos) const
{
// TODO
return wxString("");
}
bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
{
// TODO
return FALSE;
}
bool wxMenuBar::OnAppend(wxMenu *a_menu, const char *title)
{
// TODO
return FALSE;
}
void wxMenuBar::Append (wxMenu * menu, const wxString& title)
{
if (!OnAppend(menu, title))
return;
m_menuCount ++;
wxMenu **new_menus = new wxMenu *[m_menuCount];
wxString *new_titles = new wxString[m_menuCount];
int i;
for (i = 0; i < m_menuCount - 1; i++)
{
new_menus[i] = m_menus[i];
m_menus[i] = NULL;
new_titles[i] = m_titles[i];
m_titles[i] = "";
}
if (m_menus)
{
delete[]m_menus;
delete[]m_titles;
}
m_menus = new_menus;
m_titles = new_titles;
m_menus[m_menuCount - 1] = (wxMenu *)menu;
m_titles[m_menuCount - 1] = title;
// TODO
}
void wxMenuBar::Delete(wxMenu * menu, int i)
{
int j;
int ii = (int) i;
if (menu != 0)
{
for (ii = 0; ii < m_menuCount; ii++)
{
if (m_menus[ii] == menu)
break;
}
if (ii >= m_menuCount)
return;
} else
{
if (ii < 0 || ii >= m_menuCount)
return;
menu = m_menus[ii];
}
if (!OnDelete(menu, ii))
return;
menu->SetParent(NULL);
-- m_menuCount;
for (j = ii; j < m_menuCount; j++)
{
m_menus[j] = m_menus[j + 1];
m_titles[j] = m_titles[j + 1];
}
}
// Find the menu menuString, item itemString, and return the item id.
// Returns -1 if none found.
int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
{
char buf1[200];
char buf2[200];
wxStripMenuCodes ((char *)(const char *)menuString, buf1);
int i;
for (i = 0; i < m_menuCount; i++)
{
wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
if (strcmp (buf1, buf2) == 0)
return m_menus[i]->FindItem (itemString);
}
return -1;
}
wxMenuItem *wxMenuBar::FindItemForId (int Id, wxMenu ** itemMenu) const
{
if (itemMenu)
*itemMenu = NULL;
wxMenuItem *item = NULL;
int i;
for (i = 0; i < m_menuCount; i++)
if ((item = m_menus[i]->FindItemForId (Id, itemMenu)))
return item;
return NULL;
}
void wxMenuBar::SetHelpString (int Id, const wxString& helpString)
{
int i;
for (i = 0; i < m_menuCount; i++)
{
if (m_menus[i]->FindItemForId (Id))
{
m_menus[i]->SetHelpString (Id, helpString);
return;
}
}
}
wxString wxMenuBar::GetHelpString (int Id) const
{
int i;
for (i = 0; i < m_menuCount; i++)
{
if (m_menus[i]->FindItemForId (Id))
eturn wxString(m_menus[i]->GetHelpString (Id));
}
return wxString("");
}

414
src/qt/notebook.cpp
View File

@@ -1,185 +1,371 @@
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Name: notebook.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: implementation of wxNotebook
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "notebook.h"
#endif
#include "wx/notebook.h"
#include "wx/panel.h"
#include "wx/utils.h"
#include "wx/imaglist.h"
#include "wx/log.h"
#include <wx/string.h>
#include <wx/log.h>
#include <wx/imaglist.h>
#include <wx/notebook.h>
//-----------------------------------------------------------------------------
// wxNotebookPage
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
class wxNotebookPage: public wxObject
{
public:
wxNotebookPage()
{
m_id = -1;
m_text = "";
m_image = -1;
m_page = NULL;
m_client = NULL;
m_parent = NULL;
};
// check that the page index is valid
#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
//private:
int m_id;
wxString m_text;
int m_image;
wxWindow *m_client;
};
// ----------------------------------------------------------------------------
// event table
// ----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// wxNotebook
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
BEGIN_EVENT_TABLE(wxNotebook, wxControl)
EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
EVT_SIZE(wxNotebook::OnSize)
EVT_SET_FOCUS(wxNotebook::OnSetFocus)
EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
END_EVENT_TABLE()
IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
#endif
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxNotebook construction
// ----------------------------------------------------------------------------
// common part of all ctors
void wxNotebook::Init()
{
m_imageList = NULL;
m_pages.DeleteContents( TRUE );
m_pImageList = NULL;
m_nSelection = -1;
}
// default for dynamic class
wxNotebook::wxNotebook()
{
Init();
};
}
wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
// the same arguments as for wxControl
wxNotebook::wxNotebook(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
Init();
Create( parent, id, pos, size, style, name );
};
Create(parent, id, pos, size, style, name);
}
// Create() function
bool wxNotebook::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
// base init
SetName(name);
SetParent(parent);
m_windowId = id == -1 ? NewControlId() : id;
// colors and font
m_backgroundColour = wxColour(GetSysColor(COLOR_BTNFACE));
m_foregroundColour = *wxBLACK ;
// style
m_windowStyle = style;
if ( parent != NULL )
parent->AddChild(this);
// TODO
return FALSE;
}
// dtor
wxNotebook::~wxNotebook()
{
DeleteAllPages();
};
bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
PreCreation( parent, id, pos, size, style, name );
PostCreation();
Show( TRUE );
return TRUE;
};
int wxNotebook::GetSelection() const
{
};
}
// ----------------------------------------------------------------------------
// wxNotebook accessors
// ----------------------------------------------------------------------------
int wxNotebook::GetPageCount() const
{
};
return m_aPages.Count();
}
int wxNotebook::GetRowCount() const
{
};
// TODO
return 0;
}
wxString wxNotebook::GetPageText( int page ) const
int wxNotebook::SetSelection(int nPage)
{
};
wxASSERT( IS_VALID_PAGE(nPage) );
int wxNotebook::GetPageImage( int page ) const
{
};
ChangePage(m_nSelection, nPage);
wxNotebookPage* wxNotebook::GetNotebookPage(int page) const
{
return NULL;
};
int wxNotebook::SetSelection( int page )
{
};
// TODO
return 0;
}
void wxNotebook::AdvanceSelection(bool bForward)
{
int nSel = GetSelection();
int nMax = GetPageCount() - 1;
if ( bForward )
SetSelection(nSel == nMax ? 0 : nSel + 1);
else
SetSelection(nSel == 0 ? nMax : nSel - 1);
}
bool wxNotebook::SetPageText(int nPage, const wxString& strText)
{
wxASSERT( IS_VALID_PAGE(nPage) );
// TODO
return FALSE;
}
wxString wxNotebook::GetPageText(int nPage) const
{
wxASSERT( IS_VALID_PAGE(nPage) );
// TODO
return wxString("");
}
int wxNotebook::GetPageImage(int nPage) const
{
wxASSERT( IS_VALID_PAGE(nPage) );
// TODO
return 0;
}
bool wxNotebook::SetPageImage(int nPage, int nImage)
{
wxASSERT( IS_VALID_PAGE(nPage) );
// TODO
return FALSE;
}
void wxNotebook::SetImageList(wxImageList* imageList)
{
m_imageList = imageList;
};
m_pImageList = imageList;
// TODO
}
bool wxNotebook::SetPageText( int page, const wxString &text )
// ----------------------------------------------------------------------------
// wxNotebook operations
// ----------------------------------------------------------------------------
// remove one page from the notebook
bool wxNotebook::DeletePage(int nPage)
{
wxCHECK( IS_VALID_PAGE(nPage), FALSE );
// TODO: delete native widget page
delete m_aPages[nPage];
m_aPages.Remove(nPage);
return TRUE;
};
bool wxNotebook::SetPageImage( int page, int image )
{
return TRUE;
};
void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
{
};
void wxNotebook::SetPadding( const wxSize &WXUNUSED(padding) )
{
};
}
// remove all pages
bool wxNotebook::DeleteAllPages()
{
// TODO: delete native widget pages
int nPageCount = GetPageCount();
int nPage;
for ( nPage = 0; nPage < nPageCount; nPage++ )
delete m_aPages[nPage];
m_aPages.Clear();
return TRUE;
};
}
bool wxNotebook::DeletePage( int page )
// add a page to the notebook
bool wxNotebook::AddPage(wxNotebookPage *pPage,
const wxString& strText,
bool bSelect,
int imageId)
{
return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId);
}
// same as AddPage() but does it at given position
bool wxNotebook::InsertPage(int nPage,
wxNotebookPage *pPage,
const wxString& strText,
bool bSelect,
int imageId)
{
wxASSERT( pPage != NULL );
wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE );
// TODO: insert native widget page
// save the pointer to the page
m_aPages.Insert(pPage, nPage);
// some page must be selected: either this one or the first one if there is
// still no selection
if ( bSelect )
m_nSelection = nPage;
else if ( m_nSelection == -1 )
m_nSelection = 0;
return TRUE;
};
}
bool wxNotebook::AddPage(wxWindow* win, const wxString& text,
bool bSelect, int imageId)
{
return TRUE;
};
// ----------------------------------------------------------------------------
// wxNotebook callbacks
// ----------------------------------------------------------------------------
wxWindow *wxNotebook::GetPage( int page ) const
// @@@ OnSize() is used for setting the font when it's called for the first
// time because doing it in ::Create() doesn't work (for unknown reasons)
void wxNotebook::OnSize(wxSizeEvent& event)
{
return NULL;
};
static bool s_bFirstTime = TRUE;
if ( s_bFirstTime ) {
// TODO: any first-time-size processing.
s_bFirstTime = FALSE;
}
void wxNotebook::AddChild( wxWindow *win )
// TODO: all this may or may not be necessary for your platform
// emulate page change (it's esp. important to do it first time because
// otherwise our page would stay invisible)
int nSel = m_nSelection;
m_nSelection = -1;
SetSelection(nSel);
// fit the notebook page to the tab control's display area
int w, hl
GetSize(&w, &h);
uint nCount = m_aPages.Count();
for ( uint nPage = 0; nPage < nCount; nPage++ ) {
wxNotebookPage *pPage = m_aPages[nPage];
pPage->SetSize(0, 0, w, h);
if ( pPage->GetAutoLayout() )
pPage->Layout();
}
// Processing continues to next OnSize
event.Skip();
}
void wxNotebook::OnSelChange(wxNotebookEvent& event)
{
};
// is it our tab control?
if ( event.GetEventObject() == this )
ChangePage(event.GetOldSelection(), event.GetSelection());
// we want to give others a chance to process this message as well
event.Skip();
}
void wxNotebook::OnSetFocus(wxFocusEvent& event)
{
// set focus to the currently selected page if any
if ( m_nSelection != -1 )
m_aPages[m_nSelection]->SetFocus();
event.Skip();
}
void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
{
if ( event.IsWindowChange() ) {
// change pages
AdvanceSelection(event.GetDirection());
}
else {
// pass to the parent
if ( GetParent() ) {
event.SetCurrentFocus(this);
GetParent()->ProcessEvent(event);
}
}
}
// ----------------------------------------------------------------------------
// wxNotebook base class virtuals
// ----------------------------------------------------------------------------
// override these 2 functions to do nothing: everything is done in OnSize
void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
void wxNotebook::SetConstraintSizes(bool /* recurse */)
{
// don't set the sizes of the pages - their correct size is not yet known
wxControl::SetConstraintSizes(FALSE);
}
bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
bool wxNotebook::DoPhase(int /* nPhase */)
{
return TRUE;
}
//-----------------------------------------------------------------------------
// wxNotebookEvent
//-----------------------------------------------------------------------------
void wxNotebook::Command(wxCommandEvent& event)
{
wxFAIL_MSG("wxNotebook::Command not implemented");
}
// ----------------------------------------------------------------------------
// wxNotebook helper functions
// ----------------------------------------------------------------------------
// hide the currently active panel and show the new one
void wxNotebook::ChangePage(int nOldSel, int nSel)
{
wxASSERT( nOldSel != nSel ); // impossible
if ( nOldSel != -1 ) {
m_aPages[nOldSel]->Show(FALSE);
}
wxNotebookPage *pPage = m_aPages[nSel];
pPage->Show(TRUE);
pPage->SetFocus();
m_nSelection = nSel;
}
IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)

130
src/qt/palette.cpp
View File

@@ -1,103 +1,91 @@
/////////////////////////////////////////////////////////////////////////////
// Name: palette.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxPalette
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "palette.h"
#endif
#include "wx/palette.h"
//-----------------------------------------------------------------------------
// wxPalette
//-----------------------------------------------------------------------------
class wxPaletteRefData: public wxObjectRefData
{
public:
wxPaletteRefData(void);
~wxPaletteRefData(void);
};
wxPaletteRefData::wxPaletteRefData(void)
{
};
wxPaletteRefData::~wxPaletteRefData(void)
{
};
//-----------------------------------------------------------------------------
#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
#endif
wxPalette::wxPalette(void)
/*
* Palette
*
*/
wxPaletteRefData::wxPaletteRefData()
{
};
// TODO
}
wxPaletteRefData::~wxPaletteRefData()
{
// TODO
}
wxPalette::wxPalette()
{
}
wxPalette::wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
m_refData = new wxPaletteRefData();
Create(n, red, green, blue);
};
}
wxPalette::wxPalette( const wxPalette& palette )
wxPalette::~wxPalette()
{
Ref( palette );
};
}
wxPalette::wxPalette( const wxPalette* palette )
bool wxPalette::FreeResource(bool force)
{
UnRef();
if (palette) Ref( *palette );
};
wxPalette::~wxPalette(void)
if ( M_PALETTEDATA && M_PALETTEDATA->m_hPalette)
{
};
wxPalette& wxPalette::operator = ( const wxPalette& palette )
{
if (*this == palette) return (*this);
Ref( palette );
return *this;
};
bool wxPalette::operator == ( const wxPalette& palette )
{
return m_refData == palette.m_refData;
};
bool wxPalette::operator != ( const wxPalette& palette )
{
return m_refData != palette.m_refData;
};
bool wxPalette::Ok(void) const
{
return (m_refData);
};
DeleteObject((HPALETTE)M_PALETTEDATA->m_hPalette);
}
return TRUE;
}
bool wxPalette::Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
};
UnRef();
m_refData = new wxPaletteRefData;
// TODO
return FALSE;
}
int wxPalette::GetPixel(const unsigned char red, const unsigned char green, const unsigned char blue) const
{
};
if ( !m_refData )
return FALSE;
bool wxPalette::GetRGB( int pixel, unsigned char *red, unsigned char *green, unsigned char *blue ) const
// TODO
return FALSE;
}
bool wxPalette::GetRGB(int index, unsigned char *red, unsigned char *green, unsigned char *blue) const
{
};
if ( !m_refData )
return FALSE;
if (index < 0 || index > 255)
return FALSE;
// TODO
return FALSE;
}

341
src/qt/pen.cpp
View File

@@ -1,204 +1,229 @@
/////////////////////////////////////////////////////////////////////////////
// Name: pen.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxPen
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "pen.h"
#endif
#include "wx/setup.h"
#include "wx/utils.h"
#include "wx/pen.h"
//-----------------------------------------------------------------------------
// wxPen
//-----------------------------------------------------------------------------
class wxPenRefData: public wxObjectRefData
{
public:
wxPenRefData(void);
int m_width;
int m_style;
int m_joinStyle;
int m_capStyle;
wxColour m_colour;
};
wxPenRefData::wxPenRefData(void)
{
m_width = 1;
m_style = wxSOLID;
m_joinStyle = wxJOIN_ROUND;
m_capStyle = wxCAP_ROUND;
};
//-----------------------------------------------------------------------------
#define M_PENDATA ((wxPenRefData *)m_refData)
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
#endif
wxPen::wxPen(void)
wxPenRefData::wxPenRefData()
{
if (wxThePenList) wxThePenList->AddPen( this );
};
m_style = wxSOLID;
m_width = 1;
m_join = wxJOIN_ROUND ;
m_cap = wxCAP_ROUND ;
m_nbDash = 0 ;
m_dash = 0 ;
/* TODO: null data
m_hPen = 0;
*/
}
wxPen::wxPen( const wxColour &colour, int width, int style )
wxPenRefData::wxPenRefData(const wxPenRefData& data)
{
m_style = data.m_style;
m_width = data.m_width;
m_join = data.m_join;
m_cap = data.m_cap;
m_nbDash = data.m_nbDash;
m_dash = data.m_dash;
m_colour = data.m_colour;
/* TODO: null data
m_hPen = 0;
*/
}
wxPenRefData::~wxPenRefData()
{
// TODO: delete data
}
// Pens
wxPen::wxPen()
{
if ( wxThePenList )
wxThePenList->AddPen(this);
}
wxPen::~wxPen()
{
if (wxThePenList)
wxThePenList->RemovePen(this);
}
// Should implement Create
wxPen::wxPen(const wxColour& col, int Width, int Style)
{
m_refData = new wxPenRefData;
M_PENDATA->m_colour = col;
M_PENDATA->m_width = Width;
M_PENDATA->m_style = Style;
M_PENDATA->m_join = wxJOIN_ROUND ;
M_PENDATA->m_cap = wxCAP_ROUND ;
M_PENDATA->m_nbDash = 0 ;
M_PENDATA->m_dash = 0 ;
RealizeResource();
if ( wxThePenList )
wxThePenList->AddPen(this);
}
wxPen::wxPen(const wxBitmap& stipple, int Width)
{
m_refData = new wxPenRefData;
M_PENDATA->m_stipple = stipple;
M_PENDATA->m_width = Width;
M_PENDATA->m_style = wxSTIPPLE;
M_PENDATA->m_join = wxJOIN_ROUND ;
M_PENDATA->m_cap = wxCAP_ROUND ;
M_PENDATA->m_nbDash = 0 ;
M_PENDATA->m_dash = 0 ;
RealizeResource();
if ( wxThePenList )
wxThePenList->AddPen(this);
}
wxPen::wxPen(const wxString& col, int Width, int Style)
{
m_refData = new wxPenRefData;
M_PENDATA->m_colour = col;
M_PENDATA->m_width = Width;
M_PENDATA->m_style = Style;
M_PENDATA->m_join = wxJOIN_ROUND ;
M_PENDATA->m_cap = wxCAP_ROUND ;
M_PENDATA->m_nbDash = 0 ;
M_PENDATA->m_dash = 0 ;
RealizeResource();
if ( wxThePenList )
wxThePenList->AddPen(this);
}
void wxPen::Unshare()
{
// Don't change shared data
if (!m_refData)
{
m_refData = new wxPenRefData();
M_PENDATA->m_width = width;
M_PENDATA->m_style = style;
M_PENDATA->m_colour = colour;
if (wxThePenList) wxThePenList->AddPen( this );
};
wxPen::wxPen( const wxString &colourName, int width, int style )
{
m_refData = new wxPenRefData();
M_PENDATA->m_width = width;
M_PENDATA->m_style = style;
M_PENDATA->m_colour = colourName;
if (wxThePenList) wxThePenList->AddPen( this );
};
wxPen::wxPen( const wxPen& pen )
{
Ref( pen );
if (wxThePenList) wxThePenList->AddPen( this );
};
wxPen::wxPen( const wxPen* pen )
}
else
{
wxPenRefData* ref = new wxPenRefData(*(wxPenRefData*)m_refData);
UnRef();
if (pen) Ref( *pen );
if (wxThePenList) wxThePenList->AddPen( this );
};
m_refData = ref;
}
}
wxPen::~wxPen(void)
void wxPen::SetColour(const wxColour& col)
{
if (wxThePenList) wxThePenList->RemovePen( this );
};
Unshare();
wxPen& wxPen::operator = ( const wxPen& pen )
M_PENDATA->m_colour = col;
RealizeResource();
}
void wxPen::SetColour(const wxString& col)
{
if (*this == pen) return (*this);
Ref( pen );
return *this;
};
Unshare();
bool wxPen::operator == ( const wxPen& pen )
M_PENDATA->m_colour = col;
RealizeResource();
}
void wxPen::SetColour(const unsigned char r, const unsigned char g, const unsigned char b)
{
return m_refData == pen.m_refData;
};
Unshare();
bool wxPen::operator != ( const wxPen& pen )
M_PENDATA->m_colour.Set(r, g, b);
RealizeResource();
}
void wxPen::SetWidth(int Width)
{
return m_refData != pen.m_refData;
};
Unshare();
void wxPen::SetColour( const wxColour &colour )
M_PENDATA->m_width = Width;
RealizeResource();
}
void wxPen::SetStyle(int Style)
{
if (!m_refData)
m_refData = new wxPenRefData();
Unshare();
M_PENDATA->m_colour = colour;
};
M_PENDATA->m_style = Style;
void wxPen::SetColour( const wxString &colourName )
RealizeResource();
}
void wxPen::SetStipple(const wxBitmap& Stipple)
{
if (!m_refData)
m_refData = new wxPenRefData();
Unshare();
M_PENDATA->m_colour = colourName;
};
M_PENDATA->m_stipple = Stipple;
M_PENDATA->m_style = wxSTIPPLE;
void wxPen::SetColour( int red, int green, int blue )
RealizeResource();
}
void wxPen::SetDashes(int nb_dashes, const wxDash *Dash)
{
if (!m_refData)
m_refData = new wxPenRefData();
Unshare();
M_PENDATA->m_colour.Set( red, green, blue );
};
M_PENDATA->m_nbDash = nb_dashes;
M_PENDATA->m_dash = (wxDash *)Dash;
void wxPen::SetCap( int capStyle )
RealizeResource();
}
void wxPen::SetJoin(int Join)
{
if (!m_refData)
m_refData = new wxPenRefData();
Unshare();
M_PENDATA->m_capStyle = capStyle;
};
M_PENDATA->m_join = Join;
void wxPen::SetJoin( int joinStyle )
RealizeResource();
}
void wxPen::SetCap(int Cap)
{
if (!m_refData)
m_refData = new wxPenRefData();
Unshare();
M_PENDATA->m_joinStyle = joinStyle;
};
M_PENDATA->m_cap = Cap;
void wxPen::SetStyle( int style )
RealizeResource();
}
bool wxPen::RealizeResource()
{
if (!m_refData)
m_refData = new wxPenRefData();
// TODO: create actual pen
return FALSE;
}
M_PENDATA->m_style = style;
};
void wxPen::SetWidth( int width )
{
if (!m_refData)
m_refData = new wxPenRefData();
M_PENDATA->m_width = width;
};
int wxPen::GetCap(void) const
{
return M_PENDATA->m_capStyle;
};
int wxPen::GetJoin(void) const
{
if (!m_refData)
return 0;
else
return M_PENDATA->m_joinStyle;
};
int wxPen::GetStyle(void) const
{
if (!m_refData)
return 0;
else
return M_PENDATA->m_style;
};
int wxPen::GetWidth(void) const
{
if (!m_refData)
return 0;
else
return M_PENDATA->m_width;
};
wxColour &wxPen::GetColour(void) const
{
if (!m_refData)
return wxNullColour;
else
return M_PENDATA->m_colour;
};
bool wxPen::Ok(void) const
{
return (m_refData);
};

209
src/qt/radiobox.cpp
View File

@@ -1,133 +1,194 @@
/////////////////////////////////////////////////////////////////////////////
// Name: radiobox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxRadioBox
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "radiobox.h"
#endif
#include "wx/radiobox.h"
#include "wx/dialog.h"
#include "wx/frame.h"
//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------
extern bool g_blockEventsOnDrag;
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
#endif
wxRadioBox::wxRadioBox(void)
// Radio box item
wxRadioBox::wxRadioBox()
{
};
wxRadioBox::wxRadioBox( wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
int majorDim, long style,
const wxString &name )
{
Create( parent, id, title, pos, size, n, choices, majorDim, style, name );
};
m_selectedButton = -1;
m_noItems = 0;
m_noRowsOrCols = 0;
m_majorDim = 0 ;
}
bool wxRadioBox::Create(wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint& pos, const wxSize& size,
int n, const wxString choices[],
int WXUNUSED(majorDim), long style,
const wxString &name )
int majorDim, long style,
const wxValidator& val, const wxString& name)
{
return TRUE;
};
m_selectedButton = -1;
m_noItems = n;
bool wxRadioBox::Show( bool show )
SetName(name);
SetValidator(val);
parent->AddChild(this);
m_windowStyle = (long&)style;
if (id == -1)
m_windowId = NewControlId();
else
m_windowId = id;
m_noRowsOrCols = majorDim;
if (majorDim==0)
m_majorDim = n ;
else
m_majorDim = majorDim ;
// TODO create radiobox
return FALSE;
}
wxRadioBox::~wxRadioBox()
{
wxWindow::Show( show );
return TRUE;
};
// TODO
}
wxString wxRadioBox::GetLabel(int item) const
{
// TODO
return wxString("");
}
void wxRadioBox::SetLabel(int item, const wxString& label)
{
// TODO
}
int wxRadioBox::FindString(const wxString& s) const
{
// TODO
return -1;
};
}
void wxRadioBox::SetSelection(int n)
{
};
if ((n < 0) || (n >= m_noItems))
return;
// TODO
int wxRadioBox::GetSelection(void) const
m_selectedButton = n;
}
// Get single selection, for single choice list items
int wxRadioBox::GetSelection() const
{
return -1;
};
return m_selectedButton;
}
// Find string for position
wxString wxRadioBox::GetString(int n) const
{
};
// TODO
return wxString("");
}
wxString wxRadioBox::GetLabel(void) const
void wxRadioBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
return wxControl::GetLabel();
};
// TODO
}
void wxRadioBox::SetLabel( const wxString& WXUNUSED(label) )
void wxRadioBox::GetSize(int *width, int *height) const
{
};
// TODO
}
void wxRadioBox::SetLabel( int WXUNUSED(item), const wxString& WXUNUSED(label) )
void wxRadioBox::GetPosition(int *x, int *y) const
{
};
// TODO
}
void wxRadioBox::SetLabel( int WXUNUSED(item), wxBitmap *WXUNUSED(bitmap) )
wxString wxRadioBox::GetLabel() const
{
};
// TODO
return wxString("");
}
wxString wxRadioBox::GetLabel( int WXUNUSED(item) ) const
void wxRadioBox::SetLabel(const wxString& label)
{
return "";
};
// TODO
}
void wxRadioBox::Enable( bool WXUNUSED(enable) )
void wxRadioBox::SetFocus()
{
};
// TODO
}
void wxRadioBox::Enable( int WXUNUSED(item), bool WXUNUSED(enable) )
bool wxRadioBox::Show(bool show)
{
};
// TODO
return FALSE;
}
void wxRadioBox::Show( int WXUNUSED(item), bool WXUNUSED(show) )
// Enable a specific button
void wxRadioBox::Enable(int item, bool enable)
{
};
// TODO
}
wxString wxRadioBox::GetStringSelection(void) const
// Enable all controls
void wxRadioBox::Enable(bool enable)
{
return "";
};
wxControl::Enable(enable);
// TODO
}
// Show a specific button
void wxRadioBox::Show(int item, bool show)
{
// TODO
}
// For single selection items only
wxString wxRadioBox::GetStringSelection () const
{
int sel = GetSelection ();
if (sel > -1)
return this->GetString (sel);
else
return wxString("");
}
bool wxRadioBox::SetStringSelection (const wxString& s)
{
int sel = FindString (s);
if (sel > -1)
{
SetSelection (sel);
return TRUE;
};
}
else
return FALSE;
}
int wxRadioBox::Number(void) const
void wxRadioBox::Command (wxCommandEvent & event)
{
return 0;
};
SetSelection (event.m_commandInt);
ProcessCommand (event);
}
int wxRadioBox::GetNumberOfRowsOrCols(void) const
{
return 1;
};
void wxRadioBox::SetNumberOfRowsOrCols( int WXUNUSED(n) )
{
};

63
src/qt/radiobut.cpp
View File

@@ -1,17 +1,68 @@
/////////////////////////////////////////////////////////////////////////////
// Name: radiobut.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxRadioButton
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "radiobut.h"
#endif
#include "wx/radiobut.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxRadioButton, wxControl)
#endif
bool wxRadioButton::Create(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
SetName(name);
SetValidator(validator);
if (parent) parent->AddChild(this);
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
m_windowStyle = style ;
// TODO create radiobutton
return FALSE;
}
void wxRadioButton::SetLabel(const wxString& label)
{
// TODO
}
void wxRadioButton::SetValue(bool value)
{
// TODO
}
// Get single selection, for single choice list items
bool wxRadioButton::GetValue() const
{
// TODO
return FALSE;
}
void wxRadioButton::Command (wxCommandEvent & event)
{
SetValue ( (event.m_commandInt != 0) );
ProcessCommand (event);
}

426
src/qt/region.cpp
View File

@@ -1,163 +1,373 @@
/////////////////////////////////////////////////////////////////////////////
// Name: region.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/98
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// File: region.cpp
// Purpose: Region class
// Author: Markus Holzem/Julian Smart/AUTHOR
// Created: Fri Oct 24 10:46:34 MET 1997
// RCS-ID: $Id$
// Copyright: (c) 1997 Markus Holzem/Julian Smart/AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "region.h"
#endif
#include "wx/region.h"
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "wx/msw/region.h"
#include "wx/gdicmn.h"
#include <windows.h>
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
#endif
//-----------------------------------------------------------------------------
// wxRegionRefData implementation
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxRegionRefData : public wxGDIRefData {
public:
wxRegionRefData()
{
}
wxRegionRefData(const wxRegionRefData& data)
{
// TODO
}
~wxRegionRefData()
{
// TODO
}
HRGN m_region;
};
//-----------------------------------------------------------------------------
// wxRegion
//-----------------------------------------------------------------------------
class wxRegionRefData: public wxObjectRefData
/*!
* Create an empty region.
*/
wxRegion::wxRegion()
{
public:
wxRegionRefData(void);
~wxRegionRefData(void);
public:
};
wxRegionRefData::wxRegionRefData(void)
{
};
wxRegionRefData::~wxRegionRefData(void)
{
};
//-----------------------------------------------------------------------------
#define M_REGIONDATA ((wxRegionRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxRegion,wxGDIObject);
m_refData = new wxRegionRefData;
// TODO create empty region
}
wxRegion::wxRegion(long x, long y, long w, long h)
{
m_refData = new wxRegionRefData();
};
m_refData = new wxRegionRefData;
// TODO create rect region
}
wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
{
m_refData = new wxRegionRefData();
};
m_refData = new wxRegionRefData;
// TODO create rect region
}
wxRegion::wxRegion(const wxRect& rect)
{
m_refData = new wxRegionRefData();
};
m_refData = new wxRegionRefData;
// TODO create rect region
}
wxRegion::wxRegion(void)
/*!
* Destroy the region.
*/
wxRegion::~wxRegion()
{
m_refData = new wxRegionRefData();
};
// m_refData unrefed in ~wxObject
}
wxRegion::~wxRegion(void)
{
};
//-----------------------------------------------------------------------------
//# Modify region
//-----------------------------------------------------------------------------
void wxRegion::Clear(void)
//! Clear current region
void wxRegion::Clear()
{
UnRef();
}
//! Combine rectangle (x, y, w, h) with this.
bool wxRegion::Combine(long x, long y, long width, long height, wxRegionOp op)
{
// Don't change shared data
if (!m_refData) {
m_refData = new wxRegionRefData();
};
} else if (m_refData->GetRefCount() > 1) {
wxRegionRefData* ref = (wxRegionRefData*)m_refData;
UnRef();
m_refData = new wxRegionRefData(*ref);
}
// If ref count is 1, that means it's 'ours' anyway so no action.
bool wxRegion::Union( long x, long y, long width, long height )
// TODO create rect region
int mode = 0; // TODO platform-specific code
switch (op)
{
return TRUE;
};
case wxRGN_AND:
// TODO
break ;
case wxRGN_OR:
// TODO
break ;
case wxRGN_XOR:
// TODO
break ;
case wxRGN_DIFF:
// TODO
break ;
case wxRGN_COPY:
default:
// TODO
break ;
}
bool wxRegion::Union( const wxRect& rect )
// TODO do combine region
return FALSE;
}
//! Union /e region with this.
bool wxRegion::Combine(const wxRegion& region, wxRegionOp op)
{
return TRUE;
};
if (region.Empty())
return FALSE;
bool wxRegion::Union( const wxRegion& region )
// Don't change shared data
if (!m_refData) {
m_refData = new wxRegionRefData();
} else if (m_refData->GetRefCount() > 1) {
wxRegionRefData* ref = (wxRegionRefData*)m_refData;
UnRef();
m_refData = new wxRegionRefData(*ref);
}
int mode = 0; // TODO platform-specific code
switch (op)
{
return TRUE;
};
case wxRGN_AND:
// TODO
break ;
case wxRGN_OR:
// TODO
break ;
case wxRGN_XOR:
// TODO
break ;
case wxRGN_DIFF:
// TODO
break ;
case wxRGN_COPY:
default:
// TODO
break ;
}
bool wxRegion::Intersect( long x, long y, long width, long height )
// TODO combine region
return FALSE;
}
bool wxRegion::Combine(const wxRect& rect, wxRegionOp op)
{
return TRUE;
};
return Combine(rect.GetLeft(), rect.GetTop(), rect.GetWidth(), rect.GetHeight(), op);
}
bool wxRegion::Intersect( const wxRect& rect )
{
return TRUE;
};
bool wxRegion::Intersect( const wxRegion& region )
{
return TRUE;
};
bool wxRegion::Subtract( long x, long y, long width, long height )
{
return TRUE;
};
bool wxRegion::Subtract( const wxRect& rect )
{
return TRUE;
};
bool wxRegion::Subtract( const wxRegion& region )
{
return TRUE;
};
bool wxRegion::Xor( long x, long y, long width, long height )
{
return TRUE;
};
bool wxRegion::Xor( const wxRect& rect )
{
return TRUE;
};
bool wxRegion::Xor( const wxRegion& region )
{
return TRUE;
};
//-----------------------------------------------------------------------------
//# Information on region
//-----------------------------------------------------------------------------
// Outer bounds of region
void wxRegion::GetBox(long& x, long& y, long&w, long &h) const
{
x = 0;
y = 0;
w = -1;
h = -1;
};
if (m_refData) {
// TODO get box
} else {
x = y = w = h = 0;
}
}
wxRect wxRegion::GetBox(void) const
wxRect wxRegion::GetBox() const
{
return wxRect( 0, 0, -1, -1 );
};
long x, y, w, h;
GetBox(x, y, w, h);
return wxRect(x, y, w, h);
}
bool wxRegion::Empty(void) const
// Is region empty?
bool wxRegion::Empty() const
{
};
// TODO
return FALSE;
}
//-----------------------------------------------------------------------------
//# Tests
//-----------------------------------------------------------------------------
// Does the region contain the point (x,y)?
wxRegionContain wxRegion::Contains(long x, long y) const
{
if (!m_refData)
return wxOutRegion;
};
// TODO. Return wxInRegion if within region.
if (0)
return wxInRegion;
return wxOutRegion;
}
// Does the region contain the point pt?
wxRegionContain wxRegion::Contains(const wxPoint& pt) const
{
if (!m_refData)
return wxOutRegion;
// TODO. Return wxInRegion if within region.
if (0)
return wxInRegion;
else
return wxOutRegion;
}
// Does the region contain the rectangle (x, y, w, h)?
wxRegionContain wxRegion::Contains(long x, long y, long w, long h) const
{
if (!m_refData)
return wxOutRegion;
};
// TODO. Return wxInRegion if within region.
if (0)
return wxInRegion;
else
return wxOutRegion;
}
// Does the region contain the rectangle rect
wxRegionContain wxRegion::Contains(const wxRect& rect) const
{
if (!m_refData)
return wxOutRegion;
long x, y, w, h;
x = rect.x;
y = rect.y;
w = rect.GetWidth();
h = rect.GetHeight();
return Contains(x, y, w, h);
}
///////////////////////////////////////////////////////////////////////////////
// //
// wxRegionIterator //
// //
///////////////////////////////////////////////////////////////////////////////
/*!
* Initialize empty iterator
*/
wxRegionIterator::wxRegionIterator() : m_current(0), m_numRects(0), m_rects(NULL)
{
}
wxRegionIterator::~wxRegionIterator()
{
if (m_rects)
delete[] m_rects;
}
/*!
* Initialize iterator for region
*/
wxRegionIterator::wxRegionIterator(const wxRegion& region)
{
m_rects = NULL;
Reset(region);
}
/*!
* Reset iterator for a new /e region.
*/
void wxRegionIterator::Reset(const wxRegion& region)
{
m_current = 0;
m_region = region;
if (m_rects)
delete[] m_rects;
m_rects = NULL;
if (m_region.Empty())
m_numRects = 0;
else
{
// TODO create m_rects and fill with rectangles for this region
m_numRects = 0;
}
}
/*!
* Increment iterator. The rectangle returned is the one after the
* incrementation.
*/
void wxRegionIterator::operator ++ ()
{
if (m_current < m_numRects)
++m_current;
}
/*!
* Increment iterator. The rectangle returned is the one before the
* incrementation.
*/
void wxRegionIterator::operator ++ (int)
{
if (m_current < m_numRects)
++m_current;
}
long wxRegionIterator::GetX() const
{
if (m_current < m_numRects)
return m_rects[m_current].x;
return 0;
}
long wxRegionIterator::GetY() const
{
if (m_current < m_numRects)
return m_rects[m_current].y;
return 0;
}
long wxRegionIterator::GetW() const
{
if (m_current < m_numRects)
return m_rects[m_current].width ;
return 0;
}
long wxRegionIterator::GetH() const
{
if (m_current < m_numRects)
return m_rects[m_current].height;
return 0;
}

124
src/qt/scrolbar.cpp
View File

@@ -1,102 +1,78 @@
/////////////////////////////////////////////////////////////////////////////
// Name: scrolbar.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxScrollBar
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "scrolbar.h"
#endif
#include "wx/scrolbar.h"
#include "wx/utils.h"
//-----------------------------------------------------------------------------
// wxScrollBar
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
wxScrollBar::wxScrollBar(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
Create( parent, id, pos, size, style, name );
};
wxScrollBar::~wxScrollBar(void)
{
};
#endif
// Scrollbar
bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
if (!parent)
return FALSE;
parent->AddChild(this);
SetName(name);
SetValidator(validator);
m_windowStyle = style;
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
// TODO create scrollbar
return TRUE;
};
}
int wxScrollBar::GetPosition(void) const
wxScrollBar::~wxScrollBar()
{
};
int wxScrollBar::GetThumbSize() const
{
};
int wxScrollBar::GetPageSize() const
{
};
int wxScrollBar::GetRange() const
{
};
}
void wxScrollBar::SetPosition(int viewStart)
{
};
// TODO
}
int wxScrollBar::GetPosition() const
{
// TODO
return 0;
}
void wxScrollBar::SetScrollbar(int position, int thumbSize, int range, int pageSize,
bool WXUNUSED(refresh) )
bool refresh)
{
};
m_viewSize = pageSize;
m_pageSize = thumbSize;
m_objectSize = range;
// Backward compatibility
int wxScrollBar::GetValue(void) const
// TODO
}
void wxScrollBar::Command(wxCommandEvent& event)
{
return GetPosition();
};
void wxScrollBar::SetValue( int viewStart )
{
SetPosition( viewStart );
};
void wxScrollBar::GetValues( int *viewStart, int *viewLength, int *objectLength, int *pageLength ) const
{
};
int wxScrollBar::GetViewLength() const
{
};
int wxScrollBar::GetObjectLength() const
{
};
void wxScrollBar::SetPageSize( int pageLength )
{
};
void wxScrollBar::SetObjectLength( int objectLength )
{
};
void wxScrollBar::SetViewLength( int viewLength )
{
};
SetValue(event.m_commandInt);
ProcessCommand(event);
}

249
src/qt/settings.cpp
View File

@@ -1,144 +1,151 @@
/////////////////////////////////////////////////////////////////////////////
// Name: settings.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxSettings
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "settings.h"
#endif
#include "wx/settings.h"
/*
#define wxSYS_COLOUR_SCROLLBAR 0
#define wxSYS_COLOUR_BACKGROUND 1
#define wxSYS_COLOUR_ACTIVECAPTION 2
#define wxSYS_COLOUR_INACTIVECAPTION 3
#define wxSYS_COLOUR_MENU 4
#define wxSYS_COLOUR_WINDOW 5
#define wxSYS_COLOUR_WINDOWFRAME 6
#define wxSYS_COLOUR_MENUTEXT 7
#define wxSYS_COLOUR_WINDOWTEXT 8
#define wxSYS_COLOUR_CAPTIONTEXT 9
#define wxSYS_COLOUR_ACTIVEBORDER 10
#define wxSYS_COLOUR_INACTIVEBORDER 11
#define wxSYS_COLOUR_APPWORKSPACE 12
#define wxSYS_COLOUR_HIGHLIGHT 13
#define wxSYS_COLOUR_HIGHLIGHTTEXT 14
#define wxSYS_COLOUR_BTNFACE 15
#define wxSYS_COLOUR_BTNSHADOW 16
#define wxSYS_COLOUR_GRAYTEXT 17
#define wxSYS_COLOUR_BTNTEXT 18
#define wxSYS_COLOUR_INACTIVECAPTIONTEXT 19
#define wxSYS_COLOUR_BTNHIGHLIGHT 20
#define wxSYS_COLOUR_3DDKSHADOW 21
#define wxSYS_COLOUR_3DLIGHT 22
#define wxSYS_COLOUR_INFOTEXT 23
#define wxSYS_COLOUR_INFOBK 24
#define wxSYS_COLOUR_DESKTOP wxSYS_COLOUR_BACKGROUND
#define wxSYS_COLOUR_3DFACE wxSYS_COLOUR_BTNFACE
#define wxSYS_COLOUR_3DSHADOW wxSYS_COLOUR_BTNSHADOW
#define wxSYS_COLOUR_3DHIGHLIGHT wxSYS_COLOUR_BTNHIGHLIGHT
#define wxSYS_COLOUR_3DHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
#define wxSYS_COLOUR_BTNHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
*/
#define SHIFT (8*(sizeof(short int)-sizeof(char)))
wxColour *g_systemBtnFaceColour = NULL;
wxColour *g_systemBtnShadowColour = NULL;
wxColour *g_systemBtnHighlightColour = NULL;
wxColour *g_systemHighlightColour = NULL;
wxColour wxSystemSettings::GetSystemColour(int index)
{
switch (index)
{
case wxSYS_COLOUR_SCROLLBAR:
case wxSYS_COLOUR_BACKGROUND:
case wxSYS_COLOUR_ACTIVECAPTION:
case wxSYS_COLOUR_INACTIVECAPTION:
case wxSYS_COLOUR_MENU:
case wxSYS_COLOUR_WINDOW:
case wxSYS_COLOUR_WINDOWFRAME:
case wxSYS_COLOUR_ACTIVEBORDER:
case wxSYS_COLOUR_INACTIVEBORDER:
case wxSYS_COLOUR_BTNFACE:
{
return *g_systemBtnFaceColour;
};
case wxSYS_COLOUR_BTNSHADOW:
{
return *g_systemBtnShadowColour;
};
case wxSYS_COLOUR_GRAYTEXT:
case wxSYS_COLOUR_BTNHIGHLIGHT:
{
return *g_systemBtnHighlightColour;
};
case wxSYS_COLOUR_HIGHLIGHT:
{
return *g_systemHighlightColour;
};
case wxSYS_COLOUR_MENUTEXT:
case wxSYS_COLOUR_WINDOWTEXT:
case wxSYS_COLOUR_CAPTIONTEXT:
case wxSYS_COLOUR_INACTIVECAPTIONTEXT:
case wxSYS_COLOUR_INFOTEXT:
{
return *wxBLACK;
};
case wxSYS_COLOUR_HIGHLIGHTTEXT:
{
return *wxWHITE;
};
case wxSYS_COLOUR_INFOBK:
case wxSYS_COLOUR_APPWORKSPACE:
{
return *wxWHITE; // ?
};
};
return *wxWHITE;
};
wxFont *g_systemFont = NULL;
// TODO
return col;
}
wxFont wxSystemSettings::GetSystemFont(int index)
{
switch (index)
{
case wxSYS_OEM_FIXED_FONT:
case wxSYS_ANSI_FIXED_FONT:
case wxSYS_SYSTEM_FIXED_FONT:
{
return *wxNORMAL_FONT;
};
case wxSYS_ANSI_VAR_FONT:
case wxSYS_SYSTEM_FONT:
case wxSYS_DEVICE_DEFAULT_FONT:
case wxSYS_DEFAULT_GUI_FONT:
{
return *g_systemFont;
};
};
return wxNullFont;
};
// TODO
return wxFont;
}
// Get a system metric, e.g. scrollbar size
int wxSystemSettings::GetSystemMetric(int index)
{
switch ( index)
{
case wxSYS_SCREEN_X: return 0;
case wxSYS_SCREEN_Y: return 0;
};
case wxSYS_MOUSE_BUTTONS:
// TODO
return 0;
};
case wxSYS_BORDER_X:
// TODO
return 0;
case wxSYS_BORDER_Y:
// TODO
return 0;
case wxSYS_CURSOR_X:
// TODO
return 0;
case wxSYS_CURSOR_Y:
// TODO
return 0;
case wxSYS_DCLICK_X:
// TODO
return 0;
case wxSYS_DCLICK_Y:
// TODO
return 0;
case wxSYS_DRAG_X:
// TODO
return 0;
case wxSYS_DRAG_Y:
// TODO
return 0;
case wxSYS_EDGE_X:
// TODO
return 0;
case wxSYS_EDGE_Y:
// TODO
return 0;
case wxSYS_HSCROLL_ARROW_X:
// TODO
return 0;
case wxSYS_HSCROLL_ARROW_Y:
// TODO
return 0;
case wxSYS_HTHUMB_X:
// TODO
return 0;
case wxSYS_ICON_X:
// TODO
return 0;
case wxSYS_ICON_Y:
// TODO
return 0;
case wxSYS_ICONSPACING_X:
// TODO
return 0;
case wxSYS_ICONSPACING_Y:
// TODO
return 0;
case wxSYS_WINDOWMIN_X:
// TODO
return 0;
case wxSYS_WINDOWMIN_Y:
// TODO
return 0;
case wxSYS_SCREEN_X:
// TODO
return 0;
case wxSYS_SCREEN_Y:
// TODO
return 0;
case wxSYS_FRAMESIZE_X:
// TODO
return 0;
case wxSYS_FRAMESIZE_Y:
// TODO
return 0;
case wxSYS_SMALLICON_X:
// TODO
return 0;
case wxSYS_SMALLICON_Y:
// TODO
return 0;
case wxSYS_HSCROLL_Y:
// TODO
return 0;
case wxSYS_VSCROLL_X:
// TODO
return 0;
case wxSYS_VSCROLL_ARROW_X:
// TODO
return 0;
case wxSYS_VSCROLL_ARROW_Y:
// TODO
return 0;
case wxSYS_VTHUMB_Y:
// TODO
return 0;
case wxSYS_CAPTION_Y:
// TODO
return 0;
case wxSYS_MENU_Y:
// TODO
return 0;
case wxSYS_NETWORK_PRESENT:
// TODO
return 0;
case wxSYS_PENWINDOWS_PRESENT:
// TODO
return 0;
case wxSYS_SHOW_SOUNDS:
// TODO
return 0;
case wxSYS_SWAP_BUTTONS:
// TODO
return 0;
default:
return 0;
}
return 0;
}

244
src/qt/slider.cpp
View File

@@ -1,147 +1,185 @@
/////////////////////////////////////////////////////////////////////////////
// Name: slider.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxSlider
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "slider.h"
#endif
#include "wx/slider.h"
#include "wx/utils.h"
//-----------------------------------------------------------------------------
// wxSlider
//-----------------------------------------------------------------------------
#include "wx/msw/slider.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl)
#endif
wxSlider::wxSlider(void)
// Slider
wxSlider::wxSlider()
{
};
wxSlider::wxSlider( wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos, const wxSize& size,
long style,
/* const wxValidator& validator = wxDefaultValidator, */
const wxString& name )
{
Create( parent, id, value, minValue, maxValue,
pos, size, style, name );
};
wxSlider::~wxSlider(void)
{
};
m_pageSize = 1;
m_lineSize = 1;
m_rangeMax = 0;
m_rangeMin = 0;
m_tickFreq = 0;
}
bool wxSlider::Create(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos, const wxSize& size,
long style,
/* const wxValidator& validator = wxDefaultValidator, */
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
SetName(name);
SetValidator(validator);
int wxSlider::GetValue(void) const
if (parent) parent->AddChild(this);
m_lineSize = 1;
m_windowStyle = style;
m_tickFreq = 0;
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
m_rangeMax = maxValue;
m_rangeMin = minValue;
m_pageSize = (int)((maxValue-minValue)/10);
// TODO create slider
return FALSE;
}
wxSlider::~wxSlider()
{
};
}
int wxSlider::GetValue() const
{
// TODO
return 0;
}
void wxSlider::SetValue(int value)
{
};
// TODO
}
void wxSlider::SetRange( int minValue, int maxValue )
void wxSlider::GetSize(int *width, int *height) const
{
};
int wxSlider::GetMin(void) const
{
};
int wxSlider::GetMax(void) const
{
};
void wxSlider::SetPageSize( int pageSize )
{
};
int wxSlider::GetPageSize(void) const
{
};
void wxSlider::SetThumbLength( int len )
{
};
int wxSlider::GetThumbLength(void) const
{
};
void wxSlider::SetLineSize( int WXUNUSED(lineSize) )
{
};
int wxSlider::GetLineSize(void) const
{
};
void wxSlider::GetSize( int *x, int *y ) const
{
wxWindow::GetSize( x, y );
};
void wxSlider::SetSize( int x, int y, int width, int height, int sizeFlags )
{
wxWindow::SetSize( x, y, width, height, sizeFlags );
};
// TODO
}
void wxSlider::GetPosition(int *x, int *y) const
{
wxWindow::GetPosition( x, y );
};
// TODO
}
void wxSlider::SetTick( int WXUNUSED(tickPos) )
void wxSlider::SetSize(int x, int y, int width, int height, int sizeFlags)
{
};
// TODO
}
void wxSlider::SetTickFreq( int WXUNUSED(n), int WXUNUSED(pos) )
void wxSlider::SetRange(int minValue, int maxValue)
{
};
m_rangeMin = minValue;
m_rangeMax = maxValue;
int wxSlider::GetTickFreq(void) const
// TODO
}
// For trackbars only
void wxSlider::SetTickFreq(int n, int pos)
{
// TODO
m_tickFreq = n;
}
void wxSlider::SetPageSize(int pageSize)
{
// TODO
m_pageSize = pageSize;
}
int wxSlider::GetPageSize() const
{
return m_pageSize;
}
void wxSlider::ClearSel()
{
// TODO
}
void wxSlider::ClearTicks()
{
// TODO
}
void wxSlider::SetLineSize(int lineSize)
{
m_lineSize = lineSize;
// TODO
}
int wxSlider::GetLineSize() const
{
// TODO
return 0;
};
}
void wxSlider::ClearTicks(void)
{
};
void wxSlider::SetSelection( int WXUNUSED(minPos), int WXUNUSED(maxPos) )
{
};
int wxSlider::GetSelEnd(void) const
int wxSlider::GetSelEnd() const
{
// TODO
return 0;
};
}
int wxSlider::GetSelStart(void) const
int wxSlider::GetSelStart() const
{
// TODO
return 0;
};
}
void wxSlider::ClearSel(void)
void wxSlider::SetSelection(int minPos, int maxPos)
{
};
// TODO
}
void wxSlider::SetThumbLength(int len)
{
// TODO
}
int wxSlider::GetThumbLength() const
{
// TODO
return 0;
}
void wxSlider::SetTick(int tickPos)
{
// TODO
}
void wxSlider::Command (wxCommandEvent & event)
{
SetValue (event.GetInt());
ProcessCommand (event);
}
bool wxSlider::Show(bool show)
{
// TODO
return TRUE;
}

61
src/qt/statbmp.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: statbmp.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxStaticBitmap
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,31 +15,45 @@
#include "wx/statbmp.h"
//-----------------------------------------------------------------------------
// wxStaticBitmap
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
#endif
wxStaticBitmap::wxStaticBitmap(void)
{
};
/*
* wxStaticBitmap
*/
wxStaticBitmap::wxStaticBitmap( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
Create( parent, id, bitmap, pos, size, style, name );
};
m_messageBitmap = bitmap;
SetName(name);
if (parent) parent->AddChild(this);
bool wxStaticBitmap::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
m_windowStyle = style;
// TODO: create static bitmap control
return FALSE;
}
void wxStaticBitmap::SetSize(int x, int y, int width, int height, int sizeFlags)
{
return TRUE;
};
// TODO
}
void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
{
};
m_messageBitmap = bitmap;
// TODO: redraw bitmap
}

68
src/qt/statbox.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: statbox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxStaticBox
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,25 +15,48 @@
#include "wx/statbox.h"
//-----------------------------------------------------------------------------
// wxStaticBox
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxStaticBox, wxControl)
wxStaticBox::wxStaticBox(void)
{
};
BEGIN_EVENT_TABLE(wxStaticBox, wxControl)
EVT_ERASE_BACKGROUND(wxStaticBox::OnEraseBackground)
END_EVENT_TABLE()
wxStaticBox::wxStaticBox( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
Create( parent, id, label, pos, size, style, name );
};
#endif
bool wxStaticBox::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
/*
* Static box
*/
bool wxStaticBox::Create(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
};
SetName(name);
if (parent) parent->AddChild(this);
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
m_windowStyle = style;
// TODO: create static box
return FALSE;
}
void wxStaticBox::SetLabel(const wxString& label)
{
// TODO
}
void wxStaticBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
// TODO
}

216
src/qt/stattext.cpp
View File

@@ -1,49 +1,211 @@
/////////////////////////////////////////////////////////////////////////////
// Name: stattext.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxStaticText
// Author: AUTHOR
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "stattext.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/app.h"
#endif
#include "wx/stattext.h"
#include "wx/msw/private.h"
#include <stdio.h>
//-----------------------------------------------------------------------------
// wxStaticText
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl)
#endif
wxStaticText::wxStaticText(void)
bool wxStaticText::Create(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
};
SetName(name);
if (parent) parent->AddChild(this);
wxStaticText::wxStaticText( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
Create( parent, id, label, pos, size, style, name );
};
SetBackgroundColour(parent->GetDefaultBackgroundColour()) ;
SetForegroundColour(parent->GetDefaultForegroundColour()) ;
bool wxStaticText::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
m_windowStyle = style;
long msStyle = WS_CHILD|WS_VISIBLE;
if (m_windowStyle & wxALIGN_CENTRE)
msStyle |= SS_CENTER;
else if (m_windowStyle & wxALIGN_RIGHT)
msStyle |= SS_RIGHT;
else
msStyle |= SS_LEFT;
// Even with extended styles, need to combine with WS_BORDER
// for them to look right.
if ((m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
(m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
msStyle |= WS_BORDER;
HWND static_item = CreateWindowEx(MakeExtendedStyle(m_windowStyle), "STATIC", (const char *)label,
msStyle,
0, 0, 0, 0, (HWND) parent->GetHWND(), (HMENU)m_windowId,
wxGetInstance(), NULL);
#if CTL3D
/*
if (!(GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS))
Ctl3dSubclassCtl(static_item);
*/
#endif
m_hWnd = (WXHWND)static_item;
SubclassWin((WXHWND)static_item);
SetFont(* parent->GetFont());
SetSize(x, y, width, height);
return TRUE;
};
}
wxString wxStaticText::GetLabel(void) const
void wxStaticText::SetSize(int x, int y, int width, int height, int sizeFlags)
{
};
int currentX, currentY;
GetPosition(&currentX, &currentY);
int x1 = x;
int y1 = y;
if (x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
x1 = currentX;
if (y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
y1 = currentY;
AdjustForParentClientOrigin(x1, y1, sizeFlags);
int actualWidth = width;
int actualHeight = height;
char buf[300];
int current_width;
int cyf;
::GetWindowText((HWND) GetHWND(), buf, 300);
GetTextExtent(buf, &current_width, &cyf, NULL, NULL,GetFont());
int ww, hh;
GetSize(&ww, &hh);
// If we're prepared to use the existing width, then...
if (width == -1 && ((sizeFlags & wxSIZE_AUTO_WIDTH) != wxSIZE_AUTO_WIDTH))
actualWidth = ww;
else if (width == -1)
{
int cx;
int cy;
wxGetCharSize(GetHWND(), &cx, &cy,GetFont());
actualWidth = (int)(current_width + cx) ;
}
// If we're prepared to use the existing height, then...
if (height == -1 && ((sizeFlags & wxSIZE_AUTO_HEIGHT) != wxSIZE_AUTO_HEIGHT))
actualHeight = hh;
else if (height == -1)
{
actualHeight = (int)(cyf) ;
}
MoveWindow((HWND) GetHWND(), x1, y1, actualWidth, actualHeight, TRUE);
}
void wxStaticText::SetLabel(const wxString& label)
{
wxControl::SetLabel(label);
};
int w, h;
RECT rect;
wxWindow *parent = GetParent();
GetWindowRect((HWND) GetHWND(), &rect);
// Since we now have the absolute screen coords,
// if there's a parent we must subtract its top left corner
POINT point;
point.x = rect.left;
point.y = rect.top;
if (parent)
{
::ScreenToClient((HWND) parent->GetHWND(), &point);
}
GetTextExtent(label, &w, &h, NULL, NULL, GetFont());
MoveWindow((HWND) GetHWND(), point.x, point.y, (int)(w + 10), (int)h,
TRUE);
SetWindowText((HWND) GetHWND(), (const char *)label);
}
WXHBRUSH wxStaticText::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
/*
#if CTL3D
if ( m_useCtl3D )
{
HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
if (hbrush != (HBRUSH) 0)
return hbrush;
else
return (HBRUSH)MSWDefWindowProc(message, wParam, lParam);
}
#endif
*/
if (GetParent()->GetTransparentBackground())
SetBkMode((HDC) pDC, TRANSPARENT);
else
SetBkMode((HDC) pDC, OPAQUE);
::SetBkColor((HDC) pDC, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
::SetTextColor((HDC) pDC, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue()));
wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID);
// Note that this will be cleaned up in wxApp::OnIdle, if backgroundBrush
// has a zero usage count.
// backgroundBrush->RealizeResource();
return (WXHBRUSH) backgroundBrush->GetResourceHandle();
}
long wxStaticText::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
// Ensure that static items get messages. Some controls don't like this
// message to be intercepted (e.g. RichEdit), hence the tests.
if (nMsg == WM_NCHITTEST)
return (long)HTCLIENT;
return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
}

452
src/qt/textctrl.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: textctrl.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxTextCtrl
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -12,162 +13,362 @@
#pragma implementation "textctrl.h"
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <fstream.h>
#include "wx/textctrl.h"
#include "wx/utils.h"
#include "wx/settings.h"
//-----------------------------------------------------------------------------
// wxTextCtrl
//-----------------------------------------------------------------------------
#if defined(__BORLANDC__) && !defined(__WIN32__)
#include <alloc.h>
#else
#ifndef __GNUWIN32__
#include <malloc.h>
#endif
#endif
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
// EVT_CHAR(wxTextCtrl::OnChar)
EVT_CHAR(wxTextCtrl::OnChar)
EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
END_EVENT_TABLE()
#endif
wxTextCtrl::wxTextCtrl(void) : streambuf()
// Text item
wxTextCtrl::wxTextCtrl()
#ifndef NO_TEXT_WINDOW_STREAM
:streambuf()
#endif
{
if( allocate() )
setp(base(),ebuf());
m_fileName = "";
}
m_modified = FALSE;
};
wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
const wxPoint &pos, const wxSize &size,
int style, const wxString &name ) : streambuf()
bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
if( allocate() )
setp(base(),ebuf());
m_fileName = "";
SetName(name);
SetValidator(validator);
if (parent) parent->AddChild(this);
m_modified = FALSE;
Create( parent, id, value, pos, size, style, name );
};
m_windowStyle = style;
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
const wxPoint &pos, const wxSize &size,
int style, const wxString &name )
{
return TRUE;
};
}
wxString wxTextCtrl::GetValue(void) const
wxString wxTextCtrl::GetValue() const
{
return tmp;
};
// TODO
return wxString("");
}
void wxTextCtrl::SetValue(const wxString& value)
{
};
// TODO
}
void wxTextCtrl::WriteText( const wxString &text )
void wxTextCtrl::SetSize(int x, int y, int width, int height, int sizeFlags)
{
};
// TODO
}
bool wxTextCtrl::LoadFile( const wxString &WXUNUSED(file) )
// Clipboard operations
void wxTextCtrl::Copy()
{
return FALSE;
};
// TODO
}
bool wxTextCtrl::SaveFile( const wxString &WXUNUSED(file) )
void wxTextCtrl::Cut()
{
return FALSE;
};
// TODO
}
/*
wxString wxTextCtrl::GetLineText( long lineNo ) const
void wxTextCtrl::Paste()
{
};
void wxTextCtrl::OnDropFiles( wxDropFilesEvent &event )
{
};
long wxTextCtrl::PositionToXY( long pos, long *x, long *y ) const
{
};
long wxTextCtrl::XYToPosition( long x, long y )
{
};
int wxTextCtrl::GetNumberOfLines(void)
{
};
*/
void wxTextCtrl::SetInsertionPoint( long pos )
{
};
void wxTextCtrl::SetInsertionPointEnd(void)
{
};
// TODO
}
void wxTextCtrl::SetEditable(bool editable)
{
};
// TODO
}
void wxTextCtrl::SetSelection( long from, long to )
void wxTextCtrl::SetInsertionPoint(long pos)
{
};
// TODO
}
void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
void wxTextCtrl::SetInsertionPointEnd()
{
};
long pos = GetLastPosition();
SetInsertionPoint(pos);
}
long wxTextCtrl::GetInsertionPoint(void) const
long wxTextCtrl::GetInsertionPoint() const
{
};
// TODO
return 0;
}
long wxTextCtrl::GetLastPosition(void) const
long wxTextCtrl::GetLastPosition() const
{
};
void wxTextCtrl::Remove( long from, long to )
{
};
// TODO
return 0;
}
void wxTextCtrl::Replace(long from, long to, const wxString& value)
{
};
// TODO
return 0;
}
void wxTextCtrl::Cut(void)
void wxTextCtrl::Remove(long from, long to)
{
};
// TODO
}
void wxTextCtrl::Copy(void)
void wxTextCtrl::SetSelection(long from, long to)
{
};
// TODO
}
void wxTextCtrl::Paste(void)
bool wxTextCtrl::LoadFile(const wxString& file)
{
};
if (!wxFileExists(file))
return FALSE;
void wxTextCtrl::Delete(void)
{
};
m_fileName = file;
void wxTextCtrl::OnChar( wxKeyEvent &WXUNUSED(event) )
{
};
Clear();
int wxTextCtrl::overflow( int WXUNUSED(c) )
ifstream input((char*) (const char*) file, ios::nocreate | ios::in);
if (!input.bad())
{
int len = pptr() - pbase();
char *txt = new char[len+1];
strncpy(txt, pbase(), len);
txt[len] = '\0';
(*this) << txt;
setp(pbase(), epptr());
delete[] txt;
struct stat stat_buf;
if (stat(file, &stat_buf) < 0)
return FALSE;
// This may need to be a bigger buffer than the file size suggests,
// if it's a UNIX file. Give it an extra 1000 just in case.
char *tmp_buffer = (char*)malloc((size_t)(stat_buf.st_size+1+1000));
long no_lines = 0;
long pos = 0;
while (!input.eof() && input.peek() != EOF)
{
input.getline(wxBuffer, 500);
int len = strlen(wxBuffer);
wxBuffer[len] = 13;
wxBuffer[len+1] = 10;
wxBuffer[len+2] = 0;
strcpy(tmp_buffer+pos, wxBuffer);
pos += strlen(wxBuffer);
no_lines++;
}
// TODO add line
free(tmp_buffer);
return TRUE;
}
return FALSE;
}
// If file is null, try saved file name first
// Returns TRUE if succeeds.
bool wxTextCtrl::SaveFile(const wxString& file)
{
wxString theFile(file);
if (theFile == "")
theFile = m_fileName;
if (theFile == "")
return FALSE;
m_fileName = theFile;
ofstream output((char*) (const char*) theFile);
if (output.bad())
return FALSE;
// TODO get and save text
return FALSE;
}
void wxTextCtrl::WriteText(const wxString& text)
{
// TODO write text to control
}
void wxTextCtrl::Clear()
{
// TODO
}
bool wxTextCtrl::IsModified() const
{
// TODO
return FALSE;
}
// Makes 'unmodified'
void wxTextCtrl::DiscardEdits()
{
// TODO
}
int wxTextCtrl::GetNumberOfLines() const
{
// TODO
return 0;
}
long wxTextCtrl::XYToPosition(long x, long y) const
{
// TODO
return 0;
}
void wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
{
// TODO
}
void wxTextCtrl::ShowPosition(long pos)
{
// TODO
}
int wxTextCtrl::GetLineLength(long lineNo) const
{
// TODO
return 0;
}
wxString wxTextCtrl::GetLineText(long lineNo) const
{
// TODO
return wxString("");
}
/*
* Text item
*/
void wxTextCtrl::Command(wxCommandEvent & event)
{
SetValue (event.GetString());
ProcessCommand (event);
}
void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
{
// By default, load the first file into the text window.
if (event.GetNumberOfFiles() > 0)
{
LoadFile(event.GetFiles()[0]);
}
}
// The streambuf code was partly taken from chapter 3 by Jerry Schwarz of
// AT&T's "C++ Lanuage System Release 3.0 Library Manual" - Stein Somers
//=========================================================================
// Called then the buffer is full (gcc 2.6.3)
// or when "endl" is output (Borland 4.5)
//=========================================================================
// Class declaration using multiple inheritance doesn't work properly for
// Borland. See note in wb_text.h.
#ifndef NO_TEXT_WINDOW_STREAM
int wxTextCtrl::overflow(int c)
{
// Make sure there is a holding area
if ( allocate()==EOF )
{
wxError("Streambuf allocation failed","Internal error");
return EOF;
};
}
int wxTextCtrl::sync(void)
// Verify that there are no characters in get area
if ( gptr() && gptr() < egptr() )
{
wxError("Who's trespassing my get area?","Internal error");
return EOF;
}
// Reset get area
setg(0,0,0);
// Make sure there is a put area
if ( ! pptr() )
{
/* This doesn't seem to be fatal so comment out error message */
// wxError("Put area not opened","Internal error");
setp( base(), base() );
}
// Determine how many characters have been inserted but no consumed
int plen = pptr() - pbase();
// Now Jerry relies on the fact that the buffer is at least 2 chars
// long, but the holding area "may be as small as 1" ???
// And we need an additional \0, so let's keep this inefficient but
// safe copy.
// If c!=EOF, it is a character that must also be comsumed
int xtra = c==EOF? 0 : 1;
// Write temporary C-string to wxTextWindow
{
char *txt = new char[plen+xtra+1];
memcpy(txt, pbase(), plen);
txt[plen] = (char)c; // append c
txt[plen+xtra] = '\0'; // append '\0' or overwrite c
// If the put area already contained \0, output will be truncated there
WriteText(txt);
delete[] txt;
}
// Reset put area
setp(pbase(), epptr());
#if defined(__WATCOMC__)
return __NOT_EOF;
#elif defined(zapeof) // HP-UX (all cfront based?)
return zapeof(c);
#else
return c!=EOF ? c : 0; // this should make everybody happy
#endif
}
//=========================================================================
// called then "endl" is output (gcc) or then explicit sync is done (Borland)
//=========================================================================
int wxTextCtrl::sync()
{
// Verify that there are no characters in get area
if ( gptr() && gptr() < egptr() )
{
wxError("Who's trespassing my get area?","Internal error");
return EOF;
}
if ( pptr() && pptr() > pbase() ) return overflow(EOF);
return 0;
/* OLD CODE
int len = pptr() - pbase();
char *txt = new char[len+1];
strncpy(txt, pbase(), len);
@@ -176,12 +377,17 @@ int wxTextCtrl::sync(void)
setp(pbase(), epptr());
delete[] txt;
return 0;
};
*/
}
int wxTextCtrl::underflow(void)
//=========================================================================
// Should not be called by a "ostream". Used by a "istream"
//=========================================================================
int wxTextCtrl::underflow()
{
return EOF;
};
}
#endif
wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
{
@@ -191,33 +397,33 @@ wxTextCtrl& wxTextCtrl::operator<<(const wxString& s)
wxTextCtrl& wxTextCtrl::operator<<(float f)
{
static char buf[100];
sprintf(buf, "%.2f", f);
WriteText(buf);
wxString str;
str.Printf("%.2f", f);
WriteText(str);
return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(double d)
{
static char buf[100];
sprintf(buf, "%.2f", d);
WriteText(buf);
wxString str;
str.Printf("%.2f", d);
WriteText(str);
return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(int i)
{
static char buf[100];
sprintf(buf, "%i", i);
WriteText(buf);
wxString str;
str.Printf("%d", i);
WriteText(str);
return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(long i)
{
static char buf[100];
sprintf(buf, "%ld", i);
WriteText(buf);
wxString str;
str.Printf("%ld", i);
WriteText(str);
return *this;
}
@@ -231,5 +437,3 @@ wxTextCtrl& wxTextCtrl::operator<<(const char c)
return *this;
}

76
src/qt/timer.cpp
View File

@@ -1,66 +1,56 @@
/////////////////////////////////////////////////////////////////////////////
// Name: timer.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxTimer implementation
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "timer.h"
#endif
#include "wx/timer.h"
//-----------------------------------------------------------------------------
// wxTimer
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxTimer,wxObject)
gint timeout_callback( gpointer data )
wxTimer::wxTimer()
{
wxTimer *timer = (wxTimer*)data;
timer->Notify();
if (timer->OneShot()) timer->Stop();
return TRUE;
};
wxTimer::wxTimer(void)
{
m_time = 1000;
m_milli = 0 ;
m_lastMilli = -1 ;
m_id = 0;
m_oneShot = FALSE;
};
}
wxTimer::~wxTimer(void)
wxTimer::~wxTimer()
{
Stop();
};
}
int wxTimer::Interval(void)
bool wxTimer::Start(int milliseconds,bool mode)
{
return m_time;
};
m_oneShot = mode ;
if (m_milliseconds < 0)
m_milliseconds = lastMilli;
bool wxTimer::OneShot(void)
if (m_milliseconds <= 0)
return FALSE;
m_lastMilli = m_milli = m_milliseconds;
// TODO: set the timer going.
return FALSE;
}
void wxTimer::Stop()
{
return m_oneShot;
};
m_id = 0 ;
m_milli = 0 ;
}
void wxTimer::Notify(void)
{
};
void wxTimer::Start( int millisecs, bool oneShot )
{
if (millisecs != -1) m_time = millisecs;
m_oneShot = oneShot;
};
void wxTimer::Stop(void)
{
};

1229
src/qt/window.cpp
View File

File diff suppressed because it is too large Load Diff