FactoryCraft-Server/FactoryCraft/UIMLBuilder.h

#pragma once

#include <XML.h>

#include "Recipie.h"

template<typename T> class UIMLElementBuilder
{
protected:
    Framework::XML::Element* result;

    void calculate(int percentage, int pixelOffset, Framework::Text& result)
    {
        if (percentage != 0)
        {
            result += percentage;
            result += "%";
            if (pixelOffset > 0)
            {
                result += "+";
            }
            if (pixelOffset != 0)
            {
                result += pixelOffset;
            }
        }
        else
        {
            result += pixelOffset;
        }
    }

public:
    UIMLElementBuilder()
        : result(new Framework::XML::Element())
    {}

    ~UIMLElementBuilder()
    {
        if (result)
        {
            result->release();
        }
    }

    T* setID(const Framework::Text& id)
    {
        result->setAttribute("id", id);
        return (T*)this;
    }

    T* setWidth(int width)
    {
        result->setAttribute("width", Framework::Text() += width);
        return (T*)this;
    }

    T* setHeight(int height)
    {
        result->setAttribute("height", Framework::Text() += height);
        return (T*)this;
    }

    T* setWidthPercentage(int width)
    {
        result->setAttribute("width", (Framework::Text() += width) += "%");
        return (T*)this;
    }

    T* setHeightPercentage(int height)
    {
        result->setAttribute("height", (Framework::Text() += height) += "%");
        return (T*)this;
    }

    T* setWidth(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("width", value);
        return (T*)this;
    }

    T* setHeight(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("height", value);
        return (T*)this;
    }

    T* setAlignXStart()
    {
        result->setAttribute("align-x", "start");
        return (T*)this;
    }

    T* setAlignXCenter()
    {
        result->setAttribute("align-x", "center");
        return (T*)this;
    }

    T* setAlignXEnd()
    {
        result->setAttribute("align-x", "end");
        return (T*)this;
    }

    T* setAlignXToElement(const char* elementId)
    {
        result->setAttribute("align-x", elementId);
        return (T*)this;
    }

    T* setMarginX(int margin)
    {
        result->setAttribute("margin-x", Framework::Text() += margin);
        return (T*)this;
    }

    T* setMarginXPercentage(int margin)
    {
        result->setAttribute("margin-x", (Framework::Text() += margin) += "%");
        return (T*)this;
    }

    T* setMarginX(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("margin-x", value);
        return (T*)this;
    }

    T* setAlignLeftStart()
    {
        result->setAttribute("align-left", "start");
        return (T*)this;
    }

    T* setAlignLeftCenter()
    {
        result->setAttribute("align-left", "center");
        return (T*)this;
    }

    T* setAlignLeftEnd()
    {
        result->setAttribute("align-left", "end");
        return (T*)this;
    }

    T* setAlignLeftToElement(const char* elementId)
    {
        result->setAttribute("align-left", elementId);
        return (T*)this;
    }

    T* setMarginLeft(int margin)
    {
        result->setAttribute("margin-left", Framework::Text() += margin);
        return (T*)this;
    }

    T* setMarginLeftPercentage(int margin)
    {
        result->setAttribute(
            "margin-left", (Framework::Text() += margin) += "%");
        return (T*)this;
    }

    T* setMarginLeft(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("margin-left", value);
        return (T*)this;
    }

    T* setAlignRightStart()
    {
        result->setAttribute("align-right", "start");
        return (T*)this;
    }

    T* setAlignRightCenter()
    {
        result->setAttribute("align-right", "center");
        return (T*)this;
    }

    T* setAlignRightEnd()
    {
        result->setAttribute("align-right", "end");
        return (T*)this;
    }

    T* setAlignRightToElement(const char* elementId)
    {
        result->setAttribute("align-right", elementId);
        return (T*)this;
    }

    T* setMarginRight(int margin)
    {
        result->setAttribute("margin-right", Framework::Text() += margin);
        return (T*)this;
    }

    T* setMarginRightPercentage(int margin)
    {
        result->setAttribute(
            "margin-right", (Framework::Text() += margin) += "%");
        return (T*)this;
    }

    T* setMarginRight(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("margin-right", value);
        return (T*)this;
    }

    T* setAlignYStart()
    {
        result->setAttribute("align-y", "start");
        return (T*)this;
    }

    T* setAlignYCenter()
    {
        result->setAttribute("align-y", "center");
        return (T*)this;
    }

    T* setAlignYEnd()
    {
        result->setAttribute("align-y", "end");
        return (T*)this;
    }

    T* setAlignYToElement(const char* elementId)
    {
        result->setAttribute("align-y", elementId);
        return (T*)this;
    }

    T* setMarginY(int margin)
    {
        result->setAttribute("margin-y", Framework::Text() += margin);
        return (T*)this;
    }

    T* setMarginYPercentage(int margin)
    {
        result->setAttribute("margin-y", (Framework::Text() += margin) += "%");
        return (T*)this;
    }

    T* setMarginY(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("margin-y", value);
        return (T*)this;
    }

    T* setAlignTopStart()
    {
        result->setAttribute("align-top", "start");
        return (T*)this;
    }

    T* setAlignTopCenter()
    {
        result->setAttribute("align-top", "center");
        return (T*)this;
    }

    T* setAlignTopEnd()
    {
        result->setAttribute("align-top", "end");
        return (T*)this;
    }

    T* setAlignTopToElement(const char* elementId)
    {
        result->setAttribute("align-top", elementId);
        return (T*)this;
    }

    T* setMarginTop(int margin)
    {
        result->setAttribute("margin-top", Framework::Text() += margin);
        return (T*)this;
    }

    T* setMarginTopPercentage(int margin)
    {
        result->setAttribute(
            "margin-top", (Framework::Text() += margin) += "%");
        return (T*)this;
    }

    T* setMarginTop(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("margin-top", value);
        return (T*)this;
    }

    T* setAlignBottomStart()
    {
        result->setAttribute("align-bottom", "start");
        return (T*)this;
    }

    T* setAlignBottomCenter()
    {
        result->setAttribute("align-bottom", "center");
        return (T*)this;
    }

    T* setAlignBottomEnd()
    {
        result->setAttribute("align-bottom", "end");
        return (T*)this;
    }

    T* setAlignBottomToElement(const char* elementId)
    {
        result->setAttribute("align-bottom", elementId);
        return (T*)this;
    }

    T* setMarginBottom(int margin)
    {
        result->setAttribute("margin-bottom", Framework::Text() += margin);
        return (T*)this;
    }

    T* setMarginBottomPercentage(int margin)
    {
        result->setAttribute(
            "margin-bottom", (Framework::Text() += margin) += "%");
        return (T*)this;
    }

    T* setMarginBottom(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("margin-bottom", value);
        return (T*)this;
    }

    T* setX(int pixelOffset)
    {
        result->setAttribute("x", Framework::Text() += pixelOffset);
        return (T*)this;
    }

    T* setXPercentage(int percentage)
    {
        result->setAttribute("x", (Framework::Text() += percentage) += "%");
        return (T*)this;
    }

    T* setX(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("x", value);
        return (T*)this;
    }

    T* setY(int pixelOffset)
    {
        result->setAttribute("y", Framework::Text() += pixelOffset);
        return (T*)this;
    }

    T* setYPercentage(int percentage)
    {
        result->setAttribute("y", (Framework::Text() += percentage) += "%");
        return (T*)this;
    }

    T* setY(int percentage, int pixelOffset)
    {
        Framework::Text value;
        calculate(percentage, pixelOffset, value);
        result->setAttribute("y", value);
        return (T*)this;
    }

    T* setBorder(int width, int color)
    {
        result->setAttribute("border", Framework::Text() += width);
        Framework::Text value = "0x";
        value.appendHex(color);
        result->setAttribute("border-color", value);
        return (T*)this;
    }

    T* setOnClickMessage(
        const char* dialogName, std::initializer_list<char> message)
    {
        Framework::Text value(dialogName);
        value += ";";
        for (char c : message)
        {
            value += "(char)";
            value.appendHex((int)c);
        }
        result->setAttribute("onClick", value);
        return (T*)this;
    }

    Framework::XML::Element* build()
    {
        Framework::XML::Element* r = result;
        result = 0;
        delete this;
        return r;
    }
};

