1 files changed, 256 insertions, 154 deletions

diff --git a/noncore/games/minesweep/minefield.cpp b/noncore/games/minesweep/minefield.cpp
index be2f9a3..eca1a36 100644
--- a/noncore/games/minesweep/minefield.cpp
+++ b/noncore/games/minesweep/minefield.cpp
@@ -1,623 +1,725 @@
 /**********************************************************************
 ** 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 "minefield.h"
 
 #include <qpe/config.h>
 
 #include <qpainter.h>
 #include <qdrawutil.h>
 #include <qpixmap.h>
 #include <qimage.h>
 #include <qtimer.h>
 
 #include <stdlib.h>
 
 static const char *pix_flag[]={
 "13 13 3 1",
 "# c #000000",
 "x c #ff0000",
 ". c None",
 ".............",
 ".............",
 ".....#xxxxxx.",
 ".....#xxxxxx.",
 ".....#xxxxxx.",
 ".....#xxxxxx.",
 ".....#.......",
 ".....#.......",
 ".....#.......",
 ".....#.......",
 "...#####.....",
 "..#######....",
 "............."};
 
 static const char *pix_mine[]={
 "13 13 3 1",
 "# c #000000",
 ". c None",
 "a c #ffffff",
 "......#......",
 "......#......",
 "..#.#####.#..",
 "...#######...",
 "..##aa#####..",
 "..##aa#####..",
 "#############",
 "..#########..",
 "..#########..",
 "...#######...",
 "..#.#####.#..",
 "......#......",
 "......#......"};
 
-class Mine : public QTableItem
+
+static const int maxGrid = 28;
+static const int minGrid = 9;
+
+
+
+class Mine : public Qt
 {
 public:
     enum MineState {
         Hidden = 0,
         Empty,
         Mined,
         Flagged,
 #ifdef MARK_UNSURE
         Unsure,
 #endif
         Exploded,
         Wrong
     };
 
-    Mine( QTable* );
-    void paint( QPainter * p, const QColorGroup & cg, const QRect & cr, bool selected );
-    EditType editType() const { return Never; }
-    QSize sizeHint() const { return QSize( 12, 12 ); }
+    Mine( MineField* );
+    void paint( QPainter * p, const QColorGroup & cg, const QRect & cr );
+
+    QSize sizeHint() const { return QSize( maxGrid, maxGrid ); }
 
     void activate( bool sure = TRUE );
     void setHint( int );
 
     void setState( MineState );
     MineState state() const { return st; }
 
     bool isMined() const { return mined; }
     void setMined( bool m ) { mined = m; }
 
     static void paletteChange();
 
 private:
     bool mined;
     int hint;
 
     MineState st;
-
+    MineField *field;
+    
     static QPixmap* knownField;
     static QPixmap* unknownField;
     static QPixmap* flag_pix;
     static QPixmap* mine_pix;
 };
 
 QPixmap* Mine::knownField = 0;
 QPixmap* Mine::unknownField = 0;
 QPixmap* Mine::flag_pix = 0;
 QPixmap* Mine::mine_pix = 0;
 
-Mine::Mine( QTable *t )
-: QTableItem( t, Never, QString::null )
+Mine::Mine( MineField *f )
 {
     mined = FALSE;
     st = Hidden;
     hint = 0;
+    field = f;
 }
 
 void Mine::activate( bool sure )
 {
     if ( !sure ) {
         switch ( st ) {
         case Hidden:
             setState( Flagged );
             break;
         case Flagged:
 #ifdef MARK_UNSURE
             setState( Unsure );
             break;
         case Unsure:
 #endif
             setState( Hidden );
         default:
             break;
         }
     } else if ( st == Flagged ) {
         return;
     } else {
         if ( mined ) {
             setState( Exploded );
         } else {
             setState( Empty );
         }
     }
 }
 
 void Mine::setState( MineState s )
 {
     st = s;
 }
 
 void Mine::setHint( int h )
 {
     hint = h;
 }
 
 void Mine::paletteChange()
 {
     delete knownField;
     knownField = 0;
     delete unknownField;
     unknownField = 0;
     delete mine_pix;
     mine_pix = 0;
     delete flag_pix;
     flag_pix = 0;
 }
 
-void Mine::paint( QPainter* p, const QColorGroup &cg, const QRect& cr, bool )
+void Mine::paint( QPainter* p, const QColorGroup &cg, const QRect& cr )
 {
+    int x = cr.x();
+    int y = cr.y();
     if ( !knownField ) {
         knownField = new QPixmap( cr.width(), cr.height() );
         QPainter pp( knownField );
         QBrush br( cg.button().dark(115) );
-        qDrawWinButton( &pp, QRect(0,0,cr.width(), cr.height())/*cr*/, cg, TRUE, &br );
+        qDrawWinButton( &pp, cr, cg, TRUE, &br );
     }
 
     const int pmmarg=cr.width()/5;
 
     if ( !unknownField ) {
         unknownField = new QPixmap( cr.width(), cr.height() );
         QPainter pp( unknownField );
         QBrush br( cg.button() );
-        qDrawWinButton( &pp, QRect(0,0,cr.width(), cr.height())/*cr*/, cg, FALSE, &br );
+        qDrawWinButton( &pp, cr, cg, FALSE, &br );
     }
 
     if ( !flag_pix ) {
         flag_pix = new QPixmap( cr.width()-pmmarg*2, cr.height()-pmmarg*2 );
         flag_pix->convertFromImage( QImage(pix_flag).smoothScale(cr.width()-pmmarg*2, cr.height()-pmmarg*2) );
     }
 
     if ( !mine_pix ) {
         mine_pix = new QPixmap( cr.width()-pmmarg*2, cr.height()-pmmarg*2 );
         mine_pix->convertFromImage( QImage(pix_mine).smoothScale(cr.width()-pmmarg*2, cr.height()-pmmarg*2) );
     }
 
     p->save();
 
     switch(st) {
     case Hidden:
-        p->drawPixmap( 0, 0, *unknownField );
+        p->drawPixmap( x, y, *unknownField );
         break;
     case Empty:
-        p->drawPixmap( 0, 0, *knownField );
+        p->drawPixmap( x, y, *knownField );
         if ( hint > 0 ) {
             switch( hint ) {
             case 1:
                 p->setPen( blue );
                 break;
             case 2:
-                p->setPen( green );
+                p->setPen( green.dark() );
+                break;
             case 3:
                 p->setPen( red );
                 break;
-            default:
+            case 4:
+                p->setPen( darkYellow.dark() );
+                break;
+            case 5:
                 p->setPen( darkMagenta );
                 break;
+            case 6:
+                p->setPen( darkRed );
+                break;
+            default:
+                p->setPen( black );
+                break;
             }
-            p->drawText( QRect( 0, 0, cr.width(), cr.height() ), AlignHCenter | AlignVCenter, QString().setNum( hint ) );
+            p->drawText( cr, AlignHCenter | AlignVCenter, QString::number( hint ) );
         }
         break;
     case Mined:
-        p->drawPixmap( 0, 0, *knownField );
-        p->drawPixmap( pmmarg, pmmarg, *mine_pix );
+        p->drawPixmap( x, y, *knownField );
+        p->drawPixmap( x+pmmarg, y+pmmarg, *mine_pix );
         break;
     case Exploded:
-        p->drawPixmap( 0, 0, *knownField );
-        p->drawPixmap( pmmarg, pmmarg, *mine_pix );
+        p->drawPixmap( x, y, *knownField );
+        p->drawPixmap( x+pmmarg, y+pmmarg, *mine_pix );
         p->setPen( red );
-        p->drawText( QRect( 0, 0, cr.width(), cr.height() ), AlignHCenter | AlignVCenter, "X" );
+        p->drawText( cr, AlignHCenter | AlignVCenter, "X" );
         break;
     case Flagged:
-        p->drawPixmap( 0, 0, *unknownField );
-        p->drawPixmap( pmmarg, pmmarg, *flag_pix );
+        p->drawPixmap( x, y, *unknownField );
+        p->drawPixmap( x+pmmarg, y+pmmarg, *flag_pix );
         break;
 #ifdef MARK_UNSURE
     case Unsure:
-        p->drawPixmap( 0, 0, *unknownField );
-        p->drawText( QRect( 0, 0, cr.width(), cr.height() ), AlignHCenter | AlignVCenter, "?" );
+        p->drawPixmap( x, y, *unknownField );
+        p->drawText( cr, AlignHCenter | AlignVCenter, "?" );
         break;
 #endif
     case Wrong:
-        p->drawPixmap( 0, 0, *unknownField );
-        p->drawPixmap( pmmarg, pmmarg, *flag_pix );
+        p->drawPixmap( x, y, *unknownField );
+        p->drawPixmap( x+pmmarg, y+pmmarg, *flag_pix );
         p->setPen( red );
-        p->drawText( QRect( 0, 0, cr.width(), cr.height() ), AlignHCenter | AlignVCenter, "X" );
+        p->drawText( cr, AlignHCenter | AlignVCenter, "X" );
         break;
     }
 
     p->restore();
 }
 
 /*
   MineField implementation
 */
 
 MineField::MineField( QWidget* parent, const char* name )
