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

1. fixes to wxDC deleting logic (should fix ~wxPrinterDC leak), some code

Browse Source 
reorganized/removed
2. applied (slightly modified) wxEnhMetaFileSimpleDataObject patch


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@9687 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2001-04-09 01:22:48 +00:00
parent 4658c44ec2
commit 7ba4fbebbc
21 changed files with 436 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
include/wx/debug.h
View File

@@ -17,94 +17,101 @@
#include "wx/wxchar.h"
// ----------------------------------------------------------------------------
/**
@name Debugging macros
All debugging macros rely on ASSERT() which in turn calls user-defined
OnAssert() function. To keep things simple, it's called even when the
expression is TRUE (i.e. everything is ok) and by default does nothing: just
returns the same value back. But if you redefine it to do something more sexy
(popping up a message box in your favourite GUI, sending you e-mail or
whatever) it will affect all ASSERTs, FAILs and CHECKs in your code.
<BR>
<BR>
<b>Warning</b>: if you don't like advices on programming style, don't read
further! ;-)
<BR>
<BR>
Extensive use of these macros is recommended! Remember that ASSERTs are
disabled in final (without __WXDEBUG__ defined) build, so they add strictly
nothing to your program's code. On the other hand, CHECK macros do stay
even in release builds, but in general are not much of a burden, while
a judicious use of them might increase your program's stability.
@memo Debugging macros (replacement for standard assert()) and more.
*/
// Debugging macros
//
// All debugging macros rely on ASSERT() which in turn calls user-defined
// OnAssert() function. To keep things simple, it's called even when the
// expression is TRUE (i.e. everything is ok) and by default does nothing: just
// returns the same value back. But if you redefine it to do something more sexy
// (popping up a message box in your favourite GUI, sending you e-mail or
// whatever) it will affect all ASSERTs, FAILs and CHECKs in your code.
//
// Warning: if you don't like advices on programming style, don't read
// further! ;-)
//
// Extensive use of these macros is recommended! Remember that ASSERTs are
// disabled in final (without __WXDEBUG__ defined) build, so they add strictly
// nothing to your program's code. On the other hand, CHECK macros do stay
// even in release builds, but in general are not much of a burden, while
// a judicious use of them might increase your program's stability.
// ----------------------------------------------------------------------------
//@{
// Use of these suppresses compiler warnings about testing constant expression
WXDLLEXPORT_DATA(extern const bool) wxTrue;
WXDLLEXPORT_DATA(extern const bool) wxFalse;
/** @name Macros which are completely disabled in 'release' mode */
//@{
// Macros which are completely disabled in 'release' mode
#ifdef __WXDEBUG__
/**
this function may be redefined to do something non trivial and is called
whenever one of debugging macros fails (i.e. condition is false in an
assertion)
@param szFile and nLine - file name and line number of the ASSERT
szMsg - optional message explaining the reason
/*
this function may be redefined to do something non trivial and is called
whenever one of debugging macros fails (i.e. condition is false in an
assertion)
parameters:
szFile and nLine - file name and line number of the ASSERT
szMsg - optional message explaining the reason
*/
void WXDLLEXPORT wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg = (const wxChar *) NULL);
/// generic assert macro
#define wxASSERT(cond) if ( !(cond) ) wxOnAssert(__TFILE__, __LINE__)
/*
notice the usage of else at the end of wxASSERT macro: this ensures that
the following code
/// assert with additional message explaining it's cause
#define wxASSERT_MSG(x, m) if ( !(x) ) wxOnAssert(__TFILE__, __LINE__, m)
if ( ... )
wxASSERT(...);
else
...
works like expected: if there were no "else", the one in the code above
would be matched with a wrong "if"
*/
// generic assert macro
#define wxASSERT(cond) if ( !(cond) ) wxOnAssert(__TFILE__, __LINE__); else
// assert with additional message explaining it's cause
#define wxASSERT_MSG(cond, msg) \
if ( !(cond) ) wxOnAssert(__TFILE__, __LINE__, msg); else
#else
// nothing to do in release modes (hopefully at this moment there are
// no more bugs ;-)
#define wxASSERT(cond)
#define wxASSERT_MSG(x, m)
#define wxASSERT(cond)
#define wxASSERT_MSG(x, m)
#endif //__WXDEBUG__
/// special form of assert: always triggers it (in debug mode)
#define wxFAIL wxASSERT(wxFalse)
// special form of assert: always triggers it (in debug mode)
#define wxFAIL wxASSERT(wxFalse)
/// FAIL with some message
#define wxFAIL_MSG(msg) wxASSERT_MSG(wxFalse, msg)
//@}
// FAIL with some message
#define wxFAIL_MSG(msg) wxASSERT_MSG(wxFalse, msg)
// NB: these macros work also in release mode!
// NB: the following macros work also in release mode!
/**
/*
These macros must be used only in invalid situation: for example, an
invalid parameter (NULL pointer) is passed to a function. Instead of
dereferencing it and causing core dump the function might try using
CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
@name Macros which remain even in 'release' mode
*/
//@{
/// check that expression is true, "return" if not (also FAILs in debug mode)
#define wxCHECK(x, rc) if (!(x)) {wxFAIL; return rc; }
/// as wxCHECK but with a message explaining why we fail
#define wxCHECK_MSG(x, rc, msg) if (!(x)) {wxFAIL_MSG(msg); return rc; }
/// check that expression is true, perform op if not
#define wxCHECK2(x, op) if (!(x)) {wxFAIL; op; }
/// as wxCHECK2 but with a message explaining why we fail
#define wxCHECK2_MSG(x, op, msg) if (!(x)) {wxFAIL_MSG(msg); op; }
/// special form of wxCHECK2: as wxCHECK, but for use in void functions
// NB: there is only one form (with msg parameter) and it's intentional:
// there is no other way to tell the caller what exactly went wrong
// from the void function (of course, the function shouldn't be void
// to begin with...)
#define wxCHECK_RET(x, msg) if (!(x)) {wxFAIL_MSG(msg); return; }
//@}
//@}
// check that expression is true, "return" if not (also FAILs in debug mode)
#define wxCHECK(x, rc) if (!(x)) {wxFAIL; return rc; }
// as wxCHECK but with a message explaining why we fail
#define wxCHECK_MSG(x, rc, msg) if (!(x)) {wxFAIL_MSG(msg); return rc; }
// check that expression is true, perform op if not
#define wxCHECK2(x, op) if (!(x)) {wxFAIL; op; }
// as wxCHECK2 but with a message explaining why we fail
#define wxCHECK2_MSG(x, op, msg) if (!(x)) {wxFAIL_MSG(msg); op; }
// special form of wxCHECK2: as wxCHECK, but for use in void functions
// NB: there is only one form (with msg parameter) and it's intentional:
// there is no other way to tell the caller what exactly went wrong
// from the void function (of course, the function shouldn't be void
// to begin with...)
#define wxCHECK_RET(x, msg) if (!(x)) {wxFAIL_MSG(msg); return; }
#endif // _WX_DEBUG_H_