template<class T> class UIMLTextElementBuilder : public UIMLElementBuilder<T>
{
public:
    UIMLTextElementBuilder()
        : UIMLElementBuilder<T>()
    {}

    T* setText(const char* text)
    {
        this->result->setText(text);
        return (T*)this;
    }

    T* setFontSize(int size)
    {
        this->result->setAttribute("font-size", Framework::Text() += size);
        return (T*)this;
    }

    T* setWidthAuto()
    {
        this->result->setAttribute("width", "auto");
        return (T*)this;
    }

    T* setHeightAuto()
    {
        this->result->setAttribute("height", "auto");
        return (T*)this;
    }

    T* setTextColor(int color)
    {
        Framework::Text value("0x");
        value.appendHex(color);
        this->result->setAttribute("text-color", value);
        return (T*)this;
    }

    T* centerHorizontally()
    {
        this->result->setAttribute("text-align-horizontal", "center");
        return (T*)this;
    }

    T* centerVertically()
    {
        this->result->setAttribute("text-align-vertical", "center");
        return (T*)this;
    }

    T* enableVerticalScrollbar()
    {
        this->result->setAttribute("vScroll", "auto");
        return (T*)this;
    }

    T* enableHorizontalScrollbar()
    {
        this->result->setAttribute("hScroll", "auto");
        return (T*)this;
    }

    T* setStyle(__int64 style)
    {
        this->result->setAttribute("style", Framework::Text() += style);
        return (T*)this;
    }

    T* setDisabled(bool disabled)
    {
        if (disabled)
        {
            this->result->setAttribute("disabled", "");
        }
        else
        {
            this->result->removeAttribute("disabled");
        }
        return (T*)this;
    }
};

class UIMLTextBuilder : public UIMLTextElementBuilder<UIMLTextBuilder>
{
public:
    UIMLTextBuilder()
        : UIMLTextElementBuilder()
    {
        result->setName("text");
    }
};

