1 files changed, 2 insertions, 0 deletions

diff --git a/noncore/games/tictac/tictac.cpp b/noncore/games/tictac/tictac.cpp
index 12ce35f..db8ee1e 100644
--- a/noncore/games/tictac/tictac.cpp
+++ b/noncore/games/tictac/tictac.cpp
@@ -18,128 +18,129 @@
 
 
 //***************************************************************************
 //* TicTacButton member functions
 //***************************************************************************
 
 // --------------------------------------------------------------------------
 // Creates a TicTacButton
 //
 
 TicTacButton::TicTacButton( QWidget *parent ) : QPushButton( parent )
 {
     t = Blank;          // initial type
 }
 
 // --------------------------------------------------------------------------
 // Paints TicTacButton
 //
 
 void TicTacButton::drawButtonLabel( QPainter *p )
 {
     QRect r = rect();
     p->setPen( QPen( white,2 ) );   // set fat pen
     if ( t == Circle ) {
         p->drawEllipse( r.left()+4, r.top()+4, r.width()-8, r.height()-8 );
     } else if ( t == Cross ) {      // draw cross
         p->drawLine( r.topLeft()   +QPoint(4,4), r.bottomRight()-QPoint(4,4));
         p->drawLine( r.bottomLeft()+QPoint(4,-4),r.topRight()   -QPoint(4,-4));
     }
 }
 
 
 //***************************************************************************
 //* TicTacGameBoard member functions
 //***************************************************************************
 
 // --------------------------------------------------------------------------
 // Creates a game board with N x N buttons and connects the "clicked()"
 // signal of all buttons to the "buttonClicked()" slot.
 //
 
 TicTacGameBoard::TicTacGameBoard( int n, QWidget *parent, const char *name )
         : QWidget( parent, name )
 {
     QPEApplication::showWidget( this );
     st = Init;          // initial state
     nBoard = n;
     n *= n;         // make square
     comp_starts = FALSE;      // human starts
     buttons = new TicTacButtons(n);   // create real buttons
     btArray = new TicTacArray(n);   // create button model
     QGridLayout * grid = new QGridLayout( this, 3, 3, 4 );
     QPalette p( blue );
     for ( int i=0; i<n; i++ ) {     // create and connect buttons
         TicTacButton *ttb = new TicTacButton( this );
         ttb->setPalette( p );
         ttb->setEnabled( FALSE );
         connect( ttb, SIGNAL(clicked()), SLOT(buttonClicked()) );
         grid->addWidget( ttb, i%3, i/3 );
         buttons->insert( i, ttb );
         btArray->at(i) = TicTacButton::Blank; // initial button type
     }
     QTime t = QTime::currentTime();   // set random seed
     srand( t.hour()*12+t.minute()*60+t.second()*60 );
+                
 }
 
 TicTacGameBoard::~TicTacGameBoard()
 {
     delete buttons;
     delete btArray;
 }
 
 
 // --------------------------------------------------------------------------
 // TicTacGameBoard::computerStarts( bool v )
 //
 // Computer starts if v=TRUE. The human starts by default.
 //
 
 void TicTacGameBoard::computerStarts( bool v )
 {
     comp_starts = v;
 }
 
 
 // --------------------------------------------------------------------------
 // TicTacGameBoard::newGame()
 //
 // Clears the game board and prepares for a new game
 //
 
 void TicTacGameBoard::newGame()
 {
     st = HumansTurn;
     for ( int i=0; i<nBoard*nBoard; i++ )
         btArray->at(i) = TicTacButton::Blank;
     if ( comp_starts )
         computerMove();
     else
         updateButtons();
 }
 
 
 // --------------------------------------------------------------------------
 // TicTacGameBoard::buttonClicked()   - SLOT
 //
 // This slot is activated when a TicTacButton emits the signal "clicked()",
 // i.e. the user has clicked on a TicTacButton.
 //
 
 void TicTacGameBoard::buttonClicked()
 {
     if ( st != HumansTurn )     // not ready
         return;
     int i = buttons->findRef( (TicTacButton*)sender() );
     TicTacButton *b = buttons->at(i);   // get piece that was pressed
     if ( b->type() == TicTacButton::Blank ) { // empty piece?
         btArray->at(i) = TicTacButton::Circle;
         updateButtons();
         if ( checkBoard( btArray ) == 0 ) // not a winning move?
             computerMove();
         int s = checkBoard( btArray );
         if ( s ) {        // any winners yet?
             st = s == TicTacButton::Circle ? HumanWon : ComputerWon;
             emit finished();
         }
     }
 }
