initial commit

Signed-off-by: Peter Siegmund <mars3142@noreply.mars3142.dev>

libs/wxWidgets-3.3.1/include/wx/msw/dib.h

@@ -0,0 +1,243 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/msw/dib.h
+// Purpose:     wxDIB class representing Win32 device independent bitmaps
+// Author:      Vadim Zeitlin
+// Created:     03.03.03 (replaces the old file with the same name)
+// Copyright:   (c) 1997-2003 wxWidgets team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MSW_DIB_H_
+#define _WX_MSW_DIB_H_
+
+class WXDLLIMPEXP_FWD_CORE wxPalette;
+
+#include "wx/msw/private.h"
+
+#if wxUSE_WXDIB
+
+#ifdef __WXMSW__
+    #include "wx/bitmap.h"
+#endif // __WXMSW__
+
+// ----------------------------------------------------------------------------
+// wxDIB: represents a DIB section
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxDIB
+{
+public:
+    // ctors and such
+    // --------------
+
+    // create an uninitialized DIB with the given width, height and depth (only
+    // 24 and 32 bpp DIBs are currently supported)
+    //
+    // after using this ctor, GetData() and GetHandle() may be used if IsOk()
+    // returns true
+    wxDIB(int width, int height, int depth)
+        { (void)Create(width, height, depth); }
+
+#ifdef __WXMSW__
+    // create a DIB from the DDB
+    wxDIB(const wxBitmap& bmp, int depth = -1)
+        { (void)Create(bmp, depth); }
+#endif // __WXMSW__
+
+    // create a DIB from the Windows DDB
+    wxDIB(HBITMAP hbmp)
+        { (void)Create(hbmp); }
+
+    // load a DIB from file (any depth is supported here unlike above)
+    //
+    // as above, use IsOk() to see if the bitmap was loaded successfully
+    wxDIB(const wxString& filename)
+        { (void)Load(filename); }
+
+    // same as the corresponding ctors but with return value
+    bool Create(int width, int height, int depth);
+#ifdef __WXMSW__
+    bool Create(const wxBitmap& bmp, int depth = -1) { return Create(GetHbitmapOf(bmp), depth); }
+#endif
+    bool Create(HBITMAP hbmp, int depth = -1);
+    bool Load(const wxString& filename);
+
+    // dtor is not virtual, this class is not meant to be used polymorphically
+    ~wxDIB()
+    {
+        if ( m_handle && m_ownsHandle )
+        {
+            if ( !::DeleteObject(m_handle) )
+            {
+                wxLogLastError(wxT("DeleteObject(hDIB)"));
+            }
+        }
+    }
+
+
+    // operations
+    // ----------
+
+    // create a bitmap compatible with the given HDC (or screen by default) and
+    // return its handle, the caller is responsible for freeing it (using
+    // DeleteObject())
+    HBITMAP CreateDDB(HDC hdc = nullptr) const;
+
+    // get the handle from the DIB and reset it, i.e. this object won't destroy
+    // the DIB after this (but the caller should do it)
+    HBITMAP Detach() { HBITMAP hbmp = m_handle; m_handle = nullptr; return hbmp; }
+
+#if defined(__WXMSW__) && wxUSE_PALETTE
+    // create a palette for this DIB (always a trivial/default one for 24bpp)
+    wxPalette *CreatePalette() const;
+#endif // defined(__WXMSW__) && wxUSE_PALETTE
+
+    // save the DIB as a .BMP file to the file with the given name
+    bool Save(const wxString& filename);
+
+
+    // accessors
+    // ---------
+
+    // return true if DIB was successfully created, false otherwise
+    bool IsOk() const { return m_handle != nullptr; }
+
+    // get the bitmap size
+    wxSize GetSize() const { DoGetObject(); return wxSize(m_width, m_height); }
+    int GetWidth() const { DoGetObject(); return m_width; }
+    int GetHeight() const { DoGetObject(); return m_height; }
+
+    // get the number of bits per pixel, or depth
+    int GetDepth() const { DoGetObject(); return m_depth; }
+
+    // get the DIB handle
+    HBITMAP GetHandle() const { return m_handle; }
+
+    // get raw pointer to bitmap bits, you should know what you do if you
+    // decide to use it
+    unsigned char *GetData() const
+        { DoGetObject(); return (unsigned char *)m_data; }
+
+
+    // HBITMAP conversion
+    // ------------------
+
+    // these functions are only used by wxWidgets internally right now, please
+    // don't use them directly if possible as they're subject to change
+
+    // creates a DDB compatible with the given (or screen) DC from either
+    // a plain DIB or a DIB section (in which case the last parameter must be
+    // non null)
+    static HBITMAP ConvertToBitmap(const BITMAPINFO *pbi,
+                                   HDC hdc = nullptr,
+                                   const void *bits = nullptr);
+
+    // create a plain DIB (not a DIB section) from a DDB, the caller is
+    // responsible for freeing it using ::GlobalFree()
+    static HGLOBAL ConvertFromBitmap(HBITMAP hbmp);
+
+    // creates a DIB from the given DDB or calculates the space needed by it:
+    // if pbi is null, only the space is calculated, otherwise pbi is supposed
+    // to point at BITMAPINFO of the correct size which is filled by this
+    // function (this overload is needed for wxBitmapDataObject code in
+    // src/msw/ole/dataobj.cpp)
+    static size_t ConvertFromBitmap(BITMAPINFO *pbi, HBITMAP hbmp);
+
+
+    // wxImage conversion
+    // ------------------
+
+#if wxUSE_IMAGE
+    // Possible formats for DIBs created by the functions below.
+    enum PixelFormat
+    {
+        PixelFormat_PreMultiplied = 0,
+        PixelFormat_NotPreMultiplied = 1
+    };
+
+    // Create a DIB from the given image, the DIB will be either 24 or 32 (if
+    // the image has alpha channel) bpp.
+    //
+    // By default the DIB stores pixel data in pre-multiplied format so that it
+    // can be used with ::AlphaBlend() but it is also possible to disable
+    // pre-multiplication for the DIB to be usable with ImageList_Draw() which
+    // does pre-multiplication internally.
+    wxDIB(const wxImage& image, PixelFormat pf = PixelFormat_PreMultiplied, int depth = -1)
+    {
+        (void)Create(image, pf, depth);
+    }
+
+    // same as the above ctor but with the return code
+    bool Create(const wxImage& image, PixelFormat pf = PixelFormat_PreMultiplied, int depth = -1);
+
+    // create wxImage having the same data as this DIB
+
+    // Possible options of conversion to wxImage
+    enum ConversionFlags
+    {
+        // Determine whether 32bpp DIB contains real alpha channel
+        // and return wxImage with or without alpha channel values.
+        Convert_AlphaAuto,
+        // Assume that 32bpp DIB contains valid alpha channel and always
+        // return wxImage with alpha channel values in this case.
+        Convert_AlphaAlwaysIf32bpp
+    };
+    wxImage ConvertToImage(ConversionFlags flags = Convert_AlphaAuto) const;
+#endif // wxUSE_IMAGE
+
+
+    // helper functions
+    // ----------------
+
+    // return the size of one line in a DIB with given width and depth: the
+    // point here is that as the scan lines need to be DWORD aligned so we may
+    // need to add some padding
+    static unsigned long GetLineSize(int width, int depth)
+    {
+        return ((width*depth + 31) & ~31) >> 3;
+    }
+
+private:
+    // initialize the contents from the provided DDB (Create() must have been
+    // already called)
+    bool CopyFromDDB(HBITMAP hbmp);
+
+
+    // the DIB section handle, 0 if invalid
+    HBITMAP m_handle = nullptr;
+
+    // NB: we could store only m_handle and not any of the other fields as
+    //     we may always retrieve them from it using ::GetObject(), but we
+    //     decide to still store them for efficiency concerns -- however if we
+    //     don't have them from the very beginning (e.g. DIB constructed from a
+    //     bitmap), we only retrieve them when necessary and so these fields
+    //     should *never* be accessed directly, even from inside wxDIB code
+
+    // function which must be called before accessing any members and which
+    // gets their values from m_handle, if not done yet
+    void DoGetObject() const;
+
+    // pointer to DIB bits, may be null
+    void *m_data = nullptr;
+
+    // size and depth of the image
+    int m_width = 0,
+        m_height = 0,
+        m_depth = 0;
+
+    // in some cases we could be using a handle which we didn't create and in
+    // this case we shouldn't free it either -- this flag tell us if this is
+    // the case
+    bool m_ownsHandle = true;
+
+
+    // DIBs can't be copied
+    wxDIB(const wxDIB&) = delete;
+    wxDIB& operator=(const wxDIB&) = delete;
+};
+
+#endif
+    // wxUSE_WXDIB
+
+#endif // _WX_MSW_DIB_H_
+