class UIMLTextInputBuilder : public UIMLTextElementBuilder<UIMLTextInputBuilder>
{
public:
    UIMLTextInputBuilder()
        : UIMLTextElementBuilder()
    {
        result->setName("textfield");
    }
};

class UIMLTextAreaBuilder : public UIMLTextElementBuilder<UIMLTextInputBuilder>
{
public:
    UIMLTextAreaBuilder()
        : UIMLTextElementBuilder()
    {
        result->setName("textarea");
    }
};

class UIMLButtonBuilder : public UIMLElementBuilder<UIMLButtonBuilder>
{
public:
    UIMLButtonBuilder()
        : UIMLElementBuilder()
    {
        result->setName("button");
    }

    UIMLButtonBuilder* setText(const char* text)
    {
        result->setText(text);
        return this;
    }

    UIMLButtonBuilder* setFontSize(int size)
    {
        result->setAttribute("font-size", Framework::Text() += size);
        return this;
    }

    UIMLButtonBuilder* setStyle(__int64 style)
    {
        result->setAttribute("style", Framework::Text() += style);
        return this;
    }
};

class UIMLCheckboxBuilder : public UIMLElementBuilder<UIMLCheckboxBuilder>
{
public:
    UIMLCheckboxBuilder()
        : UIMLElementBuilder()
    {
        result->setName("check");
    }

    UIMLCheckboxBuilder* setText(const char* text)
    {
        result->setText(text);
        return this;
    }

    UIMLCheckboxBuilder* setFontSize(int size)
    {
        result->setAttribute("font-size", Framework::Text() += size);
        return this;
    }

    UIMLCheckboxBuilder* setStyle(__int64 style)
    {
        result->setAttribute("style", Framework::Text() += style);
        return this;
    }
};

class UIMLTableBuilder;

class UIMLTableRowBuilder
{
protected:
    Framework::XML::Element* result;
    Framework::XML::Element* parentElement;
    UIMLTableBuilder* parent;

public:
    UIMLTableRowBuilder(
        Framework::XML::Element* zParentElement, UIMLTableBuilder* zParent)
        : result(new Framework::XML::Element()),
          parentElement(zParentElement),
          parent(zParent)
    {
        result->setName("tr");
    }

    ~UIMLTableRowBuilder()
    {
        if (result)
        {
            result->release();
        }
    }

    UIMLTableRowBuilder* setID(const char* id)
    {
        result->setAttribute("id", id);
        return this;
    }

    UIMLTableRowBuilder* addCell(Framework::XML::Element* cell)
    {
        result->addChild(cell);
        return this;
    }

    UIMLTableBuilder* build()
    {
        parentElement->addChild(result);
        result = 0;
        delete this;
        return parent;
    }
};

class UIMLTableBuilder : public UIMLElementBuilder<UIMLTableBuilder>
{
public:
    UIMLTableBuilder()
        : UIMLElementBuilder()
    {
        result->setName("table");
    }

    UIMLTableRowBuilder* addRow()
    {
        return new UIMLTableRowBuilder(result, this);
    }

    UIMLTableBuilder* setStyle(__int64 style)
    {
        result->setAttribute("style", Framework::Text() += style);
        return this;
    }

    UIMLTableBuilder* setLineHeight(int height)
    {
        result->setAttribute("line-height", Framework::Text() += height);
        return this;
    }
};

class UIMLContainerBuilder : public UIMLElementBuilder<UIMLContainerBuilder>
{
public:
    UIMLContainerBuilder()
        : UIMLElementBuilder()
    {
        result->setName("frame");
    }

    UIMLContainerBuilder* addChild(Framework::XML::Element* child)
    {
        result->addChild(child);
        return this;
    }

    UIMLContainerBuilder* setStyle(__int64 style)
    {
        result->setAttribute("style", Framework::Text() += style);
        return this;
    }

    UIMLContainerBuilder* setTitle(const char* title)
    {
        result->setAttribute("title", title);
        return this;
    }

    UIMLContainerBuilder* setTitleHeight(int height)
    {
        result->setAttribute("title-height", Framework::Text() += height);
        return this;
    }

    UIMLContainerBuilder* setTitleFontSize(int size)
    {
        result->setAttribute("title-font-size", Framework::Text() += size);
        return this;
    }

    UIMLContainerBuilder* setTitleTextColor(int color)
    {
        Framework::Text value("0x");
        value.appendHex(color);
        result->setAttribute("title-text-color", value);
        return this;
    }

    UIMLContainerBuilder* setWidthAuto()
    {
        result->setAttribute("width", "auto");
        return this;
    }

    UIMLContainerBuilder* setHeightAuto()
    {
        result->setAttribute("height", "auto");
        return this;
    }

    UIMLContainerBuilder* setDisplayAsColumn(int gapPercentage, int gapPixel)
    {
        Framework::Text value;
        calculate(gapPercentage, gapPixel, value);
        result->setAttribute("gap", value);
        result->setAttribute("display", "column");
        return this;
    }

    UIMLContainerBuilder* setDisplayAsRow(int gapPercentage, int gapPixel)
    {
        Framework::Text value;
        calculate(gapPercentage, gapPixel, value);
        result->setAttribute("gap", value);
        result->setAttribute("display", "row");
        return this;
    }

