18 files changed, 18 insertions, 3 deletions

diff --git a/noncore/games/bounce/main.cpp b/noncore/games/bounce/main.cpp
index eb8d561..bec4a86 100644
--- a/noncore/games/bounce/main.cpp
+++ b/noncore/games/bounce/main.cpp
@@ -1,24 +1,25 @@
 /*
  * Copyright (C) 2000 Stefan Schimanski <schimmi@kde.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
  * License along with this program; if not, write to the Free
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include "kbounce.h"
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<KJezzball> )
 
diff --git a/noncore/games/buzzword/main.cpp b/noncore/games/buzzword/main.cpp
index 596cf16..a95e91a 100644
--- a/noncore/games/buzzword/main.cpp
+++ b/noncore/games/buzzword/main.cpp
@@ -1,23 +1,24 @@
 /*
  * Copyright (C) 2002 Martin Imobersteg <imm@gmx.ch>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License,Life or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
  * License along with this program; if not, write to the Free
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <opie2/oapplicationfactory.h>
 
 #include "buzzword.h"
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<BuzzWord> )
diff --git a/noncore/games/fifteen/main.cpp b/noncore/games/fifteen/main.cpp
index ed74a47..800a270 100644
--- a/noncore/games/fifteen/main.cpp
+++ b/noncore/games/fifteen/main.cpp
@@ -1,23 +1,24 @@
 /**********************************************************************
 ** Copyright (C) 2004 Holger Freyther.  All rights reserved.
 **
 ** This file is part of Opie 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.
 **
 **********************************************************************/
 
 #include "fifteen.h"
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP(  OApplicationFactory<FifteenMainWindow> )
 
diff --git a/noncore/games/go/gowidget.cpp b/noncore/games/go/gowidget.cpp
index 79820b1..d134540 100644
--- a/noncore/games/go/gowidget.cpp
+++ b/noncore/games/go/gowidget.cpp
@@ -1,460 +1,460 @@
 /**********************************************************************
 ** 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 "gowidget.h"
 
 #include <qpe/config.h>
 #include <qpe/resource.h>
 
 #include <qpainter.h>
-#include <qpe/qpetoolbar.h>
+#include <qtoolbar.h>
 #include <qmenubar.h>
 #include <qaction.h>
 #include <qapplication.h> //processEvents()
 #include <qlabel.h>
 
 //#include <stdio.h>
 
 
 static const enum bVal computer_color = BLACK;
 
 static int current_handicap = 1;
 
 static QBrush *goBrush;
 //static QImage *newBlackStone;
 //static QImage *blackStone;
 //static QImage *whiteStone;
 static QPixmap *newBlackStone;
 static QPixmap *blackStone;
 static QPixmap *whiteStone;
 
 static bool smallStones = FALSE;
 
 GoMainWidget::GoMainWidget( QWidget *parent, const char* name, WFlags fl) :
         QMainWindow( parent, name, fl )
 {
      setToolBarsMovable( FALSE );
     GoWidget *go = new GoWidget(this);
 
     setCentralWidget(go);
     toolbar = new QToolBar(this);
     toolbar->setHorizontalStretchable( TRUE );
     addToolBar(toolbar);
 
     QMenuBar *mb = new QMenuBar( toolbar );
     mb->setMargin(0);
     QPopupMenu *file = new QPopupMenu( this );
 
     QAction *a = new QAction( tr( "New Game" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), go, SLOT( newGame() ) );
     a->addTo( file );
 
     a = new QAction( tr( "Pass" ), Resource::loadPixmap( "pass" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), go, SLOT( pass() ) );
     a->addTo( file );
     a->addTo( toolbar );
 
 
     a = new QAction( tr( "Resign" ), Resource::loadPixmap( "reset" ), QString::null, 0, this, 0 );
     connect( a, SIGNAL( activated() ), go, SLOT( resign() ) );
     a->addTo( file );
 
     a = new QAction( tr( "Two player option" ),  QString::null, 0, this, 0 );
     a->setToggleAction( TRUE );
     connect( a, SIGNAL( toggled(bool) ), go, SLOT( setTwoplayer(bool) ) );
     a->addTo( file );
 
     mb->insertItem( tr( "Game" ), file );
 
     QLabel *turnLabel = new QLabel( toolbar );
     turnLabel->setBackgroundMode( PaletteButton );
     connect( go, SIGNAL(showTurn(const QPixmap&)),
              turnLabel, SLOT(setPixmap(const QPixmap&)) );
 
 
     QLabel * scoreLabel = new QLabel( toolbar );
     scoreLabel->setBackgroundMode( PaletteButton );
     connect( go, SIGNAL(showScore(const QString&)),
              scoreLabel, SLOT(setText(const QString&)) );
 
     toolbar->setStretchableWidget( scoreLabel );
 
     go->readConfig();
 }
 
 void GoMainWidget::resizeEvent( QResizeEvent * )
 {
     //### this won't work because of the text label...
     /*
     if ( width() > height() )
         moveToolBar( toolbar, Left );
     else
         moveToolBar( toolbar, Top );
     */
 }
 
 GoWidget *GoWidget::self = 0;
 
 GoWidget::GoWidget( QWidget *parent, const char* name) :
         QWidget( parent, name )
 {
     if ( self )
         fatal( "Only one Go widget allowed" );
     self = this;
     twoplayer = FALSE;
 
 
     d = bx = by = 1;
 
     QPixmap pix = Resource::loadPixmap( "go/pine" );
     goBrush = new QBrush( black, pix );
     /*
     QString fn = Resource::findPixmap("Go-black");
     blackStone = new QImage( fn );
     fn = Resource::findPixmap("Go-black-highlight");
     newBlackStone = new QImage( fn );
     fn = Resource::findPixmap("Go-white");
     whiteStone = new QImage( fn );
     */
     blackStone = new QPixmap(Resource::loadPixmap( "Go-black" ));
     whiteStone = new QPixmap(Resource::loadPixmap( "Go-white" ));
     newBlackStone = new QPixmap(Resource::loadPixmap( "Go-black-highlight" ));
 
     init();
 }
 
 GoWidget::~GoWidget()
 {
     writeConfig();
 }
 
 void GoWidget::writeConfig()
 {
     Config cfg("Go");
     cfg.setGroup("Game");
     cfg.writeEntry("TwoPlayer", twoplayer);
     cfg.writeEntry("CurrentPlayer", currentPlayer);
     cfg.writeEntry("NPassed", nPassed);
     QString b;
     for (int i=0; i<19; i++)
         for (int j=0; j<19; j++)
             b += board[i][j] == BLACK ? 'B' : board[i][j] == WHITE ? 'W' : '.';
     cfg.writeEntry("Board", b);
     cfg.writeEntry("LastX", lastX);
     cfg.writeEntry("LastY", lastY);
     extern int blackPrisoners, whitePrisoners;
     cfg.writeEntry("BlackPrisoners", blackPrisoners);
     cfg.writeEntry("WhitePrisoners", whitePrisoners);
 }
 
 void GoWidget::readConfig()
 {
     init();
     Config cfg("Go");
     cfg.setGroup("Game");
     twoplayer = cfg.readBoolEntry("TwoPlayer");
     currentPlayer = (bVal)cfg.readNumEntry("CurrentPlayer",1);
     nPassed = cfg.readNumEntry("NPassed",0);
     QString b = cfg.readEntry("Board");
     if ( b.length() == 19*19 )
         for (int i=0; i<19; i++)
             for (int j=0; j<19; j++) {
                 QChar ch = b[j+19*i];
                 if ( ch != '.' )
                     GoPlaceStone( ch == 'B' ? BLACK : WHITE, i, j );
             }
     lastX = cfg.readNumEntry("LastX");
     lastY = cfg.readNumEntry("LastY");
     extern int blackPrisoners, whitePrisoners;
     blackPrisoners = cfg.readNumEntry("BlackPrisoners",0);
     whitePrisoners = cfg.readNumEntry("WhitePrisoners",0);
     reportPrisoners(blackPrisoners,whitePrisoners);
     emit showTurn( currentPlayer == WHITE ? *whiteStone : *blackStone );
 }
 
 void GoWidget::resizeEvent( QResizeEvent * )
 {
     d = QMIN(width(),height())/19;
     //    int r = (d/2-1);
     bx = (width() - 18*d)/2 ;
     by = (height() - 18*d)/2 ;
 
     if ( d < 10 && !smallStones ) {
         blackStone->convertFromImage( blackStone->convertToImage().smoothScale(8,8) );
         whiteStone->convertFromImage( whiteStone->convertToImage().smoothScale(8,8) );
         newBlackStone->convertFromImage( newBlackStone->convertToImage().smoothScale(8,8) );
 
         smallStones = TRUE;
     } else if ( d >= 10 && smallStones ) {
         blackStone = new QPixmap(Resource::loadPixmap( "Go-black" ));
         whiteStone = new QPixmap(Resource::loadPixmap( "Go-white" ));
         newBlackStone = new QPixmap(Resource::loadPixmap( "Go-black-highlight" ));
         smallStones = FALSE;
     }
 }
 
 void GoWidget::init()
 {
     lastX = lastY = newX = newY = -1;
     nPassed = 0;
     for ( int i = 0; i < 19; i++ )
         for ( int j = 0; j < 19; j++ )
             board[i][j]=-1;
     gameActive = TRUE;
     goRestart(current_handicap);
 
     if ( twoplayer ) {
         currentPlayer = BLACK;
     } else {
         doComputerMove();
         currentPlayer = WHITE;
     }
     emit showTurn( currentPlayer == WHITE ? *whiteStone : *blackStone );
 }
 
 void GoWidget::paintEvent( QPaintEvent *e )
 {
     int i,j;
 
     int r = whiteStone->width()/2;
 
     QPainter p(this);
     p.fillRect( bx - d/2, by - d/2, 19*d, 19*d, *goBrush );
 
     int xMin = QMAX( x2board(e->rect().left()), 0 );
     int xMax = QMIN( x2board(e->rect().right()), 18 );
     int yMin = QMAX( y2board(e->rect().top()), 0 );
     int yMax = QMIN( y2board(e->rect().bottom()), 18 );
 
     QColor pine( 255, 186, 89 );
     p.setPen( pine.dark() );
 
     for ( i = xMin; i < xMax+1 ; i ++ ) {
         p.drawLine( bx+i*d, by, bx+i*d, by+18*d );
     }
     for ( j = yMin; j < yMax+1 ; j ++ ) {
         p.drawLine( bx, by+j*d, bx+18*d, by+j*d);
     }
 
     // dots are at (3,3), (3,9), (3,15) and so on
     p.setBrush( black );
     for ( i = 3; i < xMax+1; i+=6 )
         for ( j = 3; j < yMax+1; j+=6 )
             p.drawEllipse( bx+i*d-2, by+j*d-2, 5, 5 );
 
 
     for ( i = xMin; i < xMax+1; i++ )
         for ( j = yMin; j < yMax+1; j++ ) {
             if ( board[i][j] == WHITE ||
                  currentPlayer==WHITE && newX == i && newY == j )
                 p.drawPixmap( bx+i*d - r, by+j*d - r, *whiteStone );
             else if ( i == lastX && j == lastY )
                 p.drawPixmap( bx+i*d - r, by+j*d - r, *newBlackStone );
             else if ( board[i][j] == BLACK ||
                       currentPlayer==BLACK && newX == i && newY == j)
                 p.drawPixmap( bx+i*d - r, by+j*d - r, *blackStone );
         }
 }
 
 void GoWidget::doMove( int x, int y )
 {
 
     if ( !GoPlaceStone( currentPlayer, x, y ) ) {
         //printf( "Illegal move (%d,%d)\n", x, y );
         return;
     }
     //printf( "you do (%d,%d)\n", x, y );
     nPassed = 0;
     if ( twoplayer )
         currentPlayer = (currentPlayer==WHITE) ? BLACK : WHITE;
     else
         doComputerMove();
 
     emit showTurn( currentPlayer == WHITE ? *whiteStone : *blackStone );
 
 }
 
 void GoWidget::pass()
 {
     if ( !gameActive )
         return;
     nPassed++;
     if ( nPassed >= 2 )
         endGame();
     else if ( !twoplayer )
         doComputerMove();
 }
 
 void GoWidget::resign()
 {
     if ( gameActive )
         endGame();
 }
 
 
 void GoWidget::newGame()
 {
     init();
     update();
 }
 
 
 void GoWidget::endGame()
 {
     gameActive = FALSE;
 
     int w,b;
     CountUp( &w, &b);
     QString s = tr("White %1, Black %2. ").arg(w).arg(b);
     if ( w > b )
         s += tr("White wins.");
     else if ( w < b )
         s += tr("Black wins.");
     else
         s += tr("A draw.");
     emit showScore( s );
 }
 
 void GoWidget::doComputerMove()
 {
     int ox = lastX;
     int oy = lastY;
     lastX = lastY = -1;
     emit showTurn( *blackStone );
     refresh( ox, oy);
     qApp->processEvents();
     short int x,y;
     if ( genMove( computer_color, &x, &y ) ) {
         lastX = x;
         lastY = y;
         //printf( "I do (%d,%d)\n", x, y );
         GoPlaceStone(computer_color,x,y);
         nPassed = 0;
     } else {
         emit showScore( tr("I pass") );
         nPassed++;
         if ( nPassed >= 2 )
             endGame();
     }
 }
 
 void GoWidget::mousePressEvent( QMouseEvent *me )
 {
     if ( !gameActive )
         return;
     int x = x2board(me->x());
     int y = y2board(me->y());
     showStone(x,y,currentPlayer);
 }
 
 void GoWidget::mouseMoveEvent( QMouseEvent *me )
 {
     if ( !gameActive )
         return;
     int x = x2board(me->x());
     int y = y2board(me->y());
     if ( x != newX || y != newY )
         showStone(x,y,currentPlayer);
 }
 
 void GoWidget::showStone( int x, int y, enum bVal c )
 {
 
     if ( newX > -1 ) {
         refresh( newX, newY );
         newY = newX = -1;
     }
     if ( x < 0 || x > 18 || y < 0 || y > 18 ) {
         newX = newY = -1;
         return;
     }
     if ( board[x][y] == -1 && !Suicide( c, x, y ) ) {
         newX = x;
         newY = y;
         refresh(x,y);
     }
 
 }
 
 void GoWidget::mouseReleaseEvent( QMouseEvent * )
 {
     if ( gameActive && newX > -1 )
         doMove( newX, newY );
     newX = newY = -1;
 }
 
 void GoWidget::refresh( int x, int y )
 {
     update( bx+d*x-d/2-1, by+d*y-d/2-1, d+2, d+2 );
 }
 
 void GoWidget::removeStone(short x, short y)
 {
     board[x][y]=-1;
     refresh( x, y );
 }
 
 void GoWidget::placeStone (enum bVal c, short x, short y )
 {
     board[x][y]=c;
     refresh( x, y );
 }
 
 void GoWidget::reportPrisoners( int blackcnt, int whitecnt )
 {
     QString s = tr( "Prisoners: black %1, white %2" ).arg(blackcnt).arg(whitecnt);
     emit showScore( s );
 }
 
 void GoWidget::setTwoplayer( bool b )
 {
     twoplayer = b;
 }
 
 void GoWidget::setHandicap( int h )
 {
     current_handicap = h;
 }
 
 
 extern "C" {
 
         voidremovestone(short x, short y)
 {
     GoWidget::self->removeStone(x,y);
 }
 
         voidplacestone (enum bVal c, short x, short y )
 {
     GoWidget::self->placeStone(c,x,y);
 }
 
         voidintrMoveReport(enum bVal c ,char *coord ,char *reason )
 {
     qDebug( "intrMoveReport colour %d, %s %s", c, coord, reason );
 }
 
         voidintrPrisonerReport( short blackcnt, short whitecnt )
 {
     GoWidget::self->reportPrisoners(blackcnt,whitecnt);
 }
 
 }
 
