root/deus/GraphDisplay.cpp

/*      
 *      GraphDisplay.cpp
 *
 *      Zone display pane
 *
 *      $Header: /afs/acm/sig/art/cvs/deus/DEUS/GraphDisplay.cpp,v 1.1.1.2 2003-06-27 02:25:48 hanneke Exp $
 */

#include "GraphDisplay.h"
#include "GraphIcon.h"
#include "AuthorInterface_impl.h"

#include <qsizepolicy.h>
#include <qpainter.h>
#include <qpixmap.h>
#include <qimage.h>
#include <qrect.h>


GraphDisplay::GraphDisplay(QWidget *parent, const char *name)
        : QWidget(parent, name, WRepaintNoErase)
{
        setWFlags(WRepaintNoErase);
        
        zoom = DEFAULT_ZOOM;
        factor = 1.0;
        moving = NULL;
        maxx = maxy = minx = miny = 0;
        moving_icon = moving_pane = false;
        setPalette(QPalette(QColor(255,255,255)));
        buffer = new QPixmap();
        center();

        modified = suppress_repaint = false;
        fit_pending = false;
}


PlanGraphDisplay::PlanGraphDisplay(PlanNode *root, QWidget *parent, const char *name)
        : GraphDisplay(parent, name)
{
        this->root = root;
        boundingBox();
}


AuthorGraphDisplay::AuthorGraphDisplay(AuthorForm_impl *author, QWidget *parent, const char *name)
        : GraphDisplay(parent, name)
{
        this->author = author;
        boundingBox();
}       


void 
GraphDisplay::paintEvent(QPaintEvent *)
{
        if (fit_pending) {
                fit_pending = false;
                int z = zoom;
                fit(width(), height());
                if (zoom != z) emit zoomChanged(zoom);
        }

        draw(this, width(), height());

        QString s = "Zoom: " + QString::number(100 - int(zoom*100/99.0)) + "%";
        QPainter p(this);
        p.setPen(QPen(QColor(0,0,0),1));
        p.drawText(5, height()-5, s);

}


void
PlanGraphDisplay::draw(QPaintDevice *surface, int width, int height)
{
        QPainter p(buffer);
        p.translate((width/2) + z(cx), (height/2) + z(cy));
        buffer->fill(this, rect().topLeft());

        node_set.clear();
        draw_recursive(p, root);
        
        // copy buffer to screen
        p.end();
        p.begin(surface);
        p.drawPixmap(rect().topLeft(), *buffer);
}


void
AuthorGraphDisplay::draw(QPaintDevice *surface, int width, int height)
{
        QPainter p(buffer);
        p.translate((width/2) + z(cx), (height/2) + z(cy));
        buffer->fill(this, rect().topLeft());

        if (author->viewing == STORY_VIEW)                      draw_recursive(p, story_root);
        else if (author->viewing == KEYFRAME_VIEW)      draw_recursive(p, author->current_story->frame);
        else printf("Error: View type %d is unknown...\n", author->viewing);
        
        // copy buffer to screen
        p.end();
        p.begin(surface);
        p.drawPixmap(rect().topLeft(), *buffer);
}


void
PlanGraphDisplay::draw_recursive(QPainter &p, PlanNode *n)
{
        if (!n) return;
        node_set.insert(n);
        
        // First draw lines to unvisited parents and children, then drawn them
        std::vector<PlanNode *>::iterator It;
        for (It = n->branches.begin(); It != n->branches.end(); It++)
                if (*It && (node_set.find(*It) == node_set.end()))
                {
                        p.setPen(QPen(QColor(0,0,0),2));
                        p.drawLine(z(n->icon->ul_x + (n->icon->width()/2)), z(n->icon->ul_y + (n->icon->height()/2)),
                                           z((*It)->icon->ul_x + ((*It)->icon->width()/2)), z((*It)->icon->ul_y + ((*It)->icon->height()/2)));
                        draw_recursive(p, *It);
                }

        for (It = n->prevs.begin(); It != n->prevs.end(); It++)
                if (*It && (node_set.find(*It) == node_set.end()))
                {
                        p.setPen(QPen(QColor(0,0,0),2));
                        p.drawLine(z(n->icon->ul_x + (n->icon->width()/2)), z(n->icon->ul_y + (n->icon->height()/2)),
                                           z((*It)->icon->ul_x + ((*It)->icon->width()/2)), z((*It)->icon->ul_y + ((*It)->icon->height()/2)));
                        draw_recursive(p, *It);
                }

        // Node Image
        QImage img;
        img = n->icon->getIcon()->convertToImage();
        img = img.smoothScale(z(img.width()), z(img.height()));
        p.drawImage(z(n->icon->ul_x), z(n->icon->ul_y), img);
}


