form.h

#pragma once
#include <cstddef>
#include <xtd/drawing/icon.h>
#include <xtd/io/path.h>
#include "form_border_style.h"
#include "form_closed_event_handler.h"
#include "form_closing_event_handler.h"
#include "form_start_position.h"
#include "form_window_state.h"
#include "container_control.h"
#include "dialog_result.h"
#include "ibutton_control.h"
#include "main_menu.h"
#include "screen.h"

namespace xtd {
  namespace forms {
    class application;
    class application_context;
    
    class form : public container_control {
    public:
      form();

      std::optional<std::reference_wrapper<ibutton_control>> accept_button() const {return accept_button_;}
      form& accept_button(const ibutton_control& value);
      form& accept_button(nullptr_t);
      
      std::optional<std::reference_wrapper<ibutton_control>> cancel_button() const {return cancel_button_;}
      form& cancel_button(const ibutton_control& value);
      form& cancel_button(nullptr_t);
      
      static std::optional<std::reference_wrapper<form>> active_form() {return active_form_;}
      
      virtual forms::auto_size_mode auto_size_mode() const {return auto_size_mode_;}
      virtual form& auto_size_mode(forms::auto_size_mode value);
      
      virtual bool close_box() const {return close_box_;}
      virtual form& close_box(bool value);
      
      virtual bool control_box() const {return control_box_;}
      virtual form& control_box(bool value);

      drawing::size default_size() const override {return {300, 300};}
      
      virtual forms::dialog_result dialog_result() const {return dialog_result_;}
      virtual form& dialog_result(forms::dialog_result value);
      
      virtual const xtd::drawing::icon& icon() const {return icon_;}
      virtual form& icon(const xtd::drawing::icon& value);
      
      virtual forms::form_border_style form_border_style() const {return form_border_style_;}
      virtual form& form_border_style(forms::form_border_style value);

      virtual bool help_button() const {return help_button_;}
      virtual form& help_button(bool value);
      
      virtual bool maximize_box() const {return maximize_box_;}
      virtual form& maximize_box(bool value);
      
      virtual std::optional<forms::main_menu> menu() const {return menu_;}
      virtual form& menu(const forms::main_menu& value);
      virtual form& menu(nullptr_t);

      virtual bool minimize_box() const {return minimize_box_;}
      virtual form& minimize_box(bool value);

      bool modal() const {return get_state(state::modal);}
      
      virtual std::optional<control_ref> owner() const {return from_handle(owner_);}
      virtual form& owner(const control& value);

      using container_control::parent;
      control& parent(const control& value) override;
      
      virtual bool show_icon() const {return show_icon_;}
      virtual form& show_icon(bool value);

      virtual form_start_position start_position() const {return start_position_;}
      virtual form& start_position(form_start_position value);

      virtual bool top_level() const {return get_state(state::top_level);}
      virtual form& top_level(bool top_level);

      virtual bool top_most() const {return top_most_;}
      virtual form& top_most(bool value);
      
      void bring_to_front() override;
      
      using container_control::visible;
      control& visible(bool visible) override;
      
      virtual form_window_state window_state() const {return window_state_;}
      virtual form& window_state(form_window_state value);
      
      void activate();
      
      void center_to_screen();
      
      void close();
      
      bool pre_process_message(xtd::forms::message& message) override; 
      
      virtual forms::dialog_result show_dialog();
      
      virtual forms::dialog_result show_dialog(const iwin32_window& owner);
      
      virtual void show_sheet(const iwin32_window& owner);
      
      virtual forms::dialog_result show_sheet_dialog(const iwin32_window& owner);
      
      event<form, event_handler<control&>> activated;
      event<form, event_handler<control&>> deactivate;

      event<form, form_closed_event_handler<control&>> form_closed;
      
      event<form, form_closing_event_handler<control&>> form_closing;

    protected:
      friend class application;
      forms::create_params create_params() const override;
   
      virtual void on_activated(const event_args& e) {activated(*this, e);}
      
      virtual void on_deactivate(const event_args& e) {deactivate(*this, e);}
      
      void on_handle_created(const event_args &e) override;
      
      void on_handle_destroyed(const event_args &e) override;
      
      virtual void on_form_closed(const form_closed_event_args& e) {form_closed(*this, e);}
      
      virtual void on_form_closing(form_closing_event_args& e) {form_closing(*this, e);}
      
      void on_layout(const event_args& e) override;
      
      void on_resize(const event_args& e) override;

      void wnd_proc(message& message) override;
      
      virtual void wm_activate(message& message);
      
      virtual void wm_close(message& message);
      
      std::optional<std::reference_wrapper<ibutton_control>> accept_button_;
      std::optional<std::reference_wrapper<ibutton_control>> cancel_button_;
      static std::optional<std::reference_wrapper<form>> active_form_;
      bool close_box_ = true;
      bool control_box_ = true;
      forms::dialog_result dialog_result_ = forms::dialog_result::none;
      forms::form_border_style form_border_style_ = form_border_style::sizable;
      bool help_button_ = true;
      xtd::drawing::icon icon_ = xtd::drawing::icon::empty;
      bool maximize_box_ = true;
      std::optional<forms::main_menu> menu_;
      bool minimize_box_ = true;
      std::shared_ptr<screen> previous_screeen_;
      bool show_icon_ = true;
      bool show_in_taskbar_ = true;
      form_start_position start_position_ = form_start_position::windows_default_location;
      form_window_state window_state_ = form_window_state::normal;
      
    private:
      friend class application_context;
      bool can_close_ = false;
      bool top_most_ = false;
      intptr_t owner_ = 0;
      void internal_set_window_state();
      intptr_t parent_before_show_dialog_ = 0;
    };
  }
}