vgfx.cpp

Go to the documentation of this file.

/*
 * vgfx.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 vector graphics API (see vgfx.h).
 * This contains the core routines, with separate files for
 * specific primitives.
 */

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

#include "common/wave_ex.h"

#include "util/parsing.h"



namespace vgfx {


// virtual destructor implementation
Drawer::~Drawer(void) throw() { }

Primitive::Primitive(void) throw() : m_refcount(0) { }
Primitive::~Primitive(void) throw() { }



////////////////////////////////////////////////////////////////////////////////
//
//      Primitive -- default implementation of vgfx::Primitive methods
//
////////////////////////////////////////////////////////////////////////////////

const char *
Primitive::getID(void)
const
throw()
{
        return m_id.c_str();
}



void
Primitive::setID
(
IN const char * id
)
{
        ASSERT(id, "null id in Primitive::setID()");
        m_id = id;
}



void
Primitive::listContainers
(
IN const VecString& path,
OUT VecString& ids
)
const
{
        WAVE_EX(wex);
        wex << "Objects of type " << this->getType();
        wex << " do not support listContainers() calls.";
}


bool
Primitive::doesContainerExist
(
IN const VecString& path
)
const
{
        return false;
}



bool
Primitive::canCreateContainer
(
IN const VecString& path
)
const
{
        return false;
}



void
Primitive::removeContainer
(
IN const VecString& path
)
{
        WAVE_EX(wex);
        wex << "Primitives of type '" << this->getType() << "' do not support ";
        wex << "removeContainer() calls.";
}



void
Primitive::getContainerDictionary
(
IN const VecString& path,
OUT dictionary_t& data
)
const
{
        WAVE_EX(wex);
        wex << "Primitives of type '" << this->getType() << "' do not support ";
        wex << "getContainerDictionary() calls.";
}



void
Primitive::setContainerDictionary
(
IN const VecString& path,
IN const dictionary_t& data
)
{
        WAVE_EX(wex);
        wex << "Primitives of type '" << this->getType() << "' do not support ";
        wex << "getContainerDictionary() calls.";
}



void
Primitive::draw
(
IN Drawer * drawer,
IN const rect_t& r,
IN const xform_2d_t& T
)
{
        ASSERT(drawer, "null drawer");
        // nothing to draw by default
}



bool
Primitive::getPrimitive
(
IN const char * tag_path,
IN const xform_2d_t& T,
OUT visit_result_t& vr
)
{
        ASSERT(tag_path, "null");

        WAVE_EX(wex);
        wex << "primitives of type '" << this->getType() << "' do not support ";
        wex << "getPrimitive() calls.";

        return false;
}



bool
Primitive::visit
(
IN const rect_t& r,
IN const xform_2d_t& T,         // local --> global
IN const char * tag_path,
IN callback_t callback,
IN void * context,
IN eHitDetect hit
)
{
        ASSERT(callback, "Primitive::visit() called with null callback");

        // default implementation -- callback!  We don't care about input rect
        visit_result_t vr;
        vr.p = this;
        vr.tag_path = tag_path;
        vr.T = T;
        return callback(context, vr);
}



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


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

#define CREATE(name)                                                    \
        if ( !strcmp( type, #name ) )                                   \
        {                                                               \
                init_##name##_t init;                                   \
                init_##name##_from_data (data, init);                   \
                return create_##name (init);                            \
        }

smart_ptr<Primitive>
Primitive::create
(
IN const char * type,
IN const dictionary_t& data
)
{
        ASSERT(type, "null primitive type name passed in");

        // DPRINTF("Primitive is of type '%s'...", type);

        // miniscule efficiency wins if these are ordered by expected frequency
        CREATE(line)
        CREATE(quad)
//      CREATE(dxdy)
        CREATE(rect)
        CREATE(bezier)
        CREATE(text)
//      CREATE(point)

        ASSERT(false, "Unrecognized primitive type: '%s'", type);
        return 0;
}



};      // vgfx namespace