sprint/gtl/DC.h

Go to the documentation of this file.

/******************************************************************************
 *  GTL: GUI Template Library 
 *    A Cross Platform C++ Wrapper for Win32 users
 *  Copyright (C) 2007-2011 Paolo Medici (www.pmx.it)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_GTL_DC_H
#define _SPRINT_GTL_DC_H

#ifdef WIN32
# include <windows.h>
#endif

#include <string>
#include <sprint/gtl/BaseTypes.h>
#include <sprint/gtl/Brush.h>
#include <sprint/gtl/Font.h>
#include <sprint/gtl/Bitmap.h>
#include <sprint/gtl/Pen.h>
#include <sprint/log.h>

#undef SelectBitmap
#undef SelectBrush
#undef SelectFont
#undef SelectPen

namespace sprint {
        namespace gtl {


// HDC wrapper
// Il Device Context e' il modo per disegnare in una CWindow
template<bool tManagedDC>
class TDC {
        typedef TDC<tManagedDC> this_t;
        public:
        HDC m_hdc;
        public:
        TDC(HDC hdc = NULL) : m_hdc(hdc) { }
  ~TDC() { if(tManagedDC)       DeleteDC(); }

        void Attach(HDC hDC)
        {
                if(tManagedDC && m_hdc != NULL && m_hdc != hDC)
			::DeleteDC(m_hdc);
                m_hdc = hDC;
        }

        HDC Detach()
        {
                HDC hDC = m_hdc;
                m_hdc = NULL;
                return hDC;
        }

        operator HDC() const { return m_hdc; }  
        
        bool IsNull() const { return (m_hdc == NULL); }

        CBrushHandle GetCurrentBrush() const
        {
                return CBrushHandle((HBRUSH)::GetCurrentObject(m_hdc, OBJ_BRUSH));
        }

        CFontHandle GetCurrentFont() const
        {
                return CFontHandle((HFONT)::GetCurrentObject(m_hdc, OBJ_FONT));
        }

        CBitmapHandle GetCurrentBitmap() const
        {
                return CBitmapHandle((HBITMAP)::GetCurrentObject(m_hdc, OBJ_BITMAP));
        }
        
        void SaveDC() 
    { 
         ::SaveDC(m_hdc); 
    }

        BOOL RestoreDC(int nSavedDC)
        {
            return ::RestoreDC(m_hdc, nSavedDC);
        }
        
        inline bool FillRect(const RECT &rc, HBRUSH hbr)
        {
                return 	::FillRect(m_hdc, &rc, hbr) == TRUE;
        }

        inline bool FillRect(int x0, int y0, int x1, int y1, HBRUSH hbr)
        {
        Rect r(x0,y0,x1,y1);
                return FillRect(r, hbr) == TRUE;
        }

        inline bool FrameRect(const RECT &rc, HBRUSH hbr)
        {
                return  ::FrameRect(m_hdc, &rc, hbr) == TRUE;
        }

        inline bool FrameRect(int x0, int y0, int x1, int y1, HBRUSH hbr)
        {
                return  FrameRect(Rect(x0,y0,x1,y1), hbr) == TRUE;
        }
        
        // Rectangle: un rettangolo, che usa la Pen e il Brush correnti
        inline bool Rectangle(const RECT &rc)
        {
                return ::Rectangle(m_hdc, rc.left, rc.top, rc.right, rc.bottom);
        }

        // Rectangle: un rettangolo, che usa la Pen e il Brush correnti
        inline bool Rectangle(int x0, int y0, int x1, int y1)
        {
                return ::Rectangle(m_hdc, x0, y0, x1, y1);
        }
        
        inline bool Ellipse(int x0, int y0, int x1, int y1)
        {
                return ::Ellipse(m_hdc, x0, y0, x1, y1);
        }

        inline bool Circle(int x, int y, int r)
        {
                return ::Ellipse(m_hdc, x-r, y-r, x+r, y+r);
        }
        
        // Sposta il Cursore di disegno
        inline bool MoveTo(int x, int y, LPPOINT lpPoint = NULL)
        {
                return ::MoveToEx(m_hdc, x, y, lpPoint);
        }

        // Sposta il Cursore di disegno
        inline bool MoveTo(POINT point, LPPOINT lpPointRet = NULL)
        {
                return MoveTo(point.x, point.y, lpPointRet);
        }

        // Disegna una linea dal cursore di disegno a (x,y) e sposta il cursore
        inline bool LineTo(int x, int y)
        {
                return ::LineTo(m_hdc, x, y);
        }

        // Disegna una linea dal cursore di disegno a point e sposta il cursore
        inline bool LineTo(POINT point)
        {
                return LineTo(point.x, point.y);
        }
        
        
        inline bool Line(POINT a, POINT b)
        {
                return MoveTo(a) && LineTo(b);
        }

        inline bool Line(int x0, int y0, int x1, int y1)
        {
                return MoveTo(x0,y0) && LineTo(x1,y1);
        }
        
        inline bool Polygon(LPPOINT lpPoints, int nCount)
        {
                return ::Polygon(m_hdc, lpPoints, nCount);
        }

        inline bool Polyline(LPPOINT lpPoints, int nCount)
        {
                return ::Polyline(m_hdc, lpPoints, nCount);
        }
        
        inline COLORREF SetTextColor(COLORREF rgb)
        {
                return ::SetTextColor(m_hdc, rgb);
        }
        
        inline COLORREF SetTextColor(unsigned int r, unsigned int g, unsigned int b)
        {
                return ::SetTextColor(m_hdc, RGB(r,g,b) );
        }
        
        COLORREF GetTextColor() const
        {
                return ::GetTextColor(m_hdc);
        }

        COLORREF SetBkColor(COLORREF crColor)
        {
                return ::SetBkColor(m_hdc, crColor);
        }

        UINT GetTextAlign() const
        {
                return ::GetTextAlign(m_hdc);
        }

        UINT SetTextAlign(UINT nFlags)
        {
                return ::SetTextAlign(m_hdc, nFlags);
        }
        
        int SetTextJustification(int nBreakExtra, int nBreakCount)
        {
                return ::SetTextJustification(m_hdc, nBreakExtra, nBreakCount);
        }

        int GetTextCharacterExtra() const
        {
                return ::GetTextCharacterExtra(m_hdc);
        }

        int SetTextCharacterExtra(int nCharExtra)
        {
                return ::SetTextCharacterExtra(m_hdc, nCharExtra);
        }

        BOOL DrawEdge(LPRECT lpRect, UINT nEdge, UINT nFlags)
        {
                return ::DrawEdge(m_hdc, lpRect, nEdge, nFlags);
        }

        BOOL DrawFrameControl(const RECT & lpRect, UINT nType, UINT nState)
        {
                return ::DrawFrameControl(m_hdc, & lpRect, nType, nState);
        }
        
        inline bool TextOut(int x,int y, LPCSTR lpString, int nCount = -1)
        {
        if(nCount == -1)
          nCount = strlen(lpString);
                return ::TextOut(m_hdc, x,y,lpString, nCount);
        }
        
        inline bool TextOut(int x,int y, const std::string & lpString)
        {
                return ::TextOut(m_hdc, x,y,lpString.data(), lpString.length() );
        }
        
        BOOL ExtTextOut(int x, int y, UINT nOptions, LPCRECT lpRect, LPCTSTR lpszString, UINT nCount = -1, LPINT lpDxWidths = NULL)
        {
                if(nCount == -1)
                        nCount = lstrlen(lpszString);
                return ::ExtTextOut(m_hdc, x, y, nOptions, lpRect, lpszString, nCount, lpDxWidths);
        }
        

    inline bool DrawText(LPCSTR lpString, const RECT &rc, UINT uFormat)
    {
        return ::DrawText(m_hdc, lpString, -1, const_cast<RECT*>(&rc), uFormat);
    }

    inline bool DrawText(const std::string & str, const RECT &rc, UINT uFormat)
    {
        return ::DrawText(m_hdc, str.data(), str.length(), const_cast<RECT*>(&rc), uFormat);
    }
  
    inline bool GetTextExtent(LPCSTR lpString, LPSIZE lpSize) const
    {
        return ::GetTextExtentPoint32(
                    m_hdc,
                    lpString,
                    strlen(lpString),
                    lpSize);
    }

    inline bool GetTextExtent(const std::string & str, LPSIZE lpSize) const
    {
        return ::GetTextExtentPoint32(
                    m_hdc,
                    str.data(),
                    str.length(),
                    lpSize);
    }
    
        BOOL GetTextExtent(LPCTSTR lpszString, int nCount, LPSIZE lpSize) const
        {
                if(nCount == -1)
                        nCount = lstrlen(lpszString);
                return ::GetTextExtentPoint32(m_hdc, lpszString, nCount, lpSize);
        }

        SIZE GetTextExtent(LPCTSTR lpszString, int nCount = -1) const
        {
        SIZE sz;
                if(nCount == -1)
                        nCount = strlen(lpszString);
                ::GetTextExtentPoint32(m_hdc, lpszString, nCount, &sz);
                return sz;
        }

        SIZE GetTextExtent(const std::string & str) const
        {
        SIZE sz;
                ::GetTextExtentPoint32(m_hdc, str.data(), str.size(), &sz);
                return sz;
        }

        BOOL GetTextExtentExPoint(LPCTSTR lpszString, int cchString, LPSIZE lpSize, int nMaxExtent, LPINT lpnFit = NULL, LPINT alpDx = NULL)
        {
                return ::GetTextExtentExPoint(m_hdc, lpszString, cchString, nMaxExtent, lpnFit, alpDx, lpSize);
        }
    
    inline int SetBkMode(int mode) const {
        return ::SetBkMode(m_hdc, mode);
    }
    
        inline HBITMAP SelectBitmap(HBITMAP hbmp) const
        {
                return reinterpret_cast<HBITMAP>(::SelectObject(m_hdc, hbmp));
        }

        inline HBRUSH SelectBrush(HBRUSH hbr) const
        {
                return reinterpret_cast<HBRUSH>(::SelectObject(m_hdc, hbr));
        }

        inline HFONT SelectFont(HFONT hbr) const
        {
                return reinterpret_cast<HFONT>(::SelectObject(m_hdc, hbr));
        }

        inline HPEN SelectPen(HPEN hpen) const
        {
                return reinterpret_cast<HPEN>(::SelectObject(m_hdc, hpen));
        }

        inline TDC<true> CreateCompatibleDC() const
        {
                return TDC<true>(::CreateCompatibleDC(m_hdc));
  }     
  
        inline HBITMAP CreateCompatibleBitmap(int nWidth, int nHeight)
        {
                return ::CreateCompatibleBitmap(m_hdc, nWidth, nHeight);
        }

  inline void DeleteDC() 
  {
			::DeleteDC(m_hdc);
                        m_hdc = 0;
        }

        inline bool BitBlt(int nXDest,  
    int nYDest,                                                                         
    int nWidth,                                                                         
    int nHeight,                                                                        
    HDC hdcSrc,                                                                         
    int nXSrc = 0,                                                              
    int nYSrc = 0,                                                              
    DWORD dwRop = SRCCOPY                               
    ) const
    {
    return ::BitBlt(m_hdc, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, dwRop) == TRUE;
        }

          void BitBlt(int x, int y, HBITMAP hbmp, DWORD dwRop = SRCCOPY) const
          {
            TDC<true> Mem(CreateCompatibleDC());
            HBITMAP hbmOld = Mem.SelectBitmap(hbmp);
            BITMAP bm;
            ::GetObject(hbmp, sizeof(BITMAP), &bm);
            
            BitBlt(0, 0, bm.bmWidth, bm.bmHeight, Mem.m_hdc,0,0,dwRop);
            Mem.SelectBitmap(hbmOld);
                }

        
};

typedef TDC<false> CDCHandle;
typedef TDC<true> CDC;

class CPaintDC: public CDCHandle {
        HWND m_hwnd;            
        PAINTSTRUCT m_ps;
        public:
                CPaintDC(HWND hwnd) : CDCHandle(::BeginPaint(hwnd, &m_ps)) , m_hwnd(hwnd) { }
                ~CPaintDC() { ::EndPaint(m_hwnd, &m_ps); }
};

class CWindowDC : public CDCHandle
{
public:
// Data members
        HWND m_hWnd;

// Constructor/destructor
        CWindowDC(HWND hWnd) : CDCHandle(::GetWindowDC(hWnd))
        {
                m_hWnd = hWnd;
        }

        ~CWindowDC()
        {
                ::ReleaseDC(m_hWnd, m_hdc);
        }
};

class CClientDC : public CDCHandle
{
public:
// Data members
        HWND m_hWnd;

// Constructor/destructor
        CClientDC(HWND hWnd) : CDCHandle(::GetDC(hWnd))
        {
                m_hWnd = hWnd;
        }

        ~CClientDC()
        {
                ::ReleaseDC(m_hWnd, m_hdc);
        }
};


class CObjectContext {
        HDC m_hdc;
        HGDIOBJ m_hold;
        public:
                CObjectContext(HDC hdc, HGDIOBJ hnew) : m_hdc(hdc)
                        {
                                m_hold = ::SelectObject(hdc, hnew);
                        }

                ~CObjectContext()
                        {
                                ::SelectObject(m_hdc, m_hold);
                        }
};



class DoubleBufferDC : public CDCHandle {
      RECT rt;                
      CDCHandle target_dc;    
          HBITMAP bitmap;         
          HBITMAP m_hBmpOld;      
      public:
      DoubleBufferDC(HWND hwnd, HDC hdc) : 
                          CDCHandle(::CreateCompatibleDC(hdc)),
                          target_dc(hdc)
                        {
                                ::GetClientRect(hwnd, &rt);
                                bitmap = ::CreateCompatibleBitmap(hdc, rt.right, rt.bottom);
                                m_hBmpOld = (HBITMAP)::SelectObject(m_hdc, bitmap);
                        }
                        
      DoubleBufferDC(const RECT & r, HDC hdc) :
                           CDCHandle(::CreateCompatibleDC(hdc)),
                           rt(r),
                           target_dc(hdc)
                        {
                                bitmap = ::CreateCompatibleBitmap(hdc, rt.right, rt.bottom);
                                m_hBmpOld = (HBITMAP)::SelectObject(m_hdc, bitmap);
                        }
                        
      DoubleBufferDC(unsigned int width, unsigned int height, HDC hdc) :
                           CDCHandle(::CreateCompatibleDC(hdc)),
                           target_dc(hdc)
                        {
                                bitmap = ::CreateCompatibleBitmap(hdc, width, height);
                                rt.left = rt.top = 0;
                                rt.right = width; rt.bottom  = height;
                                m_hBmpOld = (HBITMAP)::SelectObject(m_hdc, bitmap);
                        }
                                                
      ~DoubleBufferDC()
      {
        ::SelectObject(m_hdc, m_hBmpOld);
        // rilascio il dc
		::DeleteDC(m_hdc);
                // cancello la bitmap
                ::DeleteObject(bitmap);
      }
      
      CBitmapHandle Bitmap() const { return bitmap; }
      
      void clear(HBRUSH hbr)
      {
        FillRect(rt, hbr);
      }
      
      inline int width() const { return rt.right; }
      inline int height() const { return rt.bottom; }
            
      bool swap()
      {
                // when finished drawing blit the hdcMem to the hdc
                if(::BitBlt(target_dc, 0, 0, rt.right, rt.bottom, m_hdc, 0, 0, SRCCOPY) == 0)
                {
                logPutsf(LOG_LEVEL_ERROR, "BitBlt failed");
                return false;
                }
                else
                        return true;
      }
};

}

}

#endif