diff --git a/noncore/games/go/main.cpp b/noncore/games/go/main.cpp
index 46817d1..f6bb813 100644
--- a/noncore/games/go/main.cpp
+++ b/noncore/games/go/main.cpp
@@ -1,27 +1,28 @@
 /**********************************************************************
 ** 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 "gowidget.h"
 
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<GoMainWidget> )
 
diff --git a/noncore/games/kcheckers/main.cpp b/noncore/games/kcheckers/main.cpp
index 79b5ac7..8c708e2 100644
--- a/noncore/games/kcheckers/main.cpp
+++ b/noncore/games/kcheckers/main.cpp
@@ -1,9 +1,10 @@
 
 
 #include "kcheckers.h"
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<KCheckers> )
 
 
diff --git a/noncore/games/minesweep/main.cpp b/noncore/games/minesweep/main.cpp
index f3070f5..629afbf 100644
--- a/noncore/games/minesweep/main.cpp
+++ b/noncore/games/minesweep/main.cpp
@@ -1,26 +1,27 @@
 /**********************************************************************
 ** 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 "minesweep.h"
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<MineSweep> )
 
diff --git a/noncore/games/parashoot/main.cpp b/noncore/games/parashoot/main.cpp
index 81d513d..da21c25 100644
--- a/noncore/games/parashoot/main.cpp
+++ b/noncore/games/parashoot/main.cpp
@@ -1,26 +1,27 @@
 /**********************************************************************
 ** 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 "interface.h"
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<ParaShoot> )
 
diff --git a/noncore/games/qasteroids/main.cpp b/noncore/games/qasteroids/main.cpp
index 33e4729..6ddb238 100644
--- a/noncore/games/qasteroids/main.cpp
+++ b/noncore/games/qasteroids/main.cpp
@@ -1,26 +1,27 @@
 /**********************************************************************
 ** 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 "toplevel.h"
 
 #include <opie2/oapplicationfactory.h>
 
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<KAstTopLevel> )
diff --git a/noncore/games/snake/interface.cpp b/noncore/games/snake/interface.cpp
index b5fb5bf..9d9550a 100644
--- a/noncore/games/snake/interface.cpp
+++ b/noncore/games/snake/interface.cpp
@@ -1,219 +1,219 @@
 /**********************************************************************
 ** 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 "interface.h"
 
 #include <qpe/resource.h>
 
-#include <qpe/qpetoolbar.h>
+#include <qtoolbar.h>
 #include <qtoolbutton.h>
 
 SnakeGame::SnakeGame(QWidget* parent, const char* name, WFlags f) :
     QMainWindow(parent,name,f),
     canvas(232, 258)
 {
     setCaption( tr("Snake") );
     QPEApplication::setInputMethodHint(this, QPEApplication::AlwaysOff );
     QPixmap bg = Resource::loadPixmap("snake/grass");
     canvas.setBackgroundPixmap(bg);
     canvas.setUpdatePeriod(100);
     snake = 0;
 
     cv = new QCanvasView(&canvas, this);
 
     pauseTimer = new QTimer(this);
     connect(pauseTimer, SIGNAL(timeout()), this, SLOT(wait()) );
 
     setToolBarsMovable( FALSE );
 
     QToolBar* toolbar = new QToolBar( this);
     toolbar->setHorizontalStretchable( TRUE );
 
     QPixmap newicon = Resource::loadPixmap("ksnake");
     setIcon(newicon);
     (void)new QToolButton(newicon, tr("New Game"), 0,
                             this, SLOT(newGame()), toolbar, "New Game");
 
     scorelabel = new QLabel(toolbar);
     showScore(0);
     scorelabel->setBackgroundMode( PaletteButton );
     scorelabel->setAlignment( AlignRight | AlignVCenter | ExpandTabs );
     toolbar->setStretchableWidget( scorelabel );
 
     setFocusPolicy(StrongFocus);
 
     setCentralWidget(cv);
 
     QTimer::singleShot( 16, this, SLOT(welcomescreen()) );
     gamestopped = true;
     waitover = true;
 }
 
 SnakeGame::~SnakeGame()
 {
    delete snake;
 }
 
 void SnakeGame::resizeEvent(QResizeEvent *)
 {
     QSize s = centralWidget()->size();
     int fw = style().defaultFrameWidth();
     canvas.resize( s.width() - fw - 2, s.height() - fw - 2);
 }
 
 void SnakeGame::welcomescreen()
 {
    QCanvasText* title = new QCanvasText(tr("SNAKE!"), &canvas);
    title->setColor(yellow);
    title->setFont( QFont("times", 18, QFont::Bold) );
    int w = title->boundingRect().width();
    title->move(canvas.width()/2 -w/2, canvas.height()/2-110);
    title->show();
    QCanvasPixmapArray* titlearray = new QCanvasPixmapArray(Resource::findPixmap("snake/title"));
    QCanvasSprite* titlepic = new QCanvasSprite(titlearray, &canvas);
    titlepic->move(canvas.width()/2 - 33, canvas.height()/2-85);
    titlepic->show();
    QCanvasText* instr = new QCanvasText(tr("Use the arrow keys to guide the\n"
                                   "snake to eat the mouse. You must not\n"
                                   "crash into the walls, edges or its tail."),
                                         &canvas);
    w = instr->boundingRect().width();
    instr->move(canvas.width()/2-w/2, canvas.height()/2-20);
    instr->setColor(white);
    instr->show();
    QCanvasText* cont = new QCanvasText(tr("Press any key to start"), &canvas);
    w = cont->boundingRect().width();
    cont->move(canvas.width()/2-w/2, canvas.height()-20);
    cont->setColor(yellow);
    cont->show();
 
 }
 
 void SnakeGame::newGame()
 {
     clear();
     snake = new Snake(&canvas);
     connect(snake, SIGNAL(dead()), this, SLOT(gameOver()) );
     connect(snake, SIGNAL(targethit()), this, SLOT(levelUp()) );
     connect(snake, SIGNAL(scorechanged()), this, SLOT(scoreInc()) );
     connect(this, SIGNAL(moveFaster()), snake, SLOT(increaseSpeed()) );
     last = 0;
     targetamount = 1;
     notargets = 1;
     level = 1;
     stage = 1;
     showScore(0);
     gamestopped = false;
     waitover = true;
     int y = canvas.height()-50;
     (void)new Obstacle(&canvas, 32);
     (void)new Obstacle(&canvas, y);
     createTargets();
 }
 
 
 void SnakeGame::showScore(int score)
 {
     scorelabel->setText(tr("     Score :    %1   ").arg(score) );
 }
 
 
 void SnakeGame::scoreInc()
 {
    showScore( snake->getScore() );
 }
 
 void SnakeGame::levelUp()
 {
    notargets--;
    if (notargets == 0) {
         stage++;
        if (stage == 3) {
           level++;
           emit moveFaster();
           targetamount++;
           stage = 0;
        }
        createTargets();
    }
 }
 
 void SnakeGame::createTargets()
 {
    for (int i = 0; i < targetamount; i++)
        (void)new Target(&canvas);
    notargets = targetamount;
 }
 
 void SnakeGame::clear()
 {
    delete snake;
    snake = 0;
    QCanvasItemList l = canvas.allItems();
    for (QCanvasItemList::Iterator it=l.begin(); it!=l.end(); ++it) {
         delete *it;
    }
 }
 
 void SnakeGame::gameOver()
 {
    int score = snake->getScore();
    QString scoreoutput="";
    scoreoutput.setNum(score);
    QCanvasText* gameover = new QCanvasText(tr("GAME OVER!\n Your Score: %1").arg( scoreoutput), &canvas);
 
    gameover->setZ(100);
    gameover->setColor(yellow);
    gameover->setFont( QFont("times", 18, QFont::Bold) );
    int w = gameover->boundingRect().width();
    gameover->move(canvas.width()/2 -w/2, canvas.height()/2 -50);
    gameover->show();
    gamestopped = true;
    waitover = false;
    pauseTimer->start(1500);
 }
 
 void SnakeGame::wait()
 {
    waitover = true;
    pauseTimer->stop();
    QCanvasText* cont = new QCanvasText(tr("Press any key to begin a new game."),
                                        &canvas);
    cont->setZ(100);
    cont->setColor(white);
    int w = cont->boundingRect().width();
    cont->move(canvas.width()/2 -w/2, canvas.height()/2);
    cont->show();
 }
 
 void SnakeGame::keyPressEvent(QKeyEvent* event)
 {
    if (gamestopped) {
         if (waitover)
            newGame();
         else
            return;
    }
    else {
        int newkey = event->key();
        snake->go(newkey);
    }
 }
 
diff --git a/noncore/games/snake/main.cpp b/noncore/games/snake/main.cpp
index 44f742f..81eb9ee 100644
--- a/noncore/games/snake/main.cpp
+++ b/noncore/games/snake/main.cpp
@@ -1,28 +1,29 @@
 /**********************************************************************
 ** 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 "interface.h"
 
 #include <opie2/oapplicationfactory.h>
 
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<SnakeGame> )
 
 
diff --git a/noncore/games/solitaire/main.cpp b/noncore/games/solitaire/main.cpp
index d4f6673..c8d4040 100644
--- a/noncore/games/solitaire/main.cpp
+++ b/noncore/games/solitaire/main.cpp
@@ -1,25 +1,26 @@
 /**********************************************************************
 ** 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 "canvascardwindow.h"
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<CanvasCardWindow> )
\ No newline at end of file
diff --git a/noncore/games/tetrix/main.cpp b/noncore/games/tetrix/main.cpp
index 147d13d..6194bbf 100644
--- a/noncore/games/tetrix/main.cpp
+++ b/noncore/games/tetrix/main.cpp
@@ -1,27 +1,28 @@
 /**********************************************************************
 ** 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 "qtetrix.h"
 
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<QTetrix> )
 
diff --git a/noncore/games/tictac/main.cpp b/noncore/games/tictac/main.cpp
index b8193f7..f3df375 100644
--- a/noncore/games/tictac/main.cpp
+++ b/noncore/games/tictac/main.cpp
@@ -1,13 +1,14 @@
 /****************************************************************************
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of an example program for Qt.  This example
 ** program may be used, distributed and modified without limitation.
 **
 *****************************************************************************/
 
 #include "tictac.h"
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<TicTacToe> )
diff --git a/noncore/games/wordgame/main.cpp b/noncore/games/wordgame/main.cpp
index 7fd5f50..c388775 100644
--- a/noncore/games/wordgame/main.cpp
+++ b/noncore/games/wordgame/main.cpp
@@ -1,27 +1,28 @@
 /**********************************************************************
 ** 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 "wordgame.h"
 
 #include <opie2/oapplicationfactory.h>
 
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<WordGame> )
 
diff --git a/noncore/games/wordgame/wordgame.cpp b/noncore/games/wordgame/wordgame.cpp
index 43a54f8..a80bd35 100644
--- a/noncore/games/wordgame/wordgame.cpp
+++ b/noncore/games/wordgame/wordgame.cpp
@@ -1,1510 +1,1510 @@
 /**********************************************************************
 ** 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 "wordgame.h"
 
 #include <qpe/global.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 
 #include <qapplication.h>
 #include <qmessagebox.h>
 #include <qcombobox.h>
 #include <qdir.h>
 #include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qtextstream.h>
 #include <qtimer.h>
-#include <qpe/qpetoolbar.h>
+#include <qtoolbar.h>
 #include <qtoolbutton.h>
 #include <qvbox.h>
 #include <qwidgetstack.h>
 #include <qlayout.h>
 
 #include <stdlib.h>
 #include <unistd.h>
 #include <pwd.h>
 #include <sys/types.h>
 
 enum RuleEffects {
     Multiplier=15,
     MultiplyAll=64,
     Start=128
 };
 
 static int tile_smallw = 16;
 static int tile_smallh = 16;
 static int tile_bigw = 22;
 static int tile_bigh = 22;
 static int tile_stweak = -2;
 static int tile_btweak = -1;
 
 static const int rack_tiles=7;
 
 const char* sampleWGR=
         "wordgame_shapes\n"
         "15 15\n"
         "400001040100004\n"
         "030000000000030\n"
         "002002000200200\n"
         "000300020003000\n"
         "000020000020000\n"
         "102001000100201\n"
         "000000202000000\n"
         "400200050002004\n"
         "000000202000000\n"
         "102001000100201\n"
         "000020000020000\n"
         "000300020003000\n"
         "002002000200200\n"
         "030000000000030\n"
         "400001040100004\n"
         "1 2 3 66 67 194 100 0\n"
         "1 j 8\n"
         "1 q 7\n"
         "1 x 6\n"
         "1 z 6\n"
         "1 w 4\n"
         "1 k 4\n"
         "1 v 3\n"
         "1 f 3\n"
         "2 y 3\n"
         "2 h 2\n"
         "2 b 2\n"
         "2 m 2\n"
         "3 p 2\n"
         "3 g 2\n"
         "3 u 2\n"
         "4 d 2\n"
         "4 c 2\n"
         "5 l 1\n"
         "5 o 1\n"
         "7 t 1\n"
         "7 n 1\n"
         "7 a 1\n"
         "7 r 1\n"
         "8 s 1\n"
         "8 i 1\n"
         "11 e 1\n"
         "0\n";
 
 WordGame::WordGame( QWidget* parent, const char* name, WFlags fl ) :
     QMainWindow(parent, name, fl)
 {
     if ( qApp->desktop()->width() < 240 ) {
         tile_smallw = 10;
         tile_smallh = 10;
         tile_bigw = 16;
         tile_bigh = 16;
         tile_stweak = 0;
         tile_btweak = 0;
     }
 
     setIcon( Resource::loadPixmap( "wordgame/WordGame.png" ) );
     setCaption( tr("Word Game") );
 
     setToolBarsMovable( FALSE );
     vbox = new QVBox(this);
 
     setCentralWidget(vbox);
     toolbar = new QToolBar(this);
     addToolBar(toolbar, Bottom);
     reset = new QToolButton(Resource::loadPixmap("back"), tr("Back"), "", this, SLOT(resetTurn()), toolbar);
     done = new QToolButton(Resource::loadPixmap("done"), tr("Done"), "", this, SLOT(endTurn()), toolbar);
     scoreinfo = new ScoreInfo(toolbar);
     scoreinfo->setFont(QFont("Helvetica",10));
     new QToolButton(Resource::loadPixmap("finish"), tr("Close"), "", this, SLOT(endGame()), toolbar);
     toolbar->setStretchableWidget(scoreinfo);
 
     cpu = 0;
     board = 0;
     bag = 0;
     racks = 0;
 
     aiheart = new QTimer(this);
     connect(aiheart, SIGNAL(timeout()), this, SLOT(think()));
 
     readConfig();
 }
 
 WordGame::~WordGame()
 {
     writeConfig();
 }
 
 void WordGame::writeConfig()
 {
     Config cfg("WordGame");
     cfg.setGroup("Game");
     cfg.writeEntry("NameList",namelist,';');
     cfg.writeEntry("CurrentPlayer",gameover ? 0 : player+1);
     if ( !gameover ) {
         cfg.writeEntry("Rules",rules);
         bag->writeConfig(cfg);
         board->writeConfig(cfg);
         scoreinfo->writeConfig(cfg);
     }
     for (int p=0; p<nplayers; p++) {
         cfg.setGroup("Player"+QString::number(p+1));
         if ( gameover ) cfg.clearGroup(); else rack(p)->writeConfig(cfg);
     }
 }
 
 void WordGame::readConfig()
 {
     Config cfg("WordGame");
     cfg.setGroup("Game");
     int currentplayer = cfg.readNumEntry("CurrentPlayer",0);
     QStringList pnames = cfg.readListEntry("NameList",';');
     if ( currentplayer ) {
         gameover = FALSE;
         rules = cfg.readEntry("Rules");
         if ( rules.find("x-wordgamerules") >= 0 ) {
             // rules files moved
             rules = "Sample.rules";
         }
         if ( loadRules(rules) ) {
             startGame(pnames);
             bag->readConfig(cfg);
             board->readConfig(cfg);
             scoreinfo->readConfig(cfg);
             for (int p=0; p<nplayers; p++) {
                 cfg.setGroup("Player"+QString::number(p+1));
                 rack(p)->readConfig(cfg);
             }
             player=currentplayer-1;
             readyRack(player);
             return;
         }
     }
     // fall-back
     openGameSelector(pnames);
 }
 
 void WordGame::openGameSelector(const QStringList& initnames)
 {
     toolbar->hide();
     gameover = FALSE;
 
     delete board;
     board = 0;
     delete racks;
     racks = 0;
 
     delete cpu;
     cpu = 0;
 
     newgame = new NewGame(vbox);
 
     //Rules rules(this);
     //connect(game.editrules, SIGNAL(clicked()), &rules, SLOT(editRules()));
     //connect(&rules, SIGNAL(rulesChanged()), &game, SLOT(updateRuleSets()));
     struct passwd* n = getpwuid(getuid());
     QString playername = n ? n->pw_name : "";
     if ( playername.isEmpty() ) {
         playername = "Player";
     }
     newgame->player0->changeItem(playername,0);
     newgame->player1->setCurrentItem(1);
     newgame->updateRuleSets();
     newgame->show();
 
     connect(newgame->buttonOk, SIGNAL(clicked()), this, SLOT(startGame()));
 }
 
 void WordGame::startGame()
 {
     rules = newgame->ruleslist[newgame->rules->currentItem()];
     if ( loadRules(rules) ) {
         QStringList names;
         names.append(newgame->player0->currentText());
         names.append(newgame->player1->currentText());
         names.append(newgame->player2->currentText());
         names.append(newgame->player3->currentText());
         names.append(newgame->player4->currentText());
         names.append(newgame->player5->currentText());
         delete newgame;
         startGame(names);
     } else {
         // error...
         delete newgame;
         close();
     }
 }
 
 void WordGame::startGame(const QStringList& playerlist)
 {
     toolbar->show();
     racks = new QWidgetStack(vbox);
     racks->setFixedHeight(TileItem::bigHeight()+2);
     namelist.clear();
     nplayers=0;
     for (QStringList::ConstIterator it=playerlist.begin(); it!=playerlist.end(); ++it)
         addPlayer(*it);
     scoreinfo->init(namelist);
 
     if ( nplayers ) {
         player=0;
         readyRack(player);
     }
 
     board->show();
     racks->show();
 }
 
 bool WordGame::loadRules(const QString &name)
 {
     QString filename = Global::applicationFileName( "wordgame", name );
     QFile file( filename );
     if ( !file.open( IO_ReadOnly ) )
         return FALSE;
 
     QTextStream ts( &file );
 
     QString title = name;
     title.truncate( title.length() - 6 );
     //setCaption( title );
 
     QString shapepixmap;
     ts >> shapepixmap;
     int htiles,vtiles;
     ts >> htiles >> vtiles;
 
     if ( htiles < 3 || vtiles < 3 )
         return FALSE;
 
     QString rule_shapes;
     for (int i=0; i<vtiles; i++) {
         QString line;
         ts >> line;
         rule_shapes += line;
     }
     static int rule_effects[12];
     int re=0,e;
     ts >> e;
     while ( e && re < 10 ) {
         rule_effects[re] = e;
         if ( re++ < 10 ) ts >> e;
     }
 
     QImage shim = Resource::loadImage("wordgame/wordgame_shapes");
     shim = shim.smoothScale((re-1)*TileItem::smallWidth(),TileItem::smallHeight());
     QPixmap bgshapes;
     bgshapes.convertFromImage(shim);
 
     rule_effects[re++] = 100; // default bonus
     board = new Board(bgshapes, htiles, vtiles, vbox);
     board->setRules(rule_shapes, rule_effects);
     connect(board, SIGNAL(temporaryScore(int)), scoreinfo, SLOT(showTemporaryScore(int)));
 
     bag = new Bag;
 
     int count;
     ts >> count;
     while ( count ) {
         QString text;
         int value;
         ts >> text >> value;
         if ( text == "_" )
             text = "";
 
         Tile t(text, value);
         for (int n=count; n--; )
             bag->add(t);
 
         ts >> count;
     }
 
     return TRUE;
 }
 
 
 NewGame::NewGame(QWidget* parent) :
     NewGameBase(parent)
 {
 }
 
 void NewGame::updateRuleSets()
 {
     rules->clear();
 
     QString rulesDir = Global::applicationFileName( "wordgame", "" );
     QDir dir( rulesDir, "*.rules" );
     ruleslist = dir.entryList();
     if ( ruleslist.isEmpty() ) {
         // Provide a sample
         QFile file( rulesDir + "Sample.rules" );
         if ( file.open( IO_WriteOnly ) ) {
             file.writeBlock( sampleWGR, strlen(sampleWGR) );
             file.close();
             updateRuleSets();
         }
         return;
     }
     int newest=0;
     int newest_age=INT_MAX;
     QDateTime now = QDateTime::currentDateTime();
     QStringList::Iterator it;
     for ( it = ruleslist.begin(); it != ruleslist.end(); ++it ) {
         QFileInfo fi((*it));
         int age = fi.lastModified().secsTo(now);
         QString name = *it;
         name.truncate( name.length()-6 ); // remove extension
         rules->insertItem( name );
         if ( age < newest_age ) {
             newest_age = age;
             newest = rules->count()-1;
         }
     }
     rules->setCurrentItem(newest);
 }
 
 Rules::Rules(QWidget* parent) :
     RulesBase(parent,0,TRUE)
 {
 }
 
 void Rules::editRules()
 {
     if ( exec() ) {
         // ### create a new set of rules
         emit rulesChanged();
     }
 }
 
 void Rules::deleteRuleSet()
 {
     // ### delete existing rule set
     emit rulesChanged();
 }
 
 void WordGame::addPlayer(const QString& name)
 {
     if ( !name.isEmpty() ) {
         int colon = name.find(':');
         int cpu = (colon >=0 && name.left(2) == "AI") ? name.mid(2,1).toInt() : 0;
         addPlayer(name,cpu);
     }
 }
 
 void WordGame::addPlayer(const QString& name, int cpu)
 {
     Rack* r = new Rack(rack_tiles,racks);
     r->setPlayerName(name);
     r->setComputerization(cpu);
     racks->addWidget(r, nplayers);
     refillRack(nplayers);
     namelist.append(name);
 
     ++nplayers;
 }
 
 void WordGame::nextPlayer()
 {
     if ( !refillRack(player) ) {
         endGame();
     } else {
         player = (player+1)%nplayers;
         scoreinfo->setBoldOne(player);
         readyRack(player);
     }
 }
 
 bool WordGame::mayEndGame()
 {
     int out=-1;
     int i;
     for (i=0; i<nplayers; i++)
         if ( !rack(i)->count() )
             out = i;
     if ( out<0 ) {
         if ( QMessageBox::warning(this,tr("End game"),
                                   tr("Do you want to end the game early?"), 
                                   tr("Yes"), tr("No") )!=0 )
         {
             return FALSE;
         }
     }
     return TRUE;
 }
 
 void WordGame::endGame()
 {
     if ( gameover ) {
         close();
         return;
     }
 
     if ( !mayEndGame() )
         return;
     int out=-1;
     int totalleft=0;
     int i;
     for (i=0; i<nplayers; i++) {
         Rack* r = rack(i);
         int c = r->count();
         if ( c ) {
             int lose=0;
             for ( int j=0; j<c; j++ )
                 lose += r->tileRef(j)->value();
             totalleft += lose;
             scoreinfo->addScore(i,-lose);
         } else {
             out = i;
         }
     }
     int highest=0;
     int winner=0;
     for (i=0; i<nplayers; i++) {
         int s = scoreinfo->playerScore(i);
         if ( s > highest ) {
             highest = s;
             winner = i;
         }
     }
     if ( out >= 0 )
         scoreinfo->addScore(out,totalleft);
     scoreinfo->setBoldOne(winner);
     gameover = TRUE;
     done->setEnabled(TRUE);
     reset->setEnabled(FALSE);
 }
 
 void WordGame::endTurn()
 {
     if ( gameover ) {
         openGameSelector(namelist);
     } else {
         if ( board->checkTurn() ) {
             if ( board->turnScore() >= 0 ) {
                 scoreinfo->addScore(player,board->turnScore());
                 board->finalizeTurn();
             } else {
                 QApplication::beep();
             }
             nextPlayer();
         }
     }
 }
 
 void WordGame::resetTurn()
 {
     board->resetRack();
 }
 
 void WordGame::passTurn()
 {
     // ######## trade?
     nextPlayer();
 }
 
 bool WordGame::refillRack(int i)
 {
     Rack* r = rack(i);
     while ( !bag->isEmpty() && !r->isFull() ) {
         r->addTile(bag->takeRandom());
     }
     return r->count() != 0;
 }
 
 void WordGame::readyRack(int i)
 {
     Rack* r = rack(i);
     racks->raiseWidget(i);
     board->setCurrentRack(r);
 
     done->setEnabled( !r->computerized() );
     reset->setEnabled( !r->computerized() );
 
     if ( r->computerized() ) {
         cpu = new ComputerPlayer(board, r);
         aiheart->start(0);
     }
 }
 
 Rack* WordGame::rack(int i) const
 {
     return (Rack*)racks->widget(i);
 }
 
 void WordGame::think()
 {
     if ( !cpu->step() ) {
         delete cpu;
         cpu = 0;
         aiheart->stop();
         if ( board->turnScore() < 0 )
             passTurn();
         else
             endTurn();
     }
 }
 
 ComputerPlayer::ComputerPlayer(Board* b, Rack* r) :
     board(b), rack(r), best(new const Tile*[rack_tiles]),
         best_blankvalues(new Tile[rack_tiles])
 {
     best_score = -1;
     across=FALSE;
     dict=0;
 }
 
 ComputerPlayer::~ComputerPlayer()
 {
     delete [] best;
     delete [] best_blankvalues;
 }
 
 bool ComputerPlayer::step()
 {
     const QDawg::Node* root = dict ? Global::dawg("WordGame").root()
                                 : Global::fixedDawg().root();
     QPoint d = across ? QPoint(1,0) : QPoint(0,1);
     const Tile* tiles[99]; // ### max board size
     uchar nletter[4095]; // QDawg only handles 0..4095
     memset(nletter,0,4096);
     for (int i=0; i<rack->count(); i++) {
         const Tile* r = rack->tileRef(i);
         if ( r->isBlank() )
             nletter[0]++;
         else
             nletter[r->text()[0].unicode()]++;
     }
     Tile blankvalues[99]; // ### max blanks
     findBest(current, d, root, 0, nletter, tiles, 0, blankvalues, 0);
     if ( ++current.rx() == board->xTiles() ) {
         current.rx() = 0;
         if ( ++current.ry() == board->yTiles() ) {
             if ( across ) {
                 if ( dict == 1 ) {
                     if ( best_score >= 0 ) {
                         rack->arrangeTiles(best,best_n);
                         rack->setBlanks(best_blankvalues);
                         board->scoreTurn(best_start, best_n, best_dir);
                         board->showTurn();
                     }
                     return FALSE;
                 }
                 dict++;
                 across = FALSE;
                 current = QPoint(0,0);
             } else {
                 across = TRUE;
                 current = QPoint(0,0);
             }
         }
     }
     return TRUE;
 }
 
 void ComputerPlayer::findBest(QPoint at, const QPoint& d, const QDawg::Node* node, ulong used, uchar* nletter, const Tile** tiles, int n, Tile* blankvalues, int blused)
 {
     if ( !node )
         return;
     QChar l = node->letter();
     const Tile* cur = board->tile(at);
     if ( cur ) {
         if ( cur->text()[0] == l ) {
             bool nextok =  board->contains(at+d);
             if ( node->isWord() && n && (!nextok || !board->tile(at+d)) )
                 noteChoice(tiles,n,d,blankvalues,blused);
             if ( nextok )
                 findBest(at+d, d, node->jump(), used, nletter, tiles, n, blankvalues, blused);
             // #### text()[1]...
         }
     } else {
         if ( nletter[l.unicode()] || nletter[0] ) {
             int rc = rack->count();
             ulong msk = 1;
             for ( int x=0; x<rc; x++ ) {
                 if ( !(used&msk) ) {
                     const Tile* t = rack->tileRef(x);
                     if ( t->isBlank() || t->text() == l ) { // #### multi-char value()s
                         bool nextok =  board->contains(at+d);
                         tiles[n++] = t;
                         if ( t->isBlank() )
                             blankvalues[blused++] = Tile(l,0);
                         if ( node->isWord() && (!nextok || !board->tile(at+d)) )
                             noteChoice(tiles,n,d,blankvalues,blused);
                         used |= msk; // mark
                         nletter[t->text()[0].unicode()]--;
                         if ( nextok )
                             findBest(at+d, d, node->jump(), used, nletter, tiles, n, blankvalues, blused);
                         n--;
                         nletter[t->text()[0].unicode()]++;
                         if ( t->isBlank() ) {
                             // keep looking
                             blused--;
                             used &= ~msk; // unmark
                         } else {
                             break;
                         }
                     }
                 }
                 msk <<= 1;
             }
         }
         // #### text()[1]...
     }
     findBest(at, d, node->next(), used, nletter, tiles, n, blankvalues, blused);
 }
 
 void ComputerPlayer::noteChoice(const Tile** tiles, int n, const QPoint& d, const Tile* blankvalues, int blused)
 {
     int s = board->score(current, tiles, n, blankvalues, d, TRUE, 0);
 /*
 if (s>0 || current==QPoint(5,1)){
 QString st;
 for ( int i=0; i<n; i++ )
     st += tiles[i]->text();
 qDebug("%d,%d: %s (%d) for %d",current.x(),current.y(),st.latin1(),n,s);
 }
 */
     if ( s > best_score ) {
         int i;
         for ( i=0; i<n; i++ )
             best[i] = tiles[i];
         for ( i=0; i<blused; i++ )
             best_blankvalues[i] = blankvalues[i];
         best_n = n;
         best_blused = blused;
         best_score = s;
         best_dir = d;
         best_start = current;
     }
 }
 
 int TileItem::smallWidth()
 {
     return tile_smallw;
 }
 
 int TileItem::smallHeight()
 {
     return tile_smallh;
 }
 
 int TileItem::bigWidth()
 {
     return tile_bigw;
 }
 
 int TileItem::bigHeight()
 {
     return tile_bigh;
 }
 
 void TileItem::setState( State state )
 {
     hide();
     s = state;
     show(); // ### use update() in Qt 3.0
 }
 
 void TileItem::setTile(const Tile& tile)
 {
     hide();
     t = tile;
     show(); // ### use update() in Qt 3.0
 }
 
 void TileItem::setBig(bool b)
 {
     big = b;
 }
 
 void TileItem::drawShape(QPainter& p)
 {
     static QFont *value_font=0;
     static QFont *big_font=0;
     static QFont *small_font=0;
     if ( !value_font ) {
         value_font = new QFont("helvetica",8);
         if ( TileItem::bigWidth() < 20 ) {
             big_font = new QFont("helvetica",12);
             small_font = new QFont("helvetica",8);
         } else {
             big_font = new QFont("smoothtimes",17);
             small_font = new QFont("smoothtimes",10);
         }
     }
 
     QRect area(x(),y(),width(),height());
     p.setBrush(s == Floating ? yellow/*lightGray*/ : white);
     p.drawRect(area);
     if ( big ) {
         p.setFont(*value_font);
         QString n = QString::number(t.value());
         int w = p.fontMetrics().width('1');
         int h = p.fontMetrics().height();
         w *= n.length();
         QRect valuearea(x()+width()-w-1,y()+height()-h,w,h);
         p.drawText(valuearea,AlignCenter,n);
         p.setFont(*big_font);
         area = QRect(x(),y()+tile_btweak,width()-4,height()-1);
     } else {
         p.setFont(*small_font);
         area = QRect(x()+1+tile_stweak,y()+1,width(),height()-3);
     }
     if ( t.value() == 0 )
         p.setPen(darkGray);
     p.drawText(area,AlignCenter,t.text().upper());
 }
 
 Board::Board(QPixmap bgshapes, int w, int h, QWidget* parent) :
     QCanvasView(new QCanvas(bgshapes,w,h, TileItem::smallWidth(), TileItem::smallHeight()),
                 parent)
 {
     setFixedSize(w*TileItem::smallWidth(),h*TileItem::smallHeight());
     grid = new TileItem*[w*h];
     memset(grid,0,w*h*sizeof(TileItem*));
     setFrameStyle(0);
     setHScrollBarMode(AlwaysOff);
     setVScrollBarMode(AlwaysOff);
     current_rack = 0;
     shown_n = 0;
 }
 
 Board::~Board()
 {
     delete canvas();
 }
 
 QSize Board::sizeHint() const
 {
     return QSize(canvas()->width(),canvas()->height());
 }
 
 void Board::writeConfig(Config& cfg)
 {
     QStringList t;
     int n=canvas()->tilesHorizontally()*canvas()->tilesVertically();
     for (int i=0; i<n; i++)
         t.append( grid[i] ? grid[i]->tile().key() : QString(".") );
     cfg.writeEntry("Board",t,';');
 }
 
 void Board::readConfig(Config& cfg)
 {
     clear();
     QStringList t = cfg.readListEntry("Board",';');
     int i=0;
     int h=canvas()->tilesHorizontally();
     for (QStringList::ConstIterator it=t.begin(); it!=t.end(); ++it) {
         if ( *it != "." ) {
             QPoint p(i%h,i/h);
             setTile(p,Tile(*it));
         }
         i++;
     }
     canvas()->update();
 }
 
 void Board::clear()
 {
     int n=canvas()->tilesHorizontally()*canvas()->tilesVertically();
     for (int i=0; i<n; i++) {
         delete grid[i];
         grid[i]=0;
     }
 }
 
 
 void Board::setCurrentRack(Rack* r)
 {
     turn_score = -1;
     current_rack = r;
 }
 
 void Board::resetRack()
 {
     unshowTurn();
     canvas()->update();
 }
 
 void Board::contentsMousePressEvent(QMouseEvent* e)
 {
     dragstart = e->pos();
 }
 
 void Board::contentsMouseMoveEvent(QMouseEvent* e)
 {
     if ( current_rack && !current_rack->computerized() ) {
         QPoint d = e->pos() - dragstart;
         if ( d.x() <= 0 && d.y() <= 0 ) {
             // None
             resetRack();
         } else {
             int n;
             QPoint start=boardPos(dragstart);
             QPoint end=boardPos(e->pos());
             QPoint diff=end-start;
             QPoint dir;
             if ( d.x() > d.y() ) {
                 n = diff.x()+1;
                 dir = QPoint(1,0);
             } else {
                 n = diff.y()+1;
                 dir = QPoint(0,1);
             }
 
             unshowTurn();
 
             // Subtract existing tiles from n
             QPoint t = start;
             for ( int i=n; i--; ) {
                 if ( contains(t) && tile(t) )
                     n--;
                 t += dir;
             }
 
             // Move start back to real start
             while (contains(start-dir) && tile(start-dir))
                 start -= dir;
 
             scoreTurn(start, n, dir);
             showTurn();
         }
     }
 }
 
 void Board::finalizeTurn()
 {
     int i=0;
     QPoint at = shown_at;
     while ( i<shown_n && contains(at) ) {
         if ( item(at) && item(at)->state() == TileItem::Floating ) {
             current_rack->remove(item(at)->tile());
             setTileState(at,TileItem::Firm);
             i++;
         }
         at += shown_step;
     }
     canvas()->update();
 }
 
 void Board::unshowTurn()
 {
     int i=0;
     QPoint at = shown_at;
     while ( i<shown_n && i<current_rack->count() && contains(at) ) {
         if ( item(at) && item(at)->state() == TileItem::Floating ) {
             unsetTile(at);
             i++;
         }
         at += shown_step;
     }
 }
 
 void Board::showTurn()
 {
     unshowTurn();
     QPoint at = shown_at;
     int i=0;
     while ( i<shown_n && i<current_rack->count() && contains(at) ) {
         if ( !tile(at) ) {
             Tile t = current_rack->tile(i);
             setTile(at,t);
             setTileState(at,TileItem::Floating);
             i++;
         }
         at += shown_step;
     }
     canvas()->update();
 }
 
 int Board::bonussedValue(const QPoint& at, int base, int& all_mult) const
 {
     int rule = rule_shape[idx(at)]-'0';
     int effect = rule_effect[rule];
     int mult = effect&Multiplier;
     if ( effect & MultiplyAll ) {
         all_mult *= mult;
         return base;
     } else {
         return base * mult;
     }
 }
 
 bool Board::isStart(const QPoint& at) const
 {
     int rule = rule_shape[idx(at)]-'0';
     int effect = rule_effect[rule];
     return effect&Start;
 }
 
 bool Board::checkTurn()
 {
     if ( current_rack->computerized() )
         return TRUE; // computer doesn't cheat, and has already set blanks.
 
     QPoint at = shown_at;
     int n = shown_n;
     QPoint d = shown_step;
     const Tile* tiles[99];
     Tile blankvalues[99];
     if ( n > current_rack->count() )
         n = current_rack->count();
 
     QDialog check(this,0,TRUE);
     (new QVBoxLayout(&check))->setAutoAdd(TRUE);
 
     QHBox mw(&check);
     new QLabel(tr("Blanks: "),&mw);
 
     int bl=0;
     QLineEdit* le[99];
     for (int i=0; i<n; i++) {
         tiles[i] = current_rack->tileRef(i);
         if ( tiles[i]->isBlank() ) {
             QLineEdit *l = new QLineEdit(&mw);
             le[bl++] = l;
             l->setMaxLength(1);
             l->setFixedSize(l->minimumSizeHint());
         }
     }
 
     QHBox btns(&check);
     connect(new QPushButton(tr("OK"),&btns), SIGNAL(clicked()), &check, SLOT(accept()));
     connect(new QPushButton(tr("Cancel"),&btns), SIGNAL(clicked()), &check, SLOT(reject()));
 
     if ( bl ) {
 retry:
         if ( !check.exec() ) {
             unshowTurn();
             canvas()->update();
             return FALSE;
         }
 
         for (int b=0; b<bl; b++) {
             QString v = le[b]->text();
             blankvalues[b]=Tile(v,0);
             if ( v.length() != 1 )
                 goto retry;
         }
     }
 
     QStringList words;
     unshowTurn();
     turn_score = score(at,tiles,n,blankvalues,d,FALSE,&words);
     showTurn();
     QStringList to_add;
     for (QStringList::Iterator it=words.begin(); it!=words.end(); ++it) {
         if ( !Global::fixedDawg().contains(*it)
                 && !Global::dawg("WordGame").contains(*it) ) {
             switch (QMessageBox::warning(this, tr("Unknown word"),
                 tr("<p>The word \"%1\" is not in the dictionary.").arg(*it),
                 tr("Add"), tr("Ignore"), tr("Cancel")))
             {
             case 0:
                 // ####### add to wordgame dictionary
                 to_add.append(*it);
                 break;
             case 1:
                 break;
             case 2:
                 unshowTurn();
                 canvas()->update();
                 return FALSE;
             }
         }
     }
     if ( to_add.count() )
         Global::addWords("WordGame",to_add);
     return TRUE;
 }
 
 void Board::scoreTurn(const QPoint& at, int n, const QPoint& d)
 {
     unshowTurn();
     shown_at = at;
     shown_n = n;
     shown_step = d;
     const Tile* tiles[99];
     if ( n > current_rack->count() )
         n = current_rack->count();
     for (int i=0; i<n; i++)
         tiles[i] = current_rack->tileRef(i);
     turn_score = score(at,tiles,n,0,d,FALSE,0);
     emit temporaryScore(turn_score);
 }
 
 int Board::score(QPoint at, const Tile** tiles, int n, const Tile* blankvalue, const QPoint& d, bool checkdict, QStringList* words) const
 {
     int total=0;
     int totalsidetotal=0;
 
     // words gets filled with words made
 
     // mainword==0 ->
     // Checks side words, but not main word
 
     // -1 means words not in dict, or illegally positioned (eg. not connected)
 
     // text is assumed to fit on board.
 
     if ( words ) *words=QStringList();
 
     QPoint otherd(d.y(), d.x());
 
     int all_mult = 1;
     int bl=0;
 
     bool connected = FALSE;
 
     QString mainword="";
 
     if ( contains(at-d) && tile(at-d) ) {
         return -1; // preceeding tiles
     }
 
     const Tile* t;
     for (int i=0; contains(at) && ((t=tile(at)) || i<n); ) {
         if ( t ) {
             if ( checkdict || words ) mainword += t->text();
             total += t->value();
             connected = TRUE;
         } else {
             QString sideword;
             QString tt;
             if ( tiles[i]->isBlank() ) {
                 if ( blankvalue )
                     tt = blankvalue[bl++].text();
             } else {
                 tt = tiles[i]->text();
             }
             sideword=tt;
             if ( checkdict || words ) mainword += tt;
             int side_mult = 1;
             int tilevalue = bonussedValue(at,tiles[i]->value(),side_mult);
             all_mult *= side_mult;
             if ( !connected && isStart(at) )
                 connected = TRUE;
             total += tilevalue;
             int sidetotal = tilevalue;
             {
                 QPoint side = at-otherd;
                 
                 while ( contains(side) && (t=tile(side)) ) {
                     sidetotal += t->value();
                     sideword.prepend(t->text());
                     side -= otherd;
                 }
             }
             {
                 QPoint side = at+otherd;
                 while ( contains(side) && (t=tile(side)) ) {
                     sidetotal += t->value();
                     sideword.append(t->text());
                     side += otherd;
                 }
             }
             if ( sideword.length() > 1 ) {
                 if ( words )
                     words->append(sideword);
                 if ( checkdict && !Global::fixedDawg().contains(sideword)
                                && !Global::dawg("WordGame").contains(sideword) )
                     return -1;
                 totalsidetotal += sidetotal * side_mult;
                 connected = TRUE;
             }
             i++;
         }
         at += d;
     }
 
     if ( words )
         words->append(mainword);
     if ( checkdict && !Global::fixedDawg().contains(mainword)
                    && !Global::dawg("WordGame").contains(mainword) )
         return -1;
 
     if ( n == rack_tiles )
         totalsidetotal += rack_tiles_bonus;
 
     return connected ? totalsidetotal + total * all_mult : -1;
 }
 
 QPoint Board::boardPos(const QPoint& p) const
 {
     return QPoint(p.x()/canvas()->tileWidth(), p.y()/canvas()->tileHeight());
 }
 
 void Board::contentsMouseReleaseEvent(QMouseEvent*)
 {
     if ( current_rack ) {
     }
 }
 
 
 void Board::setRules(const QString& shapes, const int* effects)
 {
     rule_shape=shapes; rule_effect=effects;
     int i=0;
     int maxre=0;
     for (int y=0; y<yTiles(); y++) {
         for (int x=0; x<xTiles(); x++) {
             int re = shapes[i++]-'0';
             if ( re > maxre ) maxre = re;
             canvas()->setTile(x,y,re);
         }
     }
     rack_tiles_bonus=effects[maxre+1];
 }
 
 void Board::unsetTile(const QPoint& p)
 {
     delete item(p);
     grid[idx(p)] = 0;
 }
 
 void Board::setTile(const QPoint& p, const Tile& t)
 {
     TileItem* it=item(p);
     if ( !it ) {
         it = grid[idx(p)] = new TileItem(t,FALSE,canvas());
         it->move(p.x()*canvas()->tileWidth(), p.y()*canvas()->tileHeight());
         it->show();
     } else {
         it->setTile(t);
     }
 }
 
 Rack::Rack(int ntiles, QWidget* parent) : QCanvasView(
         new QCanvas(ntiles*TileItem::bigWidth(),TileItem::bigHeight()),
             parent),
         item(ntiles)
 {
     setLineWidth(1);
     setFixedHeight(sizeHint().height());
     n = 0;
     for (int i=0; i<ntiles; i++)
         item[i]=0;
     setHScrollBarMode(AlwaysOff);
     setVScrollBarMode(AlwaysOff);
     canvas()->setBackgroundColor(gray);
     dragging = 0;
 }
 
 Rack::~Rack()
 {
     clear();
     delete canvas();
 }
 
 QSize Rack::sizeHint() const
 {
     return QSize(-1,TileItem::bigHeight()+2);
 }
 
 void Rack::clear()
 {
     for (int i=0; i<n; i++)
         delete item[i];
     n=0;
 }
 
 void Rack::writeConfig(Config& cfg)
 {
     QStringList l;
     for (int i=0; i<n; i++)
         l.append(tile(i).key());
     cfg.writeEntry("Tiles",l,';');
 }
 
 void Rack::readConfig(Config& cfg)
 {
     clear();
     int x=0;
     QStringList l = cfg.readListEntry("Tiles",';');
     for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it) {
         TileItem *i = new TileItem(Tile(*it),TRUE,canvas());
         i->move(x++,0);
         i->show();
         item[n++] = i;
     }
     layoutTiles();
 }
 
 static int cmp_tileitem(const void *a, const void *b)
 {
     const TileItem* ia = *(TileItem**)a;
     const TileItem* ib = *(TileItem**)b;
     return int(ia->x() - ib->x());
 }
 
 void Rack::layoutTiles()
 {
     int w = TileItem::bigWidth()+2;
 
     if ( dragging ) dragging->moveBy(dragging_adj,0);
     qsort(item.data(), n, sizeof(TileItem*), cmp_tileitem);
     if ( dragging ) dragging->moveBy(-dragging_adj,0);
 
     for (int i=0; i<n ;i++)
         if ( item[i] == dragging ) {
             item[i]->setZ(1);
         } else {
             item[i]->move(i*w, 0);
             item[i]->setZ(0);
         }
     canvas()->update();
 }
 
 void Rack::setBlanks(const Tile* bv)
 {
     for (int j=0; j<n; j++) {
         Tile tt = item[j]->tile();
         if ( tt.isBlank() ) {
             tt.setText(bv->text());
             item[j]->setTile(tt);
             bv++;
         }
     }
 }
 
 bool Rack::arrangeTiles(const Tile** s, int sn)
 {
     bool could = TRUE;
     for (int j=0; j<n; j++) {
         Tile tt = item[j]->tile();
         int f=-1;
         for (int i=0; i<sn && f<0; i++) {
             if (s[i] && *s[i] == tt ) {
                 s[i]=0;
                 f=i;
             }
         }
         if ( f >= 0 ) {
             item[j]->move(f-999,0);
         } else {
             could = FALSE;
         }
     }
     layoutTiles();
     return could;
 }
 
 void Rack::addTile(const Tile& t)
 {
     TileItem *i = new TileItem(t,TRUE,canvas());
     i->show();
     item[n++] = i;
     layoutTiles();
 }
 
 void Rack::remove(Tile t)
 {
     for (int i=0; i<n ;i++)
         if ( item[i]->tile() == t ) {
             remove(i);
             return;
         }
 }
 
 void Rack::remove(int i)
 {
     delete item[i];
     n--;
     for (;i<n;i++)
         item[i]=item[i+1];
     layoutTiles();
 }
 
 void Rack::resizeEvent(QResizeEvent* e)
 {
     canvas()->resize(width()-frameWidth()*2,height()-frameWidth()*2);
     QCanvasView::resizeEvent(e);
 }
 
 void Rack::contentsMousePressEvent(QMouseEvent* e)
 {
     if ( computerized() )
         return;
     QCanvasItemList list = canvas()->collisions(e->pos());
     if (list.count()) {
         dragging = list.first();
         dragstart = e->pos()-QPoint(int(dragging->x()),int(dragging->y()));
     } else {
         dragging = 0;
     }
 }
 
 void Rack::contentsMouseMoveEvent(QMouseEvent* e)
 {
     if ( computerized() )
         return;
     //int w = TileItem::bigWidth()+2;
     if ( dragging ) {
         dragging_adj = TileItem::bigWidth()/2;
         if ( dragging->x() > e->x()-dragstart.x() )
             dragging_adj = -dragging_adj;
         dragging->move(e->x()-dragstart.x(),0);
         layoutTiles();
     }
 }
 
 void Rack::contentsMouseReleaseEvent(QMouseEvent* e)
 {
     if ( computerized() )
         return;
     if ( dragging ) {
         dragging=0;
         layoutTiles();
     }
 }
 
 Tile::Tile(const QString& key)
 {
     int a=key.find('@');
     txt = key.left(a);
     val = key.mid(a+1).toInt();
     blank = txt.isEmpty();
 }
 
 QString Tile::key() const
 {
     return txt+"@"+QString::number(val);
 }
 
 Bag::Bag()
 {
     tiles.setAutoDelete(TRUE);
 }
 
 void Bag::writeConfig(Config& cfg)
 {
     QStringList t;
     for (QListIterator<Tile> it(tiles); it; ++it)
         t.append((*it)->key());
     cfg.writeEntry("Tiles",t,';');
 }
 
 void Bag::readConfig(Config& cfg)
 {
     tiles.clear();
     QStringList t = cfg.readListEntry("Tiles",';');
     for (QStringList::ConstIterator it=t.begin(); it!=t.end(); ++it )
         add(Tile(*it));
 }
 
 void Bag::add(const Tile& t)
 {
     tiles.append(new Tile(t));
 }
 
 Tile Bag::takeRandom()
 {
     Tile* rp = tiles.take(random()%tiles.count());
     Tile r=*rp;
     return r;
 }
 
 ScoreInfo::ScoreInfo( QWidget* parent, const char* name, WFlags fl ) :
     QLabel("<P>",parent,name,fl)
 {
     score=0;
     msgtimer = new QTimer(this);
     connect(msgtimer, SIGNAL(timeout()), this, SLOT(showScores()));
     setBackgroundMode( PaletteButton );
 }
 
 ScoreInfo::~ScoreInfo()
 {
     if ( score ) delete [] score;
 }
 
 void ScoreInfo::writeConfig(Config& cfg)
 {
     QStringList l;
     for (int i=0; i<(int)names.count(); i++)
         l.append(QString::number(score[i]));
     cfg.writeEntry("Scores",l,';');
 }
 
 void ScoreInfo::readConfig(Config& cfg)
 {
     QStringList l = cfg.readListEntry("Scores",';');
     int i=0;
     for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it )
         score[i++]=(*it).toInt();
     showScores();
 }
 
 
 QSize ScoreInfo::sizeHint() const
 {
     return QSize(QLabel::sizeHint().width(),fontMetrics().height());
 }
 
 void ScoreInfo::init(const QStringList& namelist)
 {
     names = namelist;
     if ( score ) delete [] score;
     score = new int[names.count()];
     memset(score,0,sizeof(int)*names.count());
     boldone = -1;
     showScores();
 }
 
 void ScoreInfo::addScore(int player, int change)
 {
     score[player] += change;
     showScores();
 }
 
 void ScoreInfo::setBoldOne(int b)
 {
     boldone=b;
     showScores();
 }
 
 void ScoreInfo::showScores()
 {
     QString r="<p>";
     int i=0;
     //int spl=(names.count()+1)/2; // 2 lines
     for (QStringList::ConstIterator it=names.begin(); it!=names.end(); ) {
         if ( i==boldone ) r += "<b>";
         QString n = *it;
         n.replace(QRegExp(":.*"),"");
         r += n;
         r += ":";
         r += QString::number(score[i]);
         if ( i==boldone ) r += "</b>";
 
         ++i;
         ++it;
         if ( it != names.end() )
             r += " ";
     }
     setText(r);
 }
 
 void ScoreInfo::showTemporaryScore(int amount)
 {
     if ( amount < 0 )
         setText(tr("<P>Invalid move"));
     else
         setText(tr("<P>Score: ")+QString::number(amount));
     msgtimer->start(3000,TRUE);
 }
 
