bitmap.h

 
#ifndef _aspose_system_drawing_bitmap_h_
#define _aspose_system_drawing_bitmap_h_
 
#include "fwd.h"
#include "defines.h"
#include "drawing/image.h"
#include "drawing/color.h"
#include "drawing/rectangle.h"
#include "drawing/rectangle_f.h"
#include "drawing/imaging/bitmap_data.h"
#include "drawing/imaging/pixel_format.h"
#include "drawing/imaging/image_lock_mode.h"
#include "drawing/size_f.h"
#include "system/io/stream.h"
#include "system/string.h"
 
#include <memory>
 
#if defined(ASPOSECPPLIB_BEING_BUILT) || defined(ASPOSECPP_SKIA_EXTERNAL_USAGE)
#include <core/SkEncodedImageFormat.h>
#include <core/SkBitmap.h>
#include <core/SkCanvas.h>
#endif
 
ASPOSECPP_3RD_PARTY_CLASS(SkBitmap);
ASPOSECPP_3RD_PARTY_CLASS(SkCanvas);
ASPOSECPP_3RD_PARTY_CLASS(SkData);
ASPOSECPP_3RD_PARTY_CLASS(SkWStream);
ASPOSECPP_3RD_PARTY_CLASS(SkMatrix);
ASPOSECPP_3RD_PARTY_STRUCT(SkImageInfo);
ASPOSECPP_3RD_PARTY_STRUCT(SkRect);
ASPOSECPP_3RD_PARTY_TYPEDEF(SkColor, uint32_t);
 
#if defined(ASPOSECPPLIB_BEING_BUILT) || !defined(ASPOSECPP_SKIA_EXTERNAL_USAGE)
// Static checks of SkEncodedImageFormat enum.
ASPOSECPP_3RD_PARTY_ENUM_CLASS(SkEncodedImageFormat);
#endif
 
namespace System { namespace Drawing {
 
namespace Detail {
    ASPOSECPP_3RD_PARTY_ENUM_HOLDER(SkEncodedImageFormat, int, SkEncodedFormatHolder);
}
 
namespace Imaging { class Metafile; }
 
class Graphics;
class ASPOSECPP_SHARED_CLASS Bitmap : public Image
{
    RTTI_INFO(System::Drawing::Bitmap, ::System::BaseTypesInfo<System::Drawing::Image>)
 
public:
    ASPOSECPP_SHARED_API Bitmap(const SharedPtr<Image>& original);
    ASPOSECPP_SHARED_API Bitmap(const SharedPtr<System::IO::Stream>& stream, bool useIcm = false);
    ASPOSECPP_SHARED_API Bitmap(const String & filename);
    ASPOSECPP_SHARED_API Bitmap(const String & filename, bool useIcm);
    ASPOSECPP_SHARED_API Bitmap(int width, int height, Imaging::PixelFormat format = Imaging::PixelFormat::Format32bppArgb);
    ASPOSECPP_SHARED_API Bitmap(const SharedPtr<Image>& original, const Size &size);
    ASPOSECPP_SHARED_API Bitmap(const SharedPtr<Image>& original, int width, int height);
    MEMBER_FUNCTION_MAKE_OBJECT(Bitmap, CODEPORTING_ARGS(const SharedPtr<Image>& original, int width, int height), CODEPORTING_ARGS(original, width, height));
 
    virtual ASPOSECPP_SHARED_API int get_Width() const override;
    virtual ASPOSECPP_SHARED_API int get_Height() const override;
 
    virtual ASPOSECPP_SHARED_API Imaging::ImageFormatPtr get_RawFormat() const override;
    virtual ASPOSECPP_SHARED_API Imaging::PixelFormat get_PixelFormat() const override;
 
    virtual ASPOSECPP_SHARED_API Imaging::ColorPalettePtr get_Palette() const override;
    ASPOSECPP_SHARED_API void set_Palette(Imaging::ColorPalettePtr value) override;
 
    ASPOSECPP_SHARED_API void SetResolution(float xDpi, float yDpi);
    ASPOSECPP_SHARED_API void SetPixel(int x, int y, Color color);
 
    ASPOSECPP_SHARED_API Imaging::BitmapDataPtr LockBits(const Rectangle & rect, Imaging::ImageLockMode flags, Imaging::PixelFormat format);
    
    ASPOSECPP_SHARED_API Imaging::BitmapDataPtr LockBits(const Rectangle & rect, Imaging::ImageLockMode flags, Imaging::PixelFormat format, const Imaging::BitmapDataPtr& bitmap_data);
    ASPOSECPP_SHARED_API void UnlockBits(const Imaging::BitmapDataPtr& bitmap_data);
    ASPOSECPP_SHARED_API Color GetPixel(int x, int y);
 
