// the margins around the bitmap
int m_marginX,
m_marginY;
+
private:
// Prevent Virtual function hiding warnings
void SetLabel(const wxString& rsLabel)
- { wxWindowBase::SetLabel(rsLabel); }
+ { wxWindowBase::SetLabel(rsLabel); }
+
+ DECLARE_NO_COPY_CLASS(wxBitmapButtonBase)
};
#if defined(__WXUNIVERSAL__)
{
public:
wxInfoFrame(wxWindow *parent, const wxString& message);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxInfoFrame)
};
class WXDLLEXPORT wxButtonBase : public wxControl
{
public:
+ wxButtonBase() { }
+
// show the image in the button in addition to the label
virtual void SetImageLabel(const wxBitmap& WXUNUSED(bitmap)) { }
// returns the default button size for this platform
static wxSize GetDefaultSize();
+
+ DECLARE_NO_COPY_CLASS(wxButtonBase)
};
#if defined(__WXUNIVERSAL__)
wxDateTime m_date;
wxDateTime::WeekDay m_wday;
- DECLARE_DYNAMIC_CLASS(wxCalendarEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxCalendarEvent)
};
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxCheckBoxBase : public wxControl
{
public:
+ wxCheckBoxBase() { }
+
// set/get the checked status of the listbox
virtual void SetValue(bool value) = 0;
virtual bool GetValue() const = 0;
bool IsChecked() const { return GetValue(); }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxCheckBoxBase)
};
#if defined(__WXUNIVERSAL__)
class WXDLLEXPORT wxCheckListBoxBase : public wxListBox
{
public:
+ wxCheckListBoxBase() { }
+
// check list box specific methods
virtual bool IsChecked(size_t item) const = 0;
virtual void Check(size_t item, bool check = TRUE) = 0;
+
+ DECLARE_NO_COPY_CLASS(wxCheckListBoxBase)
};
#if defined(__WXUNIVERSAL__)
class WXDLLEXPORT wxChoiceBase : public wxControlWithItems
{
public:
- // all generic methods are in wxControlWithItems
+ wxChoiceBase() { }
virtual ~wxChoiceBase();
+ // all generic methods are in wxControlWithItems
+
// single selection logic
virtual void SetSelection(int n) = 0;
virtual bool SetStringSelection(const wxString& s);
// emulate selecting the item event.GetInt()
void Command(wxCommandEvent& event);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxChoiceBase)
};
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxControlBase : public wxWindow
{
public:
+ wxControlBase() { }
+
virtual ~wxControlBase();
// Create() function adds the validator parameter
// initialize the common fields of wxCommandEvent
void InitCommandEvent(wxCommandEvent& event) const;
+
+ DECLARE_NO_COPY_CLASS(wxControlBase)
};
// ----------------------------------------------------------------------------
void OnContextHelp(wxCommandEvent& event);
private:
- DECLARE_CLASS(wxContextHelpButton)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxContextHelpButton)
DECLARE_EVENT_TABLE()
};
{
return wxItemContainer::GetClientObject(n);
}
+
+private:
+ DECLARE_NO_COPY_CLASS(wxControlWithItems);
};
#endif // wxUSE_CONTROLS
private:
// the one and only format we support
wxDataFormat m_format;
+
+ DECLARE_NO_COPY_CLASS(wxDataObjectSimple)
};
// ----------------------------------------------------------------------------
// the index of the preferred one (0 initially, so by default the first
// one is the preferred)
size_t m_preferred;
+
+ DECLARE_NO_COPY_CLASS(wxDataObjectComposite)
};
// ============================================================================
{ return(wxDataObjectSimple::GetDataHere(format, pBuf)); }
bool SetData(const wxDataFormat& format, size_t nLen, const void* pBuf)
{ return(wxDataObjectSimple::SetData(format, nLen, pBuf)); }
+
+ DECLARE_NO_COPY_CLASS(wxTextDataObject)
};
// ----------------------------------------------------------------------------
protected:
wxBitmap m_bitmap;
+
+ DECLARE_NO_COPY_CLASS(wxBitmapDataObjectBase)
};
// ----------------------------------------------------------------------------
{ return(wxDataObjectSimple::GetDataSize(format)); }
bool GetDataHere(const wxDataFormat& format, void* pBuf) const
{ return(wxDataObjectSimple::GetDataHere(format, pBuf)); }
+
+ DECLARE_NO_COPY_CLASS(wxFileDataObjectBase)
};
// ----------------------------------------------------------------------------
return SetToWeekDay(weekday, -1, month, year);
}
-inline wxDateTime wxDateTime::GetWeekDayInSameWeek(WeekDay weekday,
- WeekFlags flags) const
+inline wxDateTime
+wxDateTime::GetWeekDayInSameWeek(WeekDay weekday,
+ WeekFlags WXUNUSED(flags)) const
{
MODIFY_AND_RETURN( SetToWeekDayInSameWeek(weekday) );
}
wxDC& m_dc;
wxColour m_colFgOld;
+
+ DECLARE_NO_COPY_CLASS(wxDCTextColourChanger)
};
// ----------------------------------------------------------------------------
private:
wxDC& m_dc;
+
+ DECLARE_NO_COPY_CLASS(wxDCClipper)
};
#endif
// default copy ctor ok.
~wxBufferedPaintDC();
+
+ DECLARE_NO_COPY_CLASS(wxBufferedPaintDC)
};
wxMirrorDC& m_dc;
bool m_mirror;
+
+ DECLARE_NO_COPY_CLASS(wxMirrorDC)
};
#endif // _WX_DCMIRROR_H_
// suppress some Visual C++ warnings
#ifdef __VISUALC__
+ // the only "real" warning here is 4244 but there arej ust too many of them
+ // in our code... one day someone should go and fix them but until then...
# pragma warning(disable:4201) // nonstandard extension used: nameless struct/union
# pragma warning(disable:4244) // conversion from double to float
-# pragma warning(disable:4100) // unreferenced formal parameter
-# pragma warning(disable:4511) // copy ctor couldn't be generated
-# pragma warning(disable:4512) // operator=() couldn't be generated
-# pragma warning(disable:4699) // using precompiled header
-# pragma warning(disable:4134) // conversion between pointers to members of same class
# pragma warning(disable:4710) // function not inlined
# pragma warning(disable:4097) // typedef used as class
#ifndef WIN32
// the return code from modal dialog
int m_returnCode;
+ DECLARE_NO_COPY_CLASS(wxDialogBase)
DECLARE_EVENT_TABLE()
WX_DECLARE_CONTROL_CONTAINER();
};
virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxTextDropTarget)
};
// A drop target which accepts files (dragged from File Manager or Explorer)
const wxArrayString& filenames) = 0;
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxFileDropTarget)
};
#endif // wxUSE_DRAG_AND_DROP
private:
wxEvent& m_event;
int m_propagationLevelOld;
+
+ DECLARE_NO_COPY_CLASS(wxPropagationDisabler)
};
/*
private:
wxEvent& m_event;
+
+ DECLARE_NO_COPY_CLASS(wxPropagateOnce)
};
#if wxUSE_GUI
class WXDLLIMPEXP_CORE wxCommandEvent : public wxEvent
{
-private:
- wxCommandEvent& operator=(const wxCommandEvent& event);
-
public:
wxCommandEvent(wxEventType commandType = wxEVT_NULL, int winid = 0);
wxClientData* m_clientObject; // Arbitrary client object
private:
- DECLARE_DYNAMIC_CLASS(wxCommandEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCommandEvent)
};
// this class adds a possibility to react (from the user) code to a control
bool m_bAllow;
private:
- DECLARE_DYNAMIC_CLASS(wxNotifyEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNotifyEvent)
};
// Scroll event class, derived form wxCommandEvent. wxScrollEvents are
virtual wxEvent *Clone() const { return new wxScrollEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxScrollEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxScrollEvent)
};
// ScrollWin event class, derived fom wxEvent. wxScrollWinEvents
long m_extraLong;
private:
- DECLARE_DYNAMIC_CLASS(wxScrollWinEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxScrollWinEvent)
};
// Mouse event class
wxCursor m_cursor;
private:
- DECLARE_DYNAMIC_CLASS(wxSetCursorEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSetCursorEvent)
};
// Keyboard input event class
wxRect m_rect; // Used for wxEVT_SIZING
private:
- DECLARE_DYNAMIC_CLASS(wxSizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSizeEvent)
};
// Move event class
wxRect m_rect;
private:
- DECLARE_DYNAMIC_CLASS(wxMoveEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMoveEvent)
};
// Paint event class
virtual wxEvent *Clone() const { return new wxPaintEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxPaintEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxPaintEvent)
};
class WXDLLIMPEXP_CORE wxNcPaintEvent : public wxEvent
virtual wxEvent *Clone() const { return new wxNcPaintEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxNcPaintEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNcPaintEvent)
};
// Erase background event class
class WXDLLIMPEXP_CORE wxEraseEvent : public wxEvent
{
-private:
- wxEraseEvent& operator=(const wxEraseEvent& event);
-
public:
wxEraseEvent(int Id = 0, wxDC *dc = (wxDC *) NULL)
: wxEvent(Id, wxEVT_ERASE_BACKGROUND),
wxDC *m_dc;
private:
- DECLARE_DYNAMIC_CLASS(wxEraseEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxEraseEvent)
};
// Focus event class
class WXDLLIMPEXP_CORE wxFocusEvent : public wxEvent
{
-private:
- wxFocusEvent& operator=(const wxFocusEvent& event);
-
public:
wxFocusEvent(wxEventType type = wxEVT_NULL, int winid = 0)
: wxEvent(winid, type)
wxWindow *m_win;
private:
- DECLARE_DYNAMIC_CLASS(wxFocusEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxFocusEvent)
};
// wxChildFocusEvent notifies the parent that a child has got the focus: unlike
virtual wxEvent *Clone() const { return new wxChildFocusEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxChildFocusEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxChildFocusEvent)
};
// Activate event class
bool m_active;
private:
- DECLARE_DYNAMIC_CLASS(wxActivateEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxActivateEvent)
};
// InitDialog event class
virtual wxEvent *Clone() const { return new wxInitDialogEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxInitDialogEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxInitDialogEvent)
};
// Miscellaneous menu event class
public:
wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0, wxMenu* menu = NULL)
: wxEvent(winid, type)
- { m_menuId = winid; m_menu = NULL; }
+ { m_menuId = winid; m_menu = menu; }
wxMenuEvent(const wxMenuEvent & event)
: wxEvent(event)
{ m_menuId = event.m_menuId; m_menu = event.m_menu; }
int m_menuId;
wxMenu* m_menu;
- DECLARE_DYNAMIC_CLASS(wxMenuEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMenuEvent)
};
// Window close or session close event class
#endif
private:
- DECLARE_DYNAMIC_CLASS(wxCloseEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCloseEvent)
};
bool m_show;
private:
- DECLARE_DYNAMIC_CLASS(wxShowEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxShowEvent)
};
/*
bool m_iconized;
private:
- DECLARE_DYNAMIC_CLASS(wxIconizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxIconizeEvent)
};
/*
wxEVT_MAXIMIZE
virtual wxEvent *Clone() const { return new wxMaximizeEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxMaximizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMaximizeEvent)
};
// Joystick event class
virtual wxEvent *Clone() const { return new wxJoystickEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxJoystickEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxJoystickEvent)
};
// Drop files event class
class WXDLLIMPEXP_CORE wxDropFilesEvent : public wxEvent
{
-private:
- wxDropFilesEvent& operator=(const wxDropFilesEvent& event);
-
public:
int m_noFiles;
wxPoint m_pos;
virtual wxEvent *Clone() const { return new wxDropFilesEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxDropFilesEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxDropFilesEvent)
};
// Update UI event
static wxUpdateUIMode sm_updateMode;
private:
- DECLARE_DYNAMIC_CLASS(wxUpdateUIEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxUpdateUIEvent)
};
/*
virtual wxEvent *Clone() const { return new wxSysColourChangedEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxSysColourChangedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSysColourChangedEvent)
};
/*
class WXDLLIMPEXP_CORE wxMouseCaptureChangedEvent : public wxEvent
{
-private:
- wxMouseCaptureChangedEvent operator=(const wxMouseCaptureChangedEvent& event);
-
public:
wxMouseCaptureChangedEvent(wxWindowID winid = 0, wxWindow* gainedCapture = NULL)
: wxEvent(winid, wxEVT_MOUSE_CAPTURE_CHANGED),
private:
wxWindow* m_gainedCapture;
- DECLARE_DYNAMIC_CLASS(wxMouseCaptureChangedEvent)
+
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxMouseCaptureChangedEvent)
};
/*
class WXDLLIMPEXP_CORE wxDisplayChangedEvent : public wxEvent
{
private:
- DECLARE_DYNAMIC_CLASS(wxDisplayChangedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxDisplayChangedEvent)
public:
wxDisplayChangedEvent()
class WXDLLIMPEXP_CORE wxPaletteChangedEvent : public wxEvent
{
-private:
- wxPaletteChangedEvent& operator=(const wxPaletteChangedEvent& event);
-
public:
wxPaletteChangedEvent(wxWindowID winid = 0)
: wxEvent(winid, wxEVT_PALETTE_CHANGED),
wxWindow* m_changedWindow;
private:
- DECLARE_DYNAMIC_CLASS(wxPaletteChangedEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxPaletteChangedEvent)
};
/*
bool m_paletteRealized;
private:
- DECLARE_DYNAMIC_CLASS(wxQueryNewPaletteEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxQueryNewPaletteEvent)
};
/*
// NB: don't derive from command event to avoid being propagated to the parent
class WXDLLIMPEXP_CORE wxNavigationKeyEvent : public wxEvent
{
-private:
- wxNavigationKeyEvent& operator=(const wxNavigationKeyEvent& event);
-
public:
wxNavigationKeyEvent()
: wxEvent(0, wxEVT_NAVIGATION_KEY),
wxWindow *m_focus;
private:
- DECLARE_DYNAMIC_CLASS(wxNavigationKeyEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxNavigationKeyEvent)
};
// Window creation/destruction events: the first is sent as soon as window is
virtual wxEvent *Clone() const { return new wxWindowCreateEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxWindowCreateEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxWindowCreateEvent)
};
class WXDLLIMPEXP_CORE wxWindowDestroyEvent : public wxCommandEvent
virtual wxEvent *Clone() const { return new wxWindowDestroyEvent(*this); }
private:
- DECLARE_DYNAMIC_CLASS(wxWindowDestroyEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxWindowDestroyEvent)
};
// A help event is sent when the user clicks on a window in context-help mode.
wxString m_link;
private:
- DECLARE_DYNAMIC_CLASS(wxHelpEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxHelpEvent)
};
// A Context event is sent when the user right clicks on a window or
wxPoint m_pos;
private:
- DECLARE_DYNAMIC_CLASS(wxContextMenuEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxContextMenuEvent)
};
// Idle event
static wxIdleMode sm_idleMode;
private:
- DECLARE_DYNAMIC_CLASS(wxIdleEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxIdleEvent)
};
#endif // wxUSE_GUI
// objects will have been initialized (including the event type constants)
// and so it will have the correct value when it is needed
const int& m_eventType;
+
+private:
+ wxEventTableEntry& operator=(const wxEventTableEntry&);
};
class WXDLLIMPEXP_BASE wxEvtHandler;
// EventFunction is always a member of the EventHandler receiving the
// message
wxEvtHandler* m_eventSink;
+
+ DECLARE_NO_COPY_CLASS(wxDynamicEventTableEntry)
};
#endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
size_t m_size;
EventTypeTablePointer *m_eventTypeTable;
+
+ DECLARE_NO_COPY_CLASS(wxEventHashTable)
};
// ----------------------------------------------------------------------------
virtual void *DoGetClientData() const;
private:
- DECLARE_NO_COPY_CLASS(wxEvtHandler)
- DECLARE_DYNAMIC_CLASS(wxEvtHandler)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxEvtHandler)
};
// Post a message to the given eventhandler which will be processed during the
private:
wxString m_strReplace;
- DECLARE_DYNAMIC_CLASS(wxFindDialogEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxFindDialogEvent)
};
BEGIN_DECLARE_EVENT_TYPES()
{ if ( data ) m_fontData = *data; }
wxFontData m_fontData;
+
+ DECLARE_NO_COPY_CLASS(wxFontDialogBase)
};
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxGaugeBase : public wxControl
{
public:
+ wxGaugeBase() { }
virtual ~wxGaugeBase();
bool Create(wxWindow *parent,
// the current position
int m_gaugePos;
+
+ DECLARE_NO_COPY_CLASS(wxGaugeBase)
};
#if defined(__WXUNIVERSAL__)
wxString m_stringSelection;
private:
- DECLARE_DYNAMIC_CLASS(wxSingleChoiceDialog)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxSingleChoiceDialog)
DECLARE_EVENT_TABLE()
};
wxArrayInt m_selections;
private:
- DECLARE_DYNAMIC_CLASS(wxMultiChoiceDialog)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxMultiChoiceDialog)
};
// ----------------------------------------------------------------------------
private:
size_t m_maxChars; // max number of chars allowed
wxString m_startValue;
+
+ DECLARE_NO_COPY_CLASS(wxGridCellTextEditor)
};
// the editor for numeric (long) data
m_max;
long m_valueOld;
+
+ DECLARE_NO_COPY_CLASS(wxGridCellNumberEditor)
};
// the editor for floating point numbers (double) data
int m_width,
m_precision;
double m_valueOld;
+
+ DECLARE_NO_COPY_CLASS(wxGridCellFloatEditor)
};
#endif // wxUSE_TEXTCTRL
class WXDLLEXPORT wxGridCellBoolEditor : public wxGridCellEditor
{
public:
+ wxGridCellBoolEditor() { }
+
virtual void Create(wxWindow* parent,
wxWindowID id,
wxEvtHandler* evtHandler);
private:
bool m_startValue;
+
+ DECLARE_NO_COPY_CLASS(wxGridCellBoolEditor)
};
#endif // wxUSE_CHECKBOX
wxString m_startValue;
wxArrayString m_choices;
bool m_allowOthers;
+
+ DECLARE_NO_COPY_CLASS(wxGridCellChoiceEditor)
};
#endif // wxUSE_COMBOBOX
wxArrayString m_rowLabels;
wxArrayString m_colLabels;
- DECLARE_DYNAMIC_CLASS( wxGridStringTable )
+ DECLARE_DYNAMIC_CLASS_NO_COPY( wxGridStringTable )
};
bool m_shift;
bool m_alt;
- DECLARE_DYNAMIC_CLASS(wxGridEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxGridEvent)
};
class WXDLLEXPORT wxGridSizeEvent : public wxNotifyEvent
bool m_shift;
bool m_alt;
- DECLARE_DYNAMIC_CLASS(wxGridSizeEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxGridSizeEvent)
};
bool m_shift;
bool m_alt;
- DECLARE_DYNAMIC_CLASS(wxGridRangeSelectEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxGridRangeSelectEvent)
};
private:
long int m_startint;
+
+ DECLARE_NO_COPY_CLASS(wxGridCellEnumEditor)
};
#endif // wxUSE_COMBOBOX
virtual wxGridCellEditor *Clone() const
{ return new wxGridCellAutoWrapStringEditor; }
+
+ DECLARE_NO_COPY_CLASS(wxGridCellAutoWrapStringEditor)
};
class WXDLLEXPORT wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
void Init();
private:
- DECLARE_DYNAMIC_CLASS(wxPanel)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxPanel)
DECLARE_EVENT_TABLE()
};
#endif // __WXMSW__
private:
- DECLARE_ABSTRACT_CLASS(wxGenericScrolledWindow)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxGenericScrolledWindow)
DECLARE_EVENT_TABLE()
};
} pt; // position of double click for DCLICK event
} m_data;
- DECLARE_DYNAMIC_CLASS(wxSplitterEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxSplitterEvent)
};
typedef void (wxEvtHandler::*wxSplitterEventFunction)(wxSplitterEvent&);
((listclass *)m_hashTable[slot])->Append(value, data); \
m_count++; \
} \
+ \
+ DECLARE_NO_COPY_CLASS(hashclass) \
}
#endif
wxString m_Word;
bool m_allowLinebreak;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlWordCell)
};
protected:
wxColour m_Colour;
unsigned m_Flags;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlColourCell)
};
protected:
wxFont m_Font;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlFontCell)
};
#define TAG_HANDLER_END(name) \
+ DECLARE_NO_COPY_CLASS(HTML_Handler_##name) \
};
wxListItem m_item;
private:
- DECLARE_DYNAMIC_CLASS(wxListEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxListEvent)
};
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxListBoxBase : public wxControlWithItems
{
public:
- // all generic methods are in wxControlWithItems, except for the following
- // ones which are not yet implemented by wxChoice/wxCombobox
+ wxListBoxBase() { }
virtual ~wxListBoxBase();
+ // all generic methods are in wxControlWithItems, except for the following
+ // ones which are not yet implemented by wxChoice/wxCombobox
void Insert(const wxString& item, int pos)
{ DoInsert(item, pos); }
void Insert(const wxString& item, int pos, void *clientData)
virtual void DoSetItems(const wxArrayString& items, void **clientData) = 0;
virtual void DoSetFirstItem(int n) = 0;
+
+ DECLARE_NO_COPY_CLASS(wxListBoxBase)
};
// ----------------------------------------------------------------------------
void ClearColumnImage(int col) { SetColumnImage(col, -1); }
private:
- DECLARE_DYNAMIC_CLASS(wxListView)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxListView)
};
#endif // wxUSE_LISTCTRL
{
public:
wxLogPassThrough();
+
+private:
+ DECLARE_NO_COPY_CLASS(wxLogPassThrough)
};
#if wxUSE_GUI
0) // don't use any files
{
}
+
+ DECLARE_NO_COPY_CLASS(wxMemoryConfig)
};
#endif // wxUSE_CONFIG
virtual bool OnWrite(wxTextFileType WXUNUSED(typeNew),
wxMBConv& WXUNUSED(conv) = wxConvUTF8)
{ return TRUE; }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxMemoryText)
};
#endif // wxUSE_TEXTBUFFER
bool m_keepGoing;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxApp)
};
int WXDLLEXPORT wxEntry(WXHINSTANCE hInstance, WXHINSTANCE hPrevInstance,
virtual void DrawButtonDisable( WXHDC dc, int left, int top, int right, int bottom, bool with_marg );
private:
- DECLARE_DYNAMIC_CLASS(wxBitmapButton)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxBitmapButton)
};
#endif
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const ;
private:
- DECLARE_DYNAMIC_CLASS(wxButton)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxButton)
};
#endif
private:
bool m_hasCaret;
+
+ DECLARE_NO_COPY_CLASS(wxCaret)
};
#endif // _WX_CARET_H_
virtual wxSize DoGetBestSize() const;
private:
- DECLARE_DYNAMIC_CLASS(wxCheckBox)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxCheckBox)
};
#endif
size_t m_nItemHeight; // height of checklistbox items (the same for all)
DECLARE_EVENT_TABLE()
- DECLARE_DYNAMIC_CLASS(wxCheckListBox)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxCheckListBox)
};
#endif //_CHECKLST_H
class WXDLLEXPORT wxChoice : public wxChoiceBase
{
- DECLARE_DYNAMIC_CLASS(wxChoice)
-
public:
// ctors
wxChoice() { }
// free all memory we have (used by Clear() and dtor)
void Free();
+
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxChoice)
};
#endif // _WX_CHOICE_H_
wxPoint m_pos;
- DECLARE_DYNAMIC_CLASS(wxColourDialog)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxColourDialog)
};
#endif
class WXDLLEXPORT wxComboBox: public wxChoice
{
- DECLARE_DYNAMIC_CLASS(wxComboBox)
-
public:
wxComboBox() { }
WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
WXHWND GetEditHWND() const;
+
+private:
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxComboBox)
};
#endif // wxUSE_COMBOBOX
class WXDLLEXPORT wxControl : public wxControlBase
{
public:
- wxControl();
- wxControl(wxWindow *parent, wxWindowID id,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize, long style = 0,
- const wxValidator& validator = wxDefaultValidator,
- const wxString& name = wxControlNameStr)
+ wxControl();
+ wxControl(wxWindow *parent, wxWindowID id,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxValidator& validator = wxDefaultValidator,
+ const wxString& name = wxControlNameStr)
{
Create(parent, id, pos, size, style, validator, name);
}
wxArrayLong m_subControls;
private:
- DECLARE_ABSTRACT_CLASS(wxControl)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxControl)
DECLARE_EVENT_TABLE()
};
public:
wxDCTemp(WXHDC hdc) { SetHDC(hdc); }
virtual ~wxDCTemp() { SetHDC((WXHDC)NULL); }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxDCTemp)
};
#endif
virtual void DoGetSize(int *width, int *height) const;
private:
- DECLARE_DYNAMIC_CLASS(wxWindowDC)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxWindowDC)
};
class WXDLLEXPORT wxClientDC : public wxWindowDC
virtual void DoGetSize(int *width, int *height) const;
private:
- DECLARE_DYNAMIC_CLASS(wxClientDC)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxClientDC)
};
class WXDLLEXPORT wxPaintDC : public wxClientDC
wxPaintDCInfo *FindInCache(size_t *index = NULL) const;
private:
- DECLARE_DYNAMIC_CLASS(wxPaintDC)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxPaintDC)
};
#endif
void Init();
private:
- DECLARE_DYNAMIC_CLASS(wxMemoryDC)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxMemoryDC)
};
#endif
wxPrintData m_printData;
private:
- DECLARE_CLASS(wxPrinterDC)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxPrinterDC)
};
// Gets an HDC for the default printer configuration
virtual void DoGetSize(int *width, int *height) const;
private:
- DECLARE_DYNAMIC_CLASS(wxScreenDC)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxScreenDC)
};
#endif
wxString m_path;
private:
- DECLARE_DYNAMIC_CLASS(wxDirDialog)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxDirDialog)
};
#endif
: wxFontDialogBase(parent, data) { Create(parent, data); }
protected:
- DECLARE_DYNAMIC_CLASS(wxFontDialog)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxFontDialog)
};
#endif
bool m_wasMinimized;
DECLARE_EVENT_TABLE()
- DECLARE_DYNAMIC_CLASS(wxFrame)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxFrame)
};
#endif
// Group box
class WXDLLEXPORT wxGauge95 : public wxControl
{
- DECLARE_DYNAMIC_CLASS(wxGauge95)
-
public:
wxGauge95(void) { m_rangeMax = 0; m_gaugePos = 0; }
protected:
int m_rangeMax;
int m_gaugePos;
+
+
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxGauge95)
};
#endif // wxUSE_GAUGE
#endif
private:
- DECLARE_DYNAMIC_CLASS(wxListBox)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxListBox)
};
#endif // wxUSE_LISTBOX
bool m_needsResize; // flag which tells us to artificially resize the frame
DECLARE_EVENT_TABLE()
- DECLARE_DYNAMIC_CLASS(wxMDIChildFrame)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxMDIChildFrame)
};
// ---------------------------------------------------------------------------
private:
DECLARE_EVENT_TABLE()
- DECLARE_DYNAMIC_CLASS(wxMDIClientWindow)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxMDIClientWindow)
};
#endif
wxAcceleratorArray m_accels;
#endif // wxUSE_ACCEL
- DECLARE_DYNAMIC_CLASS(wxMenu)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxMenu)
};
// ----------------------------------------------------------------------------
#endif
private:
- DECLARE_DYNAMIC_CLASS(wxMenuBar)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxMenuBar)
};
#endif // _WX_MENU_H_
// does this item start a radio group?
bool m_isRadioGroupStart;
- DECLARE_DYNAMIC_CLASS(wxMenuItem)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxMenuItem)
};
#endif //_MENUITEM_H
int m_nSelection;
- DECLARE_DYNAMIC_CLASS(wxNotebook)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxNotebook)
DECLARE_EVENT_TABLE()
};
virtual size_t GetDataSize() const;
virtual bool GetDataHere(void *buf) const;
virtual bool SetData(size_t len, const void *buf);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxBitmapDataObject2)
};
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxFileDataObject : public wxFileDataObjectBase
{
public:
+ wxFileDataObject() { }
+
// implement base class pure virtuals
virtual bool SetData(size_t len, const void *buf);
virtual size_t GetDataSize() const;
virtual bool GetDataHere(void *pData) const;
virtual void AddFile(const wxString& file);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxFileDataObject)
};
// ----------------------------------------------------------------------------
// get the HWND to be used as parent of this window with CreateWindow()
virtual WXHWND MSWGetParent() const;
- DECLARE_DYNAMIC_CLASS(wxPopupWindow)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxPopupWindow)
};
#endif // _WX_MSW_POPUPWIN_H_
class WXDLLEXPORT wxWindowsPrintPreview : public wxPrintPreviewBase
{
- DECLARE_CLASS(wxWindowsPrintPreview)
-
public:
wxWindowsPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting = NULL,
virtual bool Print(bool interactive);
virtual void DetermineScaling();
+
+private:
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxWindowsPrintPreview)
};
#endif
// see the comments in SetFocus()
bool m_focusJustSet;
- DECLARE_DYNAMIC_CLASS(wxRadioButton)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxRadioButton)
};
#endif
// Scrollbar item
class WXDLLEXPORT wxScrollBar: public wxScrollBarBase
{
- DECLARE_DYNAMIC_CLASS(wxScrollBar)
-
public:
wxScrollBar() { m_pageSize = 0; m_viewSize = 0; m_objectSize = 0; }
~wxScrollBar();
int m_objectSize;
DECLARE_EVENT_TABLE()
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxScrollBar)
};
#endif
int width, int height,
int sizeFlags = wxSIZE_AUTO);
- DECLARE_DYNAMIC_CLASS(wxSlider95)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxSlider95)
};
#endif
virtual wxSize DoGetBestSize() const;
private:
- DECLARE_DYNAMIC_CLASS(wxSpinButton)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxSpinButton)
};
#endif
virtual wxSize DoGetBestSize() const;
private:
- DECLARE_DYNAMIC_CLASS(wxStaticBox)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticBox)
};
#endif
void DoMoveWindow(int x, int y, int width, int height);
private:
- DECLARE_DYNAMIC_CLASS(wxStatusBar95);
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxStatusBar95);
};
#endif // wxUSE_NATIVE_STATUSBAR
class WXDLLEXPORT wxStaticLine : public wxStaticLineBase
{
- DECLARE_DYNAMIC_CLASS(wxStaticLine)
-
public:
// constructors and pseudo-constructors
wxStaticLine() { }
protected:
// usually overridden base class virtuals
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const;
+
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticLine)
};
#endif // _WX_MSW_STATLINE_H_
virtual wxSize DoGetBestSize() const;
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const;
- DECLARE_DYNAMIC_CLASS(wxStaticText)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticText)
};
#endif
class WXDLLEXPORT wxTaskBarIcon: public wxTaskBarIconBase
{
- DECLARE_DYNAMIC_CLASS(wxTaskBarIcon)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxTaskBarIcon)
public:
wxTaskBarIcon(void);
virtual ~wxTaskBarIcon(void);
private:
DECLARE_EVENT_TABLE()
- DECLARE_DYNAMIC_CLASS(wxTextCtrl)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxTextCtrl)
wxMenu* m_privateContextMenu;
long m_id;
private:
- DECLARE_ABSTRACT_CLASS(wxTimer)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxTimer)
};
#endif
// hit test, returns which tab is hit and, optionally, where (icon, label)
// (not implemented on all platforms)
- virtual int HitTest(const wxPoint& pt, long *flags = NULL) const
+ virtual int HitTest(const wxPoint& WXUNUSED(pt),
+ long * WXUNUSED(flags) = NULL) const
{
return wxNOT_FOUND;
}
int m_nSel, // currently selected page
m_nOldSel; // previously selected page
- DECLARE_DYNAMIC_CLASS(wxNotebookEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxNotebookEvent)
};
// ----------------------------------------------------------------------------
virtual wxClassInfo *GetClassInfo() const \
{ return &name::sm_class##name; }
+#define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name) \
+ private: \
+ name& operator=(const name&); \
+ DECLARE_DYNAMIC_CLASS(name)
+
+#define DECLARE_DYNAMIC_CLASS_NO_COPY(name) \
+ DECLARE_NO_COPY_CLASS(name) \
+ DECLARE_DYNAMIC_CLASS(name)
+
#define DECLARE_ABSTRACT_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
#define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
// the point must be given in screen coordinates!
virtual void Position(const wxPoint& ptOrigin,
const wxSize& size);
+
+ DECLARE_NO_COPY_CLASS(wxPopupWindowBase)
};
private:
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxPrintAbortDialog)
};
#endif // wxUSE_PRINTING_ARCHITECTURE
int m_pid,
m_exitcode;
- DECLARE_DYNAMIC_CLASS(wxProcessEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxProcessEvent)
};
typedef void (wxEvtHandler::*wxProcessEventFunction)(wxProcessEvent&);
#include "wx/url.h"
class WXDLLIMPEXP_BASE wxFileProto: public wxProtocol {
- DECLARE_DYNAMIC_CLASS(wxFileProto)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxFileProto)
DECLARE_PROTOCOL(wxFileProto)
protected:
wxProtocolError m_error;
friend class wxInputFTPStream;
friend class wxOutputFTPStream;
- DECLARE_DYNAMIC_CLASS(wxFTP)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxFTP)
DECLARE_PROTOCOL(wxFTP)
};
virtual void SetPassword(const wxString& WXUNUSED(passwd) ) {}
private:
- DECLARE_ABSTRACT_CLASS(wxProtocol)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxProtocol)
};
#if wxUSE_SOCKETS
protected:
wxRendererNative& m_rendererNative;
+
+ DECLARE_NO_COPY_CLASS(wxDelegateRendererNative)
};
#endif // _WX_RENDERER_H_
public:
wxSocketStream(wxSocketBase& s);
~wxSocketStream();
+
+ DECLARE_NO_COPY_CLASS(wxSocketStream)
};
#endif
class WXDLLEXPORT wxScrollBarBase : public wxControl
{
public:
+ wxScrollBarBase() { }
+
// scrollbar construction
bool Create(wxWindow *parent,
wxWindowID id,
virtual void SetScrollbar(int position, int thumbSize,
int range, int pageSize,
bool refresh = TRUE) = 0;
+
+private:
+ DECLARE_NO_COPY_CLASS(wxScrollBarBase)
};
#if defined(__WXUNIVERSAL__)
}
private:
- DECLARE_CLASS(wxScrolledWindow)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxScrolledWindow)
};
#define wxSCROLLED_WINDOW_IS_GENERIC 1
#endif
// _WX_SCROLWIN_H_BASE_
-// vi:sts=4:sw=4:et
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
*/
+ wxSliderBase() { }
// get/set the current slider value (should be in range)
virtual int GetValue() const = 0;
virtual int GetSelEnd() const { return GetMin(); }
virtual int GetSelStart() const { return GetMax(); }
virtual void SetSelection(int WXUNUSED(min), int WXUNUSED(max)) { }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxSliderBase)
};
// ----------------------------------------------------------------------------
wxSocketNotify m_event;
void *m_clientData;
- DECLARE_DYNAMIC_CLASS(wxSocketEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxSocketEvent)
};
// the range value
int m_min;
int m_max;
+
+ DECLARE_NO_COPY_CLASS(wxSpinButtonBase)
};
// ----------------------------------------------------------------------------
void SetPosition(int pos) { m_commandInt = pos; }
private:
- DECLARE_DYNAMIC_CLASS(wxSpinEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxSpinEvent)
};
typedef void (wxEvtHandler::*wxSpinEventFunction)(wxSpinEvent&);
// a control showing an icon or a bitmap
class WXDLLEXPORT wxStaticBitmapBase : public wxControl
{
- public:
+public:
+ wxStaticBitmapBase() { }
virtual ~wxStaticBitmapBase();
// our interface
protected:
virtual wxSize DoGetBestClientSize() const;
+
+ DECLARE_NO_COPY_CLASS(wxStaticBitmapBase)
};
#if defined(__WXUNIVERSAL__)
class WXDLLEXPORT wxStaticBoxBase : public wxControl
{
public:
+ wxStaticBoxBase() { }
+
// overriden base class virtuals
virtual bool AcceptsFocus() const { return FALSE; }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxStaticBoxBase)
};
#if defined(__WXUNIVERSAL__)
{
return AdjustSize(wxDefaultSize);
}
+
+ DECLARE_NO_COPY_CLASS(wxStaticLineBase)
};
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxStaticTextBase : public wxControl
{
public:
- // overriden base class virtuals
+ wxStaticTextBase() { }
+
+ // overriden base cirtuals
virtual bool AcceptsFocus() const { return FALSE; }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxStaticTextBase)
};
#if defined(__WXUNIVERSAL__)
size_t m_wbackcur;
friend class wxStreamBuffer;
+
+ DECLARE_NO_COPY_CLASS(wxInputStream)
};
// ----------------------------------------------------------------------------
virtual size_t OnSysWrite(const void *buffer, size_t bufsize);
friend class wxStreamBuffer;
+
+ DECLARE_NO_COPY_CLASS(wxOutputStream)
};
// ============================================================================
virtual off_t OnSysTell() const;
size_t m_currentPos;
+
+ DECLARE_NO_COPY_CLASS(wxCountingOutputStream)
};
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxTaskBarIconBase : public wxEvtHandler
{
+public:
+ wxTaskBarIconBase() { }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxTaskBarIconBase)
};
}
virtual wxEvent *Clone() const { return new wxTaskBarIconEvent(*this); }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxTaskBarIconEvent)
};
BEGIN_DECLARE_EVENT_TYPES()
private:
DECLARE_EVENT_TABLE()
- DECLARE_CLASS(wxToolBarBase)
+ DECLARE_NO_COPY_CLASS(wxToolBarBase)
};
// Helper function for creating the image for disabled buttons
// the text style which will be used for any new text added to the control
wxTextAttr m_defaultStyle;
+
+ DECLARE_NO_COPY_CLASS(wxTextCtrlBase)
};
// ----------------------------------------------------------------------------
m_end;
private:
- DECLARE_DYNAMIC_CLASS(wxTextUrlEvent)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxTextUrlEvent)
public:
// for wxWin RTTI only, don't use
virtual bool OnWrite(wxTextFileType typeNew, wxMBConv& conv);
private:
+
wxFile m_file;
+
+ DECLARE_NO_COPY_CLASS(wxTextFile)
};
#else // !wxUSE_TEXTFILE
private:
wxTimer& m_timer;
+
+ DECLARE_NO_COPY_CLASS(wxTimerRunner)
};
// ----------------------------------------------------------------------------
private:
int m_interval;
- DECLARE_DYNAMIC_CLASS(wxTimerEvent)
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxTimerEvent)
};
typedef void (wxEvtHandler::*wxTimerEventFunction)(wxTimerEvent&);
// Set the shape of the window to the given region.
// Returns TRUE if the platform supports this feature (and the
// operation is successful.)
- virtual bool SetShape(const wxRegion& region) { return FALSE; }
+ virtual bool SetShape(const wxRegion& WXUNUSED(region)) { return FALSE; }
// old functions, use the new ones instead!
#if WXWIN_COMPATIBILITY_2
// the frame icon
wxIconBundle m_icons;
+ DECLARE_NO_COPY_CLASS(wxTopLevelWindowBase)
DECLARE_EVENT_TABLE()
};
Create(parent, winid, title, pos, size, style, name);
}
- DECLARE_DYNAMIC_CLASS(wxTopLevelWindow)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxTopLevelWindow)
};
#endif // wxTopLevelWindowNative
#endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
#endif // _WX_TOPLEVEL_BASE_H_
-
-// vi:sts=4:sw=4:et
friend class WXDLLEXPORT wxTreeCtrl;
friend class WXDLLEXPORT wxGenericTreeCtrl;
- DECLARE_DYNAMIC_CLASS(wxTreeEvent);
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxTreeEvent);
};
typedef void (wxEvtHandler::*wxTreeEventFunction)(wxTreeEvent&);
// returns EOT (\4) if there is a stream error, or end of file
wxChar NextChar(); // this should be used instead of GetC() because of Unicode issues
wxChar NextNonSeparators();
+
+ DECLARE_NO_COPY_CLASS(wxTextInputStream)
};
typedef enum
wxMBConv &m_conv;
#endif
+ DECLARE_NO_COPY_CLASS(wxTextOutputStream)
};
#endif
DECLARE_NO_COPY_CLASS(wxFileOutputStream)
};
-class WXDLLIMPEXP_BASE wxFileStream: public wxFileInputStream, public wxFileOutputStream {
- public:
- wxFileStream(const wxString& fileName);
+class WXDLLIMPEXP_BASE wxFileStream : public wxFileInputStream,
+ public wxFileOutputStream
+{
+public:
+ wxFileStream(const wxString& fileName);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxFileStream)
};
// ----------------------------------------------------------------------------
DECLARE_NO_COPY_CLASS(wxFFileOutputStream)
};
-class WXDLLIMPEXP_BASE wxFFileStream: public wxFFileInputStream, public wxFFileOutputStream {
- public:
- wxFFileStream(const wxString& fileName);
+class WXDLLIMPEXP_BASE wxFFileStream : public wxFFileInputStream,
+ public wxFFileOutputStream
+{
+public:
+ wxFFileStream(const wxString& fileName);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxFFileStream)
};
+
#endif
// wxUSE_STREAMS && wxUSE_FILE
wxBitmap m_bitmap;
private:
- DECLARE_ABSTRACT_CLASS(wxWizardPage)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxWizardPage)
};
// ----------------------------------------------------------------------------
wxWizardPage *m_prev,
*m_next;
- DECLARE_DYNAMIC_CLASS(wxWizardPageSimple)
- DECLARE_NO_COPY_CLASS(wxWizardPageSimple)
+ DECLARE_DYNAMIC_CLASS_NO_COPY(wxWizardPageSimple)
};
// ----------------------------------------------------------------------------
const wxPoint& pos = wxDefaultPosition,
long style = wxDEFAULT_DIALOG_STYLE);
*/
+ wxWizardBase() { }
// executes the wizard starting from the given page, returns TRUE if it was
// successfully finished, FALSE if user cancelled it
virtual bool HasPrevPage(wxWizardPage *page)
{ return page->GetPrev() != NULL; }
+
+private:
+ DECLARE_NO_COPY_CLASS(wxWizardBase)
};
// include the real class declaration
return needMore;
}
-void wxAppBase::OnIdle(wxIdleEvent& event)
+void wxAppBase::OnIdle(wxIdleEvent& WXUNUSED(event))
{
// If there are pending events, we must process them: pending events
// are either events to the threads other than main or events posted
// ----------------------------------------------------------------------------
wxBitmap wxDefaultArtProvider::CreateBitmap(const wxArtID& id,
- const wxArtClient& client,
+ const wxArtClient& WXUNUSED(client),
const wxSize& WXUNUSED(size))
{
// wxMessageBox icons:
private:
wxArrayString& m_files;
+
+ DECLARE_NO_COPY_CLASS(wxDirTraverserSimple)
};
/* static */
const wxString& defaultFile,
const wxString& wildCard,
long style,
- const wxPoint& pos)
+ const wxPoint& WXUNUSED(pos))
{
m_parent = parent;
m_message = message;
private:
bool m_flagOld;
bool& m_flag;
+
+ DECLARE_NO_COPY_CLASS(ReentrancyBlocker)
};
// ============================================================================
class wxDummyConsoleApp : public wxAppConsole
{
public:
+ wxDummyConsoleApp() { }
+
virtual int OnRun() { wxFAIL_MSG( _T("unreachable code") ); return 0; }
+
+ DECLARE_NO_COPY_CLASS(wxDummyConsoleApp)
};
// we need a special kind of auto pointer to wxApp which not only deletes the
wxTheApp = ptr;
}
+
+ DECLARE_NO_COPY_CLASS(wxAppPtr)
};
// class to ensure that wxAppBase::CleanUp() is called if our Initialize()
// free it when doing cleanup to avoid memory leaks
wchar_t **argv;
#endif // wxUSE_UNICODE
+
+ DECLARE_NO_COPY_CLASS(InitData)
} gs_initData;
// ============================================================================
void Server_OnRequest(wxSocketEvent& event);
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxTCPEventHandler)
};
enum
// were we initialized successfully?
bool m_ok;
+
+ DECLARE_NO_COPY_CLASS(EC_CharSet)
};
#endif // wxUSE_FONTMAP
// wxWindows macros
// ----------------------------------------------------------------------------
-IMPLEMENT_CLASS(wxToolBarBase, wxControl)
-
BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
END_EVENT_TABLE()
return TRUE;
}
+#else
+ event;
#endif // !__WIN32__
return FALSE;
private:
wxTextFile m_textfile;
+
+ DECLARE_NO_COPY_CLASS(wxFileTipProvider)
};
#ifdef __WIN32__
class HP_Parser : public wxHtmlParser
{
public:
+ HP_Parser() { }
+
wxObject* GetProduct() { return NULL; }
+
protected:
virtual void AddText(const wxChar* WXUNUSED(txt)) {}
+
+ DECLARE_NO_COPY_CLASS(HP_Parser)
};
Set(p1, fromCell, p2, toCell);
}
-wxColour wxDefaultHtmlRenderingStyle::GetSelectedTextColour(
- const wxColour& clr)
+wxColour
+wxDefaultHtmlRenderingStyle::
+GetSelectedTextColour(const wxColour& WXUNUSED(clr))
{
return wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
}
-wxColour wxDefaultHtmlRenderingStyle::GetSelectedTextBgColour(
- const wxColour& WXUNUSED(clr))
+wxColour
+wxDefaultHtmlRenderingStyle::
+GetSelectedTextBgColour(const wxColour& WXUNUSED(clr))
{
return wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
}
// do nothing here
}
-void wxHtmlWindow::OnEraseBackground(wxEraseEvent& event)
+void wxHtmlWindow::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
{
}
}
-void wxHtmlWindow::OnMouseMove(wxMouseEvent& event)
+void wxHtmlWindow::OnMouseMove(wxMouseEvent& WXUNUSED(event))
{
m_tmpMouseMoved = true;
}
}
}
-void wxHtmlWindow::OnCopy(wxCommandEvent& event)
+void wxHtmlWindow::OnCopy(wxCommandEvent& WXUNUSED(event))
{
if ( m_selection )
CopySelection();
TAG_HANDLER_BEGIN(DEFLIST, "DL,DT,DD" )
+ TAG_HANDLER_CONSTR(DEFLIST) { }
+
TAG_HANDLER_PROC(tag)
{
wxHtmlContainerCell *c;
TAG_HANDLER_VARS
wxArrayString m_Faces;
+ TAG_HANDLER_CONSTR(FONT) { }
+
TAG_HANDLER_PROC(tag)
{
wxColour oldclr = m_WParser->GetActualColor();
TAG_HANDLER_BEGIN(FACES_U, "U,STRIKE")
+ TAG_HANDLER_CONSTR(FACES_U) { }
+
TAG_HANDLER_PROC(tag)
{
int underlined = m_WParser->GetFontUnderlined();
TAG_HANDLER_BEGIN(FACES_B, "B,STRONG")
+ TAG_HANDLER_CONSTR(FACES_B) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(FACES_I, "I,EM,CITE,ADDRESS")
+ TAG_HANDLER_CONSTR(FACES_I) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(FACES_TT, "TT,CODE,KBD,SAMP")
+ TAG_HANDLER_CONSTR(FACES_TT) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(Hx, "H1,H2,H3,H4,H5,H6")
+ TAG_HANDLER_CONSTR(Hx) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(BIGSMALL, "BIG,SMALL")
+ TAG_HANDLER_CONSTR(BIGSMALL) { }
TAG_HANDLER_PROC(tag)
{
private:
// Should we draw 3-D shading or not
bool m_HasShading;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlLineCell)
};
TAG_HANDLER_BEGIN(HR, "HR")
+ TAG_HANDLER_CONSTR(HR) { }
TAG_HANDLER_PROC(tag)
{
int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(view_y1), int WXUNUSED(view_y2),
wxHtmlRenderingInfo& WXUNUSED(info)) {}
+
+
+ DECLARE_NO_COPY_CLASS(wxHtmlImageMapAreaCell)
};
int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(view_y1), int WXUNUSED(view_y2),
wxHtmlRenderingInfo& WXUNUSED(info)) {}
+
+ DECLARE_NO_COPY_CLASS(wxHtmlImageMapCell)
};
//--------------------------------------------------------------------------------
TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
+ TAG_HANDLER_CONSTR(IMG) { }
TAG_HANDLER_PROC(tag)
{
}
TAG_HANDLER_BEGIN(P, "P")
+ TAG_HANDLER_CONSTR(P) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(BR, "BR")
+ TAG_HANDLER_CONSTR(BR) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(CENTER, "CENTER")
+ TAG_HANDLER_CONSTR(CENTER) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(DIV, "DIV")
+ TAG_HANDLER_CONSTR(DIV) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(TITLE, "TITLE")
+ TAG_HANDLER_CONSTR(TITLE) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(BODY, "BODY")
+ TAG_HANDLER_CONSTR(BODY) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(BLOCKQUOTE, "BLOCKQUOTE")
+ TAG_HANDLER_CONSTR(BLOCKQUOTE) { }
TAG_HANDLER_PROC(tag)
{
// Tag handler for tags that we have to ignore, otherwise non-text data
// would show up as text:
TAG_HANDLER_BEGIN(DoNothing, "SCRIPT")
- TAG_HANDLER_PROC(tag)
+ TAG_HANDLER_CONSTR(DoNothing) { }
+
+ TAG_HANDLER_PROC(WXUNUSED(tag))
{
return true;
}
return wxHtmlCell::Find(condition, param);
}
}
+
+ DECLARE_NO_COPY_CLASS(wxHtmlAnchorCell)
};
TAG_HANDLER_BEGIN(A, "A")
+ TAG_HANDLER_CONSTR(A) { }
TAG_HANDLER_PROC(tag)
{
wxHtmlListmarkCell(wxDC *dc, const wxColour& clr);
void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
wxHtmlRenderingInfo& info);
+
+ DECLARE_NO_COPY_CLASS(wxHtmlListmarkCell)
};
wxHtmlListmarkCell::wxHtmlListmarkCell(wxDC* dc, const wxColour& clr) : wxHtmlCell(), m_Brush(clr, wxSOLID)
TAG_HANDLER_BEGIN(PRE, "PRE")
+ TAG_HANDLER_CONSTR(PRE) { }
TAG_HANDLER_PROC(tag)
{
TAG_HANDLER_BEGIN(STYLE, "STYLE")
+ TAG_HANDLER_CONSTR(STYLE) { }
TAG_HANDLER_PROC(WXUNUSED(tag))
{
wxWindow *child = node->GetData();
ApplyThemeBackground(child, colour);
}
+#else
+ window;
+ colour;
#endif
}
private:
wxArrayTreeItemIds& m_selections;
+
+ DECLARE_NO_COPY_CLASS(TraverseSelections)
};
// internal class for counting tree items
private:
size_t m_count;
+
+ DECLARE_NO_COPY_CLASS(TraverseCounter)
};
// ----------------------------------------------------------------------------
projects / wxWidgets.git / commitdiff
