Remove unused parameter

8 files changed, 53 insertions, 50 deletions

diff --git a/noncore/decorations/flat/flat.cpp b/noncore/decorations/flat/flat.cpp
index a2f12be..9a670cc 100644
--- a/noncore/decorations/flat/flat.cpp
+++ b/noncore/decorations/flat/flat.cpp
@@ -193,170 +193,170 @@ static QImage scaleButton( const QImage &img, int height )
 
 static void colorize( QImage &img, const QColor &c, bool rev )
 {
     for ( int i = 0; i < img.numColors(); i++ ) {
 	bool sc = (img.color(i) & 0xff000000);
 	if ( rev ) sc = !sc;
 	img.setColor(i, sc ? c.rgb() : 0x00000000 );
     }
 }
 
 FlatDecoration::FlatDecoration() : buttonCache(16)
 {
     buttonCache.setAutoDelete(TRUE);
 }
 
 FlatDecoration::~FlatDecoration()
 {
 }
 
 int FlatDecoration::metric( Metric m, const WindowData *wd ) const
 {
     switch ( m ) {
 	case TopBorder:
 	    return 1;
 	    break;
 	case LeftBorder:
 	case RightBorder:
 	    return 2;
 	case BottomBorder:
 	    return 4;
 	case TitleHeight:
 	    if ( QApplication::desktop()->height() > 320 )
 		return 20;
 	    else
 		return 18;
 	case OKWidth:
 	case CloseWidth:
 	case HelpWidth:
 	case MaximizeWidth:
 	    return metric(TitleHeight,wd);
 	    break;
 	default:
 	    return WindowDecorationInterface::metric( m, wd );
 	    break;
     }
 
     return 0;
 }
 
 void FlatDecoration::drawArea( Area a, QPainter *p, const WindowData *wd ) const
 {
     int th = metric( TitleHeight, wd );
     QRect r = wd->rect;
 
     switch ( a ) {
 	case Border:
 	    {
 		const QColorGroup &cg = wd->palette.active();
 		if ( wd->flags & WindowData::Active ) {
 		    p->setBrush( cg.color(QColorGroup::Highlight) );
 		} else {
 		    p->setBrush( cg.color(QColorGroup::Background) );
 		}
 		p->setPen( cg.foreground() );
 		int lb = metric(LeftBorder,wd);
 		int rb = metric(RightBorder,wd);
 		int tb = metric(TopBorder,wd);
 		int bb = metric(BottomBorder,wd);
 		p->drawRect( r.x()-lb, r.y()-tb-th, r.width()+lb+rb,
 			     r.height()+th+tb+bb );
 	    }
 	    break;
 	case Title:
 	    if ( r.height() < 2 ) {
 		WindowDecorationInterface::drawArea( a, p, wd );
 	    } else {
 		const QColorGroup &cg = wd->palette.active();
 		QColor c;
 		if ( wd->flags & WindowData::Active )
 		    c = cg.color(QColorGroup::Highlight);
 		else
 		    c = cg.color(QColorGroup::Background);
 		p->fillRect( QRect(r.x(),r.y()-th,r.width(),th), c );
 	    }
 	    break;
 	case TitleText:
 	    p->drawText( r.left()+3+metric(HelpWidth,wd), r.top()-th,
 			 r.width()-metric(HelpWidth,wd)-metric(CloseWidth,wd), th,
 			 Qt::AlignVCenter, wd->caption );
 	    break;
 	default:
 	    FlatDecoration::drawArea( a, p, wd );
 	    break;
     }
 }
 
-void FlatDecoration::drawButton( Button b, QPainter *p, const WindowData *wd, int x, int y, int w, int h, QWSButton::State state ) const
+void FlatDecoration::drawButton( Button b, QPainter *p, const WindowData *wd, int x, int y, int, int, QWSButton::State state ) const
 {
     QColor c;
     const QColorGroup &cg = wd->palette.active();
     if ( wd->flags & WindowDecorationInterface::WindowData::Active )
 	c = cg.color(QColorGroup::HighlightedText);
     else
 	c = cg.color(QColorGroup::Foreground);
     bool r = (state & QWSButton::MouseOver) && (state & QWSButton::Clicked);
     int th = metric(TitleHeight, wd);
 
     QString key( "%1-%2-%3-%4" );
     key = key.arg(b).arg(th).arg(c.name()).arg(r ? "1" : "0");
     QImage *img = buttonCache.find( key );
     if ( !img ) {
 	QImage tmp;
 	switch ( b ) {
 	    case OK:
 		tmp = QImage( ok_xpm );
 		break;
 	    case Close:
 		tmp = QImage( close_xpm );
 		break;
 	    case Help:
 		tmp = QImage( help_xpm );
 		break;
 	    case Maximize:
 		tmp = QImage( maximize_xpm );
 		break;
 	}
 	colorize( tmp, c, r );
 	img = new QImage( scaleButton(tmp,th) );
 	FlatDecoration *that = (FlatDecoration *)this;
 	that->buttonCache.insert( key, img, 1 );
     }
-    
+
     p->drawImage( x, y, *img );
 }
 
 QRegion FlatDecoration::mask( const WindowData *wd ) const
 {
     return WindowDecorationInterface::mask( wd );
 }
 
 QString FlatDecoration::name() const
 {
     return qApp->translate( "Decoration", "Flat" );
 }
 
 QPixmap FlatDecoration::icon() const
 {
     return QPixmap();
 }
 
 QRESULT FlatDecoration::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
     if ( uuid == IID_QUnknown )
 	*iface = this;
     else if ( uuid == IID_WindowDecoration )
 	*iface = this;
     else
 	return QS_FALSE;
 
     if ( *iface )
 	(*iface)->addRef();
     return QS_OK;
 }
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( FlatDecoration )
 }
 
