control.h

Go to the documentation of this file.

#pragma once
#include <any>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <thread>
#include <vector>
#include <xtd/iasync_result.h>
#include <xtd/drawing/color.h>
#include <xtd/drawing/font.h>
#include <xtd/drawing/point.h>
#include <xtd/drawing/rectangle.h>
#include <xtd/drawing/size.h>
#include <xtd/forms/create_params.h>

#include "../forms_export.h"
#include "layout/arranged_element_collection.h"
#include "anchor_styles.h"
#include "auto_size_mode.h"
#include "bounds_specified.h"
#include "component.h"
#include "context_menu.h"
#include "control_appearance.h"
#include "control_event_handler.h"
#include "control_ref.h"
#include "control_styles.h"
#include "cursors.h"
#include "dock_style.h"
#include "help_event_handler.h"
#include "image_layout.h"
#include "iwin32_window.h"
#include "key_event_handler.h"
#include "key_press_event_handler.h"
#include "mouse_event_handler.h"
#include "padding.h"
#include "paint_event_handler.h"
#include "message.h"
#include "theme_colors.h"
#include "timer.h"
#include "style_sheets/style_sheet.h"
#include "visual_styles/control_state.h"

namespace xtd {
  namespace forms {
    class application;
    class context_menu;
    class screen;
    
    class forms_export_ control : public component, public iwin32_window {
    protected:
      enum class state {
        empty = 0,
        creating = 0b1,
        created = 0b10,
        destroying = 0b100,
        destroyed = 0b1000,
        creating_handle = 0b10000,
        recreate = 0b100000,
        parent_recreating = 0b1000000,
        
        client_size_setted = 0b10000000,
        modal = 0b100000000,
        top_level = 0b1000000000,
        visible = 0b10000000000,
        enabled = 0b100000000000,
        auto_size = 0b1000000000000,
        tab_stop = 0b10000000000000,
        allow_drop = 0b100000000000000,
        drop_target = 0b1000000000000000,
        
        layout_deferred = 0b10000000000000000,
        docked = 0b100000000000000000,
        
        double_click_fired = 0b1000000000000000000,
        double_buffered = 0b10000000000000000000,
        /*
        mouse_enter_pending = 0,
        tracking_mouse_event = 0,
        mouse_pressed = 0,
        use_wait_cursor = 0,
         */
        
        /*
        is_accessible = 0,
        no_zorder = 0,
        size_locked_by_os = 0,
        causes_validation = 0,
        own_ctl_brush = 0,
        exception_while_painting = 0,
        layout_sis_dirty = 0,
        checked_host = 0,
        hosted_in_dialog = 0,
        validation_cancelled = 0,
        mirrored = 0,
        */
      };
      
      class async_result_invoke : public xtd::iasync_result {
      public:
        explicit async_result_invoke(std::any async_state) : async_state_(async_state) {}
        std::any async_state() const noexcept override {return async_state_;}
        std::shared_mutex& async_mutex() override {return *async_mutex_;}
        bool completed_synchronously() const noexcept override {return false;}
        bool is_completed() const noexcept override {return *is_completed_;};
        
        std::any async_state_;
        std::shared_ptr<bool> is_completed_ = std::make_shared<bool>(false);
        std::shared_ptr<std::shared_mutex> async_mutex_ = std::make_shared<std::shared_mutex>();
      };
      
    public:
      class control_collection : public xtd::forms::layout::arranged_element_collection<control_ref> {
      public:
        
        using base = xtd::forms::layout::arranged_element_collection<control_ref>;
        
        
        explicit control_collection(const allocator_type& allocator = allocator_type());
        
        explicit control_collection(const base& collection);
        control_collection(const control_collection& collection);
        control_collection& operator=(const control_collection& collection);
        control_collection(control_collection&&) = default;
        
        
        using base::operator[];
        std::optional<value_type> operator[](const xtd::ustring& name) const;
        std::optional<value_type> operator[](const xtd::ustring& name);
      };
      
      
      control();
      explicit control(const xtd::ustring& text) : control() {
        this->text(text);
      }
      explicit control(const control& parent, const xtd::ustring& text) : control() {
        this->parent(parent);
        this->text(text);
      }
      explicit control(const xtd::ustring& text, int32_t left, int32_t top, int32_t width, int32_t height) : control() {
        this->text(text);
        this->left(left);
        this->top(top);
        this->width(width);
        this->height(height);
      }
      explicit control(const control& parent, const xtd::ustring& text, int32_t left, int32_t top, int32_t width, int32_t height) : control() {
        this->parent(parent);
        this->text(text);
        this->left(left);
        this->top(top);
        this->width(width);
        this->height(height);
      }
      
