TnbGdiPlus.h

[詳解]

#pragma once
#ifdef new
 #pragma push_macro("new")
 #undef new
 #define __TnbNEEDPOPNEW__
#endif
 
 
 
#include "TnbPointerHandle.h"
#include "TnbStrLib.h"
#include <math.h>
#include <gdiplus.h>
#pragma comment(lib, "gdiplus.lib")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 // HWNDとリスナーのMAP
 _SELECTANY ULONG_PTR s_uGdiToken = 0; 
#endif
 
 
 
class CGdiPlus
{
public:
 
    class CPos : public Gdiplus::PointF
    {
        DEFSUPER(Gdiplus::PointF);
        // 変換
        template<typename T> Gdiplus::REAL _(T t) const
        {
            return static_cast<Gdiplus::REAL>(t);
        }
    public:
        CPos(double x, double y) : _super(_(x), _(y)) { }
        CPos(const POINT& pos) : _super(_(pos.x), _(pos.y)) { }
        CPos(const SIZE& sz) : _super(_(sz.cx), _(sz.cy)) { }
    };
 
 
    //-----------------------------
 
 
    virtual ~CGdiPlus(void)
    {
    }
 
    CGdiPlus(void) : m_hDC(NULL)
    {
        Startup();
    }
    
    CGdiPlus(HDC hdc) : m_hDC(hdc)
    {
        Startup();
        m_pGraphics = Gdiplus::Graphics::FromHDC(hdc);
        m_pGraphics->SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
    }
    
    CGdiPlus(const CGdiPlus& other) : m_hDC(NULL)
    {
        operator=(other);
    }
 
    CGdiPlus& operator=(const CGdiPlus& other)
    {
        if ( this != &other )
        {
            m_pGraphics.Null();
            if ( m_hDC != NULL )
            {
                m_pGraphics = Gdiplus::Graphics::FromHDC(m_hDC);
                m_pGraphics->SetTextRenderingHint(other.m_pGraphics->GetTextRenderingHint());
            }
            m_pFont = other.m_pFont;
            m_pBrush = other.m_pBrush;
            m_pPen = other.m_pPen;
            m_pStringFormat = other.m_pStringFormat;
        }
        return *this;
    }
 
    bool SetDC(HDC hdc)
    {
        m_pGraphics.Null();
        m_hDC = hdc;
        m_pGraphics = Gdiplus::Graphics::FromHDC(hdc);
        m_pGraphics->SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
        return m_Ret(m_pGraphics);
    }
 
    bool SetFont(HFONT hFont)
    {
        m_pFont = new Gdiplus::Font(m_hDC, hFont);
        return m_Ret(m_pFont);
    }
 
    enum EFontStyle
    {
        REGULAR     = Gdiplus::FontStyleRegular,        
        BOLD        = Gdiplus::FontStyleBold,           
        ITALIC      = Gdiplus::FontStyleItalic,         
        UNDERLINE   = Gdiplus::FontStyleUnderline,      
        STRIKEOUT   = Gdiplus::FontStyleStrikeout,      
    };
 
    bool SetFont(LPCWSTR lpszFontName, float size, int style = REGULAR)
    {
        Gdiplus::FontFamily fontfamily(lpszFontName);
        m_pFont = new Gdiplus::Font(&fontfamily, size, style, Gdiplus::UnitPixel);
        return m_Ret(m_pFont);
    }
 
    bool SetBrush(COLORREF color)
    {
        Gdiplus::Color c;
        c.SetFromCOLORREF(color);
        m_pBrush = new Gdiplus::SolidBrush(c);
        return m_Ret(m_pBrush);
    }
 
    bool SetBrush(HBITMAP bmp)
    {
        HPALETTE h = NULL;
        Gdiplus::Bitmap bm(bmp, h);
        if ( bm.GetLastStatus() == Gdiplus::Ok )
        {
            m_pBrush = new Gdiplus::TextureBrush(&bm);
            return m_Ret(m_pBrush);
        }
        m_pBrush.Null();
        return false;
    }
 
//LinearGradientBrush
//HatchBrush
 
    
    bool SetPen(COLORREF color, float width)
    {
        Gdiplus::Color co;
        co.SetFromCOLORREF(color);
        m_pPen = new Gdiplus::Pen(co, width);
        return m_Ret(m_pPen);
    }
 
