control.hpp

Go to the documentation of this file.

#pragma once
#include "../forms_export.hpp"
#include "layout/arranged_element_collection.hpp"
#include "anchor_styles.hpp"
#include "auto_size_mode.hpp"
#include "bounds_specified.hpp"
#include "component.hpp"
#include "const_control_ref.hpp"
#include "context_menu.hpp"
#include "control_appearance.hpp"
#include "control_event_handler.hpp"
#include "control_ref.hpp"
#include "control_styles.hpp"
#include "create_params.hpp"
#include "cursors.hpp"
#include "dock_style.hpp"
#include "help_event_handler.hpp"
#include "image_layout.hpp"
#include "iwin32_window.hpp"
#include "key_event_handler.hpp"
#include "key_press_event_handler.hpp"
#include "message.hpp"
#include "mouse_event_handler.hpp"
#include "padding.hpp"
#include "paint_event_handler.hpp"
#include "right_to_left.hpp"
#include "timer.hpp"
#include "style_sheets/style_sheet.hpp"
#include "visual_styles/control_state.hpp"
#include <xtd/drawing/color>
#include <xtd/drawing/font>
#include <xtd/drawing/point>
#include <xtd/drawing/rectangle>
#include <xtd/drawing/size>
#include <xtd/any>
#include <xtd/async_result>
#include <xtd/optional>
#include <xtd/iclonable>
#include <xtd/iequatable>
#include <xtd/isynchronize_invoke>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>

namespace xtd {
  namespace forms {
    class application;
    class context_menu;
    class horizontal_layout_panel;
    class screen;
    class vertical_layout_panel;
    
    
    class forms_export_ control : public component, public iwin32_window, public iclonable, public icomparable<control>, public xtd::iequatable<control>, public xtd::isynchronize_invoke {
      struct data;
      
    protected:
      enum class state : int64 {
        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 = 0b100000000000000000000,
        tracking_mouse_event = 0b1000000000000000000000,
        mouse_pressed = 0b10000000000000000000000,
        use_wait_cursor = 0b100000000000000000000000,
        
        is_accessible = 0b1000000000000000000000000,
        no_zorder = 0b10000000000000000000000000,
        size_locked_by_os = 0b10000000000000000000000000,
        causes_validation = 0b100000000000000000000000000,
        own_ctl_brush = 0b1000000000000000000000000000,
        exception_while_painting = 0b10000000000000000000000000000,
        layout_sis_dirty = 0b100000000000000000000000000000,
        checked_host = 0b1000000000000000000000000000000,
        hosted_in_dialog = 0b10000000000000000000000000000000,
        validation_cancelled = 0b100000000000000000000000000000000,
        mirrored = 0b1000000000000000000000000000000000,
      };
      
      class async_result_invoke : public xtd::iasync_result {
        struct data;
      public:
        explicit async_result_invoke(const xtd::any_object& async_state);
        xtd::any_object async_state() const noexcept override;
        xtd::threading::wait_handle& async_wait_handle() noexcept override;
        bool completed_synchronously() const noexcept override;
        bool is_completed() const noexcept override;
        
        xtd::sptr<data> data_;
      };
      
    public:
      
      using context_menu_ref = std::reference_wrapper<xtd::forms::context_menu>;
      
      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(bool keep_cloned_controls, 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::string& name) const;
        std::optional<value_type> operator [](const xtd::string& name);
        
        
        template<class control_t, class ...args_t>
        control_t& emplace(const_iterator pos, args_t&& ...args) {
          auto control_ptr = xtd::new_uptr<control_t>(control_t::create(std::forward<args_t>(args)...));
          auto& control_ref = *control_ptr;
          controls_.push_back(std::move(control_ptr));
          base::insert(pos, control_ref);
          return control_ref;
        }
        control_t& emplace(const_iterator pos, args_t&& ...args) {…}
        
        template<class control_t, class ...args_t>
        control_t& emplace_at(size_t index, args_t&& ...args) {
          auto control_ptr = xtd::new_uptr<control_t>(control_t::create(std::forward<args_t>(args)...));
          auto& control_ref = *control_ptr;
          controls_.push_back(std::move(control_ptr));
          base::insert_at(index, control_ref);
          return control_ref;
        }
        control_t& emplace_at(size_t index, args_t&& ...args) {…}
        