    UIMLContainerBuilder* enableVerticalScrollbar()
    {
        this->result->setAttribute("vScroll", "auto");
        return this;
    }

    UIMLContainerBuilder* enableHorizontalScrollbar()
    {
        this->result->setAttribute("hScroll", "auto");
        return this;
    }
};

class UIMLListSelectionBuilder
    : public UIMLElementBuilder<UIMLListSelectionBuilder>
{
public:
    UIMLListSelectionBuilder()
        : UIMLElementBuilder()
    {
        result->setName("listView");
    }

    UIMLListSelectionBuilder* addItem(
        const char* id, const char* text, bool selected)
    {
        Framework::XML::Element* item = new Framework::XML::Element();
        item->setName("listItem");
        item->setAttribute("id", id);
        item->setText(text);
        if (selected)
        {
            item->setAttribute("selected", "");
        }
        result->addChild(item);
        return this;
    }

    UIMLListSelectionBuilder* setOnSelectNotification(
        const char* targetDialogName, char messageID)
    {
        Framework::Text value;
        value += targetDialogName;
        value += ";";
        value += (int)messageID;
        result->setAttribute("onSelectMessage", value);
        return this;
    }

    UIMLListSelectionBuilder* setItemHeight(int height)
    {
        result->setAttribute("member-height", Framework::Text() += height);
        return this;
    }
};

class UIMLCraftingGridBuilder
    : public UIMLElementBuilder<UIMLCraftingGridBuilder>
{
public:
    UIMLCraftingGridBuilder()
        : UIMLElementBuilder()
    {
        result->setName("craftingGrid");
    }

    UIMLCraftingGridBuilder* setRows(int rows)
    {
        result->setAttribute("rowSize", Framework::Text() += rows);
        return this;
    }

    UIMLCraftingGridBuilder* setColumns(int columns)
    {
        result->setAttribute("colSize", Framework::Text() += columns);
        return this;
    }

    UIMLCraftingGridBuilder* setOutputSize(int slotSize)
    {
        result->setAttribute("numOutputSlots", Framework::Text() += slotSize);
        return this;
    }

    UIMLCraftingGridBuilder* setEntitySource(int entityId)
    {
        result->setAttribute("target", Framework::Text() += entityId);
        return this;
    }

    UIMLCraftingGridBuilder* setBlockSource(
        int dimensionId, int x, int y, int z)
    {
        Framework::Text value;
        value.append() << dimensionId << "," << x << "," << y << "," << z;
        result->setAttribute("target", value);
        return this;
    }

    UIMLCraftingGridBuilder* setBlockSource(
        int dimensionId, int x, int y, int z, int componentIndex)
    {
        Framework::Text value;
        value.append() << dimensionId << "," << x << "," << y << "," << z << ":"
                       << componentIndex;
        result->setAttribute("target", value);
        return this;
    }
};

class UIMLInventoryBuilder : public UIMLElementBuilder<UIMLInventoryBuilder>
{
public:
    UIMLInventoryBuilder()
        : UIMLElementBuilder()
    {
        result->setName("inventory");
    }

    UIMLInventoryBuilder* setEntitySource(int entityId)
    {
        result->setAttribute("target", Framework::Text() += entityId);
        return this;
    }

    UIMLInventoryBuilder* setBlockSource(int dimensionId, int x, int y, int z)
    {
        Framework::Text value;
        value.append() << dimensionId << "," << x << "," << y << "," << z;
        result->setAttribute("target", value);
        return this;
    }

    UIMLInventoryBuilder* setRowSize(int rowSize)
    {
        result->setAttribute("rowSize", Framework::Text() += rowSize);
        return this;
    }

    UIMLInventoryBuilder* setSlotNameFilter(const char* filter)
    {
        result->setAttribute("slotNameFilter", filter);
        return this;
    }

    UIMLInventoryBuilder* setSlotCount(int count)
    {
        result->setAttribute("numSlots", Framework::Text() += count);
        return this;
    }
};

class UIMLCraftingProgressBuilder
    : public UIMLElementBuilder<UIMLCraftingProgressBuilder>
{
public:
    UIMLCraftingProgressBuilder()
        : UIMLElementBuilder()
    {
        result->setName("craftingProgress");
    }

    UIMLCraftingProgressBuilder* setTargetBlock(
        int dimensionId, int x, int y, int z, int componentIndex)
    {
        Framework::Text value;
        value.append() << dimensionId << "," << x << "," << y << "," << z << ":"
                       << componentIndex;
        result->setAttribute("target", value);
        return this;
    }

    UIMLCraftingProgressBuilder* setBackgroundImage(const char* imagePath)
    {
        result->setAttribute("backgroundImagePath", imagePath);
        return this;
    }

    UIMLCraftingProgressBuilder* setForegroundImage(const char* imagePath)
    {
        result->setAttribute("foregroundImagePath", imagePath);
        return this;
    }

    UIMLCraftingProgressBuilder* setDirectionTOP()
    {
        result->setAttribute("direction", "TOP");
        return this;
    }

    UIMLCraftingProgressBuilder* setDirectionBOTTOM()
    {
        result->setAttribute("direction", "BOTTOM");
        return this;
    }

    UIMLCraftingProgressBuilder* setDirectionLEFT()
    {
        result->setAttribute("direction", "LEFT");
        return this;
    }
};

