dialog-draw/test/test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 * Program to test the dialog-draw library.
 */

// includes --------------------------------------------------------------------
#include <iostream>
#include <fstream>

#include "common/wave_ex.h"
#include "datahash/datahash.h"
#include "dialog/dialog.h"
#include "dialog/request.h"
#include "dialog-draw/dialog-draw.h"
#include "glut-font/glut-font.h"
#include "perf/perf.h"
#include "util/file.h"
#include "wave-glut/camera.h"
#include "wave-glut/glut_2d.h"
#include "wave-glut/wave-glut.h"



static const int s_defaultWidth                 = 800;
static const int s_defaultHeight                = 600;

static float s_dist                             = 10.0;


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

static void
addDialog
(
IN dialog::Manager * mgr,
IN dialog::Host * host
)
{
        ASSERT(mgr, "null");
        ASSERT(host, "null");

        dialog::ContainerRequest crRoot;

        dialog::ContainerRequest cr(dialog::ContainerRequest::eAxis_Horizontal);


        dialog::ContainerRequest cr2;
        cr2.addLabel("Sample dialog");
        cr2.addButton("submit1", "button-1");
        cr2.addButton("submit2", "button-2");
        cr2.addTextbox("text1", "foo", 12);

        cr.addContainer(cr2);

        dialog::ContainerRequest cr3;
        cr3.addLabel("Sample d2");
        cr3.addButton("submit3", "button-3");

        cr.addContainer(cr3);

        crRoot.addLabel("Start of dialog");
        crRoot.addContainer(cr);
        crRoot.addLabel("End of dialog");

        smart_ptr<Datahash> data = crRoot.getDatahash();
        ASSERT(data, "null");

        mgr->createDialog("d1", 32, 32, data, host);
}



class TestHost : public glut::Host,
                public dialog::Host {
public:
        TestHost(IN const char * file) { m_fontFile = file; }
        ~TestHost(void) throw() { }

        // dialog::Host class interface methods --------------------------------
        void notifySubmit(IN const char * id,
                                IN const Datahash * hash) {
                        DPRINTF("Submit event, id='%s'", id);
                }

        // glut::Host class interface methods ----------------------------------
        void init(void) {
                // create DES key(!)
                smart_ptr<crypto::DESKey> des = crypto::DESKey::create();
                ASSERT(des, "failed to create DES encryption key");

                // get font stream
                std::string parentDir;
                GetParentDirectory(m_fontFile.c_str(), parentDir);
                smart_ptr<nstream::Manager> mgr =
                    nstream::getFilesystemManager(parentDir.c_str());
                ASSERT(mgr, "null");
                smart_ptr<nstream::Stream> fontStream =
                    nstream::openNamedStream(mgr, GetFilename(m_fontFile.c_str()));
                ASSERT(fontStream, "null");

                // get font
                m_fontMgr = glut::FontManager::create();
                ASSERT(m_fontMgr, "null");

                // set up dialog drawer data
                dialog::ogl_dialog_draw_t odd;
                odd.font = m_fontMgr->getFont(fontStream);
                ASSERT(odd.font, "failed to acquire OpenGL font");
                ASSERT(odd.isValid(),
                    "should have valid OpenGL dialog draw data");

                // create dialog drawer
                smart_ptr<dialog::Drawer> drawer =
                    dialog::createOpenGLDrawer(odd);
                ASSERT(drawer, "null");

                // create dialog manager
                m_dialogMgr = dialog::Manager::create(des, drawer);
                ASSERT(m_dialogMgr, "failed to create dialog manager");

                // construct a sample dialog
                addDialog(m_dialogMgr, this);

                // other initialization
                glShadeModel(GL_SMOOTH);

                glEnable(GL_LIGHT0);

                glFrontFace(GL_CCW);
                glEnable(GL_CULL_FACE);
                glCullFace(GL_BACK);
        }

        void display(IN int w, IN int h) {
                perf::time_t now = perf::getNow();
                static glut::fps_t s_fps(now);
                s_fps.tick(now);

                glEnable(GL_LIGHTING);
                glEnable(GL_LIGHT0);
                glEnable(GL_DEPTH_TEST);
                glEnable(GL_TEXTURE_2D);
                glEnable(GL_CULL_FACE);
                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

                // clear buffers (takes no effect until drawing much later)
                glClearColor(0.35, 0.35, 0.35, 1.0);
                glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

                // set up camera, viewer
                glut::camera_t camera;
                camera.setAspect(w, h);
                glut::Viewer viewer;
                viewer.setPosition(point3d_t(0, 0, -s_dist));

                // set up glut for drawing
                glut::setOpenGLProjection(camera);
                glut::setOpenGLViewer(viewer);

                // set up lighting
                float lightAmbient[] = { 0.8, 0.8, 0.8, 1.0 };
                glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightAmbient);

                // rotate object
                static float angle = 0.0;
                angle += 0.5;
                glMatrixMode(GL_MODELVIEW);
                glPushMatrix();
                glRotatef(angle, 0.0, 1.0, 0.0);

                // draw object
                glutSolidSphere(4.0, 16, 16);
                glPopMatrix();

                glDisable(GL_LIGHTING);
                glDisable(GL_LIGHT0);
                glDisable(GL_DEPTH_TEST);
                glDisable(GL_TEXTURE_2D);
                glDisable(GL_CULL_FACE);

                glut::push2D(w, h);

                // dialog
                m_dialogMgr->display(w, h);

                // output FPS
                glut::Font * font = glut::getDefaultFont();
                char buffer[128];
                sprintf(buffer, "%d fps", (int) s_fps.getFPS());
                font->display(1, 12, 0, buffer);
                sprintf(buffer, "%d x %d", w, h);
                font->display(w - 100, 12, 0, buffer);

                glut::pop2D();
        }

        eBehavior tick(void) {
                return eContinue;
        }

        int shutdown(void) {
                perf::dumpTimingSummary(std::cout);
                return 0;
        }

        eBehavior mouseMove(IN int x, IN int y) {
                        m_dialogMgr->cursor(x, y);
                        return eContinue;
                }

        eBehavior mouseButton(IN int button, IN int state, IN int x, IN int y) {
                        DPRINTF("button = %d,    state = %d", button, state);
                        m_dialogMgr->button(button, state, x, y);
                        return eContinue;
                }

        eBehavior keyboard(IN int key, IN int mods) {
                if ('=' == key)
                        s_dist += 1.0;
                if ('-' == key)
                        s_dist -= 1.0;
        
                if (s_dist < 1.0)
                        s_dist = 1.0;

                if ('l' == key)
                        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

                if ('s' == key)
                        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

                if (27 == key)
                        return eExit;

                m_dialogMgr->keyboard(key, mods);

                return eContinue;
        }

private:
        std::string                             m_fontFile;
        smart_ptr<dialog::Manager>              m_dialogMgr;
        smart_ptr<glut::FontManager>            m_fontMgr;
};



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc,
            "usage: dialog-draw-test <path-to-font>");
        const char * fontFile = argv[1];
        DPRINTF("Using font: %s", fontFile);
        try {
                // main loop
                smart_ptr<glut::Host> host = new TestHost(fontFile);
                ASSERT(host, "out of memory");
                glut::start(argc, argv,
                        s_defaultWidth, s_defaultHeight,
                        "wave-glut dialog draw test",
                        NULL,
                        host);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
        }

        // only reach here on error
        return 1;
}