vgfx/request.h

Go to the documentation of this file.

/*
 * request.h
 *
 * Copyright (C) 2007  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.
 *
 *
 * Utility methods for constructing vgfx requests.
 */

#ifndef WAVEPACKET_VGFX_REQUEST_H__
#define WAVEPACKET_VGFX_REQUEST_H__

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

#include <sstream>


namespace vgfx {

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


/// used to easily construct vgfx Requests
///
/// To use, create one of these, add a bunch of stuff, and then call
/// get().  That closes the request and returns a string containing
/// the full request.
///
/// Note that once a request has been closed, you cannot add any more
/// objects to it!  Subsequent addXXX() calls will fail (program crash,
/// since to do so is a programming mistake).
class Request {
public:
        Request(void) : m_closed(false) {
                        m_stream << "request {\n";
                }

        void close(void) {
                        if (!m_closed) {
                                m_stream << "}";
                                m_closed = true;
                        }
                }

        std::string get(void) {
                        this->close();
                        return m_stream.str();
                }

        void addBezier(IN const char * id,
                        IN float x0, IN float ax, IN float bx, IN float cx,
                        IN float y0, IN float ay, IN float by, IN float cy) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "add bezier id " << id;
                        m_stream << " x0 " << x0 << " ax " << ax;
                        m_stream << " bx " << bx << " cx " << cx;
                        m_stream << " y0 " << y0 << " ay " << ay;
                        m_stream << " by " << by << " cy " << cy;
                        m_stream << "\n";
                }

        void addQuadBezier(IN const char * id, IN const point_t& p0,
                                IN const point_t& p1, IN const point_t& p2) {
                        ASSERT(!m_closed, "request is closed");

                        m_stream << "add quad id " << id;
                        m_stream << " x0 " << p0.x << " y0 " << p0.y;
                        m_stream << " x1 " << p1.x << " y1 " << p1.y;
                        m_stream << " x2 " << p2.x << " y2 " << p2.y;
                        m_stream << "\n";
                }

        void addRect(IN const char * id,
                                IN float left, IN float top,
                                IN float right, IN float bottom,
                                IN bool fill) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "add rect id " << id << " left " << left;
                        m_stream << " top " << top;
                        m_stream << " right " << right << " bottom " << bottom;
                        if (fill) {
                                m_stream << " fill true";
                        }
                        m_stream << "\n";
                }

        void addSimpleRect(IN const char * id,
                                IN float width, IN float height, IN bool fill) {
                        this->addRect(id, 0, 0, width, height, fill);
                }

        void addText(IN const char * id, IN const char * text) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "add text id " << id;
                        m_stream << " text \"" << text << "\"\n";
                }

        void addSimpleGroup(IN const char * id) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "add group {\n";
                        m_stream << "\tid\t" << id << "\n";
                        m_stream << "\t}\n";
                }

        void addMeta(IN const char * group_id,
                                IN const char * name,
                                IN const char * value) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "set " << group_id << ".meta." << name;
                        m_stream << "\t" << name << " \"" << value << "\"\n";
                }

        void addObject(IN const char * group_id, IN const char * tag,
                                IN const char * ref,
                                IN float x, IN float y,
                                IN float z, IN float phi = 0.0) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "set " << group_id << ".object." << tag;
                        m_stream << "\ttag " << tag << "\tid " << ref;
                        m_stream << "\tx " << x << "\ty " << y;
                        m_stream << "\tz " << z;
                        m_stream << "\tphi " << phi << "\n";
                }

        void setDictionary(IN const char * path, IN const dictionary_t& data) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "set " << path;
                        for (dictionary_t::const_iterator i = data.begin();
                             i != data.end(); ++i) {
                                m_stream << " " << i->first << " \"";
                                m_stream << i->second << "\"";
                        }
                        m_stream << "\n";
                }

        void removeObject(IN const char * path) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "remove " << path << "\n";
                }

        std::ostream& getStream(void) {
                        ASSERT(!m_closed, "request is closed");
                        return m_stream; 
                }
        
private:
        std::ostringstream      m_stream;
        bool                    m_closed;
};


};      // namespace vgfx


#endif  // WAVEPACKET_VGFX_REQUEST_H__