Unigine::Property Class

#ifndef __APP_SYSTEM_LOGIC_H__
#define __APP_SYSTEM_LOGIC_H__

#include <UnigineLogic.h>
#include <UnigineWidgets.h>
#include <UnigineGui.h>
#include <UnigineMap.h>

using namespace Unigine;
using namespace Math;

class AppSystemLogic : public Unigine::SystemLogic
{

private:
	// declaring UI widgets to be used
	WidgetWindowPtr window;
	WidgetHBoxPtr hbox;

	WidgetGroupBoxPtr properties_gb;
	WidgetTreeBoxPtr properties;
	WidgetGroupBoxPtr parameters_gb;
	WidgetTreeBoxPtr parameters;
	WidgetGroupBoxPtr value_gb;
	WidgetGroupBoxPtr menu_gb;

	WidgetVBoxPtr vbox2, vbox3;
	WidgetHBoxPtr hbox2;
	WidgetButtonPtr reload;
	WidgetButtonPtr clone;
	WidgetButtonPtr inherit;
	WidgetButtonPtr save_prop;

	// values
	Vector<WidgetLabelPtr> label;
	WidgetEditLinePtr value;
	WidgetButtonPtr change;
	WidgetButtonPtr reset;

	WidgetLabelPtr info;
	WidgetLabelPtr prop_info;
	// lists of properties and parameters
	Map<int, PropertyPtr> item_prop;
	Map<int, PropertyParameterPtr> item_param;

	void refresh_properties();
	void properties_changed();
	void parameters_changed();

	void change_clicked();
	void reset_clicked();
	void reload_clicked();
	void refresh_info();
	void clone_clicked();
	void inherit_clicked();
	void save_prop_clicked();
public:
	AppSystemLogic();
	~AppSystemLogic() override;

	int init() override;

	int update() override;
	int postUpdate() override;

	int shutdown() override;
};

#endif // __APP_SYSTEM_LOGIC_H__

#include "AppSystemLogic.h"
#include <UnigineProperties.h>
#include <UnigineFileSystem.h>
#include <functional>

using namespace Unigine;

// System logic, it exists during the application life cycle.
// These methods are called right after corresponding system script's (UnigineScript) methods.

AppSystemLogic::AppSystemLogic()
{
}

AppSystemLogic::~AppSystemLogic()
{
}

