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

first pass of wxUniv merge - nothing works, most parts don't even compile

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@10673 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2001-06-26 20:59:19 +00:00
parent aeb313f31c
commit 1e6feb95a7
409 changed files with 42065 additions and 6675 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
include/wx/gtk1/accel.h
View File

@@ -1,110 +1,4 @@
/////////////////////////////////////////////////////////////////////////////
// Name: accel.h
// Purpose: wxAcceleratorTable class
// Author: Robert Roebling
// RCS-ID: $Id$
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKACCELH__
#define __GTKACCELH__
#ifdef __GNUG__
#pragma interface "accel.h"
#endif
#include "wx/defs.h"
#if wxUSE_ACCEL
#include "wx/object.h"
#include "wx/event.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxAcceleratorEntry;
class wxAcceleratorTable;
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
extern wxAcceleratorTable wxNullAcceleratorTable;
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
// Hold Ctrl key down
#define wxACCEL_ALT 0x01
// Hold Ctrl key down
#define wxACCEL_CTRL 0x02
// Hold Shift key down
#define wxACCEL_SHIFT 0x04
// Hold no other key
#define wxACCEL_NORMAL 0x00
//-----------------------------------------------------------------------------
// wxAcceleratorEntry
//-----------------------------------------------------------------------------
class wxAcceleratorEntry: public wxObject
{
public:
wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0)
{ m_flags = flags; m_keyCode = keyCode; m_command = cmd; }
inline void Set(int flags, int keyCode, int cmd)
{ m_flags = flags; m_keyCode = keyCode; m_command = cmd; }
inline int GetFlags() const { return m_flags; }
inline int GetKeyCode() const { return m_keyCode; }
inline int GetCommand() const { return m_command; }
int m_flags;
int m_keyCode; // ASCII or virtual keycode
int m_command; // Command id to generate
};
//-----------------------------------------------------------------------------
// wxAcceleratorTable
//-----------------------------------------------------------------------------
class wxAcceleratorTable: public wxObject
{
public:
wxAcceleratorTable();
wxAcceleratorTable(int n, wxAcceleratorEntry entries[] );
~wxAcceleratorTable();
inline wxAcceleratorTable(const wxAcceleratorTable& accel) : wxObject()
{ Ref(accel); }
inline wxAcceleratorTable(const wxAcceleratorTable* accel)
{ if (accel) Ref(*accel); }
inline bool operator == (const wxAcceleratorTable& accel)
{ return m_refData == accel.m_refData; }
inline bool operator != (const wxAcceleratorTable& accel)
{ return m_refData != accel.m_refData; }
inline wxAcceleratorTable& operator = (const wxAcceleratorTable& accel)
{ if (*this == accel) return (*this); Ref(accel); return *this; }
bool Ok() const;
// implementation
// --------------
int GetCommand( wxKeyEvent &event );
private:
DECLARE_DYNAMIC_CLASS(wxAcceleratorTable)
};
#endif
#endif
// VZ: keeping the old file just in case we're going to have a native GTK+
// wxAcceleratorTable implementation one day, but for now use the generic
// version
#include "wx/generic/accel.h"

2
include/wx/gtk1/app.h
View File

@@ -74,7 +74,7 @@ public:
unsigned char *m_colorCube;
private:
/// Set to TRUE while we are in wxYield().
// Set to TRUE while we are in wxYield().
bool m_suppressIdleEvents;
private:

81
include/wx/gtk1/bmpbuttn.h
View File