diff --git a/noncore/games/zlines/main.cpp b/noncore/games/zlines/main.cpp
index d1709e4..8d80bae 100644
--- a/noncore/games/zlines/main.cpp
+++ b/noncore/games/zlines/main.cpp
@@ -1,28 +1,29 @@
 /***************************************************************************
                           main.cpp  -  description
                              -------------------
     begin                : Fri May 19 2000
     copyright            : (C) 2000 by Roman Merzlyakov
     email                : roman@sbrf.barrt.ru
     copyright            : (C) 2000 by Roman Razilov
     email                : Roman.Razilov@gmx.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
  /*
   * Roman Razilov 2000-05-19 debug dummmy
   * Roman Razilov 2000-05-21 qimgio
 */
 
 #include "klines.h"
 
 #include <opie2/oapplicationfactory.h>
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<KLines> )
diff --git a/noncore/games/zsame/ZSameWidget.cpp b/noncore/games/zsame/ZSameWidget.cpp
index 3c58c93..4fab0f6 100644
--- a/noncore/games/zsame/ZSameWidget.cpp
+++ b/noncore/games/zsame/ZSameWidget.cpp
@@ -1,243 +1,244 @@
 /* Yo Emacs, this is -*- C++ -*- */
 /*
  *   ksame 0.4 - simple Game
  *   Copyright (C) 1997,1998  Marcus Kreutzberger
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  *
  */
 
 #include <stdio.h>
 
 #include <opie2/oapplicationfactory.h>
 
 #include <qpe/resource.h>
 
 #include <qtoolbar.h>
 #include <qmenubar.h>
 #include <qapplication.h>
 #include <qaction.h>
 #include <qmessagebox.h>
 
 #include <kapplication.h>
 
 #include "ZSameWidget.h"
 
 static int default_colors=3;
 
 #define i18n tr
 
 