diff --git a/noncore/games/bounce/game.cpp b/noncore/games/bounce/game.cpp
index bbd3d0b..5ef9f15 100644
--- a/noncore/games/bounce/game.cpp
+++ b/noncore/games/bounce/game.cpp
@@ -1,512 +1,513 @@
 /*
  * Copyright (C) 2000 Stefan Schimanski <1Stein@gmx.de>
  *
  * 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 "game.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 using namespace Opie::Core;
 
 /* QT */
 #include <qtimer.h>
 
 /* STD */
 #include <stdlib.h>
 
-#define TILE_SIZE 9 
+#define TILE_SIZE 9
 
 #define TILE_FIRST ((FIELD_WIDTH-2)*(FIELD_HEIGHT-2))
 #define TILE_FREE (TILE_FIRST + 0)
 #define TILE_BORDER (TILE_FIRST + 1)
 #define TILE_WALLEND (TILE_FIRST + 2)
 #define TILE_WALLUP (TILE_FIRST + 3)
 #define TILE_WALLDOWN (TILE_FIRST + 4)
 #define TILE_WALLLEFT (TILE_FIRST + 5)
 #define TILE_WALLRIGHT (TILE_FIRST + 6)
 
 #define GAME_DELAY 15
 #define BALL_ANIM_DELAY 60
 #define WALL_DELAY 100
 
 #define MS2TICKS( ms ) ((ms)/GAME_DELAY)
 
 Arrow::Arrow(QCanvasPixmapArray* array, QCanvas* canvas)
     : QCanvasSprite( array, canvas )
 {
 	m_vertical = true;
 	move(3,3);
 }
 
 void Arrow::update()
 {
 	if ( m_vertical )
 		setFrame( 0 );
 	else
 		setFrame( 1 );
 }
 
 void Arrow::changeDirection()
 {
 	m_vertical = ! m_vertical;
 	update();
 }
