vgfx-util.cpp

Go to the documentation of this file.

/*
 * vgfx-util.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 DAG helper routines for vgfx objects.
 * (see vgfx-util.h)
 */

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

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

#include "request.h"


namespace vgfx {

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


// root node for all drag/drop/copy/paste collections
static const char * s_keyTop                    = "collectionRoot";

NodeChecker::~NodeChecker(void) throw() { }


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

static bool
containsSpace
(
IN const char * p
)
throw()
{
        ASSERT(p, "null");

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

        return false;
}



static void
getIdPrefix
(
IN const char * id,
OUT std::string& prefix
)
{
        ASSERT(id, "null");
        prefix.clear();

        const char * p = id;
        while (*p && *p != '_') {
                prefix += *p;
                ++p;
        }
}



void
addDependenciesToGraphInternal
(
IN ObjectMap * map,
IN const char * id,
IO graph::DAG * dag
)
{
        ASSERT(map, "null");
        ASSERT(id, "null");
        ASSERT(dag, "null");

        // look up this object
        Primitive * p = map->findObject(id);
        ASSERT(p, "Object does not exist? '%s'", id);

        if (strcmp("group", p->getType())) {
                return;         // not a group?  stop recursing
        }

        // is this a path?  Self-contained
        VecString path;
        path.push_back("meta");
        path.push_back("vgfxPath");
        if (p->doesContainerExist(path)) {
                dag->addNode(id);
                return;
        }

        // get all subobjects for p
        path.clear();
        path.push_back("object");
        VecString ids;
        p->listContainers(path, ids);

        // loop through all subobjects
        for (VecString::iterator i = ids.begin(); i != ids.end(); ++i) {
                VecString obj_path;
                obj_path.push_back("object");
                obj_path.push_back(*i);

                dictionary_t data;
                p->getContainerDictionary(obj_path, data);

                // get ID
                const char * sub_id = getRequiredValue(data, "id");

                // add to dag
                dag->addEdge(id, sub_id);

                // recurse
                addDependenciesToGraphInternal(map, sub_id, dag);
        }
}



static void
replaceIDs
(
IN ObjectMap * map,
IN std::istream& in,
OUT std::string& request
)
{
        ASSERT(map, "null");
        ASSERT(in.good(), "bad");
        request = "";

        // DPRINTF("parsing input request and replacing IDs...");

        // given an input stream, find all IDs and replace them
        Dictionary old_new;
        old_new[s_keyTop] = s_keyTop;

        // copy data as we parse into a new stream
        std::ostringstream out;

        std::string line, token;

        while (!in.eof()) {
                line = getNextLineFromStream(in, s_line_behavior);

                // look for any IDs in the line
                const char * cursor = line.c_str();
                while (true) {
                        cursor = getNextTokenFromString(cursor, token,
                            eParse_RespectQuotes);
                        if ("" == token) {
                                out << "\n";
                                break;  // end of line
                        }
                        // DPRINTF("  parsed '%s'", token.c_str());

                        if (containsSpace(token.c_str())) {
                                out << "\"" << token << "\"";
                        } else {
                                out << token;
                        }
                        out << " ";
                        if ("set" == token) {
                                // it's a set instruction.  get next token and
                                //      replace the ID
                                cursor = getNextTokenFromString(cursor, token,
                                    eParse_None);
                                if ("" == token)
                                        continue;       // not a real set
                                // extract old ID
                                std::string old_id;
                                const char * p = token.c_str();
                                while (*p && '.' != *p) {
                                        old_id += *p;
                                        ++p;
                                }
                                // DPRINTF("'%s' --> id='%s', remainder = '%s'",
                                //    token.c_str(), old_id.c_str(), p);

                                Dictionary::iterator i = old_new.find(old_id);
                                if (old_new.end() == i) {
                                        WAVE_EX(wex);
                                        wex << "ID not yet encountered in set:";
                                        wex << "'" << old_id << "'";
                                }
                                out << i->second;
                                if (*p) {
                                        out << p;
                                }
                                out << " ";
                                continue;

                        } else if ("id" != token)
                                continue;       // not an "id" tag

                        // it's an ID field!  get the next token (the ID)
                        cursor =
                            getNextTokenFromString(cursor, token, eParse_None);
                        if ("" == token) {
                                WAVE_EX(wex);
                                wex << "malformed drag/drop stream--missing ";
                                wex << "token after id specifier";
                        }
                        // DPRINTF("    Need to replace '%s'", token.c_str());

                        Dictionary::iterator i = old_new.find(token);
                        if (old_new.end() == i) {
                                std::string prefix;
                                getIdPrefix(token.c_str(), prefix);
                                std::string new_id;
                                map->newObjectID(prefix.c_str(), new_id);
                                old_new[token] = new_id;
                                out << new_id;
                        } else {
                                out << i->second;
                        }
                        out << " ";
                }
        }

        // all done
        request = out.str();
}



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

const char *
getDragDropRootNodeID
(
void
)
throw()
{
        return s_keyTop;
}



void
getDragRequest
(
IN ObjectMap * map,
IN Primitive * root,
IN const SetString& selection,
IN float x_cm,
IN float y_cm,
OUT std::string& request
)
{
        perf::Timer timer("vgfx::getDragRequest");
        ASSERT(map, "null");
        ASSERT(root, "null");

        // first, figure out what items we need
        xform_2d_t T;           // identity transform
        smart_ptr<graph::DAG> dag = graph::DAG::create();
        ASSERT(dag, "failed to create directed acyclic graph");
        for (SetString::const_iterator i = selection.begin();
             i != selection.end(); ++i) {
                const char * tag_path = i->c_str();

                visit_result_t vr;
                root->getPrimitive(tag_path, T, vr);
                ASSERT(vr.p, "could not find in folio: '%s'", tag_path);

                addDependenciesToGraph(map, vr.p->getID(), dag);
        }

        // get the list of all the ids we really need
        VecString ids;
        dag->getOrderedNodeList(ids);

        // get a request to add all items
        Request r;
        std::ostream& oss = r.getStream();

        for (VecString::iterator i = ids.begin(); i != ids.end(); ++i) {
                const char * id = i->c_str();

                Primitive * p = map->findObject(id);
                ASSERT(p, "could not find in map: '%s'", id);

                oss << "add ";
                p->persist(oss);
                oss << "\n";
        }

        // create top-level group that has all of the objects
        r.addSimpleGroup(s_keyTop);
        for (SetString::const_iterator i = selection.begin();
             i != selection.end(); ++i) {
                const char * tag_path = i->c_str();

                visit_result_t vr;
                root->getPrimitive(tag_path, T, vr);
                ASSERT(vr.p, "could not find in folio: '%s'", tag_path);
                const char * id = vr.p->getID();

                // map origin from node-local to global
                point_t p(0.0, 0.0);              // node-local origin
                point_t q;                        // global
                vr.T.transformPoint(p, q);

                float dx = q.x - x_cm;
                float dy = q.y - y_cm;

                // DPRINTF("'%s' is at (%5.2f, %5.2f) --> (%5.2f, %5.2f)",
                //      tag_path, q.x, q.y, dx, dy);

                r.addObject(s_keyTop, id, id, dx, dy, 1.0);
        }

        request = r.get();

        // DPRINTF("Drag request:\n%s\n", request.c_str());
}



void
addDependenciesToGraph
(
IN ObjectMap * map,
IN const char * id,
IO graph::DAG * dag
)
{
        // wrap call in a timer that won't be confused by recursion
        perf::Timer timer("vgfx::addDependenciesToGraph");
        addDependenciesToGraphInternal(map, id, dag);
}



bool
getDropRequest
(
IN ObjectMap * map,
IN Primitive * root,
IN const SetString& selection,
IN std::istream& drag_request,
IN float x_cm,
IN float y_cm,
IN NodeChecker& okayToReceiveDrop,
OUT std::string& request,
OUT SetString& out_selection
)
{
        perf::Timer timer("vgfx::getDropRequest");
        ASSERT(map, "null");
        ASSERT(drag_request.good(), "not good");
        request.clear();
        out_selection.clear();

        // replace IDs in incoming request
        std::string swapped;
        replaceIDs(map, drag_request, swapped);
        // DPRINTF("Swapped request:\n%s\n--------", swapped.c_str());

        // create temporary map
        smart_ptr<ObjectMap> workspace = ObjectMap::create();
        ASSERT(workspace, "failed to create temporary vgfx map");

        // drop there
        std::istringstream iss(swapped);
        std::string undo, diagnostic;
        if (!processRequest(workspace, iss, false, undo, diagnostic)) {
                DPRINTF("Failed to add drag request to map");
                DPRINTF("Diagnostic: %s", diagnostic.c_str());
                return false;
        }

        // get root node
        Primitive * drag_root = workspace->findObject(s_keyTop);
        if (!drag_root) {
                DPRINTF("Drag request did not contain root node: '%s'",
                    s_keyTop);
                return false;
        }

        // get ordered list of all objects in map
        smart_ptr<graph::DAG> dag = graph::DAG::create();
        ASSERT(dag, "Failed to create dag");
        addDependenciesToGraph(workspace, s_keyTop, dag);
        VecString ids;
        dag->getOrderedNodeList(ids);
        // DPRINTF("%d objects in drag request", ids.size());

        // create output request to add to current map
        Request r;

        // remove all selected items
        // TODO: actually have separate codepaths for moves vs. drops?
        // What I'm doing here is very general: handles drops or moves.
        // But the move behavior is funky: items on the canvas are deleted,
        //   then added again at the new location with new IDs!
        // At the moment I'm sticking with a single code path.
        for (SetString::const_iterator i = selection.begin();
             i != selection.end(); ++i) {
                const char * tag_path = i->c_str();
                // DPRINTF("removing '%s'...", tag_path);

                // look up the parent
                std::string parent_path;
                GetParentDirectory(tag_path, parent_path);
                xform_2d_t T;   // identity
                vgfx::visit_result_t vr;
                ASSERT(root->getPrimitive(parent_path.c_str(), T, vr),
                    "Parent '%s' does not exist?", parent_path.c_str());
                ASSERT(vr.p, "Should have a primitive now");
                const char * parent_id = vr.p->getID();
                // DPRINTF("  parent_id = '%s'", parent_id);

                // get tag
                const char * tag = GetFilename(tag_path);

                // issue removal request
                std::ostream& out = r.getStream();
                out << "remove " << parent_id << ".object." << tag << "\n";
        }

        // walk through all but root node, add to request
        for (VecString::iterator i = ids.begin(); i != ids.end(); ++i) {
                const char * id = i->c_str();
                if (!strcmp(id, s_keyTop))
                        continue;       // this is the root node--skip

                // look up this object
                Primitive * p = workspace->findObject(id);
                ASSERT(p, "failed to find new id? '%s'", id);

                std::ostream& out = r.getStream();
                out << "add ";
                p->persist(out);
                out << "\n";
        }

        // get children of root node
        VecString path, children;
        path.push_back("object");
        drag_root->listContainers(path, children);

        // for each child, get root-relative coordinates, add delta
        for (VecString::iterator i = children.begin(); i != children.end();
             ++i) {
                const char * tag = i->c_str();

                // get child x,y position from root
                path.clear();
                path.push_back("object");
                path.push_back(tag);
                dictionary_t data;
                drag_root->getContainerDictionary(path, data);
                float x = atof(getRequiredValue(data, "x"));
                float y = atof(getRequiredValue(data, "y"));
                float z = atof(getRequiredValue(data, "z"));
                const char * id = getRequiredValue(data, "id");

                // update for drop position
                x += x_cm;
                y += y_cm;

                // DPRINTF("Looking for receiver for '%s' at (%5.2f, %5.2f)",
                //     tag, x, y);

                // TODO: is there an object here that can receive it?
                hit_result_t wr;
                if (!getObjectAt(root, x, y, okayToReceiveDrop, wr))
                        continue;       // nope, nothing to receive

                // DPRINTF("Found object to receive at '%s'", wr.tag_path.c_str());

                // add to parent
                r.addObject(wr.p->getID(), id, id, wr.x, wr.y, z);

                // create new tag path
                std::string new_tag = wr.tag_path;
                new_tag += "/";
                new_tag += id;
                out_selection.insert(new_tag);
        }

        // have enough children?
        // DPRINTF("%d children being dropped", out_selection.size());
        if (!out_selection.size())
                return false;

        // successful
        request = r.get();
        // DPRINTF("Drop request:\n%s\n", request.c_str());

        return true;
}



void
getSelectionRect
(
IN ObjectMap * map,
IN Primitive * root,
IN const SetString& selection,
OUT rect_t& r_cm
)
{
        ASSERT(map, "null");
        ASSERT(root, "null");
        r_cm.set(0.0, 0.0, 0.0, 0.0);
        if (!selection.size())
                return; // nothing to do!

        // starting transformation
        xform_2d_t T;   // identity

        // loop through and keep expanding rect
        for (SetString::const_iterator i = selection.begin();
             i != selection.end(); ++i) {
                const char * tag_path = i->c_str();

                visit_result_t vr;
                ASSERT(root->getPrimitive(tag_path, T, vr),
                    "Failed to find selected object at '%s'", tag_path);
                ASSERT(vr.p, "null primitive?");
                rect_t r;
                vr.p->getBoundingRect(r);
                rect_t gr;              // bounding rect in global coordinates
                vr.T.transformRect(r, gr);

                if (selection.begin() == i)
                        r_cm = gr;
                else
                        r_cm.inflate(gr);
        }
}



// context struct used for getObjectAt
struct walk_context_t {
        walk_context_t(IN NodeChecker& nc) throw() :
            pwr(NULL),
            checker(nc)
                { }