int AppSystemLogic::init()
{
	Engine::get()->setBackgroundUpdate(true);

	// creating user interface
	GuiPtr gui = Gui::getCurrent();
	window = WidgetWindow::create(gui, "Properties Viewer");
	window->setSizeable(1);
	window->setWidth(WindowManager::getMainWindow()->getSize().x);
	window->setHeight(WindowManager::getMainWindow()->getSize().y);
	gui->addChild(window, Gui::ALIGN_OVERLAP);

	vbox2 = WidgetVBox::create(gui);
	window->addChild(vbox2, Gui::ALIGN_EXPAND);

	hbox = WidgetHBox::create(gui);
	vbox2->addChild(hbox, Gui::ALIGN_EXPAND);

	properties_gb = WidgetGroupBox::create(gui, "Properties");
	parameters_gb = WidgetGroupBox::create(gui, "Parameters");
	hbox->addChild(properties_gb, Gui::ALIGN_EXPAND);
	hbox->addChild(parameters_gb, Gui::ALIGN_EXPAND);

	properties = WidgetTreeBox::create(gui);
	parameters = WidgetTreeBox::create(gui);
	properties_gb->addChild(properties, Gui::ALIGN_EXPAND);
	parameters_gb->addChild(parameters, Gui::ALIGN_EXPAND);

	vbox3 = WidgetVBox::create(gui);
	hbox->addChild(vbox3, Gui::ALIGN_EXPAND);
	value_gb = WidgetGroupBox::create(gui, "Value");
	value_gb->setWidth(300);
	value_gb->setHeight(300);
	value_gb->arrange();
	menu_gb = WidgetGroupBox::create(gui, "Menu");
	vbox3->addChild(value_gb, Gui::ALIGN_LEFT);
	vbox3->addChild(menu_gb, Gui::ALIGN_EXPAND);

	label.append() = WidgetLabel::create(gui, "");
	label.last()->setFontRich(1);
	value_gb->addChild(label.last(), Gui::ALIGN_LEFT);
	value = WidgetEditLine::create(gui);
	value_gb->addChild(value, Gui::ALIGN_EXPAND);
	for (int i = 0; i < 12; i++)
	{
		label.append() = WidgetLabel::create(gui, "");
		label.last()->setFontRich(1);
		value_gb->addChild(label.last(), Gui::ALIGN_LEFT);
	}
	change = WidgetButton::create(gui, "Change Value");
	value_gb->addChild(change, Gui::ALIGN_LEFT);
	reset = WidgetButton::create(gui, "Reset Value");
	value_gb->addChild(reset, Gui::ALIGN_LEFT);

	reload = WidgetButton::create(gui, "Reload Property Files");
	clone = WidgetButton::create(gui, "Clone Property");
	inherit = WidgetButton::create(gui, "Inherit Property");
	save_prop = WidgetButton::create(gui, "Save Property");

	menu_gb->addChild(reload, Gui::ALIGN_EXPAND);
	menu_gb->addChild(clone, Gui::ALIGN_EXPAND);
	menu_gb->addChild(inherit, Gui::ALIGN_EXPAND);
	menu_gb->addChild(save_prop, Gui::ALIGN_EXPAND);

	info = WidgetLabel::create(gui);
	info->setFontRich(1);
	info->setText(
		"<font color=00ffff>Unique value</font><br>"
		"<font color=ffffff>Inherited value</font><br>"
		"<font color=ffff00>Overridden value</font><br>");
	menu_gb->addChild(info, Gui::ALIGN_LEFT);
	prop_info = WidgetLabel::create(gui);
	menu_gb->addChild(prop_info, Gui::ALIGN_LEFT);

	// setting callbacks for UI elements
	properties->addCallback(Gui::CHANGED, MakeCallback(this, &AppSystemLogic::properties_changed));
	parameters->addCallback(Gui::CHANGED, MakeCallback(this, &AppSystemLogic::parameters_changed));

	change->addCallback(Gui::CLICKED, MakeCallback(this, &AppSystemLogic::change_clicked));
	reset->addCallback(Gui::CLICKED, MakeCallback(this, &AppSystemLogic::reset_clicked));
	reload->addCallback(Gui::CLICKED, MakeCallback(this, &AppSystemLogic::reload_clicked));
	clone->addCallback(Gui::CLICKED, MakeCallback(this, &AppSystemLogic::clone_clicked));
	inherit->addCallback(Gui::CLICKED, MakeCallback(this, &AppSystemLogic::inherit_clicked));
	save_prop->addCallback(Gui::CLICKED, MakeCallback(this, &AppSystemLogic::save_prop_clicked));

	refresh_properties();
	return 1;
}

/// method refreshing properties
void AppSystemLogic::refresh_properties()
{
	properties->setCallbackEnabled(Gui::CHANGED, 0);
	properties->clear();
	item_prop.clear();

	// recursive function iterating through all children properties and building property hierarchy
	std::function<void(int, const PropertyPtr &)> attach_children = [&, this](int parent, const PropertyPtr &prop_parent)
	{
		for (int k = 0; k < prop_parent->getNumChildren(); k++)
		{
			PropertyPtr prop = prop_parent->getChild(k);
			if (prop != prop_parent && prop->getParent() && prop->getParent() == prop_parent)
			{
				int child = properties->addItem(prop->getName());
				properties->addItemChild(parent, child);
				item_prop.append(child, prop);
				attach_children(child, prop);
			}
		}
	};
	// building property hierarchy
	for (int i = 0; i < Properties::getNumProperties(); i++)
	{
		PropertyPtr prop_base = Properties::getProperty(i);
		if (prop_base->isBase())
		{
			int parent = properties->addItem(prop_base->getName());
			item_prop.append(parent, prop_base);
			attach_children(parent, prop_base);
		}
	}
	properties->setCallbackEnabled(Gui::CHANGED, 1);
}