@@ -268,111 +269,112 @@ void TicTacGameBoard::computerMove()
             st = NobodyWon;
             emit finished();
         }
     }
     *btArray = a;       // update model
     updateButtons();        // update buttons
     delete[] altv;
 }
 
 
 //***************************************************************************
 //* TicTacToe member functions
 //***************************************************************************
 
 // --------------------------------------------------------------------------
 // Creates a game widget with a game board and two push buttons, and connects
 // signals of child widgets to slots.
 //
 
 TicTacToe::TicTacToe( QWidget *parent, const char *name, WFlags fl )
         : QWidget( parent, name, fl )
 {
     QVBoxLayout * l = new QVBoxLayout( this, 6 );
 
       // Create a message label
     boardSize = 3;
 
     message = new QLabel( this );
     message->setFrameStyle( QFrame::WinPanel | QFrame::Sunken );
     message->setAlignment( AlignCenter );
     l->addWidget( message );
 
       // Create the game board and connect the signal finished() to this
       // gameOver() slot
 
     board = new TicTacGameBoard( boardSize, this );
     connect( board, SIGNAL(finished()), SLOT(gameOver()) );
     l->addWidget( board );
 
       // Create a horizontal frame line
 
     QFrame *line = new QFrame( this );
     line->setFrameStyle( QFrame::HLine | QFrame::Sunken );
     l->addWidget( line );
 
       // Create the combo box for deciding who should start, and
       // connect its clicked() signals to the buttonClicked() slot
 
     whoStarts = new QComboBox( this );
     whoStarts->insertItem( tr( "Computer starts" ) );
     whoStarts->insertItem( tr( "Human starts" ) );
     l->addWidget( whoStarts );
 
       // Create the push buttons and connect their clicked() signals
       // to this right slots.
 
     newGame = new QPushButton( tr( "Play!" ), this );
     connect( newGame, SIGNAL(clicked()), SLOT(newGameClicked()) );
     quit = new QPushButton( tr( "Quit" ), this );
     connect( quit, SIGNAL(clicked()), qApp, SLOT(quit()) );
     QHBoxLayout * b = new QHBoxLayout;
     l->addLayout( b );
     b->addWidget( newGame );
     b->addWidget( quit );
+                move(0,0);
     QPEApplication::showWidget( this );
     newState();
 }
 
 
 // --------------------------------------------------------------------------
 // TicTacToe::newGameClicked()      - SLOT
 //
 // This slot is activated when the new game button is clicked.
 //
 
 void TicTacToe::newGameClicked()
 {
     board->computerStarts( whoStarts->currentItem() == 0 );
     board->newGame();
     newState();
 }
 
 
 // --------------------------------------------------------------------------
 // TicTacToe::gameOver()      - SLOT
 //
 // This slot is activated when the TicTacGameBoard emits the signal
 // "finished()", i.e. when a player has won or when it is a draw.
 //
 
 void TicTacToe::gameOver()
 {
     newState();         // update text box
 }
 
 
 // --------------------------------------------------------------------------
 // Updates the message to reflect a new state.
 //
 
 void TicTacToe::newState()
 {
     QStringList msg;
     msg << tr( "Click Play to start")
         << tr("Make your move")
         << tr("You won!")
         << tr("Computer won!")
         << tr("It's a draw");
     message->setText( msg[board->state()] );
     return;
 }