        // data fields
        hit_result_t *  pwr;
        NodeChecker&    checker;
        float           x;      // global x-value
        float           y;      // global y-value
};



// callback used for getObjectAt
static bool
getObjectAtCallback
(
IN void * context,
IN visit_result_t& vr
)
{
        walk_context_t * pwc = (walk_context_t *) context;
        ASSERT(pwc, "null context");
        ASSERT(pwc->pwr, "null walk result");
        ASSERT(vr.p, "null primitive");
        ASSERT(vr.tag_path, "null tag path");

        // what does the node checker say?
        if (!pwc->checker(vr))
                return true;    // keep looking

        // this is a hit!
        hit_result_t& wr = *(pwc->pwr);
        wr.p = vr.p;
        wr.tag_path = vr.tag_path;
        wr.T = vr.T;

        // get object-relative coordinates
        xform_2d_t Tinv;
        Tinv.setToInverseOf(wr.T);
        point_t q;      // object-relative coordinates
        Tinv.transformPoint(point_t(pwc->x, pwc->y), q);
        wr.x = q.x;
        wr.y = q.y;

        return false;   // stop looking--we hit something
}



bool
getObjectAt
(
IN Primitive * root,
IN float x_cm,
IN float y_cm,
IN NodeChecker& checker,
OUT hit_result_t& wr
)
{
        perf::Timer("vgfx::getObjectAt");
        ASSERT(root, "null root in getObjectAt()");
        wr.clear();

        // set up context
        walk_context_t wc(checker);
        wc.pwr = &wr;
        wc.x = x_cm;
        wc.y = y_cm;

        // set up hit rect
        rect_t r;
        r.set(x_cm, y_cm, x_cm, y_cm);
        r.expand(0.01);

        // identity transform (already working in CM)
        xform_2d_t T;

        // recursive walk
        return !root->visit(r, T, "", getObjectAtCallback, &wc,
            vgfx::eHit_Overlap);
}



////////////////////////////////////////////////////////////////////////////////
//
//      node checkers
//
////////////////////////////////////////////////////////////////////////////////

MetaKeyValueChecker::~MetaKeyValueChecker(void) throw() { }

MetaKeyValueChecker::MetaKeyValueChecker
(
IN const char * key,
IN const char * value
)
{
        ASSERT(key, "null key");
        ASSERT(value, "null value");

        m_key = key;
        m_value = value;
}



bool
MetaKeyValueChecker::checkNode
(
IN visit_result_t& vr
)
{
        ASSERT(vr.p, "null pointer");

        // does the key even exist?
        VecString path;
        path.push_back("meta");
        path.push_back(m_key);
        if (!vr.p->doesContainerExist(path)) {
                // nope, doesn't have this meta key
                return false;
        }

        // key exists.  Does the value match?
        dictionary_t data;
        vr.p->getContainerDictionary(path, data);
        if (m_value != getRequiredValue(data, m_key.c_str())) {
                return false;    // keep looking
        }

        // matches!
        return true;
}



meta_check_t
getMeta
(
IN Primitive * p,
IN const char * name
)
{
        ASSERT(p, "null");
        ASSERT(name, "null");
        validateHashKeyName(name);

        meta_check_t mc;

        VecString path;
        path.push_back("meta");
        path.push_back(name);
        if (!p->doesContainerExist(path)) {
                return mc;      // no such property
        }

        dictionary_t data;
        p->getContainerDictionary(path, data);
        mc.value = getRequiredValue(data, name);
        mc.exists = true;
        return mc;
}



std::string
getOptionalMeta
(
IN Primitive * p,
IN const char * name,
IN const char * default_value
)
{
        ASSERT(p, "null");
        ASSERT(name, "null");
        ASSERT(default_value, "null");

        meta_check_t mc = getMeta(p, name);
        if (!mc.exists)
                return default_value;
        return mc.value;
}



};      // vgfx namespace