14
include/wx/defs.h
View File

@@ -53,21 +53,23 @@
#endif
#if defined(__APPLE__)
// MacOS X
// MacOS X
#ifndef __WXMAC__
#define __WXMAC__
#endif
#ifndef __WXMAC_X__
#define __WXMAC_X__
#endif
#define PM_USE_SESSION_APIS 0
#include <Carbon/Carbon.h>
#endif
#elif defined(applec) || defined(THINK_C) || (defined(__MWERKS__) && !defined(__INTEL__))
// MacOS
#elif defined(applec) || \
defined(THINK_C) || \
(defined(__MWERKS__) && !defined(__INTEL__))
// MacOS
#elif defined(__WXMAC__) && defined(__APPLE__)
// MacOS X
// MacOS X
#define __UNIX_LIKE__
#ifndef __WXMAC__
@@ -76,7 +78,7 @@
#ifndef __WXMAC_X__
#define __WXMAC_X__
#endif
#define PM_USE_SESSION_APIS 0
#include <Carbon/Carbon.h>
#elif defined(__OS2__)

1
include/wx/msw/dc.h
View File

@@ -216,7 +216,6 @@ protected:
// our HDC and its usage count: we only free it when the usage count drops
// to 0
WXHDC m_hDC;
int m_hDCCount;
// Store all old GDI objects when do a SelectObject, so we can select them
// back in (this unselecting user's objects) so we can safely delete the

21
include/wx/msw/dcclient.h
View File

@@ -38,34 +38,36 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxPaintDCInfo, wxArrayDCInfo);
class WXDLLEXPORT wxWindowDC : public wxDC
{
DECLARE_DYNAMIC_CLASS(wxWindowDC)
public:
// default ctor
wxWindowDC();
// Create a DC corresponding to the whole window
wxWindowDC(wxWindow *win);
virtual ~wxWindowDC();
protected:
// intiialize the newly created DC
void InitDC();
private:
DECLARE_DYNAMIC_CLASS(wxWindowDC)
};
class WXDLLEXPORT wxClientDC : public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxClientDC)
public:
// default ctor
wxClientDC();
// Create a DC corresponding to the client area of the window
wxClientDC(wxWindow *win);
virtual ~wxClientDC();
private:
DECLARE_DYNAMIC_CLASS(wxClientDC)
};
class WXDLLEXPORT wxPaintDC : public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxPaintDC)
public:
wxPaintDC();
@@ -82,6 +84,9 @@ protected:
// find the entry for this DC in the cache (keyed by the window)
wxPaintDCInfo *FindInCache(size_t *index = NULL) const;
private:
DECLARE_DYNAMIC_CLASS(wxPaintDC)
};
#endif

16
include/wx/msw/dcmemory.h
View File

