C:/Users/admin/Documents/Visual Studio 2008/Projects/AdaptiviTree/AdaptiviTree/canvas.cpp

Go to the documentation of this file.

#include "canvas.h"

int Canvas::STEP_UP = -3;
int Canvas::STEP_DOWN = 3;

Canvas::Canvas(QWidget *parent)
: QWidget(parent), painter(new QPainter(this)), HMARGIN(0), brcktVmargin(0), x0(0), y0(0), dx(0), dy(0), animated(false), colorStep(0), picks(true)
{
        timer = new QTimer(this);
        connect(timer, SIGNAL(timeout()), this, SLOT(animate()));
        
        undecided = QPen(Qt::white, 1.5, Qt::CustomDashLine, Qt::RoundCap);
        undecided.setDashPattern(QVector<qreal> (2,3));
        decided = QPen(QColor(150,150,150), 1.5, Qt::SolidLine, Qt::RoundCap);
}

Canvas::~Canvas()
{
        delete timer;
        delete painter;
        delete tournament;
}

void Canvas::init(void)
{
        //QWidget::showNormal();
        pen = QPen(Qt::white, 1.5, Qt::CustomDashLine, Qt::RoundCap);
        pen.setDashPattern(QVector<qreal> (2,3));

        HMARGIN = width()/6;
        brcktVmargin = 50; //35;
        
        x0 = HMARGIN+brcktHmargin;              
        y0 = VMARGIN;
        dx = floor((double)((width()/2-HMARGIN-brcktHmargin)/((log((double)tournament->getTeamCount())/log(2.0)-1))));
        dy = floor((double)((height()-2*VMARGIN-(tournament->getBracketCount()-1)*brcktVmargin)/tournament->getBracketCount()));

        initBracketPositions(tournament->getTeamCount()-2, tournament->getBracketCount(),y0,dy,0);
}

void Canvas::initBracketPositions(int id, int num, int y0, int dy, int level)
{
        int ylink;
        int h = floor((double)(y0+dy/2));

        for (int i=0; i<num; i++)
        { 
                ylink = floor((double)(y0+dy/2));
                tournament->getGameByID(id-i)->setBracket(y0,dy,ylink,level,Canvas::LEFT,3,pen);
                tournament->getGameByID(id-i-num)->setBracket(y0,dy,ylink,level,Canvas::RIGHT,-3,undecided);
                y0 += dy+brcktVmargin;
        }

        y0 = h;
        dy += brcktVmargin;
        brcktVmargin = dy;
        
        if (num!=1)
                initBracketPositions((id-2)/2,num/2, y0, dy, ++level);
}

void Canvas::resizeEvent(QResizeEvent* revent)
{
        //QSize oldSize = revent->oldSize();
        //if(oldSize.isValid())
        //{
        //      HMARGIN = width()/6;
        //
        //      x0 = HMARGIN+brcktHmargin;              
        //      dx = floor((double)((width()/2-HMARGIN-brcktHmargin)/((log((double)tournament->getTeamCount())/log(2.0)-1))));
        //      //dy = floor((double)((height()-2*VMARGIN-(tournament->getBracketCount()-1)*brcktVmargin)/tournament->getBracketCount()));
        //      
        //      int h = size().height()-oldSize.height();
        //      QVector<Game*> games = tournament->getGames();
        //      for(int i=0; i<games.size()-1; i++)
        //      {
        //              Game::Bracket bracket = games[i]->getBracket();
        //              if(i!=0 && i!=tournament->getBracketCount())
        //                      games[i]->setBracket(bracket.y0+h, bracket.dy+h, bracket.y0+h+(bracket.dy+h)/2, bracket.dashOffset);
        //              else
        //                      games[i]->setBracket(bracket.y0, bracket.dy+h, bracket.y0+(bracket.dy+h)/2, bracket.dashOffset);
        //      }

        //}
        //else
        //      init();

        //update();
}

void Canvas::paintEvent(QPaintEvent* pevent)
{
        painter->begin(this);
        painter->setRenderHint(QPainter::Antialiasing, true);
        fontheight = painter->fontMetrics().height()/2;
        
        if(picks)
                drawPicks(round);
        drawTeamInfo();
        drawBrackets();
        
        painter->end();
}

QPainterPath Canvas::drawBracket(int x0, int y0, int ylink, int dx, int dy, int dashOffset)
{
        int ym = floor((double)(y0+dy/2));
        dx/= 2;

        QPainterPath path;
        path.moveTo(x0,y0);
        path.cubicTo(x0+dx,y0,x0+dx,y0,x0+dx,ym-abs(ym-ylink));
        path.lineTo(x0+dx,ym+abs(ym-ylink));
        path.cubicTo(x0+dx,y0+dy,x0+dx,y0+dy,x0,y0+dy);
        path.moveTo(x0+dx+dashOffset,ylink);
        path.lineTo(x0+2*dx,ylink);

        return path;
}

