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 "control_event_handler.h"
#include "control_ref.h"
#include "control_styles.h"
#include "cursors.h"
#include "dock_style.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"

namespace xtd {
  namespace forms {
    class application;
    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:
        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());
        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 {return anchor_;}
      virtual control& anchor(anchor_styles anchor);
      
      virtual drawing::point auto_scroll_point() const {return auto_scroll_point_;}
      
      virtual bool auto_size() const {return get_state(state::auto_size);}
      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(nullptr_t);

      virtual const xtd::drawing::image& background_image() const {return background_image_;}
      virtual control& background_image(const xtd::drawing::image& background_image);
      
      virtual xtd::forms::image_layout background_image_layout() const {return background_image_layout_;}
      
      virtual control& background_image_layout(xtd::forms::image_layout background_image_layout);
      
      virtual int32_t bottom() const {return top() + height();}
      
      virtual drawing::rectangle bounds() const {return {location_, size_};}
      virtual control& bounds(const drawing::rectangle& bounds) {
        set_bounds_core(bounds.x(), bounds.y(), bounds.width(), bounds.height(), bounds_specified::all);
        return *this;
      }
      
      virtual bool can_focus() const;
      
      virtual bool can_select() const {return enabled() &&  visible() && get_style(control_styles::selectable);}
      
      bool can_raise_events() const override {return can_raise_events_;}

      virtual const drawing::rectangle& client_rectangle() const {return client_rectangle_;}

      virtual const drawing::size& client_size() const {return client_size_;}
      virtual control& client_size(const drawing::size& client_size) {
        if (!get_state(state::client_size_setted) || client_size_ != client_size) {
          set_state(state::client_size_setted, true);
          set_client_size_core(client_size.width(), client_size.height());
        }
        return *this;
      }
      
      virtual xtd::ustring company_name() const {return "Gammasoft";}
      
      virtual control_collection& controls() {return controls_;}
      virtual const control_collection& controls() const {return controls_;}

      virtual bool created() {return get_state(state::created);}
      
      virtual forms::cursor cursor() const;
      virtual control& cursor(const forms::cursor& cursor);
      virtual control& cursor(nullptr_t);

      virtual drawing::color default_back_color() const {return xtd::forms::theme_colors::current_theme().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::theme_colors::current_theme().control_text();}
      
      virtual drawing::size default_size() const {return {0, 0};}
      
      virtual drawing::rectangle display_rectangle() const {return client_rectangle_;}
      
      virtual dock_style dock() const {return dock_;}
      virtual control& dock(dock_style dock);

      virtual bool double_buffered() const {return get_state(state::double_buffered);}
      virtual control& double_buffered(bool double_buffered) {
        set_state(state::double_buffered, double_buffered);
        return *this;
      }
      
      virtual bool enabled() const {return get_state(state::enabled);}
      virtual control& enabled(bool enabled);

      virtual bool focused() const {return focused_;}

      virtual drawing::color fore_color() const;
      virtual control& fore_color(const drawing::color& color);
      virtual control& fore_color(nullptr_t);

      virtual drawing::font font() const;
      virtual control& font(const drawing::font& font);
      virtual control& font(nullptr_t);

      intptr_t handle() const override;
      
      virtual int32_t height() const {return size_.height();}
      virtual control& height(int32_t height) {
        if (size_.height() != height)
          set_bounds_core(0, 0, 0, height, bounds_specified::height);
        return *this;
      }
      
      bool is_handle_created() const;
      
      virtual int32_t left() const {return location_.x();}
      virtual control& left(int32_t left) {
        if (location_.x() != left)
          set_bounds_core(left, 0, 0, 0, bounds_specified::x);
        return *this;
      }

      virtual drawing::point location() const {return location_;}
      virtual control& location(const drawing::point& location) {
        if (location_ != location)
          set_bounds_core(location.x(), location.y(), 0, 0, bounds_specified::location);
        return *this;
      }
      
      virtual forms::padding margin() const {return margin_;}
      virtual control& margin(const forms::padding& margin) {
        if (margin_ != margin)
          margin_ = margin;
        return *this;
      }

      virtual const drawing::size& maximum_size() const;
      virtual control& maximum_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() {return modifier_keys_;}
      
      static forms::mouse_buttons mouse_buttons() {return mouse_buttons_;}
      
      virtual const xtd::ustring& name() const {return name_;}
      virtual control& name(const xtd::ustring& name) {
        name_ = name;
        return*this;
      }
      
      virtual forms::padding padding() const {return padding_;}
      virtual control& padding(const forms::padding& padding) {
        if (padding_ != padding)
          padding_ = padding;
        return *this;
      }
      
      virtual std::optional<control_ref> parent() const {return from_handle(parent_);}
      virtual control& parent(const control& parent);
      virtual control& parent(std::nullptr_t);

      virtual xtd::ustring product_name() const {return "xtd";}
      
      bool recreating_handle() const {return get_state(state::recreate);}
      
      virtual int32_t right() const {return left() + width();}

      virtual const drawing::size& size() const {return size_;}
      virtual control& size(const drawing::size& size) {
        if (get_state(state::client_size_setted) || size_ != size) {
          set_state(state::client_size_setted, false);
          set_bounds_core(0, 0, size.width(), size.height(), bounds_specified::size);
        }
        return *this;
      }
      
      virtual std::any tag() const {return tag_;}
      
      virtual control& tag(std::any tag) {
        tag_ = tag;
        return*this;
      }
      
      virtual const xtd::ustring& text() const {return text_;}
      virtual control& text(const xtd::ustring& text);

