function.cpp

Go to the documentation of this file.

/*
 * function.cpp
 *
 * Copyright (C) 2007,2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of vgfx functions (see vgfx.h function API)
 */

// includes --------------------------------------------------------------------
#include "vgfx.h"               // always include our own header first!

#include <fstream>

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "util/file.h"
#include "util/parsing.h"
#include "util/token_stream.h"


namespace vgfx {

static const eParseBehavior s_line_behavior = (eParseBehavior) (
        eParse_StripComments |
        eParse_StripBogus |
        eParse_RespectQuotes
        );


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static bool
requiresQuotes
(
IN const char * p
)
throw()
{
        ASSERT(p, "null string passed to requiresQuotes()");

        if (!*p)
                return true;    // empty string

        while (*p) {
                if (isspace(*p))
                        return true;
                ++p;
        }

        return false;
}



static void
getFunctionValue
(
IN ObjectMap * map,
const char * fn_name,
OUT std::string& value
)
{
        ASSERT(map, "null object map");
        ASSERT(fn_name, "null function name");

        // TODO: support real functions!
        if (!strcmp("_newID()", fn_name)) {
                // okay, get a free ID
                map->newObjectID(NULL, value);
        } else {
                WAVE_EX(wex);
                wex << "Unknown function: '" << fn_name << "'";
        }

}



static bool
isOperation
(
IN const char * s
)
throw()
{
        ASSERT(s, "null string passed in to isOperation()");

        if (!strcmp("-", s) ||
            !strcmp("+", s) ||
            !strcmp("*", s) ||
            !strcmp("/", s))
                return true;
        return false;
}



static float
operate
(
IN float left,
IN char op,
IN float right
)
throw()
{
        switch (op) {
        case '-': return left - right;
        case '+': return left + right;
        case '*': return left * right;
        case '/': return left / right;
        }

        WAVE_EX(wex);
        wex << "Unrecognized operation! '" << op << "'";
        return -1;
}



static void
computeValue
(
IN ObjectMap * map,
IN const char * raw,
IN const dictionary_t& variables,
OUT std::string& computed
);



static void
evaluate
(
IN ObjectMap * map,
IN const dictionary_t& variables,
IN const char * expr,
OUT std::string& result
)
{
        ASSERT(map, "null object map in evaluate()");
        ASSERT(expr, "null expression");

        result.clear();

        // keep parsing expression
        DPRINTF("WARNING: expression parsing is still primitive");

        std::string token;
        float value = 0.0;
        char operation = 0;
        bool have_left = false;
        const char * cursor = expr;
        while (true) {
                cursor = getNextTokenFromString(cursor, token, eParse_None);
                if (!token[0])
                        break;  // no more tokens

                float right = 0.0;
                bool have_right = false;
                if (!isOperation(token.c_str())) {
                        std::string val;
                        computeValue(map, token.c_str(), variables, val);
                        right = atof(val.c_str());
                        // DPRINTF("'%s' --> %5.2f", token, right);
                        have_right = true;
                } else {
                        if (operation) {
                                WAVE_EX(wex);
                                wex << "encountered two operators in a row?  '";
                                wex << operation << "' and '" << token << "'";
                        }
                        operation = token[0];
                }

                // should we evaluate something?
                if (have_right) {
                        if (!have_left) {
                                // this is the first token
                                have_left = true;
                                have_right = false;
                                value = right;
                        } else {
                                // left + right -- operation?
                                if (!operation) {
                                        WAVE_EX(wex);
                                        wex << "Have left and right values, ";
                                        wex << "but no operator between them!";
                                }

                                value = operate(value, operation, right);
                                have_left = true;
                                have_right = false;
                                operation = 0;
                        }
                }
        }

        const int bufsize = 32;
        char buffer[bufsize];
        sprintf(buffer, "%8.6f", value);
        result = buffer;
}



static void
computeValue
(
IN ObjectMap * map,
IN const char * raw,
IN const dictionary_t& variables,
OUT std::string& computed
)
{
        ASSERT(raw, "null raw value");
        computed.clear();

        if ('$' == raw[0]) {
                // variable
//              DPRINTF("looking for variable '%s'...", raw + 1);
                computed = getRequiredValue(variables, raw + 1);
        } else if ('&' == raw[0]) {
                // function call
//              DPRINTF("invoking function '%s'...", raw + 1);
                getFunctionValue(map, raw + 1, computed);
        } else if ('=' == raw[0]) {
//              DPRINTF("attempting to evaluate expression '%s'...", raw + 1);
                evaluate(map, variables, raw + 1, computed);
        } else {
                computed = raw;
        }
}



static float
getFloat
(
IN ObjectMap * map,
IN const dictionary_t& variables,
IN const dictionary_t& data,
IN const char * key,
IN const char * default_value
)
{
        ASSERT(key, "null key name in getFloat()");
        ASSERT(default_value, "null default value in getFloat()");

        const char * value = NULL;
        if (default_value)
                value = getOptionalValue(data, key, default_value);
        else
                value = getRequiredValue(data, key);
        ASSERT(value, "should have value now");

        std::string computed;
        computeValue(map, value, variables, computed);

        return atof(computed.c_str());
}



static void
processTile
(
IN ObjectMap * map,
IN const char * cursor,
IN const dictionary_t& variables,
IO std::ostream& stream
)
{
        ASSERT(map, "null object map in processTile()");
        ASSERT(cursor, "null tile declaration line");
        ASSERT(stream.good(), "bad stream in processTile()");

        dictionary_t data;
        getDictionaryFromString(cursor, "parsing tile declaration line", data);

        // get x/y tiling parameters
        float x_start = getFloat(map, variables, data, "xStart", "0.0");
        float x_inc = getFloat(map, variables, data, "xInc", "0.0");
        float x_end = getFloat(map, variables, data, "xEnd", "0.0");
        if (x_end != x_start && !x_inc) {
                WAVE_EX(wex);
                wex << "Cannot tile in x-direction: missing increment 'xInc'";
        }
        if (x_inc < 0) {
                WAVE_EX(wex);
                wex << "Bad x-increment: " << x_inc;
        }

        float y_start = getFloat(map, variables, data, "yStart", "0.0");
        float y_inc = getFloat(map, variables, data, "yInc", "0.0");
        float y_end = getFloat(map, variables, data, "yEnd", "0.0");
        if (y_end != y_start && !y_inc) {
                WAVE_EX(wex);
                wex << "Cannot tile in y-direction: missing increment 'yInc'";
        }
        if (y_inc < 0) {
                WAVE_EX(wex);
                wex << "Bad y-increment: " << y_inc;
        }

        // okay, tile!
        const char * raw_id = getRequiredValue(data, "id");
        std::string id;
        computeValue(map, raw_id, variables, id);
//      DPRINTF("Looping x from %5.2f to %5.2f with increment %5.2f",
//          x_start, x_end, x_inc);
//      DPRINTF("Looping y from %5.2f to %5.2f with increment %5.2f",
//          y_start, y_end, y_inc);
        float x = x_start;
        while (x <= x_end) {

                float y = y_start;
                while (y <= y_end) {
                        std::string tag_id;
                        map->newObjectID("tag", tag_id);
                        stream << "object tag " << tag_id << " id " << id;
                        stream << " x " << x << " y " << y << "\n";

                        if (!y_inc)
                                break;
                        y += y_inc;
                }

                if (!x_inc)
                        break;
                x += x_inc;
        }
}



static void
processVariable
(
IN ObjectMap * map,
IN const char * cursor,
IN const dictionary_t& in_params,
IN const objtree::property_set_t& pub,
IO dictionary_t& variables
)
{
        ASSERT(map, "null object map in processVariable()");
        ASSERT(cursor, "null variable declaration line");

        dictionary_t data;
        getDictionaryFromString(cursor, "parsing variable declaration line",
            data);

        // must declare a name
        const char * name = getRequiredValue(data, "name");
        if (!objtree::isValidPropertyName(name)) {
                WAVE_EX(wex);
                wex << "Invalid variable name: '" << name << "'";
        }

        const char * value = getValue(in_params, name);
        if (!value) {
                // not passed in -- public?
                value = pub.getValue(name);
                if (!value) {
                        // not passed in or public -- value provided in script?
                        value = getValue(data, "value");
                        if (!value) {
                                WAVE_EX(wex);
                                wex << "variable '" << name << "' has ";
                                wex << "no default value, and no value was ";
                                wex << "passed in by caller.";
                        }
                }
        }
        ASSERT(value, "Should have value for variable '%s'", name);

        // execute value if necessary
        std::string computed;
        computeValue(map, value, variables, computed);

        // set in variable map
        variables[name] = computed;
//      DPRINTF("Added variable '%s' == '%s'", name, computed.c_str());
}



////////////////////////////////////////////////////////////////////////////////
//
//      Function -- class that implements vgfx::Primitive interface for fns
//
////////////////////////////////////////////////////////////////////////////////

class Function : public Primitive {
public:
        ~Function(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN std::istream& stream);
        const VecString& getLines(void) const throw() { return m_lines; }
        const objtree::property_set_t& getPublic(void) const throw()
                                { return m_public; }