/// method refreshing property parameters
void AppSystemLogic::properties_changed()
{
	parameters->setCallbackEnabled(Gui::CHANGED, 0);
	// clearing the list of property parameters and updating values displayed
	parameters->clear();
	value_gb->setEnabled(0);
	for (int i = 0; i <= 12; i++)
		label[i]->setText("");

	item_param.clear();

	int item = properties->getCurrentItem();
	if (item == -1)
	{
		parameters->setCallbackEnabled(Gui::CHANGED, 1);
		return;
	}
	// getting a property from the list in accordance with current selection
	PropertyPtr prop = item_prop[item];

	// getting a root parameter of the selected property
	PropertyParameterPtr pp = prop->getParameterPtr();

	// recursive function iterating through all parameters of a property
	std::function<void(int, const PropertyParameterPtr &)> add_parameters = [&, this](int parent, const PropertyParameterPtr &p)
	{
		for (int i = 0; i < p->getNumChildren(); i++)
		{
			PropertyParameterPtr child = p->getChild(i);
			int child_index = parameters->addItem(child->getName());
			parameters->setItemColor(child_index,
				vec4(
					itof(child->isInherited()),
					1,
					itof(!child->isOverridden()),
					child->isHidden() ? 0.5f : 1.0f));
			item_param.append(child_index, child);

			if (parent != -1)
				parameters->addItemChild(parent, child_index);

			add_parameters(child_index, child);
		}
	};

	// building the hierarchy of parameters for the selected property
	add_parameters(-1, pp);

	// preparing property information
	String pi = String::format("\nName: %s\nPath: %s\nInternal: %d\nStructs: %d\n", prop->getName(), prop->getPath(), prop->isInternal(), prop->getNumStructs());
	// adding all structures defined in the property (if any)
	for (int i = 0; i < prop->getNumStructs(); i++)
		pi += String::format("%d) %s\n", i, prop->getStructName(i));
	// displaying property information
	prop_info->setText(pi.get());

	parameters->setCallbackEnabled(Gui::CHANGED, 1);
	parameters->setCurrentItem(-1);
}
/// method refreshing information about the currently selected property parameter
void AppSystemLogic::parameters_changed()
{
	// checking if any property parameter is selected
	int item = parameters->getCurrentItem();
	if (item == -1)
		return;

	value_gb->setEnabled(1);
	// getting the parameter from the list in accordance with current selection
	PropertyParameterPtr p = item_param[item];
	int i = 0;
	label[i++]->setText(String::format("<font color=ffff00>ID:</font> %d", p->getID()));
	label[i++]->setText(String::format("<font color=ffff00>Name:</font> %s", p->getName()));
	label[i++]->setText(String::format("<font color=ffff00>Title:</font> %s", p->getTitle()));
	label[i++]->setText(String::format("<font color=ffff00>Tooltip:</font> %s", p->getTooltip()));
	label[i++]->setText(String::format("<font color=ffff00>Group:</font> %s", p->getGroup()));
	label[i++]->setText(String::format("<font color=ffff00>Filter:</font> %s", p->getFilter()));

	String s;
	// displaying parameter's type
	if (p->getType() == Property::PARAMETER_ARRAY)
		s = String::format("<font color=ffff00>Type:</font> array "
			"[<font color=ffff00>Size:</font> %d, <font color=ffff00>Type:</font> %s]", p->getArraySize(), p->getArrayTypeName());
	else if (p->getType() == Property::PARAMETER_STRUCT)
		s = String::format("<font color=ffff00>Type:</font> struct [<font color=ffff00>Struct Name:</font> %s]", p->getStructName());
	else
		s = String::format("<font color=ffff00>Type:</font> %s", p->getProperty()->parameterNameByType(p->getType()));
	label[i++]->setText(s.get());
	label[i++]->setText(String::format("<font color=ffff00>Hidden:</font> %d", p->isHidden()));
	label[i++]->setText(String::format("<font color=ffff00>Inherited:</font> %d", p->isInherited()));
	label[i++]->setText(String::format("<font color=ffff00>Overridden:</font> %d", p->isOverridden()));
	label[i++]->setText(String::format("<font color=ffff00>Has Min:</font> %d", p->hasSliderMinValue()));
	label[i++]->setText(String::format("<font color=ffff00>Has Max:</font> %d", p->hasSliderMaxValue()));
	s = "";
	if (p->getType() == Property::PARAMETER_INT)
		s = String::format("<font color=ffff00>Min:</font> %d <font color=ffff00>Max:</font> %d", p->getIntMinValue(), p->getIntMaxValue());
	else if (p->getType() == Property::PARAMETER_FLOAT)
		s = String::format("<font color=ffff00>Min:</font> %f <font color=ffff00>Max:</font> %f", p->getFloatMinValue(), p->getFloatMaxValue());
	else if (p->getType() == Property::PARAMETER_DOUBLE)
		s = String::format("<font color=ffff00>Min:</font> %f <font color=ffff00>Max:</font> %f", p->getDoubleMinValue(), p->getDoubleMaxValue());
	else if (p->getType() == Property::PARAMETER_SWITCH)
		s = String::format("<font color=ffff00>Switch Num Items:</font> %d", p->getSwitchNumItems());
	label[i++]->setText(s.get());
	value->setText(p->getValueString());
	reset->setEnabled(p->isOverridden());
}