@@ -15,71 +15,41 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_BMPBUTTON
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/bitmap.h"
#include "wx/button.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxBitmapButton;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const wxChar *wxButtonNameStr;
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxBitmapButton
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxBitmapButton: public wxButton
class wxBitmapButton: public wxBitmapButtonBase
{
public:
wxBitmapButton();
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 )
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create( wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetDefault();
virtual bool Enable(bool enable = TRUE);
void SetLabel( const wxString &label );
wxString GetLabel() const;
virtual void SetLabel( const wxBitmap& bitmap ) { SetBitmapLabel(bitmap); }
wxBitmap& GetBitmapDisabled() const { return (wxBitmap&) m_disabled; }
wxBitmap& GetBitmapFocus() const { return (wxBitmap&) m_focus; }
wxBitmap& GetBitmapLabel() const { return (wxBitmap&) m_bitmap; }
wxBitmap& GetBitmapSelected() const { return (wxBitmap&) m_selected; }
void SetBitmapDisabled( const wxBitmap& bitmap );
void SetBitmapFocus( const wxBitmap& bitmap );
void SetBitmapLabel( const wxBitmap& bitmap );
void SetBitmapSelected( const wxBitmap& bitmap );
void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
int GetMarginX() const { return m_marginX; }
int GetMarginY() const { return m_marginY; }
virtual bool Enable(bool enable);
// implementation
// --------------
@@ -92,19 +62,12 @@ public:
bool m_hasFocus;
bool m_isSelected;
wxBitmap m_bitmap;
wxBitmap m_disabled;
wxBitmap m_focus;
wxBitmap m_selected;
protected:
int m_marginX;
int m_marginY;
virtual void OnSetBitmap();
private:
DECLARE_DYNAMIC_CLASS(wxBitmapButton)
};
#endif
#endif // __BMPBUTTONH__

30
include/wx/gtk1/checkbox.h
View File

@@ -14,31 +14,11 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_CHECKBOX
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxCheckBox;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxCheckBoxNameStr;
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxCheckBox
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxCheckBox: public wxControl
class wxCheckBox : public wxCheckBoxBase
{
public:
wxCheckBox();
@@ -74,7 +54,7 @@ public:
GtkWidget *m_widgetCheckbox;
GtkWidget *m_widgetLabel;
protected:
virtual wxSize DoGetBestSize() const;
@@ -82,6 +62,4 @@ private:
DECLARE_DYNAMIC_CLASS(wxCheckBox)
};
#endif
#endif // __GTKCHECKBOXH__

13
include/wx/gtk1/checklst.h
View File

@@ -15,15 +15,6 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_CHECKLISTBOX
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/listbox.h"
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
@@ -37,7 +28,7 @@
#define wxCHECKLBOX_STRING _T("[ ] ")
#endif
// ----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// wxCheckListBox
// ----------------------------------------------------------------------------
@@ -63,6 +54,4 @@ private:
DECLARE_DYNAMIC_CLASS(wxCheckListBox)
};
#endif
#endif //__GTKCHECKLISTH__

1
include/wx/gtk1/combobox.h
View File

@@ -86,6 +86,7 @@ public:
int GetSelection() const;
wxString GetString( int n ) const;
wxString GetStringSelection() const;
int GetCount() const { return Number(); }
int Number() const;
void SetSelection( int n );
void SetStringSelection( const wxString &string );

2
include/wx/gtk1/control.h
View File