-	
+
 
 Ball::Ball(QCanvasPixmapArray* array, QCanvas* canvas)
     : QCanvasSprite( array, canvas ), m_animDelay( 0 ), m_soundDelay( MS2TICKS(BALL_ANIM_DELAY)/2 )
 {
 }
 
 void Ball::update()
 {
    m_animDelay--;
    if ( m_animDelay<=0 )
    {
        m_animDelay =  MS2TICKS(BALL_ANIM_DELAY);
        int frameNum = frame();
        frameNum++;
        if ( frameNum>=frameCount() )
            frameNum = 0;
        setFrame( frameNum );
    }
 }
 
 void Ball::advance(int stage)
 {
    bool reflectX = false;
    bool reflectY = false;
 
    // check for collisions
    if ( collide(xVelocity(), 0) ) reflectX = true;
    if ( collide(0, yVelocity()) ) reflectY = true;
    if ( !reflectX && !reflectY && collide(xVelocity(), yVelocity()) ) reflectX = reflectY = true;
 
    // emit collision
    QRect r = boundingRect();
-   r.moveBy( xVelocity(), yVelocity() );
+   r.moveBy( static_cast<int>(xVelocity()), static_cast<int>( yVelocity() ) );
    JezzField* field = (JezzField *)canvas();
 
    int ul = field->tile( r.left() / TILE_SIZE, r.top() / TILE_SIZE );
    int ur = field->tile( r.right() / TILE_SIZE, r.top() / TILE_SIZE );
    int bl = field->tile( r.left() / TILE_SIZE, r.bottom() / TILE_SIZE );
    int br = field->tile( r.right() / TILE_SIZE, r.bottom() / TILE_SIZE );
 
    if ( ul!=TILE_FREE ) field->emitBallCollisiton( this, r.left() / TILE_SIZE, r.top() / TILE_SIZE, ul ); else
    if ( ur!=TILE_FREE ) field->emitBallCollisiton( this, r.right() / TILE_SIZE, r.top() / TILE_SIZE, ur ); else
    if ( bl!=TILE_FREE ) field->emitBallCollisiton( this, r.left() / TILE_SIZE, r.bottom() / TILE_SIZE, bl ); else
    if ( br!=TILE_FREE ) field->emitBallCollisiton( this, r.right() / TILE_SIZE, r.bottom() / TILE_SIZE, br );
 
    // apply reflection
    if ( reflectX ) setXVelocity( -xVelocity() );
    if ( reflectY ) setYVelocity( -yVelocity() );
 
    // update field
    update();
    QCanvasSprite::advance( stage );
 }
 
 bool Ball::collide( double dx, double dy )
 {
    QRect r = boundingRect();
-   r.moveBy( dx, dy );
+   r.moveBy( static_cast<int>( dx ), static_cast<int>( dy ) );
    JezzField* field = (JezzField *)canvas();
 
    int ul = field->tile( r.left() / TILE_SIZE, r.top() / TILE_SIZE );
    int ur = field->tile( r.right() / TILE_SIZE, r.top() / TILE_SIZE );
    int bl = field->tile( r.left() / TILE_SIZE, r.bottom() / TILE_SIZE );
    int br = field->tile( r.right() / TILE_SIZE, r.bottom() / TILE_SIZE );
 
    return ( ul!=TILE_FREE || ur!=TILE_FREE || bl!=TILE_FREE || br!=TILE_FREE );
 }
 
 /*************************************************************************/
 
 Wall::Wall( JezzField *field, int x, int y, Direction dir, int tile, QObject *parent, const char *name )
     : QObject( parent, name ), m_dir( dir ), m_field( field ), m_startX( x ), m_startY( y ),
       m_tile( tile ), m_delay( MS2TICKS(WALL_DELAY)/2 ), m_active( true )
 {
    // setup position and direction
    m_dx = 0;
    m_dy = 0;
    switch ( m_dir )
    {
       case Up: m_dy = -1; break;
       case Down: m_dy = 1; break;
       case Left: m_dx = -1; break;
       case Right: m_dx = 1; break;
    }
 
    m_x = m_startX;
    m_y = m_startY;
 
    m_field->setTile( m_x, m_y, m_tile );
 }
 
 void Wall::finish()
 {
     m_active = false;
 }
 
 bool Wall::isFree( int x, int y )
 {
     if ( m_field->tile(x, y)==TILE_FREE )
     {
         // check whether there is a ball at the moment
         QCanvasItemList cols = m_field->collisions( QRect(x*TILE_SIZE, y*TILE_SIZE,
                                                           TILE_SIZE, TILE_SIZE) );
         if ( cols.count()==0 )
             return true;
     }
 
     return false;
 }
 
 void Wall::update()
 {
 }
 
 void Wall::advance()
 {
     update();
 
     // move wall
     if ( m_active )
     {
         m_delay--;
         if ( m_delay<=0 )
         {
             m_delay =  MS2TICKS(WALL_DELAY);
 
             // set previous tile
             m_field->setTile( m_x, m_y, m_tile );
 
             // check whether next place is still free
             if ( isFree(m_x+m_dx, m_y+m_dy) )
             {
                 // move ball
                 m_x += m_dx;
                 m_y += m_dy;
 
                 // set tile
                 m_field->setTile( m_x, m_y, TILE_WALLEND );
             } else
             {
                 finish();
                 emit finished( this, m_field->tile( m_x+m_dx, m_y+m_dy ) );
             }
         }
     }
 }
 
 void Wall::fill( bool black )
 {
 	if ( m_dx )
 	{
 		for ( int x=m_startX ; x!=m_x; x+=m_dx )
 			if ( m_field->tile(x, m_startY)==m_tile )
 				m_field->setGameTile( x, m_startY, black );
 
 		m_field->setGameTile( m_x, m_startY, black );
 	} else
 	{
 		for ( int y=m_startY ; y!=m_y; y+=m_dy )
 			if ( m_field->tile(m_startX, y)==m_tile )
 				m_field->setGameTile( m_startX, y, black );
 
 		m_field->setGameTile( m_startX, m_y, black );
 	}
 }
 
 /*************************************************************************/
 
 JezzField::JezzField( QPixmap tiles, QObject* parent, const char* name )
     : QCanvas( parent, name ), m_tiles( tiles )
 {
     setPixmaps( tiles );
 }
 
 void JezzField::setGameTile( int x, int y, bool black )
 {
    setTile( x, y, black ? TILE_BORDER : TILE_FREE );
 }
 
 void JezzField::setPixmaps( QPixmap tiles )
 {
     // create new tiles
     QPixmap allTiles( TILE_SIZE*(FIELD_WIDTH-2), TILE_SIZE*(FIELD_HEIGHT-1) );
 
     // handle default tiles
     bitBlt( &allTiles, 0, TILE_SIZE*(FIELD_HEIGHT-2),
             &tiles, 0, 0, tiles.width(), tiles.height() );
 
     // load tiles into canvas
     setTiles( allTiles, FIELD_WIDTH, FIELD_HEIGHT, TILE_SIZE, TILE_SIZE );
 }
 
 /*************************************************************************/
 
 JezzView::JezzView(QCanvas* viewing, QWidget* parent, const char* name, WFlags f)
    : QCanvasView( viewing, parent, name, f ), m_vertical( false )
 {
    setResizePolicy( AutoOne );
    setHScrollBarMode( AlwaysOff );
    setVScrollBarMode( AlwaysOff );
 
    setCursor( sizeHorCursor );
 }
 
 void JezzView::viewportMouseReleaseEvent( QMouseEvent *ev )
 {
    if ( ev->button() & LeftButton )
    {
       emit buildWall( ev->x()/TILE_SIZE, ev->y()/TILE_SIZE, m_vertical );
    }
 }
 
 void JezzView::changeCursor()
 {
 	m_vertical = !m_vertical;
 	if ( m_vertical )
 	{
 		setCursor( sizeVerCursor );
 	}
 	else
 	{
 		setCursor( sizeHorCursor );
 	}
 }
 
 /*************************************************************************/
 
 JezzGame::JezzGame( int ballNum, QWidget *parent, const char *name )
     : QWidget( parent, name ), m_wall1( 0 ), m_wall2( 0 ),
       m_text( 0 ), m_running( false ), m_percent( 0 ), m_pictured( false )
 {
-   QString path = QPEApplication::qpeDir()+"pics/bounce/"; 
+   QString path = QPEApplication::qpeDir()+"pics/bounce/";
 
    // load gfx
    m_ballPixmaps = new QCanvasPixmapArray( path + "ball%1.png", 25 );
    for ( unsigned n=0; n < m_ballPixmaps->count(); n++ )
        m_ballPixmaps->image(n)->setOffset( 0, 0 );
 
    m_arrowPixmaps = new QCanvasPixmapArray( path + "arrow%1.png", 2 );
    for ( unsigned n=0; n < m_arrowPixmaps->count(); n++ )
        m_arrowPixmaps->image(n)->setOffset( 0, 0 );
 
    QPixmap tiles( path + "tiles.png" );
 
    // create field
    m_field = new JezzField( tiles, this, "m_field" );
    m_field->resize( TILE_SIZE*FIELD_WIDTH, TILE_SIZE*FIELD_HEIGHT );
 
    for ( int x=0; x<FIELD_WIDTH; x++ )
          m_field->setTile( x, 0, TILE_BORDER );
    for ( int y=1; y<FIELD_HEIGHT-1; y++ )
    {
       m_field->setTile( 0, y, TILE_BORDER );
       for ( int x=1; x<FIELD_WIDTH-1; x++ )
          m_field->setTile( x, y, TILE_FREE );
       m_field->setTile( FIELD_WIDTH-1, y, TILE_BORDER );
    }
    for ( int x=0; x<FIELD_WIDTH; x++ )
          m_field->setTile( x, FIELD_HEIGHT-1, TILE_BORDER );
 
    connect( m_field, SIGNAL(ballCollision(Ball*,int,int,int)), this, SLOT(ballCollision(Ball*,int,int,int)) );
 
    // create view
    m_view = new JezzView( m_field, this, "m_view" );
    m_view->move( 0, 0 );
    m_view->adjustSize();
    connect( m_view, SIGNAL(buildWall(int,int,bool)), this, SLOT(buildWall(int,int,bool)) );
 
    // create balls
    for ( int n=0; n<ballNum; n++ )
    {
       Ball *ball = new Ball( m_ballPixmaps, m_field );
       m_balls.append( ball );
       ball->setVelocity( ((rand() & 1)*2-1)*2, ((rand() & 1)*2-1)*2 );
       ball->setFrame( rand() % 25 );
       ball->move( 4*TILE_SIZE + ( rand() - 50 ) % ( (FIELD_WIDTH-8)*TILE_SIZE ),
                   4*TILE_SIZE + rand() % ( (FIELD_HEIGHT-8)*TILE_SIZE ) );
       ball->show();
    }
-   
+
    // create arrow
    arrow = new Arrow( m_arrowPixmaps, m_field );
    arrow->show();
 
    // create text label
    m_text = new QCanvasText( m_field );
 
    // create game clock
    m_clock = new QTimer( this );
    connect( m_clock, SIGNAL(timeout()), this, SLOT(tick()) );
    m_clock->start( GAME_DELAY );
 
    // setup geometry
    setFixedSize( m_view->size() );
 }
 
 JezzGame::~JezzGame()
 {
     m_balls.clear();
     delete m_view;
     delete m_field;
     delete m_ballPixmaps;
 }
 
 void JezzGame::display( QString text, int size )
 {
-    odebug << "This function \"display\" shouldn't be called!!!" << oendl; 
+    odebug << "This function \"display\" shouldn't be called!!!" << oendl;
     if ( !text.isEmpty() )
     {
         QFont font( "Helvetica", size, QFont::Bold );
         font.setStyleHint( QFont::Helvetica );
         m_text->setFont( font );
         m_text->setText( text );
 
         QRect size = m_text->boundingRect();
         m_text->move( ( FIELD_WIDTH*TILE_SIZE - size.width() ) / 2,
                       ( FIELD_HEIGHT*TILE_SIZE - size.height() ) / 2 );
 
         m_text->show();
     } else
     {
         m_text->hide();
     }
 }
 
 void JezzGame::start()
 {
     m_running = true;
 }
 
 void JezzGame::stop()
 {
     m_running = false;
 }
 
 
 void JezzGame::makeBlack()
 {
    // copy current field into buffer
    for ( int y=0; y<FIELD_HEIGHT; y++ )
       for ( int x=0; x<FIELD_WIDTH; x++ )
          m_buf[x][y] = m_field->tile( x, y );
 
    // fill areas that contains a ball
    for ( Ball *ball=m_balls.first(); ball!=0; ball=m_balls.next() )
-      fill( ball->x()/TILE_SIZE, ball->y()/TILE_SIZE );
+      fill( static_cast<int>( ball->x()/TILE_SIZE ),
+            static_cast<int>( ball->y()/TILE_SIZE ) );
 
    // areas still free can be blacked now
    for ( int y=0; y<FIELD_HEIGHT; y++ )
       for ( int x=0; x<FIELD_WIDTH; x++ )
       {
          if ( m_buf[x][y]==TILE_FREE )
              m_field->setGameTile( x, y, true );
       }
 
    m_field->update();
    m_view->repaint();
 
    // count percent value of occupied area
    int p = percent();
    if ( p!=m_percent )
    {
        m_percent = p;
        emit newPercent( m_percent );
    }
 }
 
 int JezzGame::percent()
 {
    int notFree = 0;
    for ( int y=1; y<FIELD_HEIGHT-1; y++ )
       for ( int x=1; x<FIELD_WIDTH-1; x++ )
       {
          if ( m_field->tile(x,y)!=TILE_FREE )
              notFree++;
       }
 
    return 100 * notFree / ( (FIELD_WIDTH-1) * (FIELD_HEIGHT-1) );
 }
 
 void JezzGame::fill( int x, int y )
 {
    if ( m_buf[x][y]!=TILE_FREE) return;
 
    // go left
    int _x=x;
    for ( ; m_buf[_x][y]==TILE_FREE; _x-- )
       m_buf[_x][y] = TILE_BORDER;
    int stopx = _x;
 
    // fill above
    for ( _x=x; _x>stopx; _x-- )
       if ( m_buf[_x][y-1]==TILE_FREE ) fill( _x, y-1 );
 
    // fill below
    for ( _x=x; _x>stopx; _x-- )
       if ( m_buf[_x][y+1]==TILE_FREE ) fill( _x, y+1 );
 
    // go right
    for ( _x=x+1; m_buf[_x][y]==TILE_FREE; _x++ )
       m_buf[_x][y] = TILE_BORDER;
    stopx = _x;
 
    // fill above
    for ( _x=x+1; _x<stopx; _x++ )
       if ( m_buf[_x][y-1]==TILE_FREE ) fill( _x, y-1 );
 
    // fill below;
    for ( _x=x+1; _x<stopx; _x++ )
       if ( m_buf[_x][y+1]==TILE_FREE ) fill( _x, y+1 );
 }
 
 void JezzGame::ballCollision( Ball*, int, int, int tile )
 {
    if ( tile!=TILE_BORDER && tile>TILE_FREE && tile!=TILE_WALLEND )
    {
       // stop walls
       if ( (tile==TILE_WALLUP || tile==TILE_WALLLEFT) && m_wall1 )
       {
           m_wall1->finish();
           m_wall1->fill( false );
           delete m_wall1;
           m_wall1 = 0;
       }
 
       if ( (tile==TILE_WALLDOWN || tile==TILE_WALLRIGHT) && m_wall2 )
       {
           m_wall2->finish();
           m_wall2->fill( false );
           delete m_wall2;
           m_wall2 = 0;
       }
 
       // update view
       m_field->update();
       m_view->repaint();
 
       // send death msg
       emit died();
    }
 }
 