class UIMLFuelStateBuilder : public UIMLElementBuilder<UIMLFuelStateBuilder>
{
public:
    UIMLFuelStateBuilder()
        : UIMLElementBuilder()
    {
        result->setName("fuelState");
    }

    UIMLFuelStateBuilder* setTargetBlock(
        int dimensionId, int x, int y, int z, int componentIndex)
    {
        Framework::Text value;
        value.append() << dimensionId << "," << x << "," << y << "," << z << ":"
                       << componentIndex;
        result->setAttribute("target", value);
        return this;
    }

    UIMLFuelStateBuilder* setBackgroundImage(const char* imagePath)
    {
        result->setAttribute("backgroundImagePath", imagePath);
        return this;
    }

    UIMLFuelStateBuilder* setForegroundImage(const char* imagePath)
    {
        result->setAttribute("foregroundImagePath", imagePath);
        return this;
    }

    UIMLFuelStateBuilder* setDirectionTOP()
    {
        result->setAttribute("direction", "TOP");
        return this;
    }

    UIMLFuelStateBuilder* setDirectionBOTTOM()
    {
        result->setAttribute("direction", "BOTTOM");
        return this;
    }

    UIMLFuelStateBuilder* setDirectionLEFT()
    {
        result->setAttribute("direction", "LEFT");
        return this;
    }
};

class UIMLItemBarBuilder : public UIMLElementBuilder<UIMLItemBarBuilder>
{
public:
    UIMLItemBarBuilder()
        : UIMLElementBuilder()
    {
        result->setName("itemBar");
    }

    UIMLItemBarBuilder* setEntitySource(int entityId)
    {
        result->setAttribute("target", Framework::Text() += entityId);
        return this;
    }

    UIMLItemBarBuilder* setRowSize(int rowSize)
    {
        result->setAttribute("rowSize", Framework::Text() += rowSize);
        return this;
    }

    UIMLItemBarBuilder* setSlotNameFilter(const char* filter)
    {
        result->setAttribute("slotNameFilter", filter);
        return this;
    }
};

class UIMLStatusBarsBuilder : public UIMLElementBuilder<UIMLStatusBarsBuilder>
{
public:
    UIMLStatusBarsBuilder()
        : UIMLElementBuilder()
    {
        result->setName("statusBars");
    }

    UIMLStatusBarsBuilder* setEntitySource(int entityId)
    {
        result->setAttribute("target", Framework::Text() += entityId);
        return this;
    }
};

class UIMLTooltipBuilder : public UIMLElementBuilder<UIMLTooltipBuilder>
{
public:
    UIMLTooltipBuilder()
        : UIMLElementBuilder()
    {
        result->setName("tip");
    }

    UIMLTooltipBuilder* addElement(Framework::XML::Element* element)
    {
        result->addChild(element);
        return this;
    }
};

class UIMLItemStackBuilder : public UIMLElementBuilder<UIMLItemStackBuilder>
{
public:
    UIMLItemStackBuilder()
        : UIMLElementBuilder()
    {
        result->setName("itemStack");
    }

    UIMLItemStackBuilder* setItemTypeID(int itemTypeId)
    {
        result->setAttribute("type", Framework::Text() += itemTypeId);
        return this;
    }

    UIMLItemStackBuilder* setAmount(int amount)
    {
        result->setAttribute("count", Framework::Text() += amount);
        return this;
    }

    UIMLItemStackBuilder* setQuantity(int quantity)
    {
        result->setAttribute("quantity", Framework::Text() += quantity);
        return this;
    }

    UIMLItemStackBuilder* setToolTip(UIMLTooltipBuilder* builder)
    {
        result->addChild(builder->build());
        return this;
    }
};

class UIMLQuestNodeBuilder : public UIMLElementBuilder<UIMLQuestNodeBuilder>
{
public:
    UIMLQuestNodeBuilder()
        : UIMLElementBuilder()
    {
        result->setName("questGraphItem");
    }

    UIMLQuestNodeBuilder* setQuestName(const char* name)
    {
        result->setAttribute("name", name);
        return this;
    }

    UIMLQuestNodeBuilder* setDescription(const char* description)
    {
        result->setAttribute("description", description);
        return this;
    }

    UIMLQuestNodeBuilder* setImagePath(const char* imagePath)
    {
        result->setAttribute("image", imagePath);
        return this;
    }

    UIMLQuestNodeBuilder* setFinished(bool finished)
    {
        result->setAttribute("finished", finished ? "1" : 0);
        return this;
    }

    UIMLQuestNodeBuilder* setRewarded(bool rewarded)
    {
        result->setAttribute("rewarded", rewarded ? "1" : "0");
        return this;
    }

    UIMLQuestNodeBuilder* setMainQuest(bool mainQuest)
    {
        result->setAttribute("mainQuest", mainQuest ? "1" : "0");
        return this;
    }

    UIMLQuestNodeBuilder* setRequirements(const char* requirements)
    {
        result->setAttribute("requirements", requirements);
        return this;
    }
};