        // vgfx::Primitive class interface methods -----------------------------
        const char * getType(void) const throw() { return "function"; }
        void persist(OUT std::ostream& stream) const;
        void listContainers(IN const VecString& path,
                                OUT VecString& ids) const;
        bool doesContainerExist(IN const VecString& path) const;
        bool canCreateContainer(IN const VecString& path) const;
        void removeContainer(IN const VecString& path);
        void getContainerDictionary(IN const VecString& path,
                                OUT dictionary_t& data) const;
        void setContainerDictionary(IN const VecString& path,
                                IN const dictionary_t& data);
        void recalcBoundingRect(IN const char * tag_path,
                                IN Drawer *, IN const xform_2d_t&) { }
        bool getBoundingRect(OUT rect_t& r) const throw() { return false; }
        void draw(IN Drawer * drawer,
                                IN const rect_t& r_cm,
                                IN const xform_2d_t& T) { }

private:
        // private member data -------------------------------------------------
        VecString               m_lines;        // actual function data
        objtree::property_set_t m_public;       // public values
};



void
Function::persist
(
OUT std::ostream& stream
)
const
{
        stream << "function {\n";
        stream << "\tid\t" << this->getID() << "\n";
        for (VecString::const_iterator i = m_lines.begin(); i != m_lines.end();
             ++i) {
                stream << *i << "\n";
        }
        stream << "}\n";
}



void
Function::listContainers
(
IN const VecString& path,
OUT VecString& ids
)
const
{
        ids.clear();
        if (1 != path.size() || path[0] != "public") {
                WAVE_EX(wex);
                wex << "Functions only support path='public' in listContainers()";
        }

        for (objtree::property_set_t::const_iterator i = m_public.begin();
             i != m_public.end(); ++i) {
                ids.push_back(i->first);
        }
}



bool
Function::doesContainerExist
(
IN const VecString& path
)
const
{
        if (2 != path.size())
                return false;

        if ("public" != path[0])
                return false;

        return !m_public.getProperty(path[1].c_str());
}



bool
Function::canCreateContainer
(
IN const VecString& path
)
const
{
        if (2 != path.size())
                return false;
        if ("public" != path[0])
                return false;
        return objtree::isValidPropertyName(path[1].c_str());
}



void
Function::removeContainer
(
IN const VecString& path
)
{
        if (2 != path.size() || "public" != path[0]) {
                WAVE_EX(wex);
                wex << "invalid path in Function::removeContainer()";
        }

        ASSERT(false, "who is removing function public properties?");
}



void
Function::getContainerDictionary
(
IN const VecString& path,
OUT dictionary_t& data
)
const
{
        data.clear();
        if (2 != path.size() || "public" != path[0]) {
                WAVE_EX(wex);
                wex << "invalid path in Function::getContainerDictionary()";
        }

        const char * name = path[1].c_str();
        const objtree::property_t * p = m_public.getProperty(name);
        if (!p) {
                WAVE_EX(wex);
                wex << "Public property '" << name << "' not found in ";
                wex << "function '" << this->getID() << "'";
        }

        for (objtree::property_t::const_iterator i = p->begin(); i != p->end();
             ++i) {
                const char * field = i->first.c_str();
                const char * value = i->second.c_str();

                data[field] = value;
        }
}



void
Function::setContainerDictionary
(
IN const VecString& path,
IN const dictionary_t& data
)
{
        if (2 != path.size() || "public" != path[0]) {
                WAVE_EX(wex);
                wex << "invalid path in Function::setContainerDictionary()";
        }

        ASSERT(false, "Who is changing public parameters of functions?");

/*
        objtree::property_set_t::iterator i = m_public.find(path[1]);
        if (m_public.end() == i) {
                WAVE_EX(wex);
                wex << "Public property '" << path[1] << "' not found in ";
                wex << "function '" << this->getID() << "'";
        }

        objtree::property_t& p = i->second;
        p.type = getOptionalValue(data, "type", p.type.c_str());
        p.value = getOptionalValue(data, "value", p.value.c_str());
*/
}



void
Function::initialize
(
IN std::istream& stream
)
{
        ASSERT(stream.good(), "bad stream passed to Function::create()");

        // keep parsing lines until we hit the closing bracket
        std::string line, token;
        int depth = 0;          // cheesy way to keep track of parse depth
        while (true) {
                line = getNextLineFromStream(stream, s_line_behavior);
                const char * cursor =
                    getNextTokenFromString(line.c_str(), token, eParse_None);
                if ("" == token) {
                        continue;       // empty line
                }

                if ("variable" == token) {
                        // it's a token!
                        dictionary_t data;
                        getDictionaryFromString(cursor, "parsing variable", data);

                        if (!strcmp("true", getOptionalValue(data, "public", "false"))) {
                                objtree::property_t p;
                                const char * name = getRequiredValue(data, "name");

                                for (dictionary_t::iterator i = data.begin();
                                     i != data.end(); ++i) {
                                        const char * field = i->first.c_str();
                                        if (!strcmp("name", field))
                                                continue;       // skip this one
                                        const char * value = i->second.c_str();
                                        p.setFieldValue(field, value);
                                }

                                m_public[name] = p;
                        }
                }

                // are we diving into a subojbect?
                if (strstr(line.c_str(), "{"))
                        ++depth;        // diving into object
                if (strstr(line.c_str(), "}"))
                        --depth;        // popping out of object

                // end of function?
                if (depth < 0) {
                        ASSERT(-1 == depth, "Bad depth: %d", depth);
                        break;          // hit the final closing bracket
                }

                // not an empty line: copy into our buffer

                // only care about global data after this point
                if (depth) {
                        m_lines.push_back(line);        // push, don't process
                        continue;       // not in global parsing
                }

                // is this the ID?
                if ("id" == token) {
                        getNextTokenFromString(cursor, token, eParse_None);
                        this->setID(token.c_str());     // stash ID
                        continue;       // don't store this line
                }

                // store line
                m_lines.push_back(line);
        }

//      DPRINTF("%d lines read for function", m_lines.size());
//      DPRINTF("Function name: '%s'", m_id.c_str());
}



static void
getScriptOutputId
(
IN const char * param_id,
OUT std::string& output_id
)
{
        ASSERT(param_id, "null");

        output_id = param_id;
        output_id += "ScriptOutput";
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Primitive>
parseFunction
(
IN std::istream& stream,
IN ObjectMap * map
)
{
        smart_ptr<Function> local = new Function;
        ASSERT(local, "out of memory");

        local->initialize(stream);

        return local;
}



void
invokeFunction
(
IN Primitive * in_function,
IN ObjectMap * map,
IN const dictionary_t& in_params,
OUT std::ostream& out
)
{
        perf::Timer timer("vgfx::invokeFunction");
        ASSERT(in_function, "null function object");
        ASSERT(map, "null object map");

        if (strcmp("function", in_function->getType())) {
                WAVE_EX(wex);
                wex << "Object '" << in_function->getID() << "' is not a ";
                wex << "function, it is a '" << in_function->getType() << "'";
        }

        Function * function = dynamic_cast<Function *>(in_function);
        ASSERT(function, "this should work!");  

        dictionary_t variables;
        std::string token;

        const VecString& lines = function->getLines();
        for (VecString::const_iterator i = lines.begin(); i != lines.end(); ++i)
        {
                const char * line = i->c_str();
                // DPRINTF("Line: '%s'", line);

                const char * cursor =
                    getNextTokenFromString(line, token, eParse_None);
                if ("" == token) {
                        DPRINTF("Weird: blank line in function???");
                        continue;       // next line
                }

                // special processing for this line?
                if ("variable" == token) {
                        // variable declaration
                        processVariable(map, cursor, in_params,
                            function->getPublic(), variables);
                        continue;       // no more parsing for line
                } else if ("tile" == token) {
                        // tile command
                        processTile(map, cursor, variables, out);
                } else {
                        // just render with search/replace as needed
                        out << token << " ";
                        while (true) {
                                cursor = getNextTokenFromString(cursor, token,
                                    eParse_None);
                                if ("" == token)
                                        break;  // end of line

                                std::string computed;
                                computeValue(map, token.c_str(), variables,
                                    computed);
                                const char * value = computed.c_str();
                                if (requiresQuotes(value)) {
                                        out << "\"" << value << "\" ";
                                } else {
                                        out << value << " ";
                                }
                        }
                        out << "\n";
                }
        }
}



Primitive *
addFunctionFromPath
(
IN ObjectMap * map,
IN const char * path
)
{
        ASSERT(map, "null");
        ASSERT(path, "null");

        // get root filename
        std::string id;
        GetFileRoot(path, id);

        // already have this?  Then don't do anything
        // NOTE (and TODO): I'd love to remove and re-load, but there
        // is a problem: we don't know who else in the map is also
        // using this script.  We'd have to find and clear all references
        // before removing the object.  So for now, if someone is tweaking
        // scripts, they have to reload the app to get an updated script.
        Primitive * p = map->findObject(id.c_str());
        if (p) {
                DPRINTF("Already loaded script with id='%s'", id.c_str());
                return p;
        }

        // need to load it
        std::ifstream infile(path);
        if (!infile.good()) {
                WAVE_EX(wex);
                wex << "Failed to open file for reading: " << path;
        }

        // add to map
        std::string unused, diagnostic;
        if (!processRequest(map, infile, false, unused, diagnostic)) {
                WAVE_EX(wex);
                wex << "Failed to load script: " << diagnostic;
        }

        // verify
        p = map->findObject(id.c_str());
        if (!p) {
                WAVE_EX(wex);
                wex << "Malformed script: function id should match filename: ";
                wex << "'" << id << "'";
        }

        // return
        return p;
}



void
setScript
(
IN ObjectMap * map,
IN const char * parent_id,
IN const char * script_id,
IN const objtree::property_set_t& pset_def,     // defaults (may be empty)
IO std::ostream& stream,
OUT std::string& root
)
{
        perf::Timer timer("vgfx::setScript");
        ASSERT(map, "null");
        ASSERT(parent_id, "null");
        ASSERT(script_id, "null");
        ASSERT(stream.good(), "bad stream?");

        // the setScript() function will create a sub-object of the parent
        // (with the name parent_id_script_root) and a child object of that
        // (named parent_id_script_output) that is the executed contents of
        // the script.  The script_root contains all script parameters as
        // meta keys.

        // construct object IDs
        //   (root = script parameter group, out = script output)
        root = parent_id;       
        root += "ScriptRoot";
        const char * root_id = root.c_str();

        std::string out;
        getScriptOutputId(parent_id, out);
        const char * out_id = out.c_str();

        // if the script output object already exists, delete it
        if (map->findObject(out_id)) {
                stream << "remove " << root_id << ".object.output\n";
                stream << "remove " << out_id << "\n";
        }

        // if the script root object already exists, delete it
        if (map->findObject(root_id)) {
                stream << "remove " << parent_id << ".object.scriptParams\n";
                stream << "remove " << root << "\n";
        }

        // create empty group for script root
        stream << "add group {\n";
        stream << "id " << root_id << "\n";
        stream << "}\n";

        // get the function object
        Primitive * fn = map->findObject(script_id);
        ASSERT(fn, "Need to add function object to map first!  script='%s'",
            script_id);

        // get bounding rect of parent object
        Primitive * p = map->findObject(parent_id);
        ASSERT(p, "Parent does not exist? '%s'", parent_id);
        rect_t r;
        p->getBoundingRect(r);

        // get default parameters
        dictionary_t data;
        data["rootId"] = out_id;
        data["width"] = getStringValue(r.right - r.left);
        data["height"] = getStringValue(r.bottom - r.top);

        // get all public script parameters
        VecString params;
        VecString path;
        path.push_back("public");
        fn->listContainers(path, params);
        for (VecString::const_iterator i = params.begin(); i != params.end();
             ++i) {
                const char * name = i->c_str();
                // DPRINTF("  Adding public parameter '%s'...", name);

                dictionary_t q;
                path.clear();
                path.push_back("public");
                path.push_back(name);
                fn->getContainerDictionary(path, q);

                // add to public dictionary
                // is this in the defaults?
                const char * value = pset_def.getValue(name);
                if (!value) {
                        // not in defaults, use default in script
                        value = getRequiredValue(q, "value");
                }
                data[name] = value;

                // update script parameter group
                stream << "set " << root << ".meta." << name << " " << name;
                stream << " \"" << value << "\"\n";;
        }

        // invoke function to create script output object
        invokeFunction(fn, map, data, stream);

        // add output to script params
        stream << "set " << root << ".meta.parentId parentId ";
        stream << parent_id << "\n";
        stream << "set " << root << ".object.output id " << out << " z -1.0\n";
        stream << "set " << root << ".object.script id " << script_id << "\n";

        // add this to the parent
        stream << "set " << parent_id << ".object.scriptParams id " << root << " z -1.0\n";

        // that's it!
}



void
updateScriptParameters
(
IN ObjectMap * map,
IN const char * parent_id,
IN const objtree::property_set_t& pset,
IO std::ostream& stream
)
{
        perf::Timer timer("vgfx::updateScriptParameters");
        ASSERT(map, "null");
        ASSERT(parent_id, "null");
        ASSERT(stream.good(), "bad stream");

        // we are being asked to update script parameters.  This means
        // re-creating the script output

        // load the parent object (should be the script_params object)
        vgfx::Primitive * params = map->findObject(parent_id);
        ASSERT(params, "should have a valid script parameter object '%s'",
            parent_id);

        // get the parent of the script parameter object
        VecString path;
        path.push_back("meta");
        path.push_back("parentId");
        dictionary_t data;
        params->getContainerDictionary(path, data);
        const char * grandparent_id = getRequiredValue(data, "parentId");
        // DPRINTF("grandparent = '%s'", grandparent_id);
        vgfx::Primitive * gp = map->findObject(grandparent_id);
        ASSERT(gp, "Grandparent does not exist? '%s'", grandparent_id);

        // get bounding rect of grandparent
        rect_t r;
        gp->getBoundingRect(r);

        // what is the id of the script output object?
        std::string output_id;
        getScriptOutputId(grandparent_id, output_id);

        // set standard parameters
        dictionary_t script_params;
        script_params["rootId"] = output_id;
        script_params["width"] = getStringValue(r.right - r.left);
        script_params["height"] = getStringValue(r.bottom - r.top);

        // override standard parameters!
        if (pset.getValue("width"))
                script_params["width"] = pset.getValue("width");
        if (pset.getValue("height"))
                script_params["height"] = pset.getValue("height");

        // get script object
        path.clear();
        path.push_back("object");
        path.push_back("script");
        params->getContainerDictionary(path, data);
        const char * script_id = getRequiredValue(data, "id");
        // DPRINTF("Adjusting parameters for script '%s'", script_id);
        vgfx::Primitive * fn = map->findObject(script_id);
        ASSERT(fn, "No such script object found? '%s'", script_id);

        // get public script parameters
        path.clear();
        path.push_back("public");
        VecString props;
        fn->listContainers(path, props);

        // set based on property set
        for (VecString::const_iterator i = props.begin(); i != props.end();
             ++i) {
                const char * name = i->c_str();
                const char * value = pset.getValue(name);
                ASSERT(value, "Script public parameter '%s' not found in pset?",
                    name);
                // DPRINTF("  Setting public parameter '%s' = '%s'", name, value);

                script_params[name] = value;
        }

        // clear existing script output object
        stream << "remove " << parent_id << ".object.output\n";
        stream << "remove " << output_id << "\n";

        // invoke function to regenerate script output
        invokeFunction(fn, map, script_params, stream);

        // set back to parent
        stream << "set " << parent_id << ".object.output id " << output_id << "\n";
}



void
resizeScript
(
IN ObjectMap * map,
IN const char * parent_id,
IN float width,
IN float height,
IO std::ostream& stream
)
{
        ASSERT(map, "null");
        ASSERT(parent_id, "null");
        ASSERT(width > 0, "bad width: %f", width);
        ASSERT(height > 0, "bad height: %f", height);
        ASSERT(stream.good(), "bad stream");

        // look up parent
        Primitive * parent = map->findObject(parent_id);
        ASSERT(parent, "could not find script parent: '%s'", parent_id);

        // get script object
        const char * tag_path = "script";
        xform_2d_t T;   // identity
        visit_result_t vr;
        parent->getPrimitive(tag_path, T, vr);
        ASSERT(vr.p, "No script child for parent '%s'", parent_id);
        Primitive * script = vr.p;

        // get all required parameters
        VecString path;
        path.push_back("public");
        VecString params;
        script->listContainers(path, params);

        objtree::property_set_t pset;   // we'll populate this

        // pull properties from parent (should be a script_params object)
        for (VecString::iterator i = params.begin(); i != params.end(); ++i) {
                const char * param = i->c_str();
                DPRINTF("Looking for parameter '%s'...", param);

                // get value from parent
                path.clear();
                path.push_back("meta");
                path.push_back(param);

                dictionary_t data;
                parent->getContainerDictionary(path, data);

                // add to property set
                pset[param] =
                    objtree::property_t(getRequiredValue(data, param));
        }

        // add width, height
        pset["width"] = objtree::property_t(getStringValue(width).c_str());
        pset["height"] = objtree::property_t(getStringValue(height).c_str());

        // invoke other helper
        updateScriptParameters(map, parent_id, pset, stream);
}



};      // vgfx namespace