void Canvas::drawBrackets(void)
{
        QVector<Game*> games = tournament->getGames();
        for (int i=0; i<games.size()-1; i++)
        {
                Game::Bracket bracket = games[i]->getBracket();
                
                if(bracket.dir == Canvas::LEFT)
                        x0 = HMARGIN+brcktHmargin;
                else
                        x0 = width()-HMARGIN-brcktHmargin;
                
                painter->setPen(bracket.pen);
                painter->drawPath(drawBracket(x0+dx*bracket.level*bracket.dir, bracket.y0, bracket.ylink, dx*bracket.dir, bracket.dy, bracket.dashOffset));
                
                if(isDrawn(games[i]) && !games[i]->getTeam(games[i]->getState())->hasLost())
                {
                        painter->setPen(QPen(Qt::white, 4, Qt::SolidLine, Qt::RoundCap));
                        painter->drawLine(x0, bracket.ylink, x0+dx*(bracket.level+1)*bracket.dir, bracket.ylink);
                }
        }
        // final game
        if(games.last()->getState() && round == tournament->getTeamCount()-1)
                painter->setPen(decided);
        else
                painter->setPen(undecided);
        painter->drawLine(width()/2, games[games.size()-2]->getBracket().ylink, width()/2, games[games.size()-3]->getBracket().ylink); 
}

void Canvas::drawTeamInfo(void)
{
        int cnt = tournament->getBracketCount();
        int gameCnt = tournament->getTeamCount()-1;
        int currRound = gameCnt-round;
        bool draw;

        for (int i=0; i<cnt; i++)
        {
                Game* game = tournament->getGameByID(tournament->getTeamCount()-2-i);
                Game::Bracket bracket = game->getBracket();

                //left bracket
                //team 1
                painter->setPen(getPenForTeam(game->getTeam(1)));
                painter->drawText(QRect(QPoint(0, bracket.y0-fontheight), QPoint(HMARGIN-35*!game->getTeam(1)->getIcon().isNull(), bracket.y0+fontheight)), 
                        game->getTeam(1)->getName(), QTextOption(Qt::AlignRight));
                                
                //if(currRound>game->getID() || game->getState()==Game::WINTEAM1 || game->getState()==Game::UNDECIDED)
                        painter->drawPixmap(QRect(QPoint(HMARGIN-25, bracket.y0-12), QPoint(HMARGIN, bracket.y0+12)), game->getTeam(1)->getIcon());
                
                //team 2
                painter->setPen(getPenForTeam(game->getTeam(2)));
                painter->drawText(QRect(QPoint(0, bracket.y0+bracket.dy-fontheight), QPoint(HMARGIN-35*!game->getTeam(2)->getIcon().isNull(), bracket.y0+bracket.dy+fontheight)), 
                        game->getTeam(2)->getName(), QTextOption(Qt::AlignRight));      
                
                //if(currRound>game->getID() || game->getState()==Game::WINTEAM2 || game->getState()==Game::UNDECIDED)
                        painter->drawPixmap(QRect(QPoint(HMARGIN-25, bracket.y0+bracket.dy-12), QPoint(HMARGIN, bracket.y0+bracket.dy+12)), game->getTeam(2)->getIcon());
                
                game = tournament->getGameByID(tournament->getTeamCount()-tournament->getBracketCount()-2-i);
                bracket = game->getBracket();

                //right bracket
                //team 1
                painter->setPen(getPenForTeam(game->getTeam(1)));
                painter->drawText(QRect(QPoint(width()-HMARGIN+35*!game->getTeam(1)->getIcon().isNull(), bracket.y0-fontheight), QPoint(width(), bracket.y0+fontheight)), 
                        game->getTeam(1)->getName(), QTextOption(Qt::AlignLeft));
                painter->drawPixmap(QRect(QPoint(width()-HMARGIN, bracket.y0-12), QPoint(width()-HMARGIN+25, bracket.y0+12)), game->getTeam(1)->getIcon());
                
                //team 2
                painter->setPen(getPenForTeam(game->getTeam(2)));
                painter->drawText(QRect(QPoint(width()-HMARGIN+35*!game->getTeam(2)->getIcon().isNull(), bracket.y0+bracket.dy-fontheight), QPoint(width(), bracket.y0+bracket.dy+fontheight)), 
                        game->getTeam(2)->getName(), QTextOption(Qt::AlignLeft));
                painter->drawPixmap(QRect(QPoint(width()-HMARGIN, bracket.y0+bracket.dy-12), QPoint(width()-HMARGIN+25, bracket.y0+bracket.dy+12)), game->getTeam(2)->getIcon());
        }
}