class UIMLQuestGraphBuilder : public UIMLElementBuilder<UIMLQuestGraphBuilder>
{
public:
    UIMLQuestGraphBuilder()
        : UIMLElementBuilder()
    {
        result->setName("questGraph");
    }

    UIMLQuestGraphBuilder* setCollectionName(const char* collectionName)
    {
        result->setAttribute("collectionName", collectionName);
        return this;
    }

    UIMLQuestGraphBuilder* addQuestNode(UIMLQuestNodeBuilder* questNode)
    {
        result->addChild(questNode->build());
    }
};

class UIMLCraftingRecipiesBuilder
    : public UIMLElementBuilder<UIMLCraftingRecipiesBuilder>
{
public:
    UIMLCraftingRecipiesBuilder()
        : UIMLElementBuilder()
    {
        result->setName("craftingRecipies");
    }

    UIMLCraftingRecipiesBuilder* addRecipieGroup(const char* groupName,
        const char* iconItemType,
        const Framework::RCArray<Recipie>& recipies)
    {
        Framework::XML::Element* groupElement = new Framework::XML::Element();
        groupElement->setName("craftingRecipieGroup");
        groupElement->setAttribute("name", groupName);
        groupElement->setAttribute("iconItemType", iconItemType);
        for (const Recipie* recipie : recipies)
        {
            groupElement->addChild(recipie->getRecipieUIML());
        }
        result->addChild(groupElement);
        return this;
    }
};

class UIMLItemFilterBuilder
{
private:
    Framework::XML::Element* result;

protected:
    UIMLItemFilterBuilder(Framework::XML::Element* result)
        : result(result) {};

public:
    ~UIMLItemFilterBuilder()
    {
        if (result)
        {
            result->release();
        }
    }

    Framework::XML::Element* build()
    {
        Framework::XML::Element* r = result;
        result = 0;
        delete this;
        return r;
    }

    friend class UIMLItemAttributeFilterBuilder;
    friend class UIMLAnyItemFilterBuilder;
    friend class UIMLOperatorItemFilterBuilder;
};

class UIMLItemAttributeFilterBuilder
{
private:
    Framework::XML::Element* result;

public:
    UIMLItemAttributeFilterBuilder()
        : result(new Framework::XML::Element())
    {
        result->setName("attribute");
    }

    ~UIMLItemAttributeFilterBuilder()
    {
        if (result)
        {
            result->release();
        }
    }

    UIMLItemAttributeFilterBuilder* requireAttributeEquals(
        const char* attributeName, const char* attributeValue)
    {
        result->setAttribute("operator", "=");
        result->setAttribute("name", attributeName);
        result->setAttribute("value", attributeValue);
        return this;
    }

    UIMLItemAttributeFilterBuilder* requireAttributeNotEquals(
        const char* attributeName, const char* attributeValue)
    {
        result->setAttribute("operator", "!=");
        result->setAttribute("name", attributeName);
        result->setAttribute("value", attributeValue);
        return this;
    }

    UIMLItemAttributeFilterBuilder* requireAttributeGreater(
        const char* attributeName, const char* attributeValue)
    {
        result->setAttribute("operator", ">");
        result->setAttribute("name", attributeName);
        result->setAttribute("value", attributeValue);
        return this;
    }

    UIMLItemAttributeFilterBuilder* requireAttributeGreaterOrEquals(
        const char* attributeName, const char* attributeValue)
    {
        result->setAttribute("operator", ">=");
        result->setAttribute("name", attributeName);
        result->setAttribute("value", attributeValue);
        return this;
    }

    UIMLItemAttributeFilterBuilder* requireAttributeLower(
        const char* attributeName, const char* attributeValue)
    {
        result->setAttribute("operator", "<");
        result->setAttribute("name", attributeName);
        result->setAttribute("value", attributeValue);
        return this;
    }

    UIMLItemAttributeFilterBuilder* requireAttributeLowerOrEquals(
        const char* attributeName, const char* attributeValue)
    {
        result->setAttribute("operator", "<=");
        result->setAttribute("name", attributeName);
        result->setAttribute("value", attributeValue);
        return this;
    }

    UIMLItemFilterBuilder* build()
    {
        UIMLItemFilterBuilder* builder = new UIMLItemFilterBuilder(result);
        result = 0;
        delete this;
        return builder;
    }
};

class UIMLAnyItemFilterBuilder
{
private:
    Framework::XML::Element* result;

public:
    UIMLAnyItemFilterBuilder()
        : result(new Framework::XML::Element())
    {
        result->setName("anyItem");
    }

    ~UIMLAnyItemFilterBuilder()
    {
        if (result)
        {
            result->release();
        }
    }

    UIMLItemFilterBuilder* build()
    {
        UIMLItemFilterBuilder* builder = new UIMLItemFilterBuilder(result);
        result = 0;
        delete this;
        return builder;
    }
};

class UIMLOperatorItemFilterBuilder
{
private:
    Framework::XML::Element* result;

public:
    UIMLOperatorItemFilterBuilder()
        : result(new Framework::XML::Element())
    {
        result->setName("operator");
    }

    ~UIMLOperatorItemFilterBuilder()
    {
        if (result)
        {
            result->release();
        }
    }

