VuoUiThemeGroup.cc

Go to the documentation of this file.

 
#include "VuoUiThemeBase.hh"
 
#include "type.h"
 
extern "C" {
#include "VuoList_VuoUiTheme.h"
}
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "UI Theme Group",
                 });
#endif
 
class VuoUiThemeGroup : public VuoUiThemeBase
{
private:
    VuoList_VuoUiTheme elements;
 
public:
    static std::string type; 
 
    static VuoSerializable *makeFromJson(json_object *js)
    {
        return new VuoUiThemeGroup(VuoJson_getObjectValue(VuoList_VuoUiTheme, js, "elements", NULL));
    }
 
    VuoUiThemeGroup(VuoList_VuoUiTheme _elements)
    {
        elements = _elements;
        VuoRetain(elements);
    }
    ~VuoUiThemeGroup()
    {
        VuoRelease(elements);
    }
 
    json_object *getJson()
    {
        json_object *json = VuoSerializable::getJson();
        json_object_object_add(json, "elements", VuoList_VuoUiTheme_getJson(elements));
        return json;
    }
 
    char *getSummary()
    {
        return strdup("Widget Theme Group");
    }
 
    bool operator==(const VuoSerializable &that)
    {
        VuoSerializableEquals(VuoUiThemeGroup);
        return VuoList_VuoUiTheme_areEqual(elements, thatSpecialized->elements);
    }
 
    bool operator<(const VuoSerializable &that)
    {
        VuoSerializableLessThan(VuoUiThemeGroup);
        VuoType_returnInequality(VuoList_VuoUiTheme, elements, thatSpecialized->elements);
        return false;
    }
 
    VuoUiThemeBase *findElement(std::string typeToFind)
    {
        size_t typeToFindLength = typeToFind.length();
        unsigned long elementCount = VuoListGetCount_VuoUiTheme(elements);
        for (unsigned long i = 1; i <= elementCount; ++i)
        {
            VuoUiTheme item = VuoListGetValue_VuoUiTheme(elements, i);
            VuoUiThemeBase *base = (VuoUiThemeBase *)item;
            if (base && base->getType().compare(0, typeToFindLength, typeToFind) == 0)
                return base;
        }
 
        return NULL;
    }
};
 
VuoSerializableRegister(VuoUiThemeGroup);   
 
VuoUiTheme VuoUiTheme_makeGroup(VuoList_VuoUiTheme elements)
{
    return reinterpret_cast<VuoUiTheme>(new VuoUiThemeGroup(elements));
}
 
VuoUiThemeBase *VuoUiTheme_getSpecificTheme(VuoUiTheme theme, std::string type)
{
    if (theme)
    {
        VuoUiThemeBase *base = (VuoUiThemeBase *)theme;
 
        if (base->getType().compare(0, type.length(), type) == 0)
            return base;
 
        VuoUiThemeGroup *group = dynamic_cast<VuoUiThemeGroup *>(base);
        if (group)
        {
            VuoUiThemeBase *found = group->findElement(type);
            if (found)
                return found;
        }
    }
 
    // `theme` is neither the specified type nor a group that contains the specified type, make a new instance with default settings.
    json_object *js = json_object_new_object();
    std::string roundedType = type + "Rounded";
    json_object_object_add(js, "type", json_object_new_string(roundedType.c_str()));
    VuoUiThemeBase *rounded = (VuoUiThemeBase *)VuoUiTheme_makeFromJson(js);
    json_object_put(js);
    return rounded;
}