QPen Canvas::getPenForTeam(Team *team)
{
        if(team->hasLost())
                return decided;
        else
                return undecided;
}


void Canvas::drawPicks(int round)
{
        painter->setPen(Qt::NoPen);

        QBrush brush;
        QPixmap pix("Resources/strip.png");
        
        int pickLength=dx/2;

        Team::Round minR = tournament->getMinRound();

        int mult = 1, x, y;
        int dir = 1;
        int tcnt = tournament->getTeamCount();
        int length = normalLen;
        int gameCnt = tcnt-1;
        int currRound = gameCnt-round;

        /*Iterate over all games in the first round */
        for(int i=tcnt-2; i>=tcnt/2-1; i--) 
        {
                Game* currGame = tournament->getGameByID(i);

                Team::Round r[2]; 
                r[0] = currGame->getTeam1Direct()->getPick();
                r[1] = currGame->getTeam2Direct()->getPick();

                Game::Bracket bracket = currGame->getBracket();

                if(bracket.dir == Canvas::LEFT)
                        x0 = HMARGIN+brcktHmargin;
                else
                        x0 = width()-HMARGIN-brcktHmargin;

                /*draw pick for both teams in this game*/
                for(int j=0; j<2; j++) 
                {
                        if(j==0) mult = 0;
                        else mult = 1;
                        
                        if(bracket.dir==-1)
                        {
                                length = pickLength*2*-1;
                                x=x0-dx/4;
                        }
                        else
                        {
                                length = pickLength*2;
                                x = x0+dx/4;
                        }
                        
                        y = bracket.y0+mult*dy-pickHeight/2;

                        //Draw small picks for every team
                        brush = QBrush(Qt::green, Qt::SolidPattern);
                        painter->setBrush(brush);
                        painter->drawRoundedRect(QRect(x-10,y,15,pickHeight),5,5,Qt::AbsoluteSize);
                        
                        int rNumber = r[j]-minR+1;      //number of rounds where picks were set
                        QVector<bool> played;
                        Game* temp = currGame;

                        for(int l=0; l<rNumber; l++)
                        {               
                                if(currRound-1<temp->getID() && temp->getState()!=Game::UNDECIDED)
                                {
                                        played.append(true);
                                }
                                else
                                        played.append(false);

                                if(temp->getID()%2==0)
                                        temp = tournament->getGameByID(temp->getID()/2-1);
                                else
                                        temp = tournament->getGameByID(temp->getID()/2);
                        }

                        int tL;

                        temp = currGame;
                        bool wrongBet = false;

                        /*Draw all rectangles */
                        for(int k=minR; k<=r[j]; k++) {
                                if(rNumber>0)
                                {
                                        int t1=1, t2=2;
                                        if(temp->getTeam1()!= currGame->getTeam1())
                                        {
                                                t1 = 2;
                                                t2 = 1;
                                        }
                                        
                                        if(played[k-minR]) 
                                        {
                                                if((j==0 && t1==1 && temp->getState()==Game::WINTEAM1) 
                                                        || (j==0 && t1==2 && temp->getState()==Game::WINTEAM2)
                                                        || (j==1 && t2==1 && temp->getState()==Game::WINTEAM1)
                                                        || (j==1 && t2==2 && temp->getState()==Game::WINTEAM2)) {
                                                        brush = QBrush(Qt::green, Qt::SolidPattern);
                                                        painter->setBrush(brush); 
                                                } 
                                                else 
                                                {
                                                        brush = QBrush(Qt::red, Qt::SolidPattern);
                                                        painter->setBrush(brush); 
                                                }
                                                if((j==0 && t1==1 && temp->getState()==Game::WINTEAM2) 
                                                        || (j==0 && t1==2 && temp->getState()==Game::WINTEAM1)
                                                        || (j==1 && t2==1 && temp->getState()==Game::WINTEAM2)
                                                        || (j==1 && t2==2 && temp->getState()==Game::WINTEAM1)) {
                                                        wrongBet = true;
                                                }
                                        }
                                        else 
                                        {
                                                brush = QBrush(Qt::green,pix);
                                                painter->setBrush(brush); 
                                        }
                                        if(wrongBet)
                                        {
                                                        brush = QBrush(Qt::red, Qt::SolidPattern);
                                                        painter->setBrush(brush); 
                                        }
                                }

                                if(k==minR) 
                                {
                                        tL = length;
                                        if(bracket.dir==-1)
                                        {
                                                length = length-dx/4;
                                        }
                                        else
                                        {
                                                length = length+dx/4;
                                        }
                                }
                                else length = tL;


                                if(k==Team::HALF) length=length/3;
                                if(k==Team::FINAL) length = length/5;
                                painter->drawRect(x,y,length,pickHeight); 
                                x = x+length;
                                if(temp->getID()%2==0)
                                        temp = tournament->getGameByID(temp->getID()/2-1);
                                else
                                        temp = tournament->getGameByID(temp->getID()/2);
                        }
                }
        }
        
        
        painter->setBrush(Qt::NoBrush);

        pen = QPen(Qt::white, 1.5, Qt::CustomDashLine, Qt::RoundCap);
        pen.setDashPattern(QVector<qreal> (2,3));
        painter->setPen(pen);   
}