    UIMLOperatorItemFilterBuilder* setOperator(
        std::function<bool(bool, bool)> operatorFunction)
    {
        result->setAttribute(
            "result_0_0", Framework::Text() += (int)operatorFunction(0, 0));
        result->setAttribute(
            "result_0_1", Framework::Text() += (int)operatorFunction(0, 1));
        result->setAttribute(
            "result_1_0", Framework::Text() += (int)operatorFunction(1, 0));
        result->setAttribute(
            "result_1_1", Framework::Text() += (int)operatorFunction(1, 1));
        return this;
    }

    UIMLOperatorItemFilterBuilder* setOperands(
        UIMLItemFilterBuilder* leftOperand, UIMLItemFilterBuilder* rightOperand)
    {
        result->addChild(leftOperand->build());
        result->addChild(rightOperand->build());
        return this;
    }

    UIMLItemFilterBuilder* build()
    {
        UIMLItemFilterBuilder* builder = new UIMLItemFilterBuilder(result);
        result = 0;
        delete this;
        return builder;
    }
};

class UIMLRecipieIngredientBuilder
    : public UIMLElementBuilder<UIMLRecipieIngredientBuilder>
{
public:
    UIMLRecipieIngredientBuilder()
        : UIMLElementBuilder()
    {
        result->setName("ingredient");
    };

    UIMLRecipieIngredientBuilder* setAmount(int amount)
    {
        result->setAttribute("amount", Framework::Text() += amount);
        return this;
    };

    UIMLRecipieIngredientBuilder* setFilter(UIMLItemFilterBuilder* filter)
    {
        Framework::XML::Element* filterElement = filter->build();
        filterElement->setName("logic");
        filterElement->addChild(filter->build());
        result->addChild(filterElement);
        return this;
    };
};

class UIMLRecipieOutputBuilder
    : public UIMLElementBuilder<UIMLRecipieOutputBuilder>
{
public:
    UIMLRecipieOutputBuilder()
        : UIMLElementBuilder()
    {
        result->setName("output");
    };

    UIMLRecipieOutputBuilder* setItemTypeID(int itemTypeId)
    {
        result->setAttribute("itemType", Framework::Text() += itemTypeId);
        return this;
    };

    UIMLRecipieOutputBuilder* setAmount(int amount)
    {
        result->setAttribute("amount", Framework::Text() += amount);
        return this;
    };

    UIMLRecipieOutputBuilder* setHP(float hp)
    {
        result->setAttribute("hp", Framework::Text() += hp);
        return this;
    };

    UIMLRecipieOutputBuilder* setMaxHP(float hp)
    {
        result->setAttribute("maxHp", Framework::Text() += hp);
        return this;
    };

    UIMLRecipieOutputBuilder* setDurability(float durability)
    {
        result->setAttribute("durability", Framework::Text() += durability);
        return this;
    }

    UIMLRecipieOutputBuilder* setMaxDurability(float durability)
    {
        result->setAttribute("maxDurability", Framework::Text() += durability);
        return this;
    }

    UIMLRecipieOutputBuilder* setToolTip(UIMLTooltipBuilder* tooltip)
    {
        result->addChild(tooltip->build());
        return this;
    }
};

class UIMLShapedRecipieBuilder
    : public UIMLElementBuilder<UIMLShapedRecipieBuilder>
{
private:
    Framework::XML::Element* ingredients;
    Framework::XML::Element* outputs;

public:
    UIMLShapedRecipieBuilder()
        : UIMLElementBuilder(),
          ingredients(0)
    {
        result->setName("recipie");
        result->setAttribute("type", "shaped");
    };

    UIMLShapedRecipieBuilder* setWidth(int width)
    {
        result->setAttribute("width", Framework::Text() += width);
        return this;
    };

    UIMLShapedRecipieBuilder* setHeight(int height)
    {
        result->setAttribute("height", Framework::Text() += height);
        return this;
    };

    UIMLShapedRecipieBuilder* addIngredient(
        UIMLRecipieIngredientBuilder* ingredient)
    {
        if (!ingredients)
        {
            ingredients = new Framework::XML::Element();
            ingredients->setName("ingredients");
            result->addChild(ingredients);
        }
        ingredients->addChild(ingredient->build());
        return this;
    };

    UIMLShapedRecipieBuilder* addOutput(UIMLRecipieOutputBuilder* output)
    {
        if (!outputs)
        {
            outputs = new Framework::XML::Element();
            outputs->setName("outputs");
            result->addChild(outputs);
        }
        outputs->addChild(output->build());
        return this;
    };
};

class UIMLUnshapedRecipieBuilder
    : public UIMLElementBuilder<UIMLUnshapedRecipieBuilder>
{
private:
    Framework::XML::Element* ingredients;
    Framework::XML::Element* outputs;

public:
    UIMLUnshapedRecipieBuilder()
        : UIMLElementBuilder(),
          ingredients(0)
    {
        result->setName("recipie");
        result->setAttribute("type", "unshaped");
    };

    UIMLUnshapedRecipieBuilder* addIngredient(
        UIMLRecipieIngredientBuilder* ingredient)
    {
        if (!ingredients)
        {
            ingredients = new Framework::XML::Element();
            ingredients->setName("ingredients");
            result->addChild(ingredients);
        }
        ingredients->addChild(ingredient->build());
        return this;
    };

    UIMLUnshapedRecipieBuilder* addOutput(UIMLRecipieOutputBuilder* output)
    {
        if (!outputs)
        {
            outputs = new Framework::XML::Element();
            outputs->setName("outputs");
            result->addChild(outputs);
        }
        outputs->addChild(output->build());
        return this;
    };
};