        template<class control_t, class ...args_t>
        control_t& emplace_back(args_t&& ...args) {
          auto control_ptr = xtd::new_uptr<control_t>(control_t::create(std::forward<args_t>(args)...));
          auto& control_ref = *control_ptr;
          controls_.push_back(std::move(control_ptr));
          base::push_back(control_ref);
          return control_ref;
        }
        control_t& emplace_back(args_t&& ...args) {…}
        
        iterator insert(const_iterator pos, const value_type& value) override;
        
        void insert_at(size_t index, const value_type& value) override;
        
        void push_back(const value_type& value) override;
        
        template<class control_t>
        iterator insert(const_iterator pos, control_t& value) {
          for (auto it = begin(); it != end(); ++it)
            if (it->get() == value) return it;
          if (!keep_cloned_controls_) return base::insert(pos, value);
          auto control_ptr = as<control>(as<iclonable>(value).clone());
          auto& control_ref = *control_ptr;
          controls_.push_back(std::move(control_ptr));
          return base::insert(pos, control_ref);
        }
        
        template<class control_t>
        void insert_at(size_t index, control_t& value) {
          for (auto it = begin(); it != end(); ++it)
            if (it->get() == value) return;
          if (!keep_cloned_controls_) base::insert_at(index, value);
          else {
            auto control_ptr = as<control>(as<iclonable>(value).clone());
            auto& control_ref = *control_ptr;
            controls_.push_back(std::move(control_ptr));
            base::insert_at(index, control_ref);
          }
        }
        
        template<class control_t>
        void push_back(control_t& value) {
          for (auto it = begin(); it != end(); ++it)
            if (it->get() == value) return;
          if (!keep_cloned_controls_) base::push_back(value);
          else {
            auto control_ptr = as<control>(as<iclonable>(value).clone());
            auto& control_ref = *control_ptr;
            controls_.push_back(std::move(control_ptr));
            base::push_back(control_ref);
          }
        }

        
      protected:
        
        void on_item_removed(size_t index, control_ref& item) override {
          xtd::forms::layout::arranged_element_collection<control_ref>::on_item_removed(index, item);
          for (auto iterator = controls_.begin(); iterator != controls_.end(); ++iterator) {
            if (iterator->get() != &item.get()) continue;
            controls_.erase(iterator);
            break;
          }
        }
        void on_item_removed(size_t index, control_ref& item) override  {…}

 
      private:
        using xtd::forms::layout::arranged_element_collection<control_ref>::insert;
        using xtd::forms::layout::arranged_element_collection<control_ref>::push_back;
 
        bool keep_cloned_controls_ = false;
        static xtd::collections::generic::list<xtd::sptr<xtd::forms::control>> controls_;
      };
      class control_collection : public xtd::forms::layout::arranged_element_collection<control_ref> {…};
      
      
      control();
      explicit control(const xtd::string& text);
      control(const control& parent, const xtd::string& text);
      control(const xtd::string& text, int32 left, int32 top, int32 width, int32 height);
      control(const control& parent, const xtd::string& text, int32 left, int32 top, int32 width, int32 height);
      
      control(control&& rhs);
      control(const control&) = default;
      control& operator =(const control&) = default;
      ~control();
      
      
      virtual anchor_styles anchor() const noexcept;
      virtual control& anchor(xtd::forms::anchor_styles anchor);
      
      virtual drawing::point auto_scroll_point() const noexcept;
      
      virtual bool auto_size() const noexcept;
      virtual control& auto_size(bool auto_size);
      
      virtual drawing::color back_color() const noexcept;
      virtual control& back_color(const xtd::drawing::color& color);
      virtual control& back_color(std::nullptr_t);
      
      virtual const xtd::drawing::image& background_image() const noexcept;
      virtual control& background_image(const xtd::drawing::image& background_image);
      
      virtual xtd::forms::image_layout background_image_layout() const noexcept;
      
      virtual control& background_image_layout(xtd::forms::image_layout background_image_layout);
      
      virtual int32 bottom() const noexcept;
      