    enum ETextRenderingHint
    {
        SYSTEM_DEFAULT  = Gdiplus::TextRenderingHintSystemDefault,              
        BITPERPIXEL     = Gdiplus::TextRenderingHintSingleBitPerPixelGridFit,   
        ANTIALIAS       = Gdiplus::TextRenderingHintAntiAliasGridFit,           
        CLEARTYPE       = Gdiplus::TextRenderingHintClearTypeGridFit            
    };
 
    bool SetTextRenderingHint(ETextRenderingHint hint, bool boIsGridFit = false)
    {
        if ( m_pGraphics.IsNull() ) { return false; }
        int i = hint;
        if ( ! boIsGridFit && (hint == BITPERPIXEL || hint == ANTIALIAS) )
        {
            i++;
        }
        Gdiplus::TextRenderingHint h = static_cast<Gdiplus::TextRenderingHint>(i);
        return m_Ret(m_pGraphics->SetTextRenderingHint(h));
    }   
 
    bool SetTextStyle(DWORD drawTextStyle)
    {
        m_pStringFormat = ms_DtToStringFormat(drawTextStyle);
        return m_Ret(m_pStringFormat);
    }
 
    bool DrawText(const RECT& rc, LPCWSTR lpsz) const
    {
        if ( m_pGraphics.IsNull() || m_pFont.IsNull() || m_pBrush.IsNull() ) { return false; }
        Gdiplus::RectF rcf(_(rc.left), _(rc.top), _(rc.right - rc.left + 1), _(rc.bottom - rc.top + 1));
        Gdiplus::Status r = m_pGraphics->DrawString(lpsz, -1, m_pFont, rcf, m_pStringFormat, m_pBrush);
        return m_Ret(r);
    }
 
    bool DrawText(const CGdiPlus::CPos& po, LPCWSTR lpsz) const
    {
        if ( m_pGraphics.IsNull() || m_pFont.IsNull() || m_pBrush.IsNull() ) { return false; }
        Gdiplus::Status r = m_pGraphics->DrawString(lpsz, -1, m_pFont, po, m_pStringFormat, m_pBrush);
        return m_Ret(r);
    }
 
    enum EInterpolationMode
    {
        BICUBIC         = Gdiplus::InterpolationModeBicubic,            
        BILINEAR        = Gdiplus::InterpolationModeBilinear,           
//      I_DEFAULT       = Gdiplus::InterpolationModeDefault,            ///< 既定のモードを指定します。
        HIGH            = Gdiplus::InterpolationModeHighQuality,        
        HQ_BICUBIC      = Gdiplus::InterpolationModeHighQualityBicubic, 
        HQ_BILINEAR     = Gdiplus::InterpolationModeHighQualityBilinear,
//      I_INVALID       = Gdiplus::InterpolationModeInvalid,            ///< 無効なモードを指定します。 
        LOW             = Gdiplus::InterpolationModeLowQuality,         
        NEAREST_NEIGHBOR = Gdiplus::InterpolationModeNearestNeighbor,   
    };
    
    bool SetImageInterpolationMode(EInterpolationMode mode)
    {
        if ( m_pGraphics.IsNull() ) { return false; }
        Gdiplus::Status r = m_pGraphics->SetInterpolationMode(static_cast<Gdiplus::InterpolationMode>(mode));
        return m_Ret(r);
    }
 
    void ClearImageAttribute(void)
    {
        m_pImageAttr = NULL;
    }
 
    void SetImageTransparentColor(COLORREF colorLow, COLORREF colorHigh)
    {
        if ( m_pImageAttr.IsNull() )
        {
            m_pImageAttr = new Gdiplus::ImageAttributes();
        }
        Gdiplus::Color c1;
        Gdiplus::Color c2;
        c1.SetFromCOLORREF(colorLow);
        c2.SetFromCOLORREF(colorHigh);
        m_pImageAttr->SetColorKey(c1, c2);
    }
 
    CPointerHandleT<Gdiplus::ImageAttributes> ReferImageAttribute(void)
    {
        if ( m_pImageAttr.IsNull() )
        {
            m_pImageAttr = new Gdiplus::ImageAttributes();
        }
        return m_pImageAttr;
    }
 
