cImageBMP.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cImageBMP_H
#define _INC_cImageBMP_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cImageBase.h"
#include "GrayCore/include/cAppState.h"
#include "GrayCore/include/cBits.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/cFilePath.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cImageBMP);
 
        class GRAYLIB_LINK cImageBMP
                : public cImageBase // The device independent bitmap.
        {
 
                typedef cImageBase SUPER_t;
 
        public:
                static const WORD k_DIB_HEADER_MARKER = ((WORD)('M' << 8) | 'B');
        private:
                cSurfaceBitmapInfo* m_pBMI;     
 
        private:
                void InitSurfaceBitmap(const cSurfaceBitmapInfo* pBMI);
        public:
                cImageBMP() noexcept;
                cImageBMP(const cSurfaceBitmapInfo* pBMI);
                cImageBMP(const FILECHAR_t* pszFileNameBMP);
                virtual ~cImageBMP();
 
                virtual void SetEmpty() override;
 
                virtual bool isValidImage() const noexcept override
                {
                        return cMem::IsValid(this) && m_pBMI != nullptr;
                }
 
                WORD get_BitsPerPixel(void) const
                {
                        return m_pBMI->get_BitsPerPixel() ;
                }
                size_t get_ImageSize(void) const
                {
                        ASSERT(m_pBMI != nullptr);
                        return m_pBMI->get_ImageSize() ;
                }
 
                cSurfaceBitmapInfo* get_BMI() const
                {
                        return m_pBMI;
                }
                size_t get_HeaderSize(void) const
                {
                        ASSERT(m_pBMI != nullptr);
                        return m_pBMI->bmiHeader.biSize ;
                }
                size_t get_TotalSize(void) const
                {
                        return m_pBMI->get_TotalSize() ;
                }
 
                WORD get_NumColors(void) const
                {
                        return m_pBMI->get_NumColors() ;
                }
                size_t get_ColorSize(void) const  // Size of the palette info.
                {
                        // bmiHeader.biClrUsed
                        return m_pBMI->get_ColorSize() ;
                }
                tagRGBQUAD* get_PaletteColors() const   // COLORREF
                {
                        return m_pBMI->get_ColorTablePtr();
                }
 
                HRESULT CreateSurface(const cSurfaceBitmapInfo* pBMI);
                HRESULT CreateSurfaceBC(const cSurfaceInfo& rInfo);
                HRESULT CreateSurfaceBC(PIXELS_t x, PIXELS_t y, BIT_ENUM_t iBitsPerPixel, int nColorQtyUsed = 0);
 
                HRESULT ReadBMP(cStreamInput& file, bool bHeader = true, bool bData = true);
                HRESULT WriteBMP(cStreamOutput* pFile, bool bHeader = true) const;
 
                virtual HRESULT ReadStream(cStreamInput& strIn) override
                {
                        return ReadBMP(strIn, true);
                }
                virtual HRESULT WriteStream(cStreamOutput* pFile) const override
                {
                        return WriteBMP(pFile, true);
                }
 
                virtual HRESULT SetCopySurface(const cSurfaceBase& Surf) override;
#ifdef _WIN32
                HRESULT SetCopyBitmap(HBITMAP hBitmap, HPALETTE hPal = WINHANDLE_NULL);
#endif
 
                UNITTEST2_PREDEF(cImageBMP);
        };
 
        class GRAYLIB_LINK cImageBMPType
                : public IImageCreator
                , public cSingleton<cImageBMPType>
        {
        public:
                cImageBMPType()
                        : cSingleton<cImageBMPType>(this, typeid(cImageBMPType))
                {
                }
                virtual bool IsFileExt(const FILECHAR_t* pszFileExt) const
                {
                        return cFilePath::IsFileNameExt(pszFileExt, _FN(".bmp"));
                }
                virtual cImageBasePtr CreateObject() const override
                {
                        return new cImageBMP;
                }
        };
};
#endif // _INC_cImageBMP_H