void
AuthorGraphDisplay::draw_recursive(QPainter &p, AuthorNode *n)
{
        if (!n) return;

        // First draw connecting lines, then children, then node
        if (n->type == NODE_STORY)
        {
                StoryNode *nt = (StoryNode *)n;
                std::vector<StoryNode*>::iterator It;
                for (It = nt->next.begin(); It != nt->next.end(); It++)
                        if (*It) 
                        {
                                p.setPen(QPen(QColor(0,0,0),2));
                                p.drawLine(z(n->icon->ul_x + (n->icon->width()/2)), z(n->icon->ul_y + (n->icon->height()/2)),
                                                   z((*It)->icon->ul_x + ((*It)->icon->width()/2)), z((*It)->icon->ul_y + ((*It)->icon->height()/2)));
                                draw_recursive(p, *It);
                        }
        }
        else    // NODE_KEYFRAME
        {
                KeyFrameNode *nt = (KeyFrameNode *)n;
                std::vector<KeyFrameNode*>::iterator It;
                for (It = nt->preconds.begin(); It != nt->preconds.end(); It++)
                        if (*It)
                        {
                                p.setPen(QPen(QColor(0,0,0),2));
                                p.drawLine(z(n->icon->ul_x + (n->icon->width()/2)), z(n->icon->ul_y + (n->icon->height()/2)),
                                                   z((*It)->icon->ul_x + ((*It)->icon->width()/2)), z((*It)->icon->ul_y + ((*It)->icon->height()/2)));
                                draw_recursive(p, *It);
                        }
        }

        // Node Image
        QImage img;
        img = n->icon->getIcon()->convertToImage();
        img = img.smoothScale(z(img.width()), z(img.height()));
        p.drawImage(z(n->icon->ul_x), z(n->icon->ul_y), img);
}


void
GraphDisplay::setZoom(int zoom) 
{
        if (this->zoom == zoom) return;

        if (zoom < 0) {this->zoom = 0;}
        else if (zoom > 99) {this->zoom = 99;}
        else this->zoom = zoom;
        factor = 1.0-(((1.0-FACTOR_MIN)*zoom)/99.0);
        repaint();
        emit zoomChanged(zoom);
}


void
GraphDisplay::resizeEvent(QResizeEvent *re)
{
        QWidget::resizeEvent(re);
        delete buffer;
        buffer = new QPixmap(re->size());
        repaint();
}


QSizePolicy 
GraphDisplay::sizePolicy() const
{
        return QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
}


void 
GraphDisplay::repaint(int x, int y, int w, int h, bool clear)
{
        if (!suppress_repaint) QWidget::repaint(x,y,w,h,false);
}


void
GraphDisplay::repaint() {if (!suppress_repaint) QWidget::repaint(false);}


void
GraphDisplay::center() {cx = cy = 0; repaint();}


void
GraphDisplay::fit() 
{
        int z = zoom;
        fit(width(), height());
        if (zoom != z) emit zoomChanged(zoom);
        repaint();
}


void
GraphDisplay::fit(int width, int height)
{
        boundingBox();
        int xspan = maxx - minx;
        int yspan = maxy - miny;

        cx = -1*(maxx + minx)/2;
        cy = -1*(maxy + miny)/2;

        factor = __min(width/float(xspan), height/float(yspan));
        if (factor > 1.0) factor = 1.0;
        if (factor < FACTOR_MIN) factor = FACTOR_MIN;

        int zoom_t = int(-99.0*(factor-1.0)/(1.0-FACTOR_MIN));
        zoom = zoom_t;
}


void
AuthorGraphDisplay::mouseMoveEvent(QMouseEvent *me)
{
        if (moving_icon) {
                int px = oldx + dez(me->x() - clickx);
                int py = oldy + dez(me->y() - clicky);
                int p2x = moving->ul_x;
                int p2y = moving->ul_y;

                moving->ul_x = px;
                moving->ul_y = py;      
                moving->modified = true;
                boundingBox();
                repaint();
        }
        else if (moving_pane) {
                cx = oldcx + dez(me->x() - clickx);
                cy = oldcy + dez(me->y() - clicky);
                repaint();
        }
}


void
AuthorGraphDisplay::mousePressEvent(QMouseEvent *me)
{
        clickx = me->x();
        clicky = me->y();       
        moving_icon = false;
        moving_pane = false;

        if (me->button() == RightButton) {
                // see if an icon is being dragged
                moving = intersect(tx(clickx), ty(clicky));
                if (moving != NULL) {
                        moving_icon = true;
                        oldx = moving->ul_x;
                        oldy = moving->ul_y;
                        setCursor(pointingHandCursor);
                }
        }
        else if (me->button() == LeftButton) {
                GraphIcon* i = intersect(tx(clickx), ty(clicky));
                if (i != NULL)
                        author->changeSelected(i->parent);
                else {
                        moving_pane = true;
                        oldcx = cx;
                        oldcy = cy;
                        setCursor(sizeAllCursor);
                }
        }
        else setCursor(forbiddenCursor);
}


void 
AuthorGraphDisplay::mouseDoubleClickEvent(QMouseEvent *me)
{
        clickx = me->x();
        clicky = me->y();

        // Go to keyframe view!
        if (me->button() == LeftButton) {
                GraphIcon* i = intersect(tx(clickx), ty(clicky));
                if (i != NULL && author->viewing == STORY_VIEW)
                        author->keyframeView((StoryNode*)i->parent);
        }
}