    bool DrawImage(const CGdiPlus::CPos& po, HBITMAP bmp, double mag = 1.0, bool isFlipX = false, bool isFlipY = false) const
    {
        if ( m_pGraphics.IsNull() ) { return false; }
        HPALETTE h = NULL;
        Gdiplus::Bitmap bm(bmp, h);
        Gdiplus::PointF pos[3];
        pos[0].X = _(po.X);
        pos[0].Y = _(po.Y);
        pos[1].X = _(po.X + bm.GetWidth() * mag);
        pos[1].Y = _(po.Y);
        pos[2].X = _(po.X);
        pos[2].Y = _(po.Y + bm.GetHeight() * mag);
        if ( isFlipX )
        {
             pos[0].X = _(po.X + bm.GetWidth() * mag);      // 水平方向の反転を処理します。
             pos[1].X = _(po.X);
             pos[2].X = pos[0].X;
        }
        if ( isFlipY )
        {
            pos[0].Y = _(po.Y + bm.GetHeight() * mag);      // 垂直方向の反転を処理します。
            pos[1].Y = pos[0].Y;
            pos[2].Y = _(po.Y);
        }
        return m_DrawImage(bm, pos, 3);
    }
 
    bool DrawFitImage(const RECT& rc, HBITMAP bmp, bool isFlipX = false, bool isFlipY = false) const
    {
        if ( m_pGraphics.IsNull() ) { return false; }
        HPALETTE h = NULL;
        Gdiplus::Bitmap bm(bmp, h);
        double width = rc.right - rc.left;
        double height = rc.bottom - rc.top;
        double dx = width / bm.GetWidth();
        double dy = height / bm.GetHeight();
        CGdiPlus::CPos po(0, 0);
        double d = 1.0;
        if ( dx > dy )
        {
            //dy をベースにする
            d = dy;
            double x = (width - bm.GetWidth() * d);
            po.X = static_cast<float>(x / 2.0);
        }
        else
        {
            //dx をベースにする
            d = dx;
            double y = (height - bm.GetHeight() * d);
            po.Y = static_cast<float>(y / 2.0);
        }
        return DrawImage(po, bmp, d, isFlipX, isFlipY);
    }
    
    bool DrawRotateImage(const CGdiPlus::CPos& po, HBITMAP bmp, const CGdiPlus::CPos& hotSpot, double angle, double mag = 1.0) const
    {
        if ( m_pGraphics.IsNull() ) { return false; }
        HPALETTE hPalette = NULL;
        Gdiplus::Bitmap bm(bmp, hPalette);
        Gdiplus::PointF pos[3];
        double restW = bm.GetWidth() - hotSpot.X;
        double restH = bm.GetHeight() - hotSpot.Y;
        double radian = ToRadian(angle);
        double sinVal = ::sin(radian);
        double cosVal = ::cos(radian);
        // 回転・拡大 & 平行移動
        pos[0].X = _(((hotSpot.X * -cosVal) - (hotSpot.Y * -sinVal)) * mag + po.X);
        pos[0].Y = _(((hotSpot.X * -sinVal) + (hotSpot.Y * -cosVal)) * mag + po.Y);
        pos[1].X = _(((restW * cosVal) - (hotSpot.Y * -sinVal)) * mag + po.X);
        pos[1].Y = _(((restW * sinVal) + (hotSpot.Y * -cosVal)) * mag + po.Y);
        pos[2].X = _(((hotSpot.X * -cosVal) - (restH * sinVal)) * mag + po.X);
        pos[2].Y = _(((hotSpot.X * -sinVal) + (restH * cosVal)) * mag + po.Y);
        //
        return m_DrawImage(bm, pos, 3);
    }
 
    bool DrawRotateImage(const CGdiPlus::CPos& po, HBITMAP bmp, double angle, double mag = 1.0) const
    {
        BITMAP bm;
        if ( ::GetObject(bmp, sizeof(BITMAP), &bm) )
        {
            return DrawRotateImage(po, bmp, CPos(bm.bmWidth / 2.0, bm.bmHeight / 2.0), angle, mag);
        }
        return false;
    }
 
