#include "smg_app.hpp"

#include "widgets/smgw_button.hpp"
#include "widgets/smgw_label.hpp"

#include "containers/smgw_vgroup.hpp"
#include "containers/smgw_hgroup.hpp"

#include "dialogs/smgw_info.hpp"

class testing : public smg::iface, public smg::gets_messages
{
  private:
    // defines a common interface for everything in this class to use
		smg::smg_interface main;

                // creates a window of the defaulted type.
		smg::window<> window;

	private: // dialogs

	private: // containers
                // containers hold other widgets. They are considered widgets
                // themselves.
                // a 'vgroup' holds a vertical arrangement of widgets.
                // 'hgroup' is the same, but horizontally.
		smg::widget_container< smg::widget::vgroup > the_vgroup;
		smg::widget_container< smg::widget::hgroup > the_buttons;

	private: // widgets
                // just a couple button widgets
		smg::widget_item< smg::widget::button > the_ok_button;
		smg::widget_item< smg::widget::button > the_cancel_button;

	private:
                // this is virtual and is called whenever a widget wants to
                // notify us of something (such as a button click).
		void incoming_widget_message(smg::sends_messages &from_,
		 size_t msg_, smg::message_data *data_);

	protected:
		testing();
		virtual ~testing() { }

};

testing::testing()
: main(0), window(main, get_info())
{
        // set up some default text for the buttons
	the_cancel_button->set_text("cancel");
	the_ok_button->set_text("ok");

        // this associates (attaches) a widget with a container.
        // since the_buttons is a horizontal container, attach_front attaches 
        // the widget after the last widget on the left side. attach_back attaches
        // before the first widget on the right side.
	the_buttons->attach_front(the_cancel_button);	
	the_buttons->attach_back(the_ok_button);	

	{
                // a managed widget is managed by smg itself.
                // when add_me goes out of scope, the underlying widget will
                // persist until it has been removed from a container.
                // a widget_item<> (see above) will remove itself from the
                // container when it goes out of scope.
                // managed widgets are useful for, say, adding a list of
                // files to a container widget where you don't wish to manage
                // the widget yourself.
		smg::widget_managed< smg::widget::label > add_me;
		add_me->set_text("This is a simple label");

		the_vgroup->attach_front(add_me);
	}

        // since the_vgroup is a vertical container, buttons will appear
        // at the bottom.
	the_vgroup->attach_back(the_buttons);

        // associate a widget (remember, containers are widgets too) to the
        // window. A window's underying container can hold only one 
        // non-overlapped widget
        // (but this of course can be many widgets held together in a single
        // container).
	window.attach(the_vgroup);

        // enables calling 'incoming_widget_message' for the specifed widget /
        // window.
	watch_for_messages(the_ok_button);
	watch_for_messages(window);

        // this creates a window, resizes it, and draws everything.
        // the window is now ready for events to occur.
	window.activate();
}

void testing::incoming_widget_message(smg::sends_messages &from_,
 size_t msg_, smg::message_data *data_)
{
        // if the window has been closed with the 'X' button, this
        // requests to smg that we wish to terminate this interface.
	if (from_ == window && msg_ == smg::window_base::close_request)
		request_terminate();

        // user clicked on 'ok' button. We just pop up a simple dialog.
	if (from_ == the_ok_button && msg_ == smg::widget::button::button_clicked)
		smg::widget::simple_error(window, "Some title", "some text");
}

int main(int, char **)
{
        // this is needed to instantiate SML (SandMines Library).
	sml::sml_main sml_start;

        // set up some debugging stuffs
	sml::exception::get_logger().set_warn_as_fatal(true);
	sml::exception::set_abort_on_exception(true);

        // instantiate our 'testing' interface
	smg::local_interface< testing > local;

        // wait until the interface calls request_terminate().
	local.wait_for_terminate();
}