      virtual drawing::rectangle bounds() const noexcept;
      virtual control& bounds(const xtd::drawing::rectangle& bounds);
      
      virtual bool can_focus() const noexcept;
      
      virtual bool can_select() const noexcept;
      
      bool can_raise_events() const noexcept override;
      
      virtual const drawing::rectangle& client_rectangle() const noexcept;
      
      virtual const drawing::size& client_size() const noexcept;
      virtual control& client_size(const xtd::drawing::size& client_size);
      
      virtual xtd::string company_name() const noexcept;
      
      virtual std::optional<context_menu_ref> context_menu() const noexcept;
      virtual control& context_menu(xtd::forms::context_menu& value);
      virtual control& context_menu(std::nullptr_t);
      
      virtual forms::control_appearance control_appearance() const noexcept;
      virtual control& control_appearance(xtd::forms::control_appearance value);
      
      virtual control_collection& controls() noexcept;
      virtual const control_collection& controls() const noexcept;
      
      virtual bool created() const noexcept;
      
      virtual forms::cursor cursor() const noexcept;
      virtual control& cursor(const xtd::forms::cursor& cursor);
      virtual control& cursor(std::nullptr_t);
      
      virtual drawing::rectangle display_rectangle() const noexcept;
      
      virtual dock_style dock() const noexcept;
      virtual control& dock(xtd::forms::dock_style dock);
      
      virtual bool double_buffered() const noexcept;
      virtual control& double_buffered(bool double_buffered);
      
      virtual bool enabled() const noexcept;
      virtual control& enabled(bool enabled);
      
      virtual bool focused() const noexcept;
      
      virtual drawing::font font() const noexcept;
      virtual control& font(const xtd::drawing::font& font);
      virtual control& font(std::nullptr_t);
      
      virtual drawing::color fore_color() const noexcept;
      virtual control& fore_color(const xtd::drawing::color& color);
      virtual control& fore_color(std::nullptr_t);
      
      intptr handle() const override;
      
      virtual int32 height() const noexcept;
      virtual control& height(int32 height);
      
      bool invoke_required() const noexcept override;
      
      bool is_handle_created() const noexcept;
      
      virtual int32 left() const noexcept;
      virtual control& left(int32 left);
      
      virtual drawing::point location() const noexcept;
      virtual control& location(const xtd::drawing::point& location);
      
      virtual forms::padding margin() const noexcept;
      virtual control& margin(const xtd::forms::padding& margin);
      
      virtual const drawing::size& maximum_client_size() const noexcept;
      virtual control& maximum_client_size(const xtd::drawing::size& size);
      
      virtual const drawing::size& maximum_size() const noexcept;
      virtual control& maximum_size(const xtd::drawing::size& size);
      
      virtual const drawing::size& minimum_client_size() const noexcept;
      virtual control& minimum_client_size(const xtd::drawing::size& size);
      
      virtual const drawing::size& minimum_size() const noexcept;
      virtual control& minimum_size(const xtd::drawing::size& size);
      
      intptr native_handle() const noexcept;
      
      virtual const xtd::string& name() const noexcept;
      virtual control& name(const xtd::string& name);
      
      virtual forms::padding padding() const noexcept;
      virtual control& padding(const xtd::forms::padding& padding);
      
      virtual std::optional<control_ref> parent() const noexcept;
      virtual control& parent(const control& parent);
      virtual control& parent(std::nullptr_t);
      
      virtual xtd::string product_name() const noexcept;
      
      bool recreating_handle() const noexcept;
      
      virtual const xtd::drawing::region& region() const noexcept;
      virtual control& region(const xtd::drawing::region& value);
      
      virtual int32 right() const noexcept;
      
      virtual xtd::forms::right_to_left right_to_left() const noexcept;
      virtual control& right_to_left(xtd::forms::right_to_left value);
      virtual control& right_to_left(std::nullptr_t);

      virtual drawing::size size() const noexcept;
      virtual control& size(const drawing::size& size);
      
      virtual style_sheets::style_sheet style_sheet() const noexcept;
      virtual control& style_sheet(const style_sheets::style_sheet& value);
      virtual control& style_sheet(const xtd::string& value);
      virtual control& style_sheet(std::nullptr_t);
      