      control(control&&) = delete;
      control(const control&) = delete;
      ~control();
      
      
      virtual anchor_styles anchor() const;
      virtual control& anchor(anchor_styles anchor);
      
      virtual drawing::point auto_scroll_point() const;
      
      virtual bool auto_size() const;
      virtual control& auto_size(bool auto_size);
      
      virtual drawing::color back_color() const;
      virtual control& back_color(const drawing::color& color);
      virtual control& back_color(std::nullptr_t);
      
      virtual const xtd::drawing::image& background_image() const;
      virtual control& background_image(const xtd::drawing::image& background_image);
      
      virtual xtd::forms::image_layout background_image_layout() const;
      
      virtual control& background_image_layout(xtd::forms::image_layout background_image_layout);
      
      virtual int32_t bottom() const;
      
      virtual drawing::rectangle bounds() const;
      virtual control& bounds(const drawing::rectangle& bounds);
      
      virtual bool can_focus() const;
      
      virtual bool can_select() const;
      
      bool can_raise_events() const override;
      
      static bool check_for_illegal_cross_thread_calls();
      static void check_for_illegal_cross_thread_calls(bool value);
      
      virtual const drawing::rectangle& client_rectangle() const;
      
      virtual const drawing::size& client_size() const;
      virtual control& client_size(const drawing::size& client_size);
      
      virtual xtd::ustring company_name() const;
      
      virtual std::optional<std::reference_wrapper<xtd::forms::context_menu>> context_menu() const;
      virtual control& context_menu(xtd::forms::context_menu& value);
      virtual control& context_menu(std::nullptr_t);
      
      virtual forms::control_appearance control_appearance() const;
      virtual control& control_appearance(forms::control_appearance value);
      
      virtual control_collection& controls();
      virtual const control_collection& controls() const;
      
      virtual bool created();
      
      virtual forms::cursor cursor() const;
      virtual control& cursor(const forms::cursor& cursor);
      virtual control& cursor(std::nullptr_t);
      
      virtual drawing::color default_back_color() const {return xtd::forms::style_sheets::style_sheet::current_style_sheet().system_colors().control();}
      
      virtual forms::cursor default_cursor() const {return cursors::default_cursor();}
      
      virtual drawing::font default_font() const;
      
      virtual drawing::color default_fore_color() const {return xtd::forms::style_sheets::style_sheet::current_style_sheet().system_colors().control_text();}
      
      virtual drawing::size default_size() const;
      
      virtual drawing::rectangle display_rectangle() const;
      
      virtual dock_style dock() const;
      virtual control& dock(dock_style dock);
      
      virtual bool double_buffered() const;
      virtual control& double_buffered(bool double_buffered);
      
      virtual bool enabled() const;
      virtual control& enabled(bool enabled);
      
      virtual bool focused() const;
      
      virtual drawing::font font() const;
      virtual control& font(const drawing::font& font);
      virtual control& font(std::nullptr_t);
      
      virtual drawing::color fore_color() const;
      virtual control& fore_color(const drawing::color& color);
      virtual control& fore_color(std::nullptr_t);
      
      intptr_t handle() const override;
      
      virtual int32_t height() const;
      virtual control& height(int32_t height);
      
      bool invoke_required() const;
      
      bool is_handle_created() const;
      
      virtual int32_t left() const;
      virtual control& left(int32_t left);
      
      virtual drawing::point location() const;
      virtual control& location(const drawing::point& location);
      
      virtual forms::padding margin() const;
      virtual control& margin(const forms::padding& margin);
      
      virtual const drawing::size& maximum_client_size() const;
      virtual control& maximum_client_size(const drawing::size& size);
      
      virtual const drawing::size& maximum_size() const;
      virtual control& maximum_size(const drawing::size& size);
      
      virtual const drawing::size& minimum_client_size() const;
      virtual control& minimum_client_size(const drawing::size& size);
      
      virtual const drawing::size& minimum_size() const;
      virtual control& minimum_size(const drawing::size& size);
      
      static forms::keys modifier_keys();
      
      static forms::mouse_buttons mouse_buttons();
      
      intptr_t native_handle() const;
      
      virtual const xtd::ustring& name() const;
      virtual control& name(const xtd::ustring& name);
      
