form.h

Go to the documentation of this file.

 
#pragma once
#include "const_form_ref.h"
#include "form_border_style.h"
#include "form_closed_event_handler.h"
#include "form_closing_event_handler.h"
#include "form_ref.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"
#include "status_bar.h"
#include "tool_bar.h"
#include <xtd/drawing/icon>
#include <xtd/io/path>
#include <cstddef>
 
namespace xtd {
  namespace forms {
    class application;
    class application_context;
    class form;
    
    class forms_export_ form : public container_control {
      struct data;
      
    public:
      
      using ibutton_control_ref = std::reference_wrapper<xtd::forms::ibutton_control>;
      
      using main_menu_ref = std::reference_wrapper<xtd::forms::main_menu>;
      
      using status_bar_ref = std::reference_wrapper<xtd::forms::status_bar>;
      
      using tool_bar_ref = std::reference_wrapper<xtd::forms::tool_bar>;
      
      
      form();
      
      
      std::optional<ibutton_control_ref> accept_button() const noexcept;
      form& accept_button(const ibutton_control& value);
      form& accept_button(std::nullptr_t);
      
      virtual forms::auto_size_mode auto_size_mode() const noexcept;
      virtual form& auto_size_mode(forms::auto_size_mode value);
      
      std::optional<ibutton_control_ref> cancel_button() const noexcept;
      form& cancel_button(const ibutton_control& value);
      form& cancel_button(std::nullptr_t);
      
      virtual bool close_box() const noexcept;
      virtual form& close_box(bool value);
      
      virtual bool control_box() const noexcept;
      virtual form& control_box(bool value);
      
      virtual forms::dialog_result dialog_result() const noexcept;
      virtual form& dialog_result(forms::dialog_result value);
      
      using container_control::font;
      control& font(std::nullptr_t) override;
      
      virtual forms::form_border_style form_border_style() const noexcept;
      virtual form& form_border_style(forms::form_border_style value);
      
      virtual bool help_button() const;
      virtual form& help_button(bool value);
      
      virtual const xtd::drawing::icon& icon() const noexcept;
      virtual form& icon(const xtd::drawing::icon& value);
      
      virtual bool maximize_box() const noexcept;
      virtual form& maximize_box(bool value);
      
      virtual std::optional<main_menu_ref> menu() const noexcept;
      virtual form& menu(const forms::main_menu& value);
      virtual form& menu(std::nullptr_t);
      
      virtual bool minimize_box() const noexcept;
      virtual form& minimize_box(bool value);
      
      bool modal() const noexcept;
      
      virtual double opacity() const noexcept;
      virtual form& opacity(double opacity);
      
      virtual std::optional<control_ref> owner() const noexcept;
      virtual form& owner(const control& value);
      virtual form& owner(std::nullptr_t);
      
      using container_control::parent;
      control& parent(const control& value) override;
      
      virtual bool show_icon() const noexcept;
      virtual form& show_icon(bool value);
      
      virtual bool show_in_taskbar() const noexcept;
      virtual form& show_in_taskbar(bool value);
      
      virtual form_start_position start_position() const noexcept;
      virtual form& start_position(form_start_position value);
      
      virtual std::optional<status_bar_ref> status_bar() const noexcept;
      virtual form& status_bar(const forms::status_bar& value);
      virtual form& status_bar(std::nullptr_t);
      
      virtual std::optional<tool_bar_ref> tool_bar() const noexcept;
      virtual form& tool_bar(const forms::tool_bar& value);
      virtual form& tool_bar(std::nullptr_t);
      
      virtual bool top_level() const noexcept;
      virtual form& top_level(bool top_level);
      
      virtual bool top_most() const noexcept;
      virtual form& top_most(bool value);
      
      using container_control::visible;
      control& visible(bool visible) override;
      
      virtual form_window_state window_state() const noexcept;
      virtual form& window_state(form_window_state value);
      
      
      static std::optional<form_ref> active_form() noexcept;
      
      
      void activate();
      
      void bring_to_front() override;
      
      void center_to_screen();
      
      void close();
 
      bool pre_process_message(const 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);
      
      
      static form create();
      static form create(const xtd::string& text);
      static form create(const xtd::string& text, const drawing::point& location);
      static form create(const xtd::string& text, const drawing::point& location, const drawing::size& size);
      static form create(const xtd::string& text, const drawing::point& location, const drawing::size& size, const xtd::string& name);
      static form create(const xtd::string& text, const drawing::size& size);
      static form create(const xtd::string& text, const drawing::size& size, const xtd::string& name);
      static form create(const xtd::string& text, form_start_position start_position);
      static form create(const xtd::string& text, form_start_position start_position, const drawing::point& location);
      static form create(const xtd::string& text, form_start_position start_position, const drawing::point& location, const drawing::size& size);
      static form create(const xtd::string& text, form_start_position start_position, const drawing::point& location, const drawing::size& size, const xtd::string& name);
      static form create(const xtd::string& text, form_start_position start_position, const drawing::size& size);
      static form create(const xtd::string& text, form_start_position start_position, const drawing::size& size, const xtd::string& name);
      
      
      event<form, event_handler> activated;
      
      event<form, event_handler> deactivate;
      
      event<form, form_closed_event_handler> form_closed;
      
      event<form, form_closing_event_handler> form_closing;
      
    protected:
      friend class application;
      
      
      forms::create_params create_params() const noexcept override;
      drawing::size default_size() const noexcept override;
      
      
      xtd::uptr<xtd::object> clone() const override;
      
      virtual void on_activated(const event_args& e);
      
      virtual void on_deactivate(const event_args& 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);
      
      virtual void on_form_closing(form_closing_event_args& e);
      
      void on_layout(const event_args& e) override;
      void on_location_changed(const event_args& e) override;
      void on_paint(paint_event_args& e) override;
      void on_region_changed(const event_args& e) override;
      
      void on_resize(const event_args& e) override;
      void wnd_proc(message& message) override;
      
    private:
      friend class application_context;
      bool closed_() const noexcept;
      void internal_set_window_state();
      
      void create_system_menu();
      void destroy_system_menu();
      
      void fill_in_create_params_border_icons(xtd::forms::create_params& cp) const;
      void fill_in_create_params_border_styles(xtd::forms::create_params& cp) const;
      void fill_in_create_params_start_position(xtd::forms::create_params& cp) const;
      void fill_in_create_params_window_state(xtd::forms::create_params& cp) const;
      
      void wm_activate(message& message);
      void wm_close(message& message);
      void wm_recreate(message& message);
      void wm_syscolor_change(message& message);
      
      xtd::sptr<data> data_;
      static std::optional<form_ref> active_form_;
    };
  }
}