vgfx-util.h

Go to the documentation of this file.

/*
 * vgfx-util.h
 *
 * Copyright 2007 (C)  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.
 *
 *
 * Helper methods for dealing with VGFX objects.
 * At the moment, these are most useful for copy/paste/drag/drop operations.
 */

#ifndef WAVEPACKET_VGFX_UTIL_H__
#define WAVEPACKET_VGFX_UTIL_H__

// includes --------------------------------------------------------------------
#include "vgfx.h"

#include "graph/dag.h"


/// \ingroup vgfx
/*@{*/


namespace vgfx {


/// NodeChecker -- base class that can be used for walk validation
///     see the bottom of this file for some useful validators
class NodeChecker {
public:
        virtual ~NodeChecker(void) throw();
        virtual bool checkNode(IN visit_result_t& vr) { return false; }
        bool operator()(IN visit_result_t& vr) { return this->checkNode(vr); }
};



/// getDragDropRootNodeID() - returns the id of the root node used for all
///     drag/drop/copy/paste operations
const char * getDragDropRootNodeID(void) throw();

/// getDragRequest() - given root object in map, and selection of tag_paths,
///     return a drag/drop request (all selected objects attached to the
///     known drag/drop root node id)
void getDragRequest(IN ObjectMap * map,
                                IN Primitive * root,
                                IN const SetString& selection,
                                IN float x_cm,
                                IN float y_cm,
                                OUT std::string& request);

/// getDropRequest() - given a drag_request that has been dropped at (x_cm, y_cm)
///     on a given root in a given map, return a request that adds all of the
///     dropped objects to the correct position in the root.
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);


/// getSelectionRect() - given a set of selected objects, return bounding rect
void getSelectionRect(IN ObjectMap * map,
                                IN Primitive * root,
                                IN const SetString& selection,  // tag_paths
                                OUT rect_t& r_cm);


/// addDependenciesToGraph(map, id, dag) - given a top-level object (id) in a
///     map, run through and find all dependencies of the object.
void addDependenciesToGraph(IN ObjectMap * map,
                                IN const char * id,
                                IO graph::DAG * dag);

/// hit_result_t -- returned from hit detection
struct hit_result_t {
        hit_result_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        p = NULL;
                        tag_path = "";
                        T.setIdentity();
                }

        // data fields
        Primitive      *p;
        std::string     tag_path;
        xform_2d_t      T;              // object local --> global coordinates
        float           x;              // object-local x-value
        float           y;              // object-local y-value
};

bool getObjectAt(IN Primitive * root,
                                IN float x_cm,
                                IN float y_cm,
                                IN NodeChecker& checker,
                                OUT hit_result_t& hr);



struct meta_check_t {
        meta_check_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        exists = false;
                        value.clear();
                }

        operator bool(void) const throw() { return exists; }
        const char * c_str(void) const throw() { return value.c_str(); }

        // data fields
        std::string             value;
        bool                    exists;
};

meta_check_t getMeta(IN Primitive * p, IN const char * name);
std::string getOptionalMeta(IN Primitive * p,
                                IN const char * name,
                                IN const char * default_value);

////////////////////////////////////////////////////////////////////////////////
//
//      validators (derived from NodeChecker)
//
////////////////////////////////////////////////////////////////////////////////

class MetaKeyValueChecker : public NodeChecker {
public:
        ~MetaKeyValueChecker(void) throw();
        MetaKeyValueChecker(IN const char * key, IN const char * value);
        bool checkNode(IN visit_result_t& vr);
private:
        std::string             m_key;
        std::string             m_value;
};


};      // vgfx namespace

#endif  // WAVEPACKET_VGFX_UTIL_H__