      virtual forms::padding padding() const;
      virtual control& padding(const forms::padding& padding);
      
      virtual std::optional<control_ref> parent() const;
      virtual control& parent(const control& parent);
      virtual control& parent(std::nullptr_t);
      
      virtual xtd::ustring product_name() const;
      
      bool recreating_handle() const;

      virtual const xtd::drawing::region& region() const;
      virtual control& region(const xtd::drawing::region& value);

      virtual int32_t right() const;
      
      virtual drawing::size size() const;
      virtual control& size(const drawing::size& size);
      
      virtual style_sheets::style_sheet style_sheet() const;
      virtual control& style_sheet(const style_sheets::style_sheet& value);
      virtual control& style_sheet(const xtd::ustring& value);
      
      virtual bool tab_stop() const;
      virtual control& tab_stop(bool value);
      
      virtual std::any tag() const;
      
      virtual control& tag(std::any tag);
      
      virtual const xtd::ustring& text() const;
      virtual control& text(const xtd::ustring& text);
      
      intptr_t toolkit_handle() const;

      virtual int32_t top() const;
      virtual control& top(int32_t top);
      
      virtual std::optional<control_ref> top_level_control() const;
      
      virtual bool visible() const;
      virtual control& visible(bool visible);
      
      virtual int32_t width() const;
      virtual control& width(int32_t width);
      
      
      std::shared_ptr<xtd::iasync_result> begin_invoke(delegate<void()> value);
      
      std::shared_ptr<xtd::iasync_result> begin_invoke(delegate<void(std::vector<std::any>)> value, const std::vector<std::any>& args);
      
      template<typename delegate_t>
      std::shared_ptr<xtd::iasync_result> begin_invoke(delegate_t value, const std::vector<std::any>& args) {return begin_invoke(delegate<void(std::vector<std::any>)>(value), args);}
      
      template<typename delegate_t>
      std::shared_ptr<xtd::iasync_result> begin_invoke(delegate_t value) {return begin_invoke(delegate<void(std::vector<std::any>)>(value), {});}
      
      virtual void bring_to_front();
      
      template<typename control_t>
      static std::unique_ptr<control_t> create(const drawing::point& location = {-1, -1}, const drawing::size& size = {-1, -1}, const drawing::color& back_color = drawing::color::empty, const drawing::color& fore_color = drawing::color::empty) {
        std::unique_ptr<control_t> item = std::make_unique<control_t>();
        if (location != drawing::point {-1, -1}) item->location(location);
        if (size != drawing::size {-1, -1}) item->size(size);
        if (back_color != drawing::color::empty) item->back_color(back_color);
        if (fore_color != drawing::color::empty) item->fore_color(fore_color);
        return item;
      }
      
      template<typename control_t>
      static std::unique_ptr<control_t> create(const control& parent, const drawing::point& location = {-1, -1}, const drawing::size& size = {-1, -1}, const drawing::color& back_color = drawing::color::empty, const drawing::color& fore_color = drawing::color::empty) {
        std::unique_ptr<control_t> item = std::make_unique<control_t>();
        item->parent(parent);
        if (location != drawing::point {-1, -1}) item->location(location);
        if (size != drawing::size {-1, -1}) item->size(size);
        if (back_color != drawing::color::empty) item->back_color(back_color);
        if (fore_color != drawing::color::empty) item->fore_color(fore_color);
        return item;
      }
      
      template<typename control_t>
      static std::unique_ptr<control_t> create(const xtd::ustring& text, const drawing::point& location = {-1, -1}, const drawing::size& size = {-1, -1}, const drawing::color& back_color = drawing::color::empty, const drawing::color& fore_color = drawing::color::empty) {
        std::unique_ptr<control_t> item = std::make_unique<control_t>();
        item->text(text);
        if (location != drawing::point {-1, -1}) item->location(location);
        if (size != drawing::size {-1, -1}) item->size(size);
        if (back_color != drawing::color::empty) item->back_color(back_color);
        if (fore_color != drawing::color::empty) item->fore_color(fore_color);
        return item;
      }
      
      template<typename control_t>
      static std::unique_ptr<control_t> create(const control& parent, const xtd::ustring& text, const drawing::point& location = {-1, -1}, const drawing::size& size = {-1, -1}, const drawing::color& back_color = drawing::color::empty, const drawing::color& fore_color = drawing::color::empty) {
        std::unique_ptr<control_t> item = std::make_unique<control_t>();
        item->parent(parent);
        item->text(text);
        if (location != drawing::point {-1, -1}) item->location(location);
        if (size != drawing::size {-1, -1}) item->size(size);
        if (back_color != drawing::color::empty) item->back_color(back_color);
        if (fore_color != drawing::color::empty) item->fore_color(fore_color);
        return item;
      }
      