      virtual bool tab_stop() const noexcept;
      virtual control& tab_stop(bool value);
      
      virtual xtd::any_object tag() const noexcept;
      virtual control& tag(const xtd::any_object& tag);
      
      virtual const xtd::string& text() const noexcept;
      virtual control& text(const xtd::string& text);
      
      intptr toolkit_handle() const noexcept;
      
      virtual int32 top() const noexcept;
      virtual control& top(int32 top);
      
      virtual std::optional<control_ref> top_level_control() const noexcept;
      
      virtual bool visible() const noexcept;
      virtual control& visible(bool visible);
      
      virtual int32 width() const noexcept;
      virtual control& width(int32 width);
      
      
      static bool check_for_illegal_cross_thread_calls() noexcept;
      static void check_for_illegal_cross_thread_calls(bool value);
      
      static forms::keys modifier_keys() noexcept;
      
      static forms::mouse_buttons mouse_buttons() noexcept;
      
      static xtd::drawing::point mouse_position() noexcept;
      
      
      using isynchronize_invoke::begin_invoke;
      xtd::async_result begin_invoke(delegate<void()> method) override;
      
      xtd::async_result begin_invoke(delegate<void(xtd::array<xtd::any_object>)> method, const xtd::array<xtd::any_object>& args) override;
      
      virtual void bring_to_front();
      
      int32 compare_to(const control& value) const noexcept override;

      void create_control();
      
      drawing::graphics create_graphics() const;
      
      virtual void destroy_control();
      
      std::optional<object_ref> end_invoke(xtd::async_result async) override;
      
      bool equals(const xtd::object& obj) const noexcept override;
      bool equals(const control& value) const noexcept override;
      
      bool focus();
      
      auto_size_mode get_auto_size_mode() const;
      
      std::optional<xtd::drawing::color> get_back_color() const noexcept;
      
      std::optional<xtd::drawing::font> get_font() const noexcept;
      
      std::optional<xtd::drawing::color> get_fore_color() const noexcept;
      
      size_t get_child_index(intptr child) const;
      
      size_t get_child_index(intptr child, bool& throw_exception) const;
      
      xtd::size get_hash_code() const noexcept override;

      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;
      
      virtual void invalidate(const drawing::region& region) const;
      
      virtual void invalidate(const drawing::region& region, bool invalidate_children) const;
      
      using isynchronize_invoke::invoke;
      std::optional<object_ref> invoke(delegate<void()> method) override;
      std::optional<object_ref> invoke(delegate<void(xtd::array<xtd::any_object>)> method, const xtd::array<xtd::any_object>& args) override;
      std::optional<object_ref> invoke(delegate<void(xtd::array<xtd::any_object>)> method, const xtd::any_object& arg) override;
      
      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;

      bool post_message(intptr hwnd, int32 msg, intptr wparam, intptr lparam) const;

      virtual bool pre_process_message(const xtd::forms::message& message);
      
      virtual void refresh() const;
      
      void resume_layout();
      
      void resume_layout(bool perform_layout);
      
      intptr send_message(intptr hwnd, int32 msg, intptr wparam, intptr lparam) const;
      
      void set_auto_size_mode(auto_size_mode auto_size_mode);
      
      void set_bounds(int32 x, int32 y, int32 width, int32 height);
      
      void set_bounds(int32 x, int32 y, int32 width, int32 height, bounds_specified specified);
      
      virtual void show();
      
      void suspend_layout();
      
      xtd::string to_string() const noexcept override;
      
      virtual void update() const;
      
      
      control& operator <<(control& child);
      
      control& operator >>(control& child);
      
      
      static control create();
      static control create(const drawing::point& location);
      static control create(const drawing::point& location, const drawing::size& size);
      static control create(const drawing::point& location, const drawing::size& size, const xtd::string& name);
      static control create(const control& paren);
      static control create(const control& parent, const drawing::point& location);
      static control create(const control& parent, const drawing::point& location, const drawing::size& size);
      static control create(const control& parent, const drawing::point& location, const drawing::size& size, const xtd::string& name);
      template<class control_t>
      static control_t create() {
        auto result = control_t {};
        return result;
      }
      static control_t create() {…}