diff --git a/noncore/games/kbill/Game.cc b/noncore/games/kbill/Game.cc
index 624b50b..4cd5322 100644
--- a/noncore/games/kbill/Game.cc
+++ b/noncore/games/kbill/Game.cc
@@ -1,246 +1,246 @@
 #include "objects.h"
 
 Horde bill;
 Network net;
 Library OS;
 Bucket bucket;
 Spark spark;
 //Scorelist scores;
 Game game;
 UI ui;
 
 int Game::RAND(int lb, int ub) {
 	return (rand()%(ub-lb+1) + lb);
 }
 
 int Game::MAX(int x, int y) {
 	return (x>y ? x : y);
 }
 
 int Game::MIN(int x, int y) {
 	return (x<y ? x : y);
 }
 
 int Game::INTERSECT(int x1, int y1, int w1, int h1, int x2, int y2, int w2,
 	int h2)
 {
 	return (((x2-x1<=w1 && x2-x1>=0) || (x1-x2<=w2 && x1-x2>=0))
 		&& ((y2-y1<=h1 && y2-y1>=0) || (y1-y2<=h2 && y1-y2>=0)));
 }
 
 void Game::setup_level (unsigned int lev) {
 	level = lev;
 	bill.setup();
 	grabbed = EMPTY;
 	ui.set_cursor(DEFAULTC);
 	net.setup();
 	iteration = efficiency = 0;
 }
 
 void Game::start(unsigned int lev) {
 	state = PLAYING;
 	score = 0;
 	ui.restart_timer();
 	ui.set_pausebutton(true);
 	setup_level(lev);
 }
 
 void Game::quit() {
 
 	exit(0);
 }
 
 void Game::update_info() {
 	static char str[80];
 	sprintf (str, "Bill:%d/%d  System:%d/%d/%d  Level:%d  Score:%d",
 		bill.on_screen, bill.off_screen, net.base, net.off,
 		net.win, level, score);
 	ui.draw_str(str, 5, scrheight-5);
 	efficiency += ((100*net.base-10*net.win)/net.units);
 }