    ASPOSECPP_SHARED_API void MakeTransparent(Color transparent_color = Color::get_LightGray());
 
    ASPOSECPP_SHARED_API IntPtr GetHbitmap();
 
    virtual ASPOSECPP_SHARED_API SharedPtr<Image> Clone() override;
    ASPOSECPP_SHARED_API SharedPtr<Bitmap> Clone(Rectangle rect, Imaging::PixelFormat format);
    ASPOSECPP_SHARED_API SharedPtr<Bitmap> Clone(RectangleF rect, Imaging::PixelFormat format);
 
    virtual ASPOSECPP_SHARED_API void RotateFlip(RotateFlipType rotate_flip_type) override;
 
    // it must be public for manually implemented code parts
    virtual ASPOSECPP_SHARED_API const SkBitmap* GetSkBitmap() const override;
 
    virtual ASPOSECPP_SHARED_API bool IsMultiImage() const override;
 
    // Service method used in manually implemented code parts
    static ASPOSECPP_SHARED_API SharedPtr<Bitmap> ConvertToARGBImage(const SharedPtr<Bitmap>& src_bmp);
 
    //service method used in manually implemented code parts
    ASPOSECPP_SHARED_API void PremultipleColors();
 
    //service method used in manually implemented code parts
    ASPOSECPP_SHARED_API bool BeginPixelProcessing(bool update_colors = true);
 
    //service method used in manually implemented code parts
    ASPOSECPP_SHARED_API bool EndPixelProcessing(bool update_colors = true);
 
    //service method used in manually implemented code parts
    ASPOSECPP_SHARED_API ArrayPtr<uint8_t> ComputeHash();
 
private:
    void PutRawBytesBmp(SkWStream *to);
    static sk_sp<SkColorTable> CreatePalette(Imaging::PixelFormat pixel_format);
    sk_sp<SkColorTable> ChoosePalette(Imaging::PixelFormat pixel_format) const;
 
    Imaging::PixelFormat m_original_pixel_format = Imaging::PixelFormat::Undefined;
 
    bool m_is_multi_image = false;
 
    bool m_pixel_processing_mode = false;
 
    static const SkColor s_bw_colors[];
    static const SkColor s_indexed_colors[];
    static const SkColor s_gray_colors[];
 
 
protected:
    friend class Graphics;
    friend class Imaging::Metafile;
 
protected:
    ASPOSECPP_SHARED_API ~Bitmap() override;
    ASPOSECPP_SHARED_API Bitmap(const SharedPtr<Bitmap>& original, Rectangle rect, Imaging::PixelFormat format);
    MEMBER_FUNCTION_MAKE_OBJECT(Bitmap, CODEPORTING_ARGS(const SharedPtr<Bitmap>& original, Rectangle rect, Imaging::PixelFormat format), CODEPORTING_ARGS(original, rect, format));
    ASPOSECPP_SHARED_API bool GetSkBitmapFromArray(const ArrayPtr<uint8_t>& data);
    virtual ASPOSECPP_SHARED_API std::unique_ptr<SkCanvas> GetDrawingCanvas() const override;
    virtual ASPOSECPP_SHARED_API sk_sp<SkData> GetRawBytes(SkEncodedImageFormat encoder_type, int quality) override;
    virtual ASPOSECPP_SHARED_API const SkEncodedImageFormat GetSkEncodedFormat() const override;
    virtual Imaging::PixelFormat GetOriginalFormat() const override { return m_original_pixel_format; }
 
    virtual void Draw(SkCanvas* sk_canvas, const SkRect& dest_rect, const SkRect& src_rect, SkMatrix* matrix, SkFilterQuality quality, SkBlendMode blend_mode) const override;
    virtual void Draw(SkCanvas* sk_canvas, const SkRect& dest_rect, SkMatrix* matrix, SkFilterQuality quality, SkBlendMode blend_mode) const override;
    virtual void Draw(SkCanvas* sk_canvas, ArrayPtr<PointF> dest_points, const SkRect& src_rect, SkMatrix* matrix, SkFilterQuality quality, SkBlendMode blend_mode) const override;
    virtual void Draw(SkCanvas* sk_canvas, const System::Details::ArrayView<PointF>& dest_points, const SkRect& src_rect, SkMatrix* matrix, SkFilterQuality quality, SkBlendMode blend_mode) const override;
 
    std::unique_ptr<SkBitmap> m_sk_bitmap;
    Detail::SkEncodedFormatHolder m_sk_encoded_format;
    Imaging::ImageLockMode m_lock_mode = (Imaging::ImageLockMode)0;
};
 
}}
 
 
#endif