void
AuthorGraphDisplay::mouseReleaseEvent(QMouseEvent *me)
{
        setCursor(arrowCursor);
        moving = NULL;
        moving_icon = false;
        moving_pane = false;
}


GraphIcon*
AuthorGraphDisplay::intersect(int x, int y)
{
        if (author->viewing == STORY_VIEW)
        {
                StoryNode *n;
                list<StoryNode*> queue;
                queue.push_back(story_root);
                
                std::vector<StoryNode*>::iterator It;
                while (!queue.empty()) {
                        n = queue.front(); queue.pop_front();
                
                        if (n) {
                                if (x >= n->icon->ul_x && x <= (n->icon->ul_x + n->icon->width()))
                                        if (y >= n->icon->ul_y && y <= (n->icon->ul_y + n->icon->height()))
                                                return n->icon;

                                for (It = n->next.begin(); It != n->next.end(); It++)
                                        queue.push_back(*It);
                        }
                }
        }
        else
        {
                KeyFrameNode *n;
                list<KeyFrameNode*> queue;
                queue.push_back(author->current_story->frame);

                std::vector<KeyFrameNode*>::iterator It;
                while (!queue.empty()) {
                        n = queue.front(); queue.pop_front();
                
                        if (n) {
                                if (x >= n->icon->ul_x && x <= (n->icon->ul_x + n->icon->width()))
                                        if (y >= n->icon->ul_y && y <= (n->icon->ul_y + n->icon->height()))
                                                return n->icon;

                                for (It = n->preconds.begin(); It != n->preconds.end(); It++)
                                        queue.push_back(*It);
                        }
                }
        }

        return NULL;
}


void
PlanGraphDisplay::boundingBox()
{
        maxx = maxy = -1e16 + 1;
        minx = miny = 1e16 - 1;

        PlanNode *n;
        std::vector<PlanNode *>::iterator It;
        set<PlanNode *> visited;
        list<PlanNode *> queue;
        queue.push_back(root);

        while (!queue.empty())
        {
                n = queue.front(); queue.pop_front();
                
                if (n && visited.find(n) == visited.end())
                {
                        visited.insert(n);
                        
                        if ((n->icon->ul_x + n->icon->width()) > maxx)
                                maxx = n->icon->ul_x + n->icon->width();
                        if (n->icon->ul_x < minx) minx = n->icon->ul_x;
                        if ((n->icon->ul_y + n->icon->height()) > maxy)
                                maxy = n->icon->ul_y + n->icon->height();
                        if (n->icon->ul_y < miny) miny = n->icon->ul_y;

                        // Parents and children
                        for (It = n->branches.begin(); It != n->branches.end(); It++)
                                queue.push_back(*It);
                        for (It = n->prevs.begin(); It != n->prevs.end(); It++)
                                queue.push_back(*It);
                }
        }

        maxx += dez(10);
        maxy += dez(10);
        minx -= dez(10);
        miny -= dez(10);
}


void
AuthorGraphDisplay::boundingBox()
{
        maxx = maxy = -1e16 + 1;
        minx = miny = 1e16 - 1;

        if (author->viewing == STORY_VIEW)
        {
                StoryNode *n;
                list<StoryNode*> queue;
                queue.push_back(story_root);
                
                std::vector<StoryNode*>::iterator It;
                while (!queue.empty()) {
                        n = queue.front(); queue.pop_front();
                
                        if (n) {
                                if ((n->icon->ul_x + n->icon->width()) > maxx)
                                        maxx = n->icon->ul_x + n->icon->width();
                                if (n->icon->ul_x < minx) minx = n->icon->ul_x;
                                if ((n->icon->ul_y + n->icon->height()) > maxy)
                                        maxy = n->icon->ul_y + n->icon->height();
                                if (n->icon->ul_y < miny) miny = n->icon->ul_y;
        
                                for (It = n->next.begin(); It != n->next.end(); It++)
                                        queue.push_back(*It);
                        }
                }
        }
        else
        {
                KeyFrameNode *n;
                list<KeyFrameNode*> queue;
                queue.push_back(author->current_story->frame);

                std::vector<KeyFrameNode*>::iterator It;
                while (!queue.empty()) {
                        n = queue.front(); queue.pop_front();
                
                        if (n) {
                                if ((n->icon->ul_x + n->icon->width()) > maxx)
                                        maxx = n->icon->ul_x + n->icon->width();
                                if (n->icon->ul_x < minx) minx = n->icon->ul_x;
                                if ((n->icon->ul_y + n->icon->height()) > maxy)
                                        maxy = n->icon->ul_y + n->icon->height();
                                if (n->icon->ul_y < miny) miny = n->icon->ul_y;

                                for (It = n->preconds.begin(); It != n->preconds.end(); It++)
                                        queue.push_back(*It);
                        }
                }

        }

        maxx += dez(10);
        maxy += dez(10);
        minx -= dez(10);
        miny -= dez(10);
}