      void create_control();
      
      drawing::graphics create_graphics() const;
      
      virtual void create_handle();
      
      virtual void destroy_control();
      
      virtual void destroy_handle();
      
      void end_invoke(std::shared_ptr<xtd::iasync_result> async);
      
      bool focus();
      
      static std::optional<control_ref> from_child_handle(intptr_t handle);
      
      static std::optional<control_ref> from_handle(intptr_t handle);
      
      auto_size_mode get_auto_size_mode() const;
      
      std::optional<xtd::drawing::color> get_back_color() const {return data_->back_color;}
      
      std::optional<xtd::drawing::font> get_font() const {return data_->font;}
      
      std::optional<xtd::drawing::color> get_fore_color() const {return data_->fore_color;}
      
      size_t get_child_index(intptr_t child) const;
      
      size_t get_child_index(intptr_t child, bool& throw_exception) const;
      
      virtual void hide();
      
      virtual void invalidate() const;
      
      virtual void invalidate(bool invalidate_children) const;
      
      virtual void invalidate(const drawing::rectangle& rect) const;
      
      virtual void invalidate(const drawing::rectangle& rect, bool invalidate_children) const;
      
      void invoke(delegate<void()> value);
      
      void invoke(delegate<void(std::vector<std::any>)> value, const std::vector<std::any>& args);
      
      void invoke(delegate<void(std::vector<std::any>)> value, std::any arg);
      
      template<typename delegate_t>
      void invoke(delegate_t value, const std::vector<std::any>& args) {invoke(delegate<void(std::vector<std::any>)>(value), args);}
      
      template<typename delegate_t, typename args_t>
      void invoke(delegate_t value, args_t args) {invoke(delegate<void(std::vector<std::any>)>(value), std::any(args));}
      
      template<typename delegate_t>
      void invoke(delegate_t value) {invoke(delegate<void(std::vector<std::any>)>(value), std::vector<std::any> {});}
      
      void perform_layout();
      
      xtd::drawing::point point_to_client(const xtd::drawing::point& p) const;
      
      xtd::drawing::point point_to_screen(const xtd::drawing::point& p) const;
      
      virtual bool pre_process_message(xtd::forms::message& message);
      
      virtual void refresh() const;
      
      void resume_layout();
      
      void resume_layout(bool perform_layout);
      
      intptr_t send_message(intptr_t hwnd, int32_t msg, intptr_t wparam, intptr_t lparam) const;
      
      void set_auto_size_mode(auto_size_mode auto_size_mode);
      
      void set_bounds(int32_t x, int32_t y, int32_t width, int32_t height);
      
      void set_bounds(int32_t x, int32_t y, int32_t width, int32_t height, bounds_specified specified);
      
      virtual void show();
      
      void suspend_layout();
      
      xtd::ustring to_string() const noexcept override;
      
      virtual void update() const;
      
      
      control& operator<<(control& child) {
        child.parent(*this);
        return *this;
      }
      
      control& operator>>(control& child) {
        if (child.parent().has_value() && &child.parent().value().get() == this)
          child.parent(nullptr);
        return *this;
      }
      
      friend std::ostream& operator<<(std::ostream& os, const xtd::forms::control& control) noexcept {
        return os << control.to_string();
      }
      
      bool operator==(const control& value) const {return this == &value;}
      bool operator!=(const control& value) const {return !operator==(value);}
      bool operator<(const control& value) const {return this < &value;}
      
      
      event<control, event_handler> auto_size_changed;
      
      event<control, event_handler> back_color_changed;
      
      event<control, event_handler> background_image_changed;
      
      event<control, event_handler> background_image_layout_changed;
      
      event<control, event_handler> click;
      
      event<control, event_handler> client_size_changed;
      
      event<control, event_handler> cursor_changed;
      
      event<control, control_event_handler> control_added;
      
      event<control, control_event_handler> control_removed;
      
      event<control, event_handler> dock_changed;
      
      event<control, event_handler> double_click;
      
      event<control, event_handler> got_focus;
      
      event<control, event_handler> handle_created;
      
      event<control, event_handler> handle_destroyed;
      
      event<control, event_handler> enabled_changed;
      