-  
+
 void Game::update_score (int action) {
 	switch (action){
 		case ENDLEVEL: score+=(level*efficiency/iteration); break;
 		default: score+=(action*action*BILLPOINTS);
 	}
 }
 
 void Game::warp_to_level (unsigned int lev) {
 	if (state==PLAYING) {
 		if (lev <= level) return;
 		setup_level(lev);
 	}
 	else {
-		if (lev<=0) return;
+		if (lev <=0) return;
 		start(lev);
 	}
 }
 
 void Game::button_press(int x, int y) {
 	int i, counter=0, flag=0;
 	if (state != PLAYING) return;
 	ui.set_cursor(DOWNC);
 	if (bucket.clicked(x, y)) {
 		ui.set_cursor(BUCKETC);
 		grabbed = BUCKET;
 	}
 	for (i=0; i < bill.MAX_BILLS && !flag; i++) {
 		if (bill.list[i].state == bill.list[i].OFF
 			|| bill.list[i].state == bill.list[i].DYING)
 				continue;
 		if (bill.list[i].state == bill.list[i].STRAY &&
 			bill.list[i].clickedstray(x, y))
 		{
 			ui.set_cursor (bill.list[i].cargo);
 			grabbed = i;
 			flag = 1;
 		}
 		else if (bill.list[i].state != bill.list[i].STRAY &&
 			bill.list[i].clicked(x, y))
 		{
-			if (bill.list[i].state == bill.list[i].AT) 
+			if (bill.list[i].state == bill.list[i].AT)
 				net.computers[bill.list[i].target_c].busy=0;
 			bill.list[i].index = -1;
 			bill.list[i].cels = bill.dcels;
 			bill.list[i].x_offset = -2;
 			bill.list[i].y_offset = -15;
 			bill.list[i].state = bill.list[i].DYING;
 			counter++;
 		}
 	}
 	if (counter) update_score(counter);
 }
 
 void Game::button_release(int x, int y) {
 	int i;
 	ui.set_cursor (DEFAULTC);
 	if (state != PLAYING || grabbed == EMPTY)
 		return;
 	if (grabbed == BUCKET) {
 		grabbed = EMPTY;
 		for (i=0; i<net.ncables; i++)
 			if (net.cables[i].onspark(x, y)) {
 				net.cables[i].active=0;
 				net.cables[i].delay = spark.delay(level);
 			}
 		return;
 	}
 	for (i=0; i<net.units; i++)
 		if (net.computers[i].oncomputer(x, y)
 			&&
 			net.computers[i].compatible (bill.list[grabbed].cargo)
 			&&
-			(net.computers[i].os == OS.WINGDOWS || 
+			(net.computers[i].os == OS.WINGDOWS ||
 			 net.computers[i].os == OS.OFF))
 		{
-			net.base++; 
+			net.base++;
 			if (net.computers[i].os == OS.WINGDOWS)
 				net.win--;
 			else
 				net.off--;
 			net.computers[i].os = bill.list[grabbed].cargo;
 			bill.list[grabbed].state = bill.list[grabbed].OFF;
 			grabbed = EMPTY;
 			return;
 		}
 	grabbed = EMPTY;
-}	
+}
 
 void Game::update() {
 	switch (state) {
 	case PLAYING:
-		ui.clear(); 
+		ui.clear();
 		bucket.draw();
 		net.update();
 		net.draw();
 		bill.update();
 		bill.draw();
 		update_info();
 		if (!(bill.on_screen+bill.off_screen)) {
 			update_score(ENDLEVEL);
 			state = BETWEEN;
 		}
 		if ((net.base+net.off)<=1) state = END;
 		break;
 	case END:
 		ui.clear();
 		net.toasters();
 		net.draw();
 		ui.refresh();
 		ui.popup_dialog(ENDGAME);
 /*		if (score > scores.score[9]) ui.popup_dialog(ENTERNAME);
 		scores.update();*/
 		ui.popup_dialog(HIGHSCORE);
 		ui.clear();
 		ui.draw_centered(logo);
 		ui.kill_timer();
 		ui.set_pausebutton (false);
 		state = WAITING;
 		break;
 	case BETWEEN:
 		ui.update_scorebox(level, score);
 		ui.popup_dialog (SCORE);
 		state = PLAYING;
 		setup_level(++level);
 		break;
 	}
 	ui.refresh();
 	iteration++;
 }
 
 void Game::main(int argc, char **argv) {
 	int c;
 	extern char *optarg;
 
 	level = 0;
 	ui.initialize(&argc, argv);
 	while (argv && argv[0] && (c = getopt(argc, argv, "l:L:")) != -1)
 		switch(c) {
 			case 'l':
 			case 'L': level = MAX (1, atoi(optarg)); break;
 		}
 	srand(time(NULL));
 	ui.make_mainwin();
 	ui.graph_init();
 	ui.clear();
 	logo.load("logo");
 	ui.draw_centered(logo);
 	ui.refresh();
 	ui.make_windows();
 // 	scores.read();
 // 	scores.update();
 
 	bill.load_pix();
 	OS.load_pix();
 	net.load_pix();
 	bucket.load_pix();
 	spark.load_pix();
 
 	ui.load_cursors();
 
 	state = WAITING;
 	if (level) start(level);
 	else ui.set_pausebutton(false);
 	ui.MainLoop();
 	exit(0);
 }
 
 int main(int argc, char **argv) {
 	if (argc>1 && !strcmp(argv[1], "-v")) {
 		printf ("XBill version 2.0\n\n");
 		exit(0);
 	}
 	if (argc>1 && !strcmp(argv[1], "-h")) {
 		printf ("XBill version 2.0\n");
 		printf ("Options:\n");
 		printf ("-l n, -L n\tStart at level n.\n");
 		printf ("-v\t\tPrint version number and exit.\n");
 		printf ("-h\t\tPrint help and exit.\n");
 		printf ("leaves the window.\n");
 		printf ("All standard X Intrinsics options are also ");
 		printf ("supported.\n\n");
 		exit(0);
 	}
 	game.main(argc, argv);
 }
