- no default args in method impls

- resolved parameter shadowing

1 files changed, 5 insertions, 5 deletions

diff --git a/noncore/games/mindbreaker/mindbreaker.cpp b/noncore/games/mindbreaker/mindbreaker.cpp
index b0e4d88..1a1d05d 100644
--- a/noncore/games/mindbreaker/mindbreaker.cpp
+++ b/noncore/games/mindbreaker/mindbreaker.cpp
@@ -1,447 +1,447 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "mindbreaker.h"
 
 #include <qpe/resource.h>
 #include <qpe/config.h>
 
 #include <qpainter.h>
 #include <qpixmap.h>
 #include <qpe/qpetoolbar.h>
 #include <qtoolbutton.h>
 #include <qpushbutton.h>
 #include <qmessagebox.h>
 #include <qlabel.h>
 #include <qstyle.h>
 
 #include <stdlib.h>
 #include <sys/time.h>
 #include <unistd.h>
 
 static int pegRTTI = 3393393;
 
 /* helper class,  */
 class Peg : public QCanvasRectangle
 {
 public:
     Peg(QCanvas *canvas, int type, int go = -1, int pos = -1);
     int rtti() const {return pegRTTI; }
     void advance(int phase);
 
     bool hit( const QPoint &) const;
 
 /* a placed peg is one that has been set down on the board correctly and 
    should not be moved, only copied */
     bool placed() const;
     void setPlaced(bool);
 
     int pegGo() const;
     int pegPos() const;
     void setPegPos(int);
 
     int type() const;
 
     static void buildImages();
     static QImage imageForType(int t);
 
     static int eggLevel;
 
 protected:
     void drawShape(QPainter &);
 private:
     static QVector<QImage> normalPegs;
     static QVector<QImage> specialPegs;
 
     bool isplaced;
     int pegtype;
     int peg_go;
     int peg_pos;
 
     int aniStep;
 };
 
 int Peg::eggLevel = 0;
 QVector<QImage> Peg::normalPegs;
 QVector<QImage> Peg::specialPegs;
 
 void Peg::buildImages()
 {
 
     QImage pegs = Resource::loadImage("mindbreaker/pegs");
     int x = 0; 
     int y = 0;
     int i;
     eggLevel = 0;
     normalPegs.resize(10);
     for (i = 0; i < 6; i++) {
         normalPegs.insert(i, new QImage(pegs.copy(x, y, peg_size, peg_size)));
         x += peg_size;
     }
     specialPegs.resize(5);
     for (i = 0; i < 5; i++) {
         specialPegs.insert(i, new QImage(pegs.copy(x,y,peg_size, peg_size)));
         x += peg_size;
     }
 
     QImage image = Resource::loadImage("mindbreaker/mindbreaker");
     /* copy from master image to functional images */
     x = 0;
     y = panel_height;
     normalPegs.insert(8, 
             new QImage(image.copy(x, y, panel_width, panel_height)));
     y += panel_height;
     y += title_height;
     normalPegs.insert(9, 
             new QImage(image.copy(x, y, title_width, title_height)));
     y += title_height;
 
     x = 6 * peg_size;
     normalPegs.insert(6, 
             new QImage(image.copy(x, y, answerpeg_size, answerpeg_size)));
     x += answerpeg_size;
     normalPegs.insert(7, 
             new QImage(image.copy(x, y, answerpeg_size, answerpeg_size)));
 }
 
 QImage Peg::imageForType(int t) 
 {
     if (eggLevel > t ) {
         if( t < 5) {
             return *specialPegs[t];
         } else {
             return *normalPegs[rand() % 6];
         }
     }
     return *normalPegs[t];
 }
 
-Peg::Peg(QCanvas *canvas , int t, int g = -1, int p = -1) 
+Peg::Peg(QCanvas *canvas , int t, int g, int p) 
         : QCanvasRectangle(canvas)
 {
     setSize(normalPegs[t]->width(), normalPegs[t]->height() );
     pegtype = t;
     isplaced = FALSE;
     peg_pos = p;
     peg_go = g;
     aniStep = rand() % 6;
     setAnimated(TRUE);
 }
 
 void Peg::advance(int phase) {
     if (phase == 0)
         aniStep = (++aniStep) % 6;
     else {
         hide();
         show();
     }
 }
 
 void Peg::drawShape(QPainter &p )
 {
     if ((pegtype == 5) && eggLevel > 5) {
         p.drawImage(x(), y(), *normalPegs[aniStep]);
     } else 
         p.drawImage(x(), y(), imageForType(pegtype));
 }
 
 bool Peg::hit( const QPoint &p ) const
 {
     int ix = p.x() - int(x());
     int iy = p.y() - int(y());
     if (!normalPegs[pegtype]->valid(ix, iy))
         return FALSE;
     QRgb pixel = normalPegs[pegtype]->pixel(ix, iy);
     return (qAlpha(pixel ) != 0);
 }
 
 inline bool Peg::placed() const
 {
     return isplaced;
 }
 
 inline int Peg::pegGo() const
 {
     return peg_go;
 }
 
 inline int Peg::pegPos() const
 {
     return peg_pos;
 }
 
 inline void Peg::setPegPos(int p) 
 {
     peg_pos = p;
 }
 
 inline void Peg::setPlaced(bool p) 
 {
     isplaced = p;
 }
 
 inline int Peg::type() const 
 {
     return pegtype;
 }
 
 /* Load the main image, copy from it the pegs, the board, and the answer image 
  * and use these to create the tray, answer and board
  */
