Skip to main content

Form

In This Section

Overview

The forms are what we call top level controls.

There are three types of forms:

  • form
  • MDI and child
  • dialog

Show

These forms can be displayed in different ways:

Remarks

Sheet is a special dialog mode on macOS :

  • TThe dialog is shown centered on form (if form is specifed) without title.
  • The method is not blocking and you must retrieve the result of the dialog at the closing event.
  • On other platforms than macOS, is a normal dialog, but you must also retrieve the result of the dialog on the close event but the method is blocking (this can be changed in the future).

Example

The following example demonstates the different ways to display a xtd::forms::form.

#include <xtd/xtd>

using namespace std;
using namespace xtd;
using namespace xtd::drawing;
using namespace xtd::forms;

namespace example {
class form1 : public form {
public:
form1() {
client_size({320, 610});
controls().push_back(layout_panel);
padding(5);
text("Form show example");

layout_panel.dock(dock_style::fill);
layout_panel.controls().push_back_range({button_normal, button_modeless, button_top_most, button_modal, button_sheet, button_sheet_modal});
layout_panel.control_layout_style(button_normal, {size_type::auto_size, true});
layout_panel.control_layout_style(button_modeless, {size_type::auto_size, true});
layout_panel.control_layout_style(button_top_most, {size_type::auto_size, true});
layout_panel.control_layout_style(button_modal, {size_type::auto_size, true});
layout_panel.control_layout_style(button_sheet, {size_type::auto_size, true});
layout_panel.control_layout_style(button_sheet_modal, {size_type::auto_size, true});

button_normal.text("Show normal");
button_normal.click += [&] {
auto dialog = make_unique<form>();
dialog->text("dialog show normal");
dialog->size({250, 100});
dialog->show();
dialogs.push_back(std::move(dialog));
};

button_modeless.text("Show modeless");
button_modeless.click += [&] {
auto dialog = make_unique<form>();
dialog->text("dialog show modeless");
dialog->size({250, 100});
dialog->owner(*this).show();
dialogs.push_back(std::move(dialog));
};

button_top_most.text("Show top most");
button_top_most.click += [&] {
auto dialog = make_unique<form>();
dialog->text("dialog top most");
dialog->size({250, 100});
dialog->top_most(true).show();
dialogs.push_back(std::move(dialog));
};

button_modal.text("Show modal");
button_modal.click += [&] {
auto dialog = form::create("dialog show modal", size {250, 100});
dialog.show_dialog(*this);
};

button_sheet.text("Show sheet");
button_sheet.click += [&] {
auto dialog = make_unique<form>();
dialog->text("dialog show sheet");
dialog->size({250, 100});
dialog->key_up += [&](object & control, key_event_args & e) {
if (e.key_code() == keys::escape) as<form&>(control).close();
};
dialog->show_sheet(*this);
dialogs.push_back(std::move(dialog));
};

button_sheet_modal.text("Show sheet modal");
button_sheet_modal.click += [&] {
auto dialog = form::create("dialog show sheet modal", size {250, 100});
dialog.key_up += [&](object & control, key_event_args & e) {
if (e.key_code() == keys::escape) as<form&>(control).close();
};
dialog.show_sheet_dialog(*this);
};
}

static auto main() {
application::run(form1());
}

private:
vertical_layout_panel layout_panel;
button button_normal;
button button_modeless;
button button_top_most;
button button_modal;
button button_sheet;
button button_sheet_modal;
vector<shared_ptr<form>> dialogs;
};
}

startup_(example::form1);

Start position

A form can be shown with different start positions:

Window state

A form can be shown with different states:

Examples

The folloing example demonstates the different ways to display a xtd::forms::form.

#define TRACE
#include <xtd/xtd>

using namespace xtd;
using namespace xtd::forms;

class form1 : public form {
public:
form1() {
*this << button_full_screen << button_maximize << button_minimize << button_normal;
text("Window state example");
resize += [&] {
button_full_screen.enabled(window_state() != form_window_state::full_screen && window_state() != form_window_state::maximized);
button_maximize.enabled(window_state() != form_window_state::maximized && window_state() != form_window_state::full_screen);
button_normal.enabled(window_state() != form_window_state::normal);
button_minimize.enabled(window_state() != form_window_state::minimized && window_state() != form_window_state::full_screen);

ctrace << ustring::format("resize: {}, {}", size(), window_state()) << std::endl;
};
client_size({410, 200});
window_state(form_window_state::maximized);

button_full_screen.location({10, 10});
button_full_screen.text("Full screen");
button_full_screen.width(90);
button_full_screen.click += [&] {
window_state(form_window_state::full_screen);
};

button_maximize.location({110, 10});
button_maximize.text("Maximize");
button_maximize.width(90);
button_maximize.click += [&] {
window_state(form_window_state::maximized);
};

button_normal.location({210, 10});
button_normal.text("Normal");
button_normal.width(90);
button_normal.click += [&] {
window_state(form_window_state::normal);
};

button_minimize.location({310, 10});
button_minimize.text("Minimize");
button_minimize.width(90);
button_minimize.click += [&] {
window_state(form_window_state::minimized);
};
}

private:
button button_full_screen;
button button_maximize;
button button_normal;
button button_minimize;
};

auto main() -> int {
application::run(form1());
}

Form

The xtd::forms::form represents a window or dialog box that makes up an application's user interface.

MDI and child

Not yet implemented.

Dialog

A dialog does not have a defined type, it is a xtd::forms::form.

The only difference is that a dialog cannot have a menu, a toolbar or a status bar.

If any of the above elements are accidentally present, an xtd::invalid_operation_exception will be generated during the dialog show.

Examples

The following example demontrates how to create your own dialog :

#include <xtd/xtd>

using namespace std;
using namespace xtd;
using namespace xtd::forms;

class user_input_dialog : public form {
public:
user_input_dialog() {
accept_button(button_ok);
cancel_button(button_cancel);
client_size({200, 80});
form_border_style(forms::form_border_style::fixed_dialog);
minimize_box(false);
maximize_box(false);
show_icon(false);
start_position(form_start_position::center_parent);
text("User input dialog");
controls().push_back_range({input, button_ok, button_cancel});

input.location({10, 10});
input.width(180);

button_cancel.dialog_result(forms::dialog_result::cancel);
button_cancel.location({10, 50});
button_cancel.text("Cancel");
button_cancel.width(85);

button_ok.dialog_result(forms::dialog_result::ok);
button_ok.location({105, 50});
button_ok.text("OK");
button_ok.width(85);

active_control(input);
}

virtual ustring input_text() const {return input.text();}
virtual user_input_dialog& input_text(const ustring& input_text) {
input.text(input_text);
return *this;
}

private:
text_box input;
button button_cancel;
button button_ok;
};

class form1 : public form {
public:
form1() {
controls().push_back_range({button_dialog, input_text});
size({800, 450});
text("User dialog exemple");

input_text.auto_size(true);
input_text.location({10, 50});
input_text.text("User input text");

button_dialog.location({10, 10});
button_dialog.text("Dialog...");
button_dialog.click += [&] {
dialog.input_text(input_text.text());
if (dialog.show_dialog(*this) == forms::dialog_result::ok)
input_text.text(dialog.input_text());
};
}

private:
user_input_dialog dialog;
button button_dialog;
label input_text;
};

auto main() -> int {
application::run(form1());
}

See also