@@ -1,12 +1,12 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcmemory.h
// Name: wx/msw/dcmemory.h
// Purpose: wxMemoryDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCMEMORY_H_
@@ -24,13 +24,19 @@ public:
wxMemoryDC();
wxMemoryDC(wxDC *dc); // Create compatible DC
~wxMemoryDC();
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void SelectObject(const wxBitmap& bitmap);
protected:
// override some base class virtuals
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void DoGetSize(int* width, int* height) const;
// create DC compatible with the given one or screen if dc == NULL
bool CreateCompatible(wxDC *dc);
// initialize the newly created DC
void Init();
private:
DECLARE_DYNAMIC_CLASS(wxMemoryDC)
};

12
include/wx/msw/dcprint.h
View File

@@ -21,11 +21,9 @@
#include "wx/dc.h"
#include "wx/cmndata.h"
class WXDLLEXPORT wxPrinterDC: public wxDC
class WXDLLEXPORT wxPrinterDC : public wxDC
{
public:
DECLARE_CLASS(wxPrinterDC)
// Create a printer DC (obsolete function: use wxPrintData version now)
wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output, bool interactive = TRUE, int orientation = wxPORTRAIT);
@@ -34,8 +32,6 @@ DECLARE_CLASS(wxPrinterDC)
wxPrinterDC(WXHDC theDC);
~wxPrinterDC(void);
// override some base class virtuals
virtual bool StartDoc(const wxString& message);
virtual void EndDoc();
@@ -50,7 +46,13 @@ protected:
wxDC *source, wxCoord xsrc, wxCoord ysrc,
int rop = wxCOPY, bool useMask = FALSE);
// init the dc
void Init();
wxPrintData m_printData;
private:
DECLARE_CLASS(wxPrinterDC)
};
// Gets an HDC for the default printer configuration

25
include/wx/msw/dcscreen.h
View File

@@ -1,12 +1,12 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcscreen.h
// Name: wx/msw/dcscreen.h
// Purpose: wxScreenDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCSCREEN_H_
@@ -18,20 +18,19 @@
#include "wx/dcclient.h"
class WXDLLEXPORT wxScreenDC: public wxWindowDC
class WXDLLEXPORT wxScreenDC : public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxScreenDC)
public:
// Create a DC representing the whole screen
wxScreenDC();
public:
// Create a DC representing the whole screen
wxScreenDC(void);
~wxScreenDC(void);
// Compatibility with X's requirements for drawing on top of all windows
static bool StartDrawingOnTop(wxWindow* WXUNUSED(window)) { return TRUE; }
static bool StartDrawingOnTop(wxRect* WXUNUSED(rect) = NULL) { return TRUE; }
static bool EndDrawingOnTop(void) { return TRUE; }
// Compatibility with X's requirements for
// drawing on top of all windows
static bool StartDrawingOnTop(wxWindow* WXUNUSED(window)) { return TRUE; }
static bool StartDrawingOnTop(wxRect* WXUNUSED(rect) = NULL) { return TRUE; }
static bool EndDrawingOnTop(void) { return TRUE; }
private:
DECLARE_DYNAMIC_CLASS(wxScreenDC)
};
#endif

36
include/wx/msw/enhmeta.h
View File

@@ -94,12 +94,12 @@ private:
DECLARE_DYNAMIC_CLASS(wxEnhMetaFileDC)
};
#if wxUSE_DRAG_AND_DROP
// ----------------------------------------------------------------------------
// wxEnhMetaFileDataObject is a specialization of wxDataObject for enh metafile
// ----------------------------------------------------------------------------
#if wxUSE_DRAG_AND_DROP
// notice that we want to support both CF_METAFILEPICT and CF_ENHMETAFILE and
// so we derive from wxDataObject and not from wxDataObjectSimple
class WXDLLEXPORT wxEnhMetaFileDataObject : public wxDataObject
@@ -130,6 +130,38 @@ protected:
wxEnhMetaFile m_metafile;
};
// ----------------------------------------------------------------------------
// wxEnhMetaFileSimpleDataObject does derive from wxDataObjectSimple which
// makes it more convenient to use (it can be used with wxDataObjectComposite)
// at the price of not supoprting any more CF_METAFILEPICT but only
// CF_ENHMETAFILE
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxEnhMetaFileSimpleDataObject : public wxDataObjectSimple
{
public:
// ctors
wxEnhMetaFileSimpleDataObject() : wxDataObjectSimple(wxDF_ENHMETAFILE) { }
wxEnhMetaFileSimpleDataObject(const wxEnhMetaFile& metafile)
: wxDataObjectSimple(wxDF_ENHMETAFILE), m_metafile(metafile) { }
// virtual functions which you may override if you want to provide data on
// demand only - otherwise, the trivial default versions will be used
virtual void SetEnhMetafile(const wxEnhMetaFile& metafile)
{ m_metafile = metafile; }
virtual wxEnhMetaFile GetEnhMetafile() const
{ return m_metafile; }
// implement base class pure virtuals
virtual size_t GetDataSize() const;
virtual bool GetDataHere(void *buf) const;
virtual bool SetData(size_t len, const void *buf);
protected:
wxEnhMetaFile m_metafile;
};
#endif // wxUSE_DRAG_AND_DROP
#endif // _WX_MSW_ENHMETA_H_