drawer.cpp

Go to the documentation of this file.

/*
 * drawer.cpp
 *
 * Copyright (C) 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.
 *
 *
 * Dumb drawer that just writes to ASCII strings.  Helpful for testing.
 */

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

#include "common/wave_ex.h"


namespace dialog {

/// \ingroup dialog
/*@{*/


// Drawer interface destructor
Drawer::~Drawer(void) throw() { }
TextDrawer::~TextDrawer(void) throw() { }


static const int s_maxText              = 147;
static const int s_maxDim               = s_maxText + 1;


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


////////////////////////////////////////////////////////////////////////////////
//
//      TDI -- class that implements the TextDrawer interface
//
////////////////////////////////////////////////////////////////////////////////

class TDI : public TextDrawer {
public:
        ~TDI(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN int borderSize) throw();

        // dialog::Drawer class interface methods ------------------------------
        font_size_t getFontSizing(IN eElementType type,
                                IN const char * text) {
                        font_size_t fs;
                        fs.lead = 0;
                        fs.trail = strlen(text);
                        fs.rise = 1;
                        fs.drop = 0;
                        return fs;
                }

        border_size_t getBorderSizing(IN eElementType type) {
                        border_size_t bs;
                        bs.size = m_borderSize;
                        return bs;
                }

        void drawString(IN eElementType type,
                                IN const point_t& pos,
                                IN const char * text);

        void drawRectWithBorder(IN eElementType type,
                                IN const rect_t& r);

        void drawCircle(IN const point_t& pos,
                                IN float radius) { /* not implemented! */ };

        // dialog::TextDrawer class interface methods --------------------------
        void writeToStream(IO std::ostream& stream);

private:
        // private helper methods ----------------------------------------------
        struct row_t {
                char            text[s_maxDim];
        };

        void markUsed(IN int iRow) throw() {
                        ASSERT(iRow >= 0 && iRow < s_maxDim,
                            "Bad row index: %d", iRow);
                        row_t& r = m_rows[iRow];
                        if (!r.text[0]) {
                                r.text[0] = ' ';
                        }
                }

        // private member data -------------------------------------------------
        row_t           m_rows[s_maxDim];
        int             m_borderSize;
};



void
TDI::initialize
(
IN int borderSize
)
throw()
{
        ASSERT2(borderSize > 0, "Bad border size: " << borderSize);

        m_borderSize = borderSize;
        for (int y = 0; y < s_maxDim; ++y) {
                row_t& r = m_rows[y];

                r.text[0] = 0;          // flag as unused
                for (int x = 1; x < s_maxText; ++x) {
                        r.text[x] = ' ';
                }
                r.text[s_maxText] = 0;  // null-terminate
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      TDI -- dialog::Drawer and dialog::TextDrawer class interface methods
//
////////////////////////////////////////////////////////////////////////////////


void
TDI::drawString
(
IN eElementType type,
IN const point_t& pos,
IN const char * text
)
{
        ASSERT(text, "null");
        ASSERT2(pos.y >= 0 && pos.y < s_maxDim, "bad pos.y: " << pos.y);

        int L = strlen(text);
        ASSERT2(pos.x >= 0 && pos.x + L < s_maxDim, "bad pos.x: " << pos.x
            << "   or bad L: " << L);

        row_t& r = m_rows[pos.y];
        this->markUsed(pos.y);
        for (int i = 0; i < L; ++i) {
                r.text[pos.x + i] = text[i];
        }
}



void
TDI::drawRectWithBorder
(
IN eElementType type,
IN const rect_t& r
)
{
        ASSERT2(r.isValid(), "bad r");
        ASSERT2(r.top >= 0, "bad top: " << r.top);
        ASSERT2(r.left >= 0, "bad left: " << r.left);
        ASSERT2(r.right < s_maxDim, "bad right: " << r.right);
        ASSERT2(r.bottom < s_maxDim, "bad bottom: " << r.bottom);

        // top and bottom rows
        row_t& tRow = m_rows[r.top];
        row_t& bRow = m_rows[r.bottom - 1];
        this->markUsed(r.top);
        this->markUsed(r.bottom - 1);
        tRow.text[r.left] = '/';
        tRow.text[r.right - 1] = '\\';
        bRow.text[r.left] = '\\';
        bRow.text[r.right - 1] = '/';
        for (int i = r.left + 1; i < r.right - 1; ++i) {
                tRow.text[i] = '-';
                bRow.text[i] = '-';
        }

        // intermediate rows: just endpoints
        for (int i = r.top + 1; i < r.bottom - 1; ++i) {
                row_t& row = m_rows[i];
                this->markUsed(i);
                row.text[r.left] = '|';
                row.text[r.right - 1] = '|';
        }
}



void
TDI::writeToStream
(
IO std::ostream& stream
)
{
        for (int i = 0; i < s_maxDim; ++i) {
                const row_t& r = m_rows[i];
                if (!r.text[0])
                        continue;               // skip this row--unused
                stream << r.text << "\n";
        }
}



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

smart_ptr<TextDrawer>
TextDrawer::create
(
IN int borderSize
)
{
        ASSERT2(borderSize > 0, "Bad border size: " << borderSize);

        smart_ptr<TDI> local = new TDI;
        ASSERT(local, "out of memory");

        local->initialize(borderSize);

        return local;
}



};      // dialog namespace