region.h

 
#pragma once
 
#include "fwd.h"
 
#include "drawing/rectangle_f.h"
#include "drawing/drawing2d/combine_mode.h"
#include "drawing/drawing2d/matrix.h"
#include "drawing/drawing2d/graphics_path.h"
#include "drawing/drawing2d/region_data.h"
#include "system/exceptions.h"
#include "system/shared_ptr.h"
 
#include <memory>
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include <core/SkRegion.h>
#endif
 
ASPOSECPP_3RD_PARTY_CLASS(SkRegion);
ASPOSECPP_3RD_PARTY_STRUCT(SkIRect);
ASPOSECPP_3RD_PARTY_STRUCT(SkRect);
ASPOSECPP_3RD_PARTY_CLASS(SkMatrix);
ASPOSECPP_3RD_PARTY_CLASS(SkPath);
 
namespace System { namespace Drawing { namespace Details { namespace Region { class BaseRegionDataNode; } } } }
namespace System { namespace Drawing { namespace Details { namespace Skia { class SkiaData; } } } }
 
namespace System { namespace Drawing {
 
class Graphics;
class ASPOSECPP_SHARED_CLASS Region : public Object
{
    RTTI_INFO(System::Drawing::Region, ::System::BaseTypesInfo<System::Object>)
public:
    using Object::Equals;
 
    ASPOSECPP_SHARED_API Region();
    ASPOSECPP_SHARED_API Region(const RectangleF& rect);
    ASPOSECPP_SHARED_API Region(const Rectangle& rect);
    ASPOSECPP_SHARED_API Region(const SharedPtr<Drawing2D::GraphicsPath>& path);
    ASPOSECPP_SHARED_API Region(const SkPath& path);
    ASPOSECPP_SHARED_API Region(const SharedPtr<Drawing2D::RegionData>& region_data);
 
    virtual ASPOSECPP_SHARED_API ~Region();
 
    ASPOSECPP_SHARED_API ArrayPtr<RectangleF> GetRegionScans(const SharedPtr<Drawing2D::Matrix>& matrix) const;
 
    ASPOSECPP_SHARED_API RectangleF GetBounds(const SharedPtr<Graphics>& graphics) const;
 
    ASPOSECPP_SHARED_API void Union(const RectangleF & rect);
 
    ASPOSECPP_SHARED_API void Union(const Rectangle & rect);
 
    ASPOSECPP_SHARED_API void Union(const SharedPtr<Drawing2D::GraphicsPath>& path);
 
    ASPOSECPP_SHARED_API void Union(const SharedPtr<Region>& region);
 
    ASPOSECPP_SHARED_API SharedPtr<Region> Clone() const;
 
    ASPOSECPP_SHARED_API void Intersect(const RectangleF & rect);
 
    ASPOSECPP_SHARED_API void Intersect(const Rectangle & rect);
 
    ASPOSECPP_SHARED_API void Intersect(const SharedPtr<Drawing2D::GraphicsPath>& path);
 
    ASPOSECPP_SHARED_API void Intersect(const SharedPtr<Region>& region);
 
    ASPOSECPP_SHARED_API void Exclude(const RectangleF & rect);
 
    ASPOSECPP_SHARED_API void Exclude(const Rectangle & rect);
 
    ASPOSECPP_SHARED_API void Exclude(const SharedPtr<Drawing2D::GraphicsPath>& path);
 
    ASPOSECPP_SHARED_API void Exclude(const SharedPtr<Region>& region);
 
    ASPOSECPP_SHARED_API void Translate(int dx, int dy);
    ASPOSECPP_SHARED_API void Translate(float dx, float dy);
    ASPOSECPP_SHARED_API void Transform(const SharedPtr<Drawing2D::Matrix>& matrix);
 
    ASPOSECPP_SHARED_API void Transform(const SkMatrix& matrix);
 
    ASPOSECPP_SHARED_API void Complement(const RectangleF & rect);
 
    ASPOSECPP_SHARED_API void Complement(const Rectangle & rect);
 
    ASPOSECPP_SHARED_API void Complement(const SharedPtr<Drawing2D::GraphicsPath>& path);
 
    ASPOSECPP_SHARED_API void Complement(const SharedPtr<Region>& region);
 
    ASPOSECPP_SHARED_API void Xor(const RectangleF & rect);
    ASPOSECPP_SHARED_API void Xor(const Rectangle & rect);
    ASPOSECPP_SHARED_API void Xor(const SharedPtr<Drawing2D::GraphicsPath>& path);
    ASPOSECPP_SHARED_API void Xor(const SharedPtr<Region>& region);
 
    ASPOSECPP_SHARED_API bool Equals(const SharedPtr<Region>& r, const SharedPtr<Graphics>& g);
 
    ASPOSECPP_SHARED_API bool IsEmpty(const SharedPtr<Graphics>& g) const;
 
    ASPOSECPP_SHARED_API bool IsInfinite(const SharedPtr<Graphics>& g) const;
 
    ASPOSECPP_SHARED_API bool IsVisible(const Point& point) const;
    ASPOSECPP_SHARED_API bool IsVisible(const PointF& point) const;
    ASPOSECPP_SHARED_API bool IsVisible(const Rectangle& rect);
    ASPOSECPP_SHARED_API bool IsVisible(const RectangleF& rect);
    ASPOSECPP_SHARED_API bool IsVisible(const Point& point, const SharedPtr<Graphics>& graphics) const;
    ASPOSECPP_SHARED_API bool IsVisible(const PointF& point, const SharedPtr<Graphics>& graphics) const;
    ASPOSECPP_SHARED_API bool IsVisible(const Rectangle& rect, const SharedPtr<Graphics>& graphics);
    ASPOSECPP_SHARED_API bool IsVisible(const RectangleF& rect, const SharedPtr<Graphics>& graphics);
    ASPOSECPP_SHARED_API bool IsVisible(float x, float y) const;
    ASPOSECPP_SHARED_API bool IsVisible(float x, float y, const SharedPtr<Graphics>& graphics) const;
 
    void Dispose() {}
    ASPOSECPP_SHARED_API void MakeInfinite();
    ASPOSECPP_SHARED_API void MakeEmpty();
    ASPOSECPP_SHARED_API SharedPtr<Drawing2D::RegionData> GetRegionData() const;
 
private:
    friend class Graphics;
    friend class Details::Skia::SkiaData;
 
    SharedPtr<Details::Region::BaseRegionDataNode> m_nodeRegion;
 
    void GetSkiaPath(SkPath& path);
 
    SharedPtr<Details::Region::BaseRegionDataNode> get_RegionNode() const;
 
    bool IsInfinite() const;
 
    void ApplyOperation(const SharedPtr<Details::Region::BaseRegionDataNode>& node, Drawing2D::CombineMode operationType);
    void ApplyOperation(const SharedPtr<Region>& region, Drawing2D::CombineMode operationType);
};
 
}} // System::Drawing