/// change button on_click event handler
void AppSystemLogic::change_clicked()
{
	// checking if any property parameter is currently selected
	int item = parameters->getCurrentItem();
	if (item == -1)
		return;
	// setting the value of the currently selected property parameter and refreshing information
	PropertyParameterPtr pp = item_param[item];
	pp->setValue(value->getText());

	refresh_info();
}

/// reset button on_click event handler
void AppSystemLogic::reset_clicked()
{
	// checking if any property parameter is currently selected
	int item = parameters->getCurrentItem();
	if (item == -1)
		return;

	// resetting the value of the currently selected property parameter and refreshing information
	PropertyParameterPtr pp = item_param[item];
	pp->resetValue();

	refresh_info();
}

/// reload button on_click event handler
void AppSystemLogic::reload_clicked()
{
	// reload all properties and refreshing information
	Properties::reloadProperties();
	refresh_info();
}

/// method refreshing property and parameter information
void AppSystemLogic::refresh_info()
{
	// getting current indices of property and parameter selection
	int item_pr = properties->getCurrentItem();
	int item_pa = parameters->getCurrentItem();
	refresh_properties();

	// setting current items and updating information displayed
	properties->setCurrentItem(clamp(item_pr, -1, properties->getNumItems() - 1));
	properties_changed();
	parameters->setCurrentItem(clamp(item_pa, -1, parameters->getNumItems() - 1));
	parameters_changed();
}

void AppSystemLogic::clone_clicked()
{
	// checking if any property is selected in the hierarchy
	int item = properties->getCurrentItem();
	if (item == -1)
		return;
	// cloning the selected property
	PropertyPtr p = item_prop[item];
	PropertyPtr p_clone = p->clone();
	p_clone->setName(String::format("%s_cloned", p->getName()));

	// refreshing information displayed
	refresh_info();
}

/// inherit button on_click event handler
void AppSystemLogic::inherit_clicked()
{
	// checking if any property is selected in the hierarchy
	int item = properties->getCurrentItem();
	if (item == -1)
		return;
	// inheriting a new property from the selected one
	PropertyPtr p = item_prop[item];
	p->inherit()->setName(String::format("%s_inherited", p->getName()));

	// refreshing information displayed
	refresh_info();
}

/// method saving the currently selected property to the "my_test_prop.prop" file
void AppSystemLogic::save_prop_clicked()
{
	// checking if any property is selected in the hierarchy
	int item = properties->getCurrentItem();
	if (item == -1)
		return;
	// saving a property to the specified file
	PropertyPtr p = item_prop[item];
	p->save("my_test_prop.prop");
}
////////////////////////////////////////////////////////////////////////////////
// start of the main loop
////////////////////////////////////////////////////////////////////////////////

int AppSystemLogic::update()
{
	// Write here code to be called before updating each render frame.
	return 1;
}

int AppSystemLogic::postUpdate()
{
	// Write here code to be called after updating each render frame.
	return 1;
}

////////////////////////////////////////////////////////////////////////////////
// end of the main loop
////////////////////////////////////////////////////////////////////////////////

int AppSystemLogic::shutdown()
{
	// Write here code to be called on engine shutdown.
	return 1;
}