void Canvas::mousePressEvent(QMouseEvent* mevent)
{
        int x = mevent->globalX();
        int y = mevent->globalY();
        Qt::MouseButton button = mevent->button();

        Team* t = findTeamFromCoordinates(x,y);

        if(t!=0)        //clicked on a team
        {
                qDebug("Team clicked: %i", t->getId());
                Team::Round r = t->getPick();
                if(button==Qt::LeftButton)
                {
                        if(r==Team::NO)
                                t->setPick(tournament->getMinRound());
                        else if(r!=Team::FINAL)
                        {
                                r = Team::getPickForInt(r+1);
                                t->setPick(r);
                        }
                        
                }
                else
                {
                        if(r!=Team::NO)
                        {
                                r = Team::getPickForInt(r-1);
                                t->setPick(r);
                        }
                }

        }
        update();       
}

Team* Canvas::findTeamFromCoordinates(int x, int y)
{
        int bar = 72;
        int sizeVert = 10;
        int sizeHor = 10;

        QVector<Game*> games = this->tournament->getGames();
        int currXLow;
        int currXHigh;
        int currYLow;
        int currYHigh;
        Game::Bracket bracket;

        for(int i=0; i<games.size(); i++) 
        {
                bracket = games[i]->getBracket();
                if(bracket.dir == Canvas::LEFT)
                        x0 = HMARGIN+brcktHmargin+dx/4;
                else
                        x0 = width()-HMARGIN-brcktHmargin-dx/4;

                currXLow = x0-sizeHor;
                currXHigh = x0+sizeHor;
                currYLow = bracket.y0-sizeVert+bar;
                currYHigh = bracket.y0+sizeVert+bar;

                if(x>currXLow && x<currXHigh 
                        && y>currYLow && y<currYHigh)   //mouse click for this team
                {
                        return games[i]->getTeam1Direct();
                }

                currYLow = currYLow + bracket.dy;
                currYHigh = currYHigh + bracket.dy;

                if(x>currXLow && x<currXHigh 
                        && y>currYLow && y<currYHigh)   //mouse click for this team
                {
                        return games[i]->getTeam2Direct();
                }
        }
        return 0;
}


void Canvas::updateParentBracket(int ID)
{
        if(ID != 0)
        {
                Game* game = tournament->getGameByID(ID);
                Game::Bracket left = game->getChild(Game::LEFTCHILD)->getBracket();
                Game::Bracket right = game->getChild(Game::RIGHTCHILD)->getBracket();
                game->setBracket(left.ylink, right.ylink-left.ylink, left.ylink+floor((double)(right.ylink-left.ylink)/2), game->getBracket().dashOffset);      
                updateParentBracket((ID-2+ID%2)/2);
        }
}

bool Canvas::isDrawn(Game *game)
{
        Game::Bracket bracket = game->getBracket();
        if(bracket.ylink == bracket.y0 || bracket.ylink == bracket.y0+bracket.dy)
                return true;
        else
                return false;
}


void Canvas::setAnimationEndPoint(int end, int offset, int color)
{
        animEnd = end;
        dashOffset = offset;
        colorStep = color;
}

void Canvas::animate()
{
        Game::Bracket bracket = animatedGame->getBracket();
        int ID = animatedGame->getID();

        if(ID != 0)
        {
                if(abs(bracket.ylink-animEnd)>STEP_DOWN)        
                {
                        int color = bracket.pen.color().green();
                        if(isDrawn(animatedGame))
                        {
                                bracket.pen = undecided;
                                colorStep = -colorStep;
                        }
                        color = std::max(std::min(color-colorStep, 255), 150);
                        animatedGame->setBracket(bracket.y0, bracket.dy, bracket.ylink+step, dashOffset);
                        bracket.pen.setColor(QColor(color,color,color));
                        animatedGame->setPen(bracket.pen);
                        updateParentBracket((ID-2+ID%2)/2);
                }
                //animation finished
                else
                {
                        animatedGame->setBracket(bracket.y0, bracket.dy, animEnd, dashOffset);
                        updateParentBracket((ID-2+ID%2)/2);
                        timer->stop();
                        animated = false;
                        if(isDrawn(animatedGame))
                                animatedGame->setPen(decided);
                        else
                                animatedGame->setPen(undecided);
                }
                update();
        } 
        // final game
        else 
        {
                timer->stop();
                animated = false;
        }
}

---