      template<class control_t>
      static control_t create(const drawing::point& location) {
        auto result = control_t {};
        result.location(location);
        return result;
      }
      static control_t create(const drawing::point& location) {…}

      template<class control_t>
      static control_t create(const drawing::point& location, const drawing::size& size) {
        auto result = control_t {};
        result.location(location);
        result.size(size);
        return result;
      }
      static control_t create(const drawing::point& location, const drawing::size& size) {…}

      template<class control_t>
      static control_t create(const drawing::point& location, const drawing::size& size, const xtd::string& name) {
        auto result = control_t {};
        result.location(location);
        result.size(size);
        result.name(name);
        return result;
      }
      static control_t create(const drawing::point& location, const drawing::size& size, const xtd::string& name) {…}

      template<class control_t>
      static control_t create(const control& parent) {
        auto result = control_t {};
        result.parent(parent);
        return result;
      }
      static control_t create(const control& parent) {…}

      template<class control_t>
      static control_t create(const control& parent, const drawing::point& location) {
        auto result = control_t {};
        result.parent(parent);
        result.location(location);
        return result;
      }
      static control_t create(const control& parent, const drawing::point& location) {…}

      template<class control_t>
      static control_t create(const control& parent, const drawing::point& location, const drawing::size& size) {
        auto result = control_t {};
        result.parent(parent);
        result.location(location);
        result.size(size);
        return result;
      }
      static control_t create(const control& parent, const drawing::point& location, const drawing::size& size) {…}

      template<class control_t>
      static control_t create(const control& parent, const drawing::point& location, const drawing::size& size, const xtd::string& name) {
        auto result = control_t {};
        result.parent(parent);
        result.location(location);
        result.size(size);
        result.name(name);
        return result;
      }
      static control_t create(const control& parent, const drawing::point& location, const drawing::size& size, const xtd::string& name) {…}

      template<class control_t>
      static control_t create(const xtd::string& text) {
        auto result = control_t {};
        result.text(text);
        return result;
      }
      static control_t create(const xtd::string& text) {…}

      template<class control_t>
      static control_t create(const xtd::string& text, const drawing::point& location) {
        auto result = control_t {};
        result.text(text);
        result.location(location);
        return result;
      }
      static control_t create(const xtd::string& text, const drawing::point& location) {…}

      template<class control_t>
      static control_t create(const xtd::string& text, const drawing::point& location, const drawing::size& size) {
        auto result = control_t {};
        result.text(text);
        result.location(location);
        result.size(size);
        return result;
      }
      static control_t create(const xtd::string& text, const drawing::point& location, const drawing::size& size) {…}

      template<class control_t>
      static control_t create(const xtd::string& text, const drawing::point& location, const drawing::size& size, const xtd::string& name) {
        auto result = control_t {};
        result.text(text);
        result.location(location);
        result.size(size);
        result.name(name);
        return result;
      }
      static control_t create(const xtd::string& text, const drawing::point& location, const drawing::size& size, const xtd::string& name) {…}

      template<class control_t>
      static control_t create(const control& parent, const xtd::string& text) {
        auto result = control_t {};
        result.parent(parent);
        result.text(text);
        return result;
      }
      static control_t create(const control& parent, const xtd::string& text) {…}

      template<class control_t>
      static control_t create(const control& parent, const xtd::string& text, const drawing::point& location) {
        auto result = control_t {};
        result.parent(parent);
        result.text(text);
        result.location(location);
        return result;
      }
      static control_t create(const control& parent, const xtd::string& text, const drawing::point& location) {…}

      template<class control_t>
      static control_t create(const control& parent, const xtd::string& text, const drawing::point& location, const drawing::size& size) {
        auto result = control_t {};
        result.parent(parent);
        result.text(text);
        result.location(location);
        result.size(size);
        return result;
      }
      static control_t create(const control& parent, const xtd::string& text, const drawing::point& location, const drawing::size& size) {…}

      template<class control_t>
      static control_t create(const control& parent, const xtd::string& text, const drawing::point& location, const drawing::size& size, const xtd::string& name) {
        auto result = control_t {};
        result.parent(parent);
        result.text(text);
        result.location(location);
        result.size(size);
        result.name(name);
        return result;
      }
      static control_t create(const control& parent, const xtd::string& text, const drawing::point& location, const drawing::size& size, const xtd::string& name) {…}
      