-: QTable( parent, name )
+: QScrollView( parent, name )
 {
     setState( GameOver );
-    setShowGrid( FALSE );
-    horizontalHeader()->hide();
-    verticalHeader()->hide();
-    setTopMargin( 0 );
-    setLeftMargin( 0 );
 
     setSizePolicy( QSizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum ) );
-    
-    setSelectionMode( QTable::NoSelection );
-    setFocusPolicy( QWidget::NoFocus );
-
-    setCurrentCell( -1, -1 );
 
-    connect( this, SIGNAL( pressed( int, int, int, const QPoint& ) ), this, SLOT( cellPressed( int, int ) ) );
-    connect( this, SIGNAL( clicked( int, int, int, const QPoint& ) ), this, SLOT( cellClicked( int, int ) ) );
+    setFocusPolicy( QWidget::NoFocus );
 
     holdTimer = new QTimer( this );
     connect( holdTimer, SIGNAL( timeout() ), this, SLOT( held() ) );
 
     flagAction = NoAction;
     ignoreClick = FALSE;
-    currRow = currCol = 0;
+    currRow = currCol = -1;
     minecount=0;
     mineguess=0;
     nonminecount=0;
+    cellSize = -1;
+    mines = 0;
 }
 
 MineField::~MineField()
 {
+    int i;
+    if ( mines )
+    {
+        for ( i = 0; i < numCols*numRows; i++ )
+        {
+            delete mines[i];
+        }
+        delete[] mines;
+    }
 }
 
 void MineField::setState( State st )
 {
     stat = st;
 }
 