@@ -29,8 +29,6 @@ class wxControl;
// wxControl
//-----------------------------------------------------------------------------
extern const wxChar* wxControlNameStr;
class wxControl : public wxControlBase
{
public:

2
include/wx/gtk1/dcclient.h
View File

@@ -140,7 +140,7 @@ private:
class wxClientDC : public wxWindowDC
{
public:
wxClientDC() { }
wxClientDC();
wxClientDC( wxWindow *win );
protected:

28
include/wx/gtk1/frame.h
View File

@@ -26,24 +26,22 @@ class wxMenuBar;
class wxToolBar;
class wxStatusBar;
class wxFrame;
//-----------------------------------------------------------------------------
// wxFrame
// wxFrameGTK
//-----------------------------------------------------------------------------
class wxFrame : public wxFrameBase
class wxFrameGTK : public wxFrameBase
{
public:
// construction
wxFrame() { Init(); }
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)
wxFrameGTK() { Init(); }
wxFrameGTK(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
@@ -58,7 +56,7 @@ public:
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual ~wxFrame();
virtual ~wxFrameGTK();
// implement base class pure virtuals
virtual void Maximize(bool maximize = TRUE);
@@ -72,7 +70,9 @@ public:
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL);
virtual bool IsFullScreen() const { return m_fsIsShowing; };
#if wxUSE_MENUS
virtual void SetMenuBar( wxMenuBar *menuBar );
#endif // wxUSE_MENUS
#if wxUSE_STATUSBAR
virtual void PositionStatusBar();
@@ -138,7 +138,7 @@ protected:
bool m_isIconized;
private:
DECLARE_DYNAMIC_CLASS(wxFrame)
DECLARE_DYNAMIC_CLASS(wxFrameGTK)
};
#endif // __GTKFRAMEH__

45
include/wx/gtk1/notebook.h
View File

@@ -15,23 +15,6 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_NOTEBOOK
#include "wx/object.h"
#include "wx/string.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxImageList;
class wxNotebook;
typedef wxWindow wxNotebookPage; // so far, any window can be a page
//-----------------------------------------------------------------------------
// internal class
//-----------------------------------------------------------------------------
@@ -42,7 +25,7 @@ class wxGtkNotebookPage;
// wxNotebook
//-----------------------------------------------------------------------------
class wxNotebook : public wxControl
class wxNotebook : public wxNotebookBase
{
public:
// default for dynamic class
@@ -66,15 +49,11 @@ public:
// accessors
// ---------
// get number of pages in the dialog
int GetPageCount() const;
// set the currently selected page, return the index of the previously
// selected one (or -1 on error)
// NB: this function will _not_ generate wxEVT_NOTEBOOK_PAGE_xxx events
int SetSelection(int nPage);
// cycle thru the tabs
void AdvanceSelection(bool bForward = TRUE);
// get the currently selected page
int GetSelection() const;
@@ -90,17 +69,11 @@ public:
// associate image list with a control
void SetImageList(wxImageList* imageList);
void AssignImageList(wxImageList* imageList);
// get pointer (may be NULL) to the associated image list
wxImageList *GetImageList() const { return m_imageList; }
// sets/returns item's image index in the current image list
int GetPageImage(int nPage) const;
bool SetPageImage(int nPage, int nImage);
// currently it's always 1 because wxGTK doesn't support multi-row
// tab controls
int GetRowCount() const;
// control the appearance of the notebook pages
// set the size (the same for all pages)
void SetPageSize(const wxSize& size);
@@ -111,13 +84,11 @@ public:
// operations
// ----------
// remove one page from the notebook but do not destroy it
bool RemovePage(int nPage);
// remove one page from the notebook
bool DeletePage(int nPage);
// remove all pages
bool DeleteAllPages();
// adds a new page to the notebook (it will be deleted ny the notebook,
// don't delete it yourself). If bSelect, this page becomes active.
bool AddPage( wxNotebookPage *win,
@@ -131,9 +102,6 @@ public:
bool bSelect = FALSE,
int imageId = -1 );
// get the panel which represents the given page
wxNotebookPage *GetPage(int nPage) const;
// handler for tab navigation
// --------------------------
void OnNavigationKey(wxNavigationKeyEvent& event);
@@ -148,7 +116,7 @@ public:
void ApplyWidgetStyle();
// report if window belongs to notebook
// report if window belongs to notebook
bool IsOwnGtkWindow( GdkWindow *window );
// common part of all ctors
@@ -157,7 +125,6 @@ public:
// helper function
wxGtkNotebookPage* GetNotebookPage(int page) const;
wxImageList* m_imageList;
bool m_ownsImageList;
wxList m_pages;
@@ -165,12 +132,14 @@ public:
// selection internally instead of querying the notebook for it
int m_selection;
protected:
// remove one page from the notebook but do not destroy it
virtual wxNotebookPage *DoRemovePage(int nPage);
private:
DECLARE_DYNAMIC_CLASS(wxNotebook)
DECLARE_EVENT_TABLE()
};
#endif
#endif
// __GTKNOTEBOOKH__

24
include/wx/gtk1/radiobox.h
View File

@@ -15,27 +15,8 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_RADIOBOX
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxRadioBox;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxRadioBoxNameStr;
//-----------------------------------------------------------------------------
// wxRadioBox
//-----------------------------------------------------------------------------
@@ -97,7 +78,8 @@ public:
virtual wxString GetStringSelection() const;
virtual bool SetStringSelection( const wxString& s );
virtual int Number() const;
int Number() const;
int GetCount() const { return Number(); }
int GetNumberOfRowsOrCols() const;
void SetNumberOfRowsOrCols( int n );
@@ -131,6 +113,4 @@ private:
DECLARE_DYNAMIC_CLASS(wxRadioBox)
};
#endif
#endif // __GTKRADIOBOXH__

22
include/wx/gtk1/radiobut.h
View File

@@ -15,26 +15,6 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_RADIOBOX
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxRadioButton;
//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------
extern const char* wxRadioButtonNameStr;
//-----------------------------------------------------------------------------
// wxRadioButton
//-----------------------------------------------------------------------------
@@ -77,6 +57,4 @@ private:
DECLARE_DYNAMIC_CLASS(wxRadioButton)
};
#endif
#endif // __GTKRADIOBUTTONH__

