graphics.hpp

#pragma once
#if !defined(__XTD_DRAWING_NATIVE_LIBRARY__)
#error "Do not include this file: Internal use only"
#endif
 
#include <cstdint>
#include <tuple>
#include <xtd/collections/generic/key_value_pair>
#include <xtd/static>
#include <xtd/string>
#include <xtd/drawing_native_export.hpp>
#include "hot_key_prefixes.hpp"
#include "path_fill_modes.hpp"
 
namespace xtd {
  namespace drawing {
    class graphics;
    
    namespace native {
      class drawing_native_export_ graphics final static_ {
        friend xtd::drawing::graphics;
      protected:
        
        static void copy_from_graphics(intptr handle, intptr handle_source, int32 source_x, int32 source_y, int32 destination_x, int32 destination_y, int32 block_region_width, int32 block_region_height, int32 copy_pixel_operation);
        static void clear(intptr handle, xtd::byte a, xtd::byte r, xtd::byte g, xtd::byte b);
        
        static void clip(intptr handle, intptr region);
        
        static void compositing_mode(intptr handle, int32 compositing_mode);
        
        static void compositing_quality(intptr handle, int32 compositing_quality);
        
        static void copy_from_screen(intptr handle, int32 source_x, int32 source_y, int32 destination_x, int32 destination_y, int32 block_region_width, int32 block_region_height, int32 copy_pixel_operation);
        
        static void destroy(intptr handle);
        
        static void draw_arc(intptr handle, intptr pen, float x, float y, float width, float height, float start_angle, float sweep_angle);
        
        static void draw_bezier(intptr handle, intptr pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);
        
        static void draw_beziers(intptr handle, intptr pen, const std::vector<xtd::collections::generic::key_value_pair<float, float>>& points);
        
        static void draw_closed_curve(intptr handle, intptr pen, std::vector<xtd::collections::generic::key_value_pair<float, float>> points, float tension);
        
        static void draw_curve(intptr handle, intptr pen, std::vector<xtd::collections::generic::key_value_pair<float, float>> points, float tension);
        
        static void draw_ellipse(intptr handle, intptr pen, float x, float y, float width, float heigh);
        
        static void draw_image(intptr handle, intptr image, float x, float y, float width, float height);
        
        static void draw_image(intptr handle, intptr image, float dest_x, float dest_y, float dest_width, float dest_height, float src_x, float src_y, float src_width, float src_height);
 
        static void draw_image_disabled(intptr handle, intptr image, float x, float y, float width, float height, float brightness);
        
        static void draw_line(intptr handle, intptr pen, float x1, float y1, float x2, float y2);
        
        static void draw_lines(intptr handle, intptr pen, const std::vector<xtd::collections::generic::key_value_pair<float, float>>& points);
        
        static void draw_path(intptr handle, intptr pen, intptr graphics_path);
        
        static void draw_pie(intptr handle, intptr pen, float x, float y, float width, float height, float start_angle, float sweep_angle);
        
        static void draw_polygon(intptr handle, intptr pen, const std::vector<xtd::collections::generic::key_value_pair<float, float>>& points);
        
        static void draw_rectangle(intptr handle, intptr pen, float x, float y, float width, float height);
        
        static void draw_rectangles(intptr handle, intptr pen, std::vector<std::tuple<float, float, float, float>>& rects);
        
        static void draw_rotated_string(intptr handle, const xtd::string& text, intptr font, intptr brush, float x, float y, float angle);
        
        static void draw_rounded_rectangle(intptr handle, intptr pen, float x, float y, float width, float height, float radius);
        
        static void draw_string(intptr handle, const xtd::string& text, intptr font, intptr brush, float x, float y, int32 alignment, int32 line_alignment, int32 hot_key_prefix, int32 trimming);
        static void draw_string(intptr handle, const xtd::string& text, intptr font, intptr brush, float x, float y, float width, float height, int32 alignment, int32 line_alignment, int32 hot_key_prefix, int32 trimming, int32 string_formats);
        
        static void fill_closed_curve(intptr handle, intptr brush, std::vector<xtd::collections::generic::key_value_pair<float, float>> points, uint32 fill_mode, float tension);
        
        static void fill_ellipse(intptr handle, intptr brush, float x, float y, float width, float heigh);
        
        static void fill_path(intptr handle, intptr brush, intptr graphics_path, int32 mode);
        
        static void fill_pie(intptr handle, intptr brush, float x, float y, float width, float height, float start_angle, float sweep_angle);
        
        static void fill_polygon(intptr handle, intptr pen, const std::vector<xtd::collections::generic::key_value_pair<float, float>>& points, int32 fill_mode);
        
        static void fill_rectangle(intptr handle, intptr brush, float x, float y, float width, float height);
        
        static void fill_rectangles(intptr handle, intptr brush, std::vector<std::tuple<float, float, float, float>>& rects);
        
        static void fill_region(intptr handle, intptr brush, intptr region);
        
        static void fill_rounded_rectangle(intptr handle, intptr brush, float x, float y, float width, float height, float radius);
        
        static void flush(intptr handle, int32 intention);
        
        static intptr from_hdc(intptr hdc);
        static intptr from_hdc(intptr hdc, intptr hdevice);
        
        static intptr from_hwnd(intptr hwnd);
        
        static intptr from_image(intptr image);
        
        static float get_dpi_x(intptr handle);
        
        static float get_dpi_y(intptr handle);
        
        static intptr get_hdc(intptr handle);
        
        static void get_nearest_color(intptr handle, xtd::byte original_a, xtd::byte original_r, xtd::byte original_g, xtd::byte original_b, xtd::byte& nearest_a, xtd::byte& nearest_r, xtd::byte& nearest_g, xtd::byte& nearest_b);
        
        static void interpolation_mode(intptr handle, int32 interpolation_mode);
        
        static void pixel_offset_mode(intptr handle, int32 pixel_offst_mode);
        
        static void measure_string(intptr handle, const xtd::string& text, intptr font, float& width, float& height, float max_width, float max_height, int32 alignment, int32 line_alignment, int32 hot_key_prefix, int32 trimming, size_t characters_fitted, size_t lines_filled, bool measure_trailing_spaces);
        
        static void release_hdc(intptr handle, intptr hdc);
        
        static void reset_transform(intptr handle);
        
        static void restore(intptr handle, intptr& gstate);
        
        static void rotate_transform(intptr handle, float angle, int32 order);
        
        static intptr save(intptr handle);
        
        static void scale_transform(intptr handle, float sx, float sy, int32 order);
        
        static void smoothing_mode(intptr handle, int32 smoothing_mode);
        
        static void text_contrast(intptr handle, int32 text_contrast);
        
        static void text_rendering_hint(intptr handle, int32 text_rendering_hint);
        
        static intptr transform(intptr handle);
        static void transform(intptr handle, intptr matrix);
        
        static void translate_transform(intptr handle, float dx, float dy, int32 order);
        
        static xtd::string trim_string(intptr handle, const xtd::string& text, intptr font, float width, int32 trimming);
        
        static void visible_clip_bounds(intptr handle, float& x, float& y, float& width, float& height);
      };
    }
  }
}