      event<control, event_handler> fore_color_changed;
      
      event<control, event_handler> font_changed;

      event<control, help_event_handler> help_requested;
      
      event<control, key_event_handler> key_down;
      
      event<control, key_press_event_handler> key_press;
      
      event<control, key_event_handler> key_up;
      
      event<control, event_handler> layout;
      
      event<control, event_handler> location_changed;
      
      event<control, event_handler> lost_focus;
      
      event<control, mouse_event_handler> mouse_click;
      
      event<control, mouse_event_handler> mouse_double_click;
      
      event<control, mouse_event_handler> mouse_down;
      
      event<control, event_handler> mouse_enter;
      
      event<control, mouse_event_handler> mouse_horizontal_wheel;
      
      event<control, event_handler> mouse_leave;
      
      event<control, mouse_event_handler> mouse_move;
      
      event<control, mouse_event_handler> mouse_up;
      
      event<control, mouse_event_handler> mouse_wheel;
      
      event<control, paint_event_handler> paint;
      
      event<control, event_handler> parent_changed;
      
      event<control, event_handler> region_changed;

      event<control, event_handler> resize;
      
      event<control, event_handler> size_changed;
      
      event<control, event_handler> tab_stop_changed;
      
      event<control, event_handler> text_changed;
      
      event<control, event_handler> visible_changed;
      
    protected:
      friend class application;
      friend class context_menu;
      friend class paint_event_args;
      friend class screen;
      
      
      
      xtd::forms::visual_styles::control_state control_state() const noexcept {return data_->control_state;}
      
      virtual forms::create_params create_params() const;
      
      virtual void def_wnd_proc(message& message);
      
      bool get_style(control_styles flag) const;
      
      virtual drawing::size measure_control() const;
      
      drawing::size measure_text() const;
      
      virtual void on_auto_size_changed(const event_args& e);
      
      virtual void on_back_color_changed(const event_args& e);
      
      virtual void on_background_image_changed(const event_args& e);
      
      virtual void on_background_image_layout_changed(const event_args& e);
      
      virtual void on_click(const event_args& e);
      
      virtual void on_client_size_changed(const event_args& e);
      
      virtual void on_control_added(const control_event_args& e);
      
      virtual void on_control_removed(const control_event_args& e);
      
      virtual void on_create_control();
      
      virtual void on_cursor_changed(const event_args& e);
      
      virtual void on_dock_changed(const event_args& e);
      
      virtual void on_double_click(const event_args& e);
      
      virtual void on_enabled_changed(const event_args& e);
      
      virtual void on_fore_color_changed(const event_args& e);
      
      virtual void on_font_changed(const event_args& e);
      
      virtual void on_got_focus(const event_args& e);
      
      virtual void on_handle_created(const event_args& e);
      
      virtual void on_handle_destroyed(const event_args& e);

      virtual void on_help_requested(help_event_args& e);

      virtual void on_key_down(key_event_args& e);
      
      virtual void on_key_press(key_press_event_args& e);
      
      virtual void on_key_up(key_event_args& e);
      
      virtual void on_layout(const event_args& e);
      
      virtual void on_location_changed(const event_args& e);
      
      virtual void on_lost_focus(const event_args& e);
      
      virtual void on_mouse_click(const mouse_event_args& e);
      
      virtual void on_mouse_double_click(const mouse_event_args& e);
      
      virtual void on_mouse_down(const mouse_event_args& e);
      
      virtual void on_mouse_enter(const event_args& e);
      
      virtual void on_mouse_horizontal_wheel(const mouse_event_args& e);
      
      virtual void on_mouse_leave(const event_args& e);
      
      virtual void on_mouse_move(const mouse_event_args& e);
      
      virtual void on_mouse_up(const mouse_event_args& e);
      
      virtual void on_mouse_wheel(const mouse_event_args& e);
      
      virtual void on_paint(paint_event_args& e);
      
      virtual void on_paint_background(paint_event_args& e);
      
      virtual void on_parent_back_color_changed(const event_args& e);
      
      virtual void on_parent_cursor_changed(const event_args& e);
      
      virtual void on_parent_changed(const event_args& e);
      
      virtual void on_parent_enabled_changed(const event_args& e);
      
      virtual void on_parent_fore_color_changed(const event_args& e);
      
      virtual void on_parent_font_changed(const event_args& e);

      virtual void on_resize(const event_args& e);

      virtual void on_region_changed(const event_args& e);
      
      virtual void on_size_changed(const event_args& e);
      