diff --git a/noncore/games/kbill/Game.h b/noncore/games/kbill/Game.h
index 4473936..5c9c497 100644
--- a/noncore/games/kbill/Game.h
+++ b/noncore/games/kbill/Game.h
@@ -1,55 +1,55 @@
 #ifndef GAME_H
 #define GAME_H
 
 #include "objects.h"
 
 class Game {
-	unsigned state;
+	int state;
 	int efficiency;
 public:
 	unsigned score, level, iteration;
 	Picture logo;
 	int grabbed;
 
 	static const unsigned short scrwidth = 240;
 	static const unsigned short scrheight = 290;
 
 	static const int PLAYING = 1;
 	static const int BETWEEN = 2;
 	static const int END = 3;
 	static const int WAITING = 4;
 
 	static const int DEFAULTC = 0;		/* cursors */
 	static const int DOWNC = -1;
 	static const int BUCKETC = -2;
 
 	static const int ENDGAME = 200;		/* dialog window IDs */
 	static const int ENTERNAME = 201;
 	static const int HIGHSCORE = 202;
 	static const int SCORE = 203;
 
 	static const int ENDLEVEL = -1;		/* Codes for updating score */
 	static const int BILLPOINTS = 5;
 
 	static const int EMPTY = -2;		/* Grabbed object */
 	static const int BUCKET = -1;
 
 	int RAND(int lb, int ub);
 	int MAX(int x, int y);
 	int MIN(int x, int y);
 	int INTERSECT(int x1, int y1, int w1, int h1, int x2, int y2, int w2,
 		int h2);
 
 	void setup_level (unsigned int lev);
 	void start(unsigned int lev);
 	void quit();
 	void update_info();
 	void update_score (int action);
 	void warp_to_level (unsigned int lev);
 	void button_press(int x, int y);
 	void button_release(int x, int y);
 	void update();
 	void main(int argc, char **argv);
 };
 
 #endif