    bool DrawSkewImage(const CGdiPlus::CPos& po, HBITMAP bmp, const CGdiPlus::CPos& diff, double mag = 1.0) const
    {
        if ( m_pGraphics.IsNull() ) { return false; }
        HPALETTE h = NULL;
        Gdiplus::Bitmap bm(bmp, h);
        Gdiplus::PointF pos[3];
        pos[0].X = _(po.X);
        pos[0].Y = _(po.Y);
        pos[1].X = _(po.X + bm.GetWidth() * mag);
        pos[1].Y = _(po.Y + diff.Y * mag);
        pos[2].X = _(po.X + diff.X * mag);
        pos[2].Y = _(po.Y + bm.GetHeight() * mag);
        //
        return m_DrawImage(bm, pos, 3);
    }
 
    enum ESmoothingMode
    {
//      S_INVALID       = Gdiplus::SmoothingModeInvalid,        ///< 無効なモードを指定します。
//      S_DEFAULT       = Gdiplus::SmoothingModeDefault,        ///< アンチエイリアス処理しないことを指定します。
        HIGH_SPEED      = Gdiplus::SmoothingModeHighSpeed,      
        HIGH_QUALITY    = Gdiplus::SmoothingModeHighQuality,    
        NONE            = Gdiplus::SmoothingModeNone,           
        ANTI_ALIAS      = Gdiplus::SmoothingModeAntiAlias       
    };
 
    bool SetSmoothingMode(ESmoothingMode mode)
    {
        if ( m_pGraphics.IsNull() ) { return false; }
        Gdiplus::Status r = m_pGraphics->SetSmoothingMode(static_cast<Gdiplus::SmoothingMode>(mode));
        return m_Ret(r);
    }
 
    bool DrawLine(const CPos& s, const CPos& e)
    {
        if ( m_pGraphics.IsNull() ) { return false; }
        Gdiplus::Status r = m_pGraphics->DrawLine(m_pPen, s, e);
        return m_Ret(r);
    }
 
  /*
    bool DrawArc()
    bool DrawCurve()
    bool DrawEllipse()
    bool DrawPie()
    bool DrawPolygon()
    bool DrawRectangle()
 
    bool FillCurve()
    bool FillEllipse()
    bool FillPie()
    bool FillPolygon()
    bool FillRectangle()
    bool FillRegion()
    */
 
    //------------------------------------
 
    static bool Startup(void)
    {
        if ( s_uGdiToken == 0 )
        {
            static CReject r;
            Gdiplus::GdiplusStartupInput startupInput;
            Gdiplus::GdiplusStartup(&s_uGdiToken, &startupInput, NULL);
        }
        return s_uGdiToken != 0;
    }
 
    static bool DrawAntialiasText(HDC dc, HFONT hFont, DWORD drawTextStyle, COLORREF color, const CGdiPlus::CPos& po, LPCWSTR lpsz)
    {
        CGdiPlus g(dc);
        g.SetFont(hFont);
        g.SetBrush(color);
        g.SetTextRenderingHint(ANTIALIAS);
        g.SetTextStyle(drawTextStyle);
        return g.DrawText(po, lpsz);
    }
 
    static HBITMAP LoadBitmap(LPCWSTR lpsz)
    {
        Startup();
        Gdiplus::Bitmap bm(lpsz);
        if ( bm.GetLastStatus() == Gdiplus::Ok )
        {
            Gdiplus::Color c;
            c.SetFromCOLORREF(RGB(255, 255, 255));
            HBITMAP hBmp;
            if ( bm.GetHBITMAP(c, &hBmp) == Gdiplus::Ok )
            {
                return hBmp;
            }
        }
        return NULL;
    }
 