      virtual void on_tab_stop_changed(const event_args& e);
      
      virtual void on_text_changed(const event_args& e);
      
      virtual void on_visible_changed(const event_args& e);
      
      void post_recreate_handle();
      
      virtual void recreate_handle();
      
      virtual void set_bounds_core(int32_t x, int32_t y, int32_t width, int32_t height, bounds_specified specified);
      
      void set_can_focus(bool value);
      
      virtual void set_text(const xtd::ustring& text);
      
      virtual void set_client_size_core(int32_t width, int32_t height);
      
      static void set_mouse_buttons(forms::mouse_buttons value);
      
      void set_parent(intptr_t handle);
      
      void set_style(control_styles flag, bool value);
      
      virtual void wnd_proc(message& m);
      
      bool get_state(control::state flag) const;
      void set_state(control::state flag, bool value);
      bool on_context_menu_item_click(xtd::forms::context_menu& menu, int32_t menu_id) const;
      
    private:
      void on_parent_size_changed(object& sender, const event_args& e);
      void do_layout_children_with_dock_style();
      void do_layout_with_auto_size_mode();
      void do_layout_with_anchor_styles();
      control(const xtd::ustring& name, bool);
      void show_context_menu(xtd::forms::context_menu& menu, const xtd::drawing::point& pos) const;
      intptr_t wnd_proc_(intptr_t hwnd, int32_t msg, intptr_t wparam, intptr_t lparam, intptr_t handle);
      void wm_child_activate(message& message);
      void wm_create(message& message);
      void wm_command(message& message);
      void wm_enter_idle(message& message);
      void wm_key_char(message& message);
      void wm_kill_focus(message& message);
      void wm_menu_command(message& message);
      void wm_mouse_down(message& message);
      void wm_mouse_double_click(message& message);
      void wm_mouse_enter(message& message);
      void wm_mouse_leave(message& message);
      void wm_mouse_up(message& message);
      void wm_mouse_move(message& message);
      void wm_move(message& message);
      void wm_mouse_wheel(message& message);
      void wm_notify(message& message);
      void wm_paint(const message& message);
      void wm_erase_background(const message& message);
      void wm_help(message& message);
      void wm_scroll(message& message);
      void wm_set_focus(message& message);
      void wm_set_text(message& message);
      void wm_show(message& message);
      void wm_size(message& message);
      void wm_sizing(message& message);
      
      struct data {
        anchor_styles anchor = anchor_styles::top | anchor_styles::left;
        forms::padding anchoring;
        drawing::point auto_scroll_point;
        forms::auto_size_mode auto_size_mode = forms::auto_size_mode::grow_and_shrink;
        std::optional<drawing::color> back_color;
        xtd::drawing::image background_image = xtd::drawing::image::empty;
        xtd::forms::image_layout background_image_layout = xtd::forms::image_layout::tile;
        bool can_focus = true;
        bool can_raise_events = true;
        drawing::rectangle client_rectangle;
        drawing::size client_size;
        forms::control_appearance control_appearance = forms::control_appearance::standard;
        xtd::forms::visual_styles::control_state control_state = xtd::forms::visual_styles::control_state::normal;
        control_collection controls;
        std::optional<std::reference_wrapper<xtd::forms::context_menu>> context_menu;
        std::optional<forms::cursor> cursor;
        dock_style dock = dock_style::none;
        bool focused = false;
        std::optional<drawing::color> fore_color;
        std::optional<drawing::font> font;
        intptr_t handle = 0;
        drawing::point location;
        drawing::region region;
        forms::padding margin {3};
        drawing::size maximum_client_size;
        drawing::size maximum_size;
        drawing::size minimum_client_size;
        drawing::size minimum_size;
        forms::padding padding;
        bool mouse_in = false;
        xtd::ustring name;
        intptr_t parent = 0;
        bool recreate_handle_posted = false;
        std::optional<drawing::size> size;
        control::state state = control::state::empty;
        control_styles style = control_styles::none;
        style_sheets::style_sheet style_sheet;
        std::any tag;
        xtd::ustring text;
      };
      
      static bool check_for_illegal_cross_thread_calls_;
      static std::thread::id handle_created_on_thread_id_;
      static forms::keys modifier_keys_;
      static forms::mouse_buttons mouse_buttons_;
      static std::map<intptr_t, control*> handles_;
      static control_collection top_level_controls_;

      std::shared_ptr<data> data_ = std::make_shared<data>();
    };
  }
}