-
 void MineField::setup( int level )
 {
     lev = level;
     setState( Waiting );
-    viewport()->setUpdatesEnabled( FALSE );
-
-    int cellsize;
-
-    int x; 
-    int y;
-    for ( x = 0; x < numCols(); x++ )
-        for ( y = 0; y < numRows(); y++ )
-            clearCell( y, x );
+    //viewport()->setUpdatesEnabled( FALSE );
+
+    int i;
+    if ( mines )
+    {
+        for ( i = 0; i < numCols*numRows; i++ )
+        {
+            delete mines[i];
+        }
+        delete[] mines;
+    }
 
     switch( lev ) {
     case 1:
-        setNumRows( 9 );
-        setNumCols( 9 );
+        numRows = 9 ;
+        numCols = 9 ;
         minecount = 12;
-        cellsize = 21;
         break;
     case 2:
-        setNumRows( 16 );
-        setNumCols( 16 );
+        numRows = 16;
+        numCols = 16;
         minecount = 45;
-        cellsize = 14;
         break;
     case 3:
-        setNumRows( 18 );
-        setNumCols( 18 );
+        numCols = 18;
+        numRows = 18;
         minecount = 66 ;
-        cellsize = 12;
         break;
     }
-    nonminecount = numRows()*numCols() - minecount;
+    mines = new (Mine*)[numRows*numCols];
+    for ( i = 0; i < numCols*numRows; i++ )
+        mines[i] = new Mine( this );
+
+
+    nonminecount = numRows*numCols - minecount;
     mineguess = minecount;
     emit mineCount( mineguess );
     Mine::paletteChange();
 
-    for ( y = 0; y < numRows(); y++ )
-        setRowHeight( y, cellsize );
-    for ( x = 0; x < numCols(); x++ )
-        setColumnWidth( x, cellsize );
-    for ( x = 0; x < numCols(); x++ )
-        for ( y = 0; y < numRows(); y++ )
-            setItem( y, x, new Mine( this ) );
-
+    if ( availableRect.isValid() )
+        setCellSize(findCellSize());
+    //    viewport()->setUpdatesEnabled( TRUE );
+    //viewport()->repaint( TRUE );
+    updateContents( 0, 0, numCols*cellSize, numRows*cellSize );
     updateGeometry();
-    viewport()->setUpdatesEnabled( TRUE );
-    viewport()->repaint( TRUE );
+}
+
+void MineField::drawContents( QPainter * p, int clipx, int clipy, int clipw, int cliph )
+{
+    int c1 = clipx / cellSize;
+    int c2 = ( clipx + clipw - 1 ) / cellSize;
+    int r1 = clipy / cellSize;
+    int r2 = ( clipy + cliph - 1 ) / cellSize;
+
+    for ( int c = c1; c <= c2 ; c++ ) {
+        for ( int r = r1; r <= r2 ; r++ ) {
+            int x = c * cellSize;
+            int y = r * cellSize;
+            Mine *m = mine( r, c );
+            if ( m )
+                m->paint( p, colorGroup(), QRect(x, y, cellSize, cellSize ) );
+        }
+    }
+}
+
+
+// Chicken and egg problem: We need to know how big the parent is
+// before we can decide how big to make the table.
+
+void MineField::setAvailableRect( const QRect &r )
+{
+    availableRect = r;
+    int newCellSize = findCellSize();
+    if ( newCellSize != cellSize ) {
+        viewport()->setUpdatesEnabled( FALSE );
+        setCellSize( newCellSize );
+        viewport()->setUpdatesEnabled( TRUE );
+        viewport()->repaint( TRUE );
+    }
+}
+
+int MineField::findCellSize()
+{
+    int w = availableRect.width() - 1;
+    int h = availableRect.height() - 1;
+    int cellsize;
+
+    cellsize = QMIN( w/numCols, h/numRows );
+    cellsize = QMIN( QMAX( cellsize, minGrid ), maxGrid );
+    return cellsize;
+}
+
+
+void MineField::setCellSize( int cellsize )
+{
+    cellSize = cellsize;
+
+    int w = availableRect.width();
+    int h = availableRect.height();
+
+    int w2 = cellsize*numCols;
+    int h2 = cellsize*numRows;
+
+    resizeContents( w2, h2 );
+
+    int b = 5;
+
+    setGeometry( availableRect.x() + (w-w2)/2, availableRect.y() + (h-h2)/2,
+                 w2+b, h2+b );
+        //       QMIN(w,w2+b), QMIN(h,h2+b) );
 }
 
 
 void MineField::placeMines()
 {
     int mines = minecount;
     while ( mines ) {
-        int col = int((double(rand()) / double(RAND_MAX)) * numCols());
-        int row = int((double(rand()) / double(RAND_MAX)) * numRows());
+        int col = int((double(rand()) / double(RAND_MAX)) * numCols);
+        int row = int((double(rand()) / double(RAND_MAX)) * numRows);
 
-        Mine* mine = (Mine*)item( row, col );
+        Mine* m = mine( row, col );
 
-        if ( mine && !mine->isMined() && mine->state() == Mine::Hidden ) {
-            mine->setMined( TRUE );
+        if ( m && !m->isMined() && m->state() == Mine::Hidden ) {
+            m->setMined( TRUE );
             mines--;
         }
     }
 }
 
-void MineField::paintFocus( QPainter*, const QRect& )
+
+void MineField::updateCell( int r, int c )
 {
+    updateContents( c*cellSize, r*cellSize, cellSize, cellSize );
 }
 
-void MineField::viewportMousePressEvent( QMouseEvent* e )
+
+void MineField::contentsMousePressEvent( QMouseEvent* e )
 {
-    QTable::viewportMousePressEvent( e );
+    int c = e->pos().x() / cellSize;
+    int r = e->pos().y() / cellSize;
+    if ( onBoard( r, c ) )
+        cellPressed( r, c );
+    else
+        currCol = currRow = -1;
 }
 
-void MineField::viewportMouseReleaseEvent( QMouseEvent* e )
+void MineField::contentsMouseReleaseEvent( QMouseEvent* e )
 {
-    QTable::viewportMouseReleaseEvent( e );
+    int c = e->pos().x() / cellSize;
+    int r = e->pos().y() / cellSize;
+    if ( onBoard( r, c ) && c == currCol && r == currRow )
+        cellClicked( r, c );
+    
+    
     if ( flagAction == FlagNext ) {
         flagAction = NoAction;
     }
 }
 
+
+
+/*
+ state == Waiting means no "hold"
+
+ 
+*/
+void MineField::cellPressed( int row, int col )
+{
+    if ( state() == GameOver ) 
+        return;
+    currRow = row;
+    currCol = col;
+    if ( state() == Playing )
+        holdTimer->start( 150, TRUE );
+}
+
+void MineField::held()
+{
+    flagAction = FlagNext;
+    updateMine( currRow, currCol );
+    ignoreClick = TRUE;
+}
+
+
+
+
 void MineField::keyPressEvent( QKeyEvent* e )
 {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     flagAction = ( e->key() == Key_Up ) ? FlagOn : NoAction;
 #else
     flagAction = ( ( e->state() & ShiftButton ) ==  ShiftButton ) ? FlagOn : NoAction;
 #endif
 }
 
 void MineField::keyReleaseEvent( QKeyEvent* )
 {
     flagAction = NoAction;
 }
 
 int MineField::getHint( int row, int col )
 {
     int hint = 0;
     for ( int c = col-1; c <= col+1; c++ )
         for ( int r = row-1; r <= row+1; r++ ) {
-            Mine* mine = (Mine*)item( r, c );
-            if ( mine && mine->isMined() )
+            Mine* m = mine( r, c );
+            if ( m && m->isMined() )
                 hint++;
         }
 
     return hint;
 }
 
-void MineField::setHint( Mine* mine )
+void MineField::setHint( int row, int col )
 {
-    if ( !mine )
+    Mine *m = mine( row, col );
+    if ( !m )
         return;
 
-    int row = mine->row();
-    int col = mine->col();
     int hint = getHint( row, col );
 
     if ( !hint ) {
         for ( int c = col-1; c <= col+1; c++ )
             for ( int r = row-1; r <= row+1; r++ ) {
-                Mine* mine = (Mine*)item( r, c );
-                if ( mine && mine->state() == Mine::Hidden ) {
-                    mine->activate( TRUE );
+                Mine* m = mine( r, c );
+                if ( m && m->state() == Mine::Hidden ) {
+                    m->activate( TRUE );
                     nonminecount--;
-                    setHint( mine );
+                    setHint( r, c );
                     updateCell( r, c );
                 }
             }
     }
 
-    mine->setHint( hint );
+    m->setHint( hint );
     updateCell( row, col );
 }
 
 /*
- state == Waiting means no "hold"
-
- 
-*/
-void MineField::cellPressed( int row, int col )
-{
-    if ( state() == GameOver ) 
-        return;
-    currRow = row;
-    currCol = col;
-    if ( state() == Playing )
-        holdTimer->start( 150, TRUE );
-}
-
-void MineField::held()
-{
-    flagAction = FlagNext;
-    updateMine( currRow, currCol );
-    ignoreClick = TRUE;
-}
-
-/*
   Only place mines after first click, since it is pointless to
   kill the player before the game has started.
 */
 
 void MineField::cellClicked( int row, int col )
 {
     if ( state() == GameOver )
         return;
     if ( state() == Waiting ) {
-        Mine* mine = (Mine*)item( row, col );
-        if ( !mine )
+        Mine* m = mine( row, col );
+        if ( !m )
             return;
-        mine->setState( Mine::Empty );
+        m->setState( Mine::Empty );
         nonminecount--;
         placeMines();
         setState( Playing );
         emit gameStarted();
         updateMine( row, col );
     } else { // state() == Playing
         holdTimer->stop();
         if ( ignoreClick )
             ignoreClick = FALSE;
         else
             updateMine( row, col );
     }
 }
 
 void MineField::updateMine( int row, int col )
 {
-    Mine* mine = (Mine*)item( row, col );
-    if ( !mine )
+    Mine* m = mine( row, col );
+    if ( !m )
         return;
 
-    bool wasFlagged = mine->state() == Mine::Flagged;
-    bool wasEmpty =  mine->state() == Mine::Empty;
+    bool wasFlagged = m->state() == Mine::Flagged;
+    bool wasEmpty =  m->state() == Mine::Empty;
     
-    mine->activate( flagAction == NoAction );
+    m->activate( flagAction == NoAction );
 
-    if ( mine->state() == Mine::Exploded ) {
+    if ( m->state() == Mine::Exploded ) {
         emit gameOver( FALSE );
         setState( GameOver );
         return;
-    } else if ( mine->state() == Mine::Empty ) {
-        setHint( mine );
+    } else if ( m->state() == Mine::Empty ) {
+        setHint( row, col );
         if ( !wasEmpty )
             nonminecount--;
     }
 
     if ( flagAction != NoAction ) {
-        if ( mine->state() == Mine::Flagged ) {
+        if ( m->state() == Mine::Flagged ) {
             --mineguess;
             emit mineCount( mineguess );
-            if ( mine->isMined() )
+            if ( m->isMined() )
                 --minecount;
         } else if ( wasFlagged ) {
             ++mineguess;
             emit mineCount( mineguess );
-            if ( mine->isMined() )
+            if ( m->isMined() )
                 ++minecount;
         }
     }
 
     updateCell( row, col );
 
     if ( !minecount && !mineguess || !nonminecount ) {
         emit gameOver( TRUE );
         setState( GameOver );
     }
 }
 
 void MineField::showMines()
 {
-    for ( int c = 0; c < numCols(); c++ )
-        for ( int r = 0; r < numRows(); r++ ) {
-            Mine* mine = (Mine*)item( r, c );
-            if ( !mine )
+    for ( int c = 0; c < numCols; c++ )
+        for ( int r = 0; r < numRows; r++ ) {
+            Mine* m = mine( r, c );
+            if ( !m )
                 continue;
-            if ( mine->isMined() && mine->state() == Mine::Hidden )
-                mine->setState( Mine::Mined );
-            if ( !mine->isMined() && mine->state() == Mine::Flagged )
-                mine->setState( Mine::Wrong );
+            if ( m->isMined() && m->state() == Mine::Hidden )
+                m->setState( Mine::Mined );
+            if ( !m->isMined() && m->state() == Mine::Flagged )
+                m->setState( Mine::Wrong );
 
             updateCell( r, c );
         }
 }
 
 void MineField::paletteChange( const QPalette &o )
 {
     Mine::paletteChange();
-    QTable::paletteChange( o );
+    QScrollView::paletteChange( o );
 }
 
 void MineField::writeConfig(Config& cfg) const
 {
     cfg.setGroup("Field");
     cfg.writeEntry("Level",lev);
     QString grid="";
     if ( stat == Playing ) {
-        for ( int x = 0; x < numCols(); x++ )
-            for ( int y = 0; y < numRows(); y++ ) {
+        for ( int x = 0; x < numCols; x++ )
+            for ( int y = 0; y < numRows; y++ ) {
                 char code='A'+(x*17+y*101)%21; // Reduce the urge to cheat
-                Mine* mine = (Mine*)item( y, x );
-                int st = (int)mine->state(); if ( mine->isMined() ) st+=5;
+                const Mine* m = mine( y, x );
+                int st = (int)m->state(); if ( m->isMined() ) st+=5;
                 grid += code + st;
             }
     }
     cfg.writeEntry("Grid",grid);
 }
 
 void MineField::readConfig(Config& cfg)
 {
     cfg.setGroup("Field");
     lev = cfg.readNumEntry("Level",1);
     setup(lev);
     flagAction = NoAction;
     ignoreClick = FALSE;
     currRow = currCol = 0;
     QString grid = cfg.readEntry("Grid");
     if ( !grid.isEmpty() ) {
         int i=0;
         minecount=0;
         mineguess=0;
-        for ( int x = 0; x < numCols(); x++ ) {
-            for ( int y = 0; y < numRows(); y++ ) {
+        for ( int x = 0; x < numCols; x++ ) {
+            for ( int y = 0; y < numRows; y++ ) {
                 char code='A'+(x*17+y*101)%21; // Reduce the urge to cheat
                 int st = (char)(QChar)grid[i++]-code;
-                Mine* mine = (Mine*)item( y, x );
+                Mine* m = mine( y, x );
                 if ( st >= 5 ) {
                     st-=5;
-                    mine->setMined(TRUE);
+                    m->setMined(TRUE);
                     minecount++;
                     mineguess++;
                 }
-                mine->setState((Mine::MineState)st);
-                switch ( mine->state() ) {
+                m->setState((Mine::MineState)st);
+                switch ( m->state() ) {
                   case Mine::Flagged:
-                    if (mine->isMined())
+                    if (m->isMined())
                         minecount--;
                     mineguess--;
                     break;
                   case Mine::Empty:
                     --nonminecount;
+                    break;
+                default:
+                    break;
                 }
             }
         }
-        for ( int x = 0; x < numCols(); x++ ) {
-            for ( int y = 0; y < numRows(); y++ ) {
-                Mine* mine = (Mine*)item( y, x );
-                if ( mine->state() == Mine::Empty )
-                    mine->setHint(getHint(y,x));
+        for ( int x = 0; x < numCols; x++ ) {
+            for ( int y = 0; y < numRows; y++ ) {
+                Mine* m = mine( y, x );
+                if ( m->state() == Mine::Empty )
+                    m->setHint(getHint(y,x));
             }
         }
     }
     setState( Playing );
     emit mineCount( mineguess );
 }