mirror of
https://github.com/MultiMC/MultiMC5.git
synced 2024-12-27 21:15:19 +00:00
3945 lines
121 KiB
C++
3945 lines
121 KiB
C++
// Win32++ Version 7.2
|
|
// Released: 5th AUgust 2011
|
|
//
|
|
// David Nash
|
|
// email: dnash@bigpond.net.au
|
|
// url: https://sourceforge.net/projects/win32-framework
|
|
//
|
|
//
|
|
// Copyright (c) 2005-2011 David Nash
|
|
//
|
|
// Permission is hereby granted, free of charge, to
|
|
// any person obtaining a copy of this software and
|
|
// associated documentation files (the "Software"),
|
|
// to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify,
|
|
// merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom
|
|
// the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice
|
|
// shall be included in all copies or substantial portions
|
|
// of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
|
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
|
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
|
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
|
// OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
////////////////////////////////////////////////////////
|
|
|
|
|
|
////////////////////////////////////////////////////////
|
|
// gdi.h
|
|
// Declaration of the CDC class, and CBitmapInfoPtr class
|
|
|
|
// The CDC class provides a device context, along with the various associated
|
|
// objects such as Bitmaps, Brushes, Bitmaps, Fonts and Pens. This class
|
|
// handles the creation, selection, de-selection and deletion of these objects
|
|
// automatically. It also automatically deletes or releases the device context
|
|
// itself as appropriate. Any failure to create the new GDI object throws an
|
|
// exception.
|
|
//
|
|
// The CDC class is sufficient for most GDI programming needs. Sometimes
|
|
// however we need to have the GDI object seperated from the device context.
|
|
// Wrapper classes for GDI objects are provided for this purpose. The classes
|
|
// are CBitmap, CBrush, CFont, CPalette, CPen and CRgn. These classes
|
|
// automatically delete the GDI resouce assigned to them when their destructor
|
|
// is called. These wrapper class objects can be attached to the CDC as
|
|
// shown below.
|
|
//
|
|
// Coding Exampe without CDC ...
|
|
// void DrawLine()
|
|
// {
|
|
// HDC hdcClient = ::GetDC(m_hWnd);
|
|
// HDC hdcMem = ::CreateCompatibleDC(hdcClient);
|
|
// HBITMAP hBitmap = ::CreateCompatibleBitmap(hdcClient, cx, cy);
|
|
// HBITMAP hOldBitmap = (HBITMAP)::SelectObject(hdcMem, hBitmap);
|
|
// HPEN hPen = ::CreatePen(PS_SOLID, 1, RGB(255,0,0);
|
|
// HPEN hOldPen = (HPEN)::SelectObject(hdcMem, hPen);
|
|
// ::MoveToEx(hdcMem, 0, 0, NULL);
|
|
// ::LineTo(hdcMem, 50, 50);
|
|
// ::BitBlt(hdcClient, 0, 0, cx, cy, hdcMem, 0, 0);
|
|
// ::SelectObject(hdcMem, hOldPen);
|
|
// ::DeleteObject(hPen);
|
|
// ::SelectObject(hdcMem, hOldBitmap);
|
|
// ::DeleteObject(hBitmap);
|
|
// ::DeleteDC(hdcMem);
|
|
// ::ReleaseDC(m_hWnd, hdcClient);
|
|
// }
|
|
//
|
|
// Coding Example with CDC classes ...
|
|
// void DrawLine()
|
|
// {
|
|
// CClientDC dcClient(this)
|
|
// CMemDC dcMem(&dcClient);
|
|
// CBitmap* pOldBitmap = dcMem.CreateCompatibleBitmap(&dcClient, cx, cy);
|
|
// CPen* pOldPen = CMemDC.CreatePen(PS_SOLID, 1, RGB(255,0,0);
|
|
// CMemDC.MoveTo(0, 0);
|
|
// CMemDC.LineTo(50, 50);
|
|
// dcClient.BitBlt(0, 0, cx, cy, &CMemDC, 0, 0);
|
|
// }
|
|
//
|
|
// Coding Example with CDC classes and CPen ...
|
|
// void DrawLine()
|
|
// {
|
|
// CClientDC dcClient(this)
|
|
// CMemDC CMemDC(&dcClient);
|
|
// CBitmap* pOldBitmap = dcMem.CreateCompatibleBitmap(&dcClient, cx, cy);
|
|
// CPen MyPen(PS_SOLID, 1, RGB(255,0,0));
|
|
// CPen* pOldPen = CMemDC.SelectObject(&MyPen);
|
|
// CMemDC.MoveTo(0, 0);
|
|
// CMemDC.LineTo(50, 50);
|
|
// dcClient.BitBlt(0, 0, cx, cy, &CMemDC, 0, 0);
|
|
// }
|
|
|
|
// Notes:
|
|
// * When the CDC object drops out of scope, it's destructor is called, releasing
|
|
// or deleting the device context as appropriate.
|
|
// * When the destructor for CBitmap, CBrush, CPalette, CPen and CRgn are called,
|
|
// the destructor is called deleting their GDI object.
|
|
// * When the CDC object' destructor is called, any GDI objects created by one of
|
|
// the CDC member functions (CDC::CreatePen for example) will be deleted.
|
|
// * Bitmaps can only be selected into one device context at a time.
|
|
// * Palettes use SelectPalatte to select them into device the context.
|
|
// * Regions use SelectClipRgn to select them into the device context.
|
|
// * The FromHandle function can be used to convert a GDI handle (HDC, HPEN,
|
|
// HBITMAP etc) to a pointer of the appropriate GDI class (CDC, CPen CBitmap etc).
|
|
// The FromHandle function creates a temporary object unless the HANDLE is already
|
|
// assigned to a GDI class. Temporary objects don't delete their GDI object when
|
|
// their destructor is called.
|
|
// * All the GDI classes are reference counted. This allows functions to safely
|
|
// pass these objects by value, as well as by pointer or by reference.
|
|
|
|
// The CBitmapInfoPtr class is a convienient wrapper for the BITMAPINFO structure.
|
|
// The size of the BITMAPINFO structure is dependant on the type of HBITMAP, and its
|
|
// space needs to be allocated dynamically. CBitmapInfoPtr automatically allocates
|
|
// and deallocates the memory for the structure. A CBitmapInfoPtr object can be
|
|
// used anywhere in place of a LPBITMAPINFO. LPBITMAPINFO is used in functions like
|
|
// GetDIBits and SetDIBits.
|
|
//
|
|
// Coding example ...
|
|
// CDC MemDC = CreateCompatibleDC(NULL);
|
|
// CBitmapInfoPtr pbmi(hBitmap);
|
|
// MemDC.GetDIBits(hBitmap, 0, pbmi->bmiHeader.biHeight, NULL, pbmi, DIB_RGB_COLORS);
|
|
|
|
#ifndef _WIN32XX_GDI_H_
|
|
#define _WIN32XX_GDI_H_
|
|
|
|
#include "wincore.h"
|
|
|
|
// Disable macros from Windowsx.h
|
|
#undef CopyRgn
|
|
|
|
namespace Win32xx
|
|
{
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Declarations for some global functions in the Win32xx namespace
|
|
//
|
|
#ifndef _WIN32_WCE
|
|
void GrayScaleBitmap(CBitmap* pbmSource);
|
|
void TintBitmap(CBitmap* pbmSource, int cRed, int cGreen, int cBlue);
|
|
HIMAGELIST CreateDisabledImageList(HIMAGELIST himlNormal);
|
|
#endif
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CGDIObject class
|
|
//
|
|
class CGDIObject
|
|
{
|
|
friend CBitmap* FromHandle(HBITMAP hBitmap);
|
|
friend CBrush* FromHandle(HBRUSH hBrush);
|
|
friend CDC* FromHandle(HDC hDC);
|
|
friend CFont* FromHandle(HFONT hFont);
|
|
friend CPalette* FromHandle(HPALETTE hPalette);
|
|
friend CPen* FromHandle(HPEN hPen);
|
|
friend CRgn* FromHandle(HRGN hRgn);
|
|
|
|
public:
|
|
struct DataMembers // A structure that contains the data members for CGDIObject
|
|
{
|
|
HGDIOBJ hGDIObject;
|
|
long Count;
|
|
BOOL bRemoveObject;
|
|
};
|
|
CGDIObject();
|
|
CGDIObject(const CGDIObject& rhs);
|
|
virtual ~CGDIObject();
|
|
CGDIObject& operator = ( const CGDIObject& rhs );
|
|
void operator = (HGDIOBJ hObject);
|
|
|
|
void Attach(HGDIOBJ hObject);
|
|
HGDIOBJ Detach();
|
|
HGDIOBJ GetHandle() const;
|
|
int GetObject(int nCount, LPVOID pObject) const;
|
|
|
|
protected:
|
|
DataMembers* m_pData;
|
|
|
|
private:
|
|
void AddToMap();
|
|
BOOL RemoveFromMap();
|
|
void Release();
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CBitmap class
|
|
//
|
|
class CBitmap : public CGDIObject
|
|
{
|
|
public:
|
|
CBitmap();
|
|
CBitmap(HBITMAP hBitmap);
|
|
CBitmap(LPCTSTR lpstr);
|
|
CBitmap(int nID);
|
|
operator HBITMAP() const;
|
|
~CBitmap();
|
|
|
|
// Create and load methods
|
|
BOOL LoadBitmap(LPCTSTR lpszName);
|
|
BOOL LoadBitmap(int nID);
|
|
BOOL LoadImage(LPCTSTR lpszName, int cxDesired, int cyDesired, UINT fuLoad);
|
|
BOOL LoadImage(UINT nID, int cxDesired, int cyDesired, UINT fuLoad);
|
|
BOOL LoadOEMBitmap(UINT nIDBitmap);
|
|
HBITMAP CreateBitmap(int nWidth, int nHeight, UINT nPlanes, UINT nBitsPerPixel, LPCVOID lpBits);
|
|
HBITMAP CreateCompatibleBitmap(CDC* pDC, int nWidth, int nHeight);
|
|
HBITMAP CreateDIBSection(CDC* pDC, CONST BITMAPINFO* lpbmi, UINT uColorUse, LPVOID* ppvBits, HANDLE hSection, DWORD dwOffset);
|
|
|
|
#ifndef _WIN32_WCE
|
|
HBITMAP CreateDIBitmap(CDC* pDC, CONST BITMAPINFOHEADER* lpbmih, DWORD dwInit, LPCVOID lpbInit, CONST BITMAPINFO* lpbmi, UINT uColorUse);
|
|
HBITMAP CreateMappedBitmap(UINT nIDBitmap, UINT nFlags = 0, LPCOLORMAP lpColorMap = NULL, int nMapSize = 0);
|
|
HBITMAP CreateBitmapIndirect(LPBITMAP lpBitmap);
|
|
int GetDIBits(CDC* pDC, UINT uStartScan, UINT cScanLines, LPVOID lpvBits, LPBITMAPINFO lpbmi, UINT uColorUse) const;
|
|
int SetDIBits(CDC* pDC, UINT uStartScan, UINT cScanLines, CONST VOID* lpvBits, CONST BITMAPINFO* lpbmi, UINT uColorUse);
|
|
CSize GetBitmapDimensionEx() const;
|
|
CSize SetBitmapDimensionEx(int nWidth, int nHeight);
|
|
#endif // !_WIN32_WCE
|
|
|
|
// Attributes
|
|
BITMAP GetBitmapData() const;
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CBrush class
|
|
//
|
|
class CBrush : public CGDIObject
|
|
{
|
|
public:
|
|
CBrush();
|
|
CBrush(HBRUSH hBrush);
|
|
CBrush(COLORREF crColor);
|
|
operator HBRUSH() const;
|
|
~CBrush();
|
|
|
|
HBRUSH CreateSolidBrush(COLORREF crColor);
|
|
HBRUSH CreatePatternBrush(CBitmap* pBitmap);
|
|
LOGBRUSH GetLogBrush() const;
|
|
|
|
#ifndef _WIN32_WCE
|
|
HBRUSH CreateHatchBrush(int nIndex, COLORREF crColor);
|
|
HBRUSH CreateBrushIndirect(LPLOGBRUSH lpLogBrush);
|
|
HBRUSH CreateDIBPatternBrush(HGLOBAL hglbDIBPacked, UINT fuColorSpec);
|
|
HBRUSH CreateDIBPatternBrushPt(LPCVOID lpPackedDIB, UINT nUsage);
|
|
#endif // !defined(_WIN32_WCE)
|
|
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CFont class
|
|
//
|
|
class CFont : public CGDIObject
|
|
{
|
|
public:
|
|
CFont();
|
|
CFont(HFONT hFont);
|
|
CFont(const LOGFONT* lpLogFont);
|
|
operator HFONT() const;
|
|
~CFont();
|
|
|
|
// Create methods
|
|
HFONT CreateFontIndirect(const LOGFONT* lpLogFont);
|
|
HFONT CreatePointFont(int nPointSize, LPCTSTR lpszFaceName, CDC* pDC = NULL, BOOL bBold = FALSE, BOOL bItalic = FALSE);
|
|
HFONT CreatePointFontIndirect(const LOGFONT* lpLogFont, CDC* pDC = NULL);
|
|
|
|
#ifndef _WIN32_WCE
|
|
HFONT CreateFont(int nHeight, int nWidth, int nEscapement,
|
|
int nOrientation, int nWeight, DWORD dwItalic, DWORD dwUnderline,
|
|
DWORD dwStrikeOut, DWORD dwCharSet, DWORD dwOutPrecision,
|
|
DWORD dwClipPrecision, DWORD dwQuality, DWORD dwPitchAndFamily,
|
|
LPCTSTR lpszFacename);
|
|
#endif // #ifndef _WIN32_WCE
|
|
|
|
// Attributes
|
|
LOGFONT GetLogFont() const;
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CPalette class
|
|
//
|
|
class CPalette : public CGDIObject
|
|
{
|
|
public:
|
|
CPalette();
|
|
CPalette(HPALETTE hPalette);
|
|
operator HPALETTE() const;
|
|
~CPalette();
|
|
|
|
// Create methods
|
|
HPALETTE CreatePalette(LPLOGPALETTE lpLogPalette);
|
|
|
|
#ifndef _WIN32_WCE
|
|
HPALETTE CreateHalftonePalette(CDC* pDC);
|
|
#endif // !_WIN32_WCE
|
|
|
|
// Attributes
|
|
int GetEntryCount() const;
|
|
UINT GetPaletteEntries(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors) const;
|
|
UINT SetPaletteEntries(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors);
|
|
|
|
// Operations
|
|
#ifndef _WIN32_WCE
|
|
BOOL ResizePalette(UINT nNumEntries);
|
|
void AnimatePalette(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors);
|
|
#endif // !_WIN32_WCE
|
|
|
|
UINT GetNearestPaletteIndex (COLORREF crColor) const;
|
|
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CPen class
|
|
//
|
|
class CPen : public CGDIObject
|
|
{
|
|
public:
|
|
CPen();
|
|
CPen(HPEN hPen);
|
|
CPen(int nPenStyle, int nWidth, COLORREF crColor);
|
|
#ifndef _WIN32_WCE
|
|
CPen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush, int nStyleCount = 0, const DWORD* lpStyle = NULL);
|
|
#endif // !_WIN32_WCE
|
|
operator HPEN() const;
|
|
~CPen();
|
|
|
|
HPEN CreatePen(int nPenStyle, int nWidth, COLORREF crColor);
|
|
HPEN CreatePenIndirect(LPLOGPEN lpLogPen);
|
|
LOGPEN GetLogPen() const;
|
|
|
|
#ifndef _WIN32_WCE
|
|
HPEN ExtCreatePen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush, int nStyleCount = 0, const DWORD* lpStyle = NULL);
|
|
EXTLOGPEN GetExtLogPen() const;
|
|
#endif // !_WIN32_WCE
|
|
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CRgn class
|
|
//
|
|
class CRgn : public CGDIObject
|
|
{
|
|
public:
|
|
CRgn();
|
|
CRgn(HRGN hRgn);
|
|
operator HRGN() const;
|
|
~CRgn ();
|
|
|
|
// Create methods
|
|
HRGN CreateRectRgn(int x1, int y1, int x2, int y2);
|
|
HRGN CreateRectRgnIndirect(const RECT& rc);
|
|
HRGN CreateFromData(const XFORM* lpXForm, int nCount, const RGNDATA* pRgnData);
|
|
|
|
#ifndef _WIN32_WCE
|
|
HRGN CreateEllipticRgn(int x1, int y1, int x2, int y2);
|
|
HRGN CreateEllipticRgnIndirect(const RECT& rc);
|
|
HRGN CreatePolygonRgn(LPPOINT lpPoints, int nCount, int nMode);
|
|
HRGN CreatePolyPolygonRgn(LPPOINT lpPoints, LPINT lpPolyCounts, int nCount, int nPolyFillMode);
|
|
HRGN CreateRoundRectRgn(int x1, int y1, int x2, int y2, int x3, int y3);
|
|
HRGN CreateFromPath(HDC hDC);
|
|
#endif // !_WIN32_WCE
|
|
|
|
// Operations
|
|
void SetRectRgn(int x1, int y1, int x2, int y2);
|
|
void SetRectRgn(const RECT& rc);
|
|
int CombineRgn(CRgn* pRgnSrc1, CRgn* pRgnSrc2, int nCombineMode);
|
|
int CombineRgn(CRgn* pRgnSrc, int nCombineMode);
|
|
int CopyRgn(CRgn* pRgnSrc);
|
|
BOOL EqualRgn(CRgn* pRgn) const;
|
|
int OffsetRgn(int x, int y);
|
|
int OffsetRgn(POINT& pt);
|
|
int GetRgnBox(RECT& rc) const;
|
|
BOOL PtInRegion(int x, int y) const;
|
|
BOOL PtInRegion(POINT& pt) const;
|
|
BOOL RectInRegion(const RECT& rc) const;
|
|
int GetRegionData(LPRGNDATA lpRgnData, int nDataSize) const;
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CDC class
|
|
//
|
|
class CDC
|
|
{
|
|
friend class CWinApp;
|
|
friend class CWnd;
|
|
friend CDC* FromHandle(HDC hDC);
|
|
|
|
public:
|
|
struct DataMembers // A structure that contains the data members for CDC
|
|
{
|
|
std::vector<GDIPtr> m_vGDIObjects; // Smart pointers to internally created Bitmaps, Brushes, Fonts, Bitmaps and Regions
|
|
HDC hDC; // The HDC belonging to this CDC
|
|
long Count; // Reference count
|
|
BOOL bRemoveHDC; // Delete/Release the HDC on destruction
|
|
HWND hWnd; // The HWND of a Window or Client window DC
|
|
int nSavedDCState; // The save state of the HDC.
|
|
};
|
|
|
|
CDC(); // Constructs a new CDC without assigning a HDC
|
|
CDC(HDC hDC, HWND hWnd = 0); // Assigns a HDC to a new CDC
|
|
CDC(const CDC& rhs); // Constructs a new copy of the CDC
|
|
virtual ~CDC();
|
|
operator HDC() const { return m_pData->hDC; } // Converts a CDC to a HDC
|
|
CDC& operator = (const CDC& rhs); // Assigns a CDC to an existing CDC
|
|
|
|
void Attach(HDC hDC, HWND hWnd = 0);
|
|
void Destroy();
|
|
HDC Detach();
|
|
HDC GetHDC() const { return m_pData->hDC; }
|
|
CPalette* SelectPalette(const CPalette* pPalette, BOOL bForceBkgnd);
|
|
CBitmap* SelectObject(const CBitmap* pBitmap);
|
|
CBrush* SelectObject(const CBrush* pBrush);
|
|
CFont* SelectObject(const CFont* pFont);
|
|
CPalette* SelectObject(const CPalette* pPalette);
|
|
CPen* SelectObject(const CPen* pPen);
|
|
|
|
#ifndef _WIN32_WCE
|
|
void operator = (const HDC hDC);
|
|
#endif
|
|
|
|
// Initialization
|
|
BOOL CreateCompatibleDC(CDC* pDC);
|
|
BOOL CreateDC(LPCTSTR lpszDriver, LPCTSTR lpszDevice, LPCTSTR lpszOutput, const DEVMODE* pInitData);
|
|
int GetDeviceCaps(int nIndex) const;
|
|
#ifndef _WIN32_WCE
|
|
BOOL CreateIC(LPCTSTR lpszDriver, LPCTSTR lpszDevice, LPCTSTR lpszOutput, const DEVMODE* pInitData);
|
|
#endif
|
|
|
|
// Create and Select Bitmaps
|
|
CBitmap* CreateBitmap(int cx, int cy, UINT Planes, UINT BitsPerPixel, LPCVOID pvColors);
|
|
CBitmap* CreateCompatibleBitmap(CDC* pDC, int cx, int cy);
|
|
CBitmap* CreateDIBSection(CDC* pDC, const BITMAPINFO& bmi, UINT iUsage, LPVOID *ppvBits,
|
|
HANDLE hSection, DWORD dwOffset);
|
|
BITMAP GetBitmapData() const;
|
|
CBitmap* LoadBitmap(UINT nID);
|
|
CBitmap* LoadBitmap(LPCTSTR lpszName);
|
|
CBitmap* LoadImage(UINT nID, int cxDesired, int cyDesired, UINT fuLoad);
|
|
CBitmap* LoadImage(LPCTSTR lpszName, int cxDesired, int cyDesired, UINT fuLoad);
|
|
CBitmap* LoadOEMBitmap(UINT nIDBitmap); // for OBM_/OCR_/OIC
|
|
|
|
#ifndef _WIN32_WCE
|
|
CBitmap* CreateBitmapIndirect(LPBITMAP pBitmap);
|
|
CBitmap* CreateDIBitmap(CDC* pDC, const BITMAPINFOHEADER& bmih, DWORD fdwInit, LPCVOID lpbInit,
|
|
BITMAPINFO& bmi, UINT fuUsage);
|
|
CBitmap* CreateMappedBitmap(UINT nIDBitmap, UINT nFlags /*= 0*/, LPCOLORMAP lpColorMap /*= NULL*/, int nMapSize /*= 0*/);
|
|
#endif
|
|
|
|
// Create and Select Brushes
|
|
CBrush* CreatePatternBrush(CBitmap* pBitmap);
|
|
CBrush* CreateSolidBrush(COLORREF rbg);
|
|
LOGBRUSH GetLogBrush() const;
|
|
|
|
#ifndef _WIN32_WCE
|
|
CBrush* CreateBrushIndirect(LPLOGBRUSH pLogBrush);
|
|
CBrush* CreateHatchBrush(int fnStyle, COLORREF rgb);
|
|
CBrush* CreateDIBPatternBrush(HGLOBAL hglbDIBPacked, UINT fuColorSpec);
|
|
CBrush* CreateDIBPatternBrushPt(LPCVOID lpPackedDIB, UINT iUsage);
|
|
#endif
|
|
|
|
// Create and Select Fonts
|
|
CFont* CreateFontIndirect(LPLOGFONT plf);
|
|
LOGFONT GetLogFont() const;
|
|
|
|
#ifndef _WIN32_WCE
|
|
CFont* CreateFont(int nHeight, int nWidth, int nEscapement, int nOrientation, int fnWeight,
|
|
DWORD fdwItalic, DWORD fdwUnderline, DWORD fdwStrikeOut, DWORD fdwCharSet,
|
|
DWORD fdwOutputPrecision, DWORD fdwClipPrecision, DWORD fdwQuality,
|
|
DWORD fdwPitchAndFamily, LPCTSTR lpszFace);
|
|
#endif
|
|
|
|
// Create and Select Pens
|
|
CPen* CreatePen(int nStyle, int nWidth, COLORREF rgb);
|
|
CPen* CreatePenIndirect(LPLOGPEN pLogPen);
|
|
LOGPEN GetLogPen() const;
|
|
|
|
// Create Select Regions
|
|
int CreateRectRgn(int left, int top, int right, int bottom);
|
|
int CreateRectRgnIndirect(const RECT& rc);
|
|
int CreateFromData(const XFORM* Xform, DWORD nCount, const RGNDATA *pRgnData);
|
|
#ifndef _WIN32_WCE
|
|
int CreateEllipticRgn(int left, int top, int right, int bottom);
|
|
int CreateEllipticRgnIndirect(const RECT& rc);
|
|
int CreatePolygonRgn(LPPOINT ppt, int cPoints, int fnPolyFillMode);
|
|
int CreatePolyPolygonRgn(LPPOINT ppt, LPINT pPolyCounts, int nCount, int fnPolyFillMode);
|
|
#endif
|
|
|
|
// Wrappers for WinAPI functions
|
|
|
|
// Point and Line Drawing Functions
|
|
CPoint GetCurrentPosition() const;
|
|
CPoint MoveTo(int x, int y) const;
|
|
CPoint MoveTo(POINT pt) const;
|
|
BOOL LineTo(int x, int y) const;
|
|
BOOL LineTo(POINT pt) const;
|
|
COLORREF GetPixel(int x, int y) const;
|
|
COLORREF GetPixel(POINT pt) const;
|
|
COLORREF SetPixel(int x, int y, COLORREF crColor) const;
|
|
COLORREF SetPixel(POINT pt, COLORREF crColor) const;
|
|
#ifndef _WIN32_WCE
|
|
BOOL Arc(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) const;
|
|
BOOL Arc(RECT& rc, POINT ptStart, POINT ptEnd) const;
|
|
BOOL ArcTo(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) const;
|
|
BOOL ArcTo(RECT& rc, POINT ptStart, POINT ptEnd) const;
|
|
BOOL AngleArc(int x, int y, int nRadius, float fStartAngle, float fSweepAngle) const;
|
|
int GetArcDirection() const;
|
|
int SetArcDirection(int nArcDirection) const;
|
|
BOOL PolyDraw(const POINT* lpPoints, const BYTE* lpTypes, int nCount) const;
|
|
BOOL Polyline(LPPOINT lpPoints, int nCount) const;
|
|
BOOL PolyPolyline(const POINT* lpPoints, const DWORD* lpPolyPoints, int nCount) const;
|
|
BOOL PolylineTo(const POINT* lpPoints, int nCount) const;
|
|
BOOL PolyBezier(const POINT* lpPoints, int nCount) const;
|
|
BOOL PolyBezierTo(const POINT* lpPoints, int nCount) const;
|
|
BOOL SetPixelV(int x, int y, COLORREF crColor) const;
|
|
BOOL SetPixelV(POINT pt, COLORREF crColor) const;
|
|
#endif
|
|
|
|
// Shape Drawing Functions
|
|
void DrawFocusRect(const RECT& rc) const;
|
|
BOOL Ellipse(int x1, int y1, int x2, int y2) const;
|
|
BOOL Ellipse(const RECT& rc) const;
|
|
BOOL Polygon(LPPOINT lpPoints, int nCount) const;
|
|
BOOL Rectangle(int x1, int y1, int x2, int y2) const;
|
|
BOOL Rectangle(const RECT& rc) const;
|
|
BOOL RoundRect(int x1, int y1, int x2, int y2, int nWidth, int nHeight) const;
|
|
BOOL RoundRect(const RECT& rc, int nWidth, int nHeight) const;
|
|
|
|
#ifndef _WIN32_WCE
|
|
BOOL Chord(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) const;
|
|
BOOL Chord(const RECT& rc, POINT ptStart, POINT ptEnd) const;
|
|
BOOL Pie(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) const;
|
|
BOOL Pie(const RECT& rc, POINT ptStart, POINT ptEnd) const;
|
|
BOOL PolyPolygon(LPPOINT lpPoints, LPINT lpPolyCounts, int nCount) const;
|
|
#endif
|
|
|
|
// Fill and Image Drawing functions
|
|
BOOL FillRect(const RECT& rc, CBrush* pBrushr) const;
|
|
BOOL InvertRect(const RECT& rc) const;
|
|
BOOL DrawIconEx(int xLeft, int yTop, HICON hIcon, int cxWidth, int cyWidth, UINT istepIfAniCur, CBrush* pFlickerFreeDraw, UINT diFlags) const;
|
|
BOOL DrawEdge(const RECT& rc, UINT nEdge, UINT nFlags) const;
|
|
BOOL DrawFrameControl(const RECT& rc, UINT nType, UINT nState) const;
|
|
BOOL FillRgn(CRgn* pRgn, CBrush* pBrush) const;
|
|
void GradientFill(COLORREF Color1, COLORREF Color2, const RECT& rc, BOOL bVertical);
|
|
void SolidFill(COLORREF Color, const RECT& rc);
|
|
|
|
#ifndef _WIN32_WCE
|
|
BOOL DrawIcon(int x, int y, HICON hIcon) const;
|
|
BOOL DrawIcon(POINT point, HICON hIcon) const;
|
|
BOOL FrameRect(const RECT& rc, CBrush* pBrush) const;
|
|
BOOL PaintRgn(CRgn* pRgn) const;
|
|
#endif
|
|
|
|
// Bitmap Functions
|
|
void DrawBitmap(int x, int y, int cx, int cy, CBitmap& Bitmap, COLORREF clrMask);
|
|
int StretchDIBits(int XDest, int YDest, int nDestWidth, int nDestHeight, int XSrc, int YSrc, int nSrcWidth,
|
|
int nSrcHeight, CONST VOID *lpBits, BITMAPINFO& bi, UINT iUsage, DWORD dwRop) const;
|
|
BOOL PatBlt(int x, int y, int nWidth, int nHeight, DWORD dwRop) const;
|
|
BOOL BitBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC, int xSrc, int ySrc, DWORD dwRop) const;
|
|
BOOL StretchBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, DWORD dwRop) const;
|
|
|
|
#ifndef _WIN32_WCE
|
|
int GetDIBits(CBitmap* pBitmap, UINT uStartScan, UINT cScanLines, LPVOID lpvBits, LPBITMAPINFO lpbi, UINT uUsage) const;
|
|
int SetDIBits(CBitmap* pBitmap, UINT uStartScan, UINT cScanLines, CONST VOID *lpvBits, LPBITMAPINFO lpbi, UINT fuColorUse) const;
|
|
int GetStretchBltMode() const;
|
|
int SetStretchBltMode(int iStretchMode) const;
|
|
BOOL FloodFill(int x, int y, COLORREF crColor) const;
|
|
BOOL ExtFloodFill(int x, int y, COLORREF crColor, UINT nFillType) const;
|
|
#endif
|
|
|
|
// Brush Functions
|
|
#ifdef GetDCBrushColor
|
|
COLORREF GetDCBrushColor() const;
|
|
COLORREF SetDCBrushColor(COLORREF crColor) const;
|
|
#endif
|
|
|
|
// Clipping Functions
|
|
int ExcludeClipRect(int Left, int Top, int Right, int BottomRect);
|
|
int ExcludeClipRect(const RECT& rc);
|
|
int GetClipBox(RECT& rc);
|
|
int GetClipRgn(HRGN hrgn);
|
|
int IntersectClipRect(int Left, int Top, int Right, int Bottom);
|
|
int IntersectClipRect(const RECT& rc);
|
|
BOOL RectVisible(const RECT& rc);
|
|
int SelectClipRgn(CRgn* pRgn);
|
|
|
|
#ifndef _WIN32_WCE
|
|
int ExtSelectClipRgn(CRgn* pRgn, int fnMode);
|
|
int OffsetClipRgn(int nXOffset, int nYOffset);
|
|
BOOL PtVisible(int X, int Y);
|
|
#endif
|
|
|
|
// Co-ordinate Functions
|
|
#ifndef _WIN32_WCE
|
|
BOOL DPtoLP(LPPOINT lpPoints, int nCount) const;
|
|
BOOL DPtoLP(RECT& rc) const;
|
|
BOOL LPtoDP(LPPOINT lpPoints, int nCount) const;
|
|
BOOL LPtoDP(RECT& rc) const;
|
|
#endif
|
|
|
|
// Layout Functions
|
|
DWORD GetLayout() const;
|
|
DWORD SetLayout(DWORD dwLayout) const;
|
|
|
|
// Mapping functions
|
|
#ifndef _WIN32_WCE
|
|
int GetMapMode() const;
|
|
int SetMapMode(int nMapMode) const;
|
|
BOOL GetViewportOrgEx(LPPOINT lpPoint) const;
|
|
BOOL SetViewportOrgEx(int x, int y, LPPOINT lpPoint = NULL) const;
|
|
BOOL SetViewportOrgEx(POINT point, LPPOINT lpPointRet = NULL) const;
|
|
BOOL OffsetViewportOrgEx(int nWidth, int nHeight, LPPOINT lpPoint = NULL) const;
|
|
BOOL GetViewportExtEx(LPSIZE lpSize) const;
|
|
BOOL SetViewportExtEx(int x, int y, LPSIZE lpSize) const;
|
|
BOOL SetViewportExtEx(SIZE size, LPSIZE lpSizeRet) const;
|
|
BOOL ScaleViewportExtEx(int xNum, int xDenom, int yNum, int yDenom, LPSIZE lpSize) const;
|
|
BOOL OffsetWindowOrg(int nWidth, int nHeight, LPPOINT lpPoint) const;
|
|
BOOL GetWindowExtEx(LPSIZE lpSize) const;
|
|
BOOL SetWindowExtEx(int x, int y, LPSIZE lpSize) const;
|
|
BOOL SetWindowExtEx(SIZE size, LPSIZE lpSizeRet) const;
|
|
BOOL ScaleWindowExtEx(int xNum, int xDenom, int yNum, int yDenom, LPSIZE lpSize) const;
|
|
BOOL GetWindowOrgEx(LPPOINT lpPoint) const;
|
|
BOOL SetWindowOrgEx(int x, int y, LPPOINT lpPoint) const;
|
|
BOOL SetWindowOrgEx(POINT point, LPPOINT lpPointRet) const;
|
|
BOOL OffsetWindowOrgEx(int nWidth, int nHeight, LPPOINT lpPoint) const;
|
|
#endif
|
|
|
|
// Printer Functions
|
|
int StartDoc(LPDOCINFO lpDocInfo) const;
|
|
int EndDoc() const;
|
|
int StartPage() const;
|
|
int EndPage() const;
|
|
int AbortDoc() const;
|
|
int SetAbortProc(BOOL (CALLBACK* lpfn)(HDC, int)) const;
|
|
|
|
// Text Functions
|
|
int DrawText(LPCTSTR lpszString, int nCount, LPRECT lprc, UINT nFormat) const;
|
|
BOOL ExtTextOut(int x, int y, UINT nOptions, LPCRECT lprc, LPCTSTR lpszString, int nCount = -1, LPINT lpDxWidths = NULL) const;
|
|
COLORREF GetBkColor() const;
|
|
int GetBkMode() const;
|
|
UINT GetTextAlign() const;
|
|
int GetTextFace(int nCount, LPTSTR lpszFacename) const;
|
|
COLORREF GetTextColor() const;
|
|
BOOL GetTextMetrics(TEXTMETRIC& Metrics) const;
|
|
COLORREF SetBkColor(COLORREF crColor) const;
|
|
int SetBkMode(int iBkMode) const;
|
|
UINT SetTextAlign(UINT nFlags) const;
|
|
COLORREF SetTextColor(COLORREF crColor) const;
|
|
|
|
#ifndef _WIN32_WCE
|
|
int DrawTextEx(LPTSTR lpszString, int nCount, LPRECT lprc, UINT nFormat, LPDRAWTEXTPARAMS lpDTParams) const;
|
|
CSize GetTabbedTextExtent(LPCTSTR lpszString, int nCount, int nTabPositions, LPINT lpnTabStopPositions) const;
|
|
int GetTextCharacterExtra() const;
|
|
CSize GetTextExtentPoint32(LPCTSTR lpszString, int nCount) const;
|
|
BOOL GrayString(CBrush* pBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int x, int y, int nWidth, int nHeight) const;
|
|
int SetTextCharacterExtra(int nCharExtra) const;
|
|
int SetTextJustification(int nBreakExtra, int nBreakCount) const;
|
|
CSize TabbedTextOut(int x, int y, LPCTSTR lpszString, int nCount, int nTabPositions, LPINT lpnTabStopPositions, int nTabOrigin) const;
|
|
BOOL TextOut(int x, int y, LPCTSTR lpszString, int nCount = -1) const;
|
|
#endif
|
|
|
|
private:
|
|
void AddToMap();
|
|
static CDC* AddTempHDC(HDC hDC, HWND hWnd);
|
|
void Release();
|
|
BOOL RemoveFromMap();
|
|
|
|
DataMembers* m_pData; // pointer to the class's data members
|
|
};
|
|
|
|
class CClientDC : public CDC
|
|
{
|
|
public:
|
|
CClientDC(const CWnd* pWnd)
|
|
{
|
|
if (pWnd) assert(pWnd->IsWindow());
|
|
HWND hWnd = pWnd? pWnd->GetHwnd() : GetDesktopWindow();
|
|
Attach(::GetDC(hWnd), hWnd);
|
|
}
|
|
virtual ~CClientDC() {}
|
|
};
|
|
|
|
class CMemDC : public CDC
|
|
{
|
|
public:
|
|
CMemDC(const CDC* pDC)
|
|
{
|
|
if (pDC) assert(pDC->GetHDC());
|
|
HDC hDC = pDC? pDC->GetHDC() : NULL;
|
|
Attach(::CreateCompatibleDC(hDC));
|
|
}
|
|
virtual ~CMemDC() {}
|
|
};
|
|
|
|
class CPaintDC : public CDC
|
|
{
|
|
public:
|
|
CPaintDC(const CWnd* pWnd)
|
|
{
|
|
assert(pWnd->IsWindow());
|
|
m_hWnd = pWnd->GetHwnd();
|
|
Attach(::BeginPaint(pWnd->GetHwnd(), &m_ps), m_hWnd);
|
|
}
|
|
|
|
virtual ~CPaintDC() { ::EndPaint(m_hWnd, &m_ps); }
|
|
|
|
private:
|
|
HWND m_hWnd;
|
|
PAINTSTRUCT m_ps;
|
|
};
|
|
|
|
class CWindowDC : public CDC
|
|
{
|
|
public:
|
|
CWindowDC(const CWnd* pWnd)
|
|
{
|
|
if (pWnd) assert(pWnd->IsWindow());
|
|
HWND hWnd = pWnd? pWnd->GetHwnd() : GetDesktopWindow();
|
|
Attach(::GetWindowDC(hWnd), hWnd);
|
|
}
|
|
virtual ~CWindowDC() {}
|
|
};
|
|
|
|
#ifndef _WIN32_WCE
|
|
class CMetaFileDC : public CDC
|
|
{
|
|
public:
|
|
CMetaFileDC() : m_hMF(0), m_hEMF(0) {}
|
|
virtual ~CMetaFileDC()
|
|
{
|
|
if (m_hMF)
|
|
{
|
|
::CloseMetaFile(GetHDC());
|
|
::DeleteMetaFile(m_hMF);
|
|
}
|
|
if (m_hEMF)
|
|
{
|
|
::CloseEnhMetaFile(GetHDC());
|
|
::DeleteEnhMetaFile(m_hEMF);
|
|
}
|
|
}
|
|
void Create(LPCTSTR lpszFilename = NULL) { Attach(::CreateMetaFile(lpszFilename)); }
|
|
void CreateEnhanced(CDC* pDCRef, LPCTSTR lpszFileName, LPCRECT lpBounds, LPCTSTR lpszDescription)
|
|
{
|
|
HDC hDC = pDCRef? pDCRef->GetHDC() : NULL;
|
|
::CreateEnhMetaFile(hDC, lpszFileName, lpBounds, lpszDescription);
|
|
assert(GetHDC());
|
|
}
|
|
HMETAFILE Close() { return ::CloseMetaFile(GetHDC()); }
|
|
HENHMETAFILE CloseEnhanced() { return ::CloseEnhMetaFile(GetHDC()); }
|
|
|
|
private:
|
|
HMETAFILE m_hMF;
|
|
HENHMETAFILE m_hEMF;
|
|
};
|
|
#endif
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CBitmapInfoPtr class
|
|
// The CBitmapInfoPtr class is a convienient wrapper for the BITMAPINFO structure.
|
|
class CBitmapInfoPtr
|
|
{
|
|
public:
|
|
CBitmapInfoPtr(CBitmap* pBitmap)
|
|
{
|
|
BITMAP bmSource = pBitmap->GetBitmapData();
|
|
|
|
// Convert the color format to a count of bits.
|
|
WORD cClrBits = (WORD)(bmSource.bmPlanes * bmSource.bmBitsPixel);
|
|
if (cClrBits == 1) cClrBits = 1;
|
|
else if (cClrBits <= 4) cClrBits = 4;
|
|
else if (cClrBits <= 8) cClrBits = 8;
|
|
else if (cClrBits <= 16) cClrBits = 16;
|
|
else if (cClrBits <= 24) cClrBits = 24;
|
|
else cClrBits = 32;
|
|
|
|
// Allocate memory for the BITMAPINFO structure.
|
|
UINT uQuadSize = (cClrBits == 24)? 0 : sizeof(RGBQUAD) * (int)(1 << cClrBits);
|
|
m_bmi.assign(sizeof(BITMAPINFOHEADER) + uQuadSize, 0);
|
|
m_pbmiArray = (LPBITMAPINFO) &m_bmi[0];
|
|
|
|
m_pbmiArray->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
m_pbmiArray->bmiHeader.biHeight = bmSource.bmHeight;
|
|
m_pbmiArray->bmiHeader.biWidth = bmSource.bmWidth;
|
|
m_pbmiArray->bmiHeader.biPlanes = bmSource.bmPlanes;
|
|
m_pbmiArray->bmiHeader.biBitCount = bmSource.bmBitsPixel;
|
|
m_pbmiArray->bmiHeader.biCompression = BI_RGB;
|
|
if (cClrBits < 24)
|
|
m_pbmiArray->bmiHeader.biClrUsed = (1<<cClrBits);
|
|
}
|
|
LPBITMAPINFO get() const { return m_pbmiArray; }
|
|
operator LPBITMAPINFO() const { return m_pbmiArray; }
|
|
LPBITMAPINFO operator->() const { return m_pbmiArray; }
|
|
|
|
private:
|
|
CBitmapInfoPtr(const CBitmapInfoPtr&); // Disable copy construction
|
|
CBitmapInfoPtr& operator = (const CBitmapInfoPtr&); // Disable assignment operator
|
|
LPBITMAPINFO m_pbmiArray;
|
|
std::vector<byte> m_bmi;
|
|
};
|
|
|
|
|
|
CBitmap* FromHandle(HBITMAP hBitmap);
|
|
CBrush* FromHandle(HBRUSH hBrush);
|
|
CFont* FromHandle(HFONT hFont);
|
|
CPalette* FromHandle(HPALETTE hPalette);
|
|
CPen* FromHandle(HPEN hPen);
|
|
CRgn* FromHandle(HRGN hRgn);
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
namespace Win32xx
|
|
{
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CGDIObject class
|
|
//
|
|
|
|
inline CGDIObject::CGDIObject()
|
|
// Constructs the CGDIObject
|
|
{
|
|
m_pData = new DataMembers;
|
|
m_pData->hGDIObject = 0;
|
|
m_pData->Count = 1L;
|
|
m_pData->bRemoveObject = TRUE;
|
|
}
|
|
|
|
inline CGDIObject::CGDIObject(const CGDIObject& rhs)
|
|
// Note: A copy of a CGDIObject is a clone of the original.
|
|
// Both objects manipulate the one HGDIOBJ.
|
|
{
|
|
m_pData = rhs.m_pData;
|
|
InterlockedIncrement(&m_pData->Count);
|
|
}
|
|
|
|
inline CGDIObject::~CGDIObject()
|
|
// Deconstructs the CGDIObject
|
|
{
|
|
Release();
|
|
}
|
|
|
|
inline CGDIObject& CGDIObject::operator = ( const CGDIObject& rhs )
|
|
// Note: A copy of a CGDIObject is a clone of the original.
|
|
// Both objects manipulate the one HGDIOBJ.
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
InterlockedIncrement(&rhs.m_pData->Count);
|
|
Release();
|
|
m_pData = rhs.m_pData;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline void CGDIObject::operator = (HGDIOBJ hObject)
|
|
{
|
|
assert(m_pData);
|
|
assert (m_pData->hGDIObject == NULL);
|
|
m_pData->hGDIObject = hObject;
|
|
}
|
|
|
|
inline void CGDIObject::AddToMap()
|
|
// Store the HDC and CDC pointer in the HDC map
|
|
{
|
|
assert( GetApp() );
|
|
GetApp()->m_csMapLock.Lock();
|
|
|
|
assert(m_pData->hGDIObject);
|
|
assert(!GetApp()->GetCGDIObjectFromMap(m_pData->hGDIObject));
|
|
|
|
GetApp()->m_mapGDI.insert(std::make_pair(m_pData->hGDIObject, this));
|
|
GetApp()->m_csMapLock.Release();
|
|
}
|
|
|
|
inline void CGDIObject::Attach(HGDIOBJ hObject)
|
|
// Attaches a GDI HANDLE to the CGDIObject.
|
|
// The HGDIOBJ will be automatically deleted when the destructor is called unless it is detached.
|
|
{
|
|
assert(m_pData);
|
|
|
|
if (m_pData->hGDIObject != NULL && m_pData->hGDIObject != hObject)
|
|
{
|
|
::DeleteObject(Detach());
|
|
}
|
|
|
|
CGDIObject* pObject = GetApp()->GetCGDIObjectFromMap(hObject);
|
|
if (pObject)
|
|
{
|
|
delete m_pData;
|
|
m_pData = pObject->m_pData;
|
|
InterlockedIncrement(&m_pData->Count);
|
|
}
|
|
else
|
|
{
|
|
m_pData->hGDIObject = hObject;
|
|
AddToMap();
|
|
}
|
|
}
|
|
|
|
inline HGDIOBJ CGDIObject::Detach()
|
|
// Detaches the HGDIOBJ from this object.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject);
|
|
|
|
GetApp()->m_csMapLock.Lock();
|
|
RemoveFromMap();
|
|
HGDIOBJ hObject = m_pData->hGDIObject;
|
|
m_pData->hGDIObject = 0;
|
|
|
|
if (m_pData->Count)
|
|
{
|
|
if (InterlockedDecrement(&m_pData->Count) == 0)
|
|
{
|
|
delete m_pData;
|
|
}
|
|
}
|
|
|
|
GetApp()->m_csMapLock.Release();
|
|
|
|
// Assign values to our data members
|
|
m_pData = new DataMembers;
|
|
m_pData->hGDIObject = 0;
|
|
m_pData->Count = 1L;
|
|
m_pData->bRemoveObject = TRUE;
|
|
|
|
return hObject;
|
|
}
|
|
|
|
inline HGDIOBJ CGDIObject::GetHandle() const
|
|
{
|
|
assert(m_pData);
|
|
return m_pData->hGDIObject;
|
|
}
|
|
|
|
inline int CGDIObject::GetObject(int nCount, LPVOID pObject) const
|
|
{
|
|
assert(m_pData);
|
|
return ::GetObject(m_pData->hGDIObject, nCount, pObject);
|
|
}
|
|
|
|
inline void CGDIObject::Release()
|
|
{
|
|
assert(m_pData);
|
|
BOOL bSucceeded = TRUE;
|
|
|
|
if (InterlockedDecrement(&m_pData->Count) == 0)
|
|
{
|
|
if (m_pData->hGDIObject != NULL)
|
|
{
|
|
if (m_pData->bRemoveObject)
|
|
bSucceeded = ::DeleteObject(m_pData->hGDIObject);
|
|
else
|
|
bSucceeded = TRUE;
|
|
}
|
|
|
|
RemoveFromMap();
|
|
delete m_pData;
|
|
m_pData = 0;
|
|
}
|
|
|
|
assert(bSucceeded);
|
|
}
|
|
|
|
inline BOOL CGDIObject::RemoveFromMap()
|
|
{
|
|
BOOL Success = FALSE;
|
|
|
|
if( GetApp() )
|
|
{
|
|
// Allocate an iterator for our HDC map
|
|
std::map<HGDIOBJ, CGDIObject*, CompareGDI>::iterator m;
|
|
|
|
CWinApp* pApp = GetApp();
|
|
if (pApp)
|
|
{
|
|
// Erase the CGDIObject pointer entry from the map
|
|
pApp->m_csMapLock.Lock();
|
|
m = pApp->m_mapGDI.find(m_pData->hGDIObject);
|
|
if (m != pApp->m_mapGDI.end())
|
|
{
|
|
pApp->m_mapGDI.erase(m);
|
|
Success = TRUE;
|
|
}
|
|
|
|
pApp->m_csMapLock.Release();
|
|
}
|
|
}
|
|
|
|
return Success;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CBitmap class
|
|
//
|
|
inline CBitmap::CBitmap()
|
|
{
|
|
}
|
|
|
|
inline CBitmap::CBitmap(HBITMAP hBitmap)
|
|
{
|
|
assert(m_pData);
|
|
Attach(hBitmap);
|
|
}
|
|
|
|
inline CBitmap::CBitmap(LPCTSTR lpszName)
|
|
{
|
|
LoadBitmap(lpszName);
|
|
}
|
|
|
|
inline CBitmap::CBitmap(int nID)
|
|
{
|
|
LoadBitmap(nID);
|
|
}
|
|
|
|
inline CBitmap::operator HBITMAP() const
|
|
{
|
|
assert(m_pData);
|
|
return (HBITMAP)m_pData->hGDIObject;
|
|
}
|
|
|
|
inline CBitmap::~CBitmap()
|
|
{
|
|
}
|
|
|
|
inline BOOL CBitmap::LoadBitmap(int nID)
|
|
// Loads a bitmap from a resource using the resource ID.
|
|
{
|
|
return LoadBitmap(MAKEINTRESOURCE(nID));
|
|
}
|
|
|
|
inline BOOL CBitmap::LoadBitmap(LPCTSTR lpszName)
|
|
// Loads a bitmap from a resource using the resource string.
|
|
{
|
|
assert(GetApp());
|
|
assert(m_pData);
|
|
|
|
HBITMAP hBitmap = (HBITMAP)::LoadImage(GetApp()->GetResourceHandle(), lpszName, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
|
|
if (hBitmap)
|
|
{
|
|
Attach(hBitmap);
|
|
}
|
|
return (0 != hBitmap); // boolean expression
|
|
}
|
|
|
|
inline BOOL CBitmap::LoadImage(UINT nID, int cxDesired, int cyDesired, UINT fuLoad)
|
|
// Loads a bitmap from a resource using the resource ID.
|
|
{
|
|
return LoadImage(MAKEINTRESOURCE(nID), cxDesired, cyDesired, fuLoad);
|
|
}
|
|
|
|
inline BOOL CBitmap::LoadImage(LPCTSTR lpszName, int cxDesired, int cyDesired, UINT fuLoad)
|
|
// Loads a bitmap from a resource using the resource string.
|
|
{
|
|
assert(GetApp());
|
|
assert(m_pData);
|
|
|
|
HBITMAP hBitmap = (HBITMAP)::LoadImage(GetApp()->GetResourceHandle(), lpszName, IMAGE_BITMAP, cxDesired, cyDesired, fuLoad);
|
|
if (hBitmap)
|
|
{
|
|
Attach(hBitmap);
|
|
}
|
|
return (0 != hBitmap); // boolean expression
|
|
}
|
|
|
|
inline BOOL CBitmap::LoadOEMBitmap(UINT nIDBitmap) // for OBM_/OCR_/OIC_
|
|
// Loads a predefined bitmap
|
|
// Predefined bitmaps include: OBM_BTNCORNERS, OBM_BTSIZE, OBM_CHECK, OBM_CHECKBOXES, OBM_CLOSE, OBM_COMBO
|
|
// OBM_DNARROW, OBM_DNARROWD, OBM_DNARROWI, OBM_LFARROW, OBM_LFARROWD, OBM_LFARROWI, OBM_MNARROW,OBM_OLD_CLOSE
|
|
// OBM_OLD_DNARROW, OBM_OLD_LFARROW, OBM_OLD_REDUCE, OBM_OLD_RESTORE, OBM_OLD_RGARROW, OBM_OLD_UPARROW
|
|
// OBM_OLD_ZOOM, OBM_REDUCE, OBM_REDUCED, OBM_RESTORE, OBM_RESTORED, OBM_RGARROW, OBM_RGARROWD, OBM_RGARROWI
|
|
// OBM_SIZE, OBM_UPARROW, OBM_UPARROWD, OBM_UPARROWI, OBM_ZOOM, OBM_ZOOMD
|
|
{
|
|
assert(m_pData);
|
|
|
|
HBITMAP hBitmap = ::LoadBitmap(NULL, MAKEINTRESOURCE(nIDBitmap));
|
|
if (hBitmap)
|
|
{
|
|
Attach( ::LoadBitmap(NULL, MAKEINTRESOURCE(nIDBitmap)) );
|
|
}
|
|
return (0 != hBitmap); // boolean expression
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline HBITMAP CBitmap::CreateMappedBitmap(UINT nIDBitmap, UINT nFlags /*= 0*/, LPCOLORMAP lpColorMap /*= NULL*/, int nMapSize /*= 0*/)
|
|
// Creates a new bitmap using the bitmap data and colors specified by the bitmap resource and the color mapping information.
|
|
{
|
|
assert(GetApp());
|
|
assert(m_pData);
|
|
HBITMAP hBitmap = ::CreateMappedBitmap(GetApp()->GetResourceHandle(), nIDBitmap, (WORD)nFlags, lpColorMap, nMapSize);
|
|
Attach(hBitmap);
|
|
return hBitmap;
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
inline HBITMAP CBitmap::CreateBitmap(int nWidth, int nHeight, UINT nPlanes, UINT nBitsPerPixel, LPCVOID lpBits)
|
|
// Creates a bitmap with the specified width, height, and color format (color planes and bits-per-pixel).
|
|
{
|
|
assert(m_pData);
|
|
HBITMAP hBitmap = ::CreateBitmap(nWidth, nHeight, nPlanes, nBitsPerPixel, lpBits);
|
|
Attach(hBitmap);
|
|
return hBitmap;
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline HBITMAP CBitmap::CreateBitmapIndirect(LPBITMAP lpBitmap)
|
|
// Creates a bitmap with the width, height, and color format specified in the BITMAP structure.
|
|
{
|
|
assert(m_pData);
|
|
HBITMAP hBitmap = ::CreateBitmapIndirect(lpBitmap);
|
|
Attach(hBitmap);
|
|
return hBitmap;
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
inline HBITMAP CBitmap::CreateCompatibleBitmap(CDC* pDC, int nWidth, int nHeight)
|
|
// Creates a bitmap compatible with the device that is associated with the specified device context.
|
|
{
|
|
assert(m_pData);
|
|
assert(pDC);
|
|
HBITMAP hBitmap = ::CreateCompatibleBitmap(pDC->GetHDC(), nWidth, nHeight);
|
|
Attach(hBitmap);
|
|
return hBitmap;
|
|
}
|
|
|
|
// Attributes
|
|
inline BITMAP CBitmap::GetBitmapData() const
|
|
// Retrieves the BITMAP structure
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
BITMAP bmp = {0};
|
|
::GetObject(m_pData->hGDIObject, sizeof(BITMAP), &bmp);
|
|
return bmp;
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline CSize CBitmap::GetBitmapDimensionEx() const
|
|
// Retrieves the dimensions of a compatible bitmap.
|
|
// The retrieved dimensions must have been set by the SetBitmapDimensionEx function.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
CSize Size;
|
|
::GetBitmapDimensionEx((HBITMAP)m_pData->hGDIObject, &Size);
|
|
return Size;
|
|
}
|
|
|
|
inline CSize CBitmap::SetBitmapDimensionEx(int nWidth, int nHeight)
|
|
// The SetBitmapDimensionEx function assigns preferred dimensions to a bitmap.
|
|
// These dimensions can be used by applications; however, they are not used by the system.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
CSize Size;
|
|
::SetBitmapDimensionEx((HBITMAP)m_pData->hGDIObject, nWidth, nHeight, Size);
|
|
return Size;
|
|
}
|
|
|
|
// DIB support
|
|
inline HBITMAP CBitmap::CreateDIBitmap(CDC* pDC, CONST BITMAPINFOHEADER* lpbmih, DWORD dwInit, CONST VOID* lpbInit, CONST BITMAPINFO* lpbmi, UINT uColorUse)
|
|
// Creates a compatible bitmap (DDB) from a DIB and, optionally, sets the bitmap bits.
|
|
{
|
|
assert(m_pData);
|
|
assert(pDC);
|
|
HBITMAP hBitmap = ::CreateDIBitmap(pDC->GetHDC(), lpbmih, dwInit, lpbInit, lpbmi, uColorUse);
|
|
Attach(hBitmap);
|
|
return hBitmap;
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
inline HBITMAP CBitmap::CreateDIBSection(CDC* pDC, CONST BITMAPINFO* lpbmi, UINT uColorUse, VOID** ppvBits, HANDLE hSection, DWORD dwOffset)
|
|
// Creates a DIB that applications can write to directly. The function gives you a pointer to the location of the bitmap bit values.
|
|
// You can supply a handle to a file-mapping object that the function will use to create the bitmap, or you can let the system allocate the memory for the bitmap.
|
|
{
|
|
assert(m_pData);
|
|
assert(pDC);
|
|
HBITMAP hBitmap = ::CreateDIBSection(pDC->GetHDC(), lpbmi, uColorUse, ppvBits, hSection, dwOffset);
|
|
Attach(hBitmap);
|
|
return hBitmap;
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline int CBitmap::GetDIBits(CDC* pDC, UINT uStartScan, UINT cScanLines, LPVOID lpvBits, LPBITMAPINFO lpbmi, UINT uColorUse) const
|
|
// Retrieves the bits of the specified compatible bitmap and copies them into a buffer as a DIB using the specified format.
|
|
{
|
|
assert(m_pData);
|
|
assert(pDC);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::GetDIBits(pDC->GetHDC(), (HBITMAP)m_pData->hGDIObject, uStartScan, cScanLines, lpvBits, lpbmi, uColorUse);
|
|
}
|
|
|
|
inline int CBitmap::SetDIBits(CDC* pDC, UINT uStartScan, UINT cScanLines, CONST VOID* lpvBits, CONST BITMAPINFO* lpbmi, UINT uColorUse)
|
|
// Sets the pixels in a compatible bitmap (DDB) using the color data found in the specified DIB.
|
|
{
|
|
assert(m_pData);
|
|
assert(pDC);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::SetDIBits(pDC->GetHDC(), (HBITMAP)m_pData->hGDIObject, uStartScan, cScanLines, lpvBits, lpbmi, uColorUse);
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Definitions of the CBrush class
|
|
//
|
|
inline CBrush::CBrush()
|
|
{
|
|
}
|
|
|
|
inline CBrush::CBrush(HBRUSH hBrush)
|
|
{
|
|
assert(m_pData);
|
|
Attach(hBrush);
|
|
}
|
|
|
|
inline CBrush::CBrush(COLORREF crColor)
|
|
{
|
|
Attach( ::CreateSolidBrush(crColor) );
|
|
assert (m_pData->hGDIObject);
|
|
}
|
|
|
|
inline CBrush::operator HBRUSH() const
|
|
{
|
|
assert(m_pData);
|
|
return (HBRUSH)m_pData->hGDIObject;
|
|
}
|
|
|
|
inline CBrush::~CBrush()
|
|
{
|
|
}
|
|
|
|
inline HBRUSH CBrush::CreateSolidBrush(COLORREF crColor)
|
|
// Creates a logical brush that has the specified solid color.
|
|
{
|
|
assert(m_pData);
|
|
HBRUSH hBrush = ::CreateSolidBrush(crColor);
|
|
Attach(hBrush);
|
|
return hBrush;
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline HBRUSH CBrush::CreateHatchBrush(int nIndex, COLORREF crColor)
|
|
// Creates a logical brush that has the specified hatch pattern and color.
|
|
{
|
|
assert(m_pData);
|
|
HBRUSH hBrush = ::CreateHatchBrush(nIndex, crColor);
|
|
Attach(hBrush);
|
|
return hBrush;
|
|
}
|
|
|
|
inline HBRUSH CBrush::CreateBrushIndirect(LPLOGBRUSH lpLogBrush)
|
|
// Creates a logical brush from style, color, and pattern specified in the LOGPRUSH struct.
|
|
{
|
|
assert(m_pData);
|
|
HBRUSH hBrush = ::CreateBrushIndirect(lpLogBrush);
|
|
Attach(hBrush);
|
|
return hBrush;
|
|
}
|
|
|
|
inline HBRUSH CBrush::CreateDIBPatternBrush(HGLOBAL hglbDIBPacked, UINT fuColorSpec)
|
|
// Creates a logical brush that has the pattern specified by the specified device-independent bitmap (DIB).
|
|
{
|
|
assert(m_pData);
|
|
HBRUSH hBrush = ::CreateDIBPatternBrush(hglbDIBPacked, fuColorSpec);
|
|
Attach(hBrush);
|
|
return hBrush;
|
|
}
|
|
|
|
inline HBRUSH CBrush::CreateDIBPatternBrushPt(LPCVOID lpPackedDIB, UINT nUsage)
|
|
// Creates a logical brush that has the pattern specified by the device-independent bitmap (DIB).
|
|
{
|
|
assert(m_pData);
|
|
HBRUSH hBrush = ::CreateDIBPatternBrushPt(lpPackedDIB, nUsage);
|
|
Attach(hBrush);
|
|
return hBrush;
|
|
}
|
|
|
|
#endif // !defined(_WIN32_WCE)
|
|
|
|
inline HBRUSH CBrush::CreatePatternBrush(CBitmap* pBitmap)
|
|
// Creates a logical brush with the specified bitmap pattern. The bitmap can be a DIB section bitmap,
|
|
// which is created by the CreateDIBSection function, or it can be a device-dependent bitmap.
|
|
{
|
|
assert(m_pData);
|
|
assert(pBitmap);
|
|
HBRUSH hBrush = ::CreatePatternBrush(*pBitmap);
|
|
Attach(hBrush);
|
|
return hBrush;
|
|
}
|
|
|
|
inline LOGBRUSH CBrush::GetLogBrush() const
|
|
// Retrieves the LOGBRUSH structure that defines the style, color, and pattern of a physical brush.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
LOGBRUSH LogBrush = {0};
|
|
::GetObject (m_pData->hGDIObject, sizeof(LOGBRUSH), &LogBrush);
|
|
return LogBrush;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Definitions of the CFont class
|
|
//
|
|
inline CFont::CFont()
|
|
{
|
|
}
|
|
|
|
inline CFont::CFont(HFONT hFont)
|
|
{
|
|
assert(m_pData);
|
|
Attach(hFont);
|
|
}
|
|
|
|
inline CFont::CFont(const LOGFONT* lpLogFont)
|
|
{
|
|
assert(m_pData);
|
|
Attach( ::CreateFontIndirect(lpLogFont) );
|
|
}
|
|
|
|
inline CFont::operator HFONT() const
|
|
{
|
|
assert(m_pData);
|
|
return (HFONT)m_pData->hGDIObject;
|
|
}
|
|
|
|
inline CFont::~CFont()
|
|
{
|
|
}
|
|
|
|
inline HFONT CFont::CreateFontIndirect(const LOGFONT* lpLogFont)
|
|
// Creates a logical font that has the specified characteristics.
|
|
{
|
|
assert(m_pData);
|
|
HFONT hFont = ::CreateFontIndirect(lpLogFont);
|
|
Attach(hFont);
|
|
return hFont;
|
|
}
|
|
|
|
inline HFONT CFont::CreatePointFont(int nPointSize, LPCTSTR lpszFaceName, CDC* pDC /*= NULL*/, BOOL bBold /*= FALSE*/, BOOL bItalic /*= FALSE*/)
|
|
// Creates a font of a specified typeface and point size.
|
|
{
|
|
LOGFONT logFont = { 0 };
|
|
logFont.lfCharSet = DEFAULT_CHARSET;
|
|
logFont.lfHeight = nPointSize;
|
|
|
|
lstrcpy(logFont.lfFaceName, lpszFaceName);
|
|
|
|
if (bBold)
|
|
logFont.lfWeight = FW_BOLD;
|
|
if (bItalic)
|
|
logFont.lfItalic = (BYTE)TRUE;
|
|
|
|
return CreatePointFontIndirect(&logFont, pDC);
|
|
}
|
|
|
|
inline HFONT CFont::CreatePointFontIndirect(const LOGFONT* lpLogFont, CDC* pDC /* = NULL*/)
|
|
// Creates a font of a specified typeface and point size.
|
|
// This function automatically converts the height in lfHeight to logical units using the specified device context.
|
|
{
|
|
HDC hDC = pDC? pDC->GetHDC() : NULL;
|
|
HDC hDC1 = (hDC != NULL) ? hDC : ::GetDC(HWND_DESKTOP);
|
|
|
|
// convert nPointSize to logical units based on hDC
|
|
LOGFONT logFont = *lpLogFont;
|
|
|
|
#ifndef _WIN32_WCE
|
|
POINT pt = { 0, 0 };
|
|
pt.y = ::MulDiv(::GetDeviceCaps(hDC1, LOGPIXELSY), logFont.lfHeight, 720); // 72 points/inch, 10 decipoints/point
|
|
::DPtoLP(hDC1, &pt, 1);
|
|
|
|
POINT ptOrg = { 0, 0 };
|
|
::DPtoLP(hDC1, &ptOrg, 1);
|
|
|
|
logFont.lfHeight = -abs(pt.y - ptOrg.y);
|
|
#else // CE specific
|
|
// DP and LP are always the same on CE
|
|
logFont.lfHeight = -abs(((::GetDeviceCaps(hDC1, LOGPIXELSY)* logFont.lfHeight)/ 720));
|
|
#endif // _WIN32_WCE
|
|
|
|
if (hDC == NULL)
|
|
::ReleaseDC (NULL, hDC1);
|
|
|
|
return CreateFontIndirect (&logFont);
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
|
|
inline HFONT CFont::CreateFont(int nHeight, int nWidth, int nEscapement,
|
|
int nOrientation, int nWeight, DWORD dwItalic, DWORD dwUnderline,
|
|
DWORD dwStrikeOut, DWORD dwCharSet, DWORD dwOutPrecision,
|
|
DWORD dwClipPrecision, DWORD dwQuality, DWORD dwPitchAndFamily,
|
|
LPCTSTR lpszFacename)
|
|
// Creates a logical font with the specified characteristics.
|
|
{
|
|
HFONT hFont = ::CreateFont(nHeight, nWidth, nEscapement,
|
|
nOrientation, nWeight, dwItalic, dwUnderline, dwStrikeOut,
|
|
dwCharSet, dwOutPrecision, dwClipPrecision, dwQuality,
|
|
dwPitchAndFamily, lpszFacename);
|
|
|
|
Attach(hFont);
|
|
return hFont;
|
|
}
|
|
#endif // #ifndef _WIN32_WCE
|
|
|
|
inline LOGFONT CFont::GetLogFont() const
|
|
// Retrieves the Logfont structure that contains font attributes.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
LOGFONT LogFont = {0};
|
|
::GetObject(m_pData->hGDIObject, sizeof(LOGFONT), &LogFont);
|
|
return LogFont;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Definitions of the CPalette class
|
|
//
|
|
inline CPalette::CPalette()
|
|
{
|
|
}
|
|
|
|
inline CPalette::CPalette(HPALETTE hPalette)
|
|
{
|
|
Attach(hPalette);
|
|
}
|
|
|
|
inline CPalette::operator HPALETTE() const
|
|
{
|
|
assert(m_pData);
|
|
return (HPALETTE)m_pData->hGDIObject;
|
|
}
|
|
|
|
inline CPalette::~CPalette ()
|
|
{
|
|
}
|
|
|
|
inline HPALETTE CPalette::CreatePalette(LPLOGPALETTE lpLogPalette)
|
|
// Creates a logical palette from the information in the specified LOGPALETTE structure.
|
|
{
|
|
assert(m_pData);
|
|
HPALETTE hPalette = ::CreatePalette (lpLogPalette);
|
|
Attach(hPalette);
|
|
return hPalette;
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline HPALETTE CPalette::CreateHalftonePalette(CDC* pDC)
|
|
// Creates a halftone palette for the specified device context (DC).
|
|
{
|
|
assert(m_pData);
|
|
assert(pDC);
|
|
HPALETTE hPalette = ::CreateHalftonePalette(pDC->GetHDC());
|
|
Attach(hPalette);
|
|
return hPalette;
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
inline int CPalette::GetEntryCount() const
|
|
// Retrieve the number of entries in the palette.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
WORD nEntries = 0;
|
|
::GetObject(m_pData->hGDIObject, sizeof(WORD), &nEntries);
|
|
return (int)nEntries;
|
|
}
|
|
|
|
inline UINT CPalette::GetPaletteEntries(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors) const
|
|
// Retrieves a specified range of palette entries from the palette.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::GetPaletteEntries((HPALETTE)m_pData->hGDIObject, nStartIndex, nNumEntries, lpPaletteColors);
|
|
}
|
|
|
|
inline UINT CPalette::SetPaletteEntries(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors)
|
|
// Sets RGB (red, green, blue) color values and flags in a range of entries in the palette.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::SetPaletteEntries((HPALETTE)m_pData->hGDIObject, nStartIndex, nNumEntries, lpPaletteColors);
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline void CPalette::AnimatePalette(UINT nStartIndex, UINT nNumEntries, LPPALETTEENTRY lpPaletteColors)
|
|
// Replaces entries in the palette.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
::AnimatePalette((HPALETTE)m_pData->hGDIObject, nStartIndex, nNumEntries, lpPaletteColors);
|
|
}
|
|
|
|
inline BOOL CPalette::ResizePalette(UINT nNumEntries)
|
|
// Increases or decreases the size of the palette based on the specified value.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::ResizePalette((HPALETTE)m_pData->hGDIObject, nNumEntries);
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
inline UINT CPalette::GetNearestPaletteIndex(COLORREF crColor) const
|
|
// Retrieves the index for the entry in the palette most closely matching a specified color value.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::GetNearestPaletteIndex((HPALETTE)m_pData->hGDIObject, crColor);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Declarations for the CPen class
|
|
//
|
|
inline CPen::CPen()
|
|
{
|
|
}
|
|
|
|
inline CPen::CPen(HPEN hPen)
|
|
{
|
|
Attach(hPen);
|
|
}
|
|
|
|
inline CPen::CPen(int nPenStyle, int nWidth, COLORREF crColor)
|
|
{
|
|
assert(m_pData);
|
|
Attach( ::CreatePen(nPenStyle, nWidth, crColor) );
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline CPen::CPen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush, int nStyleCount /*= 0*/, const DWORD* lpStyle /*= NULL*/)
|
|
{
|
|
assert(m_pData);
|
|
Attach( ::ExtCreatePen(nPenStyle, nWidth, pLogBrush, nStyleCount, lpStyle) );
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
inline CPen::operator HPEN () const
|
|
{
|
|
assert(m_pData);
|
|
return (HPEN)m_pData->hGDIObject;
|
|
}
|
|
|
|
inline CPen::~CPen()
|
|
{
|
|
}
|
|
|
|
inline HPEN CPen::CreatePen(int nPenStyle, int nWidth, COLORREF crColor)
|
|
// Creates a logical pen that has the specified style, width, and color.
|
|
{
|
|
assert(m_pData);
|
|
HPEN hPen = ::CreatePen(nPenStyle, nWidth, crColor);
|
|
Attach(hPen);
|
|
return hPen;
|
|
}
|
|
|
|
inline HPEN CPen::CreatePenIndirect(LPLOGPEN lpLogPen)
|
|
// Creates a logical cosmetic pen that has the style, width, and color specified in a structure.
|
|
{
|
|
assert(m_pData);
|
|
HPEN hPen = ::CreatePenIndirect(lpLogPen);
|
|
Attach(hPen);
|
|
return hPen;
|
|
}
|
|
|
|
inline LOGPEN CPen::GetLogPen() const
|
|
{
|
|
// Retrieves the LOGPEN struct that specifies the pen's style, width, and color.
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
|
|
LOGPEN LogPen = {0};
|
|
::GetObject(m_pData->hGDIObject, sizeof(LOGPEN), &LogPen);
|
|
return LogPen;
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline HPEN CPen::ExtCreatePen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush, int nStyleCount /* = 0*/, const DWORD* lpStyle /*= NULL*/)
|
|
// Creates a logical cosmetic or geometric pen that has the specified style, width, and brush attributes.
|
|
{
|
|
assert(m_pData);
|
|
HPEN hPen = ::ExtCreatePen(nPenStyle, nWidth, pLogBrush, nStyleCount, lpStyle);
|
|
Attach(hPen);
|
|
return hPen;
|
|
}
|
|
|
|
inline EXTLOGPEN CPen::GetExtLogPen() const
|
|
// Retrieves the EXTLOGPEN struct that specifies the pen's style, width, color and brush attributes.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
|
|
EXTLOGPEN ExLogPen = {0};
|
|
::GetObject(m_pData->hGDIObject, sizeof(EXTLOGPEN), &ExLogPen);
|
|
return ExLogPen;
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Definitions of the CRgn class
|
|
//
|
|
inline CRgn::CRgn()
|
|
{
|
|
}
|
|
|
|
inline CRgn::CRgn(HRGN hRgn)
|
|
{
|
|
assert(m_pData);
|
|
Attach(hRgn);
|
|
}
|
|
|
|
inline CRgn::operator HRGN() const
|
|
{
|
|
assert(m_pData);
|
|
return (HRGN)m_pData->hGDIObject;
|
|
}
|
|
|
|
inline CRgn::~CRgn()
|
|
{
|
|
}
|
|
|
|
inline HRGN CRgn::CreateRectRgn(int x1, int y1, int x2, int y2)
|
|
// Creates a rectangular region.
|
|
{
|
|
assert(m_pData);
|
|
HRGN hRgn = ::CreateRectRgn(x1, y1, x2, y2);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
inline HRGN CRgn::CreateRectRgnIndirect(const RECT& rc)
|
|
// Creates a rectangular region.
|
|
{
|
|
assert(m_pData);
|
|
HRGN hRgn = ::CreateRectRgnIndirect(&rc);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline HRGN CRgn::CreateEllipticRgn(int x1, int y1, int x2, int y2)
|
|
// Creates an elliptical region.
|
|
{
|
|
assert(m_pData);
|
|
HRGN hRgn = ::CreateEllipticRgn(x1, y1, x2, y2);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
inline HRGN CRgn::CreateEllipticRgnIndirect(const RECT& rc)
|
|
// Creates an elliptical region.
|
|
{
|
|
assert(m_pData);
|
|
HRGN hRgn = ::CreateEllipticRgnIndirect(&rc);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
inline HRGN CRgn::CreatePolygonRgn(LPPOINT lpPoints, int nCount, int nMode)
|
|
// Creates a polygonal region.
|
|
{
|
|
assert(m_pData);
|
|
HRGN hRgn = ::CreatePolygonRgn(lpPoints, nCount, nMode);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
inline HRGN CRgn::CreatePolyPolygonRgn(LPPOINT lpPoints, LPINT lpPolyCounts, int nCount, int nPolyFillMode)
|
|
// Creates a region consisting of a series of polygons. The polygons can overlap.
|
|
{
|
|
assert(m_pData);
|
|
HRGN hRgn = ::CreatePolyPolygonRgn(lpPoints, lpPolyCounts, nCount, nPolyFillMode);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
inline HRGN CRgn::CreateRoundRectRgn(int x1, int y1, int x2, int y2, int x3, int y3)
|
|
// Creates a rectangular region with rounded corners.
|
|
{
|
|
assert(m_pData);
|
|
HRGN hRgn = ::CreateRoundRectRgn(x1, y1, x2, y2, x3, y3);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
inline HRGN CRgn::CreateFromPath(HDC hDC)
|
|
// Creates a region from the path that is selected into the specified device context.
|
|
// The resulting region uses device coordinates.
|
|
{
|
|
assert(m_pData);
|
|
assert(hDC != NULL);
|
|
HRGN hRgn = ::PathToRegion(hDC);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
#endif // !_WIN32_WCE
|
|
|
|
inline HRGN CRgn::CreateFromData(const XFORM* lpXForm, int nCount, const RGNDATA* pRgnData)
|
|
// Creates a region from the specified region and transformation data.
|
|
{
|
|
assert(m_pData);
|
|
HRGN hRgn = ::ExtCreateRegion(lpXForm, nCount, pRgnData);
|
|
Attach(hRgn);
|
|
return hRgn;
|
|
}
|
|
|
|
inline void CRgn::SetRectRgn(int x1, int y1, int x2, int y2)
|
|
// converts the region into a rectangular region with the specified coordinates.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
::SetRectRgn((HRGN)m_pData->hGDIObject, x1, y1, x2, y2);
|
|
}
|
|
|
|
inline void CRgn::SetRectRgn(const RECT& rc)
|
|
// converts the region into a rectangular region with the specified coordinates.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
::SetRectRgn((HRGN)m_pData->hGDIObject, rc.left, rc.top, rc.right, rc.bottom);
|
|
}
|
|
|
|
inline int CRgn::CombineRgn(CRgn* pRgnSrc1, CRgn* pRgnSrc2, int nCombineMode)
|
|
// Combines two sepcified regions and stores the result.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
assert(pRgnSrc1);
|
|
assert(pRgnSrc2);
|
|
return ::CombineRgn((HRGN)m_pData->hGDIObject, *pRgnSrc1, *pRgnSrc2, nCombineMode);
|
|
}
|
|
|
|
inline int CRgn::CombineRgn(CRgn* pRgnSrc, int nCombineMode)
|
|
// Combines the sepcified region with the current region.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
assert(pRgnSrc);
|
|
return ::CombineRgn((HRGN)m_pData->hGDIObject, (HRGN)m_pData->hGDIObject, *pRgnSrc, nCombineMode);
|
|
}
|
|
|
|
inline int CRgn::CopyRgn(CRgn* pRgnSrc)
|
|
// Assigns the specified region to the current region.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject == NULL);
|
|
assert(pRgnSrc);
|
|
return ::CombineRgn((HRGN)m_pData->hGDIObject, *pRgnSrc, NULL, RGN_COPY);
|
|
}
|
|
|
|
inline BOOL CRgn::EqualRgn(CRgn* pRgn) const
|
|
// Checks the two specified regions to determine whether they are identical.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
assert(pRgn);
|
|
return ::EqualRgn((HRGN)m_pData->hGDIObject, *pRgn);
|
|
}
|
|
|
|
inline int CRgn::OffsetRgn(int x, int y)
|
|
// Moves a region by the specified offsets.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::OffsetRgn((HRGN)m_pData->hGDIObject, x, y);
|
|
}
|
|
|
|
inline int CRgn::OffsetRgn(POINT& pt)
|
|
// Moves a region by the specified offsets.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::OffsetRgn((HRGN)m_pData->hGDIObject, pt.x, pt.y);
|
|
}
|
|
|
|
inline int CRgn::GetRgnBox(RECT& rc) const
|
|
// Retrieves the bounding rectangle of the region, and stores it in the specified RECT.
|
|
// The return value indicates the region's complexity: NULLREGION;SIMPLEREGION; or COMPLEXREGION.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::GetRgnBox((HRGN)m_pData->hGDIObject, &rc);
|
|
}
|
|
|
|
inline int CRgn::GetRegionData(LPRGNDATA lpRgnData, int nDataSize) const
|
|
// Fills the specified buffer with data describing a region.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return (int)::GetRegionData((HRGN)m_pData->hGDIObject, nDataSize, lpRgnData);
|
|
}
|
|
|
|
inline BOOL CRgn::PtInRegion(int x, int y) const
|
|
// Determines whether the specified point is inside the specified region.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::PtInRegion((HRGN)m_pData->hGDIObject, x, y);
|
|
}
|
|
|
|
inline BOOL CRgn::PtInRegion(POINT& pt) const
|
|
// Determines whether the specified point is inside the specified region.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::PtInRegion((HRGN)m_pData->hGDIObject, pt.x, pt.y);
|
|
}
|
|
|
|
inline BOOL CRgn::RectInRegion(const RECT& rc) const
|
|
// Determines whether the specified rect is inside the specified region.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hGDIObject != NULL);
|
|
return ::RectInRegion((HRGN)m_pData->hGDIObject, &rc);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
// Definitions of the CDC class
|
|
//
|
|
inline CDC::CDC()
|
|
{
|
|
// Allocate memory for our data members
|
|
m_pData = new DataMembers;
|
|
|
|
// Assign values to our data members
|
|
m_pData->hDC = 0;
|
|
m_pData->Count = 1L;
|
|
m_pData->bRemoveHDC = TRUE;
|
|
m_pData->hWnd = 0;
|
|
}
|
|
|
|
inline CDC::CDC(HDC hDC, HWND hWnd /*= 0*/)
|
|
// This constructor assigns an existing HDC to the CDC
|
|
// The HDC WILL be released or deleted when the CDC object is destroyed
|
|
// The hWnd paramter is only used in WindowsCE. It specifies the HWND of a Window or
|
|
// Window Client DC
|
|
|
|
// Note: this constructor permits a call like this:
|
|
// CDC MyCDC = SomeHDC;
|
|
// or
|
|
// CDC MyCDC = ::CreateCompatibleDC(SomeHDC);
|
|
// or
|
|
// CDC MyCDC = ::GetDC(SomeHWND);
|
|
{
|
|
UNREFERENCED_PARAMETER(hWnd);
|
|
assert(hDC);
|
|
|
|
CDC* pDC = GetApp()->GetCDCFromMap(hDC);
|
|
if (pDC)
|
|
{
|
|
m_pData = pDC->m_pData;
|
|
InterlockedIncrement(&m_pData->Count);
|
|
}
|
|
else
|
|
{
|
|
// Allocate memory for our data members
|
|
m_pData = new DataMembers;
|
|
|
|
// Assign values to our data members
|
|
m_pData->hDC = hDC;
|
|
m_pData->Count = 1L;
|
|
m_pData->bRemoveHDC = TRUE;
|
|
m_pData->nSavedDCState = ::SaveDC(hDC);
|
|
#ifndef _WIN32_WCE
|
|
m_pData->hWnd = ::WindowFromDC(hDC);
|
|
#else
|
|
m_pData->hWnd = hWnd;
|
|
#endif
|
|
if (m_pData->hWnd)
|
|
AddToMap();
|
|
}
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline void CDC::operator = (const HDC hDC)
|
|
// Note: this assignment operater permits a call like this:
|
|
// CDC MyCDC;
|
|
// MyCDC = SomeHDC;
|
|
{
|
|
Attach(hDC);
|
|
}
|
|
#endif
|
|
|
|
inline CDC::CDC(const CDC& rhs) // Copy constructor
|
|
// The copy constructor is called when a temporary copy of the CDC needs to be created.
|
|
// This can happen when a CDC is passed by value in a function call. Each CDC copy manages
|
|
// the same Device Context and GDI objects.
|
|
{
|
|
m_pData = rhs.m_pData;
|
|
InterlockedIncrement(&m_pData->Count);
|
|
}
|
|
|
|
inline CDC& CDC::operator = (const CDC& rhs)
|
|
// Note: A copy of a CDC is a clone of the original.
|
|
// Both objects manipulate the one HDC
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
InterlockedIncrement(&rhs.m_pData->Count);
|
|
Release();
|
|
m_pData = rhs.m_pData;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline CDC::~CDC ()
|
|
{
|
|
Release();
|
|
}
|
|
|
|
inline void CDC::AddToMap()
|
|
// Store the HDC and CDC pointer in the HDC map
|
|
{
|
|
assert( GetApp() );
|
|
assert(m_pData->hDC);
|
|
GetApp()->m_csMapLock.Lock();
|
|
|
|
assert(m_pData->hDC);
|
|
assert(!GetApp()->GetCDCFromMap(m_pData->hDC));
|
|
|
|
GetApp()->m_mapHDC.insert(std::make_pair(m_pData->hDC, this));
|
|
GetApp()->m_csMapLock.Release();
|
|
}
|
|
|
|
inline void CDC::Attach(HDC hDC, HWND hWnd /* = 0*/)
|
|
// Attaches a HDC to the CDC object.
|
|
// The HDC will be automatically deleted or released when the destructor is called.
|
|
// The hWnd parameter is only used on WindowsCE. It specifies the HWND of a Window or
|
|
// Window Client DC
|
|
{
|
|
UNREFERENCED_PARAMETER(hWnd);
|
|
assert(m_pData);
|
|
assert(0 == m_pData->hDC);
|
|
assert(hDC);
|
|
|
|
CDC* pDC = GetApp()->GetCDCFromMap(hDC);
|
|
if (pDC)
|
|
{
|
|
delete m_pData;
|
|
m_pData = pDC->m_pData;
|
|
InterlockedIncrement(&m_pData->Count);
|
|
}
|
|
else
|
|
{
|
|
m_pData->hDC = hDC;
|
|
|
|
#ifndef _WIN32_WCE
|
|
m_pData->hWnd = ::WindowFromDC(hDC);
|
|
#else
|
|
m_pData->hWnd = hWnd;
|
|
#endif
|
|
|
|
if (m_pData->hWnd == 0)
|
|
AddToMap();
|
|
m_pData->nSavedDCState = ::SaveDC(hDC);
|
|
}
|
|
}
|
|
|
|
inline HDC CDC::Detach()
|
|
// Detaches the HDC from this object.
|
|
{
|
|
assert(m_pData);
|
|
assert(m_pData->hDC);
|
|
|
|
GetApp()->m_csMapLock.Lock();
|
|
RemoveFromMap();
|
|
HDC hDC = m_pData->hDC;
|
|
m_pData->hDC = 0;
|
|
|
|
if (m_pData->Count)
|
|
{
|
|
if (InterlockedDecrement(&m_pData->Count) == 0)
|
|
{
|
|
delete m_pData;
|
|
}
|
|
}
|
|
|
|
GetApp()->m_csMapLock.Release();
|
|
|
|
// Assign values to our data members
|
|
m_pData = new DataMembers;
|
|
m_pData->hDC = 0;
|
|
m_pData->Count = 1L;
|
|
m_pData->bRemoveHDC = TRUE;
|
|
m_pData->hWnd = 0;
|
|
|
|
return hDC;
|
|
}
|
|
|
|
// Initialization
|
|
inline BOOL CDC::CreateCompatibleDC(CDC* pDC)
|
|
// Returns a memory device context (DC) compatible with the specified device.
|
|
{
|
|
assert(m_pData->hDC == NULL);
|
|
HDC hdcSource = (pDC == NULL)? NULL : pDC->GetHDC();
|
|
HDC hDC = ::CreateCompatibleDC(hdcSource);
|
|
if (hDC)
|
|
{
|
|
m_pData->hDC = hDC;
|
|
AddToMap();
|
|
}
|
|
return (hDC != NULL); // boolean expression
|
|
}
|
|
|
|
inline BOOL CDC::CreateDC(LPCTSTR lpszDriver, LPCTSTR lpszDevice, LPCTSTR lpszOutput, const DEVMODE* pInitData)
|
|
// Returns a device context (DC) for a device using the specified name.
|
|
{
|
|
assert(m_pData->hDC == NULL);
|
|
HDC hDC = ::CreateDC(lpszDriver, lpszDevice, lpszOutput, pInitData);
|
|
if (hDC)
|
|
{
|
|
m_pData->hDC = hDC;
|
|
AddToMap();
|
|
}
|
|
return (hDC != NULL); // boolean expression
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline BOOL CDC::CreateIC(LPCTSTR lpszDriver, LPCTSTR lpszDevice, LPCTSTR lpszOutput, const DEVMODE* pInitData)
|
|
{
|
|
assert(m_pData->hDC == NULL);
|
|
HDC hDC = ::CreateIC(lpszDriver, lpszDevice, lpszOutput, pInitData);
|
|
if (hDC)
|
|
{
|
|
m_pData->hDC = hDC;
|
|
AddToMap();
|
|
}
|
|
return (hDC != NULL); // boolean expression
|
|
}
|
|
#endif
|
|
|
|
inline void CDC::DrawBitmap(int x, int y, int cx, int cy, CBitmap& Bitmap, COLORREF clrMask)
|
|
// Draws the specified bitmap to the specified DC using the mask colour provided as the transparent colour
|
|
// Suitable for use with a Window DC or a memory DC
|
|
{
|
|
// Create the Image memory DC
|
|
CMemDC dcImage(this);
|
|
dcImage.SetBkColor(clrMask);
|
|
dcImage.SelectObject(&Bitmap);
|
|
|
|
// Create the Mask memory DC
|
|
CMemDC dcMask(this);
|
|
dcMask.CreateBitmap(cx, cy, 1, 1, NULL);
|
|
dcMask.BitBlt(0, 0, cx, cy, &dcImage, 0, 0, SRCCOPY);
|
|
|
|
// Mask the image to 'this' DC
|
|
BitBlt(x, y, cx, cy, &dcImage, 0, 0, SRCINVERT);
|
|
BitBlt(x, y, cx, cy, &dcMask, 0, 0, SRCAND);
|
|
BitBlt(x, y, cx, cy, &dcImage, 0, 0, SRCINVERT);
|
|
}
|
|
|
|
inline CDC* CDC::AddTempHDC(HDC hDC, HWND hWnd)
|
|
// Returns the CDC object associated with the device context handle
|
|
// The HDC is removed when the CDC is destroyed
|
|
{
|
|
assert( GetApp() );
|
|
CDC* pDC = new CDC;
|
|
pDC->m_pData->hDC = hDC;
|
|
GetApp()->AddTmpDC(pDC);
|
|
pDC->m_pData->bRemoveHDC = TRUE;
|
|
pDC->m_pData->hWnd = hWnd;
|
|
return pDC;
|
|
}
|
|
|
|
inline void CDC::GradientFill(COLORREF Color1, COLORREF Color2, const RECT& rc, BOOL bVertical)
|
|
// An efficient color gradient filler compatible with all Windows operating systems
|
|
{
|
|
int Width = rc.right - rc.left;
|
|
int Height = rc.bottom - rc.top;
|
|
|
|
int r1 = GetRValue(Color1);
|
|
int g1 = GetGValue(Color1);
|
|
int b1 = GetBValue(Color1);
|
|
|
|
int r2 = GetRValue(Color2);
|
|
int g2 = GetGValue(Color2);
|
|
int b2 = GetBValue(Color2);
|
|
|
|
COLORREF OldBkColor = GetBkColor();
|
|
|
|
if (bVertical)
|
|
{
|
|
for(int i=0; i < Width; ++i)
|
|
{
|
|
int r = r1 + (i * (r2-r1) / Width);
|
|
int g = g1 + (i * (g2-g1) / Width);
|
|
int b = b1 + (i * (b2-b1) / Width);
|
|
SetBkColor(RGB(r, g, b));
|
|
CRect line( i + rc.left, rc.top, i + 1 + rc.left, rc.top+Height);
|
|
ExtTextOut(0, 0, ETO_OPAQUE, line, NULL, 0, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int i=0; i < Height; ++i)
|
|
{
|
|
int r = r1 + (i * (r2-r1) / Height);
|
|
int g = g1 + (i * (g2-g1) / Height);
|
|
int b = b1 + (i * (b2-b1) / Height);
|
|
SetBkColor(RGB(r, g, b));
|
|
CRect line(rc.left, i + rc.top, rc.left+Width, i + 1 + rc.top);
|
|
ExtTextOut(0, 0, ETO_OPAQUE, line, NULL, 0, 0);
|
|
}
|
|
}
|
|
|
|
SetBkColor(OldBkColor);
|
|
}
|
|
|
|
inline void CDC::Release()
|
|
{
|
|
GetApp()->m_csMapLock.Lock();
|
|
|
|
if (m_pData->Count)
|
|
{
|
|
if (InterlockedDecrement(&m_pData->Count) == 0)
|
|
{
|
|
Destroy();
|
|
delete m_pData;
|
|
m_pData = 0;
|
|
}
|
|
}
|
|
|
|
GetApp()->m_csMapLock.Release();
|
|
}
|
|
|
|
inline BOOL CDC::RemoveFromMap()
|
|
{
|
|
BOOL Success = FALSE;
|
|
|
|
if( GetApp() )
|
|
{
|
|
// Allocate an iterator for our HDC map
|
|
std::map<HDC, CDC*, CompareHDC>::iterator m;
|
|
|
|
CWinApp* pApp = GetApp();
|
|
if (pApp)
|
|
{
|
|
// Erase the CDC pointer entry from the map
|
|
pApp->m_csMapLock.Lock();
|
|
m = pApp->m_mapHDC.find(m_pData->hDC);
|
|
if (m != pApp->m_mapHDC.end())
|
|
{
|
|
pApp->m_mapHDC.erase(m);
|
|
Success = TRUE;
|
|
}
|
|
|
|
pApp->m_csMapLock.Release();
|
|
}
|
|
}
|
|
return Success;
|
|
}
|
|
|
|
inline void CDC::SolidFill(COLORREF Color, const RECT& rc)
|
|
// Fills a rectangle with a solid color
|
|
{
|
|
COLORREF OldColor = SetBkColor(Color);
|
|
ExtTextOut(0, 0, ETO_OPAQUE, &rc, NULL, 0, 0);
|
|
SetBkColor(OldColor);
|
|
}
|
|
|
|
// Bitmap functions
|
|
inline CBitmap* CDC::CreateCompatibleBitmap(CDC* pDC, int cx, int cy)
|
|
// Creates a compatible bitmap and selects it into the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
pBitmap->CreateCompatibleBitmap(pDC, cx, cy);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
return SelectObject(pBitmap);
|
|
}
|
|
|
|
inline CBitmap* CDC::CreateBitmap(int cx, int cy, UINT Planes, UINT BitsPerPixel, LPCVOID pvColors)
|
|
// Creates a bitmap and selects it into the device context.
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
pBitmap->CreateBitmap(cx, cy, Planes, BitsPerPixel, pvColors);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
return SelectObject(pBitmap);
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline CBitmap* CDC::CreateBitmapIndirect (LPBITMAP lpBitmap)
|
|
// Creates a bitmap and selects it into the device context.
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
pBitmap->CreateBitmapIndirect(lpBitmap);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
return SelectObject(pBitmap);
|
|
}
|
|
|
|
inline CBitmap* CDC::CreateDIBitmap(CDC* pDC, const BITMAPINFOHEADER& bmih, DWORD fdwInit, LPCVOID lpbInit,
|
|
BITMAPINFO& bmi, UINT fuUsage)
|
|
// Creates a bitmap and selects it into the device context.
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
pBitmap->CreateDIBitmap(pDC, &bmih, fdwInit, lpbInit, &bmi, fuUsage);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
return SelectObject(pBitmap);
|
|
}
|
|
#endif
|
|
|
|
inline CBitmap* CDC::CreateDIBSection(CDC* pDC, const BITMAPINFO& bmi, UINT iUsage, LPVOID *ppvBits,
|
|
HANDLE hSection, DWORD dwOffset)
|
|
// Creates a bitmap and selects it into the device context.
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
pBitmap->CreateDIBSection(pDC, &bmi, iUsage, ppvBits, hSection, dwOffset);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
return SelectObject(pBitmap);
|
|
}
|
|
|
|
inline void CDC::Destroy()
|
|
// Deletes or releases the device context and returns the CDC object to its
|
|
// default state, ready for reuse.
|
|
{
|
|
if (m_pData->hDC)
|
|
{
|
|
RemoveFromMap();
|
|
if (m_pData->bRemoveHDC)
|
|
{
|
|
// Return the DC back to its initial state
|
|
::RestoreDC(m_pData->hDC, m_pData->nSavedDCState);
|
|
|
|
// We need to release a Window DC, and delete a memory DC
|
|
if (m_pData->hWnd)
|
|
::ReleaseDC(m_pData->hWnd, m_pData->hDC);
|
|
else
|
|
if (!::DeleteDC(m_pData->hDC))
|
|
::ReleaseDC(NULL, m_pData->hDC);
|
|
|
|
m_pData->hDC = 0;
|
|
m_pData->hWnd = 0;
|
|
m_pData->bRemoveHDC = TRUE;
|
|
}
|
|
}
|
|
|
|
// RemoveFromMap();
|
|
}
|
|
|
|
inline BITMAP CDC::GetBitmapData() const
|
|
// Retrieves the BITMAP information for the current HBITMAP.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
HBITMAP hbm = (HBITMAP)::GetCurrentObject(m_pData->hDC, OBJ_BITMAP);
|
|
BITMAP bm = {0};
|
|
::GetObject(hbm, sizeof(bm), &bm);
|
|
return bm;
|
|
}
|
|
|
|
inline CBitmap* CDC::LoadBitmap(UINT nID)
|
|
// Loads a bitmap from the resource and selects it into the device context
|
|
{
|
|
return LoadBitmap(MAKEINTRESOURCE(nID));
|
|
}
|
|
|
|
inline CBitmap* CDC::LoadBitmap(LPCTSTR lpszName)
|
|
// Loads a bitmap from the resource and selects it into the device context
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
BOOL bResult = pBitmap->LoadBitmap(lpszName);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
|
|
return bResult? SelectObject(pBitmap) : NULL;
|
|
}
|
|
|
|
inline CBitmap* CDC::LoadImage(UINT nID, int cxDesired, int cyDesired, UINT fuLoad)
|
|
// Loads a bitmap from the resource and selects it into the device context
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
return LoadImage(nID, cxDesired, cyDesired, fuLoad);
|
|
}
|
|
|
|
inline CBitmap* CDC::LoadImage(LPCTSTR lpszName, int cxDesired, int cyDesired, UINT fuLoad)
|
|
// Loads a bitmap from the resource and selects it into the device context
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
BOOL bResult = pBitmap->LoadImage(lpszName, cxDesired, cyDesired, fuLoad);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
return bResult? SelectObject(pBitmap) : NULL;
|
|
}
|
|
|
|
inline CBitmap* CDC::LoadOEMBitmap(UINT nIDBitmap) // for OBM_/OCR_/OIC_
|
|
// Loads a predefined system bitmap and selects it into the device context
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
BOOL bResult = pBitmap->LoadOEMBitmap(nIDBitmap);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
return bResult? SelectObject(pBitmap) : NULL;
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline CBitmap* CDC::CreateMappedBitmap(UINT nIDBitmap, UINT nFlags /*= 0*/, LPCOLORMAP lpColorMap /*= NULL*/, int nMapSize /*= 0*/)
|
|
// creates and selects a new bitmap using the bitmap data and colors specified by the bitmap resource and the color mapping information.
|
|
// Returns a pointer to the old bitmap selected out of the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBitmap* pBitmap = new CBitmap;
|
|
pBitmap->CreateMappedBitmap(nIDBitmap, (WORD)nFlags, lpColorMap, nMapSize);
|
|
m_pData->m_vGDIObjects.push_back(pBitmap);
|
|
return SelectObject(pBitmap);
|
|
}
|
|
#endif // !_WIN32_WCE
|
|
|
|
|
|
// Brush functions
|
|
#ifndef _WIN32_WCE
|
|
inline CBrush* CDC::CreateBrushIndirect(LPLOGBRUSH pLogBrush)
|
|
// Creates the brush and selects it into the device context.
|
|
// Returns a pointer to the old brush selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBrush* pBrush = new CBrush;
|
|
pBrush->CreateBrushIndirect(pLogBrush);
|
|
m_pData->m_vGDIObjects.push_back(pBrush);
|
|
return SelectObject(pBrush);
|
|
}
|
|
|
|
inline CBrush* CDC::CreateHatchBrush(int fnStyle, COLORREF rgb)
|
|
// Creates a brush with the specified hatch pattern and color, and selects it into the device context.
|
|
// Returns a pointer to the old brush selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBrush* pBrush = new CBrush;
|
|
pBrush->CreateHatchBrush(fnStyle, rgb);
|
|
m_pData->m_vGDIObjects.push_back(pBrush);
|
|
return SelectObject(pBrush);
|
|
}
|
|
|
|
inline CBrush* CDC::CreateDIBPatternBrush(HGLOBAL hglbDIBPacked, UINT fuColorSpec)
|
|
// Creates a logical from the specified device-independent bitmap (DIB), and selects it into the device context.
|
|
// Returns a pointer to the old brush selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBrush* pBrush = new CBrush;
|
|
pBrush->CreateDIBPatternBrush(hglbDIBPacked, fuColorSpec);
|
|
m_pData->m_vGDIObjects.push_back(pBrush);
|
|
return SelectObject(pBrush);
|
|
}
|
|
|
|
inline CBrush* CDC::CreateDIBPatternBrushPt(LPCVOID lpPackedDIB, UINT iUsage)
|
|
// Creates a logical from the specified device-independent bitmap (DIB), and selects it into the device context.
|
|
// Returns a pointer to the old brush selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBrush* pBrush = new CBrush;
|
|
pBrush->CreateDIBPatternBrushPt(lpPackedDIB, iUsage);
|
|
m_pData->m_vGDIObjects.push_back(pBrush);
|
|
return SelectObject(pBrush);
|
|
}
|
|
#endif
|
|
|
|
inline CBrush* CDC::CreatePatternBrush(CBitmap* pBitmap)
|
|
// Creates the brush with the specified pattern, and selects it into the device context.
|
|
// Returns a pointer to the old brush selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pBitmap);
|
|
|
|
CBrush* pBrush = new CBrush;
|
|
pBrush->CreatePatternBrush(pBitmap);
|
|
m_pData->m_vGDIObjects.push_back(pBrush);
|
|
return SelectObject(pBrush);
|
|
}
|
|
|
|
inline CBrush* CDC::CreateSolidBrush(COLORREF rgb)
|
|
// Creates the brush with the specified color, and selects it into the device context.
|
|
// Returns a pointer to the old brush selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CBrush* pBrush = new CBrush;
|
|
pBrush->CreateSolidBrush(rgb);
|
|
m_pData->m_vGDIObjects.push_back(pBrush);
|
|
return SelectObject(pBrush);
|
|
}
|
|
|
|
inline LOGBRUSH CDC::GetLogBrush() const
|
|
// Retrieves the current brush information
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
HBRUSH hBrush = (HBRUSH)::GetCurrentObject(m_pData->hDC, OBJ_BRUSH);
|
|
LOGBRUSH lBrush = {0};
|
|
::GetObject(hBrush, sizeof(lBrush), &lBrush);
|
|
return lBrush;
|
|
}
|
|
|
|
|
|
// Font functions
|
|
#ifndef _WIN32_WCE
|
|
inline CFont* CDC::CreateFont (
|
|
int nHeight, // height of font
|
|
int nWidth, // average character width
|
|
int nEscapement, // angle of escapement
|
|
int nOrientation, // base-line orientation angle
|
|
int fnWeight, // font weight
|
|
DWORD fdwItalic, // italic attribute option
|
|
DWORD fdwUnderline, // underline attribute option
|
|
DWORD fdwStrikeOut, // strikeout attribute option
|
|
DWORD fdwCharSet, // character set identifier
|
|
DWORD fdwOutputPrecision, // output precision
|
|
DWORD fdwClipPrecision, // clipping precision
|
|
DWORD fdwQuality, // output quality
|
|
DWORD fdwPitchAndFamily, // pitch and family
|
|
LPCTSTR lpszFace // typeface name
|
|
)
|
|
|
|
// Creates a logical font with the specified characteristics.
|
|
// Returns a pointer to the old font selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CFont* pFont = new CFont;
|
|
pFont->CreateFont (nHeight, nWidth, nEscapement, nOrientation, fnWeight,
|
|
fdwItalic, fdwUnderline, fdwStrikeOut, fdwCharSet,
|
|
fdwOutputPrecision, fdwClipPrecision, fdwQuality,
|
|
fdwPitchAndFamily, lpszFace);
|
|
m_pData->m_vGDIObjects.push_back(pFont);
|
|
return SelectObject(pFont);
|
|
}
|
|
#endif
|
|
|
|
inline CFont* CDC::CreateFontIndirect(LPLOGFONT plf)
|
|
// Creates a logical font and selects it into the device context.
|
|
// Returns a pointer to the old font selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CFont* pFont = new CFont;
|
|
pFont->CreateFontIndirect(plf);
|
|
m_pData->m_vGDIObjects.push_back(pFont);
|
|
return SelectObject(pFont);
|
|
}
|
|
|
|
inline LOGFONT CDC::GetLogFont() const
|
|
// Retrieves the current font information.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
HFONT hFont = (HFONT)::GetCurrentObject(m_pData->hDC, OBJ_FONT);
|
|
LOGFONT lFont = {0};
|
|
::GetObject(hFont, sizeof(lFont), &lFont);
|
|
return lFont;
|
|
}
|
|
|
|
// Pen functions
|
|
inline CPen* CDC::CreatePen (int nStyle, int nWidth, COLORREF rgb)
|
|
// Creates the pen and selects it into the device context.
|
|
// Returns a pointer to the old pen selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CPen* pPen = new CPen;
|
|
pPen->CreatePen(nStyle, nWidth, rgb);
|
|
m_pData->m_vGDIObjects.push_back(pPen);
|
|
return SelectObject(pPen);
|
|
}
|
|
|
|
inline CPen* CDC::CreatePenIndirect (LPLOGPEN pLogPen)
|
|
// Creates the pen and selects it into the device context.
|
|
// Returns a pointer to the old pen selected out of the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CPen* pPen = new CPen;
|
|
pPen->CreatePenIndirect(pLogPen);
|
|
m_pData->m_vGDIObjects.push_back(pPen);
|
|
return SelectObject(pPen);
|
|
}
|
|
|
|
inline LOGPEN CDC::GetLogPen() const
|
|
// Retrieves the current pen information as a LOGPEN
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
HPEN hPen = (HPEN)::GetCurrentObject(m_pData->hDC, OBJ_PEN);
|
|
LOGPEN lPen = {0};
|
|
::GetObject(hPen, sizeof(lPen), &lPen);
|
|
return lPen;
|
|
}
|
|
|
|
// Region functions
|
|
inline int CDC::CreateRectRgn(int left, int top, int right, int bottom)
|
|
// Creates a rectangular region from the rectangle co-ordinates.
|
|
// The return value specifies the region's complexity: NULLREGION;SIMPLEREGION;COMPLEXREGION;ERROR.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CRgn* pRgn = new CRgn;
|
|
pRgn->CreateRectRgn(left, top, right, bottom);
|
|
m_pData->m_vGDIObjects.push_back(pRgn);
|
|
return SelectClipRgn(pRgn);
|
|
}
|
|
|
|
inline int CDC::CreateRectRgnIndirect(const RECT& rc)
|
|
// Creates a rectangular region from the rectangle co-ordinates.
|
|
// The return value specifies the region's complexity: NULLREGION;SIMPLEREGION;COMPLEXREGION;ERROR.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CRgn* pRgn = new CRgn;
|
|
pRgn->CreateRectRgnIndirect(rc);
|
|
m_pData->m_vGDIObjects.push_back(pRgn);
|
|
return SelectClipRgn(pRgn);
|
|
}
|
|
|
|
inline int CDC::CreateFromData(const XFORM* Xform, DWORD nCount, const RGNDATA *pRgnData)
|
|
// Creates a region from the specified region data and tranformation data.
|
|
// The return value specifies the region's complexity: NULLREGION;SIMPLEREGION;COMPLEXREGION;ERROR.
|
|
// Notes: GetRegionData can be used to get a region's data
|
|
// If the XFROM pointer is NULL, the identity transformation is used.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CRgn* pRgn = new CRgn;
|
|
pRgn->CreateFromData(Xform, nCount, pRgnData);
|
|
m_pData->m_vGDIObjects.push_back(pRgn);
|
|
return SelectClipRgn(pRgn);
|
|
}
|
|
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline int CDC::CreateEllipticRgn(int left, int top, int right, int bottom)
|
|
// Creates the ellyiptical region from the bounding rectangle co-ordinates
|
|
// and selects it into the device context.
|
|
// The return value specifies the region's complexity: NULLREGION;SIMPLEREGION;COMPLEXREGION;ERROR.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CRgn* pRgn = new CRgn;
|
|
pRgn->CreateEllipticRgn(left, top, right, bottom);
|
|
m_pData->m_vGDIObjects.push_back(pRgn);
|
|
return SelectClipRgn(pRgn);
|
|
}
|
|
|
|
inline int CDC::CreateEllipticRgnIndirect(const RECT& rc)
|
|
// Creates the ellyiptical region from the bounding rectangle co-ordinates
|
|
// and selects it into the device context.
|
|
// The return value specifies the region's complexity: NULLREGION;SIMPLEREGION;COMPLEXREGION;ERROR.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CRgn* pRgn = new CRgn;
|
|
pRgn->CreateEllipticRgnIndirect(rc);
|
|
m_pData->m_vGDIObjects.push_back(pRgn);
|
|
return SelectClipRgn(pRgn);
|
|
}
|
|
|
|
inline int CDC::CreatePolygonRgn(LPPOINT ppt, int cPoints, int fnPolyFillMode)
|
|
// Creates the polygon region from the array of points and selects it into
|
|
// the device context. The polygon is presumed closed.
|
|
// The return value specifies the region's complexity: NULLREGION;SIMPLEREGION;COMPLEXREGION;ERROR.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CRgn* pRgn = new CRgn;
|
|
pRgn->CreatePolygonRgn(ppt, cPoints, fnPolyFillMode);
|
|
m_pData->m_vGDIObjects.push_back(pRgn);
|
|
return SelectClipRgn(pRgn);
|
|
}
|
|
|
|
inline int CDC::CreatePolyPolygonRgn(LPPOINT ppt, LPINT pPolyCounts, int nCount, int fnPolyFillMode)
|
|
// Creates the polygon region from a series of polygons.The polygons can overlap.
|
|
// The return value specifies the region's complexity: NULLREGION;SIMPLEREGION;COMPLEXREGION;ERROR.
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
CRgn* pRgn = new CRgn;
|
|
pRgn->CreatePolyPolygonRgn(ppt, pPolyCounts, nCount, fnPolyFillMode);
|
|
m_pData->m_vGDIObjects.push_back(pRgn);
|
|
return SelectClipRgn(pRgn);
|
|
}
|
|
#endif
|
|
|
|
|
|
// Wrappers for WinAPI functions
|
|
|
|
inline int CDC::GetDeviceCaps (int nIndex) const
|
|
// Retrieves device-specific information for the specified device.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetDeviceCaps(m_pData->hDC, nIndex);
|
|
}
|
|
|
|
// Brush Functions
|
|
#ifdef GetDCBrushColor
|
|
inline COLORREF CDC::GetDCBrushColor() const
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetDCBrushColor(m_pData->hDC);
|
|
}
|
|
|
|
inline COLORREF CDC::SetDCBrushColor(COLORREF crColor) const
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetDCBrushColor(m_pData->hDC, crColor);
|
|
}
|
|
#endif
|
|
|
|
// Clipping functions
|
|
inline int CDC::ExcludeClipRect(int Left, int Top, int Right, int BottomRect)
|
|
// Creates a new clipping region that consists of the existing clipping region minus the specified rectangle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::ExcludeClipRect(m_pData->hDC, Left, Top, Right, BottomRect);
|
|
}
|
|
|
|
inline int CDC::ExcludeClipRect(const RECT& rc)
|
|
// Creates a new clipping region that consists of the existing clipping region minus the specified rectangle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::ExcludeClipRect(m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom);
|
|
}
|
|
|
|
inline int CDC::GetClipBox (RECT& rc)
|
|
// Retrieves the dimensions of the tightest bounding rectangle that can be drawn around the current visible area on the device.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetClipBox(m_pData->hDC, &rc);
|
|
}
|
|
|
|
inline int CDC::GetClipRgn(HRGN hrgn)
|
|
// Retrieves a handle identifying the current application-defined clipping region for the specified device context.
|
|
// hrgn: A handle to an existing region before the function is called.
|
|
// After the function returns, this parameter is a handle to a copy of the current clipping region.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetClipRgn(m_pData->hDC, hrgn);
|
|
}
|
|
|
|
inline int CDC::IntersectClipRect(int Left, int Top, int Right, int Bottom)
|
|
// Creates a new clipping region from the intersection of the current clipping region and the specified rectangle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::IntersectClipRect(m_pData->hDC, Left, Top, Right, Bottom);
|
|
}
|
|
|
|
inline int CDC::IntersectClipRect(const RECT& rc)
|
|
// Creates a new clipping region from the intersection of the current clipping region and the specified rectangle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::IntersectClipRect(m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom);
|
|
}
|
|
|
|
inline BOOL CDC::RectVisible(const RECT& rc)
|
|
// Determines whether any part of the specified rectangle lies within the clipping region of a device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::RectVisible (m_pData->hDC, &rc);
|
|
}
|
|
|
|
inline int CDC::SelectClipRgn(CRgn* pRgn)
|
|
// Selects a region as the current clipping region for the specified device context.
|
|
// Note: Only a copy of the selected region is used.
|
|
// To remove a device-context's clipping region, specify a NULL region handle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SelectClipRgn(m_pData->hDC, pRgn? (HRGN)pRgn->GetHandle() : 0);
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline int CDC::ExtSelectClipRgn(CRgn* pRgn, int fnMode)
|
|
// Combines the specified region with the current clipping region using the specified mode.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pRgn);
|
|
return ::ExtSelectClipRgn(m_pData->hDC, *pRgn, fnMode);
|
|
}
|
|
#endif
|
|
|
|
inline CBitmap* CDC::SelectObject(const CBitmap* pBitmap)
|
|
// Use this to attach an existing bitmap.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pBitmap);
|
|
|
|
return FromHandle( (HBITMAP)::SelectObject(m_pData->hDC, *pBitmap) );
|
|
}
|
|
|
|
inline CBrush* CDC::SelectObject(const CBrush* pBrush)
|
|
// Use this to attach an existing brush.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pBrush);
|
|
|
|
return FromHandle( (HBRUSH)::SelectObject(m_pData->hDC, *pBrush) );
|
|
}
|
|
|
|
inline CFont* CDC::SelectObject(const CFont* pFont)
|
|
// Use this to attach an existing font.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pFont);
|
|
|
|
return FromHandle( (HFONT)::SelectObject(m_pData->hDC, *pFont) );
|
|
}
|
|
|
|
inline CPalette* CDC::SelectObject(const CPalette* pPalette)
|
|
// Use this to attach an existing Palette.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pPalette);
|
|
|
|
return FromHandle( (HPALETTE)::SelectObject(m_pData->hDC, *pPalette) );
|
|
}
|
|
|
|
inline CPen* CDC::SelectObject(const CPen* pPen)
|
|
// Use this to attach an existing pen.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pPen);
|
|
|
|
return FromHandle( (HPEN)::SelectObject(m_pData->hDC, *pPen) );
|
|
}
|
|
|
|
inline CPalette* CDC::SelectPalette(const CPalette* pPalette, BOOL bForceBkgnd)
|
|
// Use this to attach an existing palette.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pPalette);
|
|
|
|
return FromHandle( (HPALETTE)::SelectPalette(m_pData->hDC, *pPalette, bForceBkgnd) );
|
|
}
|
|
#ifndef _WIN32_WCE
|
|
inline BOOL CDC::PtVisible(int X, int Y)
|
|
// Determines whether the specified point is within the clipping region of a device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::PtVisible (m_pData->hDC, X, Y);
|
|
}
|
|
|
|
inline int CDC::OffsetClipRgn(int nXOffset, int nYOffset)
|
|
// Moves the clipping region of a device context by the specified offsets.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::OffsetClipRgn (m_pData->hDC, nXOffset, nYOffset);
|
|
}
|
|
#endif
|
|
|
|
// Point and Line Drawing Functions
|
|
inline CPoint CDC::GetCurrentPosition() const
|
|
// Returns the current "MoveToEx" position.
|
|
{
|
|
assert(m_pData->hDC);
|
|
CPoint pt;
|
|
::MoveToEx(m_pData->hDC, 0, 0, &pt);
|
|
::MoveToEx(m_pData->hDC, pt.x, pt.y, NULL);
|
|
return pt;
|
|
}
|
|
|
|
inline CPoint CDC::MoveTo(int x, int y) const
|
|
// Updates the current position to the specified point.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::MoveToEx(m_pData->hDC, x, y, NULL);
|
|
}
|
|
|
|
inline CPoint CDC::MoveTo(POINT pt) const
|
|
// Updates the current position to the specified point
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::MoveToEx(m_pData->hDC, pt.x, pt.y, NULL);
|
|
}
|
|
|
|
inline BOOL CDC::LineTo(int x, int y) const
|
|
// Draws a line from the current position up to, but not including, the specified point.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::LineTo(m_pData->hDC, x, y);
|
|
}
|
|
|
|
inline BOOL CDC::LineTo(POINT pt) const
|
|
// Draws a line from the current position up to, but not including, the specified point.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::LineTo(m_pData->hDC, pt.x, pt.y);
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline BOOL CDC::Arc(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) const
|
|
// Draws an elliptical arc.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Arc(m_pData->hDC, x1, y1, x2, y2, x3, y3, x4, y4);
|
|
}
|
|
|
|
inline BOOL CDC::Arc(RECT& rc, POINT ptStart, POINT ptEnd) const
|
|
// Draws an elliptical arc.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Arc(m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom,
|
|
ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
|
|
}
|
|
|
|
inline BOOL CDC::ArcTo(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) const
|
|
// Draws an elliptical arc.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::ArcTo(m_pData->hDC, x1, y1, x2, y2, x3, y3, x4, y4);
|
|
}
|
|
|
|
inline BOOL CDC::ArcTo(RECT& rc, POINT ptStart, POINT ptEnd) const
|
|
// Draws an elliptical arc.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::ArcTo (m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom,
|
|
ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
|
|
}
|
|
|
|
inline BOOL CDC::AngleArc(int x, int y, int nRadius, float fStartAngle, float fSweepAngle) const
|
|
// Draws a line segment and an arc.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::AngleArc(m_pData->hDC, x, y, nRadius, fStartAngle, fSweepAngle);
|
|
}
|
|
|
|
inline int CDC::GetArcDirection() const
|
|
// Retrieves the current arc direction ( AD_COUNTERCLOCKWISE or AD_CLOCKWISE ).
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetArcDirection(m_pData->hDC);
|
|
}
|
|
|
|
inline int CDC::SetArcDirection(int nArcDirection) const
|
|
// Sets the current arc direction ( AD_COUNTERCLOCKWISE or AD_CLOCKWISE ).
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetArcDirection(m_pData->hDC, nArcDirection);
|
|
}
|
|
|
|
inline BOOL CDC::PolyDraw(const POINT* lpPoints, const BYTE* lpTypes, int nCount) const
|
|
// Draws a set of line segments and Bzier curves.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::PolyDraw(m_pData->hDC, lpPoints, lpTypes, nCount);
|
|
}
|
|
|
|
inline BOOL CDC::Polyline(LPPOINT lpPoints, int nCount) const
|
|
// Draws a series of line segments by connecting the points in the specified array.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Polyline(m_pData->hDC, lpPoints, nCount);
|
|
}
|
|
|
|
inline BOOL CDC::PolyPolyline(const POINT* lpPoints, const DWORD* lpPolyPoints, int nCount) const
|
|
// Draws multiple series of connected line segments.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::PolyPolyline(m_pData->hDC, lpPoints, lpPolyPoints, nCount);
|
|
}
|
|
|
|
inline BOOL CDC::PolylineTo(const POINT* lpPoints, int nCount) const
|
|
// Draws one or more straight lines.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::PolylineTo(m_pData->hDC, lpPoints, nCount);
|
|
}
|
|
inline BOOL CDC::PolyBezier(const POINT* lpPoints, int nCount) const
|
|
// Draws one or more Bzier curves.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::PolyBezier(m_pData->hDC, lpPoints, nCount);
|
|
}
|
|
|
|
inline BOOL CDC::PolyBezierTo(const POINT* lpPoints, int nCount) const
|
|
// Draws one or more Bzier curves.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::PolyBezierTo(m_pData->hDC, lpPoints, nCount );
|
|
}
|
|
|
|
inline COLORREF CDC::GetPixel(int x, int y) const
|
|
// Retrieves the red, green, blue (RGB) color value of the pixel at the specified coordinates.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetPixel(m_pData->hDC, x, y);
|
|
}
|
|
|
|
inline COLORREF CDC::GetPixel(POINT pt) const
|
|
// Retrieves the red, green, blue (RGB) color value of the pixel at the specified coordinates.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetPixel(m_pData->hDC, pt.x, pt.y);
|
|
}
|
|
|
|
inline COLORREF CDC::SetPixel (int x, int y, COLORREF crColor) const
|
|
// Sets the pixel at the specified coordinates to the specified color.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetPixel(m_pData->hDC, x, y, crColor);
|
|
}
|
|
|
|
inline COLORREF CDC::SetPixel(POINT pt, COLORREF crColor) const
|
|
// Sets the pixel at the specified coordinates to the specified color.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetPixel(m_pData->hDC, pt.x, pt.y, crColor);
|
|
}
|
|
|
|
inline BOOL CDC::SetPixelV(int x, int y, COLORREF crColor) const
|
|
// Sets the pixel at the specified coordinates to the closest approximation of the specified color.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetPixelV(m_pData->hDC, x, y, crColor);
|
|
}
|
|
|
|
inline BOOL CDC::SetPixelV(POINT pt, COLORREF crColor) const
|
|
// Sets the pixel at the specified coordinates to the closest approximation of the specified color.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetPixelV(m_pData->hDC, pt.x, pt.y, crColor);
|
|
}
|
|
#endif
|
|
|
|
// Shape Drawing Functions
|
|
inline void CDC::DrawFocusRect(const RECT& rc) const
|
|
// Draws a rectangle in the style used to indicate that the rectangle has the focus.
|
|
{
|
|
assert(m_pData->hDC);
|
|
::DrawFocusRect(m_pData->hDC, &rc);
|
|
}
|
|
|
|
inline BOOL CDC::Ellipse(int x1, int y1, int x2, int y2) const
|
|
// Draws an ellipse. The center of the ellipse is the center of the specified bounding rectangle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Ellipse(m_pData->hDC, x1, y1, x2, y2);
|
|
}
|
|
|
|
inline BOOL CDC::Ellipse(const RECT& rc) const
|
|
// Draws an ellipse. The center of the ellipse is the center of the specified bounding rectangle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Ellipse(m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom);
|
|
}
|
|
|
|
inline BOOL CDC::Polygon(LPPOINT lpPoints, int nCount) const
|
|
// Draws a polygon consisting of two or more vertices connected by straight lines.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Polygon(m_pData->hDC, lpPoints, nCount);
|
|
}
|
|
|
|
inline BOOL CDC::Rectangle(int x1, int y1, int x2, int y2) const
|
|
// Draws a rectangle. The rectangle is outlined by using the current pen and filled by using the current brush.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Rectangle(m_pData->hDC, x1, y1, x2, y2);
|
|
}
|
|
|
|
inline BOOL CDC::Rectangle(const RECT& rc) const
|
|
// Draws a rectangle. The rectangle is outlined by using the current pen and filled by using the current brush.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Rectangle(m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom);
|
|
}
|
|
|
|
inline BOOL CDC::RoundRect(int x1, int y1, int x2, int y2, int nWidth, int nHeight) const
|
|
// Draws a rectangle with rounded corners.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::RoundRect(m_pData->hDC, x1, y1, x2, y2, nWidth, nHeight);
|
|
}
|
|
inline BOOL CDC::RoundRect(const RECT& rc, int nWidth, int nHeight) const
|
|
// Draws a rectangle with rounded corners.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::RoundRect(m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom, nWidth, nHeight );
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline BOOL CDC::Chord(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) const
|
|
// Draws a chord (a region bounded by the intersection of an ellipse and a line segment, called a secant).
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Chord(m_pData->hDC, x1, y1, x2, y2, x3, y3, x4, y4);
|
|
}
|
|
|
|
inline BOOL CDC::Chord(const RECT& rc, POINT ptStart, POINT ptEnd) const
|
|
// Draws a chord (a region bounded by the intersection of an ellipse and a line segment, called a secant).
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Chord(m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom,
|
|
ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
|
|
}
|
|
|
|
inline BOOL CDC::Pie(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) const
|
|
// Draws a pie-shaped wedge bounded by the intersection of an ellipse and two radials.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Pie(m_pData->hDC, x1, y1, x2, y2, x3, y3, x4, y4);
|
|
}
|
|
|
|
inline BOOL CDC::Pie(const RECT& rc, POINT ptStart, POINT ptEnd) const
|
|
// Draws a pie-shaped wedge bounded by the intersection of an ellipse and two radials.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::Pie(m_pData->hDC, rc.left, rc.top, rc.right, rc.bottom,
|
|
ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
|
|
}
|
|
|
|
inline BOOL CDC::PolyPolygon(LPPOINT lpPoints, LPINT lpPolyCounts, int nCount) const
|
|
// Draws a series of closed polygons.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::PolyPolygon(m_pData->hDC, lpPoints, lpPolyCounts, nCount);
|
|
}
|
|
#endif
|
|
|
|
// Fill and 3D Drawing functions
|
|
inline BOOL CDC::FillRect(const RECT& rc, CBrush* pBrush) const
|
|
// Fills a rectangle by using the specified brush.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pBrush);
|
|
return (BOOL)::FillRect(m_pData->hDC, &rc, *pBrush);
|
|
}
|
|
|
|
inline BOOL CDC::InvertRect(const RECT& rc) const
|
|
// Inverts a rectangle in a window by performing a logical NOT operation on the color values for each pixel in the rectangle's interior.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::InvertRect( m_pData->hDC, &rc);
|
|
}
|
|
|
|
inline BOOL CDC::DrawIconEx(int xLeft, int yTop, HICON hIcon, int cxWidth, int cyWidth, UINT istepIfAniCur, CBrush* pFlickerFreeDraw, UINT diFlags) const
|
|
// draws an icon or cursor, performing the specified raster operations, and stretching or compressing the icon or cursor as specified.
|
|
{
|
|
assert(m_pData->hDC);
|
|
HBRUSH hFlickerFreeDraw = pFlickerFreeDraw? (HBRUSH)pFlickerFreeDraw->GetHandle() : NULL;
|
|
return ::DrawIconEx(m_pData->hDC, xLeft, yTop, hIcon, cxWidth, cyWidth, istepIfAniCur, hFlickerFreeDraw, diFlags);
|
|
}
|
|
|
|
inline BOOL CDC::DrawEdge(const RECT& rc, UINT nEdge, UINT nFlags) const
|
|
// Draws one or more edges of rectangle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::DrawEdge(m_pData->hDC, (LPRECT)&rc, nEdge, nFlags);
|
|
}
|
|
|
|
inline BOOL CDC::DrawFrameControl(const RECT& rc, UINT nType, UINT nState) const
|
|
// Draws a frame control of the specified type and style.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::DrawFrameControl(m_pData->hDC, (LPRECT)&rc, nType, nState);
|
|
}
|
|
|
|
inline BOOL CDC::FillRgn(CRgn* pRgn, CBrush* pBrush) const
|
|
// Fills a region by using the specified brush.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pRgn);
|
|
assert(pBrush);
|
|
return ::FillRgn(m_pData->hDC, *pRgn, *pBrush);
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline BOOL CDC::DrawIcon(int x, int y, HICON hIcon) const
|
|
// Draws an icon or cursor.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::DrawIcon(m_pData->hDC, x, y, hIcon);
|
|
}
|
|
|
|
inline BOOL CDC::DrawIcon(POINT pt, HICON hIcon) const
|
|
// Draws an icon or cursor.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::DrawIcon(m_pData->hDC, pt.x, pt.y, hIcon);
|
|
}
|
|
|
|
inline BOOL CDC::FrameRect(const RECT& rc, CBrush* pBrush) const
|
|
// Draws a border around the specified rectangle by using the specified brush.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pBrush);
|
|
return (BOOL)::FrameRect(m_pData->hDC, &rc, *pBrush);
|
|
}
|
|
|
|
inline BOOL CDC::PaintRgn(CRgn* pRgn) const
|
|
// Paints the specified region by using the brush currently selected into the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pRgn);
|
|
return ::PaintRgn(m_pData->hDC, *pRgn);
|
|
}
|
|
#endif
|
|
|
|
// Bitmap Functions
|
|
inline int CDC::StretchDIBits(int XDest, int YDest, int nDestWidth, int nDestHeight, int XSrc, int YSrc, int nSrcWidth,
|
|
int nSrcHeight, CONST VOID *lpBits, BITMAPINFO& bi, UINT iUsage, DWORD dwRop) const
|
|
// Copies the color data for a rectangle of pixels in a DIB to the specified destination rectangle.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::StretchDIBits(m_pData->hDC, XDest, YDest, nDestWidth, nDestHeight, XSrc, YSrc, nSrcWidth, nSrcHeight, lpBits, &bi, iUsage, dwRop);
|
|
}
|
|
|
|
inline BOOL CDC::PatBlt(int x, int y, int nWidth, int nHeight, DWORD dwRop) const
|
|
// Paints the specified rectangle using the brush that is currently selected into the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::PatBlt(m_pData->hDC, x, y, nWidth, nHeight, dwRop);
|
|
}
|
|
|
|
inline BOOL CDC::BitBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC, int xSrc, int ySrc, DWORD dwRop) const
|
|
// Performs a bit-block transfer of the color data corresponding to a rectangle of pixels from the specified source device context into a destination device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pSrcDC);
|
|
return ::BitBlt(m_pData->hDC, x, y, nWidth, nHeight, pSrcDC->GetHDC(), xSrc, ySrc, dwRop);
|
|
}
|
|
|
|
inline BOOL CDC::StretchBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, DWORD dwRop) const
|
|
// Copies a bitmap from a source rectangle into a destination rectangle, stretching or compressing the bitmap to fit the dimensions of the destination rectangle, if necessary.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pSrcDC);
|
|
return ::StretchBlt(m_pData->hDC, x, y, nWidth, nHeight, pSrcDC->GetHDC(), xSrc, ySrc, nSrcWidth, nSrcHeight, dwRop);
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline int CDC::GetDIBits(CBitmap* pBitmap, UINT uStartScan, UINT cScanLines, LPVOID lpvBits, LPBITMAPINFO lpbi, UINT uUsage) const
|
|
// Retrieves the bits of the specified compatible bitmap and copies them into a buffer as a DIB using the specified format.
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pBitmap);
|
|
return ::GetDIBits(m_pData->hDC, *pBitmap, uStartScan, cScanLines, lpvBits, lpbi, uUsage);
|
|
}
|
|
|
|
inline int CDC::SetDIBits(CBitmap* pBitmap, UINT uStartScan, UINT cScanLines, CONST VOID *lpvBits, LPBITMAPINFO lpbi, UINT fuColorUse) const
|
|
// Sets the pixels in a compatible bitmap (DDB) using the color data found in the specified DIB.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetDIBits(m_pData->hDC, *pBitmap, uStartScan, cScanLines, lpvBits, lpbi, fuColorUse);
|
|
}
|
|
|
|
inline int CDC::GetStretchBltMode() const
|
|
// Retrieves the current stretching mode.
|
|
// Possible modes: BLACKONWHITE, COLORONCOLOR, HALFTONE, STRETCH_ANDSCANS, STRETCH_DELETESCANS, STRETCH_HALFTONE, STRETCH_ORSCANS, WHITEONBLACK
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetStretchBltMode(m_pData->hDC);
|
|
}
|
|
|
|
inline int CDC::SetStretchBltMode(int iStretchMode) const
|
|
// Sets the stretching mode.
|
|
// Possible modes: BLACKONWHITE, COLORONCOLOR, HALFTONE, STRETCH_ANDSCANS, STRETCH_DELETESCANS, STRETCH_HALFTONE, STRETCH_ORSCANS, WHITEONBLACK
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetStretchBltMode(m_pData->hDC, iStretchMode);
|
|
}
|
|
|
|
inline BOOL CDC::FloodFill(int x, int y, COLORREF crColor) const
|
|
// Fills an area of the display surface with the current brush.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::FloodFill(m_pData->hDC, x, y, crColor);
|
|
}
|
|
|
|
inline BOOL CDC::ExtFloodFill(int x, int y, COLORREF crColor, UINT nFillType) const
|
|
// Fills an area of the display surface with the current brush.
|
|
// Fill type: FLOODFILLBORDER or FLOODFILLSURFACE
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::ExtFloodFill(m_pData->hDC, x, y, crColor, nFillType );
|
|
}
|
|
|
|
// co-ordinate functions
|
|
inline BOOL CDC::DPtoLP(LPPOINT lpPoints, int nCount) const
|
|
// Converts device coordinates into logical coordinates.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::DPtoLP(m_pData->hDC, lpPoints, nCount);
|
|
}
|
|
|
|
inline BOOL CDC::DPtoLP(RECT& rc) const
|
|
// Converts device coordinates into logical coordinates.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::DPtoLP(m_pData->hDC, (LPPOINT)&rc, 2);
|
|
}
|
|
|
|
inline BOOL CDC::LPtoDP(LPPOINT lpPoints, int nCount) const
|
|
// Converts logical coordinates into device coordinates.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::LPtoDP(m_pData->hDC, lpPoints, nCount);
|
|
}
|
|
|
|
inline BOOL CDC::LPtoDP(RECT& rc) const
|
|
// Converts logical coordinates into device coordinates.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::LPtoDP(m_pData->hDC, (LPPOINT)&rc, 2);
|
|
}
|
|
|
|
#endif
|
|
|
|
// Layout Functions
|
|
inline DWORD CDC::GetLayout() const
|
|
// Returns the layout of a device context (LAYOUT_RTL and LAYOUT_BITMAPORIENTATIONPRESERVED).
|
|
{
|
|
#if defined(WINVER) && defined(GetLayout) && (WINVER >= 0x0500)
|
|
return ::GetLayout(m_pData->hDC);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
inline DWORD CDC::SetLayout(DWORD dwLayout) const
|
|
// changes the layout of a device context (DC).
|
|
// dwLayout values: LAYOUT_RTL or LAYOUT_BITMAPORIENTATIONPRESERVED
|
|
{
|
|
#if defined(WINVER) && defined (SetLayout) && (WINVER >= 0x0500)
|
|
// Sets the layout of a device context
|
|
return ::SetLayout(m_pData->hDC, dwLayout);
|
|
#else
|
|
UNREFERENCED_PARAMETER(dwLayout); // no-op
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
// Mapping Functions
|
|
#ifndef _WIN32_WCE
|
|
inline int CDC::GetMapMode() const
|
|
// Rretrieves the current mapping mode.
|
|
// Possible modes: MM_ANISOTROPIC, MM_HIENGLISH, MM_HIMETRIC, MM_ISOTROPIC, MM_LOENGLISH, MM_LOMETRIC, MM_TEXT, and MM_TWIPS.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetMapMode(m_pData->hDC);
|
|
}
|
|
|
|
inline BOOL CDC::GetViewportOrgEx(LPPOINT lpPoint) const
|
|
// Retrieves the x-coordinates and y-coordinates of the viewport origin for the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetViewportOrgEx(m_pData->hDC, lpPoint);
|
|
}
|
|
|
|
inline int CDC::SetMapMode(int nMapMode) const
|
|
// Sets the mapping mode of the specified device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetMapMode(m_pData->hDC, nMapMode);
|
|
}
|
|
|
|
inline BOOL CDC::SetViewportOrgEx(int x, int y, LPPOINT lpPoint /* = NULL */) const
|
|
// Specifies which device point maps to the window origin (0,0).
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetViewportOrgEx(m_pData->hDC, x, y, lpPoint);
|
|
}
|
|
|
|
inline BOOL CDC::SetViewportOrgEx(POINT point, LPPOINT lpPointRet /* = NULL */) const
|
|
// Specifies which device point maps to the window origin (0,0).
|
|
{
|
|
assert(m_pData->hDC);
|
|
return SetViewportOrgEx(point.x, point.y, lpPointRet);
|
|
}
|
|
|
|
inline BOOL CDC::OffsetViewportOrgEx(int nWidth, int nHeight, LPPOINT lpPoint /* = NULL */) const
|
|
// Modifies the viewport origin for the device context using the specified horizontal and vertical offsets.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::OffsetViewportOrgEx(m_pData->hDC, nWidth, nHeight, lpPoint);
|
|
}
|
|
|
|
inline BOOL CDC::GetViewportExtEx(LPSIZE lpSize) const
|
|
// Retrieves the x-extent and y-extent of the current viewport for the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetViewportExtEx(m_pData->hDC, lpSize);
|
|
}
|
|
|
|
inline BOOL CDC::SetViewportExtEx(int x, int y, LPSIZE lpSize ) const
|
|
// Sets the horizontal and vertical extents of the viewport for the device context by using the specified values.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetViewportExtEx(m_pData->hDC, x, y, lpSize);
|
|
}
|
|
|
|
inline BOOL CDC::SetViewportExtEx(SIZE size, LPSIZE lpSizeRet ) const
|
|
// Sets the horizontal and vertical extents of the viewport for the device context by using the specified values.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return SetViewportExtEx(size.cx, size.cy, lpSizeRet);
|
|
}
|
|
|
|
inline BOOL CDC::ScaleViewportExtEx(int xNum, int xDenom, int yNum, int yDenom, LPSIZE lpSize ) const
|
|
// Modifies the viewport for the device context using the ratios formed by the specified multiplicands and divisors.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::ScaleViewportExtEx(m_pData->hDC, xNum, xDenom, yNum, yDenom, lpSize);
|
|
}
|
|
|
|
inline BOOL CDC::GetWindowOrgEx(LPPOINT lpPoint) const
|
|
// Retrieves the x-coordinates and y-coordinates of the window origin for the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetWindowOrgEx(m_pData->hDC, lpPoint);
|
|
}
|
|
|
|
inline BOOL CDC::SetWindowOrgEx(int x, int y, LPPOINT lpPoint ) const
|
|
// Specifies which window point maps to the viewport origin (0,0).
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetWindowOrgEx(m_pData->hDC, x, y, lpPoint);
|
|
}
|
|
|
|
inline BOOL CDC::SetWindowOrgEx(POINT point, LPPOINT lpPointRet ) const
|
|
// Specifies which window point maps to the viewport origin (0,0).
|
|
{
|
|
assert(m_pData->hDC);
|
|
return SetWindowOrgEx(point.x, point.y, lpPointRet);
|
|
}
|
|
|
|
inline BOOL CDC::OffsetWindowOrgEx(int nWidth, int nHeight, LPPOINT lpPoint ) const
|
|
// Modifies the window origin for the device context using the specified horizontal and vertical offsets.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::OffsetWindowOrgEx(m_pData->hDC, nWidth, nHeight, lpPoint);
|
|
}
|
|
|
|
inline BOOL CDC::GetWindowExtEx(LPSIZE lpSize) const
|
|
// Retrieves the x-extent and y-extent of the window for the device context.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetWindowExtEx(m_pData->hDC, lpSize);
|
|
}
|
|
|
|
inline BOOL CDC::SetWindowExtEx(int x, int y, LPSIZE lpSize ) const
|
|
// Sets the horizontal and vertical extents of the window for the device context by using the specified values.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetWindowExtEx(m_pData->hDC, x, y, lpSize);
|
|
}
|
|
|
|
inline BOOL CDC::SetWindowExtEx(SIZE size, LPSIZE lpSizeRet) const
|
|
// Sets the horizontal and vertical extents of the window for the device context by using the specified values.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return SetWindowExtEx(size.cx, size.cy, lpSizeRet);
|
|
}
|
|
|
|
inline BOOL CDC::ScaleWindowExtEx(int xNum, int xDenom, int yNum, int yDenom, LPSIZE lpSize) const
|
|
// Modifies the window for the device context using the ratios formed by the specified multiplicands and divisors.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::ScaleWindowExtEx(m_pData->hDC, xNum, xDenom, yNum, yDenom, lpSize);
|
|
}
|
|
#endif
|
|
|
|
// Printer Functions
|
|
inline int CDC::StartDoc(LPDOCINFO lpDocInfo) const
|
|
// Starts a print job.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::StartDoc(m_pData->hDC, lpDocInfo);
|
|
}
|
|
|
|
inline int CDC::EndDoc() const
|
|
// Ends a print job.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::EndDoc(m_pData->hDC);
|
|
}
|
|
|
|
inline int CDC::StartPage() const
|
|
// Prepares the printer driver to accept data.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::StartPage(m_pData->hDC);
|
|
}
|
|
|
|
inline int CDC::EndPage() const
|
|
// Notifies the device that the application has finished writing to a page.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::EndPage(m_pData->hDC);
|
|
}
|
|
|
|
inline int CDC::AbortDoc() const
|
|
// Stops the current print job and erases everything drawn since the last call to the StartDoc function.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::AbortDoc(m_pData->hDC);
|
|
}
|
|
|
|
inline int CDC::SetAbortProc(BOOL (CALLBACK* lpfn)(HDC, int)) const
|
|
// Sets the application-defined abort function that allows a print job to be canceled during spooling.
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetAbortProc(m_pData->hDC, lpfn);
|
|
}
|
|
|
|
// Text Functions
|
|
inline BOOL CDC::ExtTextOut(int x, int y, UINT nOptions, LPCRECT lprc, LPCTSTR lpszString, int nCount /*= -1*/, LPINT lpDxWidths /*=NULL*/) const
|
|
// Draws text using the currently selected font, background color, and text color
|
|
{
|
|
assert(m_pData->hDC);
|
|
|
|
if (nCount == -1)
|
|
nCount = lstrlen (lpszString);
|
|
|
|
return ::ExtTextOut(m_pData->hDC, x, y, nOptions, lprc, lpszString, nCount, lpDxWidths );
|
|
}
|
|
|
|
inline int CDC::DrawText(LPCTSTR lpszString, int nCount, LPRECT lprc, UINT nFormat) const
|
|
// Draws formatted text in the specified rectangle
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::DrawText(m_pData->hDC, lpszString, nCount, lprc, nFormat );
|
|
}
|
|
|
|
inline UINT CDC::GetTextAlign() const
|
|
// Retrieves the text-alignment setting
|
|
// Values: TA_BASELINE, TA_BOTTOM, TA_TOP, TA_CENTER, TA_LEFT, TA_RIGHT, TA_RTLREADING, TA_NOUPDATECP, TA_UPDATECP
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetTextAlign(m_pData->hDC);
|
|
}
|
|
|
|
inline UINT CDC::SetTextAlign(UINT nFlags) const
|
|
// Sets the text-alignment setting
|
|
// Values: TA_BASELINE, TA_BOTTOM, TA_TOP, TA_CENTER, TA_LEFT, TA_RIGHT, TA_RTLREADING, TA_NOUPDATECP, TA_UPDATECP
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetTextAlign(m_pData->hDC, nFlags);
|
|
}
|
|
|
|
inline int CDC::GetTextFace(int nCount, LPTSTR lpszFacename) const
|
|
// Retrieves the typeface name of the font that is selected into the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetTextFace(m_pData->hDC, nCount, lpszFacename);
|
|
}
|
|
|
|
inline BOOL CDC::GetTextMetrics(TEXTMETRIC& Metrics) const
|
|
// Fills the specified buffer with the metrics for the currently selected font
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetTextMetrics(m_pData->hDC, &Metrics);
|
|
}
|
|
|
|
inline COLORREF CDC::GetBkColor() const
|
|
// Returns the current background color
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetBkColor(m_pData->hDC);
|
|
}
|
|
|
|
inline COLORREF CDC::SetBkColor(COLORREF crColor) const
|
|
// Sets the current background color to the specified color value
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetBkColor(m_pData->hDC, crColor);
|
|
}
|
|
|
|
inline COLORREF CDC::GetTextColor() const
|
|
// Retrieves the current text color
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetTextColor(m_pData->hDC);
|
|
}
|
|
|
|
inline COLORREF CDC::SetTextColor(COLORREF crColor) const
|
|
// Sets the current text color
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetTextColor(m_pData->hDC, crColor);
|
|
}
|
|
|
|
inline int CDC::GetBkMode() const
|
|
// returns the current background mix mode (OPAQUE or TRANSPARENT)
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetBkMode(m_pData->hDC);
|
|
}
|
|
|
|
inline int CDC::SetBkMode(int iBkMode) const
|
|
// Sets the current background mix mode (OPAQUE or TRANSPARENT)
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetBkMode(m_pData->hDC, iBkMode);
|
|
}
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline int CDC::DrawTextEx(LPTSTR lpszString, int nCount, LPRECT lprc, UINT nFormat, LPDRAWTEXTPARAMS lpDTParams) const
|
|
// Draws formatted text in the specified rectangle with more formatting options
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::DrawTextEx(m_pData->hDC, lpszString, nCount, lprc, nFormat, lpDTParams);
|
|
}
|
|
|
|
inline CSize CDC::GetTextExtentPoint32(LPCTSTR lpszString, int nCount) const
|
|
// Computes the width and height of the specified string of text
|
|
{
|
|
assert(m_pData->hDC);
|
|
CSize sz;
|
|
::GetTextExtentPoint32(m_pData->hDC, lpszString, nCount, &sz);
|
|
return sz;
|
|
}
|
|
|
|
inline CSize CDC::GetTabbedTextExtent(LPCTSTR lpszString, int nCount, int nTabPositions, LPINT lpnTabStopPositions) const
|
|
// Computes the width and height of a character string
|
|
{
|
|
assert(m_pData->hDC);
|
|
DWORD dwSize = ::GetTabbedTextExtent(m_pData->hDC, lpszString, nCount, nTabPositions, lpnTabStopPositions );
|
|
CSize sz(dwSize);
|
|
return sz;
|
|
}
|
|
|
|
inline BOOL CDC::GrayString(CBrush* pBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int x, int y, int nWidth, int nHeight) const
|
|
// Draws gray text at the specified location
|
|
{
|
|
assert(m_pData->hDC);
|
|
assert(pBrush);
|
|
return ::GrayString(m_pData->hDC, *pBrush, lpOutputFunc, lpData, nCount, x, y, nWidth, nHeight);
|
|
}
|
|
|
|
inline int CDC::SetTextJustification(int nBreakExtra, int nBreakCount) const
|
|
// Specifies the amount of space the system should add to the break characters in a string of text
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetTextJustification(m_pData->hDC, nBreakExtra, nBreakCount);
|
|
}
|
|
|
|
inline int CDC::GetTextCharacterExtra() const
|
|
// Retrieves the current intercharacter spacing for the device context
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::GetTextCharacterExtra(m_pData->hDC);
|
|
}
|
|
|
|
inline int CDC::SetTextCharacterExtra(int nCharExtra) const
|
|
// Sets the intercharacter spacing
|
|
{
|
|
assert(m_pData->hDC);
|
|
return ::SetTextCharacterExtra(m_pData->hDC, nCharExtra);
|
|
}
|
|
|
|
inline CSize CDC::TabbedTextOut(int x, int y, LPCTSTR lpszString, int nCount, int nTabPositions, LPINT lpnTabStopPositions, int nTabOrigin) const
|
|
// Writes a character string at a specified location, expanding tabs to the values specified in an array of tab-stop positions
|
|
{
|
|
assert(m_pData->hDC);
|
|
DWORD dwSize = ::TabbedTextOut(m_pData->hDC, x, y, lpszString, nCount, nTabPositions, lpnTabStopPositions, nTabOrigin );
|
|
CSize sz(dwSize);
|
|
return sz;
|
|
}
|
|
|
|
inline BOOL CDC::TextOut(int x, int y, LPCTSTR lpszString, int nCount/* = -1*/) const
|
|
// Writes a character string at the specified location
|
|
{
|
|
assert(m_pData->hDC);
|
|
if (nCount == -1)
|
|
nCount = lstrlen (lpszString);
|
|
|
|
return ::TextOut(m_pData->hDC, x, y, lpszString, nCount);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Definitions for some global functions in the Win32xx namespace
|
|
//
|
|
|
|
#ifndef _WIN32_WCE
|
|
inline void TintBitmap (CBitmap* pbmSource, int cRed, int cGreen, int cBlue)
|
|
// Modifies the colour of the supplied Device Dependant Bitmap, by the colour
|
|
// correction values specified. The correction values can range from -255 to +255.
|
|
// This function gains its speed by accessing the bitmap colour information
|
|
// directly, rather than using GetPixel/SetPixel.
|
|
{
|
|
// Create our LPBITMAPINFO object
|
|
CBitmapInfoPtr pbmi(pbmSource);
|
|
pbmi->bmiHeader.biBitCount = 24;
|
|
|
|
// Create the reference DC for GetDIBits to use
|
|
CMemDC MemDC(NULL);
|
|
|
|
// Use GetDIBits to create a DIB from our DDB, and extract the colour data
|
|
MemDC.GetDIBits(pbmSource, 0, pbmi->bmiHeader.biHeight, NULL, pbmi, DIB_RGB_COLORS);
|
|
std::vector<byte> vBits(pbmi->bmiHeader.biSizeImage, 0);
|
|
byte* pByteArray = &vBits[0];
|
|
|
|
MemDC.GetDIBits(pbmSource, 0, pbmi->bmiHeader.biHeight, pByteArray, pbmi, DIB_RGB_COLORS);
|
|
UINT nWidthBytes = pbmi->bmiHeader.biSizeImage/pbmi->bmiHeader.biHeight;
|
|
|
|
// Ensure sane colour correction values
|
|
cBlue = MIN(cBlue, 255);
|
|
cBlue = MAX(cBlue, -255);
|
|
cRed = MIN(cRed, 255);
|
|
cRed = MAX(cRed, -255);
|
|
cGreen = MIN(cGreen, 255);
|
|
cGreen = MAX(cGreen, -255);
|
|
|
|
// Pre-calculate the RGB modification values
|
|
int b1 = 256 - cBlue;
|
|
int g1 = 256 - cGreen;
|
|
int r1 = 256 - cRed;
|
|
|
|
int b2 = 256 + cBlue;
|
|
int g2 = 256 + cGreen;
|
|
int r2 = 256 + cRed;
|
|
|
|
// Modify the colour
|
|
int yOffset = 0;
|
|
int xOffset;
|
|
int Index;
|
|
for (int Row=0; Row < pbmi->bmiHeader.biHeight; Row++)
|
|
{
|
|
xOffset = 0;
|
|
|
|
for (int Column=0; Column < pbmi->bmiHeader.biWidth; Column++)
|
|
{
|
|
// Calculate Index
|
|
Index = yOffset + xOffset;
|
|
|
|
// Adjust the colour values
|
|
if (cBlue > 0)
|
|
pByteArray[Index] = (BYTE)(cBlue + (((pByteArray[Index] *b1)) >>8));
|
|
else if (cBlue < 0)
|
|
pByteArray[Index] = (BYTE)((pByteArray[Index] *b2) >>8);
|
|
|
|
if (cGreen > 0)
|
|
pByteArray[Index+1] = (BYTE)(cGreen + (((pByteArray[Index+1] *g1)) >>8));
|
|
else if (cGreen < 0)
|
|
pByteArray[Index+1] = (BYTE)((pByteArray[Index+1] *g2) >>8);
|
|
|
|
if (cRed > 0)
|
|
pByteArray[Index+2] = (BYTE)(cRed + (((pByteArray[Index+2] *r1)) >>8));
|
|
else if (cRed < 0)
|
|
pByteArray[Index+2] = (BYTE)((pByteArray[Index+2] *r2) >>8);
|
|
|
|
// Increment the horizontal offset
|
|
xOffset += pbmi->bmiHeader.biBitCount >> 3;
|
|
}
|
|
|
|
// Increment vertical offset
|
|
yOffset += nWidthBytes;
|
|
}
|
|
|
|
// Save the modified colour back into our source DDB
|
|
MemDC.SetDIBits(pbmSource, 0, pbmi->bmiHeader.biHeight, pByteArray, pbmi, DIB_RGB_COLORS);
|
|
}
|
|
|
|
inline void GrayScaleBitmap(CBitmap* pbmSource)
|
|
{
|
|
// Create our LPBITMAPINFO object
|
|
CBitmapInfoPtr pbmi(pbmSource);
|
|
|
|
// Create the reference DC for GetDIBits to use
|
|
CMemDC MemDC(NULL);
|
|
|
|
// Use GetDIBits to create a DIB from our DDB, and extract the colour data
|
|
MemDC.GetDIBits(pbmSource, 0, pbmi->bmiHeader.biHeight, NULL, pbmi, DIB_RGB_COLORS);
|
|
std::vector<byte> vBits(pbmi->bmiHeader.biSizeImage, 0);
|
|
byte* pByteArray = &vBits[0];
|
|
|
|
MemDC.GetDIBits(pbmSource, 0, pbmi->bmiHeader.biHeight, pByteArray, pbmi, DIB_RGB_COLORS);
|
|
UINT nWidthBytes = pbmi->bmiHeader.biSizeImage/pbmi->bmiHeader.biHeight;
|
|
|
|
int yOffset = 0;
|
|
int xOffset;
|
|
int Index;
|
|
|
|
for (int Row=0; Row < pbmi->bmiHeader.biHeight; Row++)
|
|
{
|
|
xOffset = 0;
|
|
|
|
for (int Column=0; Column < pbmi->bmiHeader.biWidth; Column++)
|
|
{
|
|
// Calculate Index
|
|
Index = yOffset + xOffset;
|
|
|
|
BYTE byGray = (BYTE) ((pByteArray[Index] + pByteArray[Index+1]*6 + pByteArray[Index+2] *3)/10);
|
|
pByteArray[Index] = byGray;
|
|
pByteArray[Index+1] = byGray;
|
|
pByteArray[Index+2] = byGray;
|
|
|
|
// Increment the horizontal offset
|
|
xOffset += pbmi->bmiHeader.biBitCount >> 3;
|
|
}
|
|
|
|
// Increment vertical offset
|
|
yOffset += nWidthBytes;
|
|
}
|
|
|
|
// Save the modified colour back into our source DDB
|
|
MemDC.SetDIBits(pbmSource, 0, pbmi->bmiHeader.biHeight, pByteArray, pbmi, DIB_RGB_COLORS);
|
|
}
|
|
|
|
inline HIMAGELIST CreateDisabledImageList(HIMAGELIST himlNormal)
|
|
// Returns a greyed image list, created from hImageList
|
|
{
|
|
int cx, cy;
|
|
int nCount = ImageList_GetImageCount(himlNormal);
|
|
if (0 == nCount)
|
|
return NULL;
|
|
|
|
ImageList_GetIconSize(himlNormal, &cx, &cy);
|
|
|
|
// Create the disabled ImageList
|
|
HIMAGELIST himlDisabled = ImageList_Create(cx, cy, ILC_COLOR24 | ILC_MASK, nCount, 0);
|
|
|
|
// Process each image in the ImageList
|
|
for (int i = 0 ; i < nCount; ++i)
|
|
{
|
|
CClientDC DesktopDC(NULL);
|
|
CMemDC MemDC(NULL);
|
|
CBitmap* pOldBitmap = MemDC.CreateCompatibleBitmap(&DesktopDC, cx, cx);
|
|
CRect rc;
|
|
rc.SetRect(0, 0, cx, cx);
|
|
|
|
// Set the mask color to grey for the new ImageList
|
|
COLORREF crMask = RGB(200, 199, 200);
|
|
if ( GetDeviceCaps(DesktopDC, BITSPIXEL) < 24)
|
|
{
|
|
HPALETTE hPal = (HPALETTE)GetCurrentObject(DesktopDC, OBJ_PAL);
|
|
UINT Index = GetNearestPaletteIndex(hPal, crMask);
|
|
if (Index != CLR_INVALID) crMask = PALETTEINDEX(Index);
|
|
}
|
|
|
|
MemDC.SolidFill(crMask, rc);
|
|
|
|
// Draw the image on the memory DC
|
|
ImageList_SetBkColor(himlNormal, crMask);
|
|
ImageList_Draw(himlNormal, i, MemDC, 0, 0, ILD_NORMAL);
|
|
|
|
// Convert colored pixels to gray
|
|
for (int x = 0 ; x < cx; ++x)
|
|
{
|
|
for (int y = 0; y < cy; ++y)
|
|
{
|
|
COLORREF clr = ::GetPixel(MemDC, x, y);
|
|
|
|
if (clr != crMask)
|
|
{
|
|
BYTE byGray = (BYTE) (95 + (GetRValue(clr) *3 + GetGValue(clr)*6 + GetBValue(clr))/20);
|
|
MemDC.SetPixel(x, y, RGB(byGray, byGray, byGray));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// Detach the bitmap so we can use it.
|
|
CBitmap* pBitmap = MemDC.SelectObject(pOldBitmap);
|
|
ImageList_AddMasked(himlDisabled, *pBitmap, crMask);
|
|
}
|
|
|
|
return himlDisabled;
|
|
}
|
|
#endif
|
|
|
|
////////////////////////////////////////////
|
|
// Global Function Definitions
|
|
//
|
|
|
|
inline CDC* FromHandle(HDC hDC)
|
|
// Returns the CDC object associated with the device context handle
|
|
// If a CDC object doesn't already exist, a temporary CDC object is created.
|
|
// The HDC belonging to a temporary CDC is not released or destroyed when the
|
|
// temporary CDC is deconstructed.
|
|
{
|
|
assert( GetApp() );
|
|
CDC* pDC = GetApp()->GetCDCFromMap(hDC);
|
|
if (hDC != 0 && pDC == 0)
|
|
{
|
|
pDC = new CDC;
|
|
GetApp()->AddTmpDC(pDC);
|
|
pDC->m_pData->hDC = hDC;
|
|
pDC->m_pData->bRemoveHDC = FALSE;
|
|
}
|
|
return pDC;
|
|
}
|
|
|
|
inline CBitmap* FromHandle(HBITMAP hBitmap)
|
|
// Returns the CBitmap associated with the Bitmap handle
|
|
// If a CBitmap object doesn't already exist, a temporary CBitmap object is created.
|
|
// The HBITMAP belonging to a temporary CBitmap is not released or destroyed
|
|
// when the temporary CBitmap is deconstructed.
|
|
{
|
|
assert( GetApp() );
|
|
CBitmap* pBitmap = (CBitmap*)GetApp()->GetCGDIObjectFromMap(hBitmap);
|
|
if (hBitmap != 0 && pBitmap == 0)
|
|
{
|
|
pBitmap = new CBitmap;
|
|
GetApp()->AddTmpGDI(pBitmap);
|
|
pBitmap->m_pData->hGDIObject = hBitmap;
|
|
pBitmap->m_pData->bRemoveObject = FALSE;
|
|
}
|
|
return pBitmap;
|
|
}
|
|
|
|
inline CBrush* FromHandle(HBRUSH hBrush)
|
|
// Returns the CBrush associated with the Brush handle
|
|
// If a CBrush object doesn't already exist, a temporary CBrush object is created.
|
|
// The HBRUSH belonging to a temporary CBrush is not released or destroyed
|
|
// when the temporary CBrush is deconstructed.
|
|
{
|
|
assert( GetApp() );
|
|
CBrush* pBrush = (CBrush*)GetApp()->GetCGDIObjectFromMap(hBrush);
|
|
if (hBrush != 0 && pBrush == 0)
|
|
{
|
|
pBrush = new CBrush;
|
|
GetApp()->AddTmpGDI(pBrush);
|
|
pBrush->m_pData->hGDIObject = hBrush;
|
|
pBrush->m_pData->bRemoveObject = FALSE;
|
|
}
|
|
return pBrush;
|
|
}
|
|
|
|
inline CFont* FromHandle(HFONT hFont)
|
|
// Returns the CFont associated with the Font handle
|
|
// If a CFont object doesn't already exist, a temporary CFont object is created.
|
|
// The HFONT belonging to a temporary CFont is not released or destroyed
|
|
// when the temporary CFont is deconstructed.
|
|
{
|
|
assert( GetApp() );
|
|
CFont* pFont = (CFont*)GetApp()->GetCGDIObjectFromMap(hFont);
|
|
if (hFont != 0 && pFont == 0)
|
|
{
|
|
pFont = new CFont;
|
|
GetApp()->AddTmpGDI(pFont);
|
|
pFont->m_pData->hGDIObject = hFont;
|
|
pFont->m_pData->bRemoveObject = FALSE;
|
|
}
|
|
return pFont;
|
|
}
|
|
|
|
inline CPalette* FromHandle(HPALETTE hPalette)
|
|
// Returns the CPalette associated with the palette handle
|
|
// If a CPalette object doesn't already exist, a temporary CPalette object is created.
|
|
// The HPALETTE belonging to a temporary CPalette is not released or destroyed
|
|
// when the temporary CPalette is deconstructed.
|
|
{
|
|
assert( GetApp() );
|
|
CPalette* pPalette = (CPalette*)GetApp()->GetCGDIObjectFromMap(hPalette);
|
|
if (hPalette != 0 && pPalette == 0)
|
|
{
|
|
pPalette = new CPalette;
|
|
GetApp()->AddTmpGDI(pPalette);
|
|
pPalette->m_pData->hGDIObject = hPalette;
|
|
pPalette->m_pData->bRemoveObject = FALSE;
|
|
}
|
|
return pPalette;
|
|
}
|
|
|
|
inline CPen* FromHandle(HPEN hPen)
|
|
// Returns the CPen associated with the HPEN.
|
|
// If a CPen object doesn't already exist, a temporary CPen object is created.
|
|
// The HPEN belonging to a temporary CPen is not released or destroyed
|
|
// when the temporary CPen is deconstructed.
|
|
{
|
|
assert( GetApp() );
|
|
CPen* pPen = (CPen*)GetApp()->GetCGDIObjectFromMap(hPen);
|
|
if (hPen != 0 && pPen == 0)
|
|
{
|
|
pPen = new CPen;
|
|
GetApp()->AddTmpGDI(pPen);
|
|
pPen->m_pData->hGDIObject = hPen;
|
|
pPen->m_pData->bRemoveObject = FALSE;
|
|
}
|
|
return pPen;
|
|
}
|
|
|
|
inline CRgn* FromHandle(HRGN hRgn)
|
|
// Returns the CRgn associated with the HRGN.
|
|
// If a CRgn object doesn't already exist, a temporary CRgn object is created.
|
|
// The HRGN belonging to a temporary CRgn is not released or destroyed
|
|
// when the temporary CRgn is deconstructed.
|
|
{
|
|
assert( GetApp() );
|
|
CRgn* pRgn = (CRgn*)GetApp()->GetCGDIObjectFromMap(hRgn);
|
|
if (hRgn != 0 && pRgn == 0)
|
|
{
|
|
pRgn = new CRgn;
|
|
GetApp()->AddTmpGDI(pRgn);
|
|
pRgn->m_pData->hGDIObject = hRgn;
|
|
pRgn->m_pData->bRemoveObject = FALSE;
|
|
}
|
|
return pRgn;
|
|
}
|
|
|
|
|
|
|
|
} // namespace Win32xx
|
|
|
|
#endif // _WIN32XX_GDI_H_
|
|
|