      static std::optional<control_ref> from_child_handle(intptr handle);
      
      static std::optional<control_ref> from_handle(intptr handle);
      
      
      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> control_appearance_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, event_handler> move;
      
      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> right_to_left_changed;

      event<control, event_handler> size_changed;
      
      event<control, event_handler> style_sheet_changed;
      
      event<control, event_handler> system_colors_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 horizontal_layout_panel;
      friend class paint_event_args;
      friend class screen;
      friend class vertical_layout_panel;
      friend class style_sheets::style_sheet;
      
      
      xtd::forms::visual_styles::control_state control_state() const noexcept;
      
      virtual forms::create_params create_params() const noexcept;
      
      virtual drawing::color default_back_color() const noexcept;
      
      virtual forms::cursor default_cursor() const noexcept;
      
      virtual drawing::font default_font() const noexcept;
      
      virtual drawing::color default_fore_color() const noexcept;
      
      virtual drawing::size default_size() const noexcept;
      
      
      xtd::uptr<xtd::object> clone() const override;
      
      virtual void create_handle();
      
      virtual void destroy_handle();
      
      virtual void def_wnd_proc(message& message);
      
      bool get_style(control_styles flag) const noexcept;
      
      virtual drawing::size measure_control() const noexcept;
      
      drawing::size measure_text() const noexcept;
      
      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_control_appearance_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_destroy_control();
      
      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_move(const 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_right_to_left_changed(const event_args& e);

      virtual void on_size_changed(const event_args& e);
      
      virtual void on_style_sheet_changed(const event_args& e);
      
      virtual void on_system_colors_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() noexcept;
      
      virtual void recreate_handle();
      
      virtual void set_bounds_core(int32 x, int32 y, int32 width, int32 height, bounds_specified specified);
      
      void set_can_focus(bool value);
      
      virtual void set_text(const xtd::string& text);
      
      virtual void set_client_size_core(int32 width, int32 height);
            
      void set_parent(intptr handle);
      
      void set_style(control_styles flag, bool value);
      
      virtual void wnd_proc(message& m);
      
      
      static void set_mouse_buttons(forms::mouse_buttons value);
      
      bool get_state(control::state flag) const noexcept;
      void set_state(control::state flag, bool value);
      bool on_context_menu_item_click(xtd::forms::context_menu& menu, intptr menu_id) const;
      
    private:
      void do_layout_children_with_dock_style();
      void do_layout_with_auto_size_mode();
      void do_layout_with_anchor_styles();
      static bool is_trace_form_or_control(const string& name);
      void on_controls_item_added(size_t, control_ref item);
      void on_controls_item_removed(size_t, control_ref item);
      void on_parent_size_changed(object& sender, const event_args& e);
      void show_context_menu(xtd::forms::context_menu& menu, const xtd::drawing::point& pos) const;
      void reflect_message(intptr handle, message& message);
      intptr wnd_proc_(intptr hwnd, int32 msg, intptr wparam, intptr lparam, intptr handle);
      void wm_app_idle(message& message);
      void wm_child_activate(message& message);
      void wm_command(message& message);
      void wm_command_control(message& message);
      void wm_ctlcolor(message& message);
      void wm_ctlcolor_control(message& message);
      void wm_create(message& message);
      void wm_destroy(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_notify_control(message& message);
      void wm_paint(message& message);
      void wm_erase_background(message& message);
      void wm_help(message& message);
      void wm_scroll(message& message);
      void wm_scroll_control(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);
      void wm_style_sheet_changed(message& message);
      
      static bool check_for_illegal_cross_thread_calls_;
      static forms::keys modifier_keys_;
      static forms::mouse_buttons mouse_buttons_;
      static std::map<intptr, control*> handles_;
      static control_collection top_level_controls_;
      
      xtd::sptr<data> data_;
    };
    class forms_export_ control : public component, public iwin32_window, public iclonable, public icomparable<control>, public xtd::iequatable<control>, public xtd::isynchronize_invoke {…};
  }
}