// the reference count
size_t m_ref;
+
+ DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
};
private:
wxInfoFrame *m_InfoFrame;
+
+ DECLARE_NO_COPY_CLASS(wxBusyInfo)
};
private:
wxCaret *m_caret;
+
+ DECLARE_NO_COPY_CLASS(wxCaretSuspend)
};
#endif // wxUSE_CARET
private:
wxClipboard *m_clipboard;
+
+ DECLARE_NO_COPY_CLASS(wxClipboardLocker)
};
#endif // wxUSE_CLIPBOARD
void Init();
struct wxCmdLineParserData *m_data;
+
+ DECLARE_NO_COPY_CLASS(wxCmdLineParser)
};
#else // !wxUSE_CMDLINE_PARSER
private:
DECLARE_DYNAMIC_CLASS(wxCommandProcessor)
+ DECLARE_NO_COPY_CLASS(wxCommandProcessor)
};
#endif // _WX_CMDPROC_H_
wxString m_strName, // name of entry (i.e. name only)
m_strOldPath; // saved path
bool m_bChanged; // was the path changed?
+
+ DECLARE_NO_COPY_CLASS(wxConfigPathChanger)
};
protected:
wxHelpControllerBase* m_helpController;
+
+ DECLARE_NO_COPY_CLASS(wxHelpControllerHelpProvider)
};
// Convenience function for turning context id into wxString
{ return(wxDataObjectSimple::GetDataHere(format, pBuf)); }
bool SetData(const wxDataFormat& format, size_t nLen, const void* pBuf)
{ return(wxDataObjectSimple::SetData(format, nLen, pBuf)); }
+
+ DECLARE_NO_COPY_CLASS(wxCustomDataObject)
};
// ----------------------------------------------------------------------------
#if wxUSE_UNICODE
wxMBConv& m_conv;
#endif
+
+ DECLARE_NO_COPY_CLASS(wxDataInputStream)
};
class WXDLLEXPORT wxDataOutputStream
#if wxUSE_UNICODE
wxMBConv& m_conv;
#endif
+
+ DECLARE_NO_COPY_CLASS(wxDataOutputStream)
};
#endif
// to) is destroyed.
void UnMask();
+
+ DECLARE_NO_COPY_CLASS(wxBufferedDC)
};
friend class WXDLLEXPORT wxDirData;
wxDirData *m_data;
+
+ DECLARE_NO_COPY_CLASS(wxDir)
};
#endif // _WX_DIR_H_
wxCursor m_cursorCopy,
m_cursorMove,
m_cursorStop;
+
+ DECLARE_NO_COPY_CLASS(wxDropSourceBase)
};
// ----------------------------------------------------------------------------
protected:
wxDataObject *m_dataObject;
+
+ DECLARE_NO_COPY_CLASS(wxDropTargetBase)
};
// ----------------------------------------------------------------------------
private:
DECLARE_CLASS(wxDocMDIParentFrame)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxDocMDIParentFrame)
};
/*
private:
DECLARE_EVENT_TABLE()
DECLARE_CLASS(wxDocMDIChildFrame)
+ DECLARE_NO_COPY_CLASS(wxDocMDIChildFrame)
};
#endif
private:
DECLARE_ABSTRACT_CLASS(wxDocument)
+ DECLARE_NO_COPY_CLASS(wxDocument)
};
class WXDLLEXPORT wxView: public wxEvtHandler
wxDocument* m_viewDocument;
wxString m_viewTypeName;
wxWindow* m_viewFrame;
-
+
private:
DECLARE_ABSTRACT_CLASS(wxView)
+ DECLARE_NO_COPY_CLASS(wxView)
};
// Represents user interface (and other) properties of documents and views
private:
DECLARE_CLASS(wxDocTemplate)
+ DECLARE_NO_COPY_CLASS(wxDocTemplate)
};
// One object of this class may be created in an application, to manage all
static wxDocManager* sm_docManager;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxDocManager)
};
// ----------------------------------------------------------------------------
private:
DECLARE_CLASS(wxDocChildFrame)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxDocChildFrame)
};
// ----------------------------------------------------------------------------
private:
DECLARE_CLASS(wxDocParentFrame)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxDocParentFrame)
};
// ----------------------------------------------------------------------------
private:
DECLARE_DYNAMIC_CLASS(wxDocPrintout)
+ DECLARE_NO_COPY_CLASS(wxDocPrintout)
};
#endif // wxUSE_PRINTING_ARCHITECTURE
private:
DECLARE_DYNAMIC_CLASS(wxFileHistory)
+ DECLARE_NO_COPY_CLASS(wxFileHistory)
};
#if wxUSE_STD_IOSTREAM
bool m_UnicodeInput, m_UnicodeOutput;
bool m_JustCopy;
+ DECLARE_NO_COPY_CLASS(wxEncodingConverter)
};
#endif // wxUSE_FONTMAP
class WXDLLEXPORT wxEventLoopImpl *m_impl;
// the pointer to currently active loop
static wxEventLoop *ms_activeLoop;
+
+ DECLARE_NO_COPY_CLASS(wxEventLoop)
};
#endif // _WX_EVTLOOP_H_
// the last string we searched for
wxString m_lastSearch;
+
+ DECLARE_NO_COPY_CLASS(wxFindReplaceDialogBase)
};
// include wxFindReplaceDialog declaration
#ifdef __UNIX__
int m_umask; // the umask to use for file creation
#endif // __UNIX__
+
+ DECLARE_NO_COPY_CLASS(wxFileConfig)
};
#endif
wxDateTime m_Modif;
DECLARE_ABSTRACT_CLASS(wxFSFile)
+ DECLARE_NO_COPY_CLASS(wxFSFile)
};
// handler that succeed in FindFirst query
DECLARE_DYNAMIC_CLASS(wxFileSystem)
+ DECLARE_NO_COPY_CLASS(wxFileSystem)
};
private:
wxArrayString *m_Facenames, *m_Encodings;
+
+ DECLARE_NO_COPY_CLASS(wxFontEnumerator)
};
#endif // _WX_FONTENUM_H_
private:
static wxFontMapper *sm_instance;
+
+ DECLARE_NO_COPY_CLASS(wxFontMapper)
};
// ----------------------------------------------------------------------------
#endif // wxUSE_TOOLBAR
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxFrameBase)
};
// include the real class declaration
wxHashTableLong *m_DirsFound;
wxString DoFind();
+
+ DECLARE_NO_COPY_CLASS(wxZipFSHandler)
};
DECLARE_DYNAMIC_CLASS(wxCalendarCtrl)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxCalendarCtrl)
};
#endif // _WX_GENERIC_CALCTRL_H
protected:
wxListBox *m_listbox;
+
+ DECLARE_NO_COPY_CLASS(wxAnyChoiceDialog)
};
// ----------------------------------------------------------------------------
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxGenericDirCtrl)
+ DECLARE_NO_COPY_CLASS(wxGenericDirCtrl)
};
//-----------------------------------------------------------------------------
DECLARE_EVENT_TABLE()
DECLARE_CLASS(wxDirFilterListCtrl)
+ DECLARE_NO_COPY_CLASS(wxDirFilterListCtrl)
};
#if !defined(__WXMSW__) && !defined(__WXMAC__) && !defined(__WXPM__)
private:
DECLARE_DYNAMIC_CLASS(wxGenericDragImage)
+ DECLARE_NO_COPY_CLASS(wxGenericDragImage)
};
#endif
// suppress the stupid gcc warning about the class having private dtor and
// no friends
friend class wxGridCellEditorDummyFriend;
+
+ DECLARE_NO_COPY_CLASS(wxGridCellEditor)
};
#if wxUSE_TEXTCTRL
void InitData();
wxGridCellAttrProviderData *m_data;
+
+ DECLARE_NO_COPY_CLASS(wxGridCellAttrProvider)
};
//////////////////////////////////////////////////////////////////////
wxGridCellAttrProvider *m_attrProvider;
DECLARE_ABSTRACT_CLASS( wxGridTableBase );
+ DECLARE_NO_COPY_CLASS(wxGridTableBase)
};
int m_id;
int m_comInt1;
int m_comInt2;
+
+ DECLARE_NO_COPY_CLASS(wxGridTableMessage)
};
DECLARE_DYNAMIC_CLASS( wxGrid )
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxGrid)
};
// ----------------------------------------------------------------------------
wxControl* m_ctrl;
DECLARE_DYNAMIC_CLASS(wxGridEditorCreatedEvent)
+ DECLARE_NO_COPY_CLASS(wxGridEditorCreatedEvent)
};
wxGrid::wxGridSelectionModes m_selectionMode;
friend class WXDLLEXPORT wxGrid;
+
+ DECLARE_NO_COPY_CLASS(wxGridSelection)
};
#endif // #ifdef __WXGRIDSEL_H__
private:
// Virtual function hiding supression
virtual void Update() { wxDialog::Update(); }
+
+ DECLARE_NO_COPY_CLASS(wxProgressDialog)
};
#endif
private:
DECLARE_DYNAMIC_CLASS(wxSashWindow)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxSashWindow)
};
BEGIN_DECLARE_EVENT_TYPES()
DECLARE_DYNAMIC_CLASS(wxSplashScreen)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxSplashScreen)
};
/*
DECLARE_DYNAMIC_CLASS(wxSplitterWindow)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxSplitterWindow)
};
// ----------------------------------------------------------------------------
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxTextEntryDialog)
+ DECLARE_NO_COPY_CLASS(wxTextEntryDialog)
};
// ----------------------------------------------------------------------------
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxGenericTreeCtrl)
+ DECLARE_NO_COPY_CLASS(wxGenericTreeCtrl)
};
#if !defined(__WXMSW__) || defined(__WIN16__) || defined(__WXUNIVERSAL__)
private:
DECLARE_DYNAMIC_CLASS(wxTreeLayoutStored)
+ DECLARE_NO_COPY_CLASS(wxTreeLayoutStored)
};
// For backward compatibility
DECLARE_DYNAMIC_CLASS(wxWizard)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxWizard)
};
unsigned char *pal; /* palette */
GIFImage *next; /* next image */
GIFImage *prev; /* prev image */
+
+ DECLARE_NO_COPY_CLASS(GIFImage)
};
// convert current frame to wxImage
bool ConvertToImage(wxImage *image) const;
+
+ DECLARE_NO_COPY_CLASS(wxGIFDecoder)
};
_wxHashTable_NodeBase() : m_nxt(0) {}
_wxHashTable_NodeBase* m_nxt;
+
+// Cannot do this:
+// DECLARE_NO_COPY_CLASS(_wxHashTable_NodeBase)
+// without rewriting the macros, which require a public copy constructor.
};
// private
wxString m_titleFormat;
int m_FrameStyle;
// DECLARE_EVENT_TABLE()
+
+ DECLARE_NO_COPY_CLASS(wxHtmlHelpController)
};
#endif // wxUSE_WXHTML_HELP
wxChar *m_Keyword;
bool m_CaseSensitive;
bool m_WholeWords;
+
+ DECLARE_NO_COPY_CLASS(wxSearchEngine)
};
int m_CurIndex; // where we are now
int m_MaxIndex; // number of files we search
// For progress bar: 100*curindex/maxindex = % complete
+
+ DECLARE_NO_COPY_CLASS(wxHtmlSearchStatus)
};
class WXDLLEXPORT wxHtmlHelpData : public wxObject
bool LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f);
// Writes binary book
bool SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f);
+
+ DECLARE_NO_COPY_CLASS(wxHtmlHelpData)
};
#endif
int m_hfStyle;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxHtmlHelpFrame)
};
#endif // wxUSE_WXHTML_HELP
// true if this cell can be placed on pagebreak, false otherwise
wxString m_id;
// unique identifier of the cell, generated from "id" property of tags
+
+ DECLARE_NO_COPY_CLASS(wxHtmlCell)
};
int m_LastLayout;
// if != -1 then call to Layout may be no-op
// if previous call to Layout has same argument
+
+ DECLARE_NO_COPY_CLASS(wxHtmlContainerCell)
};
wxWindow* m_Wnd;
int m_WidthFloat;
// width float is used in adjustWidth (it is in percents)
+
+ DECLARE_NO_COPY_CLASS(wxHtmlWidgetCell)
};
wxList m_HandlersList;
wxHashTable m_HandlersHash;
+ DECLARE_NO_COPY_CLASS(wxHtmlParser)
+
// class for opening files (file system)
wxFileSystem *m_FS;
// handlers stack used by PushTagHandler and PopTagHandler
{ m_Parser->DoParsing(tag.GetBeginPos(), tag.GetEndPos1()); }
wxHtmlParser *m_Parser;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlTagHandler)
};
wxMBConv *m_conv;
wxFontEncoding m_encoding;
#endif
+
+ DECLARE_NO_COPY_CLASS(wxHtmlEntitiesParser)
};
// Finds parameters for tag starting at at and fills the variables
void QueryTag(int at, int* end1, int* end2);
+
+ DECLARE_NO_COPY_CLASS(wxHtmlTagsCache)
};
wxHtmlTag *m_Prev;
wxHtmlTag *m_FirstChild, *m_LastChild;
wxHtmlTag *m_Parent;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlTag)
};
static wxHtmlProcessorList *m_GlobalProcessors;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxHtmlWindow)
};
wxFileSystem *m_FS;
wxHtmlContainerCell *m_Cells;
int m_MaxWidth, m_Width, m_Height;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlDCRenderer)
};
int m_HeaderHeight, m_FooterHeight;
wxHtmlDCRenderer *m_Renderer, *m_RendererHdr;
float m_MarginTop, m_MarginBottom, m_MarginLeft, m_MarginRight, m_MarginSpace;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlPrintout)
};
wxString m_Name;
wxString m_Headers[2], m_Footers[2];
wxFrame *m_Frame;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlEasyPrinting)
};
wxString m_FontFaceFixed, m_FontFaceNormal;
// html font sizes and faces of fixed and proportional fonts
+ DECLARE_NO_COPY_CLASS(wxHtmlWinParser)
+
#if !wxUSE_UNICODE
wxFontEncoding m_InputEnc, m_OutputEnc;
// I/O font encodings
protected:
wxHtmlWinParser *m_WParser; // same as m_Parser, but overcasted
+
+ DECLARE_NO_COPY_CLASS(wxHtmlWinTagHandler)
};
bool m_bConvertEncoding;
static wxLanguageInfoArray *ms_languagesDB;
+
+ DECLARE_NO_COPY_CLASS(wxLocale)
};
// ----------------------------------------------------------------------------
wxChar * m_buffer;
size_t m_buffersize;
bool m_deletebufferwhendone;
+
+ DECLARE_NO_COPY_CLASS(wxConnectionBase)
};
// Get the value of this edge or dimension, or if this
// is not determinable, -1.
int GetEdge(wxEdge which, wxWindowBase *thisWin, wxWindowBase *other) const;
+
+ DECLARE_NO_COPY_CLASS(wxIndividualLayoutConstraint)
};
// ----------------------------------------------------------------------------
// do we pass the messages to the old logger?
bool m_bPassMessages;
+
+ DECLARE_NO_COPY_CLASS(wxLogChain)
};
// a chain log target which uses itself as the new logger
// the control we use
wxTextCtrl *m_pTextCtrl;
+
+ DECLARE_NO_COPY_CLASS(wxLogTextCtrl)
};
#endif // wxUSE_TEXTCTRL
private:
wxLogFrame *m_pLogFrame; // the log frame
+
+ DECLARE_NO_COPY_CLASS(wxLogWindow)
};
#endif // wxUSE_LOGWINDOW
long m_style; // combination of wxMENU_XXX flags
wxEvtHandler *m_eventHandler; // a pluggable in event handler
+
+ DECLARE_NO_COPY_CLASS(wxMenuBase)
};
// ----------------------------------------------------------------------------
// the frame we are attached to (may be NULL)
wxFrame *m_menuBarFrame;
+
+ DECLARE_NO_COPY_CLASS(wxMenuBarBase)
};
// ----------------------------------------------------------------------------
private:
size_t m_length;
+
+ DECLARE_NO_COPY_CLASS(wxMemoryInputStream)
};
class WXDLLEXPORT wxMemoryOutputStream : public wxOutputStream
size_t OnSysWrite(const void *buffer, size_t nbytes);
off_t OnSysSeek(off_t pos, wxSeekMode mode);
off_t OnSysTell() const;
+
+ DECLARE_NO_COPY_CLASS(wxMemoryOutputStream)
};
#endif
// optional mask for transparent drawing
wxMask *m_bitmapMask;
+ DECLARE_NO_COPY_CLASS(wxBitmapRefData)
+
#if wxUSE_DIB_FOR_BITMAP
WXHANDLE m_hFileMap; // file mapping handle for large DIB's
#endif
#endif
DECLARE_DYNAMIC_CLASS(wxDC)
+ DECLARE_NO_COPY_CLASS(wxDC)
};
// ----------------------------------------------------------------------------
wxChar* m_sendingData;
int m_dataSize;
wxIPCFormat m_dataType;
+
+ DECLARE_NO_COPY_CLASS(wxDDEConnection)
};
class WXDLLEXPORT wxDDEServer: public wxServerBase
DECLARE_DYNAMIC_CLASS(wxDialog)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxDialog)
};
#endif
private:
DECLARE_DYNAMIC_CLASS(wxDragImage)
+ DECLARE_NO_COPY_CLASS(wxDragImage)
};
#endif
wxFindReplaceDialogImpl *m_impl;
DECLARE_DYNAMIC_CLASS(wxFindReplaceDialog)
+ DECLARE_NO_COPY_CLASS(wxFindReplaceDialog)
};
private:
DECLARE_DYNAMIC_CLASS(wxFileDialog)
+ DECLARE_NO_COPY_CLASS(wxFileDialog)
};
// File selector - backward compatibility
wxHelpControllerBase* m_helpController;
DECLARE_DYNAMIC_CLASS(wxBestHelpController)
+ DECLARE_NO_COPY_CLASS(wxBestHelpController)
};
#endif // wxUSE_HELP && wxUSE_MS_HTML_HELP && defined(__WIN95__) && wxUSE_WXHTML_HELP
DECLARE_DYNAMIC_CLASS(wxListCtrl)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxListCtrl)
};
#endif // wxUSE_LISTCTRL
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxMDIParentFrame)
+ DECLARE_NO_COPY_CLASS(wxMDIParentFrame)
};
// ---------------------------------------------------------------------------
long style = wxOK|wxCENTRE, const wxPoint& pos = wxDefaultPosition);
int ShowModal(void);
+
+ DECLARE_NO_COPY_CLASS(wxMessageDialog)
};
public:
WXIDISPATCH* m_dispatchPtr;
+
+ DECLARE_NO_COPY_CLASS(wxAutomationObject)
};
virtual size_t GetBufferOffset( const wxDataFormat& format );
private:
IDataObject *m_pIDataObject; // pointer to the COM interface
+
+ DECLARE_NO_COPY_CLASS(wxDataObject)
};
#endif //_WX_MSW_OLE_DATAOBJ_H
private:
// the DIB data
void /* BITMAPINFO */ *m_data;
+
+ DECLARE_NO_COPY_CLASS(wxBitmapDataObject)
};
// ----------------------------------------------------------------------------
private:
// last data object we got data in
wxDataObjectSimple *m_dataObjectLast;
+
+ DECLARE_NO_COPY_CLASS(wxURLDataObject)
};
#endif // _WX_MSW_OLE_DATAOBJ2_H
private:
wxIDropSource *m_pIDropSource; // the pointer to COM interface
+
+ DECLARE_NO_COPY_CLASS(wxDropSource)
};
#endif //_WX_OLEDROPSRC_H
wxIDropTarget *m_pIDropTarget; // the pointer to our COM interface
IDataObject *m_pIDataSource; // the pointer to the source data object
+
+ DECLARE_NO_COPY_CLASS(wxDropTarget)
};
#endif //_WX_OLEDROPTGT_H
wxDash * m_dash ;
wxColour m_colour;
WXHPEN m_hPen;
+
+private:
+// Cannot use
+// DECLARE_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:
+ wxPenRefData& operator=(const wxPenRefData&);
};
#define M_PENDATA ((wxPenRefData *)m_refData)
wxDC* m_printerDC;
bool m_destroyDC;
wxWindow* m_dialogParent;
+
+ DECLARE_NO_COPY_CLASS(wxPrintDialog)
};
class WXDLLEXPORT wxPageSetupDialog: public wxDialog
private:
wxPageSetupData m_pageSetupData;
wxWindow* m_dialogParent;
+
+ DECLARE_NO_COPY_CLASS(wxPageSetupDialog)
};
#endif // wxUSE_PRINTING_ARCHITECTURE
private:
WXFARPROC m_lpAbortProc;
+
+ DECLARE_NO_COPY_CLASS(wxWindowsPrinter)
};
// ---------------------------------------------------------------------------
private:
HDC m_hdc;
+
+ DECLARE_NO_COPY_CLASS(ScreenHDC)
};
// the same as ScreenHDC but for memory DCs: creates the HDC in ctor and
private:
HDC m_hdc;
+
+ DECLARE_NO_COPY_CLASS(MemoryHDC)
};
// a class which selects a GDI object into a DC in its ctor and deselects in
private:
HDC m_hdc;
HGDIOBJ m_hgdiobj;
+
+ DECLARE_NO_COPY_CLASS(SelectInHDC)
};
// ---------------------------------------------------------------------------
private:
DECLARE_DYNAMIC_CLASS(wxRadioBox)
+ DECLARE_NO_COPY_CLASS(wxRadioBox)
};
#endif
private:
DECLARE_DYNAMIC_CLASS(wxSpinCtrl)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxSpinCtrl)
};
#endif // _WX_MSW_SPINCTRL_H_
private:
DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
+ DECLARE_NO_COPY_CLASS(wxStaticBitmap)
};
#endif
wxImageList* m_imageList;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxTabCtrl)
};
class WXDLLEXPORT wxTabEvent : public wxNotifyEvent
private:
DECLARE_EVENT_TABLE()
DECLARE_DYNAMIC_CLASS(wxToolBar)
+ DECLARE_NO_COPY_CLASS(wxToolBar)
};
#endif // wxUSE_TOOLBAR
wxWindow *m_window; // window we're associated with
DECLARE_ABSTRACT_CLASS(wxToolTip)
+ DECLARE_NO_COPY_CLASS(wxToolTip)
};
wxWindow *m_winLastFocused;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxTopLevelWindowMSW)
};
// list of all frames and modeless dialogs
friend class wxTreeSortHelper;
DECLARE_DYNAMIC_CLASS(wxTreeCtrl)
+ DECLARE_NO_COPY_CLASS(wxTreeCtrl)
};
#endif // wxUSE_TREECTRL
wxByte* m_waveData;
int m_waveLength;
bool m_isResource;
+
+ DECLARE_NO_COPY_CLASS(wxWave)
};
#endif
#endif
wxArrayPages m_pages; // array of pages
wxImageList *m_imageList; // we can have an associated image list
bool m_ownsImageList; // true if we must delete m_imageList
+
+ DECLARE_NO_COPY_CLASS(wxNotebookBase)
};
// ----------------------------------------------------------------------------
wxPopupFocusHandler *m_handlerFocus;
DECLARE_DYNAMIC_CLASS(wxPopupTransientWindow)
+ DECLARE_NO_COPY_CLASS(wxPopupTransientWindow)
};
#if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
private:
DECLARE_CLASS(wxPrinterBase)
+ DECLARE_NO_COPY_CLASS(wxPrinterBase)
};
/*
private:
DECLARE_ABSTRACT_CLASS(wxPrintout)
+ DECLARE_NO_COPY_CLASS(wxPrintout)
};
/*
DECLARE_CLASS(wxPreviewCanvas)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxPreviewCanvas)
};
/*
private:
DECLARE_CLASS(wxPreviewFrame)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxPreviewFrame)
};
/*
private:
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxPreviewControlBar)
};
/*
private:
void Init(wxPrintout *printout, wxPrintout *printoutForPrinting);
+
+ DECLARE_NO_COPY_CLASS(wxPrintPreviewBase)
};
/*
bool m_redirect;
DECLARE_DYNAMIC_CLASS(wxProcess)
+ DECLARE_NO_COPY_CLASS(wxProcess)
};
// ----------------------------------------------------------------------------
// deletes the header value strings
void ClearHeaders();
+
+ DECLARE_NO_COPY_CLASS(wxHTTP)
};
#endif // wxUSE_PROTOCOL_HTTP
friend class wxURL;
DECLARE_DYNAMIC_CLASS(wxProtoInfo)
+ DECLARE_NO_COPY_CLASS(wxProtoInfo)
};
#endif // wxUSE_PROTOCOL
//
virtual bool Execute(const wxString& str)
{ return Execute(str, -1, wxIPC_TEXT); }
+
+ DECLARE_NO_COPY_CLASS(wxTCPConnection)
};
class wxTCPServer: public wxServerBase
// the name of the file associated to the Unix domain socket, may be empty
wxString m_filename;
#endif // __UNIX_LIKE__
+
+ DECLARE_NO_COPY_CLASS(wxTCPServer)
};
class wxTCPClient: public wxClientBase
wxSocketBase *m_o_socket;
size_t OnSysWrite(const void *buffer, size_t bufsize);
+
+ DECLARE_NO_COPY_CLASS(wxSocketOutputStream)
};
class WXDLLEXPORT wxSocketInputStream : public wxInputStream
wxSocketBase *m_i_socket;
size_t OnSysRead(void *buffer, size_t bufsize);
+
+ DECLARE_NO_COPY_CLASS(wxSocketInputStream)
};
class WXDLLEXPORT wxSocketStream : public wxSocketInputStream,
#endif // wxUSE_MOUSEWHEEL
wxScrollHelperEvtHandler *m_handler;
+
+ DECLARE_NO_COPY_CLASS(wxScrollHelper)
};
// ----------------------------------------------------------------------------
private:
DECLARE_CLASS(wxSizerItem);
+ DECLARE_NO_COPY_CLASS(wxSizerItem)
};
//---------------------------------------------------------------------------
private:
DECLARE_CLASS(wxFlexGridSizer);
+ DECLARE_NO_COPY_CLASS(wxFlexGridSizer)
};
//---------------------------------------------------------------------------
private:
DECLARE_CLASS(wxStaticBoxSizer);
+ DECLARE_NO_COPY_CLASS(wxStaticBoxSizer)
};
#endif // wxUSE_STATBOX
private:
DECLARE_CLASS(wxNotebookSizer);
+ DECLARE_NO_COPY_CLASS(wxNotebookSizer)
};
#endif // wxUSE_NOTEBOOK
// the implementation details (platform specific)
class WXDLLEXPORT wxSingleInstanceCheckerImpl *m_impl;
+
+ DECLARE_NO_COPY_CLASS(wxSingleInstanceChecker)
};
#endif // wxUSE_SNGLINST_CHECKER
wxSockCbk m_cbk; // callback
char *m_cdata; // callback data
#endif // WXWIN_COMPATIBILITY
+
+ DECLARE_NO_COPY_CLASS(wxSocketBase)
};
// stacks of previous values for PushStatusText/PopStatusText
// this is created on demand, use GetStatusStack/GetOrCreateStatusStack
wxListString **m_statusTextStacks;
+
+ DECLARE_NO_COPY_CLASS(wxStatusBarBase)
};
// ----------------------------------------------------------------------------
wxStreamError m_lasterror;
friend class wxStreamBuffer;
+
+ DECLARE_NO_COPY_CLASS(wxInputStream)
};
// ----------------------------------------------------------------------------
protected:
wxInputStream *m_parent_i_stream;
+
+ DECLARE_NO_COPY_CLASS(wxFilterInputStream)
};
class WXDLLEXPORT wxFilterOutputStream : public wxOutputStream
protected:
wxOutputStream *m_parent_o_stream;
+
+ DECLARE_NO_COPY_CLASS(wxFilterOutputStream)
};
// ============================================================================
bool m_destroybuf, // deallocate buffer?
m_fixed,
m_flushable;
+
+private:
+// Cannot use
+// DECLARE_NO_COPY_CLASS(wxStreamBuffer)
+// 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:
+ wxStreamBuffer& operator=(const wxStreamBuffer&);
};
// ---------------------------------------------------------------------------
virtual off_t OnSysTell() const;
wxStreamBuffer *m_i_streambuf;
+
+ DECLARE_NO_COPY_CLASS(wxBufferedInputStream)
};
// ----------------------------------------------------------------------------
virtual off_t OnSysTell() const;
wxStreamBuffer *m_o_streambuf;
+
+ DECLARE_NO_COPY_CLASS(wxBufferedOutputStream)
};
#endif // wxUSE_STREAMS
// short and long help strings
wxString m_shortHelpString;
wxString m_longHelpString;
+
+ DECLARE_NO_COPY_CLASS(wxToolBarToolBase)
};
// a list of toolbar tools
int m_milli; // the timer interval
bool m_oneShot; // TRUE if one shot
+
+ DECLARE_NO_COPY_CLASS(wxTimerBase)
};
// ----------------------------------------------------------------------------
DECLARE_EVENT_TABLE()
friend class wxTipWindowView;
+
+ DECLARE_NO_COPY_CLASS(wxTipWindow)
};
#endif // wxUSE_TIPWINDOW
int* m_pInt;
wxString* m_pString;
wxArrayInt* m_pArrayInt;
+
+private:
+// Cannot use
+// DECLARE_NO_COPY_CLASS(wxGenericValidator)
+// 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:
+ wxGenericValidator& operator=(const wxGenericValidator&);
};
#endif
return TRUE;
}
+
+private:
+// Cannot use
+// DECLARE_NO_COPY_CLASS(wxTextValidator)
+// 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:
+ wxTextValidator& operator=(const wxTextValidator&);
};
#endif
protected:
wxFile *m_file;
bool m_file_destroy;
+
+ DECLARE_NO_COPY_CLASS(wxFileInputStream)
};
class WXDLLEXPORT wxFileOutputStream: public wxOutputStream {
protected:
wxFile *m_file;
bool m_file_destroy;
+
+ DECLARE_NO_COPY_CLASS(wxFileOutputStream)
};
class WXDLLEXPORT wxFileStream: public wxFileInputStream, public wxFileOutputStream {
protected:
wxFFile *m_file;
bool m_file_destroy;
+
+ DECLARE_NO_COPY_CLASS(wxFFileInputStream)
};
class WXDLLEXPORT wxFFileOutputStream: public wxOutputStream {
protected:
wxFFile *m_file;
bool m_file_destroy;
+
+ DECLARE_NO_COPY_CLASS(wxFFileOutputStream)
};
class WXDLLEXPORT wxFFileStream: public wxFFileInputStream, public wxFFileOutputStream {
*m_next;
DECLARE_DYNAMIC_CLASS(wxWizardPageSimple)
+ DECLARE_NO_COPY_CLASS(wxWizardPageSimple)
};
// ----------------------------------------------------------------------------
wxWizardPage* m_page;
DECLARE_DYNAMIC_CLASS(wxWizardEvent)
+ DECLARE_NO_COPY_CLASS(wxWizardEvent)
};
// ----------------------------------------------------------------------------
// so we can index into the wxExpr database and fish out the pointer.
inline void SetClientData(wxObject *data) { client_data = data; }
inline wxObject *GetClientData(void) const { return client_data; }
+
+ DECLARE_NO_COPY_CLASS(wxExpr)
};
class WXDLLEXPORT wxExprDatabase: public wxList
private:
DECLARE_DYNAMIC_CLASS(wxExprDatabase)
+ DECLARE_NO_COPY_CLASS(wxExprDatabase)
};
// Function call-style interface - some more convenience wrappers/unwrappers
// this void* is handle of archive . I'm sorry it is void and not proper
// type but I don't want to make unzip.h header public.
void *m_Archive;
+
+ DECLARE_NO_COPY_CLASS(wxZipInputStream)
};
size_t m_z_size;
unsigned char *m_z_buffer;
struct z_stream_s *m_inflate;
+
+ DECLARE_NO_COPY_CLASS(wxZlibInputStream)
};
class WXDLLEXPORT wxZlibOutputStream: public wxFilterOutputStream {
size_t m_z_size;
unsigned char *m_z_buffer;
struct z_stream_s *m_deflate;
+
+ DECLARE_NO_COPY_CLASS(wxZlibOutputStream)
};
#endif
//// Data
wxContextHelp* m_contextHelp;
+
+ DECLARE_NO_COPY_CLASS(wxContextHelpEvtHandler)
};
// ============================================================================
// the size of the buffer
size_t m_size;
+
+ DECLARE_NO_COPY_CLASS(wxStreamTempInputBuffer)
};
inline wxStreamTempInputBuffer::wxStreamTempInputBuffer()
wxString m_strLine; // line contents
wxFileConfigLineList *m_pNext, // next node
*m_pPrev; // previous one
+
+ DECLARE_NO_COPY_CLASS(wxFileConfigLineList)
};
// ----------------------------------------------------------------------------
void SetValue(const wxString& strValue, bool bUser = TRUE);
void SetDirty();
void SetLine(wxFileConfigLineList *pLine);
+
+ DECLARE_NO_COPY_CLASS(wxFileConfigEntry)
};
// ----------------------------------------------------------------------------
// called by entries/subgroups when they're created/deleted
void SetLastEntry(wxFileConfigEntry *pEntry) { m_pLastEntry = pEntry; }
void SetLastGroup(wxFileConfigGroup *pGroup) { m_pLastGroup = pGroup; }
+
+ DECLARE_NO_COPY_CLASS(wxFileConfigGroup)
};
// ============================================================================
wxFontMapper *m_fontMapper;
bool m_ok;
wxString m_pathOld;
+
+ DECLARE_NO_COPY_CLASS(wxFontMapperPathChanger)
};
// ============================================================================
char *m_Data;
size_t m_Len;
wxDateTime m_Time;
+
+ DECLARE_NO_COPY_CLASS(MemFSHashObj)
};
wxFTP *m_ftp;
size_t m_ftpsize;
+
+ DECLARE_NO_COPY_CLASS(wxInputFTPStream)
};
class wxOutputFTPStream : public wxSocketOutputStream
}
wxFTP *m_ftp;
+
+ DECLARE_NO_COPY_CLASS(wxOutputFTPStream)
};
wxSocketClient *wxFTP::GetPort()
protected:
size_t OnSysRead(void *buffer, size_t bufsize);
+
+ DECLARE_NO_COPY_CLASS(wxHTTPStream)
};
size_t wxHTTPStream::OnSysRead(void *buffer, size_t bufsize)
#endif // wxUSE_PALETTE
wxArrayString m_optionNames;
wxArrayString m_optionValues;
+
+ DECLARE_NO_COPY_CLASS(wxImageRefData)
};
wxImageRefData::wxImageRefData()
inline size_t32 Swap(size_t32 ui) const;
bool m_bSwapped; // wrong endianness?
+
+ DECLARE_NO_COPY_CLASS(wxMsgCatalogFile)
};
wxPopupTransientWindow *m_popup;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxPopupWindowHandler)
};
class wxPopupFocusHandler : public wxEvtHandler
#endif // __WXGTK__
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxPopupFocusHandler)
};
// ----------------------------------------------------------------------------
public:
wxSocketState() : wxObject() {}
+
+ DECLARE_NO_COPY_CLASS(wxSocketState)
};
// ==========================================================================
protected:
void* m_value;
+
+ DECLARE_NO_COPY_CLASS(wxVariantDataVoidPtr)
};
IMPLEMENT_DYNAMIC_CLASS(wxVariantDataVoidPtr, wxVariantData)
wxCalendarCtrl *m_cal;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxMonthComboBox)
};
class wxYearSpinCtrl : public wxSpinCtrl
wxCalendarCtrl *m_cal;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxYearSpinCtrl)
};
// ----------------------------------------------------------------------------
wxGridCellCoords coords;
wxGridCellAttr *attr;
+
+// Cannot do this:
+// DECLARE_NO_COPY_CLASS(wxGridCellWithAttr)
+// without rewriting the macros, which require a public copy constructor.
};
WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr, wxGridCellWithAttrArray);
DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow)
};
DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxGridColLabelWindow)
};
DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow)
};
class WXDLLEXPORT wxGridWindow : public wxWindow
DECLARE_DYNAMIC_CLASS(wxGridWindow)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxGridWindow)
};
wxGridCellEditor* m_editor;
DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
};
wxString m_typeName;
wxGridCellRenderer* m_renderer;
wxGridCellEditor* m_editor;
+
+ DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo)
};
static wxString ms_details;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxLogDialog)
};
BEGIN_EVENT_TABLE(wxLogDialog, wxDialog)
wxLogWindow *m_log;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxLogFrame)
};
BEGIN_EVENT_TABLE(wxLogFrame, wxFrame)
private:
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxNumberEntryDialog)
};
// ============================================================================
wxScrollHelper *m_scrollHelper;
bool m_hasDrawnWindow;
+
+ DECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler)
};
// ----------------------------------------------------------------------------
wxEventType m_eventType;
int m_pos,
m_orient;
+
+ DECLARE_NO_COPY_CLASS(wxAutoScrollTimer)
};
// ============================================================================
wxCheckBox *m_checkbox;
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxTipDialog)
};
// ============================================================================
#endif // !wxUSE_POPUPWIN
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxTipWindowView)
};
// ============================================================================
private:
wxGenericTreeCtrl *m_owner;
+
+ DECLARE_NO_COPY_CLASS(wxTreeRenameTimer)
};
// control used for in-place edit
bool m_finished;
DECLARE_EVENT_TABLE()
+ DECLARE_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)
};
// a tree item
// children but has a [+] button
int m_isBold :1; // render the label in bold font
int m_ownsAttr :1; // delete attribute when done
+
+ DECLARE_NO_COPY_CLASS(wxGenericTreeItem)
};
// =============================================================================
bool HandleTag(const wxHtmlTag& tag);
void WriteOut(wxHtmlContentsItem*& array, int& size);
void ReadIn(wxHtmlContentsItem* array, int size);
+
+ DECLARE_NO_COPY_CLASS(HP_TagHandler)
};
private:
wxHtmlHelpFrame *m_Frame;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlHelpHtmlWindow)
};
}
DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(wxHtmlHelpFrameOptionsDialog)
};
BEGIN_EVENT_TABLE(wxHtmlHelpFrameOptionsDialog, wxDialog)
double m_scale;
wxHtmlImageMapCell *m_imageMap;
wxString m_mapName;
+
+ DECLARE_NO_COPY_CLASS(wxHtmlImageCell)
};
#if wxUSE_GIF && wxUSE_TIMER
private:
wxHtmlImageCell *m_cell;
+
+ DECLARE_NO_COPY_CLASS(wxGIFTimer)
};
#endif
// Computes minimal and maximal widths of columns. Needs to be called
// only once, before first Layout().
void ComputeMinMaxWidths();
+
+ DECLARE_NO_COPY_CLASS(wxHtmlTableCell)
};
protected:
HACCEL m_hAccel;
bool m_ok;
+
+ DECLARE_NO_COPY_CLASS(wxAcceleratorRefData)
};
#define M_ACCELDATA ((wxAcceleratorRefData *)m_refData)
void SendEvent();
private:
+
+ DECLARE_NO_COPY_CLASS(wxCheckListBoxItem)
bool m_bChecked;
wxCheckListBox *m_pParent;
size_t m_nIndex;
wxString m_filespec;
int m_flags;
+
+ DECLARE_NO_COPY_CLASS(wxDirData)
};
// ============================================================================
// registered Message for Dialog
static UINT ms_msgFindDialog;
+
+ DECLARE_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)
};
// ----------------------------------------------------------------------------
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
LV_ITEM *m_item;
+
+ DECLARE_NO_COPY_CLASS(wxLV_ITEM)
};
///////////////////////////////////////////////////////
if (attr)
delete attr;
};
+
+ DECLARE_NO_COPY_CLASS(wxListItemInternalData)
};
// Get the internal data structure
bool bSelect,
int imageId)
{
- wxASSERT( pPage != NULL );
- wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE );
+ wxCHECK_MSG( pPage != NULL, FALSE, _T("NULL page in wxNotebook::InsertPage") );
+ wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE,
+ _T("invalid index in wxNotebook::InsertPage") );
- // do add the tab to the control
- // init all fields to 0
- TC_ITEM tcItem;
- memset(&tcItem, 0, sizeof(tcItem));
+ // add a new tab to the control
+ // ----------------------------
- if ( imageId != -1 )
- {
- tcItem.mask |= TCIF_IMAGE;
- tcItem.iImage = imageId;
- }
+ // init all fields to 0
+ TC_ITEM tcItem;
+ wxZeroMemory(tcItem);
- if ( !strText.IsEmpty() )
- {
- tcItem.mask |= TCIF_TEXT;
- tcItem.pszText = (wxChar *)strText.c_str(); // const_cast
- }
+ // set the image, if any
+ if ( imageId != -1 )
+ {
+ tcItem.mask |= TCIF_IMAGE;
+ tcItem.iImage = imageId;
+ }
- if ( TabCtrl_InsertItem(m_hwnd, nPage, &tcItem) == -1 ) {
- wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
+ // and the text
+ if ( !strText.IsEmpty() )
+ {
+ tcItem.mask |= TCIF_TEXT;
+ tcItem.pszText = (wxChar *)strText.c_str(); // const_cast
+ }
- return FALSE;
- }
+ // fit the notebook page to the tab control's display area: this should be
+ // done before adding it to the notebook or TabCtrl_InsertItem() will
+ // change the notebooks size itself!
+ RECT rc;
+ rc.left = rc.top = 0;
+ GetSize((int *)&rc.right, (int *)&rc.bottom);
+ TabCtrl_AdjustRect(m_hwnd, FALSE, &rc);
+ pPage->SetSize(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
- // if the inserted page is before the selected one, we must update the
- // index of the selected page
- if ( nPage <= m_nSelection )
- {
- // one extra page added
- m_nSelection++;
- }
- // save the pointer to the page
- m_pages.Insert(pPage, nPage);
+ // finally do insert it
+ if ( TabCtrl_InsertItem(m_hwnd, nPage, &tcItem) == -1 ) {
+ wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
+
+ return FALSE;
+ }
- // don't show pages by default (we'll need to adjust their size first)
- HWND hwnd = GetWinHwnd(pPage);
- SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
+ // succeeded: save the pointer to the page
+ m_pages.Insert(pPage, nPage);
- // this updates internal flag too - otherwise it will get out of sync
- pPage->Show(FALSE);
+ // hide the page: unless it is selected, it shouldn't be shown (and if it
+ // is selected it will be shown later)
+ HWND hwnd = GetWinHwnd(pPage);
+ SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
- // fit the notebook page to the tab control's display area
- RECT rc;
- rc.left = rc.top = 0;
- GetSize((int *)&rc.right, (int *)&rc.bottom);
- TabCtrl_AdjustRect(m_hwnd, FALSE, &rc);
- pPage->SetSize(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
+ // this updates internal flag too -- otherwise it would get out of sync
+ // with the real state
+ pPage->Show(FALSE);
- // some page should be selected: either this one or the first one if there is
- // still no selection
- int selNew = -1;
- if ( bSelect )
- selNew = nPage;
- else if ( m_nSelection == -1 )
- selNew = 0;
- if ( selNew != -1 )
- SetSelection(selNew);
+ // now deal with the selection
+ // ---------------------------
- return TRUE;
+ // if the inserted page is before the selected one, we must update the
+ // index of the selected page
+ if ( nPage <= m_nSelection )
+ {
+ // one extra page added
+ m_nSelection++;
+ }
+
+ // some page should be selected: either this one or the first one if there
+ // is still no selection
+ int selNew = -1;
+ if ( bSelect )
+ selNew = nPage;
+ else if ( m_nSelection == -1 )
+ selNew = 0;
+
+ if ( selNew != -1 )
+ SetSelection(selNew);
+
+ return TRUE;
}
// ----------------------------------------------------------------------------
CLIPFORMAT *m_formats; // formats we can provide data in
ULONG m_nCount, // number of formats we support
m_nCurrent; // current enum position
+
+ DECLARE_NO_COPY_CLASS(wxIEnumFORMATETC)
};
// ----------------------------------------------------------------------------
wxDataObject *m_pDataObject; // pointer to C++ class we belong to
bool m_mustDelete;
+
+ DECLARE_NO_COPY_CLASS(wxIDataObject)
};
// ============================================================================
private:
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)
};
// ============================================================================
// get default drop effect for given keyboard flags
static inline DWORD GetDropEffect(DWORD flags);
+
+ DECLARE_NO_COPY_CLASS(wxIDropTarget)
};
// ----------------------------------------------------------------------------
}
HRGN m_region;
+
+private:
+// Cannot use
+// DECLARE_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:
+ wxRegionRefData& operator=(const wxRegionRefData&);
};
#define M_REGION (((wxRegionRefData*)m_refData)->m_region)
// the mutex handle, may be NULL
HANDLE m_hMutex;
+
+ DECLARE_NO_COPY_CLASS(wxSingleInstanceCheckerImpl)
};
// ============================================================================
wxMutexError LockTimeout(DWORD milliseconds);
HANDLE m_mutex;
+
+ DECLARE_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)
};
wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
wxThreadState m_state; // state, see wxThreadState enum
unsigned int m_priority; // thread priority in "wx" units
DWORD m_tid; // thread id
+
+ DECLARE_NO_COPY_CLASS(wxThreadInternal)
};
THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param)
private:
wxTreeItemData *m_data;
+
+ DECLARE_NO_COPY_CLASS(wxVirtualNode)
};
#ifdef __VISUALC__
bool Traverse(const wxTreeItemId& root, bool recursively);
const wxTreeCtrl *m_tree;
+
+ DECLARE_NO_COPY_CLASS(wxTreeTraversal)
};
// internal class for getting the selected items
// the real client data
wxTreeItemData *m_data;
+
+ DECLARE_NO_COPY_CLASS(wxTreeItemIndirectData)
};
// ----------------------------------------------------------------------------
// the PID we're looking from
DWORD pid;
+
+ DECLARE_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)
};
class wxPipeOutputStream: public wxOutputStream
protected:
HANDLE m_hOutput;
+
+ DECLARE_NO_COPY_CLASS(wxPipeOutputStream)
};
// define this to let wxexec.cpp know that we know what we're doing
projects / wxWidgets.git / commitdiff