    static HBITMAP LoadThumbnail(LPCWSTR lpsz)
    {
        Startup();
        Gdiplus::Bitmap bmp(lpsz);
        if ( bmp.GetLastStatus() == Gdiplus::Ok )
        {
            UINT size = bmp.GetPropertyItemSize(PropertyTagThumbnailData);
            if ( size > 0 )
            {
                HGLOBAL hGlobal = ::GlobalAlloc(GMEM_MOVEABLE, size);
                BYTE* B = static_cast<BYTE *>(::GlobalLock(hGlobal));
                Gdiplus::PropertyItem* P = reinterpret_cast<Gdiplus::PropertyItem*>(B);
                bmp.GetPropertyItem(PropertyTagThumbnailData, size, P);
                TNB::MemCopy(&B[0], &B[16], size - 16);
                ::GlobalUnlock(hGlobal);
                IStream* pis = NULL;
                CreateStreamOnHGlobal(hGlobal, TRUE, &pis);
                Gdiplus::Bitmap bm(pis);
                if ( bm.GetLastStatus() == Gdiplus::Ok )
                {
                    Gdiplus::Color c;
                    c.SetFromCOLORREF(RGB(0, 0, 0));
                    HBITMAP hBmp;
                    if ( bm.GetHBITMAP(c, &hBmp) == Gdiplus::Ok )
                    {
                        pis->Release();
                        ::GlobalFree(hGlobal);
                        return hBmp;
                    }
                }
                if ( pis != NULL )
                {
                    pis->Release();
                }
                ::GlobalFree(hGlobal);
            }
        }
        return NULL;
    }
 
    enum EBitmapFormat
    {
        BMP,        
        JPEG,       
        JPG = JPEG, 
        GIF,        
        TIFF,       
        TIF = TIFF, 
        PNG,        
    };
 
    static bool SaveBitmap(LPCWSTR lpsz, Gdiplus::Bitmap& bmp, EBitmapFormat fmt = BMP, LONG jpegQuality = 80)
    {
        Startup();
        LPCWSTR lpFmtDes;
        Gdiplus::EncoderParameters encoderParameters;
        Gdiplus::EncoderParameters* pEncoderParameters = NULL;
        switch( fmt )
        {
        case BMP:
        default:    lpFmtDes = L"BMP";  break;
        case GIF:   lpFmtDes = L"GIF";  break;
        case TIFF:  lpFmtDes = L"TIFF"; break;
        case PNG:   lpFmtDes = L"PNG";  break;
        case JPEG:  
            lpFmtDes = L"JPEG"; 
            encoderParameters.Count = 1;
            encoderParameters.Parameter[0].Guid = Gdiplus::EncoderQuality; 
            encoderParameters.Parameter[0].Type = Gdiplus::EncoderParameterValueTypeLong;
            encoderParameters.Parameter[0].NumberOfValues = 1;
            encoderParameters.Parameter[0].Value = &jpegQuality;    //JPEGクオリティ：0〜100
            pEncoderParameters = &encoderParameters;
            break;
        }       
        UINT numEncoders;
        UINT size = 0;
        Gdiplus::GetImageEncodersSize(&numEncoders, &size);
        CWorkMem work(size);
        Gdiplus::ImageCodecInfo* pEncoders = reinterpret_cast<Gdiplus::ImageCodecInfo*>(work.Ref());
        Gdiplus::GetImageEncoders(numEncoders, size, pEncoders);
        loop ( i, numEncoders )
        {
            if ( STRLIB::Compare(pEncoders[i].FormatDescription, lpFmtDes) == 0 )
            {
                return bmp.Save(lpsz, &(pEncoders[i].Clsid), pEncoderParameters) == Gdiplus::Ok;
            }
        }
        return false;
    }
 
    static bool SaveBitmap(LPCWSTR lpsz, HBITMAP hBmp, EBitmapFormat fmt = BMP, LONG jpegQuality = 80)
    {
        HPALETTE h = NULL;
        Gdiplus::Bitmap bm(hBmp, h);
        return SaveBitmap(lpsz, bm, fmt, jpegQuality);
    }
 
private:
 
    //GDI+ Shotdown処理用サブクラス
    class CReject
    {
    public: 
        ~CReject(void)
        {
            if ( s_uGdiToken != 0 )
            {
                Gdiplus::GdiplusShutdown(s_uGdiToken);
                s_uGdiToken = 0;
            }
        }
    };
 