      virtual int32_t top() const {return location_.y();}
      virtual control& top(int32_t top) {
        if (location_.y() != top)
          set_bounds_core(0, top, 0, 0, bounds_specified::y);
        return *this;
      }
      
      virtual std::optional<control_ref> top_level_control() const;

      virtual bool visible() const {return get_state(state::visible);}
      virtual control& visible(bool visible);

      virtual int32_t width() const {return size_.width();}
      virtual control& width(int32_t width) {
        if (size_.width() != width)
          set_bounds_core(0, 0, width, 0, bounds_specified::width);
        return *this;
      }
      
      friend control& operator<<(control& parent, control& child) {
        child.parent(parent);
        return parent;
      }
      
      friend control& operator>>(control& parent, control& child) {
        if (child.parent().has_value() && &child.parent().value().get() == &parent)
          child.parent(nullptr);
        return parent;
      }

      std::shared_ptr<xtd::iasync_result> begin_invoke(delegate<void()> value) {return begin_invoke(delegate<void(std::vector<std::any>)>(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);

      size_t get_child_index(intptr_t child) const {
        for (size_t index = 0;index < controls().size(); ++index)
        if (controls()[index].get().handle() == child) return index;
        throw xtd::argument_exception(current_stack_frame_);
      }

      size_t get_child_index(intptr_t child, bool& throw_exception) const {
        throw_exception = false;
        try {
          return get_child_index(child);
        } catch(...) {
          throw_exception = true;
          return control_collection::npos;
        }
      }

      virtual void hide() {visible(false);}
      
      virtual void invalidate() const {invalidate({{0, 0}, client_size()}, false);}

      virtual void invalidate(bool invalidate_children) const {invalidate({{0, 0}, client_size()}, invalidate_children);}

      virtual void invalidate(const drawing::rectangle& rect) const {invalidate(rect, false);}
      
      virtual void invalidate(const drawing::rectangle& rect, bool invalidate_children) const;

      void invoke(delegate<void()> value) {invoke(delegate<void(std::vector<std::any>)>(value), {});}
      
      void invoke(delegate<void(std::vector<std::any>)> value, const std::vector<std::any>& args) {end_invoke(begin_invoke(value, args));}
      
      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>
      void invoke(delegate_t value) {invoke(delegate<void(std::vector<std::any>)>(value), {});}

      void perform_layout();
      
      xtd::drawing::point point_to_client(const xtd::drawing::point& p);
      
      xtd::drawing::point point_to_screen(const xtd::drawing::point& p);
      
      virtual bool pre_process_message(xtd::forms::message& message);

      virtual void refresh() const;
      
      void resume_layout() {resume_layout(true);}
      
      void resume_layout(bool perform_layout) {
        set_state(state::layout_deferred, false);
        if (perform_layout) this->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) {set_bounds(x, y, width, height, bounds_specified::all);}

      void set_bounds(int32_t x, int32_t y, int32_t width, int32_t height, bounds_specified specified) {set_bounds_core(x, y, width, height, specified);}

      virtual void show() {visible(true);}
      
      void suspend_layout() {
        set_state(state::layout_deferred, true);
      }
      
      xtd::ustring to_string() const noexcept override;
      
      virtual void update() const;
      
      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, 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> resize;
        
      event<control, event_handler> size_changed;

      event<control, event_handler> text_changed;
      
      event<control, event_handler> visible_changed;

    protected:
      friend class application;
      friend class paint_event_args;
      friend class screen;
      
      virtual forms::create_params create_params() const;
      
      virtual void def_wnd_proc(message& message);

      bool get_style(control_styles flag) const {return ((int32_t)style_ & (int32_t)flag) == (int32_t)flag;}

      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_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_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_size_changed(const event_args& e);

      virtual void on_text_changed(const event_args& e);
      
      virtual void on_visible_changed(const event_args& e);

      virtual void recreate_handle();
 
      virtual void set_bounds_core(int32_t x, int32_t y, int32_t width, int32_t height, bounds_specified specified);
      
      virtual void set_client_size_core(int32_t width, int32_t height);
        
      void set_style(control_styles flag, bool value) {style_ = value ? (control_styles)((int32_t)style_ | (int32_t)flag) : (control_styles)((int32_t)style_ & ~(int32_t)flag);}

      virtual void wnd_proc(message& m);

      bool get_state(control::state flag) const {return ((int32_t)state_ & (int32_t)flag) == (int32_t)flag;}
      void set_state(control::state flag, bool value) { state_ = value ? (control::state)((int32_t)state_ | (int32_t)flag) : (control::state)((int32_t)state_ & ~(int32_t)flag); }

      anchor_styles anchor_ = anchor_styles::top | anchor_styles::left;
      drawing::point auto_scroll_point_;
      auto_size_mode auto_size_mode_ = 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_;
      control_collection controls_;
      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_;
      forms::padding margin_ {3};
      drawing::size maximum_size_;
      drawing::size minimum_size_;
      forms::padding padding_;
      static forms::keys modifier_keys_;
      static forms::mouse_buttons mouse_buttons_;
      bool mouse_in_ = false;
      xtd::ustring name_;
      intptr_t parent_ = 0;
      drawing::size parent_size_;
      drawing::size size_;
      control::state state_ = state::empty;
      control_styles style_ = control_styles::none;
      std::any tag_;
      xtd::ustring text_;
      static std::map<intptr_t, control*> handles_;
      static control_collection top_level_controls_;
      
    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) {name_ = name;}
      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_key_char(message& message);
      void wm_kill_focus(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_paint(message& message);
      void wm_scroll(message& message);
      void wm_set_focus(message& message);
      void wm_set_text(message& message);
      void wm_size(message& message);
    };
  }
}