class UIMLDialogBuilder
{
private:
    Framework::XML::Element* result;

public:
    UIMLDialogBuilder(const char* id)
        : result(new Framework::XML::Element())
    {
        result->setAttribute("id", id);
    }

    ~UIMLDialogBuilder()
    {
        if (result)
        {
            result->release();
        }
    }

    UIMLDialogBuilder* setTitle(const char* title)
    {
        result->setAttribute("title", title);
        return this;
    };

    UIMLDialogBuilder* setWidth(int width)
    {
        result->setAttribute("width", Framework::Text() += width);
        return this;
    };

    UIMLDialogBuilder* setHeight(int height)
    {
        result->setAttribute("height", Framework::Text() += height);
        return this;
    };

    UIMLDialogBuilder* addElement(Framework::XML::Element* element)
    {
        result->addChild(element);
        return this;
    };

    Framework::XML::Element* build()
    {
        Framework::XML::Element* r = result;
        result = 0;
        delete this;
        return r;
    }
};

class UIMLBuilder
{
public:
    static UIMLTextBuilder* createText(const char* content)
    {
        return (new UIMLTextBuilder())->setText(content);
    }

    static UIMLTextBuilder* createTextAuto(const char* content)
    {
        return (new UIMLTextBuilder())
            ->setText(content)
            ->setHeightAuto()
            ->setWidthAuto();
    }

    static UIMLTextInputBuilder* createTextInput(const char* content)
    {
        return (new UIMLTextInputBuilder())->setText(content);
    }

    static UIMLTextAreaBuilder* createTextArea(const char* content)
    {
        return new UIMLTextAreaBuilder();
    }

    static UIMLButtonBuilder* createButton(const char* content)
    {
        return (new UIMLButtonBuilder())->setText(content);
    }

    static UIMLCheckboxBuilder* createCheckbox(const char* content)
    {
        return (new UIMLCheckboxBuilder())->setText(content);
    }

    static UIMLTableBuilder* createTable()
    {
        return new UIMLTableBuilder();
    }

    static UIMLContainerBuilder* createContainer()
    {
        return new UIMLContainerBuilder();
    }

    static UIMLListSelectionBuilder* createListSelection()
    {
        return new UIMLListSelectionBuilder();
    }

    static UIMLCraftingGridBuilder* createCraftingGrid()
    {
        return new UIMLCraftingGridBuilder();
    }

    static UIMLInventoryBuilder* createInventory()
    {
        return new UIMLInventoryBuilder();
    }

    static UIMLCraftingProgressBuilder* createCraftingProgress()
    {
        return new UIMLCraftingProgressBuilder();
    }

    static UIMLFuelStateBuilder* createFuelState()
    {
        return new UIMLFuelStateBuilder();
    }

    static UIMLItemBarBuilder* createItemBar()
    {
        return new UIMLItemBarBuilder();
    }

    static UIMLStatusBarsBuilder* createStatusBars()
    {
        return new UIMLStatusBarsBuilder();
    }

    static UIMLItemStackBuilder* createItemStack()
    {
        return new UIMLItemStackBuilder();
    }

    static UIMLTooltipBuilder* createTooltip()
    {
        return new UIMLTooltipBuilder();
    }

    static UIMLQuestGraphBuilder* createQuestGraph()
    {
        return new UIMLQuestGraphBuilder();
    }

    static UIMLQuestNodeBuilder* createQuestNode()
    {
        return new UIMLQuestNodeBuilder();
    }

    static UIMLCraftingRecipiesBuilder* createCraftingRecipies()
    {
        return new UIMLCraftingRecipiesBuilder();
    }

    static UIMLItemAttributeFilterBuilder* createItemAttributeFilter()
    {
        return new UIMLItemAttributeFilterBuilder();
    }

    static UIMLAnyItemFilterBuilder* createAnyItemFilter()
    {
        return new UIMLAnyItemFilterBuilder();
    }

    static UIMLOperatorItemFilterBuilder* createOperatorItemFilter()
    {
        return new UIMLOperatorItemFilterBuilder();
    }

    static UIMLRecipieIngredientBuilder* createRecipieIngredient()
    {
        return new UIMLRecipieIngredientBuilder();
    }

    static UIMLRecipieOutputBuilder* createRecipieOutput()
    {
        return new UIMLRecipieOutputBuilder();
    }

    static UIMLShapedRecipieBuilder* createShapedRecipie()
    {
        return new UIMLShapedRecipieBuilder();
    }

    static UIMLUnshapedRecipieBuilder* createUnshapedRecipie()
    {
        return new UIMLUnshapedRecipieBuilder();
    }

    static UIMLDialogBuilder* createDialog(const char* id)
    {
        return new UIMLDialogBuilder(id);
    }
};