    HDC                                         m_hDC;              
    CPointerHandleT<Gdiplus::Graphics>          m_pGraphics;        
    CPointerHandleT<Gdiplus::ImageAttributes>   m_pImageAttr;       
    //
    CPointerHandleT<Gdiplus::StringFormat>      m_pStringFormat;    
    CPointerHandleT<Gdiplus::Font>              m_pFont;            
    CPointerHandleT<Gdiplus::Brush>             m_pBrush;           
    CPointerHandleT<Gdiplus::Pen>               m_pPen;             
//  Gdiplus::Region         m_region;       ///< リージョン
//  Gdiplus::GraphicsPath   m_graphicsPath; ///< パス？
 
    static Gdiplus::StringFormat* ms_DtToStringFormat(DWORD drawTextStyle)
    {
        Gdiplus::StringFormat* P = new Gdiplus::StringFormat();
        Gdiplus::StringAlignment alignX = Gdiplus::StringAlignmentNear;
        if ( (drawTextStyle & DT_CENTER) != 0 )
        {
            alignX = Gdiplus::StringAlignmentCenter;
        }
        else if ( (drawTextStyle & DT_RIGHT) != 0 )
        {
            alignX = Gdiplus::StringAlignmentFar;
        }
        P->SetAlignment(alignX);
        Gdiplus::StringAlignment alignY = Gdiplus::StringAlignmentNear;
        if ( (drawTextStyle & DT_VCENTER) != 0 )
        {
            alignY = Gdiplus::StringAlignmentCenter;
        }
        else if ( (drawTextStyle & DT_BOTTOM) != 0 )
        {
            alignY = Gdiplus::StringAlignmentFar;
        }
        P->SetLineAlignment(alignY);
        //
        int formatFlags = 0;
        if ( (drawTextStyle & DT_SINGLELINE) == 0 )
        {
            formatFlags |= Gdiplus::StringFormatFlagsNoClip;
        }
        P->SetFormatFlags(formatFlags);
        //
        Gdiplus::StringTrimming trim = Gdiplus::StringTrimmingNone;
        if ( (drawTextStyle & DT_END_ELLIPSIS) != 0 )
        {
            trim = Gdiplus::StringTrimmingEllipsisCharacter;
        }
        if ( (drawTextStyle & DT_WORD_ELLIPSIS) != 0 )
        {
            trim = Gdiplus::StringTrimmingEllipsisWord;
        }
        if ( (drawTextStyle & DT_PATH_ELLIPSIS) != 0 )
        {
            trim = Gdiplus::StringTrimmingEllipsisPath;
        }
        P->SetTrimming(trim);
        //
        if ( (drawTextStyle & DT_NOPREFIX) != 0 )
        {
            P->SetHotkeyPrefix(Gdiplus::HotkeyPrefixNone);
        }
        else
        {
            P->SetHotkeyPrefix(Gdiplus::HotkeyPrefixShow);
        }
        return P;
    }
    // 変換
    template<typename T> Gdiplus::REAL _(T t) const
    {
        return static_cast<Gdiplus::REAL>(t);
    }
    // π
    static double PI(void)
    {
        return 3.141592653589793;
    }
    // 角度 -> ラジアン
    static double ToRadian(double angle)
    {
        return angle * PI() / 180.0;
    }
    // ラジアン -> 角度
    static double ToAngle(double radian)
    {
        return radian * 180.0 / PI();
    }
    // 結果判断
    bool m_Ret(Gdiplus::Status s) const
    {
        return s == Gdiplus::Ok;
    }
    // 結果判断
    template<typename TYP>
    bool m_Ret(CPointerHandleT<TYP>  P) const
    {
        return P->GetLastStatus() == Gdiplus::Ok;
    }
    bool m_DrawImage(Gdiplus::Bitmap& bm, Gdiplus::PointF* pPos, int posLength) const
    {
        ASSERT( ! ::IsBadReadPtr(pPos, sizeof(Gdiplus::PointF) * posLength) );
        if ( ! m_pImageAttr.IsNull() )
        {
            Gdiplus::Status r = m_pGraphics->DrawImage( &bm, pPos, posLength, 0, 0, _(bm.GetWidth()), _(bm.GetHeight()), Gdiplus::UnitPixel, m_pImageAttr);
            return m_Ret(r);
        }
        return m_Ret(m_pGraphics->DrawImage(&bm, pPos, posLength));
    }
};
 
 
 
}; // TNB
 
 
 
#ifdef __TnbNEEDPOPNEW__
 #pragma pop_macro("new")
#endif