-MindBreaker::MindBreaker( QWidget *parent=0, const char *name=0, int wFlags=0 )
+MindBreaker::MindBreaker( QWidget *parent, const char *name, int wFlags )
 : QMainWindow(parent, name, wFlags),
     canvas(board_height, board_width)
 {
     MindBreakerBoard *m = new MindBreakerBoard(canvas, this);
     setCentralWidget(m);
     
     setToolBarsMovable( FALSE );
 
     QPEToolBar *tb = new QPEToolBar(this);
     tb->setHorizontalStretchable( TRUE );
 
     QPixmap newicon = Resource::loadPixmap("new");
     new QToolButton(newicon, tr("New Game"), 0, 
                                        m, SLOT(clear()), tb, "NewGame");
 
     score = new QToolButton(tb);
     score->setText("");
     score->setMaximumHeight(20);
     score->setUsesTextLabel(TRUE);
     tb->setStretchableWidget(score);
 
     connect(m, SIGNAL(scoreChanged(int, int)), this, SLOT(setScore(int, int)));
     connect(score, SIGNAL(clicked()), m, SLOT(resetScore()));
 
     int a, b;
     m->getScore(&a, &b);
     setScore(a,b);
 }
 
 void MindBreaker::setScore(int turns, int games)
 {
     double average;
     double total_turns = turns;
     double total_games = games;
 
     if(total_games > 0) 
         average = total_turns / total_games;
     else 
         average = 0.0;
 
     score->setText(tr("win avg: %1 turns (%2 games)").arg(average).arg(games));
 }
 
 