+using namespace Opie::Core;
 OPIE_EXPORT_APP( OApplicationFactory<ZSameWidget> )
 
 
 
 ZSameWidget::ZSameWidget( QWidget* parent, const char* name,  WFlags fl )
     : QMainWindow( parent, name, fl )
 {
     setCaption(tr("ZSame"));
 
     setToolBarsMovable( false );
     QToolBar* con = new QToolBar( this );
     con->setHorizontalStretchable( true );
     QMenuBar* mb = new QMenuBar( con );
     QToolBar* tb = new QToolBar( this );
 
     QPopupMenu* fileMenu = new QPopupMenu( this );
 
     QAction* a = new QAction(tr("New Game"), Resource::loadIconSet("new") ,
                              QString::null, 0, this, "new_icon");
     a->addTo( fileMenu );
     a->addTo( tb );
     connect(a, SIGNAL(activated()), this, SLOT(m_new()));
 
     a = new QAction(tr("Restart This Board"), Resource::loadIconSet("redo"),
                               QString::null, 0, this, "restart_board" );
     a->addTo( fileMenu );
     connect( a, SIGNAL(activated()), this, SLOT(m_restart()));
     restart = a;
 
     a = new QAction( tr("Undo"), Resource::loadIconSet("undo"),
                      QString::null, 0, this, "undo_action" );
     a->addTo( fileMenu );
     a->addTo( tb );
     connect( a, SIGNAL(activated()), this, SLOT(m_undo()));
 
     a = new QAction(tr("Quit"), Resource::loadIconSet("quit_icon"),
                               QString::null, 0, this, "quit_action");
     a->addTo( fileMenu );
     a->addTo( tb );
     connect(a, SIGNAL(activated()), this, SLOT(m_quit()));
 
     mb->insertItem(tr("Game" ), fileMenu );
 
     int foo[2];
     desktop_widget(foo);
     stone = new StoneWidget(this,foo[0],foo[1]);
 
     connect( stone, SIGNAL(s_gameover()), this, SLOT(gameover()));
 
     connect( stone, SIGNAL(s_colors(int)), this, SLOT(setColors(int)));
     connect( stone, SIGNAL(s_board(int)), this, SLOT(setBoard(int)));
     connect( stone, SIGNAL(s_marked(int)), this, SLOT(setMarked(int)));
     connect( stone, SIGNAL(s_score(int)), this, SLOT(setScore(int)));
     connect( stone, SIGNAL(s_remove(int,int)), this, SLOT(stonesRemoved(int,int)));
 
     connect(stone, SIGNAL(s_sizechanged()), this, SLOT(sizeChanged()));
 
     sizeChanged();
     setCentralWidget(stone);
 
 
     setScore(0);
 }
 
 ZSameWidget::~ZSameWidget() {
 
 }
 
 void ZSameWidget::readProperties(Config *conf) {
 /*
   Q_ASSERT(conf);
   stone->readProperties(conf);
 */
 }
 
 void ZSameWidget::saveProperties(Config *conf) {
 /*
   Q_ASSERT(conf);
   stone->saveProperties(conf);
   conf->sync();
 */
 }
 
 void ZSameWidget::sizeChanged() {
         //stone->setFixedSize(stone->sizeHint());
 }
 
 void ZSameWidget::newGame(unsigned int board,int colors) {
         while (board>=1000000) board-=1000000;
         // kdDebug() << "newgame board " << board << " colors " << colors << endl;
         stone->newGame(board,colors);
         setScore(0);
 }
 
 bool ZSameWidget::confirmAbort() {
     return stone->isGameover() ||
         stone->isOriginalBoard() ||
         (QMessageBox::warning(this, i18n("Resign"), i18n("<qt>Do you want to resign?</qt>"),
                               QMessageBox::Yes,
                               QMessageBox::No|QMessageBox::Default|QMessageBox::Escape, 0) == QMessageBox::Yes );
 }
 
 void ZSameWidget::m_new() {
     if (confirmAbort())
         newGame(_random(),default_colors);
 
 }
 
 void ZSameWidget::m_restart() {
         if (confirmAbort())
                 newGame(stone->board(),default_colors);
 }
 
 void ZSameWidget::m_load() {
 //  kdDebug() << "menu load not supported" << endl;
 }
 
 void ZSameWidget::m_save() {
 //  kdDebug() << "menu save not supported" << endl;
 }
 
 void ZSameWidget::m_undo() {
         //Q_ASSERT(stone);
         stone->undo();
 }
 
 
 void ZSameWidget::m_showhs() {
 /*  Q_ASSERT(stone);
   stone->unmark();
   KScoreDialog d(KScoreDialog::Name | KScoreDialog::Score, this);
   d.addField(Board, i18n("Board"), "Board");
   d.exec();
 */
 }
 
 void ZSameWidget::m_quit() {
 //  Q_ASSERT(stone);
   stone->unmark();
   qApp->quit();
 //  delete this;
 }
 
 void ZSameWidget::m_tglboard() {
         //kdDebug() << "toggled" << endl;
 }
 
 
 void ZSameWidget::setColors(int colors) {
         //status->changeItem(i18n("%1 Colors").arg(colors),1);
 }
 
 void ZSameWidget::setBoard(int board) {
         //status->changeItem(i18n("Board: %1").arg(board, 6), 2);
 }
 
 void ZSameWidget::setMarked(int m) {
 //  status->changeItem(i18n("Marked: %1").arg(m, 6),3);
 }
 
 void ZSameWidget::stonesRemoved(int,int) {
         //KNotifyClient::event("stones removed",
         //   i18n("%1 stones removed.").arg(stone->marked()));
 }
 
 void ZSameWidget::setScore(int score) {
 //  status->changeItem(i18n("Score: %1").arg(score, 6),4);
 //  undo->setEnabled(stone->undoPossible());
 //  restart->setEnabled(!stone->isOriginalBoard());
 }
 
 void ZSameWidget::gameover() {
 //  kdDebug() << "GameOver" << endl;
   if (stone->hasBonus()) {
           QMessageBox::information(this,i18n("Game won"),
                   i18n("<qt>You even removed the last stone, great job! "
                            "This gave you a score of %1 in total.</qt>").arg(stone->score()));
   } else {
           QMessageBox::information(this,i18n("Game over"),
                   i18n("<qt>There are no more removeable stones. "
                            "You got a score of %1 in total.</qt>").arg(stone->score()));
   }
   stone->unmark();
 }
 
 void ZSameWidget::desktop_widget(int *f)const{
 
     QWidget* wid = QApplication::desktop();
     /*  width > height landscape mode */
     if ( wid->width() > wid->height() ) {
         f[0]=15;
         f[1]=9;
     }
     /* normal */
     else{
         f[0]=12;
         f[1]=13;
     }
 }