- Handle exceptions thrown from overridden wxView::OnCreate() gracefully.
- Added wxPATH_RMDIR_FULL/RECURSIVE wxFileName::Rmdir() flags (Marcin Malich).
- Added wxStandardPaths::GetAppDocumentsDir().
+- Added wx-prefixed versions of DECLARE_NO_{COPY,ASSIGN}_CLASS macros.
All (Unix):
class WXDLLIMPEXP_FWD_CORE wxRect;
class WXDLLIMPEXP_CORE wxAccessibleBase : public wxObject
{
- DECLARE_NO_COPY_CLASS(wxAccessibleBase)
+ wxDECLARE_NO_COPY_CLASS(wxAccessibleBase);
public:
wxAccessibleBase(wxWindow* win): m_window(win) {}
static wxCURHandler sm_handler;
- DECLARE_NO_COPY_CLASS(wxANIDecoder)
+ wxDECLARE_NO_COPY_CLASS(wxANIDecoder);
};
// the application object is a singleton anyhow, there is no sense in
// copying it
- DECLARE_NO_COPY_CLASS(wxAppConsoleBase)
+ wxDECLARE_NO_COPY_CLASS(wxAppConsoleBase);
};
#if defined(__UNIX__)
bool m_isInsideYield;
long m_eventsToProcessInsideYield;
- DECLARE_NO_COPY_CLASS(wxAppBase)
+ wxDECLARE_NO_COPY_CLASS(wxAppBase);
};
#if WXWIN_COMPATIBILITY_2_6
const wxArrayString * array;
} m_data;
- DECLARE_NO_ASSIGN_CLASS(wxArrayStringsAdapter)
+ wxDECLARE_NO_ASSIGN_CLASS(wxArrayStringsAdapter);
};
#endif // _WX_ARRSTR_H
m_marginY;
- DECLARE_NO_COPY_CLASS(wxBitmapButtonBase)
+ wxDECLARE_NO_COPY_CLASS(wxBitmapButtonBase);
};
#if WXWIN_COMPATIBILITY_2_6
unsigned int m_internalBorder;
DECLARE_ABSTRACT_CLASS(wxBookCtrlBase)
- DECLARE_NO_COPY_CLASS(wxBookCtrlBase)
+ wxDECLARE_NO_COPY_CLASS(wxBookCtrlBase);
DECLARE_EVENT_TABLE()
};
// the reference count
size_t m_ref;
- DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryBufferData);
};
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
- DECLARE_NO_COPY_CLASS(wxButtonBase)
+ wxDECLARE_NO_COPY_CLASS(wxButtonBase);
};
#if defined(__WXUNIVERSAL__)
wxDL_VOIDMETHOD_DEFINE( pango_cairo_show_layout,
(cairo_t *cr, PangoLayout *layout), (cr, layout) )
- DECLARE_NO_COPY_CLASS(wxCairoLibrary)
+ wxDECLARE_NO_COPY_CLASS(wxCairoLibrary);
};
#endif // wxUSE_CAIRO
int m_countVisible;
private:
- DECLARE_NO_COPY_CLASS(wxCaretBase)
+ wxDECLARE_NO_COPY_CLASS(wxCaretBase);
};
// ---------------------------------------------------------------------------
public:
wxCaretSuspend(wxWindow *WXUNUSED(win)) {}
- DECLARE_NO_COPY_CLASS(wxCaretSuspend)
+ wxDECLARE_NO_COPY_CLASS(wxCaretSuspend);
};
#else // !wxHAS_CARET_USING_OVERLAYS
wxCaret *m_caret;
bool m_show;
- DECLARE_NO_COPY_CLASS(wxCaretSuspend)
+ wxDECLARE_NO_COPY_CLASS(wxCaretSuspend);
};
#endif // wxHAS_CARET_USING_OVERLAYS/!wxHAS_CARET_USING_OVERLAYS
}
private:
- DECLARE_NO_COPY_CLASS(wxCheckBoxBase)
+ wxDECLARE_NO_COPY_CLASS(wxCheckBoxBase);
};
#if defined(__WXUNIVERSAL__)
virtual bool IsChecked(unsigned int item) const = 0;
virtual void Check(unsigned int item, bool check = true) = 0;
- DECLARE_NO_COPY_CLASS(wxCheckListBoxBase)
+ wxDECLARE_NO_COPY_CLASS(wxCheckListBoxBase);
};
#if defined(__WXUNIVERSAL__)
virtual bool IsSorted() const { return HasFlag(wxCB_SORT); }
private:
- DECLARE_NO_COPY_CLASS(wxChoiceBase)
+ wxDECLARE_NO_COPY_CLASS(wxChoiceBase);
};
// ----------------------------------------------------------------------------
private:
wxClipboard *m_clipboard;
- DECLARE_NO_COPY_CLASS(wxClipboardLocker)
+ wxDECLARE_NO_COPY_CLASS(wxClipboardLocker);
};
#endif // wxUSE_CLIPBOARD
mutable char **m_argsA;
mutable wchar_t **m_argsW;
- DECLARE_NO_COPY_CLASS(wxCmdLineArgsArray)
+ wxDECLARE_NO_COPY_CLASS(wxCmdLineArgsArray);
};
// provide global operator overload for compatibility with the existing code
struct wxCmdLineParserData *m_data;
- DECLARE_NO_COPY_CLASS(wxCmdLineParser)
+ wxDECLARE_NO_COPY_CLASS(wxCmdLineParser);
};
#else // !wxUSE_CMDLINE_PARSER
private:
DECLARE_DYNAMIC_CLASS(wxCommandProcessor)
- DECLARE_NO_COPY_CLASS(wxCommandProcessor)
+ wxDECLARE_NO_COPY_CLASS(wxCommandProcessor);
};
#endif // _WX_CMDPROC_H_
friend class WXDLLIMPEXP_FWD_CORE wxBitmap;
friend class WXDLLIMPEXP_FWD_CORE wxCursor;
- DECLARE_NO_COPY_CLASS(wxCursorRefData)
+ wxDECLARE_NO_COPY_CLASS(wxCursorRefData);
};
#define M_CURSORDATA ((wxCursorRefData *)m_refData)
class WXDLLIMPEXP_CORE wxCocoaDCImpl: public wxDCImpl
{
DECLARE_ABSTRACT_CLASS(wxCocoaDCImpl)
- DECLARE_NO_COPY_CLASS(wxCocoaDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxCocoaDCImpl);
//-------------------------------------------------------------------------
// Initialization
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDirDialog: public wxDirDialogBase
{
DECLARE_DYNAMIC_CLASS(wxDirDialog)
- DECLARE_NO_COPY_CLASS(wxDirDialog)
+ wxDECLARE_NO_COPY_CLASS(wxDirDialog);
public:
wxDirDialog(wxWindow *parent,
const wxString& message = wxDirSelectorPromptStr,
protected:
int m_exitcode;
- DECLARE_NO_COPY_CLASS(wxGUIEventLoop)
+ wxDECLARE_NO_COPY_CLASS(wxGUIEventLoop);
};
#endif // _WX_COCOA_EVTLOOP_H_
class WXDLLIMPEXP_CORE wxFileDialog: public wxFileDialogBase
{
DECLARE_DYNAMIC_CLASS(wxFileDialog)
- DECLARE_NO_COPY_CLASS(wxFileDialog)
+ wxDECLARE_NO_COPY_CLASS(wxFileDialog);
public:
wxFileDialog(wxWindow *parent,
const wxString& message = wxFileSelectorPromptStr,
virtual void DoSetCustomLabel(wxString& var, const ButtonLabel& label);
DECLARE_DYNAMIC_CLASS(wxCocoaMessageDialog)
- DECLARE_NO_COPY_CLASS(wxCocoaMessageDialog)
+ wxDECLARE_NO_COPY_CLASS(wxCocoaMessageDialog);
};
#endif // _WX_MSGDLG_H_
// ========================================================================
class wxWindowCocoaScrollView: protected wxCocoaNSView
{
- DECLARE_NO_COPY_CLASS(wxWindowCocoaScrollView)
+ wxDECLARE_NO_COPY_CLASS(wxWindowCocoaScrollView);
public:
wxWindowCocoaScrollView(wxWindow *owner);
virtual ~wxWindowCocoaScrollView();
class wxCocoaTrackingRectManager
{
- DECLARE_NO_COPY_CLASS(wxCocoaTrackingRectManager)
+ wxDECLARE_NO_COPY_CLASS(wxCocoaTrackingRectManager);
public:
wxCocoaTrackingRectManager(wxWindow *window);
void ClearTrackingRect();
class WXDLLIMPEXP_CORE wxWindowCocoa: public wxWindowBase, protected wxCocoaNSView
{
DECLARE_DYNAMIC_CLASS(wxWindowCocoa)
- DECLARE_NO_COPY_CLASS(wxWindowCocoa)
+ wxDECLARE_NO_COPY_CLASS(wxWindowCocoa);
DECLARE_EVENT_TABLE()
friend wxWindow *wxWindowBase::GetCapture();
friend class wxWindowCocoaScrollView;
m_strOldPath; // saved path
bool m_bChanged; // was the path changed?
- DECLARE_NO_COPY_CLASS(wxConfigPathChanger)
+ wxDECLARE_NO_COPY_CLASS(wxConfigPathChanger);
};
protected:
- DECLARE_NO_COPY_CLASS(wxControlContainer)
+ wxDECLARE_NO_COPY_CLASS(wxControlContainer);
};
// ----------------------------------------------------------------------------
// this field contains the label in wx format, i.e. with '&' mnemonics
wxString m_labelOrig;
- DECLARE_NO_COPY_CLASS(wxControlBase)
+ wxDECLARE_NO_COPY_CLASS(wxControlBase);
};
// ----------------------------------------------------------------------------
bool m_consumedBOM;
- DECLARE_NO_ASSIGN_CLASS(wxConvAuto)
+ wxDECLARE_NO_ASSIGN_CLASS(wxConvAuto);
};
#endif // wxUSE_WCHAR_T
protected:
wxHelpControllerBase* m_helpController;
- DECLARE_NO_COPY_CLASS(wxHelpControllerHelpProvider)
+ wxDECLARE_NO_COPY_CLASS(wxHelpControllerHelpProvider);
};
// Convenience function for turning context id into wxString
void InitCommandEventWithItems(wxCommandEvent& event, int n);
private:
- DECLARE_NO_COPY_CLASS(wxControlWithItemsBase)
+ wxDECLARE_NO_COPY_CLASS(wxControlWithItemsBase);
};
// define the platform-specific wxControlWithItems class
private:
DECLARE_ABSTRACT_CLASS(wxControlWithItems)
- DECLARE_NO_COPY_CLASS(wxControlWithItems)
+ wxDECLARE_NO_COPY_CLASS(wxControlWithItems);
};
#endif
// the one and only format we support
wxDataFormat m_format;
- DECLARE_NO_COPY_CLASS(wxDataObjectSimple)
+ wxDECLARE_NO_COPY_CLASS(wxDataObjectSimple);
};
// ----------------------------------------------------------------------------
wxDataFormat m_receivedFormat;
- DECLARE_NO_COPY_CLASS(wxDataObjectComposite)
+ wxDECLARE_NO_COPY_CLASS(wxDataObjectComposite);
};
// ============================================================================
private:
wxString m_text;
- DECLARE_NO_COPY_CLASS(wxTextDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxTextDataObject);
};
// ----------------------------------------------------------------------------
protected:
wxBitmap m_bitmap;
- DECLARE_NO_COPY_CLASS(wxBitmapDataObjectBase)
+ wxDECLARE_NO_COPY_CLASS(wxBitmapDataObjectBase);
};
// ----------------------------------------------------------------------------
protected:
wxArrayString m_filenames;
- DECLARE_NO_COPY_CLASS(wxFileDataObjectBase)
+ wxDECLARE_NO_COPY_CLASS(wxFileDataObjectBase);
};
// ----------------------------------------------------------------------------
size_t m_size;
void *m_data;
- DECLARE_NO_COPY_CLASS(wxCustomDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxCustomDataObject);
};
// ----------------------------------------------------------------------------
wxMBConv *m_conv;
#endif
- DECLARE_NO_COPY_CLASS(wxDataInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxDataInputStream);
};
class WXDLLIMPEXP_BASE wxDataOutputStream
wxMBConv *m_conv;
#endif
- DECLARE_NO_COPY_CLASS(wxDataOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxDataOutputStream);
};
#endif
private:
DECLARE_ABSTRACT_CLASS(wxDC)
- DECLARE_NO_COPY_CLASS(wxDC)
+ wxDECLARE_NO_COPY_CLASS(wxDC);
};
// ----------------------------------------------------------------------------
wxColour m_colFgOld;
- DECLARE_NO_COPY_CLASS(wxDCTextColourChanger)
+ wxDECLARE_NO_COPY_CLASS(wxDCTextColourChanger);
};
// ----------------------------------------------------------------------------
wxPen m_penOld;
- DECLARE_NO_COPY_CLASS(wxDCPenChanger)
+ wxDECLARE_NO_COPY_CLASS(wxDCPenChanger);
};
// ----------------------------------------------------------------------------
wxBrush m_brushOld;
- DECLARE_NO_COPY_CLASS(wxDCBrushChanger)
+ wxDECLARE_NO_COPY_CLASS(wxDCBrushChanger);
};
// ----------------------------------------------------------------------------
private:
wxDC& m_dc;
- DECLARE_NO_COPY_CLASS(wxDCClipper)
+ wxDECLARE_NO_COPY_CLASS(wxDCClipper);
};
// ----------------------------------------------------------------------------
wxFont m_fontOld;
- DECLARE_NO_COPY_CLASS(wxDCFontChanger)
+ wxDECLARE_NO_COPY_CLASS(wxDCFontChanger);
};
int m_style;
DECLARE_DYNAMIC_CLASS(wxBufferedDC)
- DECLARE_NO_COPY_CLASS(wxBufferedDC)
+ wxDECLARE_NO_COPY_CLASS(wxBufferedDC);
};
wxPaintDC m_paintdc;
DECLARE_ABSTRACT_CLASS(wxBufferedPaintDC)
- DECLARE_NO_COPY_CLASS(wxBufferedPaintDC)
+ wxDECLARE_NO_COPY_CLASS(wxBufferedPaintDC);
};
wxT("and also, if needed, paint the background manually in the paint event handler."));
}
- DECLARE_NO_COPY_CLASS(wxAutoBufferedPaintDC)
+ wxDECLARE_NO_COPY_CLASS(wxAutoBufferedPaintDC);
};
#else // !__WXDEBUG__
void SetGraphicsContext( wxGraphicsContext* ctx );
DECLARE_DYNAMIC_CLASS(wxGCDC)
- DECLARE_NO_COPY_CLASS(wxGCDC)
+ wxDECLARE_NO_COPY_CLASS(wxGCDC);
};
wxGraphicsContext* m_graphicContext;
DECLARE_CLASS(wxGCDCImpl)
- DECLARE_NO_COPY_CLASS(wxGCDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxGCDCImpl);
};
#endif // wxUSE_GRAPHICS_CONTEXT
bool m_mirror;
- DECLARE_NO_COPY_CLASS(wxMirrorDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMirrorDCImpl);
};
class WXDLLIMPEXP_CORE wxMirrorDC : public wxDC
private:
bool m_mirror;
- DECLARE_NO_COPY_CLASS(wxMirrorDC)
+ wxDECLARE_NO_COPY_CLASS(wxMirrorDC);
};
#endif // _WX_DCMIRROR_H_
#include "wx/features.h"
/* --------------------------------------------------------------------------- */
-/* macro to define a class without copy ctor nor assignment operator */
+/* macros to define a class without copy ctor nor assignment operator */
/* --------------------------------------------------------------------------- */
-#define DECLARE_NO_COPY_CLASS(classname) \
+#define wxDECLARE_NO_COPY_CLASS(classname) \
private: \
classname(const classname&); \
- classname& operator=(const classname&);
+ classname& operator=(const classname&)
-#define DECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg) \
- private: \
- classname(const classname<arg>&); \
- classname& operator=(const classname<arg>&);
+#define wxDECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg) \
+ private: \
+ classname(const classname<arg>&); \
+ classname& operator=(const classname<arg>&)
-#define DECLARE_NO_ASSIGN_CLASS(classname) \
+#define wxDECLARE_NO_ASSIGN_CLASS(classname) \
private: \
- classname& operator=(const classname&);
+ classname& operator=(const classname&)
+
+// deprecated variants _not_ requiring a semicolon after them
+#define DECLARE_NO_COPY_CLASS(classname) \
+ wxDECLARE_NO_COPY_CLASS(classname);
+#define DECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg) \
+ wxDECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg);
+#define DECLARE_NO_ASSIGN_CLASS(classname) \
+ wxDECLARE_NO_ASSIGN_CLASS(classname);
/* --------------------------------------------------------------------------- */
/* If a manifest is being automatically generated, add common controls 6 to it */
friend class wxOverlayImpl; // for m_shouldFlip;
DECLARE_DYNAMIC_CLASS(wxWindowDCImpl)
- DECLARE_NO_COPY_CLASS(wxWindowDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
};
//-----------------------------------------------------------------------------
wxClientDCImpl(wxDC *owner, wxWindow *win);
DECLARE_DYNAMIC_CLASS(wxClientDCImpl)
- DECLARE_NO_COPY_CLASS(wxClientDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
};
wxPaintDCImpl(wxDC *owner, wxWindow *win) : wxClientDCImpl(owner, win) { }
DECLARE_DYNAMIC_CLASS(wxPaintDCImpl)
- DECLARE_NO_COPY_CLASS(wxPaintDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
};
#endif // _WX_DFB_DCCLIENT_H_
static wxIDirectFBEventBufferPtr ms_buffer;
static int ms_bufferFd;
- DECLARE_NO_COPY_CLASS(wxGUIEventLoop)
+ wxDECLARE_NO_COPY_CLASS(wxGUIEventLoop);
};
#endif // _WX_DFB_EVTLOOP_H_
friend class wxWindowDCImpl; // for PaintOverlays
DECLARE_DYNAMIC_CLASS(wxWindowDFB)
- DECLARE_NO_COPY_CLASS(wxWindowDFB)
+ wxDECLARE_NO_COPY_CLASS(wxWindowDFB);
DECLARE_EVENT_TABLE()
};
void OnSysColourChanged(wxSysColourChangedEvent& event);
- DECLARE_NO_COPY_CLASS(wxDialogBase)
+ wxDECLARE_NO_COPY_CLASS(wxDialogBase);
DECLARE_EVENT_TABLE()
};
virtual wxEvent *Clone() const { return new wxDialUpEvent(*this); }
private:
- DECLARE_NO_ASSIGN_CLASS(wxDialUpEvent)
+ wxDECLARE_NO_ASSIGN_CLASS(wxDialUpEvent);
};
// the type of dialup event handler function
wxDirData *m_data;
- DECLARE_NO_COPY_CLASS(wxDir)
+ wxDECLARE_NO_COPY_CLASS(wxDir);
};
#endif // _WX_DIR_H_
wxDisplayImpl *m_impl;
- DECLARE_NO_COPY_CLASS(wxDisplay)
+ wxDECLARE_NO_COPY_CLASS(wxDisplay);
};
#endif // _WX_DISPLAY_H_BASE_
friend class wxDisplayFactory;
- DECLARE_NO_COPY_CLASS(wxDisplayImpl)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImpl);
};
// ----------------------------------------------------------------------------
m_cursorMove,
m_cursorStop;
- DECLARE_NO_COPY_CLASS(wxDropSourceBase)
+ wxDECLARE_NO_COPY_CLASS(wxDropSourceBase);
};
// ----------------------------------------------------------------------------
wxDataObject *m_dataObject;
wxDragResult m_defaultAction;
- DECLARE_NO_COPY_CLASS(wxDropTargetBase)
+ wxDECLARE_NO_COPY_CLASS(wxDropTargetBase);
};
// ----------------------------------------------------------------------------
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
private:
- DECLARE_NO_COPY_CLASS(wxTextDropTarget)
+ wxDECLARE_NO_COPY_CLASS(wxTextDropTarget);
};
// A drop target which accepts files (dragged from File Manager or Explorer)
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
private:
- DECLARE_NO_COPY_CLASS(wxFileDropTarget)
+ wxDECLARE_NO_COPY_CLASS(wxFileDropTarget);
};
#endif // wxUSE_DRAG_AND_DROP
private:
DECLARE_CLASS(wxDocMDIParentFrame)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxDocMDIParentFrame)
+ wxDECLARE_NO_COPY_CLASS(wxDocMDIParentFrame);
};
/*
private:
DECLARE_EVENT_TABLE()
DECLARE_CLASS(wxDocMDIChildFrame)
- DECLARE_NO_COPY_CLASS(wxDocMDIChildFrame)
+ wxDECLARE_NO_COPY_CLASS(wxDocMDIChildFrame);
};
#endif
private:
DECLARE_ABSTRACT_CLASS(wxDocument)
- DECLARE_NO_COPY_CLASS(wxDocument)
+ wxDECLARE_NO_COPY_CLASS(wxDocument);
};
class WXDLLIMPEXP_CORE wxView: public wxEvtHandler
private:
DECLARE_ABSTRACT_CLASS(wxView)
- DECLARE_NO_COPY_CLASS(wxView)
+ wxDECLARE_NO_COPY_CLASS(wxView);
};
// Represents user interface (and other) properties of documents and views
private:
DECLARE_CLASS(wxDocTemplate)
- DECLARE_NO_COPY_CLASS(wxDocTemplate)
+ wxDECLARE_NO_COPY_CLASS(wxDocTemplate);
};
// One object of this class may be created in an application, to manage all
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxDocManager)
- DECLARE_NO_COPY_CLASS(wxDocManager)
+ wxDECLARE_NO_COPY_CLASS(wxDocManager);
};
#if WXWIN_COMPATIBILITY_2_6
private:
DECLARE_CLASS(wxDocChildFrame)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxDocChildFrame)
+ wxDECLARE_NO_COPY_CLASS(wxDocChildFrame);
};
// ----------------------------------------------------------------------------
typedef wxFrame base_type;
DECLARE_CLASS(wxDocParentFrame)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxDocParentFrame)
+ wxDECLARE_NO_COPY_CLASS(wxDocParentFrame);
};
// ----------------------------------------------------------------------------
private:
DECLARE_DYNAMIC_CLASS(wxDocPrintout)
- DECLARE_NO_COPY_CLASS(wxDocPrintout)
+ wxDECLARE_NO_COPY_CLASS(wxDocPrintout);
};
#endif // wxUSE_PRINTING_ARCHITECTURE
wxWindowID m_idBase;
DECLARE_DYNAMIC_CLASS(wxFileHistory)
- DECLARE_NO_COPY_CLASS(wxFileHistory)
+ wxDECLARE_NO_COPY_CLASS(wxFileHistory);
};
#if WXWIN_COMPATIBILITY_2_6
// no copy ctor/assignment operators (or we'd try to unload the library
// twice)
- DECLARE_NO_COPY_CLASS(wxDynamicLibrary)
+ wxDECLARE_NO_COPY_CLASS(wxDynamicLibrary);
};
#ifdef __WXMSW__
void RegisterModules(); // Init any wxModules in the lib.
void UnregisterModules(); // Cleanup any wxModules we installed.
- DECLARE_NO_COPY_CLASS(wxPluginLibrary)
+ wxDECLARE_NO_COPY_CLASS(wxPluginLibrary);
};
// We could allow this class to be copied if we really
// wanted to, but not without modification.
- DECLARE_NO_COPY_CLASS(wxPluginManager)
+ wxDECLARE_NO_COPY_CLASS(wxPluginManager);
};
bool m_UnicodeInput, m_UnicodeOutput;
bool m_JustCopy;
- DECLARE_NO_COPY_CLASS(wxEncodingConverter)
+ wxDECLARE_NO_COPY_CLASS(wxEncodingConverter);
};
#endif // _WX_ENCCONV_H_
wxEvent& m_event;
int m_propagationLevelOld;
- DECLARE_NO_COPY_CLASS(wxPropagationDisabler)
+ wxDECLARE_NO_COPY_CLASS(wxPropagationDisabler);
};
/*
private:
wxEvent& m_event;
- DECLARE_NO_COPY_CLASS(wxPropagateOnce)
+ wxDECLARE_NO_COPY_CLASS(wxPropagateOnce);
};
wxObject* m_callbackUserData;
private:
- DECLARE_NO_ASSIGN_CLASS(wxEventTableEntryBase)
+ wxDECLARE_NO_ASSIGN_CLASS(wxEventTableEntryBase);
};
// an entry from a static event table
const int& m_eventType;
private:
- DECLARE_NO_ASSIGN_CLASS(wxEventTableEntry)
+ wxDECLARE_NO_ASSIGN_CLASS(wxEventTableEntry);
};
// an entry used in dynamic event table managed by wxEvtHandler::Connect()
int m_eventType;
private:
- DECLARE_NO_ASSIGN_CLASS(wxDynamicEventTableEntry)
+ wxDECLARE_NO_ASSIGN_CLASS(wxDynamicEventTableEntry);
};
// ----------------------------------------------------------------------------
wxEventHashTable* m_previous;
wxEventHashTable* m_next;
- DECLARE_NO_COPY_CLASS(wxEventHashTable)
+ wxDECLARE_NO_COPY_CLASS(wxEventHashTable);
};
// ----------------------------------------------------------------------------
friend class wxEvtHandler;
- DECLARE_NO_ASSIGN_CLASS(wxEventConnectionRef)
+ wxDECLARE_NO_ASSIGN_CLASS(wxEventConnectionRef);
};
// Post a message to the given event handler which will be processed during the
wxArrayInt m_eventsToBlock;
wxWindow *m_window;
- DECLARE_NO_COPY_CLASS(wxEventBlocker)
+ wxDECLARE_NO_COPY_CLASS(wxEventBlocker);
};
typedef void (wxEvtHandler::*wxCommandEventFunction)(wxCommandEvent&);
// the pointer to currently active loop
static wxEventLoopBase *ms_activeLoop;
- DECLARE_NO_COPY_CLASS(wxEventLoopBase)
+ wxDECLARE_NO_COPY_CLASS(wxEventLoopBase);
};
#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXDFB__) || defined(__UNIX__)
// the pointer to the port specific implementation class
wxEventLoopImpl *m_impl;
- DECLARE_NO_COPY_CLASS(wxGUIEventLoop)
+ wxDECLARE_NO_COPY_CLASS(wxGUIEventLoop);
};
#endif // platforms
// the last string we searched for
wxString m_lastSearch;
- DECLARE_NO_COPY_CLASS(wxFindReplaceDialogBase)
+ wxDECLARE_NO_COPY_CLASS(wxFindReplaceDialogBase);
};
// include wxFindReplaceDialog declaration
bool m_isDirty; // if true, we have unsaved changes
- DECLARE_NO_COPY_CLASS(wxFileConfig)
+ wxDECLARE_NO_COPY_CLASS(wxFileConfig);
DECLARE_ABSTRACT_CLASS(wxFileConfig)
};
void Init();
DECLARE_DYNAMIC_CLASS(wxFileDialogBase)
- DECLARE_NO_COPY_CLASS(wxFileDialogBase)
+ wxDECLARE_NO_COPY_CLASS(wxFileDialogBase);
};
#endif // wxUSE_DATETIME
DECLARE_ABSTRACT_CLASS(wxFSFile)
- DECLARE_NO_COPY_CLASS(wxFSFile)
+ wxDECLARE_NO_COPY_CLASS(wxFSFile);
};
// Handlers local to this instance
DECLARE_DYNAMIC_CLASS(wxFileSystem)
- DECLARE_NO_COPY_CLASS(wxFileSystem)
+ wxDECLARE_NO_COPY_CLASS(wxFileSystem);
};
bool m_ok;
- DECLARE_NO_COPY_CLASS(wxFontMapperPathChanger)
+ wxDECLARE_NO_COPY_CLASS(wxFontMapperPathChanger);
};
#endif // wxUSE_CONFIG
wxFontData m_fontData;
- DECLARE_NO_COPY_CLASS(wxFontDialogBase)
+ wxDECLARE_NO_COPY_CLASS(wxFontDialogBase);
};
#if WXWIN_COMPATIBILITY_2_6
bool EnumerateEncodingsUTF8(const wxString& facename);
#endif
- DECLARE_NO_COPY_CLASS(wxFontEnumerator)
+ wxDECLARE_NO_COPY_CLASS(wxFontEnumerator);
};
#endif // wxUSE_FONTENUM
friend class wxFontMapperPathChanger;
- DECLARE_NO_COPY_CLASS(wxFontMapperBase)
+ wxDECLARE_NO_COPY_CLASS(wxFontMapperBase);
};
// ----------------------------------------------------------------------------
wxWindow *m_windowParent;
private:
- DECLARE_NO_COPY_CLASS(wxFontMapper)
+ wxDECLARE_NO_COPY_CLASS(wxFontMapper);
};
#endif // wxUSE_GUI
DECLARE_EVENT_TABLE()
#endif // wxUSE_MENUS && wxUSE_STATUSBAR
- DECLARE_NO_COPY_CLASS(wxFrameBase)
+ wxDECLARE_NO_COPY_CLASS(wxFrameBase);
};
// include the real class declaration
wxString DoFind();
- DECLARE_NO_COPY_CLASS(wxArchiveFSHandler)
+ wxDECLARE_NO_COPY_CLASS(wxArchiveFSHandler);
DECLARE_DYNAMIC_CLASS(wxArchiveFSHandler)
};
virtual wxString FindNext();
private:
- DECLARE_NO_COPY_CLASS(wxFilterFSHandler)
+ wxDECLARE_NO_COPY_CLASS(wxFilterFSHandler);
};
#endif // wxUSE_FILESYSTEM
int m_nDirection; // can be wxRIGHT or wxLEFT
#endif
- DECLARE_NO_COPY_CLASS(wxGaugeBase)
+ wxDECLARE_NO_COPY_CLASS(wxGaugeBase);
};
#if defined(__WXUNIVERSAL__)
private:
DECLARE_DYNAMIC_CLASS(wxGBSizerItem)
- DECLARE_NO_COPY_CLASS(wxGBSizerItem)
+ wxDECLARE_NO_COPY_CLASS(wxGBSizerItem);
};
private:
DECLARE_CLASS(wxGridBagSizer)
- DECLARE_NO_COPY_CLASS(wxGridBagSizer)
+ wxDECLARE_NO_COPY_CLASS(wxGridBagSizer);
};
//---------------------------------------------------------------------------
static wxObject* ms_stockObject[ITEMCOUNT];
- DECLARE_NO_COPY_CLASS(wxStockGDI)
+ wxDECLARE_NO_COPY_CLASS(wxStockGDI);
};
#define wxITALIC_FONT wxStockGDI::instance().GetFont(wxStockGDI::FONT_ITALIC)
private:
wxFrame *m_InfoFrame;
- DECLARE_NO_COPY_CLASS(wxBusyInfo)
+ wxDECLARE_NO_COPY_CLASS(wxBusyInfo);
};
DECLARE_DYNAMIC_CLASS(wxGenericCalendarCtrl)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGenericCalendarCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxGenericCalendarCtrl);
};
#endif // _WX_GENERIC_CALCTRLG_H
const wxString *choices,
long styleLbox);
- DECLARE_NO_COPY_CLASS(wxAnyChoiceDialog)
+ wxDECLARE_NO_COPY_CLASS(wxAnyChoiceDialog);
};
// ----------------------------------------------------------------------------
return true;
}
- DECLARE_NO_COPY_CLASS(wxControlWithItemsGeneric)
+ wxDECLARE_NO_COPY_CLASS(wxControlWithItemsGeneric);
};
#endif // _WX_GENERIC_CTRLSUB_H_
private:
DECLARE_DYNAMIC_CLASS(wxDataViewCtrl)
- DECLARE_NO_COPY_CLASS(wxDataViewCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxDataViewCtrl);
DECLARE_EVENT_TABLE()
};
wxCalendarComboPopup* m_popup;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxDatePickerCtrlGeneric)
+ wxDECLARE_NO_COPY_CLASS(wxDatePickerCtrlGeneric);
};
#endif // _WX_GENERIC_DATECTRL_H_
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxGenericDirCtrl)
- DECLARE_NO_COPY_CLASS(wxGenericDirCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxGenericDirCtrl);
};
//-----------------------------------------------------------------------------
DECLARE_EVENT_TABLE()
DECLARE_CLASS(wxDirFilterListCtrl)
- DECLARE_NO_COPY_CLASS(wxDirFilterListCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxDirFilterListCtrl);
};
#if !defined(__WXMSW__) && !defined(__WXMAC__) && !defined(__WXPM__)
private:
DECLARE_DYNAMIC_CLASS(wxGenericDragImage)
- DECLARE_NO_COPY_CLASS(wxGenericDragImage)
+ wxDECLARE_NO_COPY_CLASS(wxGenericDragImage);
};
#endif
// no friends
friend class wxGridCellEditorDummyFriend;
- DECLARE_NO_COPY_CLASS(wxGridCellEditor)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellEditor);
};
wxAttrKind m_attrkind;
// use Clone() instead
- DECLARE_NO_COPY_CLASS(wxGridCellAttr)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellAttr);
// suppress the stupid gcc warning about the class having private dtor and
// no friends
wxGridCellAttrProviderData *m_data;
- DECLARE_NO_COPY_CLASS(wxGridCellAttrProvider)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellAttrProvider);
};
// ----------------------------------------------------------------------------
wxGridCellAttrProvider *m_attrProvider;
DECLARE_ABSTRACT_CLASS(wxGridTableBase)
- DECLARE_NO_COPY_CLASS(wxGridTableBase)
+ wxDECLARE_NO_COPY_CLASS(wxGridTableBase);
};
int m_comInt1;
int m_comInt2;
- DECLARE_NO_COPY_CLASS(wxGridTableMessage)
+ wxDECLARE_NO_COPY_CLASS(wxGridTableMessage);
};
DECLARE_DYNAMIC_CLASS( wxGrid )
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGrid)
+ wxDECLARE_NO_COPY_CLASS(wxGrid);
};
// ----------------------------------------------------------------------------
wxGrid *m_grid;
- DECLARE_NO_COPY_CLASS(wxGridUpdateLocker)
+ wxDECLARE_NO_COPY_CLASS(wxGridUpdateLocker);
};
// ----------------------------------------------------------------------------
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
- DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler);
};
size_t m_maxChars; // max number of chars allowed
wxString m_value;
- DECLARE_NO_COPY_CLASS(wxGridCellTextEditor)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellTextEditor);
};
// the editor for numeric (long) data
long m_value;
- DECLARE_NO_COPY_CLASS(wxGridCellNumberEditor)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellNumberEditor);
};
// the editor for floating point numbers (double) data
m_precision;
double m_value;
- DECLARE_NO_COPY_CLASS(wxGridCellFloatEditor)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellFloatEditor);
};
#endif // wxUSE_TEXTCTRL
static wxString ms_stringValues[2];
- DECLARE_NO_COPY_CLASS(wxGridCellBoolEditor)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellBoolEditor);
};
#endif // wxUSE_CHECKBOX
wxArrayString m_choices;
bool m_allowOthers;
- DECLARE_NO_COPY_CLASS(wxGridCellChoiceEditor)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellChoiceEditor);
};
#endif // wxUSE_COMBOBOX
private:
long m_index;
- DECLARE_NO_COPY_CLASS(wxGridCellEnumEditor)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellEnumEditor);
};
#endif // wxUSE_COMBOBOX
virtual wxGridCellEditor *Clone() const
{ return new wxGridCellAutoWrapStringEditor; }
- DECLARE_NO_COPY_CLASS(wxGridCellAutoWrapStringEditor)
+ wxDECLARE_NO_COPY_CLASS(wxGridCellAutoWrapStringEditor);
};
#endif // wxUSE_GRID
friend class WXDLLIMPEXP_FWD_ADV wxGrid;
- DECLARE_NO_COPY_CLASS(wxGridSelection)
+ wxDECLARE_NO_COPY_CLASS(wxGridSelection);
};
#endif // wxUSE_GRID
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxHeaderCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxHeaderCtrl);
};
#endif // _WX_GENERIC_HEADERCTRLG_H_
// the control we use
wxTextCtrl *m_pTextCtrl;
- DECLARE_NO_COPY_CLASS(wxLogTextCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxLogTextCtrl);
};
#endif // wxUSE_TEXTCTRL
private:
wxLogFrame *m_pLogFrame; // the log frame
- DECLARE_NO_COPY_CLASS(wxLogWindow)
+ wxDECLARE_NO_COPY_CLASS(wxLogWindow);
};
#endif // wxUSE_LOGWINDOW
wxNotificationMessageDialog *m_dialog;
- DECLARE_NO_COPY_CLASS(wxGenericNotificationMessage)
+ wxDECLARE_NO_COPY_CLASS(wxGenericNotificationMessage);
};
#endif // _WX_GENERIC_NOTIFMSG_H_
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxNumberEntryDialog)
- DECLARE_NO_COPY_CLASS(wxNumberEntryDialog)
+ wxDECLARE_NO_COPY_CLASS(wxNumberEntryDialog);
};
// ----------------------------------------------------------------------------
wxVector<wxGridHeaderColumn> m_columns;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridHeaderCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxGridHeaderCtrl);
};
// common base class for various grid subwindows
wxGrid *m_owner;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridSubwindow)
+ wxDECLARE_NO_COPY_CLASS(wxGridSubwindow);
};
class WXDLLIMPEXP_ADV wxGridRowLabelWindow : public wxGridSubwindow
void OnMouseWheel( wxMouseEvent& event );
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow)
+ wxDECLARE_NO_COPY_CLASS(wxGridRowLabelWindow);
};
void OnMouseWheel( wxMouseEvent& event );
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridColLabelWindow)
+ wxDECLARE_NO_COPY_CLASS(wxGridColLabelWindow);
};
void OnPaint( wxPaintEvent& event );
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow)
+ wxDECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow);
};
class WXDLLIMPEXP_ADV wxGridWindow : public wxGridSubwindow
void OnFocus( wxFocusEvent& );
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridWindow)
+ wxDECLARE_NO_COPY_CLASS(wxGridWindow);
};
// ----------------------------------------------------------------------------
wxGridCellRenderer* m_renderer;
wxGridCellEditor* m_editor;
- DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo)
+ wxDECLARE_NO_COPY_CLASS(wxGridDataTypeInfo);
};
class WXDLLIMPEXP_FWD_CORE wxWindowDisabler *m_winDisabler;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxProgressDialog)
+ wxDECLARE_NO_COPY_CLASS(wxProgressDialog);
};
#endif // wxUSE_PROGRESSDLG
private:
DECLARE_DYNAMIC_CLASS(wxSashWindow)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxSashWindow)
+ wxDECLARE_NO_COPY_CLASS(wxSashWindow);
};
class WXDLLIMPEXP_FWD_ADV wxSashEvent;
wxScrollbarVisibility m_xVisibility,
m_yVisibility;
- DECLARE_NO_COPY_CLASS(wxScrollHelper)
+ wxDECLARE_NO_COPY_CLASS(wxScrollHelper);
};
#endif // _WX_GENERIC_SCROLLWIN_H_
DECLARE_DYNAMIC_CLASS(wxSplashScreen)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxSplashScreen)
+ wxDECLARE_NO_COPY_CLASS(wxSplashScreen);
};
/*
wxBitmap m_bitmap;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxSplashScreenWindow)
+ wxDECLARE_NO_COPY_CLASS(wxSplashScreenWindow);
};
DECLARE_DYNAMIC_CLASS(wxSplitterWindow)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxSplitterWindow)
+ wxDECLARE_NO_COPY_CLASS(wxSplitterWindow);
};
// ----------------------------------------------------------------------------
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxTextEntryDialog)
- DECLARE_NO_COPY_CLASS(wxTextEntryDialog)
+ wxDECLARE_NO_COPY_CLASS(wxTextEntryDialog);
};
// ----------------------------------------------------------------------------
const wxPoint& pos = wxDefaultPosition);
private:
DECLARE_DYNAMIC_CLASS(wxPasswordEntryDialog)
- DECLARE_NO_COPY_CLASS(wxPasswordEntryDialog)
+ wxDECLARE_NO_COPY_CLASS(wxPasswordEntryDialog);
};
// ----------------------------------------------------------------------------
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxGenericTreeCtrl)
- DECLARE_NO_COPY_CLASS(wxGenericTreeCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxGenericTreeCtrl);
};
#if !defined(__WXMSW__) || defined(__WXUNIVERSAL__)
DECLARE_DYNAMIC_CLASS(wxWizard)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxWizard)
+ wxDECLARE_NO_COPY_CLASS(wxWizard);
};
#endif // _WX_GENERIC_WIZARD_H_
wxGIFErrorCode dgif(wxInputStream& stream,
GIFImage *img, int interl, int bits);
- DECLARE_NO_COPY_CLASS(wxGIFDecoder)
+ wxDECLARE_NO_COPY_CLASS(wxGIFDecoder);
};
#endif // wxUSE_STREAMS && wxUSE_GIF
wxDouble angle,
const wxGraphicsBrush& backgroundBrush);
- DECLARE_NO_COPY_CLASS(wxGraphicsContext)
+ wxDECLARE_NO_COPY_CLASS(wxGraphicsContext);
DECLARE_ABSTRACT_CLASS(wxGraphicsContext)
};
private:
- DECLARE_NO_COPY_CLASS(wxGraphicsRenderer)
+ wxDECLARE_NO_COPY_CLASS(wxGraphicsRenderer);
DECLARE_ABSTRACT_CLASS(wxGraphicsRenderer)
};
private:
DECLARE_DYNAMIC_CLASS(wxGtkCalendarCtrl)
- DECLARE_NO_COPY_CLASS(wxGtkCalendarCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxGtkCalendarCtrl);
};
#endif // GTK_CALCTRL_H__
void GtkDisableSelectionEvents();
DECLARE_DYNAMIC_CLASS(wxDataViewCtrl)
- DECLARE_NO_COPY_CLASS(wxDataViewCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxDataViewCtrl);
};
// the exit code of this event loop
int m_exitcode;
- DECLARE_NO_COPY_CLASS(wxGUIEventLoop)
+ wxDECLARE_NO_COPY_CLASS(wxGUIEventLoop);
};
#endif // _WX_GTK_EVTLOOP_H_
private:
DECLARE_DYNAMIC_CLASS(wxGnomePrinter)
- DECLARE_NO_COPY_CLASS(wxGnomePrinter)
+ wxDECLARE_NO_COPY_CLASS(wxGnomePrinter);
};
//-----------------------------------------------------------------------------
private:
DECLARE_DYNAMIC_CLASS(wxGnomePrinterDCImpl)
- DECLARE_NO_COPY_CLASS(wxGnomePrinterDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxGnomePrinterDCImpl);
};
// ----------------------------------------------------------------------------
GtkWidget *m_banner;
- DECLARE_NO_COPY_CLASS(wxNotificationMessage)
+ wxDECLARE_NO_COPY_CLASS(wxNotificationMessage);
};
#endif // _WX_GTK_HILDON_NOTIFMSG_H_
wxDC *m_dc;
DECLARE_DYNAMIC_CLASS(wxGtkPrinter)
- DECLARE_NO_COPY_CLASS(wxGtkPrinter)
+ wxDECLARE_NO_COPY_CLASS(wxGtkPrinter);
};
//----------------------------------------------------------------------------
double m_DEV2PS;
DECLARE_DYNAMIC_CLASS(wxGtkPrinterDCImpl)
- DECLARE_NO_COPY_CLASS(wxGtkPrinterDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxGtkPrinterDCImpl);
};
// ----------------------------------------------------------------------------
// copying could be implemented by using g_object_ref() but for now there
// is no need for it so don't implement it
- DECLARE_NO_COPY_CLASS(wxGtkObject)
+ wxDECLARE_NO_COPY_CLASS(wxGtkObject);
};
#endif // _WX_GTK_PRIVATE_OBJECT_H_
private:
gchar *m_str;
- DECLARE_NO_COPY_CLASS(wxGtkString)
+ wxDECLARE_NO_COPY_CLASS(wxGtkString);
};
#endif // _WX_GTK_PRIVATE_STRING_H_
int *posOld);
private:
- DECLARE_NO_COPY_CLASS(wxScrollHelper)
+ wxDECLARE_NO_COPY_CLASS(wxScrollHelper);
};
#endif // _WX_GTK_SCROLLWIN_H_
DECLARE_DYNAMIC_CLASS(wxWindowGTK)
- DECLARE_NO_COPY_CLASS(wxWindowGTK)
+ wxDECLARE_NO_COPY_CLASS(wxWindowGTK);
};
#endif // _WX_GTK_WINDOW_H_
int *posOld);
private:
- DECLARE_NO_COPY_CLASS(wxScrollHelper)
+ wxDECLARE_NO_COPY_CLASS(wxScrollHelper);
};
#endif // _WX_GTK_SCROLLWIN_H_
private:
DECLARE_DYNAMIC_CLASS(wxWindowGTK)
- DECLARE_NO_COPY_CLASS(wxWindowGTK)
+ wxDECLARE_NO_COPY_CLASS(wxWindowGTK);
};
extern WXDLLIMPEXP_CORE wxWindow *wxFindFocusedChild(wxWindowGTK *win);
bool m_deleteContents;
private:
- DECLARE_NO_COPY_CLASS(wxHashTableBase)
+ wxDECLARE_NO_COPY_CLASS(wxHashTableBase);
};
// ----------------------------------------------------------------------------
_wxHashTable_NodeBase* m_next;
// Cannot do this:
-// DECLARE_NO_COPY_CLASS(_wxHashTable_NodeBase)
+// wxDECLARE_NO_COPY_CLASS(_wxHashTable_NodeBase);
// without rewriting the macros, which require a public copy constructor.
};
unsigned int m_sortKey;
- DECLARE_NO_COPY_CLASS(wxHeaderCtrlSimple)
+ wxDECLARE_NO_COPY_CLASS(wxHeaderCtrlSimple);
};
// ----------------------------------------------------------------------------
wxHtmlHelpFrame* m_helpFrame;
wxHtmlHelpDialog* m_helpDialog;
- DECLARE_NO_COPY_CLASS(wxHtmlHelpController)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlHelpController);
};
/*
bool m_CaseSensitive;
bool m_WholeWords;
- DECLARE_NO_COPY_CLASS(wxHtmlSearchEngine)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlSearchEngine);
};
int m_MaxIndex; // number of files we search
// For progress bar: 100*curindex/maxindex = % complete
- DECLARE_NO_COPY_CLASS(wxHtmlSearchStatus)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlSearchStatus);
};
class WXDLLIMPEXP_HTML wxHtmlHelpData : public wxObject
// Writes binary book
bool SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f);
- DECLARE_NO_COPY_CLASS(wxHtmlHelpData)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlHelpData);
};
#endif
wxHtmlHelpController* m_helpController;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxHtmlHelpDialog)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlHelpDialog);
};
#endif
private:
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxHtmlHelpFrame)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlHelpFrame);
};
#endif // wxUSE_WXHTML_HELP
wxHtmlHelpMergedIndex *m_mergedIndex;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxHtmlHelpWindow)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlHelpWindow);
};
/*!
wxString m_id;
DECLARE_ABSTRACT_CLASS(wxHtmlCell)
- DECLARE_NO_COPY_CLASS(wxHtmlCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlCell);
};
bool m_allowLinebreak;
DECLARE_ABSTRACT_CLASS(wxHtmlWordCell)
- DECLARE_NO_COPY_CLASS(wxHtmlWordCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlWordCell);
};
DECLARE_ABSTRACT_CLASS(wxHtmlContainerCell)
- DECLARE_NO_COPY_CLASS(wxHtmlContainerCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlContainerCell);
};
unsigned m_Flags;
DECLARE_ABSTRACT_CLASS(wxHtmlColourCell)
- DECLARE_NO_COPY_CLASS(wxHtmlColourCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlColourCell);
};
wxFont m_Font;
DECLARE_ABSTRACT_CLASS(wxHtmlFontCell)
- DECLARE_NO_COPY_CLASS(wxHtmlFontCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlFontCell);
};
// width float is used in adjustWidth (it is in percents)
DECLARE_ABSTRACT_CLASS(wxHtmlWidgetCell)
- DECLARE_NO_COPY_CLASS(wxHtmlWidgetCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlWidgetCell);
};
wxHtmlTagHandlersSet m_HandlersSet;
wxHtmlTagHandlersHash m_HandlersHash;
- DECLARE_NO_COPY_CLASS(wxHtmlParser)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlParser);
// class for opening files (file system)
wxFileSystem *m_FS;
wxHtmlParser *m_Parser;
- DECLARE_NO_COPY_CLASS(wxHtmlTagHandler)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlTagHandler);
};
wxFontEncoding m_encoding;
#endif
- DECLARE_NO_COPY_CLASS(wxHtmlEntitiesParser)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlEntitiesParser);
};
wxString::const_iterator *end2,
bool *hasEnding);
- DECLARE_NO_COPY_CLASS(wxHtmlTagsCache)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlTagsCache);
};
wxHtmlTag *m_FirstChild, *m_LastChild;
wxHtmlTag *m_Parent;
- DECLARE_NO_COPY_CLASS(wxHtmlTag)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlTag);
};
static wxCursor *ms_cursorText;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxHtmlWindow)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlWindow);
};
class WXDLLIMPEXP_FWD_HTML wxHtmlCellEvent;
wxHtmlContainerCell *m_Cells;
int m_MaxWidth, m_Width, m_Height;
- DECLARE_NO_COPY_CLASS(wxHtmlDCRenderer)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlDCRenderer);
};
// list of HTML filters
static wxList m_Filters;
- DECLARE_NO_COPY_CLASS(wxHtmlPrintout)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlPrintout);
};
wxString m_Headers[2], m_Footers[2];
wxWindow *m_ParentWindow;
- DECLARE_NO_COPY_CLASS(wxHtmlEasyPrinting)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlEasyPrinting);
};
// expand TABs; only updated while inside <pre>
int m_posColumn;
- DECLARE_NO_COPY_CLASS(wxHtmlWinParser)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlWinParser);
};
protected:
wxHtmlWinParser *m_WParser; // same as m_Parser, but overcasted
- DECLARE_NO_COPY_CLASS(wxHtmlWinTagHandler)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlWinTagHandler);
};
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxHtmlListBox)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlListBox);
};
// not be named m_clientdata as that clashes with the name of an
// anonymous struct member in wxEvtHandler, which we derive from.
- DECLARE_NO_COPY_CLASS(wxSimpleHtmlListBox)
+ wxDECLARE_NO_COPY_CLASS(wxSimpleHtmlListBox);
};
#endif // _WX_HTMLLBOX_H_
static wxLanguageInfoArray *ms_languagesDB;
- DECLARE_NO_COPY_CLASS(wxLocale)
+ wxDECLARE_NO_COPY_CLASS(wxLocale);
};
// ----------------------------------------------------------------------------
protected:
bool m_connected;
- DECLARE_NO_ASSIGN_CLASS(wxConnectionBase)
+ wxDECLARE_NO_ASSIGN_CLASS(wxConnectionBase);
DECLARE_CLASS(wxConnectionBase)
};
wxListBase *m_list; // list we belong to
- DECLARE_NO_COPY_CLASS(wxNodeBase)
+ wxDECLARE_NO_COPY_CLASS(wxNodeBase);
};
// -----------------------------------------------------------------------------
{ return wxNOT_FOUND; }
private:
- DECLARE_NO_COPY_CLASS(wxListBoxBase)
+ wxDECLARE_NO_COPY_CLASS(wxListBoxBase);
};
// ----------------------------------------------------------------------------
private:
wxString m_str;
- DECLARE_NO_COPY_CLASS(wxLogBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxLogBuffer);
};
FILE *m_fp;
- DECLARE_NO_COPY_CLASS(wxLogStderr)
+ wxDECLARE_NO_COPY_CLASS(wxLogStderr);
};
#if wxUSE_STD_IOSTREAM
// do we pass the messages to the old logger?
bool m_bPassMessages;
- DECLARE_NO_COPY_CLASS(wxLogChain)
+ wxDECLARE_NO_COPY_CLASS(wxLogChain);
};
// a chain log target which uses itself as the new logger
wxLogInterposer();
private:
- DECLARE_NO_COPY_CLASS(wxLogInterposer)
+ wxDECLARE_NO_COPY_CLASS(wxLogInterposer);
};
// a temporary interposer which doesn't destroy the old log target
wxLogInterposerTemp();
private:
- DECLARE_NO_COPY_CLASS(wxLogInterposerTemp)
+ wxDECLARE_NO_COPY_CLASS(wxLogInterposerTemp);
};
#if wxUSE_GUI
{
}
- DECLARE_NO_COPY_CLASS(wxMemoryConfig)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryConfig);
};
#endif // wxUSE_CONFIG
{ return true; }
private:
- DECLARE_NO_COPY_CLASS(wxMemoryText)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryText);
};
#endif // wxUSE_TEXTBUFFER
static bool ms_locked;
- DECLARE_NO_COPY_CLASS(wxMenuBase)
+ wxDECLARE_NO_COPY_CLASS(wxMenuBase);
};
// ----------------------------------------------------------------------------
// the frame we are attached to (may be NULL)
wxFrame *m_menuBarFrame;
- DECLARE_NO_COPY_CLASS(wxMenuBarBase)
+ wxDECLARE_NO_COPY_CLASS(wxMenuBarBase);
};
// ----------------------------------------------------------------------------
friend class wxPaintDC;
DECLARE_DYNAMIC_CLASS(wxWindowMGL)
- DECLARE_NO_COPY_CLASS(wxWindowMGL)
+ wxDECLARE_NO_COPY_CLASS(wxWindowMGL);
DECLARE_EVENT_TABLE()
public:
private:
DECLARE_ABSTRACT_CLASS(wxControlWithItems)
- DECLARE_NO_COPY_CLASS(wxControlWithItems)
+ wxDECLARE_NO_COPY_CLASS(wxControlWithItems);
};
#endif // _WX_MOTIF_CTRLSUB_H_
void Init();
DECLARE_DYNAMIC_CLASS(wxWindow)
- DECLARE_NO_COPY_CLASS(wxWindow)
+ wxDECLARE_NO_COPY_CLASS(wxWindow);
DECLARE_EVENT_TABLE()
};
m_caption;
long m_dialogStyle;
- DECLARE_NO_COPY_CLASS(wxMessageDialogBase)
+ wxDECLARE_NO_COPY_CLASS(wxMessageDialogBase);
};
// this is a helper class for native wxMessageDialog implementations which need
m_ok,
m_cancel;
- DECLARE_NO_COPY_CLASS(wxMessageDialogWithCustomLabels)
+ wxDECLARE_NO_COPY_CLASS(wxMessageDialogWithCustomLabels);
};
#endif // ports needing wxMessageDialogWithCustomLabels
// copy ctor is implemented above: it copies the other stream in this one
DECLARE_ABSTRACT_CLASS(wxMemoryInputStream)
- DECLARE_NO_ASSIGN_CLASS(wxMemoryInputStream)
+ wxDECLARE_NO_ASSIGN_CLASS(wxMemoryInputStream);
};
class WXDLLIMPEXP_BASE wxMemoryOutputStream : public wxOutputStream
wxFileOffset OnSysTell() const;
DECLARE_DYNAMIC_CLASS(wxMemoryOutputStream)
- DECLARE_NO_COPY_CLASS(wxMemoryOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryOutputStream);
};
#if WXWIN_COMPATIBILITY_2_6
protected:
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxApp)
+ wxDECLARE_NO_COPY_CLASS(wxApp);
DECLARE_DYNAMIC_CLASS(wxApp)
};
DECLARE_DYNAMIC_CLASS(wxCalendarCtrl)
- DECLARE_NO_COPY_CLASS(wxCalendarCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxCalendarCtrl);
};
#endif // _WX_MSW_CALCTRL_H_
private:
bool m_hasCaret;
- DECLARE_NO_COPY_CLASS(wxCaret)
+ wxDECLARE_NO_COPY_CLASS(wxCaret);
};
#endif // _WX_CARET_H_
private:
DECLARE_ABSTRACT_CLASS(wxControlWithItems)
- DECLARE_NO_COPY_CLASS(wxControlWithItems)
+ wxDECLARE_NO_COPY_CLASS(wxControlWithItems);
};
#endif // _WX_MSW_CTRLSUB_H_
#endif
DECLARE_CLASS(wxMSWDCImpl)
- DECLARE_NO_COPY_CLASS(wxMSWDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMSWDCImpl);
};
// ----------------------------------------------------------------------------
// find it ourselves
const wxSize m_size;
- DECLARE_NO_COPY_CLASS(wxDCTempImpl)
+ wxDECLARE_NO_COPY_CLASS(wxDCTempImpl);
};
class WXDLLIMPEXP_CORE wxDCTemp : public wxDC
void InitDC();
DECLARE_CLASS(wxWindowDCImpl)
- DECLARE_NO_COPY_CLASS(wxWindowDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
};
class WXDLLIMPEXP_CORE wxClientDCImpl : public wxWindowDCImpl
void InitDC();
DECLARE_CLASS(wxClientDCImpl)
- DECLARE_NO_COPY_CLASS(wxClientDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
};
class WXDLLIMPEXP_CORE wxPaintDCImpl : public wxClientDCImpl
wxPaintDCInfo *FindInCache(size_t *index = NULL) const;
DECLARE_CLASS(wxPaintDCImpl)
- DECLARE_NO_COPY_CLASS(wxPaintDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
};
/*
wxPaintDCEx(wxWindow *canvas, WXHDC dc);
DECLARE_CLASS(wxPaintDCEx)
- DECLARE_NO_COPY_CLASS(wxPaintDCEx)
+ wxDECLARE_NO_COPY_CLASS(wxPaintDCEx);
};
#endif
void Init();
DECLARE_CLASS(wxMemoryDCImpl)
- DECLARE_NO_COPY_CLASS(wxMemoryDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryDCImpl);
};
#endif
private:
DECLARE_CLASS(wxPrinterDCImpl)
- DECLARE_NO_COPY_CLASS(wxPrinterDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxPrinterDCImpl);
};
// Gets an HDC for the specified printer configuration
}
DECLARE_CLASS(wxScreenDCImpl)
- DECLARE_NO_COPY_CLASS(wxScreenDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxScreenDCImpl);
};
#endif // _WX_MSW_DCSCREEN_H_
int m_dataSize;
wxIPCFormat m_dataType;
- DECLARE_NO_COPY_CLASS(wxDDEConnection)
+ wxDECLARE_NO_COPY_CLASS(wxDDEConnection);
DECLARE_DYNAMIC_CLASS(wxDDEConnection)
};
WXHWND m_hGripper;
DECLARE_DYNAMIC_CLASS(wxDialog)
- DECLARE_NO_COPY_CLASS(wxDialog)
+ wxDECLARE_NO_COPY_CLASS(wxDialog);
};
#endif
private:
DECLARE_DYNAMIC_CLASS(wxDragImage)
- DECLARE_NO_COPY_CLASS(wxDragImage)
+ wxDECLARE_NO_COPY_CLASS(wxDragImage);
};
#endif // wxUSE_DRAGIMAGE
protected:
wxEnhMetaFile m_metafile;
- DECLARE_NO_COPY_CLASS(wxEnhMetaFileDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxEnhMetaFileDataObject);
};
protected:
wxEnhMetaFile m_metafile;
- DECLARE_NO_COPY_CLASS(wxEnhMetaFileSimpleDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxEnhMetaFileSimpleDataObject);
};
#endif // wxUSE_DRAG_AND_DROP
wxFindReplaceDialogImpl *m_impl;
DECLARE_DYNAMIC_CLASS(wxFindReplaceDialog)
- DECLARE_NO_COPY_CLASS(wxFindReplaceDialog)
+ wxDECLARE_NO_COPY_CLASS(wxFindReplaceDialog);
};
#endif // _WX_MSW_FDREPDLG_H_
int m_centreDir; // nothing to do if 0
DECLARE_DYNAMIC_CLASS(wxFileDialog)
- DECLARE_NO_COPY_CLASS(wxFileDialog)
+ wxDECLARE_NO_COPY_CLASS(wxFileDialog);
};
#endif // _WX_FILEDLG_H_
// the offset of the window used to emulate scrolling it
int m_scrollOffset;
- DECLARE_NO_COPY_CLASS(wxHeaderCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxHeaderCtrl);
};
#endif // _WX_MSW_HEADERCTRL_H_
int m_style;
DECLARE_DYNAMIC_CLASS(wxBestHelpController)
- DECLARE_NO_COPY_CLASS(wxBestHelpController)
+ wxDECLARE_NO_COPY_CLASS(wxBestHelpController);
};
#endif // wxUSE_HELP && wxUSE_MS_HTML_HELP && wxUSE_WXHTML_HELP
wxString m_strGroup, // current group in appname.ini file
m_strPath; // the rest of the path (no trailing '_'!)
- DECLARE_NO_COPY_CLASS(wxIniConfig)
+ wxDECLARE_NO_COPY_CLASS(wxIniConfig);
DECLARE_ABSTRACT_CLASS(wxIniConfig)
};
DECLARE_DYNAMIC_CLASS(wxListCtrl)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxListCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxListCtrl);
};
#endif // _WX_LISTCTRL_H_
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxMDIParentFrame)
- DECLARE_NO_COPY_CLASS(wxMDIParentFrame)
+ wxDECLARE_NO_COPY_CLASS(wxMDIParentFrame);
};
// ---------------------------------------------------------------------------
private:
DECLARE_CLASS(wxMetafileDCImpl)
- DECLARE_NO_COPY_CLASS(wxMetafileDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMetafileDCImpl);
};
class WXDLLIMPEXP_CORE wxMetafileDC: public wxDC
private:
DECLARE_CLASS(wxMetafileDC)
- DECLARE_NO_COPY_CLASS(wxMetafileDC)
+ wxDECLARE_NO_COPY_CLASS(wxMetafileDC);
};
WXHANDLE m_hook; // HHOOK used to position the message box
DECLARE_DYNAMIC_CLASS(wxMessageDialog)
- DECLARE_NO_COPY_CLASS(wxMessageDialog)
+ wxDECLARE_NO_COPY_CLASS(wxMessageDialog);
};
class wxNotifMsgImpl *m_impl;
- DECLARE_NO_COPY_CLASS(wxNotificationMessage)
+ wxDECLARE_NO_COPY_CLASS(wxNotificationMessage);
};
#endif // _WX_MSW_NOTIFMSG_H_
void* m_pIAccessibleStd; // the pointer to the standard COM interface,
// for default processing
- DECLARE_NO_COPY_CLASS(wxAccessible)
+ wxDECLARE_NO_COPY_CLASS(wxAccessible);
};
#endif //wxUSE_ACCESSIBILITY
public:
WXIDISPATCH* m_dispatchPtr;
- DECLARE_NO_COPY_CLASS(wxAutomationObject)
+ wxDECLARE_NO_COPY_CLASS(wxAutomationObject);
};
#endif // wxUSE_OLE_AUTOMATION
private:
IDataObject *m_pIDataObject; // pointer to the COM interface
- DECLARE_NO_COPY_CLASS(wxDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxDataObject);
};
#endif //_WX_MSW_OLE_DATAOBJ_H
// the DIB data
void /* BITMAPINFO */ *m_data;
- DECLARE_NO_COPY_CLASS(wxBitmapDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxBitmapDataObject);
};
// ----------------------------------------------------------------------------
{ return SetData(len, buf); }
private:
- DECLARE_NO_COPY_CLASS(wxBitmapDataObject2)
+ wxDECLARE_NO_COPY_CLASS(wxBitmapDataObject2);
};
// ----------------------------------------------------------------------------
{ return SetData(len, buf); }
private:
- DECLARE_NO_COPY_CLASS(wxFileDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxFileDataObject);
};
// ----------------------------------------------------------------------------
// last data object we got data in
wxDataObjectSimple *m_dataObjectLast;
- DECLARE_NO_COPY_CLASS(wxURLDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxURLDataObject);
};
#endif // _WX_MSW_OLE_DATAOBJ2_H
private:
wxIDropSource *m_pIDropSource; // the pointer to COM interface
- DECLARE_NO_COPY_CLASS(wxDropSource)
+ wxDECLARE_NO_COPY_CLASS(wxDropSource);
};
#endif //wxUSE_DRAG_AND_DROP
wxIDropTarget *m_pIDropTarget; // the pointer to our COM interface
IDataObject *m_pIDataSource; // the pointer to the source data object
- DECLARE_NO_COPY_CLASS(wxDropTarget)
+ wxDECLARE_NO_COPY_CLASS(wxDropTarget);
};
#endif //wxUSE_DRAG_AND_DROP
void* m_printDlg;
private:
- DECLARE_NO_COPY_CLASS(wxWindowsPrintDialog)
+ wxDECLARE_NO_COPY_CLASS(wxWindowsPrintDialog);
DECLARE_CLASS(wxWindowsPrintDialog)
};
private:
WXFARPROC m_lpAbortProc;
- DECLARE_NO_COPY_CLASS(wxWindowsPrinter)
+ wxDECLARE_NO_COPY_CLASS(wxWindowsPrinter);
};
// ---------------------------------------------------------------------------
private:
HDC m_hdc;
- DECLARE_NO_COPY_CLASS(ScreenHDC)
+ wxDECLARE_NO_COPY_CLASS(ScreenHDC);
};
// the same as ScreenHDC but for window DCs
HWND m_hwnd;
HDC m_hdc;
- DECLARE_NO_COPY_CLASS(WindowHDC)
+ wxDECLARE_NO_COPY_CLASS(WindowHDC);
};
// the same as ScreenHDC but for memory DCs: creates the HDC compatible with
private:
HDC m_hdc;
- DECLARE_NO_COPY_CLASS(MemoryHDC)
+ wxDECLARE_NO_COPY_CLASS(MemoryHDC);
};
// a class which selects a GDI object into a DC in its ctor and deselects in
HDC m_hdc;
HGDIOBJ m_hgdiobj;
- DECLARE_NO_COPY_CLASS(SelectInHDC)
+ wxDECLARE_NO_COPY_CLASS(SelectInHDC);
};
// a class which cleans up any GDI object
private:
HDC m_hdc;
- DECLARE_NO_COPY_CLASS(HDCClipper)
+ wxDECLARE_NO_COPY_CLASS(HDCClipper);
};
// set the given map mode for the life time of this object
HDC m_hdc;
int m_modeOld;
- DECLARE_NO_COPY_CLASS(HDCMapModeChanger)
+ wxDECLARE_NO_COPY_CLASS(HDCMapModeChanger);
};
#define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
private:
HGLOBAL m_hGlobal;
- DECLARE_NO_COPY_CLASS(GlobalPtr)
+ wxDECLARE_NO_COPY_CLASS(GlobalPtr);
};
// when working with global pointers (which is unfortunately still necessary
HGLOBAL m_hGlobal;
void *m_ptr;
- DECLARE_NO_COPY_CLASS(GlobalPtrLock)
+ wxDECLARE_NO_COPY_CLASS(GlobalPtrLock);
};
// register the class when it is first needed and unregister it in dtor
friend class wxSocketMSWManager;
- DECLARE_NO_COPY_CLASS(wxSocketImplMSW)
+ wxDECLARE_NO_COPY_CLASS(wxSocketImplMSW);
};
#endif /* _WX_MSW_GSOCKMSW_H_ */
private:
DECLARE_DYNAMIC_CLASS(wxRadioBox)
- DECLARE_NO_COPY_CLASS(wxRadioBox)
+ wxDECLARE_NO_COPY_CLASS(wxRadioBox);
};
#endif
// current path (not '/' terminated)
wxString m_strPath;
- DECLARE_NO_COPY_CLASS(wxRegConfig)
+ wxDECLARE_NO_COPY_CLASS(wxRegConfig);
DECLARE_ABSTRACT_CLASS(wxRegConfig)
};
long m_dwLastError; // last error (0 if none)
- DECLARE_NO_COPY_CLASS(wxRegKey)
+ wxDECLARE_NO_COPY_CLASS(wxRegKey);
};
#endif // wxUSE_REGKEY
// data of this object
class wxSoundData *m_data;
- DECLARE_NO_COPY_CLASS(wxSound)
+ wxDECLARE_NO_COPY_CLASS(wxSound);
};
#endif // wxUSE_SOUND
private:
DECLARE_DYNAMIC_CLASS(wxSpinCtrl)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxSpinCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxSpinCtrl);
};
#endif // wxUSE_SPINCTRL
private:
DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
- DECLARE_NO_COPY_CLASS(wxStaticBitmap)
+ wxDECLARE_NO_COPY_CLASS(wxStaticBitmap);
};
#endif
wxWindowIDRef *m_ids;
- DECLARE_NO_COPY_CLASS(wxSubwindows)
+ wxDECLARE_NO_COPY_CLASS(wxSubwindows);
};
// convenient macro to forward a few methods which are usually propagated to
private:
DWORD m_slot;
- DECLARE_NO_COPY_CLASS(wxTlsKey)
+ wxDECLARE_NO_COPY_CLASS(wxTlsKey);
};
#endif // _WX_MSW_TLS_H_
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxToolBar)
- DECLARE_NO_COPY_CLASS(wxToolBar)
+ wxDECLARE_NO_COPY_CLASS(wxToolBar);
};
#endif // wxUSE_TOOLBAR
wxWindow *m_window; // window we're associated with
DECLARE_ABSTRACT_CLASS(wxToolTip)
- DECLARE_NO_COPY_CLASS(wxToolTip)
+ wxDECLARE_NO_COPY_CLASS(wxToolTip);
};
#endif // _WX_MSW_TOOLTIP_H_
#endif
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxTopLevelWindowMSW)
+ wxDECLARE_NO_COPY_CLASS(wxTopLevelWindowMSW);
};
#endif // _WX_MSW_TOPLEVEL_H_
friend class wxTreeSortHelper;
DECLARE_DYNAMIC_CLASS(wxTreeCtrl)
- DECLARE_NO_COPY_CLASS(wxTreeCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxTreeCtrl);
};
#endif // wxUSE_TREECTRL
friend class wxUxThemeModule;
#endif // wxUSE_UXTHEME
- DECLARE_NO_COPY_CLASS(wxUxThemeEngine)
+ wxDECLARE_NO_COPY_CLASS(wxUxThemeEngine);
};
#if wxUSE_UXTHEME
private:
HTHEME m_hTheme;
- DECLARE_NO_COPY_CLASS(wxUxThemeHandle)
+ wxDECLARE_NO_COPY_CLASS(wxUxThemeHandle);
};
#endif // _WX_UXTHEME_H_
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxToolBar)
- DECLARE_NO_COPY_CLASS(wxToolBar)
+ wxDECLARE_NO_COPY_CLASS(wxToolBar);
};
#else
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxToolMenuBar)
- DECLARE_NO_COPY_CLASS(wxToolMenuBar)
+ wxDECLARE_NO_COPY_CLASS(wxToolMenuBar);
};
#endif
#endif
DECLARE_DYNAMIC_CLASS(wxWindowMSW)
- DECLARE_NO_COPY_CLASS(wxWindowMSW)
+ wxDECLARE_NO_COPY_CLASS(wxWindowMSW);
DECLARE_EVENT_TABLE()
};
private:
LPITEMIDLIST m_pidl;
- DECLARE_NO_COPY_CLASS(wxItemIdList)
+ wxDECLARE_NO_COPY_CLASS(wxItemIdList);
};
// enable autocompleting filenames in the text control with given HWND
#endif // __WXMSW__
private:
- DECLARE_NO_COPY_CLASS(wxNativeContainerWindow)
+ wxDECLARE_NO_COPY_CLASS(wxNativeContainerWindow);
};
#endif // wxHAS_NATIVE_CONTAINER_WINDOW
virtual bool AcceptsFocus() const { return wxControl::AcceptsFocus(); }
protected:
- DECLARE_NO_COPY_CLASS(wxNotebookBase)
+ wxDECLARE_NO_COPY_CLASS(wxNotebookBase);
};
// ----------------------------------------------------------------------------
int m_flags;
- DECLARE_NO_COPY_CLASS(wxNotificationMessageBase)
+ wxDECLARE_NO_COPY_CLASS(wxNotificationMessageBase);
};
#if defined(__WXGTK__) && wxUSE_LIBHILDON
void Register();
void Unregister();
- DECLARE_NO_COPY_CLASS(wxClassInfo)
+ wxDECLARE_NO_COPY_CLASS(wxClassInfo);
};
WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxString& name);
protected:
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxApp)
+ wxDECLARE_NO_COPY_CLASS(wxApp);
};
#endif
// _WX_APP_H_
private:
SIZEL m_PageSize;
DECLARE_CLASS(wxWindowDCImpl)
- DECLARE_NO_COPY_CLASS(wxWindowDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
}; // end of CLASS wxWindowDC
class WXDLLIMPEXP_CORE wxClientDCImpl : public wxWindowDCImpl
private:
DECLARE_CLASS(wxClientDCImpl)
- DECLARE_NO_COPY_CLASS(wxClientDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
}; // end of CLASS wxClientDC
class WXDLLIMPEXP_CORE wxPaintDCImpl : public wxClientDCImpl
wxPaintDCInfo* FindInCache(size_t* pIndex = NULL) const;
private:
DECLARE_CLASS(wxPaintDCImpl)
- DECLARE_NO_COPY_CLASS(wxPaintDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
}; // end of wxPaintDC
#endif
void Init(void);
private:
DECLARE_CLASS(wxMemoryDCImpl)
- DECLARE_NO_COPY_CLASS(wxMemoryDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryDCImpl);
}; // end of CLASS wxMemoryDCImpl
#endif
wxPrintData m_printData;
private:
DECLARE_CLASS(wxPrinterDCImpl)
- DECLARE_NO_COPY_CLASS(wxPrinterDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxPrinterDCImpl);
}; // end of CLASS wxPrinterDC
// Gets an HDC for the specified printer configuration
private:
DECLARE_CLASS(wxScreenDCImpl)
- DECLARE_NO_COPY_CLASS(wxScreenDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxScreenDCImpl);
}; // end of CLASS wxScreenDC
#endif
class wxWindowDisabler* m_pWindowDisabler;
DECLARE_DYNAMIC_CLASS(wxDialog)
- DECLARE_NO_COPY_CLASS(wxDialog)
+ wxDECLARE_NO_COPY_CLASS(wxDialog);
}; // end of CLASS wxDialog
#endif // _WX_DIALOG_H_
DECLARE_DYNAMIC_CLASS(wxListCtrl)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxListCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxListCtrl);
}; // end of CLASS wxListCtrl
#endif // wxUSE_LISTCTRL
private:
DECLARE_CLASS(wxMetafileDCImpl)
- DECLARE_NO_COPY_CLASS(wxMetafileDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMetafileDCImpl);
};
class WXDLLIMPEXP_CORE wxMetafileDC: public wxDC
private:
DECLARE_CLASS(wxMetafileDC)
- DECLARE_NO_COPY_CLASS(wxMetafileDC)
+ wxDECLARE_NO_COPY_CLASS(wxMetafileDC);
};
/*
private:
ULONG* m_slot;
- DECLARE_NO_COPY_CLASS(wxTlsKey)
+ wxDECLARE_NO_COPY_CLASS(wxTlsKey);
};
#endif // _WX_OS2_TLS_H_
friend class wxTreeSortHelper;
DECLARE_DYNAMIC_CLASS(wxTreeCtrl)
- DECLARE_NO_COPY_CLASS(wxTreeCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxTreeCtrl);
}; // end of CLASS wxTreeCtrl
#endif // wxUSE_TREECTRL
SWP m_vWinSwp;
DECLARE_DYNAMIC_CLASS(wxWindowOS2);
- DECLARE_NO_COPY_CLASS(wxWindowOS2)
+ wxDECLARE_NO_COPY_CLASS(wxWindowOS2);
DECLARE_EVENT_TABLE()
}; // end of wxWindow
// wxWidget internal stuff:
DECLARE_DYNAMIC_CLASS(wxDataViewCtrl)
- DECLARE_NO_COPY_CLASS(wxDataViewCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxDataViewCtrl);
DECLARE_EVENT_TABLE()
};
class WXDLLIMPEXP_CORE wxMacCGContextStateSaver
{
- DECLARE_NO_COPY_CLASS(wxMacCGContextStateSaver)
+ wxDECLARE_NO_COPY_CLASS(wxMacCGContextStateSaver);
public:
wxMacCGContextStateSaver( CGContextRef cg )
int m_height;
DECLARE_CLASS(wxWindowDCImpl)
- DECLARE_NO_COPY_CLASS(wxWindowDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
};
private:
DECLARE_CLASS(wxClientDCImpl)
- DECLARE_NO_COPY_CLASS(wxClientDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
};
protected:
DECLARE_CLASS(wxPaintDCImpl)
- DECLARE_NO_COPY_CLASS(wxPaintDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
};
wxBitmap m_selected;
DECLARE_CLASS(wxMemoryDCImpl)
- DECLARE_NO_COPY_CLASS(wxMemoryDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryDCImpl);
};
#endif
private:
DECLARE_CLASS(wxScreenDCImpl)
- DECLARE_NO_COPY_CLASS(wxScreenDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxScreenDCImpl);
};
#endif
private:
WXGLContext m_glContext;
- DECLARE_NO_COPY_CLASS(wxGLContext)
+ wxDECLARE_NO_COPY_CLASS(wxGLContext);
};
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasBase
private:
DECLARE_CLASS(wxMetafileDCImpl)
- DECLARE_NO_COPY_CLASS(wxMetafileDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMetafileDCImpl);
};
class WXDLLIMPEXP_CORE wxMetafileDC: public wxDC
private:
DECLARE_CLASS(wxMetafileDC)
- DECLARE_NO_COPY_CLASS(wxMetafileDC)
+ wxDECLARE_NO_COPY_CLASS(wxMetafileDC);
};
void DoUpdateScrollbarVisibility();
- DECLARE_NO_COPY_CLASS(wxWindowMac)
+ wxDECLARE_NO_COPY_CLASS(wxWindowMac);
DECLARE_EVENT_TABLE()
};
bool m_inDrawing;
- DECLARE_NO_COPY_CLASS(wxOverlay)
+ wxDECLARE_NO_COPY_CLASS(wxOverlay);
};
wxDC* m_dc;
- DECLARE_NO_COPY_CLASS(wxDCOverlay)
+ wxDECLARE_NO_COPY_CLASS(wxDCOverlay);
};
#endif // _WX_OVERLAY_H_
protected:
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxApp)
+ wxDECLARE_NO_COPY_CLASS(wxApp);
};
// ----------------------------------------------------------------------------
private:
bool m_hasCaret;
- DECLARE_NO_COPY_CLASS(wxCaret)
+ wxDECLARE_NO_COPY_CLASS(wxCaret);
};
#endif // _WX_CARET_H_
#endif
DECLARE_CLASS(wxPalmDCImpl)
- DECLARE_NO_COPY_CLASS(wxPalmDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxPalmDCImpl);
};
// ----------------------------------------------------------------------------
// find it ourselves
const wxSize m_size;
- DECLARE_NO_COPY_CLASS(wxDCTempImpl)
+ wxDECLARE_NO_COPY_CLASS(wxDCTempImpl);
};
class WXDLLIMPEXP_CORE wxDCTemp : public wxDC
void InitDC();
DECLARE_CLASS(wxWindowDCImpl)
- DECLARE_NO_COPY_CLASS(wxWindowDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
};
class WXDLLIMPEXP_CORE wxClientDCImpl : public wxWindowDCImpl
void InitDC();
DECLARE_CLASS(wxClientDCImpl)
- DECLARE_NO_COPY_CLASS(wxClientDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
};
class WXDLLIMPEXP_CORE wxPaintDCImpl : public wxClientDCImpl
wxPaintDCInfo *FindInCache(size_t *index = NULL) const;
DECLARE_CLASS(wxPaintDCImpl)
- DECLARE_NO_COPY_CLASS(wxPaintDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
};
#endif
void Init();
DECLARE_CLASS(wxMemoryDCImpl)
- DECLARE_NO_COPY_CLASS(wxMemoryDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryDCImpl);
};
#endif
virtual void DoGetSize(int *w, int *h) const;
DECLARE_CLASS(wxScreenDCImpl)
- DECLARE_NO_COPY_CLASS(wxScreenDCImpl)
+ wxDECLARE_NO_COPY_CLASS(wxScreenDCImpl);
};
#endif
DECLARE_DYNAMIC_CLASS(wxDialog)
- DECLARE_NO_COPY_CLASS(wxDialog)
+ wxDECLARE_NO_COPY_CLASS(wxDialog);
};
#endif
private:
DECLARE_DYNAMIC_CLASS(wxDragImage)
- DECLARE_NO_COPY_CLASS(wxDragImage)
+ wxDECLARE_NO_COPY_CLASS(wxDragImage);
};
#endif
protected:
wxEnhMetaFile m_metafile;
- DECLARE_NO_COPY_CLASS(wxEnhMetaFileDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxEnhMetaFileDataObject);
};
protected:
wxEnhMetaFile m_metafile;
- DECLARE_NO_COPY_CLASS(wxEnhMetaFileSimpleDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxEnhMetaFileSimpleDataObject);
};
#endif // wxUSE_DRAG_AND_DROP
wxFindReplaceDialogImpl *m_impl;
DECLARE_DYNAMIC_CLASS(wxFindReplaceDialog)
- DECLARE_NO_COPY_CLASS(wxFindReplaceDialog)
+ wxDECLARE_NO_COPY_CLASS(wxFindReplaceDialog);
};
#endif // _WX_PALMOS_FDREPDLG_H_
wxArrayString m_fileNames;
DECLARE_DYNAMIC_CLASS(wxFileDialog)
- DECLARE_NO_COPY_CLASS(wxFileDialog)
+ wxDECLARE_NO_COPY_CLASS(wxFileDialog);
};
#endif // _WX_FILEDLG_H_
DECLARE_DYNAMIC_CLASS(wxListCtrl)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxListCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxListCtrl);
};
#endif // wxUSE_LISTCTRL
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxMDIParentFrame)
- DECLARE_NO_COPY_CLASS(wxMDIParentFrame)
+ wxDECLARE_NO_COPY_CLASS(wxMDIParentFrame);
};
// ---------------------------------------------------------------------------
virtual int ShowModal(void);
DECLARE_DYNAMIC_CLASS(wxMessageDialog)
- DECLARE_NO_COPY_CLASS(wxMessageDialog)
+ wxDECLARE_NO_COPY_CLASS(wxMessageDialog);
};
friend class WXDLLIMPEXP_FWD_CORE wxPen;
// Cannot use
- // DECLARE_NO_COPY_CLASS(wxPenRefData)
+ // wxDECLARE_NO_COPY_CLASS(wxPenRefData);
// because copy constructor is explicitly declared above;
// but no copy assignment operator is defined, so declare
// it private to prevent the compiler from defining it:
// current group modified ?
bool m_modGroup;
- DECLARE_NO_COPY_CLASS(wxPrefConfig)
+ wxDECLARE_NO_COPY_CLASS(wxPrefConfig);
DECLARE_ABSTRACT_CLASS(wxPrefConfig)
};
bool m_destroyDC;
wxWindow* m_dialogParent;
- DECLARE_NO_COPY_CLASS(wxPrintDialog)
+ wxDECLARE_NO_COPY_CLASS(wxPrintDialog);
};
class WXDLLIMPEXP_CORE wxPageSetupDialog: public wxDialog
wxPageSetupData m_pageSetupData;
wxWindow* m_dialogParent;
- DECLARE_NO_COPY_CLASS(wxPageSetupDialog)
+ wxDECLARE_NO_COPY_CLASS(wxPageSetupDialog);
};
#endif // wxUSE_PRINTING_ARCHITECTURE
private:
WXFARPROC m_lpAbortProc;
- DECLARE_NO_COPY_CLASS(wxPalmPrinter)
+ wxDECLARE_NO_COPY_CLASS(wxPalmPrinter);
};
// ---------------------------------------------------------------------------
// Virtual function hiding supression
virtual void Update() { wxDialog::Update(); }
- DECLARE_NO_COPY_CLASS(wxProgressDialog)
+ wxDECLARE_NO_COPY_CLASS(wxProgressDialog);
};
#endif // wxUSE_PROGRESSDLG
wxHashTable m_radios;
DECLARE_DYNAMIC_CLASS(wxRadioBox)
- DECLARE_NO_COPY_CLASS(wxRadioBox)
+ wxDECLARE_NO_COPY_CLASS(wxRadioBox);
};
#endif
int m_waveLength;
bool m_isResource;
- DECLARE_NO_COPY_CLASS(wxSound)
+ wxDECLARE_NO_COPY_CLASS(wxSound);
};
#endif
#endif
private:
DECLARE_DYNAMIC_CLASS(wxSpinCtrl)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxSpinCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxSpinCtrl);
};
#endif // _WX_PALMOS_SPINCTRL_H_
private:
DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
- DECLARE_NO_COPY_CLASS(wxStaticBitmap)
+ wxDECLARE_NO_COPY_CLASS(wxStaticBitmap);
};
#endif
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxToolBar)
- DECLARE_NO_COPY_CLASS(wxToolBar)
+ wxDECLARE_NO_COPY_CLASS(wxToolBar);
};
#endif // wxUSE_TOOLBAR
wxWindow *m_window; // window we're associated with
DECLARE_ABSTRACT_CLASS(wxToolTip)
- DECLARE_NO_COPY_CLASS(wxToolTip)
+ wxDECLARE_NO_COPY_CLASS(wxToolTip);
};
#endif // _WX_PALMOS_TOOLTIP_H_
wxWindow *m_winLastFocused;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxTopLevelWindowPalm)
+ wxDECLARE_NO_COPY_CLASS(wxTopLevelWindowPalm);
};
#endif // _WX_PALMOS_TOPLEVEL_H_
friend class wxTreeSortHelper;
DECLARE_DYNAMIC_CLASS(wxTreeCtrl)
- DECLARE_NO_COPY_CLASS(wxTreeCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxTreeCtrl);
};
#endif // wxUSE_TREECTRL
bool HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags);
DECLARE_DYNAMIC_CLASS(wxWindowPalm)
- DECLARE_NO_COPY_CLASS(wxWindowPalm)
+ wxDECLARE_NO_COPY_CLASS(wxWindowPalm);
DECLARE_EVENT_TABLE()
};
bool m_doSave,
m_doRestore;
- DECLARE_NO_COPY_CLASS(wxPersistenceManager)
+ wxDECLARE_NO_COPY_CLASS(wxPersistenceManager);
};
// ----------------------------------------------------------------------------
private:
void * const m_obj;
- DECLARE_NO_COPY_CLASS(wxPersistentObject)
+ wxDECLARE_NO_COPY_CLASS(wxPersistentObject);
};
// FIXME-VC6: VC6 has troubles with template methods of DLL-exported classes,
wxPersistenceManager::Get().SaveAndUnregister(GetWindow());
}
- DECLARE_NO_COPY_CLASS(wxPersistentWindowBase)
+ wxDECLARE_NO_COPY_CLASS(wxPersistentWindowBase);
};
template <class T>
virtual bool IsTopLevel() const { return true; }
- DECLARE_NO_COPY_CLASS(wxPopupWindowBase)
+ wxDECLARE_NO_COPY_CLASS(wxPopupWindowBase);
};
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxPopupTransientWindow)
- DECLARE_NO_COPY_CLASS(wxPopupTransientWindow)
+ wxDECLARE_NO_COPY_CLASS(wxPopupTransientWindow);
};
#if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
private:
DECLARE_ABSTRACT_CLASS(wxPrintDialogBase)
- DECLARE_NO_COPY_CLASS(wxPrintDialogBase)
+ wxDECLARE_NO_COPY_CLASS(wxPrintDialogBase);
};
// ---------------------------------------------------------------------------
private:
DECLARE_DYNAMIC_CLASS(wxPrintDialog)
- DECLARE_NO_COPY_CLASS(wxPrintDialog)
+ wxDECLARE_NO_COPY_CLASS(wxPrintDialog);
};
// ---------------------------------------------------------------------------
private:
DECLARE_ABSTRACT_CLASS(wxPageSetupDialogBase)
- DECLARE_NO_COPY_CLASS(wxPageSetupDialogBase)
+ wxDECLARE_NO_COPY_CLASS(wxPageSetupDialogBase);
};
// ---------------------------------------------------------------------------
private:
DECLARE_DYNAMIC_CLASS(wxPageSetupDialog)
- DECLARE_NO_COPY_CLASS(wxPageSetupDialog)
+ wxDECLARE_NO_COPY_CLASS(wxPageSetupDialog);
};
#endif
wxBackingFile m_backer;
wxFileOffset m_pos;
- DECLARE_NO_COPY_CLASS(wxBackedInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxBackedInputStream);
};
#endif // wxUSE_FILESYSTEM
// socket is shut down
wxSocketBase *m_wxsocket;
- DECLARE_NO_COPY_CLASS(wxSocketImpl)
+ wxDECLARE_NO_COPY_CLASS(wxSocketImpl);
};
#if defined(__WXMSW__)
bool m_oneShot; // true if one shot
- DECLARE_NO_COPY_CLASS(wxTimerImpl)
+ wxDECLARE_NO_COPY_CLASS(wxTimerImpl);
};
#endif // _WX_TIMERIMPL_H_BASE_
private:
DECLARE_CLASS(wxPrintNativeDataBase)
- DECLARE_NO_COPY_CLASS(wxPrintNativeDataBase)
+ wxDECLARE_NO_COPY_CLASS(wxPrintNativeDataBase);
};
//----------------------------------------------------------------------------
private:
DECLARE_CLASS(wxPrinterBase)
- DECLARE_NO_COPY_CLASS(wxPrinterBase)
+ wxDECLARE_NO_COPY_CLASS(wxPrinterBase);
};
//----------------------------------------------------------------------------
private:
DECLARE_CLASS(wxPrinter)
- DECLARE_NO_COPY_CLASS(wxPrinter)
+ wxDECLARE_NO_COPY_CLASS(wxPrinter);
};
//----------------------------------------------------------------------------
private:
DECLARE_ABSTRACT_CLASS(wxPrintout)
- DECLARE_NO_COPY_CLASS(wxPrintout)
+ wxDECLARE_NO_COPY_CLASS(wxPrintout);
};
//----------------------------------------------------------------------------
DECLARE_CLASS(wxPreviewCanvas)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxPreviewCanvas)
+ wxDECLARE_NO_COPY_CLASS(wxPreviewCanvas);
};
//----------------------------------------------------------------------------
DECLARE_EVENT_TABLE()
DECLARE_CLASS(wxPreviewFrame)
- DECLARE_NO_COPY_CLASS(wxPreviewFrame)
+ wxDECLARE_NO_COPY_CLASS(wxPreviewFrame);
};
//----------------------------------------------------------------------------
private:
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxPreviewControlBar)
+ wxDECLARE_NO_COPY_CLASS(wxPreviewControlBar);
};
//----------------------------------------------------------------------------
private:
void Init(wxPrintout *printout, wxPrintout *printoutForPrinting);
- DECLARE_NO_COPY_CLASS(wxPrintPreviewBase)
+ wxDECLARE_NO_COPY_CLASS(wxPrintPreviewBase);
DECLARE_CLASS(wxPrintPreviewBase)
};
private:
DECLARE_CLASS(wxPrintPreview)
- DECLARE_NO_COPY_CLASS(wxPrintPreview)
+ wxDECLARE_NO_COPY_CLASS(wxPrintPreview);
};
//----------------------------------------------------------------------------
private:
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxPrintAbortDialog)
+ wxDECLARE_NO_COPY_CLASS(wxPrintAbortDialog);
};
#endif // wxUSE_PRINTING_ARCHITECTURE
bool m_redirect;
DECLARE_DYNAMIC_CLASS(wxProcess)
- DECLARE_NO_COPY_CLASS(wxProcess)
+ wxDECLARE_NO_COPY_CLASS(wxProcess);
};
// ----------------------------------------------------------------------------
DECLARE_DYNAMIC_CLASS(wxHTTP)
DECLARE_PROTOCOL(wxHTTP)
- DECLARE_NO_COPY_CLASS(wxHTTP)
+ wxDECLARE_NO_COPY_CLASS(wxHTTP);
};
#endif // wxUSE_PROTOCOL_HTTP
friend class wxURL;
DECLARE_DYNAMIC_CLASS(wxProtoInfo)
- DECLARE_NO_COPY_CLASS(wxProtoInfo)
+ wxDECLARE_NO_COPY_CLASS(wxProtoInfo);
};
#endif // wxUSE_PROTOCOL
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxRearrangeList)
+ wxDECLARE_NO_COPY_CLASS(wxRearrangeList);
};
// ----------------------------------------------------------------------------
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxRearrangeCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxRearrangeCtrl);
};
// ----------------------------------------------------------------------------
wxRearrangeCtrl *m_ctrl;
- DECLARE_NO_COPY_CLASS(wxRearrangeDialog)
+ wxDECLARE_NO_COPY_CLASS(wxRearrangeDialog);
};
#endif // wxUSE_REARRANGECTRL
protected:
wxRendererNative& m_rendererNative;
- DECLARE_NO_COPY_CLASS(wxDelegateRendererNative)
+ wxDECLARE_NO_COPY_CLASS(wxDelegateRendererNative);
};
// ----------------------------------------------------------------------------
wxRichTextHeaderFooterData m_headerFooterData;
- DECLARE_NO_COPY_CLASS(wxRichTextPrintout)
+ wxDECLARE_NO_COPY_CLASS(wxRichTextPrintout);
};
/*
wxRichTextBuffer* m_richTextBufferPrinting;
wxRect m_previewRect;
- DECLARE_NO_COPY_CLASS(wxRichTextPrinting)
+ wxDECLARE_NO_COPY_CLASS(wxRichTextPrinting);
};
#endif // wxUSE_RICHTEXT & wxUSE_PRINTING_ARCHITECTURE
bool m_unicodeMode;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxSymbolListCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxSymbolListCtrl);
DECLARE_ABSTRACT_CLASS(wxSymbolListCtrl)
};
friend class wxTCPClient;
friend class wxTCPEventHandler;
- DECLARE_NO_COPY_CLASS(wxTCPConnection)
+ wxDECLARE_NO_COPY_CLASS(wxTCPConnection);
DECLARE_DYNAMIC_CLASS(wxTCPConnection)
};
wxString m_filename;
#endif // __UNIX_LIKE__
- DECLARE_NO_COPY_CLASS(wxTCPServer)
+ wxDECLARE_NO_COPY_CLASS(wxTCPServer);
DECLARE_DYNAMIC_CLASS(wxTCPServer)
};
size_t OnSysWrite(const void *buffer, size_t bufsize);
- DECLARE_NO_COPY_CLASS(wxSocketOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxSocketOutputStream);
};
class WXDLLIMPEXP_NET wxSocketInputStream : public wxInputStream
size_t OnSysRead(void *buffer, size_t bufsize);
- DECLARE_NO_COPY_CLASS(wxSocketInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxSocketInputStream);
};
class WXDLLIMPEXP_NET wxSocketStream : public wxSocketInputStream,
wxSocketStream(wxSocketBase& s);
virtual ~wxSocketStream();
- DECLARE_NO_COPY_CLASS(wxSocketStream)
+ wxDECLARE_NO_COPY_CLASS(wxSocketStream);
};
#endif
bool IsNeeded() const { return GetRange() > GetThumbSize(); }
private:
- DECLARE_NO_COPY_CLASS(wxScrollBarBase)
+ wxDECLARE_NO_COPY_CLASS(wxScrollBarBase);
};
#if defined(__WXUNIVERSAL__)
wxScrollHelperEvtHandler *m_handler;
- DECLARE_NO_COPY_CLASS(wxScrollHelperBase)
+ wxDECLARE_NO_COPY_CLASS(wxScrollHelperBase);
};
// this macro can be used in a wxScrollHelper-derived class to forward wxWindow
// VC++ 6 gives warning for the declaration of template member function
// without definition
#if !defined(__VISUALC__) || wxCHECK_VISUALC_VERSION(7)
- DECLARE_NO_COPY_CLASS(wxScrolled)
+ wxDECLARE_NO_COPY_CLASS(wxScrolled);
#endif
};
// the array of items whose selection state is different from default
wxSelectedIndices m_itemsSel;
- DECLARE_NO_COPY_CLASS(wxSelectionStore)
+ wxDECLARE_NO_COPY_CLASS(wxSelectionStore);
};
#endif // _WX_SELSTORE_H_
private:
DECLARE_CLASS(wxSizerItem)
- DECLARE_NO_COPY_CLASS(wxSizerItem)
+ wxDECLARE_NO_COPY_CLASS(wxSizerItem);
};
WX_DECLARE_EXPORTED_LIST( wxSizerItem, wxSizerItemList );
private:
DECLARE_CLASS(wxFlexGridSizer)
- DECLARE_NO_COPY_CLASS(wxFlexGridSizer)
+ wxDECLARE_NO_COPY_CLASS(wxFlexGridSizer);
};
//---------------------------------------------------------------------------
private:
DECLARE_CLASS(wxStaticBoxSizer)
- DECLARE_NO_COPY_CLASS(wxStaticBoxSizer)
+ wxDECLARE_NO_COPY_CLASS(wxStaticBoxSizer);
};
#endif // wxUSE_STATBOX
private:
DECLARE_CLASS(wxStdDialogButtonSizer)
- DECLARE_NO_COPY_CLASS(wxStdDialogButtonSizer)
+ wxDECLARE_NO_COPY_CLASS(wxStdDialogButtonSizer);
};
#endif // wxUSE_BUTTON
}
private:
- DECLARE_NO_COPY_CLASS(wxSliderBase)
+ wxDECLARE_NO_COPY_CLASS(wxSliderBase);
};
// ----------------------------------------------------------------------------
// the implementation details (platform specific)
class WXDLLIMPEXP_FWD_BASE wxSingleInstanceCheckerImpl *m_impl;
- DECLARE_NO_COPY_CLASS(wxSingleInstanceChecker)
+ wxDECLARE_NO_COPY_CLASS(wxSingleInstanceChecker);
};
#endif // wxUSE_SNGLINST_CHECKER
friend class wxSocketReadGuard;
friend class wxSocketWriteGuard;
- DECLARE_NO_COPY_CLASS(wxSocketBase)
+ wxDECLARE_NO_COPY_CLASS(wxSocketBase);
DECLARE_CLASS(wxSocketBase)
};
bool WaitForAccept(long seconds = -1, long milliseconds = 0);
- DECLARE_NO_COPY_CLASS(wxSocketServer)
+ wxDECLARE_NO_COPY_CLASS(wxSocketServer);
DECLARE_CLASS(wxSocketServer)
};
int m_initialRecvBufferSize;
int m_initialSendBufferSize;
- DECLARE_NO_COPY_CLASS(wxSocketClient)
+ wxDECLARE_NO_COPY_CLASS(wxSocketClient);
DECLARE_CLASS(wxSocketClient)
};
*/
private:
- DECLARE_NO_COPY_CLASS(wxDatagramSocket)
+ wxDECLARE_NO_COPY_CLASS(wxDatagramSocket);
DECLARE_CLASS(wxDatagramSocket)
};
int m_min;
int m_max;
- DECLARE_NO_COPY_CLASS(wxSpinButtonBase)
+ wxDECLARE_NO_COPY_CLASS(wxSpinButtonBase);
};
// ----------------------------------------------------------------------------
virtual void SetSelection(long from, long to) = 0;
private:
- DECLARE_NO_COPY_CLASS(wxSpinCtrlBase)
+ wxDECLARE_NO_COPY_CLASS(wxSpinCtrlBase);
};
// ----------------------------------------------------------------------------
// position in the stream in bytes, *not* in chars
size_t m_pos;
- DECLARE_NO_COPY_CLASS(wxStringInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxStringInputStream);
};
// ----------------------------------------------------------------------------
wxMemoryBuffer m_unconv;
#endif // wxUSE_UNICODE_WCHAR
- DECLARE_NO_COPY_CLASS(wxStringOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxStringOutputStream);
};
#endif // wxUSE_STREAMS
virtual wxSize DoGetBestSize() const;
- DECLARE_NO_COPY_CLASS(wxStaticBitmapBase)
+ wxDECLARE_NO_COPY_CLASS(wxStaticBitmapBase);
};
#if defined(__WXUNIVERSAL__)
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
- DECLARE_NO_COPY_CLASS(wxStaticBoxBase)
+ wxDECLARE_NO_COPY_CLASS(wxStaticBoxBase);
};
#if defined(__WXUNIVERSAL__)
return AdjustSize(wxDefaultSize);
}
- DECLARE_NO_COPY_CLASS(wxStaticLineBase)
+ wxDECLARE_NO_COPY_CLASS(wxStaticLineBase);
};
// ----------------------------------------------------------------------------
virtual void DoSetLabel(const wxString& WXUNUSED(str)) { }
private:
- DECLARE_NO_COPY_CLASS(wxStaticTextBase)
+ wxDECLARE_NO_COPY_CLASS(wxStaticTextBase);
};
// see wx/generic/stattextg.h for the explanation
// if true overrides the width info of the wxStatusBarPanes
bool m_bSameWidthForAllPanes;
- DECLARE_NO_COPY_CLASS(wxStatusBarBase)
+ wxDECLARE_NO_COPY_CLASS(wxStatusBarBase);
};
// ----------------------------------------------------------------------------
// the conversion object we forward to
wxMBConv *m_conv;
- DECLARE_NO_ASSIGN_CLASS(wxConvBrokenFileNames)
+ wxDECLARE_NO_ASSIGN_CLASS(wxConvBrokenFileNames);
};
#endif // __UNIX__
friend class wxStreamBuffer;
DECLARE_ABSTRACT_CLASS(wxStreamBase)
- DECLARE_NO_COPY_CLASS(wxStreamBase)
+ wxDECLARE_NO_COPY_CLASS(wxStreamBase);
};
// ----------------------------------------------------------------------------
friend class wxStreamBuffer;
DECLARE_ABSTRACT_CLASS(wxInputStream)
- DECLARE_NO_COPY_CLASS(wxInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxInputStream);
};
// ----------------------------------------------------------------------------
friend class wxStreamBuffer;
DECLARE_ABSTRACT_CLASS(wxOutputStream)
- DECLARE_NO_COPY_CLASS(wxOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxOutputStream);
};
// ============================================================================
size_t m_currentPos;
DECLARE_DYNAMIC_CLASS(wxCountingOutputStream)
- DECLARE_NO_COPY_CLASS(wxCountingOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxCountingOutputStream);
};
// ---------------------------------------------------------------------------
bool m_owns;
DECLARE_ABSTRACT_CLASS(wxFilterInputStream)
- DECLARE_NO_COPY_CLASS(wxFilterInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxFilterInputStream);
};
class WXDLLIMPEXP_BASE wxFilterOutputStream : public wxOutputStream
bool m_owns;
DECLARE_ABSTRACT_CLASS(wxFilterOutputStream)
- DECLARE_NO_COPY_CLASS(wxFilterOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxFilterOutputStream);
};
enum wxStreamProtocolType
m_flushable;
- DECLARE_NO_ASSIGN_CLASS(wxStreamBuffer)
+ wxDECLARE_NO_ASSIGN_CLASS(wxStreamBuffer);
};
// ---------------------------------------------------------------------------
wxStreamBuffer *m_i_streambuf;
- DECLARE_NO_COPY_CLASS(wxBufferedInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxBufferedInputStream);
};
// ----------------------------------------------------------------------------
wxStreamBuffer *m_o_streambuf;
- DECLARE_NO_COPY_CLASS(wxBufferedOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxBufferedOutputStream);
};
#if WXWIN_COMPATIBILITY_2_6
// the node belongs to a particular iterator instance, it's not copied
// when a copy of the iterator is made
- DECLARE_NO_COPY_CLASS(wxStringIteratorNode)
+ wxDECLARE_NO_COPY_CLASS(wxStringIteratorNode);
};
#endif // wxUSE_UNICODE_UTF8
// copying is disallowed as it would result in more than one pointer into
// the same linked list
- DECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead)
+ wxDECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead);
};
wxStringIteratorNodeHead m_iterators;
wxString& m_str;
wxStringCharType *m_buf;
- DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer);
};
class wxStringInternalBufferLength
size_t m_len;
bool m_lenSet;
- DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
+ wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength);
};
#endif // !wxUSE_STL_BASED_WXSTRING
this->m_str.assign(this->m_buf.data());
}
- DECLARE_NO_COPY_CLASS(wxStringTypeBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxStringTypeBuffer);
};
template<typename T>
this->m_str.assign(this->m_buf.data(), this->m_len);
}
- DECLARE_NO_COPY_CLASS(wxStringTypeBufferLength)
+ wxDECLARE_NO_COPY_CLASS(wxStringTypeBufferLength);
};
#if wxUSE_STL_BASED_WXSTRING
~wxStringInternalBuffer()
{ m_str.m_impl.assign(m_buf.data()); }
- DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer);
};
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE(
m_str.m_impl.assign(m_buf.data(), m_len);
}
- DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
+ wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength);
};
#endif // wxUSE_STL_BASED_WXSTRING
conv.ToWChar(wbuf, wlen, m_buf);
}
- DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxUTF8StringBuffer);
};
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase<char> )
wbuf.SetLength(wlen);
}
- DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength)
+ wxDECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength);
};
#endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR
const wxString * const m_str;
const wxCStrData * const m_cstr;
- DECLARE_NO_ASSIGN_CLASS(wxFormatString)
+ wxDECLARE_NO_ASSIGN_CLASS(wxFormatString);
};
// these two helper classes are used to find wxFormatString argument among fixed
wxTarHeaderRecords *m_HeaderRecs;
wxTarHeaderRecords *m_GlobalHeaderRecs;
- DECLARE_NO_COPY_CLASS(wxTarInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxTarInputStream);
};
wxString m_badfit;
bool m_endrecWritten;
- DECLARE_NO_COPY_CLASS(wxTarOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxTarOutputStream);
};
void OnRightButtonDown(wxTaskBarIconEvent& event);
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxTaskBarIconBase)
+ wxDECLARE_NO_COPY_CLASS(wxTaskBarIconBase);
};
virtual wxEvent *Clone() const { return new wxTaskBarIconEvent(*this); }
private:
- DECLARE_NO_ASSIGN_CLASS(wxTaskBarIconEvent)
+ wxDECLARE_NO_ASSIGN_CLASS(wxTaskBarIconEvent);
};
typedef void (wxEvtHandler::*wxTaskBarIconEventFunction)(wxTaskBarIconEvent&);
private:
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxToolBarBase)
+ wxDECLARE_NO_COPY_CLASS(wxToolBarBase);
};
// deprecated function for creating the image for disabled buttons, use
wxTextAttr m_defaultStyle;
- DECLARE_NO_COPY_CLASS(wxTextAreaBase)
+ wxDECLARE_NO_COPY_CLASS(wxTextAreaBase);
};
// this class defines wxTextCtrl interface, wxTextCtrlBase actually implements
wxTextCtrlIface() { }
private:
- DECLARE_NO_COPY_CLASS(wxTextCtrlIface)
+ wxDECLARE_NO_COPY_CLASS(wxTextCtrlIface);
};
// ----------------------------------------------------------------------------
virtual bool DoSaveFile(const wxString& file, int fileType);
- DECLARE_NO_COPY_CLASS(wxTextCtrlBase)
+ wxDECLARE_NO_COPY_CLASS(wxTextCtrlBase);
DECLARE_ABSTRACT_CLASS(wxTextCtrlBase)
};
wxFile m_file;
- DECLARE_NO_COPY_CLASS(wxTextFile)
+ wxDECLARE_NO_COPY_CLASS(wxTextFile);
};
#else // !wxUSE_TEXTFILE
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
- DECLARE_NO_COPY_CLASS(wxToggleButtonBase)
+ wxDECLARE_NO_COPY_CLASS(wxToggleButtonBase);
};
friend class wxConditionInternal;
- DECLARE_NO_COPY_CLASS(wxMutex)
+ wxDECLARE_NO_COPY_CLASS(wxMutex);
};
// a helper class which locks the mutex in the ctor and unlocks it in the dtor:
};
#endif // Unix&OS2/Win32
- DECLARE_NO_COPY_CLASS(wxCriticalSection)
+ wxDECLARE_NO_COPY_CLASS(wxCriticalSection);
};
#if wxCRITSECT_IS_MUTEX
private:
wxCriticalSection& m_critsect;
- DECLARE_NO_COPY_CLASS(wxCriticalSectionLocker)
+ wxDECLARE_NO_COPY_CLASS(wxCriticalSectionLocker);
};
// ----------------------------------------------------------------------------
private:
wxConditionInternal *m_internal;
- DECLARE_NO_COPY_CLASS(wxCondition)
+ wxDECLARE_NO_COPY_CLASS(wxCondition);
};
#if WXWIN_COMPATIBILITY_2_6
private:
wxSemaphoreInternal *m_internal;
- DECLARE_NO_COPY_CLASS(wxSemaphore)
+ wxDECLARE_NO_COPY_CLASS(wxSemaphore);
};
// ----------------------------------------------------------------------------
wxMutex& m_mutex;
wxSemaphore m_semaphore;
- DECLARE_NO_COPY_CLASS(wxConditionInternal)
+ wxDECLARE_NO_COPY_CLASS(wxConditionInternal);
};
wxConditionInternal::wxConditionInternal(wxMutex& mutex)
wxTimerImpl *m_impl;
- DECLARE_NO_COPY_CLASS(wxTimer)
+ wxDECLARE_NO_COPY_CLASS(wxTimer);
};
// ----------------------------------------------------------------------------
private:
wxTimer& m_timer;
- DECLARE_NO_COPY_CLASS(wxTimerRunner)
+ wxDECLARE_NO_COPY_CLASS(wxTimerRunner);
};
// ----------------------------------------------------------------------------
friend class wxTipWindowView;
- DECLARE_NO_COPY_CLASS(wxTipWindow)
+ wxDECLARE_NO_COPY_CLASS(wxTipWindow);
};
#endif // wxUSE_TIPWINDOW
// a temporary override of m_winDefault, use the latter if NULL
wxWindowRef m_winTmpDefault;
- DECLARE_NO_COPY_CLASS(wxTopLevelWindowBase)
+ wxDECLARE_NO_COPY_CLASS(wxTopLevelWindowBase);
DECLARE_EVENT_TABLE()
WX_DECLARE_CONTROL_CONTAINER();
};
bool m_quickBestSize;
- DECLARE_NO_COPY_CLASS(wxTreeCtrlBase)
+ wxDECLARE_NO_COPY_CLASS(wxTreeCtrlBase);
};
// ----------------------------------------------------------------------------
wxChar NextChar(); // this should be used instead of GetC() because of Unicode issues
wxChar NextNonSeparators();
- DECLARE_NO_COPY_CLASS(wxTextInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxTextInputStream);
};
typedef enum
wxMBConv *m_conv;
#endif
- DECLARE_NO_COPY_CLASS(wxTextOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxTextOutputStream);
};
#endif
// update m_penXXX objects above
const wxColourScheme * const m_scheme;
- DECLARE_NO_COPY_CLASS(wxStdRenderer)
+ wxDECLARE_NO_COPY_CLASS(wxStdRenderer);
};
#endif // _WX_UNIV_STDREND_H_
// either wxSelectDispatcher or wxEpollDispatcher
wxFDIODispatcher *m_dispatcher;
- DECLARE_NO_COPY_CLASS(wxConsoleEventLoop)
+ wxDECLARE_NO_COPY_CLASS(wxConsoleEventLoop);
};
#endif // wxUSE_CONSOLE_EVENTLOOP
private:
pthread_key_t m_key;
- DECLARE_NO_COPY_CLASS(wxTlsKey)
+ wxDECLARE_NO_COPY_CLASS(wxTlsKey);
};
#endif // _WX_UNIX_TLS_H_
wxWindowList *m_winDisabled;
bool m_disabled;
- DECLARE_NO_COPY_CLASS(wxWindowDisabler)
+ wxDECLARE_NO_COPY_CLASS(wxWindowDisabler);
};
// ----------------------------------------------------------------------------
private:
DECLARE_CLASS(wxGenericValidator)
- DECLARE_NO_ASSIGN_CLASS(wxGenericValidator)
+ wxDECLARE_NO_ASSIGN_CLASS(wxGenericValidator);
};
#endif // wxUSE_VALIDATORS
static bool ms_isSilent;
DECLARE_DYNAMIC_CLASS(wxValidator)
- DECLARE_NO_COPY_CLASS(wxValidator)
+ wxDECLARE_NO_COPY_CLASS(wxValidator);
};
extern WXDLLIMPEXP_DATA_CORE(const wxValidator) wxDefaultValidator;
wxArrayString m_excludes;
private:
- DECLARE_NO_ASSIGN_CLASS(wxTextValidator)
+ wxDECLARE_NO_ASSIGN_CLASS(wxTextValidator);
DECLARE_DYNAMIC_CLASS(wxTextValidator)
DECLARE_EVENT_TABLE()
};
wxColour m_colBgSel;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxVListBox)
+ wxDECLARE_NO_COPY_CLASS(wxVListBox);
DECLARE_ABSTRACT_CLASS(wxVListBox)
};
#endif // __WXMAC__
private:
- DECLARE_NO_COPY_CLASS(wxVScrolledWindow)
+ wxDECLARE_NO_COPY_CLASS(wxVScrolledWindow);
DECLARE_ABSTRACT_CLASS(wxVScrolledWindow)
};
#endif // __WXMAC__
private:
- DECLARE_NO_COPY_CLASS(wxHScrolledWindow)
+ wxDECLARE_NO_COPY_CLASS(wxHScrolledWindow);
DECLARE_ABSTRACT_CLASS(wxHScrolledWindow)
};
#endif // __WXMAC__
private:
- DECLARE_NO_COPY_CLASS(wxHVScrolledWindow)
+ wxDECLARE_NO_COPY_CLASS(wxHVScrolledWindow);
DECLARE_ABSTRACT_CLASS(wxHVScrolledWindow)
};
wxFile *m_file;
bool m_file_destroy;
- DECLARE_NO_COPY_CLASS(wxFileInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxFileInputStream);
};
class WXDLLIMPEXP_BASE wxFileOutputStream : public wxOutputStream
wxFile *m_file;
bool m_file_destroy;
- DECLARE_NO_COPY_CLASS(wxFileOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxFileOutputStream);
};
class WXDLLIMPEXP_BASE wxTempFileOutputStream : public wxOutputStream
private:
wxTempFile *m_file;
- DECLARE_NO_COPY_CLASS(wxTempFileOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxTempFileOutputStream);
};
class WXDLLIMPEXP_BASE wxFileStream : public wxFileInputStream,
virtual bool IsOk() const;
private:
- DECLARE_NO_COPY_CLASS(wxFileStream)
+ wxDECLARE_NO_COPY_CLASS(wxFileStream);
};
#endif //wxUSE_FILE
wxFFile *m_file;
bool m_file_destroy;
- DECLARE_NO_COPY_CLASS(wxFFileInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxFFileInputStream);
};
class WXDLLIMPEXP_BASE wxFFileOutputStream : public wxOutputStream
wxFFile *m_file;
bool m_file_destroy;
- DECLARE_NO_COPY_CLASS(wxFFileOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxFFileOutputStream);
};
class WXDLLIMPEXP_BASE wxFFileStream : public wxFFileInputStream,
virtual bool IsOk() const;
private:
- DECLARE_NO_COPY_CLASS(wxFFileStream)
+ wxDECLARE_NO_COPY_CLASS(wxFFileStream);
};
#endif //wxUSE_FFILE
DECLARE_ABSTRACT_CLASS(wxWindowBase)
- DECLARE_NO_COPY_CLASS(wxWindowBase)
+ wxDECLARE_NO_COPY_CLASS(wxWindowBase);
DECLARE_EVENT_TABLE()
};
bool Validate() { return true; }
private:
- DECLARE_NO_COPY_CLASS(wxWizardBase)
+ wxDECLARE_NO_COPY_CLASS(wxWizardBase);
};
// include the real class declaration
private:
wxWindow *m_win;
- DECLARE_NO_COPY_CLASS(wxWindowUpdateLocker)
+ wxDECLARE_NO_COPY_CLASS(wxWindowUpdateLocker);
};
#endif // _WX_WUPDLOCK_H_
void Init();
DECLARE_DYNAMIC_CLASS(wxWindowX11)
- DECLARE_NO_COPY_CLASS(wxWindowX11)
+ wxDECLARE_NO_COPY_CLASS(wxWindowX11);
DECLARE_EVENT_TABLE()
};
// doesn't give us any means to copy a _locale_t object so we reduce the
// functionality to least common denominator here -- it shouldn't be a
// problem as copying the locale objects shouldn't be often needed
- DECLARE_NO_COPY_CLASS(wxXLocale)
+ wxDECLARE_NO_COPY_CLASS(wxXLocale);
};
#else // !wxHAS_XLOCALE_SUPPORT
// although it's not a problem to copy the objects of this class, we use
// this macro in this implementation for consistency with the xlocale-based
// one which can't be copied when using MSVC locale API
- DECLARE_NO_COPY_CLASS(wxXLocale)
+ wxDECLARE_NO_COPY_CLASS(wxXLocale);
};
#endif // wxHAS_XLOCALE_SUPPORT/!wxHAS_XLOCALE_SUPPORT
void Register();
void Unregister();
- DECLARE_NO_COPY_CLASS(wxClassInfo)
+ wxDECLARE_NO_COPY_CLASS(wxClassInfo);
};
wxString m_Comment;
bool m_endrecWritten;
- DECLARE_NO_COPY_CLASS(wxZipOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxZipOutputStream);
};
friend class wxArchiveFSHandler;
#endif
- DECLARE_NO_COPY_CLASS(wxZipInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxZipInputStream);
};
struct z_stream_s *m_inflate;
wxFileOffset m_pos;
- DECLARE_NO_COPY_CLASS(wxZlibInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxZlibInputStream);
};
class WXDLLIMPEXP_BASE wxZlibOutputStream: public wxFilterOutputStream {
struct z_stream_s *m_deflate;
wxFileOffset m_pos;
- DECLARE_NO_COPY_CLASS(wxZlibOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxZlibOutputStream);
};
class WXDLLIMPEXP_BASE wxZlibClassFactory: public wxFilterClassFactory
In such case, this macro can be used to disable the automatic assignment
operator generation.
- @see DECLARE_NO_COPY_CLASS()
+ @see wxDECLARE_NO_COPY_CLASS()
*/
-#define DECLARE_NO_ASSIGN_CLASS(classname)
+#define wxDECLARE_NO_ASSIGN_CLASS(classname)
/**
This macro can be used in a class declaration to disable the generation of
private:
// widgets can't be copied
- DECLARE_NO_COPY_CLASS(FooWidget)
+ wxDECLARE_NO_COPY_CLASS(FooWidget);
};
@endcode
- Notice that a semicolon should not be used after this macro and that it
- changes the access specifier to private internally so it is better to use
- it at the end of the class declaration.
+ Notice that a semicolon must be used after this macro and that it changes
+ the access specifier to private internally so it is better to use it at the
+ end of the class declaration.
+
+ @see wxDECLARE_NO_ASSIGN_CLASS(), wxDECLARE_NO_COPY_TEMPLATE_CLASS()
*/
-#define DECLARE_NO_COPY_CLASS(classname)
+#define wxDECLARE_NO_COPY_CLASS(classname)
/**
- Equivalent of DECLARE_NO_COPY_CLASS() for template classes.
+ Analog of wxDECLARE_NO_COPY_CLASS() for template classes.
This macro can be used for template classes (with a single template
- parameter) for the same purpose as DECLARE_NO_COPY_CLASS() is used with the
+ parameter) for the same purpose as wxDECLARE_NO_COPY_CLASS() is used with the
non-template classes.
@param classname The name of the template class.
@param arg The name of the template parameter.
*/
-#define DECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg)
+#define wxDECLARE_NO_COPY_TEMPLATE_CLASS(classname, arg)
/**
A function which deletes and nulls the pointer.
virtual bool OnInit();
- DECLARE_NO_COPY_CLASS(MyApp)
+ wxDECLARE_NO_COPY_CLASS(MyApp);
};
class MyFrame: public wxFrame
wxBoxSizer *m_paneSizer;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(MyFrame)
+ wxDECLARE_NO_COPY_CLASS(MyFrame);
};
class MyDialog : public wxDialog
wxGridSizer *m_paneSizer;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(MyDialog)
+ wxDECLARE_NO_COPY_CLASS(MyDialog);
};
// number of lines drawn in OnPaint()
int m_numLines;
- DECLARE_NO_COPY_CLASS(MyFrame)
+ wxDECLARE_NO_COPY_CLASS(MyFrame);
DECLARE_EVENT_TABLE()
};
private:
bool m_uploadReport;
- DECLARE_NO_COPY_CLASS(MyApp)
+ wxDECLARE_NO_COPY_CLASS(MyApp);
};
IMPLEMENT_APP(MyApp)
wxTextCtrl *m_text;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(MyRearrangeDialog)
+ wxDECLARE_NO_COPY_CLASS(MyRearrangeDialog);
};
BEGIN_EVENT_TABLE(MyRearrangeDialog, wxRearrangeDialog)
*m_chkCentre;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(TestMessageBoxDialog)
+ wxDECLARE_NO_COPY_CLASS(TestMessageBoxDialog);
};
class TestDefaultActionDialog: public wxDialog
virtual bool DoSaveDocument(const wxString& filename);
virtual bool DoOpenDocument(const wxString& filename);
- DECLARE_NO_COPY_CLASS(wxTextDocument)
+ wxDECLARE_NO_COPY_CLASS(wxTextDocument);
DECLARE_CLASS(wxTextDocument)
};
TextEditDocument() : wxTextDocument() { }
virtual wxTextCtrl* GetTextCtrl() const;
- DECLARE_NO_COPY_CLASS(TextEditDocument)
+ wxDECLARE_NO_COPY_CLASS(TextEditDocument);
DECLARE_DYNAMIC_CLASS(TextEditDocument)
};
wxMenu *m_menuEdit;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(MyApp)
+ wxDECLARE_NO_COPY_CLASS(MyApp);
};
DECLARE_APP(MyApp)
private:
wxString m_swf;
- DECLARE_NO_COPY_CLASS(FlashApp)
+ wxDECLARE_NO_COPY_CLASS(FlashApp);
};
// Define a new frame type: this is going to be our main frame
*m_funcarg;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(FlashFrame)
+ wxDECLARE_NO_COPY_CLASS(FlashFrame);
};
// ----------------------------------------------------------------------------
// fla for EVT_IDLE handler
bool m_shouldUpdateOrder;
- DECLARE_NO_COPY_CLASS(TabularGridFrame)
+ wxDECLARE_NO_COPY_CLASS(TabularGridFrame);
DECLARE_EVENT_TABLE()
};
wxTextFile m_file;
#endif
- DECLARE_NO_COPY_CLASS(MyHtmlListBox)
+ wxDECLARE_NO_COPY_CLASS(MyHtmlListBox);
DECLARE_DYNAMIC_CLASS(MyHtmlListBox)
};
#if wxUSE_CLIPBOARD
DECLARE_EVENT_TABLE()
#endif // wxUSE_CLIPBOARD
- DECLARE_NO_COPY_CLASS(MyHtmlWindow)
+ wxDECLARE_NO_COPY_CLASS(MyHtmlWindow);
};
// Define a new frame type: this is going to be our main frame
// should we notify the client about changes to m_item?
bool m_advise;
- DECLARE_NO_COPY_CLASS(BenchConnection)
+ wxDECLARE_NO_COPY_CLASS(BenchConnection);
};
// a simple server accepting connections to IPC_TOPIC and IPC_BENCHMARK_TOPIC
virtual bool OnInit();
private:
- DECLARE_NO_COPY_CLASS(MyApp)
+ wxDECLARE_NO_COPY_CLASS(MyApp);
};
class MyListCtrl: public wxListCtrl
long m_updated;
- DECLARE_NO_COPY_CLASS(MyListCtrl)
+ wxDECLARE_NO_COPY_CLASS(MyListCtrl);
DECLARE_EVENT_TABLE()
};
bool m_smallVirtual;
- DECLARE_NO_COPY_CLASS(MyFrame)
+ wxDECLARE_NO_COPY_CLASS(MyFrame);
DECLARE_EVENT_TABLE()
};
GLfloat m_xrot;
GLfloat m_yrot;
- DECLARE_NO_COPY_CLASS(TestGLCanvas)
+ wxDECLARE_NO_COPY_CLASS(TestGLCanvas);
DECLARE_EVENT_TABLE()
};
GLData m_gldata;
DXFRenderer m_renderer;
- DECLARE_NO_COPY_CLASS(TestGLCanvas)
+ wxDECLARE_NO_COPY_CLASS(TestGLCanvas);
DECLARE_EVENT_TABLE()
};
virtual bool OnInit();
- DECLARE_NO_COPY_CLASS(MyApp)
+ wxDECLARE_NO_COPY_CLASS(MyApp);
};
class MyFrame: public wxFrame
wxWindow *m_replacewindow;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(MyFrame)
+ wxDECLARE_NO_COPY_CLASS(MyFrame);
};
class MySplitterWindow : public wxSplitterWindow
wxFrame *m_frame;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(MySplitterWindow)
+ wxDECLARE_NO_COPY_CLASS(MySplitterWindow);
};
class MyCanvas: public wxScrolledWindow
private:
bool m_mirror;
- DECLARE_NO_COPY_CLASS(MyCanvas)
+ wxDECLARE_NO_COPY_CLASS(MyCanvas);
};
// ============================================================================
ItemContainerWidgetsPage *m_tracker;
int m_value;
- DECLARE_NO_COPY_CLASS(TrackedClientData)
+ wxDECLARE_NO_COPY_CLASS(TrackedClientData);
};
// ============================================================================
private:
CGDirectDisplayID m_id;
- DECLARE_NO_COPY_CLASS(wxDisplayImplMacOSX)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImplMacOSX);
};
class wxDisplayFactoryMacOSX : public wxDisplayFactory
virtual int GetFromPoint(const wxPoint& pt);
protected:
- DECLARE_NO_COPY_CLASS(wxDisplayFactoryMacOSX)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryMacOSX);
};
// ============================================================================
class wxCocoaPrivateScreenCoordinateTransformer
{
- DECLARE_NO_COPY_CLASS(wxCocoaPrivateScreenCoordinateTransformer)
+ wxDECLARE_NO_COPY_CLASS(wxCocoaPrivateScreenCoordinateTransformer);
public:
wxCocoaPrivateScreenCoordinateTransformer();
~wxCocoaPrivateScreenCoordinateTransformer();
// ========================================================================
class wxWindowCocoaHider: protected wxCocoaNSView
{
- DECLARE_NO_COPY_CLASS(wxWindowCocoaHider)
+ wxDECLARE_NO_COPY_CLASS(wxWindowCocoaHider);
public:
wxWindowCocoaHider(wxWindow *owner);
virtual ~wxWindowCocoaHider();
class CocoaWindowCompareContext
{
- DECLARE_NO_COPY_CLASS(CocoaWindowCompareContext)
+ wxDECLARE_NO_COPY_CLASS(CocoaWindowCompareContext);
public:
CocoaWindowCompareContext(); // Not implemented
CocoaWindowCompareContext(NSView *target, NSArray *subviews)
*/
class wxCocoaMouseMovedEventSynthesizer
{
- DECLARE_NO_COPY_CLASS(wxCocoaMouseMovedEventSynthesizer)
+ wxDECLARE_NO_COPY_CLASS(wxCocoaMouseMovedEventSynthesizer);
public:
wxCocoaMouseMovedEventSynthesizer()
{ m_lastScreenMouseLocation = NSZeroPoint;
//// Data
wxContextHelp* m_contextHelp;
- DECLARE_NO_COPY_CLASS(wxContextHelpEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxContextHelpEvtHandler);
};
// ============================================================================
private:
wxArrayString& m_files;
- DECLARE_NO_COPY_CLASS(wxDirTraverserSimple)
+ wxDECLARE_NO_COPY_CLASS(wxDirTraverserSimple);
};
/* static */
private:
wxString m_file;
- DECLARE_NO_COPY_CLASS(wxDirTraverserFindFirst)
+ wxDECLARE_NO_COPY_CLASS(wxDirTraverserFindFirst);
};
/* static */
#endif // wxUSE_DISPLAY
- DECLARE_NO_COPY_CLASS(wxDisplayImplSingle)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImplSingle);
};
// ----------------------------------------------------------------------------
// the size of the buffer
size_t m_size;
- DECLARE_NO_COPY_CLASS(wxStreamTempInputBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxStreamTempInputBuffer);
};
inline wxStreamTempInputBuffer::wxStreamTempInputBuffer()
wxFileConfigLineList *m_pNext, // next node
*m_pPrev; // previous one
- DECLARE_NO_COPY_CLASS(wxFileConfigLineList)
+ wxDECLARE_NO_COPY_CLASS(wxFileConfigLineList);
};
// ----------------------------------------------------------------------------
void SetValue(const wxString& strValue, bool bUser = true);
void SetLine(wxFileConfigLineList *pLine);
- DECLARE_NO_COPY_CLASS(wxFileConfigEntry)
+ wxDECLARE_NO_COPY_CLASS(wxFileConfigEntry);
};
// ----------------------------------------------------------------------------
void SetLastGroup(wxFileConfigGroup *pGroup)
{ m_pLastGroup = pGroup; }
- DECLARE_NO_COPY_CLASS(wxFileConfigGroup)
+ wxDECLARE_NO_COPY_CLASS(wxFileConfigGroup);
};
// ============================================================================
bool m_flagOld;
bool& m_flag;
- DECLARE_NO_COPY_CLASS(ReentrancyBlocker)
+ wxDECLARE_NO_COPY_CLASS(ReentrancyBlocker);
};
// ============================================================================
#endif // wxUSE_DATETIME
}
- DECLARE_NO_COPY_CLASS(wxMemoryFSFile)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryFSFile);
};
#if wxUSE_BASE
wxFTP *m_ftp;
- DECLARE_NO_COPY_CLASS(wxInputFTPStream)
+ wxDECLARE_NO_COPY_CLASS(wxInputFTPStream);
};
class wxOutputFTPStream : public wxSocketOutputStream
wxFTP *m_ftp;
- DECLARE_NO_COPY_CLASS(wxOutputFTPStream)
+ wxDECLARE_NO_COPY_CLASS(wxOutputFTPStream);
};
wxInputStream *wxFTP::GetInputStream(const wxString& path)
unsigned char *pal; // palette
unsigned int ncolours; // number of colours
- DECLARE_NO_COPY_CLASS(GIFImage)
+ wxDECLARE_NO_COPY_CLASS(GIFImage);
};
wxDECLARE_SCOPED_PTR(GIFImage, GIFImagePtr)
protected:
size_t OnSysRead(void *buffer, size_t bufsize);
- DECLARE_NO_COPY_CLASS(wxHTTPStream)
+ wxDECLARE_NO_COPY_CLASS(wxHTTPStream);
};
size_t wxHTTPStream::OnSysRead(void *buffer, size_t bufsize)
wxArrayString m_optionNames;
wxArrayString m_optionValues;
- DECLARE_NO_COPY_CLASS(wxImageRefData)
+ wxDECLARE_NO_COPY_CLASS(wxImageRefData);
};
wxImageRefData::wxImageRefData()
virtual int OnRun() { wxFAIL_MSG( _T("unreachable code") ); return 0; }
virtual bool DoYield(bool, long) { return true; }
- DECLARE_NO_COPY_CLASS(wxDummyConsoleApp)
+ wxDECLARE_NO_COPY_CLASS(wxDummyConsoleApp);
};
// we need a special kind of auto pointer to wxApp which not only deletes the
wxApp::SetInstance(ptr);
}
- DECLARE_NO_COPY_CLASS(wxAppPtr)
+ wxDECLARE_NO_COPY_CLASS(wxAppPtr);
};
// class to ensure that wxAppBase::CleanUp() is called if our Initialize()
wchar_t **argv;
#endif // wxUSE_UNICODE
- DECLARE_NO_COPY_CLASS(InitData)
+ wxDECLARE_NO_COPY_CLASS(InitData);
} gs_initData;
// ============================================================================
bool m_bSwapped; // wrong endianness?
- DECLARE_NO_COPY_CLASS(wxMsgCatalogFile)
+ wxDECLARE_NO_COPY_CLASS(wxMsgCatalogFile);
};
wxPopupTransientWindow *m_popup;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxPopupWindowHandler)
+ wxDECLARE_NO_COPY_CLASS(wxPopupWindowHandler);
};
class wxPopupFocusHandler : public wxEvtHandler
wxPopupTransientWindow *m_popup;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxPopupFocusHandler)
+ wxDECLARE_NO_COPY_CLASS(wxPopupFocusHandler);
};
// ----------------------------------------------------------------------------
// just to suppress a gcc warning
friend class wxRendererPtrDummyFriend;
- DECLARE_NO_COPY_CLASS(wxRendererPtr)
+ wxDECLARE_NO_COPY_CLASS(wxRendererPtr);
};
// return the global and unique wxRendererPtr
private:
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxTCPEventHandler)
+ wxDECLARE_NO_COPY_CLASS(wxTCPEventHandler);
};
enum
static wxTCPEventHandler *ms_handler;
DECLARE_DYNAMIC_CLASS(wxTCPEventHandlerModule)
- DECLARE_NO_COPY_CLASS(wxTCPEventHandlerModule)
+ wxDECLARE_NO_COPY_CLASS(wxTCPEventHandlerModule);
};
IMPLEMENT_DYNAMIC_CLASS(wxTCPEventHandlerModule, wxModule)
wxDataInputStream m_dataIn;
wxDataOutputStream m_dataOut;
- DECLARE_NO_COPY_CLASS(wxIPCSocketStreams)
+ wxDECLARE_NO_COPY_CLASS(wxIPCSocketStreams);
};
namespace
private:
wxIPCSocketStreams& m_streams;
- DECLARE_NO_COPY_CLASS(IPCOutput)
+ wxDECLARE_NO_COPY_CLASS(IPCOutput);
};
} // anonymous namespace
public:
wxSocketState() : wxObject() {}
- DECLARE_NO_COPY_CLASS(wxSocketState)
+ wxDECLARE_NO_COPY_CLASS(wxSocketState);
};
// wxSocketWaitModeChanger: temporarily change the socket flags affecting its
wxSocketBase * const m_socket;
const int m_oldflags;
- DECLARE_NO_COPY_CLASS(wxSocketWaitModeChanger)
+ wxDECLARE_NO_COPY_CLASS(wxSocketWaitModeChanger);
};
// wxSocketRead/WriteGuard are instantiated before starting reading
private:
wxSocketBase * const m_socket;
- DECLARE_NO_COPY_CLASS(wxSocketReadGuard)
+ wxDECLARE_NO_COPY_CLASS(wxSocketReadGuard);
};
class wxSocketWriteGuard
private:
wxSocketBase * const m_socket;
- DECLARE_NO_COPY_CLASS(wxSocketWriteGuard)
+ wxDECLARE_NO_COPY_CLASS(wxSocketWriteGuard);
};
// ============================================================================
// were we initialized successfully?
bool m_ok;
- DECLARE_NO_COPY_CLASS(wxMBConv_wxwin)
+ wxDECLARE_NO_COPY_CLASS(wxMBConv_wxwin);
};
// make the constructors available for unit testing
private:
wxWindowBase * const m_win;
- DECLARE_NO_COPY_CLASS(DragAcceptFilesTarget)
+ wxDECLARE_NO_COPY_CLASS(DragAcceptFilesTarget);
};
wxSizerItem& m_item;
const int m_propOld;
- DECLARE_NO_COPY_CLASS(wxPropChanger)
+ wxDECLARE_NO_COPY_CLASS(wxPropChanger);
};
} // anonymous namespace
wxFileOffset m_pos;
wxFileOffset m_len;
- DECLARE_NO_COPY_CLASS(wxStoredInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxStoredInputStream);
};
wxStoredInputStream::wxStoredInputStream(wxInputStream& stream)
private:
wxFileOffset m_pos;
- DECLARE_NO_COPY_CLASS(wxStoredOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxStoredOutputStream);
};
size_t wxStoredOutputStream::OnSysWrite(const void *buffer, size_t size)
size_t m_start;
size_t m_end;
- DECLARE_NO_COPY_CLASS(wxTeeInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxTeeInputStream);
};
wxTeeInputStream::wxTeeInputStream(wxInputStream& stream)
enum { BUFSIZE = 8192 };
wxCharBuffer m_dummy;
- DECLARE_NO_COPY_CLASS(wxRawInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxRawInputStream);
};
wxRawInputStream::wxRawInputStream(wxInputStream& stream)
wxInfoFrame(wxWindow *parent, const wxString& message);
private:
- DECLARE_NO_COPY_CLASS(wxInfoFrame)
+ wxDECLARE_NO_COPY_CLASS(wxInfoFrame);
};
}
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxDataViewHeaderWindow)
+ wxDECLARE_NO_COPY_CLASS(wxDataViewHeaderWindow);
};
BEGIN_EVENT_TABLE(wxDataViewHeaderWindow, wxHeaderCtrl)
// the text we show
wxTextCtrl *m_text;
- DECLARE_NO_COPY_CLASS(wxDumpPreviewDlg)
+ wxDECLARE_NO_COPY_CLASS(wxDumpPreviewDlg);
};
wxDumpPreviewDlg::wxDumpPreviewDlg(wxWindow *parent,
#endif // wxUSE_FILEDLG
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxDumpOpenExternalDlg)
+ wxDECLARE_NO_COPY_CLASS(wxDumpOpenExternalDlg);
};
BEGIN_EVENT_TABLE(wxDumpOpenExternalDlg, wxDialog)
wxArrayString m_files;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxDebugReportDialog)
+ wxDECLARE_NO_COPY_CLASS(wxDebugReportDialog);
};
// ============================================================================
cairo_t* m_context;
- DECLARE_NO_COPY_CLASS(wxCairoContext)
+ wxDECLARE_NO_COPY_CLASS(wxCairoContext);
};
//-----------------------------------------------------------------------------
private:
const wxHtmlListBox& m_hlbox;
- DECLARE_NO_COPY_CLASS(wxHtmlListBoxStyle)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlListBoxStyle);
};
// ----------------------------------------------------------------------------
static size_t ms_maxLength;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxLogDialog)
+ wxDECLARE_NO_COPY_CLASS(wxLogDialog);
};
BEGIN_EVENT_TABLE(wxLogDialog, wxDialog)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxLogFrame)
+ wxDECLARE_NO_COPY_CLASS(wxLogFrame);
};
BEGIN_EVENT_TABLE(wxLogFrame, wxFrame)
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxNotificationMessageDialog)
+ wxDECLARE_NO_COPY_CLASS(wxNotificationMessageDialog);
};
// ============================================================================
bool m_hasDrawnWindow;
- DECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler);
};
#if wxUSE_TIMER
int m_pos,
m_orient;
- DECLARE_NO_COPY_CLASS(wxAutoScrollTimer)
+ wxDECLARE_NO_COPY_CLASS(wxAutoScrollTimer);
};
// ============================================================================
private:
wxTextFile m_textfile;
- DECLARE_NO_COPY_CLASS(wxFileTipProvider)
+ wxDECLARE_NO_COPY_CLASS(wxFileTipProvider);
};
#endif // wxUSE_TEXTFILE
wxCheckBox *m_checkbox;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxTipDialog)
+ wxDECLARE_NO_COPY_CLASS(wxTipDialog);
};
// ============================================================================
#endif // !wxUSE_POPUPWIN
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxTipWindowView)
+ wxDECLARE_NO_COPY_CLASS(wxTipWindowView);
};
// ============================================================================
private:
wxGenericTreeCtrl *m_owner;
- DECLARE_NO_COPY_CLASS(wxTreeRenameTimer)
+ wxDECLARE_NO_COPY_CLASS(wxTreeRenameTimer);
};
// control used for in-place edit
bool m_aboutToFinish;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxTreeTextCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxTreeTextCtrl);
};
// timer used to clear wxGenericTreeCtrl::m_findPrefix if no key was pressed
private:
wxGenericTreeCtrl *m_owner;
- DECLARE_NO_COPY_CLASS(wxTreeFindTimer)
+ wxDECLARE_NO_COPY_CLASS(wxTreeFindTimer);
};
// a tree item
unsigned int m_isBold :1; // render the label in bold font
unsigned int m_ownsAttr :1; // delete attribute when done
- DECLARE_NO_COPY_CLASS(wxGenericTreeItem)
+ wxDECLARE_NO_COPY_CLASS(wxGenericTreeItem);
};
// =============================================================================
private:
wxVarScrollHelperBase *m_scrollHelper;
- DECLARE_NO_COPY_CLASS(wxVarScrollHelperEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxVarScrollHelperEvtHandler);
};
// ============================================================================
const gchar **m_strings;
size_t m_count;
- DECLARE_NO_COPY_CLASS(GtkArray)
+ wxDECLARE_NO_COPY_CLASS(GtkArray);
};
} // anonymous namespace
private:
static wxClipboard *ms_clipboard;
- DECLARE_NO_COPY_CLASS(wxClipboardSync)
+ wxDECLARE_NO_COPY_CLASS(wxClipboardSync);
};
wxClipboard *wxClipboardSync::ms_clipboard = NULL;
guint16 m_blue;
wxByte m_alpha;
- DECLARE_NO_COPY_CLASS(wxColourRefData)
+ wxDECLARE_NO_COPY_CLASS(wxColourRefData);
};
void wxColourRefData::FreeColour()
wxDL_METHOD_DEFINE( GtkWidget*, gnome_print_job_preview_new,
(GnomePrintJob *gpm, const guchar *title), (gpm, title), NULL )
- DECLARE_NO_COPY_CLASS(wxGnomePrintLibrary)
+ wxDECLARE_NO_COPY_CLASS(wxGnomePrintLibrary);
};
wxGnomePrintLibrary::wxGnomePrintLibrary()
protected:
virtual void AddText(const wxString& WXUNUSED(txt)) {}
- DECLARE_NO_COPY_CLASS(HP_Parser)
+ wxDECLARE_NO_COPY_CLASS(HP_Parser);
};
m_parentItem = NULL;
}
- DECLARE_NO_COPY_CLASS(HP_TagHandler)
+ wxDECLARE_NO_COPY_CLASS(HP_TagHandler);
};
private:
wxHtmlHelpWindow *m_Window;
- DECLARE_NO_COPY_CLASS(wxHtmlHelpHtmlWindow)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlHelpHtmlWindow);
DECLARE_EVENT_TABLE()
};
}
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxHtmlHelpWindowOptionsDialog)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlHelpWindowOptionsDialog);
};
BEGIN_EVENT_TABLE(wxHtmlHelpWindowOptionsDialog, wxDialog)
protected:
virtual void AddText(const wxString& WXUNUSED(txt)) {}
- DECLARE_NO_COPY_CLASS(wxMetaTagParser)
+ wxDECLARE_NO_COPY_CLASS(wxMetaTagParser);
};
class wxMetaTagHandler : public wxHtmlTagHandler
private:
wxString *m_retval;
- DECLARE_NO_COPY_CLASS(wxMetaTagHandler)
+ wxDECLARE_NO_COPY_CLASS(wxMetaTagHandler);
};
bool wxMetaTagHandler::HandleTag(const wxHtmlTag& tag)
int m_pos,
m_orient;
- DECLARE_NO_COPY_CLASS(wxHtmlWinAutoScrollTimer)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlWinAutoScrollTimer);
};
void wxHtmlWinAutoScrollTimer::Notify()
// Should we draw 3-D shading or not
bool m_HasShading;
- DECLARE_NO_COPY_CLASS(wxHtmlLineCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlLineCell);
};
wxHtmlRenderingInfo& WXUNUSED(info)) {}
- DECLARE_NO_COPY_CLASS(wxHtmlImageMapAreaCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlImageMapAreaCell);
};
int WXUNUSED(view_y1), int WXUNUSED(view_y2),
wxHtmlRenderingInfo& WXUNUSED(info)) {}
- DECLARE_NO_COPY_CLASS(wxHtmlImageMapCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlImageMapCell);
};
wxHtmlImageMapCell *m_imageMap;
wxString m_mapName;
- DECLARE_NO_COPY_CLASS(wxHtmlImageCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlImageCell);
};
#if wxUSE_GIF && wxUSE_TIMER
private:
wxHtmlImageCell *m_cell;
- DECLARE_NO_COPY_CLASS(wxGIFTimer)
+ wxDECLARE_NO_COPY_CLASS(wxGIFTimer);
};
#endif
wxHtmlRenderingInfo& WXUNUSED(info)) {}
private:
- DECLARE_NO_COPY_CLASS(wxHtmlPageBreakCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlPageBreakCell);
};
bool wxHtmlPageBreakCell::AdjustPagebreak(int* pagebreak, wxArrayInt& known_pagebreaks) const
}
}
- DECLARE_NO_COPY_CLASS(wxHtmlAnchorCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlAnchorCell);
};
void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
wxHtmlRenderingInfo& info);
- DECLARE_NO_COPY_CLASS(wxHtmlListmarkCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlListmarkCell);
};
wxHtmlListmarkCell::wxHtmlListmarkCell(wxDC* dc, const wxColour& clr) : wxHtmlCell(), m_Brush(clr, wxBRUSHSTYLE_SOLID)
void AddRow(wxHtmlContainerCell *mark, wxHtmlContainerCell *cont);
virtual void Layout(int w);
- DECLARE_NO_COPY_CLASS(wxHtmlListCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlListCell);
};
wxHtmlListCell::wxHtmlListCell(wxHtmlContainerCell *parent) : wxHtmlContainerCell(parent)
// only once, before first Layout().
void ComputeMinMaxWidths();
- DECLARE_NO_COPY_CLASS(wxHtmlTableCell)
+ wxDECLARE_NO_COPY_CLASS(wxHtmlTableCell);
};
HACCEL m_hAccel;
bool m_ok;
- DECLARE_NO_COPY_CLASS(wxAcceleratorRefData)
+ wxDECLARE_NO_COPY_CLASS(wxAcceleratorRefData);
};
// ============================================================================
GetConsoleCommandHistory_t m_pfnGetConsoleCommandHistory;
GetConsoleCommandHistoryLength_t m_pfnGetConsoleCommandHistoryLength;
- DECLARE_NO_COPY_CLASS(wxConsoleStderr)
+ wxDECLARE_NO_COPY_CLASS(wxConsoleStderr);
};
bool wxConsoleStderr::DoInit()
wxCheckListBox *m_pParent;
size_t m_nIndex;
- DECLARE_NO_COPY_CLASS(wxCheckListBoxItem)
+ wxDECLARE_NO_COPY_CLASS(wxCheckListBoxItem);
};
wxCheckListBoxItem::wxCheckListBoxItem(wxCheckListBox *pParent, size_t nIndex)
COLORREF m_oldColFg,
m_oldColBg;
- DECLARE_NO_COPY_CLASS(wxTextColoursChanger)
+ wxDECLARE_NO_COPY_CLASS(wxTextColoursChanger);
};
// background mode
const HDC m_hdc;
int m_oldMode;
- DECLARE_NO_COPY_CLASS(wxBkModeChanger)
+ wxDECLARE_NO_COPY_CLASS(wxBkModeChanger);
};
// instead of duplicating the same code which sets and then restores text
wxBrushAttrsSetter(wxMSWDCImpl& dc);
private:
- DECLARE_NO_COPY_CLASS(wxBrushAttrsSetter)
+ wxDECLARE_NO_COPY_CLASS(wxBrushAttrsSetter);
};
// this class saves the old stretch blit mode during its life time
int m_modeOld;
- DECLARE_NO_COPY_CLASS(StretchBltModeChanger)
+ wxDECLARE_NO_COPY_CLASS(StretchBltModeChanger);
};
#if wxUSE_DYNLIB_CLASS
private:
wxDialUpManagerMSW *m_dialUpManager;
- DECLARE_NO_COPY_CLASS(RasTimer)
+ wxDECLARE_NO_COPY_CLASS(RasTimer);
} m_timerStatusPolling;
// thread handle for the thread sitting on connection change event
// this flag tells us whether a call to RasDial() is in progress
static wxDialUpManagerMSW *ms_dialer;
- DECLARE_NO_COPY_CLASS(wxDialUpManagerMSW)
+ wxDECLARE_NO_COPY_CLASS(wxDialUpManagerMSW);
};
// module to destroy helper window created by wxDialUpManagerMSW
int m_flags;
- DECLARE_NO_COPY_CLASS(wxDirData)
+ wxDECLARE_NO_COPY_CLASS(wxDirData);
};
// ============================================================================
wxDisplayInfoArray m_displays;
- DECLARE_NO_COPY_CLASS(wxDisplayFactoryWin32Base)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryWin32Base);
};
// ----------------------------------------------------------------------------
virtual bool ChangeMode(const wxVideoMode& mode);
private:
- DECLARE_NO_COPY_CLASS(wxDisplayImplMultimon)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImplMultimon);
};
class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base
const GUID m_guid;
- DECLARE_NO_COPY_CLASS(wxDisplayInfoDirectDraw)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayInfoDirectDraw);
};
class wxDisplayImplDirectDraw : public wxDisplayImplWin32Base
private:
IDirectDraw2 *m_pDD2;
- DECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw);
};
class wxDisplayFactoryDirectDraw : public wxDisplayFactoryWin32Base
// dynamically resolved DirectDrawCreate()
DirectDrawCreate_t m_pfnDirectDrawCreate;
- DECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw);
};
#endif // wxUSE_DIRECTDRAW
wxArrayVideoModes& m_modes;
const wxVideoMode& m_modeMatch;
- DECLARE_NO_COPY_CLASS(wxDDVideoModesAdder)
+ wxDECLARE_NO_COPY_CLASS(wxDDVideoModesAdder);
};
HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc,
wxDynamicLibrary m_dll;
- DECLARE_NO_COPY_CLASS(wxVersionDLL)
+ wxDECLARE_NO_COPY_CLASS(wxVersionDLL);
};
// class used to create wxDynamicLibraryDetails objects
// registered Message for Dialog
static UINT ms_msgFindDialog;
- DECLARE_NO_COPY_CLASS(wxFindReplaceDialogImpl)
+ wxDECLARE_NO_COPY_CLASS(wxFindReplaceDialogImpl);
};
UINT wxFindReplaceDialogImpl::ms_msgFindDialog = 0;
// the list of facenames we already found while enumerating facenames
wxArrayString m_facenames;
- DECLARE_NO_COPY_CLASS(wxFontEnumeratorHelper)
+ wxDECLARE_NO_COPY_CLASS(wxFontEnumeratorHelper);
};
// ----------------------------------------------------------------------------
LV_ITEM_NATIVE *m_pItem;
LV_ITEM_NATIVE m_item;
- DECLARE_NO_COPY_CLASS(wxLV_ITEM)
+ wxDECLARE_NO_COPY_CLASS(wxLV_ITEM);
};
///////////////////////////////////////////////////////
delete attr;
}
- DECLARE_NO_COPY_CLASS(wxListItemInternalData)
+ wxDECLARE_NO_COPY_CLASS(wxListItemInternalData);
};
// Get the internal data structure
wxQTMediaBackend *m_qtb;
WXHWND m_hwnd;
- DECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler);
};
bool m_bLoadEventSent; // Whether or not FinishLoaded was already called
// prevents it being called multiple times
- DECLARE_NO_COPY_CLASS(wxAMMediaEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxAMMediaEvtHandler);
};
//===========================================================================
wxQTMediaBackend *m_qtb;
WXHWND m_hwnd;
- DECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler);
};
private:
wxWMP10MediaBackend *m_amb;
- DECLARE_NO_COPY_CLASS(wxWMP10MediaEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxWMP10MediaEvtHandler);
};
#endif
virtual bool DoClose() = 0;
private:
- DECLARE_NO_COPY_CLASS(wxNotifMsgImpl)
+ wxDECLARE_NO_COPY_CLASS(wxNotifMsgImpl);
};
// implementation which is simply a bridge to wxGenericNotificationMessage
wxTaskBarIcon * const m_icon;
- DECLARE_NO_COPY_CLASS(wxNotificationIconEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxNotificationIconEvtHandler);
};
// ============================================================================
wxVariant m_variant; // List of further variants
int m_nCurrent; // Current enum position
- DECLARE_NO_COPY_CLASS(wxIEnumVARIANT)
+ wxDECLARE_NO_COPY_CLASS(wxIEnumVARIANT);
};
// ----------------------------------------------------------------------------
private:
wxAccessible *m_pAccessible; // pointer to C++ class we belong to
- DECLARE_NO_COPY_CLASS(wxIAccessible)
+ wxDECLARE_NO_COPY_CLASS(wxIAccessible);
};
// ============================================================================
ULONG m_nCount, // number of formats we support
m_nCurrent; // current enum position
- DECLARE_NO_COPY_CLASS(wxIEnumFORMATETC)
+ wxDECLARE_NO_COPY_CLASS(wxIEnumFORMATETC);
};
// ----------------------------------------------------------------------------
bool m_mustDelete;
- DECLARE_NO_COPY_CLASS(wxIDataObject)
+ wxDECLARE_NO_COPY_CLASS(wxIDataObject);
};
// ============================================================================
{ return GetDataHere(buf); }
#endif
- DECLARE_NO_COPY_CLASS(CFSTR_SHELLURLDataObject)
+ wxDECLARE_NO_COPY_CLASS(CFSTR_SHELLURLDataObject);
};
DWORD m_grfInitKeyState; // button which started the d&d operation
wxDropSource *m_pDropSource; // pointer to C++ class we belong to
- DECLARE_NO_COPY_CLASS(wxIDropSource)
+ wxDECLARE_NO_COPY_CLASS(wxIDropSource);
};
// ============================================================================
// get default drop effect for given keyboard flags
static DWORD GetDropEffect(DWORD flags, wxDragResult defaultAction, DWORD pdwEffect);
- DECLARE_NO_COPY_CLASS(wxIDropTarget)
+ wxDECLARE_NO_COPY_CLASS(wxIDropTarget);
};
// ----------------------------------------------------------------------------
wxColour m_colour;
HPEN m_hPen;
- DECLARE_NO_ASSIGN_CLASS(wxPenRefData)
+ wxDECLARE_NO_ASSIGN_CLASS(wxPenRefData);
};
// ============================================================================
private:
// Cannot use
-// DECLARE_NO_COPY_CLASS(wxRegionRefData)
+// wxDECLARE_NO_COPY_CLASS(wxRegionRefData);
// because copy constructor is explicitly declared above;
// but no copy assignment operator is defined, so declare
// it private to prevent the compiler from defining it:
virtual int GetHeaderButtonHeight(wxWindow *win);
private:
- DECLARE_NO_COPY_CLASS(wxRendererMSW)
+ wxDECLARE_NO_COPY_CLASS(wxRendererMSW);
};
// ----------------------------------------------------------------------------
virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win);
private:
- DECLARE_NO_COPY_CLASS(wxRendererXP)
+ wxDECLARE_NO_COPY_CLASS(wxRendererXP);
};
#endif // wxUSE_UXTHEME
// the mutex handle, may be NULL
HANDLE m_hMutex;
- DECLARE_NO_COPY_CLASS(wxSingleInstanceCheckerImpl)
+ wxDECLARE_NO_COPY_CLASS(wxSingleInstanceCheckerImpl);
};
// ============================================================================
GlobalPtr m_waveData;
GlobalPtrLock m_waveDataPtr;
- DECLARE_NO_COPY_CLASS(wxSoundDataMemory)
+ wxDECLARE_NO_COPY_CLASS(wxSoundDataMemory);
};
// class for sound files and resources
const wxString m_name;
const bool m_isResource;
- DECLARE_NO_COPY_CLASS(wxSoundDataFile)
+ wxDECLARE_NO_COPY_CLASS(wxSoundDataFile);
};
// ============================================================================
private:
int& m_count;
- DECLARE_NO_COPY_CLASS(UpdatesCountFilter)
+ wxDECLARE_NO_COPY_CLASS(UpdatesCountFilter);
};
// ----------------------------------------------------------------------------
const wxArrayString m_strings;
unsigned m_index;
- DECLARE_NO_COPY_CLASS(wxIEnumString)
+ wxDECLARE_NO_COPY_CLASS(wxIEnumString);
};
BEGIN_IID_TABLE(wxIEnumString)
unsigned long m_owningThread;
wxMutexType m_type;
- DECLARE_NO_COPY_CLASS(wxMutexInternal)
+ wxDECLARE_NO_COPY_CLASS(wxMutexInternal);
};
// all mutexes are recursive under Win32 so we don't use mutexType
private:
HANDLE m_semaphore;
- DECLARE_NO_COPY_CLASS(wxSemaphoreInternal)
+ wxDECLARE_NO_COPY_CLASS(wxSemaphoreInternal);
};
wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
// reaches 0 we kill the owning wxThread -- and die ourselves with it
LONG m_nRef;
- DECLARE_NO_COPY_CLASS(wxThreadInternal)
+ wxDECLARE_NO_COPY_CLASS(wxThreadInternal);
};
// small class which keeps a thread alive during its lifetime
size_t m_nSepCount;
wxStaticText *m_staticText;
- DECLARE_NO_COPY_CLASS(wxToolBarTool)
+ wxDECLARE_NO_COPY_CLASS(wxToolBarTool);
};
// ----------------------------------------------------------------------------
// the real client data
wxTreeItemData *m_data;
- DECLARE_NO_COPY_CLASS(wxTreeItemParam)
+ wxDECLARE_NO_COPY_CLASS(wxTreeItemParam);
};
// wxVirutalNode is used in place of a single root when 'hidden' root is
private:
wxTreeItemParam *m_param;
- DECLARE_NO_COPY_CLASS(wxVirtualNode)
+ wxDECLARE_NO_COPY_CLASS(wxVirtualNode);
};
#ifdef __VISUALC__
const wxTreeCtrl *m_tree;
- DECLARE_NO_COPY_CLASS(wxTreeTraversal)
+ wxDECLARE_NO_COPY_CLASS(wxTreeTraversal);
};
// internal class for getting the selected items
private:
wxArrayTreeItemIds& m_selections;
- DECLARE_NO_COPY_CLASS(TraverseSelections)
+ wxDECLARE_NO_COPY_CLASS(TraverseSelections);
};
// internal class for counting tree items
private:
size_t m_count;
- DECLARE_NO_COPY_CLASS(TraverseCounter)
+ wxDECLARE_NO_COPY_CLASS(TraverseCounter);
};
// ----------------------------------------------------------------------------
HINTERNET m_hFile;
size_t OnSysRead(void *buffer, size_t bufsize);
- DECLARE_NO_COPY_CLASS(wxWinINetInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxWinINetInputStream);
};
size_t wxWinINetInputStream::GetSize() const
// the PID we're looking from
DWORD pid;
- DECLARE_NO_COPY_CLASS(wxFindByPidParams)
+ wxDECLARE_NO_COPY_CLASS(wxFindByPidParams);
};
// wxKill helper: EnumWindows() callback which is used to find the first (top
protected:
HANDLE m_hInput;
- DECLARE_NO_COPY_CLASS(wxPipeInputStream)
+ wxDECLARE_NO_COPY_CLASS(wxPipeInputStream);
};
class wxPipeOutputStream: public wxOutputStream
protected:
HANDLE m_hOutput;
- DECLARE_NO_COPY_CLASS(wxPipeOutputStream)
+ wxDECLARE_NO_COPY_CLASS(wxPipeOutputStream);
};
// define this to let wxexec.cpp know that we know what we're doing
wxColour m_vColour;
WXHPEN m_hPen;// in OS/2 GPI this will be the PS the pen is associated with
- DECLARE_NO_ASSIGN_CLASS(wxPenRefData)
+ wxDECLARE_NO_ASSIGN_CLASS(wxPenRefData);
};
#define M_PENDATA ((wxPenRefData *)m_refData)
);
const wxTreeCtrl* m_pTree;
- DECLARE_NO_COPY_CLASS(wxTreeTraversal)
+ wxDECLARE_NO_COPY_CLASS(wxTreeTraversal);
}; // end of CLASS wxTreeTraversal
//
friend class wxCursor;
- DECLARE_NO_ASSIGN_CLASS(wxCursorRefData)
+ wxDECLARE_NO_ASSIGN_CLASS(wxCursorRefData);
};
#define M_CURSORDATA static_cast<wxCursorRefData*>(m_refData)
private:
wxQTMediaBackend *m_qtb;
- DECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxQTMediaEvtHandler);
};
//===========================================================================
wxTaskBarIcon *m_parent;
class wxTaskBarIconWindow *m_menuEventWindow;
- DECLARE_NO_COPY_CLASS(wxTaskBarIconImpl)
+ wxDECLARE_NO_COPY_CLASS(wxTaskBarIconImpl);
};
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxMacPortSaver
{
- DECLARE_NO_COPY_CLASS(wxMacPortSaver)
+ wxDECLARE_NO_COPY_CLASS(wxMacPortSaver);
public:
wxMacPortSaver( GrafPtr port );
class WXDLLEXPORT wxMacWindowClipper : public wxMacPortSaver
{
- DECLARE_NO_COPY_CLASS(wxMacWindowClipper)
+ wxDECLARE_NO_COPY_CLASS(wxMacWindowClipper);
public:
wxMacWindowClipper( const wxWindow* win );
wxMutex& m_mutex;
wxSemaphore m_semaphore;
- DECLARE_NO_COPY_CLASS(wxConditionInternal)
+ wxDECLARE_NO_COPY_CLASS(wxConditionInternal);
};
wxConditionInternal::wxConditionInternal( wxMutex& mutex )
wxMenu * CreatePopupMenu()
{ return m_taskBarIcon->CreatePopupMenu(); }
- DECLARE_NO_COPY_CLASS(wxTaskBarIconImpl)
+ wxDECLARE_NO_COPY_CLASS(wxTaskBarIconImpl);
protected:
wxTaskBarIcon *m_taskBarIcon;
private:
CGDirectDisplayID m_id;
- DECLARE_NO_COPY_CLASS(wxDisplayImplMacOSX)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImplMacOSX);
};
class wxDisplayFactoryMacOSX : public wxDisplayFactory
virtual int GetFromPoint(const wxPoint& pt);
protected:
- DECLARE_NO_COPY_CLASS(wxDisplayFactoryMacOSX)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryMacOSX);
};
// ============================================================================
CFSocketRef m_socket;
CFRunLoopSourceRef m_source;
- DECLARE_NO_COPY_CLASS(wxSocketImplMac)
+ wxDECLARE_NO_COPY_CLASS(wxSocketImplMac);
};
} // anonymous namespace
friend class WXDLLIMPEXP_FWD_CORE wxPalette;
- DECLARE_NO_ASSIGN_CLASS(wxPaletteRefData)
+ wxDECLARE_NO_ASSIGN_CLASS(wxPaletteRefData);
};
wxPaletteRefData::wxPaletteRefData()
HACCEL m_hAccel;
bool m_ok;
- DECLARE_NO_COPY_CLASS(wxAcceleratorRefData)
+ wxDECLARE_NO_COPY_CLASS(wxAcceleratorRefData);
};
#define M_ACCELDATA ((wxAcceleratorRefData *)m_refData)
private:
wxMask *m_bitmapMask;
- DECLARE_NO_COPY_CLASS(wxBitmapRefData)
+ wxDECLARE_NO_COPY_CLASS(wxBitmapRefData);
};
// ----------------------------------------------------------------------------
private:
- DECLARE_NO_COPY_CLASS(wxCheckListBoxItem)
+ wxDECLARE_NO_COPY_CLASS(wxCheckListBoxItem);
bool m_bChecked;
wxCheckListBox *m_pParent;
size_t m_nIndex;
// registered Message for Dialog
static UINT ms_msgFindDialog;
- DECLARE_NO_COPY_CLASS(wxFindReplaceDialogImpl)
+ wxDECLARE_NO_COPY_CLASS(wxFindReplaceDialogImpl);
};
UINT wxFindReplaceDialogImpl::ms_msgFindDialog = 0;
// the mutex handle, may be NULL
HANDLE m_hMutex;
- DECLARE_NO_COPY_CLASS(wxSingleInstanceCheckerImpl)
+ wxDECLARE_NO_COPY_CLASS(wxSingleInstanceCheckerImpl);
};
// ============================================================================
HANDLE m_mutex;
- DECLARE_NO_COPY_CLASS(wxMutexInternal)
+ wxDECLARE_NO_COPY_CLASS(wxMutexInternal);
};
// all mutexes are recursive under Win32 so we don't use mutexType
private:
HANDLE m_semaphore;
- DECLARE_NO_COPY_CLASS(wxSemaphoreInternal)
+ wxDECLARE_NO_COPY_CLASS(wxSemaphoreInternal);
};
wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
// reaches 0 we kill the owning wxThread -- and die ourselves with it
LONG m_nRef;
- DECLARE_NO_COPY_CLASS(wxThreadInternal)
+ wxDECLARE_NO_COPY_CLASS(wxThreadInternal);
};
// small class which keeps a thread alive during its lifetime
private:
size_t m_nSepCount;
- DECLARE_NO_COPY_CLASS(wxToolBarTool)
+ wxDECLARE_NO_COPY_CLASS(wxToolBarTool);
};
wxRect m_rect;
int m_depth;
- DECLARE_NO_COPY_CLASS(wxDisplayImplX11)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImplX11);
};
class wxDisplayFactoryX11 : public wxDisplayFactory
virtual int GetFromPoint(const wxPoint& pt);
protected:
- DECLARE_NO_COPY_CLASS(wxDisplayFactoryX11)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryX11);
};
// ============================================================================
private:
void *m_ptr;
- DECLARE_NO_COPY_CLASS(wxX11Ptr)
+ wxDECLARE_NO_COPY_CLASS(wxX11Ptr);
};
// NB: this function is implemented using X11 and not GDK calls as it's shared
private:
FILE *m_fp;
- DECLARE_NO_COPY_CLASS(wxStdioPipe)
+ wxDECLARE_NO_COPY_CLASS(wxStdioPipe);
};
// ============================================================================
int m_argc;
char **m_argv;
- DECLARE_NO_COPY_CLASS(ArgsArray)
+ wxDECLARE_NO_COPY_CLASS(ArgsArray);
};
} // anonymous namespace
protected:
const int m_fd;
- DECLARE_NO_COPY_CLASS(wxReadFDIOHandler)
+ wxDECLARE_NO_COPY_CLASS(wxReadFDIOHandler);
};
// class for monitoring our end of the process detection pipe, simply sets a
private:
bool m_terminated;
- DECLARE_NO_COPY_CLASS(wxEndHandler)
+ wxDECLARE_NO_COPY_CLASS(wxEndHandler);
};
#if HAS_PIPE_INPUT_STREAM
private:
wxStreamTempInputBuffer * const m_buf;
- DECLARE_NO_COPY_CLASS(wxRedirectedIOHandler)
+ wxDECLARE_NO_COPY_CLASS(wxRedirectedIOHandler);
};
#endif // HAS_PIPE_INPUT_STREAM
projects / wxWidgets.git / commitdiff