-MindBreakerBoard::MindBreakerBoard( QCanvas &c, QWidget *parent=0, 
-                                    const char *name=0, int wFlags=0 )
-                     :  QCanvasView(&c, parent, name, wFlags)
+MindBreakerBoard::MindBreakerBoard( QCanvas &canv, QWidget *parent, 
+                                    const char *name, int wFlags )
+                     :  QCanvasView(&canv, parent, name, wFlags)
 {
     int i, x, y;
     struct timeval tv;
 
     current_go = 0;
     gettimeofday(&tv, 0);
 
     srand(tv.tv_usec);
 
     canvas()->setAdvancePeriod(500);
 
     QImage image = Resource::loadImage("mindbreaker/mindbreaker");
 
     /* copy from master image to functional images */
     x = 0;
     y = 0;
     panelImage = image.copy(x,y, panel_width, panel_height);
     y += panel_height;
     y += panel_height;
 
     titleImage = image.copy(x, y, title_width, title_height);
 
     Peg::buildImages(); // must be done BEFORE any pegs are made
 
     current_highlight = new Peg(canvas(), 8);
     current_highlight->setPlaced(TRUE);
     current_highlight->setX(0);
     current_highlight->setY(board_height - ((current_go + 1) * panel_height));
     current_highlight->setZ(0);
     current_highlight->show();
 
 
     /* set up the game */
     Config c("MindBreaker", Config::User);
     c.setGroup("Board");
     game_over = FALSE;
     if (c.readNumEntry("Answer0") < 0) {
         for (i = 0; i < 4; i++) {
             answer[i] = rand() % 6;
             current_guess[i] = 6;
         }
         total_turns = 0;
         total_games = 0;
     } else {
         int j;
         c.setGroup("Score");
         total_turns = c.readNumEntry("Turns");
         total_games = c.readNumEntry("Games");
         if(total_turns < 0)
             total_turns = 0;
         if(total_games < 0)
             total_games = 0;
 
 
         checkScores();
         c.setGroup("Board");
         for(i = 0; i < 4; i++) 
             answer[i] = c.readNumEntry(QString("Answer%1").arg(i));
         /* read, and parse past guesses */
         current_go = 0;
         for(j=0; j < 9; j++) {
             current_guess[0] = c.readNumEntry(QString("Go%1p0").arg(j));
             if (current_guess[0] < 0)
                 break;
             placeGuessPeg(0, current_guess[0]);
             current_guess[1] = c.readNumEntry(QString("Go%1p1").arg(j));
             placeGuessPeg(1, current_guess[1]);
             current_guess[2] = c.readNumEntry(QString("Go%1p2").arg(j));
             placeGuessPeg(2, current_guess[2]);
             current_guess[3] = c.readNumEntry(QString("Go%1p3").arg(j));
             placeGuessPeg(3, current_guess[3]);
             checkGuess();
         }
         for(i = 0; i < 4; i++) {
             current_guess[i] = c.readNumEntry(QString("CurrentGo%1").arg(i));
             if (current_guess[i] != 6) 
                 placeGuessPeg(i, current_guess[i]);
         }
     }
 
     /* draw initial screen */
     drawBackground();
     canvas()->update();
 }
 
 MindBreakerBoard::~MindBreakerBoard()
 {
     int i, j;
     if (game_over) {
         current_go = 0;
         /* clear the answer, clear the guess */
         for (i = 0; i < 4; i++) {
             answer[i] = rand() % 6;
             current_guess[i] = 6;
         }
     }
         
     Config c("MindBreaker", Config::User);
     c.setGroup("Board");
     c.clearGroup();
     /* write the board */
     for (i = 0; i < current_go; i++) {
         for(j = 0; j < 4; j++)
             c.writeEntry(tr("Go%1p%2").arg(i).arg(j), past_guesses[4*i+j]);
     }
     for(j = 0; j < 4; j++) 
         c.writeEntry(tr("CurrentGo%1").arg(j), current_guess[j]);
     for(j = 0; j < 4; j++) 
         c.writeEntry(tr("Answer%1").arg(j), answer[j]);
 
     c.setGroup("Score");
     /* write the score */
 
     c.writeEntry("Turns", total_turns);
     c.writeEntry("Games", total_games);
 }
 
 void MindBreakerBoard::getScore(int *a, int *b)
 {
     *a = total_turns;
     *b = total_games;
     return;
 }
 
 void MindBreakerBoard::placeGuessPeg(int pos, int pegId)
 {
         int x = first_peg_x_diff + (pos * peg_spacing);
         int y = board_height - ((current_go + 1) * panel_height) 
                 + first_peg_y_diff;
 
         Peg *peg = new Peg(canvas(), pegId, current_go, pos);
         peg->setPegPos(pos);
         peg->setPlaced(TRUE);
         peg->setX(x);
         peg->setY(y);
         peg->setZ(2);
         peg->show();
 }
 
 void MindBreakerBoard::drawBackground()
 {
     int i, j, x, y, x_gap, y_gap;
     QPixmap background  = QPixmap(canvas()->width(), canvas()->height());
 
     QPainter painter(&background);
 
     painter.fillRect(0, 0, canvas()->width(), canvas()->height(), QColor(0,0,0));
     /* very first thing is to draw the bins, as everything else needs
      * to be drawn over them */
 
     QPen pen(QColor(85, 45, 27), 4);
     painter.setPen(pen);
     x_gap = canvas()->width() - (panel_width + (2 * bin_margin));
     //x_gap += peg_size >> 1;
     if (x_gap < 1) 
         x_gap = 1;
 
     y_gap = board_height / 6;
     y_gap -= (2 * bin_margin);
     //y_gap += peg_size >> 1;
     if (y_gap < 1) 
         y_gap = 1;
     x = panel_width + bin_margin - (peg_size >> 1);
     y = bin_margin - (peg_size >> 1) + 2;
 
     for (i = 0; i < 6; i++) {
         for (j = 0; j < 10; j++) {
             int rx = x + (rand() % x_gap);
             int ry = y + (rand() % y_gap);
             painter.drawImage(rx,ry, Peg::imageForType(i));
         }
         y += board_height / 6;
     }
     /* now draw the surrounding boxes */
     x_gap = canvas()->width() - panel_width;
     if (x_gap < 1) x_gap = 1;
     y_gap = board_height / 6;
     x = panel_width;
     y = 1;
 
     for (i = 0; i < 6; i++) {
         painter.drawRect(x, y, x_gap, y_gap);
         y += y_gap;
     }
 
     x = 0;
     y = 0;
 
     painter.drawImage(x,y, titleImage);
     y = title_height;
     /* now nine gues panels */
     for (i = 0; i < 9; i ++) {