cImageGDIP.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cImageGDIP_H
#define _INC_cImageGDIP_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cImageBase.h"
 
#if defined(_WIN32) && (_MSC_VER >= 1300) && ! defined(UNDER_CE)
 
#include "../WinAPI/cWinResource.h"
#include "GrayCore/include/cWinHeap2.h"
#include "GrayCore/include/cNewPtr.h"
#include "GrayCore/include/cAtom.h"
#include "GrayCore/include/cSingleton.h"
#include "GrayCore/include/cFile.h"
#include "GrayCore/include/cOSModule.h"
 
#include <minmax.h>             // stupid M$ doesn't include this for gdiplus.h.
#include <gdiplus.h>    // let windows GDIPLUS do all the work.
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cImageGDIP);
 
        enum CIMAGEGDIP_TYPE
        {
                CIMAGEGDIP_NONE = -1,
                CIMAGEGDIP_JPG, // D3DXIFF_JPG
                CIMAGEGDIP_PNG,
                CIMAGEGDIP_GIF,
                CIMAGEGDIP_BMP,
                CIMAGEGDIP_TIF,
                // CIMAGEGDIP_TGA
                CIMAGEGDIP_QTY,
        };
 
        class GRAYLIB_LINK cImageGDIP : public cImageBase
        {
                typedef cImageBase SUPER_t;
 
        public:
                static const FILECHAR_t* const k_szImageExtsRev[CIMAGEGDIP_QTY + 1];
                static const FILECHAR_t* const k_szImageExts[CIMAGEGDIP_QTY + 1];
 
                int m_iLockSurfaceCount;
                cNewPtr<Gdiplus::Bitmap> m_pBitmap;     
                Gdiplus::BitmapData m_Data;                     
 
        protected:
                CWinGlobalV m_Buffer;   
 
        protected:
                bool UpdateSurfaceParams();
 
        public:
                cImageGDIP() noexcept
                        : m_pBitmap(nullptr)
                        , m_iLockSurfaceCount(0)
                {}
 
                cImageGDIP(const wchar_t* pwFile);
                cImageGDIP(const char* pwFile);
                cImageGDIP(const GChar_t* pResName, const void* pResType = RT_RCDATA, HMODULE hInst = HMODULE_NULL)
                {
                        LoadResource(pResName, pResType, hInst);
                }
                cImageGDIP(RESOURCEID_t id, const void* pResType = RT_RCDATA, HMODULE hInst = HMODULE_NULL)
                {
                        LoadResource(id, pResType, hInst);
                }
                virtual ~cImageGDIP();
 
                virtual bool isValidImage() const noexcept override
                {
                        return m_pBitmap != nullptr;
                }
 
                virtual void SetEmpty() override;
                HRESULT CreateSurface(PIXELS_t cx, PIXELS_t cy, Gdiplus::PixelFormat ePixelFormat = PixelFormatDontCare);
 
                HRESULT LoadDirectDrawSurface7(IN IDirectDrawSurface7* pSurface);
                HRESULT LoadFileGDIP(const wchar_t* pwFile);
                HRESULT LoadFileGDIP(const char* pszFile);
                virtual HRESULT LoadFile(const FILECHAR_t* pszFileName) override
                {
                        return LoadFileGDIP(pszFileName);
                }
 
                HRESULT LoadFileWildcard(const FILECHAR_t* pszFilePath, bool bPreferCompressed = false);
 
                virtual HRESULT ReadStream(cStreamInput& strIn) override;
                virtual HRESULT SaveFile(const FILECHAR_t* pszPath) const override;
 
                void CopyTo(cSurfaceBase& TexDst, PIXELS_t itxs, PIXELS_t itys, bool bTextureXReverse, bool bTextureYReverse) const;
                void CopyFrom(const cSurfaceBase& TexSrc, PIXELS_t itxs, PIXELS_t itys, bool bTextureXReverse, bool bTextureYReverse, bool bColorReverse);
 
                HRESULT LockSurface(Gdiplus::PixelFormat ePixelFormat = PixelFormatDontCare, bool bWrite = false);
                void UnlockSurface();
 
                operator Gdiplus::Bitmap*() const
                {
                        return m_pBitmap;
                }
 
                static HRESULT GRAYCALL GetHResultFrom(Gdiplus::Status status);
                static HRESULT GRAYCALL GetEncoderClsid(const wchar_t* format, CLSID& encoderClsid);
                static HRESULT GRAYCALL GetEncoderClsid(CIMAGEGDIP_TYPE eExtType, CLSID& encoderClsid);
                static CIMAGEGDIP_TYPE GRAYCALL GetImageTypeForFile(const FILECHAR_t* pszPath);
 
                UNITTEST2_PREDEF(cImageGDIP);
        };
 
        class GRAYLIB_LINK cImageGDIPType
                : public cSingleton<cImageGDIPType>
                , public IImageCreator
        {
                friend class cSingleton<cImageGDIPType>;
 
        public:
                ULONG_PTR m_gdiplusToken;
 
        protected:
                cImageGDIPType();
                ~cImageGDIPType();
 
        public:
                bool StartupGDIP();
                void ShutdownGDIP();
 
                virtual bool IsFileExt(const FILECHAR_t* pszFileExt) const
                {
                        UNREFERENCED_PARAMETER(pszFileExt);
                        return true;
                }
                virtual cImageBasePtr CreateObject() const override
                {
                        return new cImageGDIP;
                }
        };
};
#endif //  _WIN32
#endif