diff --git a/noncore/games/kbill/field.cpp b/noncore/games/kbill/field.cpp
index a974ab2..0dd8d72 100644
--- a/noncore/games/kbill/field.cpp
+++ b/noncore/games/kbill/field.cpp
@@ -1,83 +1,83 @@
 /***************************************************************************
                           field.cpp  -  description
                              -------------------
     begin                : Thu Dec 30 1999
     copyright            : (C) 1999 by Jurrien Loonstra
     email                : j.h.loonstra@st.hanze.nl
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 
 #include "objects.h"
 
 #include "field.h"
 
 Field::Field(QWidget *parent, const char *name ) : QWidget(parent,name) {
 	setFixedSize(game.scrwidth, game.scrheight);
 	setBackgroundColor(white);
 	timer = new QTimer(this);
 
 	playing = false;
 
 	connect(timer, SIGNAL(timeout()), SLOT(Timer()));
 }
 
 Field::~Field(){
 	delete timer;
 }
 
 void Field::setPixmap(QPixmap *pix) {
 	this->pix = pix;
 }
 
 // --------------------------------------------------------
 
 void Field::mousePressEvent(QMouseEvent *e){
 	game.button_press(e->x(), e->y());
 }
 
 void Field::mouseReleaseEvent(QMouseEvent *e){
 	game.button_release(e->x(), e->y());
 }
 
 void Field::enterEvent(QEvent *) {
 	if (playing && !timer->isActive()) {
 		playing = true;
 		timer->start(250, FALSE);
 	}
 }
 
 void Field::leaveEvent(QEvent *) {
 	if (timer->isActive() && playing) {
 		playing = true;
 		timer->stop();
 	}
 }
 
 void Field::stopTimer() {
 	playing = false;
 	if (timer->isActive())
 		timer->stop();
 }
 
 void Field::startTimer() {
 	playing = true;
 	if (!timer->isActive())
 		timer->start(250, FALSE);
 }
 
 void Field::Timer(){
 	game.update();
 }
 
 void Field::paintEvent(QPaintEvent *) {
 	bitBlt(this, 0, 0, pix);
-}			
\ No newline at end of file
+}
diff --git a/noncore/games/kbill/inputbox.cpp b/noncore/games/kbill/inputbox.cpp
index 5087fbb..7aaebe7 100644
--- a/noncore/games/kbill/inputbox.cpp
+++ b/noncore/games/kbill/inputbox.cpp
@@ -1,50 +1,50 @@
 /***************************************************************************
                           inputbox.cpp  -  description
                              -------------------
     begin                : Sat Jan 1 2000
     copyright            : (C) 2000 by Jurrien Loonstra
     email                : j.h.loonstra@st.hanze.nl
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "inputbox.h"
-InputBox::InputBox(QWidget *parent, const char *name, const char *caption, const char *text) : QDialog(parent, name, TRUE) {
+InputBox::InputBox(QWidget *parent, const char *name, const char *, const char *) : QDialog(parent, name, TRUE) {
 // 	setCaption(caption);
-// 
+//
 // 	question = new QLabel(this);
 // 	question->setText(text);
 // 	question->setGeometry(10, 10, 240, 50);
-// 
+//
 // 	input = new QLineEdit(this);
 //   input->setGeometry(10, 60, 240, 30);
 // 	input->setFocus();
 // 	input->setMaxLength(19);
-// 
+//
 //   ok = new QPushButton( "Ok", this );
 //   ok->setGeometry(10, 100, 100,30 );
 // 	ok->setDefault(TRUE);
 //   connect( ok, SIGNAL(clicked()), SLOT(accept()) );
-// 
+//
 //   cancel = new QPushButton( "Cancel", this );
 //   cancel->setGeometry(150, 100, 100,30 );
 //   connect( cancel, SIGNAL(clicked()), SLOT(reject()) );
 }
 
 InputBox::~InputBox(){
 	delete ok;
 	delete cancel;
 	delete question;
 	delete input;
 }
 
 QString InputBox::getText() const{
 	return input->text();
 }
diff --git a/noncore/games/kbill/kbill.h b/noncore/games/kbill/kbill.h
index fbc0c6c..da1a111 100644
--- a/noncore/games/kbill/kbill.h
+++ b/noncore/games/kbill/kbill.h
@@ -1,54 +1,56 @@
 /***************************************************************************
                           kbill.h  -  description
                              -------------------
     begin                : Thu Dec 30 16:55:55 CET 1999
     copyright            : (C) 1999 by Jurrien Loonstra
     email                : j.h.loonstra@st.hanze.nl
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KBILL_H
 #define KBILL_H
 
 
 
 #include <qmainwindow.h>
 #include <qwidget.h>
 #include <qpopupmenu.h>
 
 #include "field.h"
 
 class KBill : public QMainWindow
 {
-  Q_OBJECT 
-  public:
+  Q_OBJECT
+public:
     KBill();
-    ~KBill();
-		Field* getField();
-	private:
-		QMenuBar *menu;
-		QPopupMenu *file, *help;
-  	Field *field;
-		int pauseid;
-	protected slots:
-  	void Quit();
-  	void About();
-  	void NewGame();
-	  void Pause();
-	  void WarpTo();
-		void Story();
-		void Rules();
-		void ViewHighScores();
-
-	friend class UI;
+   ~KBill();
+    Field* getField();
+private:
+    QMenuBar *menu;
+    QPopupMenu *file, *help;
+    Field *field;
+    int pauseid;
+
+protected slots:
+    void Quit();
+    void About();
+    void NewGame();
+    void Pause();
+    void WarpTo();
+    void Story();
+    void Rules();
+    void ViewHighScores();
+
+protected:
+    friend class UI;
 };
 
 #endif
diff --git a/noncore/games/zsame/ZSameWidget.cpp b/noncore/games/zsame/ZSameWidget.cpp
index 4fab0f6..04ad825 100644
--- a/noncore/games/zsame/ZSameWidget.cpp
+++ b/noncore/games/zsame/ZSameWidget.cpp
@@ -16,229 +16,229 @@
  *   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) {
+void ZSameWidget::readProperties(Config *) {
 /*
   Q_ASSERT(conf);
   stone->readProperties(conf);
 */
 }
 
-void ZSameWidget::saveProperties(Config *conf) {
+void ZSameWidget::saveProperties(Config *) {
 /*
   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) {
+void ZSameWidget::setColors(int ) {
 //	status->changeItem(i18n("%1 Colors").arg(colors),1);
 }
 
-void ZSameWidget::setBoard(int board) {
+void ZSameWidget::setBoard(int ) {
 //	status->changeItem(i18n("Board: %1").arg(board, 6), 2);
 }
 
-void ZSameWidget::setMarked(int m) {
+void ZSameWidget::setMarked(int ) {
 //  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) {
+void ZSameWidget::setScore(int ) {
 //  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;
     }
 }