35
include/wx/gtk1/region.h
View File

@@ -30,13 +30,13 @@ class wxRegion;
enum wxRegionContain
{
wxOutRegion = 0,
wxPartRegion = 1,
wxOutRegion = 0,
wxPartRegion = 1,
wxInRegion = 2
};
// So far, for internal use only
enum wxRegionOp
enum wxRegionOp
{
wxRGN_AND, // Creates the intersection of the two combined regions.
wxRGN_COPY, // Creates a copy of the region identified by hrgnSrc1.
@@ -45,9 +45,9 @@ enum wxRegionOp
wxRGN_XOR // Creates the union of two combined regions except for any overlapping areas.
};
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxRegion
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxRegion : public wxGDIObject
{
@@ -56,12 +56,10 @@ public:
wxRegion( const wxPoint& topLeft, const wxPoint& bottomRight );
wxRegion( const wxRect& rect );
wxRegion();
~wxRegion();
virtual ~wxRegion();
inline wxRegion( const wxRegion& r ): wxGDIObject()
{ Ref(r); }
inline wxRegion& operator = ( const wxRegion& r )
{ Ref(r); return (*this); }
wxRegion( const wxRegion& r ) { Ref(r); }
wxRegion& operator = ( const wxRegion& r ) { Ref(r); return *this; }
bool operator == ( const wxRegion& region );
bool operator != ( const wxRegion& region );
@@ -98,11 +96,22 @@ public:
public:
wxList *GetRectList() const;
GdkRegion *GetRegion() const;
protected:
// helper of Intersect()
bool IntersectRegionOnly(const wxRegion& reg);
// call this before modifying the region
void Unshare();
private:
DECLARE_DYNAMIC_CLASS(wxRegion);
DECLARE_DYNAMIC_CLASS(wxRegion);
};
// ----------------------------------------------------------------------------
// wxRegionIterator: decomposes a region into rectangles
// ----------------------------------------------------------------------------
class wxRegionIterator: public wxObject
{
public:
@@ -124,7 +133,7 @@ public:
wxCoord GetWidth() const { return GetW(); }
wxCoord GetH() const;
wxCoord GetHeight() const { return GetH(); }
wxRect GetRect() const { return wxRect(GetX(), GetY(), GetWidth(), GetHeight()); }
wxRect GetRect() const;
private:
size_t m_current;

27
include/wx/gtk1/scrolbar.h
View File

@@ -4,7 +4,7 @@
// Author: Robert Roebling
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -17,31 +17,20 @@
#include "wx/defs.h"
#if wxUSE_SCROLLBAR
#include "wx/object.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxScrollBar;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxScrollBarNameStr;
//-----------------------------------------------------------------------------
// wxScrollBar
//-----------------------------------------------------------------------------
class wxScrollBar: public wxControl
class wxScrollBar: public wxScrollBarBase
{
public:
wxScrollBar()
wxScrollBar()
{ m_adjust = (GtkAdjustment *) NULL; m_oldPos = 0.0; }
inline wxScrollBar( wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
@@ -69,7 +58,7 @@ public:
// Backward compatibility
// ----------------------
int GetValue(void) const;
void SetValue( int viewStart );
void GetValues( int *viewStart, int *viewLength, int *objectLength, int *pageLength) const;
@@ -81,18 +70,16 @@ public:
// implementation
// --------------
bool IsOwnGtkWindow( GdkWindow *window );
void ApplyWidgetStyle();
GtkAdjustment *m_adjust;
float m_oldPos;
private:
DECLARE_DYNAMIC_CLASS(wxScrollBar)
};
#endif
#endif
// __GTKSCROLLBARH__

101
include/wx/gtk1/slider.h
View File

@@ -1,10 +1,10 @@
/////////////////////////////////////////////////////////////////////////////
// Name: slider.h
// Name: wx/gtk/slider.h
// Purpose:
// Author: Robert Roebling
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSLIDERH__
@@ -14,70 +14,51 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_SLIDER
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxSlider;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxSliderNameStr;
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxSlider
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
class wxSlider: public wxControl
class wxSlider : public wxSliderBase
{
public:
wxSlider() {}
inline wxSlider( wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr )
wxSlider() { }
wxSlider(wxWindow *parent,
wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr)
{
Create( parent, id, value, minValue, maxValue, pos, size, style, validator, name );
Create( parent, id, value, minValue, maxValue,
pos, size, style, validator, name );
}
bool Create(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr );
bool Create(wxWindow *parent,
wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
// implement the base class pure virtuals
virtual int GetValue() const;
virtual void SetValue( int );
void SetRange( int minValue, int maxValue );
int GetMin() const;
int GetMax() const;
void SetTickFreq( int n, int pos );
int GetTickFreq() const;
void SetPageSize( int pageSize );
int GetPageSize() const;
void ClearSel();
void ClearTicks();
void SetLineSize( int lineSize );
int GetLineSize() const;
int GetSelEnd() const;
int GetSelStart() const;
void SetSelection( int minPos, int maxPos );
void SetThumbLength( int len );
int GetThumbLength() const;
void SetTick( int tickPos );
virtual void SetValue(int value);
virtual void SetRange(int minValue, int maxValue);
virtual int GetMin() const;
virtual int GetMax() const;
virtual void SetLineSize(int lineSize);
virtual void SetPageSize(int pageSize);
virtual int GetLineSize() const;
virtual int GetPageSize() const;
virtual void SetThumbLength(int lenPixels);
virtual int GetThumbLength() const;
// implementation
// --------------
@@ -92,6 +73,4 @@ private:
DECLARE_DYNAMIC_CLASS(wxSlider)
};
#endif
#endif // __GTKSLIDERH__

35
include/wx/gtk1/spinbutt.h
View File

@@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////
// Name: spinbutt.h
// Name: wx/gtk/spinbutt.h
// Purpose: wxSpinButton class
// Author: Robert Roebling
// Modified by:
@@ -8,19 +8,13 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSPINBUTTH__
#define __GTKSPINBUTTH__
#ifndef _WX_GTK_SPINBUTT_H_
#define _WX_GTK_SPINBUTT_H_
#ifdef __GNUG__
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_SPINBTN
#include "wx/control.h"
//-----------------------------------------------------------------------------
// wxSpinButton
//-----------------------------------------------------------------------------
@@ -29,16 +23,22 @@ class wxSpinButton : public wxSpinButtonBase
{
public:
wxSpinButton() { }
wxSpinButton( wxWindow *parent, wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL, const wxString& name = "wxSpinButton")
wxSpinButton(wxWindow *parent,
wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL,
const wxString& name = wxSPIN_BUTTON_NAME)
{
Create(parent, id, pos, size, style, name);
}
bool Create( wxWindow *parent, wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL, const wxString& name = "wxSpinButton" );
bool Create(wxWindow *parent,
wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL,
const wxString& name = wxSPIN_BUTTON_NAME);
virtual int GetValue() const;
virtual void SetValue( int value );
@@ -64,7 +64,4 @@ private:
};
#endif
// wxUSE_SPINBTN
#endif
// __GTKSPINBUTTH__
// _WX_GTK_SPINBUTT_H_

45
include/wx/gtk1/statbmp.h
View File

@@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////
// Name: statbmp.h
// Name: wx/gtk/statbmp.h
// Purpose:
// Author: Robert Roebling
// Id: $Id$
@@ -15,35 +15,14 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_STATBMP
#include "wx/object.h"
#include "wx/control.h"
#include "wx/bitmap.h"
#include "wx/icon.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxStaticBitmap;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char* wxStaticBitmapNameStr;
//-----------------------------------------------------------------------------
// wxStaticBitmap
//-----------------------------------------------------------------------------
class wxStaticBitmap: public wxControl
class wxStaticBitmap : public wxStaticBitmapBase
{
DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
public:
wxStaticBitmap();
wxStaticBitmap( wxWindow *parent,
@@ -61,35 +40,25 @@ public:
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual void SetIcon(const wxIcon& icon) { SetBitmap( icon ); }
virtual void SetBitmap( const wxBitmap& bitmap );
wxBitmap& GetBitmap() { return m_bitmap; }
const wxBitmap& GetBitmap() const { return m_bitmap; }
virtual wxBitmap GetBitmap() const { return m_bitmap; }
// for compatibility with wxMSW
const wxIcon& GetIcon() const
wxIcon GetIcon() const
{
// don't use wxDynamicCast, icons and bitmaps are really the same thing
// in wxGTK
return (const wxIcon &)m_bitmap;
}
// for compatibility with wxMSW
void SetIcon(const wxIcon& icon)
{
SetBitmap( icon );
}
protected:
virtual wxSize DoGetBestSize() const;
private:
// creates the new pixmap widget
void CreatePixmapWidget();
wxBitmap m_bitmap;
DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
};
#endif
#endif // __GTKSTATICBITMAPH__

61
include/wx/gtk1/statbox.h
View File

@@ -1,10 +1,10 @@
/////////////////////////////////////////////////////////////////////////////
// Name: stabox.h
// Name: wx/gtk/stabox.h
// Purpose:
// Author: Robert Roebling
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -15,50 +15,37 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_STATBOX
#include "wx/object.h"
#include "wx/list.h"
#include "wx/control.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxStaticBox;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern const char *wxStaticBoxNameStr;
//-----------------------------------------------------------------------------
// wxStaticBox
//-----------------------------------------------------------------------------
class wxStaticBox: public wxControl
class wxStaticBox : public wxStaticBoxBase
{
DECLARE_DYNAMIC_CLASS(wxStaticBox)
public:
wxStaticBox();
wxStaticBox( wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticBoxNameStr );
bool Create( wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticBoxNameStr );
public:
virtual void SetLabel( const wxString &label );
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 );
void SetLabel( const wxString &label );
// implementation
// implementation
void ApplyWidgetStyle();
private:
DECLARE_DYNAMIC_CLASS(wxStaticBox)
};
#endif
#endif // __GTKSTATICBOXH__

2
include/wx/gtk1/stattext.h
View File

@@ -30,8 +30,6 @@ class wxStaticText;
// global data
//-----------------------------------------------------------------------------
extern const wxChar *wxStaticTextNameStr;
//-----------------------------------------------------------------------------
// wxStaticText
//-----------------------------------------------------------------------------

4
include/wx/gtk1/textctrl.h
View File

@@ -96,10 +96,6 @@ public:
virtual void Cut();
virtual void Paste();
virtual bool CanCopy() const;
virtual bool CanCut() const;
virtual bool CanPaste() const;
// Undo/redo
virtual void Undo();
virtual void Redo();

36
include/wx/gtk1/window.h
View File

@@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////
// Name: window.h
// Name: wx/gtk/window.h
// Purpose:
// Author: Robert Roebling
// Id: $Id$
@@ -19,33 +19,32 @@
// callback definition for inserting a window (internal)
//-----------------------------------------------------------------------------
typedef void (*wxInsertChildFunction)( wxWindow*, wxWindow* );
class wxWindowGTK;
typedef void (*wxInsertChildFunction)( wxWindowGTK*, wxWindowGTK* );
//-----------------------------------------------------------------------------
// wxWindow
// wxWindowGTK
//-----------------------------------------------------------------------------
class wxWindow : public wxWindowBase
class wxWindowGTK : public wxWindowBase
{
DECLARE_DYNAMIC_CLASS(wxWindow)
public:
// creating the window
// -------------------
wxWindow();
wxWindow(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
wxWindowGTK();
wxWindowGTK(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);
virtual ~wxWindow();
virtual ~wxWindowGTK();
// implement base class (pure) virtual methods
// -------------------------------------------
@@ -86,7 +85,9 @@ public:
const wxFont *theFont = (const wxFont *) NULL)
const;
#if wxUSE_MENUS
virtual bool DoPopupMenu( wxMenu *menu, int x, int y );
#endif // wxUSE_MENUS
virtual void SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh = TRUE );
@@ -120,13 +121,13 @@ public:
virtual void OnParentEnable( bool WXUNUSED(enable) ) {};
/* used by all window classes in the widget creation process */
bool PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size );
bool PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size );
void PostCreation();
/* internal addition of child windows. differs from class
to class not by using virtual functions but by using
the m_insertCallback */
void DoAddChild(wxWindow *child);
void DoAddChild(wxWindowGTK *child);
/* the methods below are required because many native widgets
are composed of several subwidgets and setting a style for
@@ -231,7 +232,8 @@ public:
void Init();
private:
DECLARE_NO_COPY_CLASS(wxWindow);
DECLARE_DYNAMIC_CLASS(wxWindowGTK)
DECLARE_NO_COPY_CLASS(wxWindowGTK);
};
#endif // __GTKWINDOWH__