Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731

6 files changed, 563 insertions, 0 deletions

diff --git a/examples/tictac/README b/examples/tictac/README
new file mode 100644
index 000000000..150f5d84b
--- /dev/null
+++ b/examples/tictac/README
@@ -0,0 +1,7 @@
+This is a very simple implementation of the tic-tac-toe game.
+
+We didn't put much effort in making a clever algorithm so it's not a
+challenge to play against the computer. Instead, study the source code to
+see how you can make reusable components such as the TicTacGameBoard
+widget.
+
diff --git a/examples/tictac/main.cpp b/examples/tictac/main.cpp
new file mode 100644
index 000000000..1a18598c9
--- /dev/null
+++ b/examples/tictac/main.cpp
@@ -0,0 +1,30 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of an example program for TQt.  This example
+** program may be used, distributed and modified without limitation.
+**
+*****************************************************************************/
+
+#include <qapplication.h>
+#include <stdlib.h>
+#include "tictac.h"
+
+
+int main( int argc, char **argv )
+{
+    TQApplication a( argc, argv );
+    int n = 3;
+    if ( argc == 2 )				// get board size n
+        n = atoi(argv[1]);
+    if ( n < 3 || n > 10 ) {			// out of range
+        qWarning( "%s: Board size must be from 3x3 to 10x10", argv[0] );
+        return 1;
+    }
+    TicTacToe ttt( n );				// create game
+    a.setMainWidget( &ttt );
+    ttt.setCaption("TQt Example - TicTac");
+    ttt.show();					// show widget
+    return a.exec();				// go
+}
diff --git a/examples/tictac/tictac.cpp b/examples/tictac/tictac.cpp
new file mode 100644
index 000000000..60cd0eb71
--- /dev/null
+++ b/examples/tictac/tictac.cpp
@@ -0,0 +1,375 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of an example program for TQt.  This example
+** program may be used, distributed and modified without limitation.
+**
+*****************************************************************************/
+
+#include "tictac.h"
+#include <qapplication.h>
+#include <qpainter.h>
+#include <qdrawutil.h>
+#include <qcombobox.h>
+#include <qcheckbox.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <stdlib.h>				// rand() function
+#include <qdatetime.h>				// seed for rand()
+
+
+//***************************************************************************
+//* TicTacButton member functions
+//***************************************************************************
+
+// --------------------------------------------------------------------------
+// Creates a TicTacButton
+//
+
+TicTacButton::TicTacButton( TQWidget *parent ) : TQPushButton( parent )
+{
+    t = Blank;					// initial type
+}
+
+// --------------------------------------------------------------------------
+// Paints TicTacButton
+//
+
+void TicTacButton::drawButtonLabel( TQPainter *p )
+{
+    TQRect r = rect();
+    p->setPen( TQPen( 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()   +TQPoint(4,4), r.bottomRight()-TQPoint(4,4));
+	p->drawLine( r.bottomLeft()+TQPoint(4,-4),r.topRight()   -TQPoint(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, TQWidget *parent, const char *name )
+    : TQWidget( parent, name )
+{
+    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
+    TQGridLayout * grid = new TQGridLayout( this, nBoard, nBoard, 4 );
+    TQPalette 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%nBoard, i/nBoard );
+	buttons->insert( i, ttb );
+	btArray->at(i) = TicTacButton::Blank;	// initial button type
+    }
+    TQTime t = TQTime::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();
+	}
+    }
+}
+
+
+// --------------------------------------------------------------------------
+// TicTacGameBoard::updateButtons()
+//
+// Updates all buttons that have changed state
+//
+
+void TicTacGameBoard::updateButtons()
+{
+    for ( int i=0; i<nBoard*nBoard; i++ ) {
+	if ( buttons->at(i)->type() != btArray->at(i) )
+	    buttons->at(i)->setType( (TicTacButton::Type)btArray->at(i) );
+	buttons->at(i)->setEnabled( buttons->at(i)->type() ==
+				    TicTacButton::Blank );
+    }
+}
+
+
+// --------------------------------------------------------------------------
+// TicTacGameBoard::checkBoard()
+//
+// Checks if one of the players won the game, works for any board size.
+//
+// Returns:
+//  - TicTacButton::Cross  if the player with X buttons won
+//  - TicTacButton::Circle if the player with O buttons won
+//  - Zero (0) if there is no winner yet
+//
+
+int TicTacGameBoard::checkBoard( TicTacArray *a )
+{
+    int  t = 0;
+    int  row, col;
+    bool won = FALSE;
+    for ( row=0; row<nBoard && !won; row++ ) {	// check horizontal
+	t = a->at(row*nBoard);
+	if ( t == TicTacButton::Blank )
+	    continue;
+	col = 1;
+	while ( col<nBoard && a->at(row*nBoard+col) == t )
+	    col++;
+	if ( col == nBoard )
+	    won = TRUE;
+    }
+    for ( col=0; col<nBoard && !won; col++ ) {	// check vertical
+	t = a->at(col);
+	if ( t == TicTacButton::Blank )
+	    continue;
+	row = 1;
+	while ( row<nBoard && a->at(row*nBoard+col) == t )
+	    row++;
+	if ( row == nBoard )
+	    won = TRUE;
+    }
+    if ( !won ) {				// check diagonal top left
+	t = a->at(0);				//   to bottom right
+	if ( t != TicTacButton::Blank ) {
+	    int i = 1;
+	    while ( i<nBoard && a->at(i*nBoard+i) == t )
+		i++;
+	    if ( i == nBoard )
+		won = TRUE;
+	}
+    }
+    if ( !won ) {				// check diagonal bottom left
+	int j = nBoard-1;			//   to top right
+	int i = 0;
+	t = a->at(i+j*nBoard);
+	if ( t != TicTacButton::Blank ) {
+	    i++; j--;
+	    while ( i<nBoard && a->at(i+j*nBoard) == t ) {
+		i++; j--;
+	    }
+	    if ( i == nBoard )
+		won = TRUE;
+	}
+    }
+    if ( !won )					// no winner
+	t = 0;
+    return t;
+}
+
+
+// --------------------------------------------------------------------------
+// TicTacGameBoard::computerMove()
+//
+// Puts a piece on the game board. Very, very simple.
+//
+
+void TicTacGameBoard::computerMove()
+{
+    int numButtons = nBoard*nBoard;
+    int *altv = new int[numButtons];		// buttons alternatives
+    int altc = 0;
+    int stopHuman = -1;
+    TicTacArray a = btArray->copy();
+    int i;
+    for ( i=0; i<numButtons; i++ ) {		// try all positions
+	if ( a[i] != TicTacButton::Blank )	// already a piece there
+	    continue;
+	a[i] = TicTacButton::Cross;		// test if computer wins
+	if ( checkBoard(&a) == a[i] ) {		// computer will win
+	    st = ComputerWon;
+	    stopHuman = -1;
+	    break;
+	}
+	a[i] = TicTacButton::Circle;		// test if human wins
+	if ( checkBoard(&a) == a[i] ) {		// oops...
+	    stopHuman = i;			// remember position
+	    a[i] = TicTacButton::Blank;		// restore button
+	    continue;				// computer still might win
+	}
+	a[i] = TicTacButton::Blank;		// restore button
+	altv[altc++] = i;			// remember alternative
+    }
+    if ( stopHuman >= 0 )			// must stop human from winning
+	a[stopHuman] = TicTacButton::Cross;
+    else if ( i == numButtons ) {		// tried all alternatives
+	if ( altc > 0 )				// set random piece
+	    a[altv[rand()%(altc--)]] = TicTacButton::Cross;
+	if ( altc == 0 ) {			// no more blanks
+	    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( int boardSize, TQWidget *parent, const char *name )
+    : TQWidget( parent, name )
+{
+    TQVBoxLayout * l = new TQVBoxLayout( this, 6 );
+
+    // Create a message label
+
+    message = new TQLabel( this );
+    message->setFrameStyle( TQFrame::WinPanel | TQFrame::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
+
+    TQFrame *line = new TQFrame( this );
+    line->setFrameStyle( TQFrame::HLine | TQFrame::Sunken );
+    l->addWidget( line );
+
+    // Create the combo box for deciding who should start, and
+    // connect its clicked() signals to the buttonClicked() slot
+
+    whoStarts = new TQComboBox( this );
+    whoStarts->insertItem( "Computer starts" );
+    whoStarts->insertItem( "Human starts" );
+    l->addWidget( whoStarts );
+
+    // Create the push buttons and connect their clicked() signals
+    // to this right slots.
+
+    newGame = new TQPushButton( "Play!", this );
+    connect( newGame, SIGNAL(clicked()), SLOT(newGameClicked()) );
+    tquit = new TQPushButton( "Quit", this );
+    connect( tquit, SIGNAL(clicked()), qApp, SLOT(tquit()) );
+    TQHBoxLayout * b = new TQHBoxLayout;
+    l->addLayout( b );
+    b->addWidget( newGame );
+    b->addWidget( tquit );
+
+    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()
+{
+    static const char *msg[] = {		// TicTacGameBoard::State texts
+	"Click Play to start", "Make your move",
+	"You won!", "Computer won!", "It's a draw" };
+    message->setText( msg[board->state()] );
+    return;
+}
diff --git a/examples/tictac/tictac.doc b/examples/tictac/tictac.doc
new file mode 100644
index 000000000..05b16fb47
--- /dev/null
+++ b/examples/tictac/tictac.doc
@@ -0,0 +1,33 @@
+/*
+*/
+/*!   \page tictac-example.html
+
+  \ingroup examples
+  \title Tic Tac Toe
+
+  This is an implementation of the Tic-tac-toe game.
+
+  We didn't put much effort in making a clever algorithm so it's not a
+  challenge to play against the computer. Instead, study the source code
+  to see how you can make reusable components such as the \e TicTacGameBoard
+  widget.
+
+  <hr>
+
+  Header file:
+
+  \include tictac/tictac.h
+
+  <hr>
+
+  Implementation:
+
+  \include tictac/tictac.cpp
+
+  <hr>
+
+  Main:
+
+  \include tictac/main.cpp
+*/
+
diff --git a/examples/tictac/tictac.h b/examples/tictac/tictac.h
new file mode 100644
index 000000000..876def88d
--- /dev/null
+++ b/examples/tictac/tictac.h
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of an example program for TQt.  This example
+** program may be used, distributed and modified without limitation.
+**
+*****************************************************************************/
+
+#ifndef TICTAC_H
+#define TICTAC_H
+
+
+#include <qpushbutton.h>
+#include <qptrvector.h>
+
+class TQComboBox;
+class TQLabel;
+
+
+// --------------------------------------------------------------------------
+// TicTacButton implements a single tic-tac-toe button
+//
+
+class TicTacButton : public TQPushButton
+{
+    Q_OBJECT
+public:
+    TicTacButton( TQWidget *parent );
+    enum Type { Blank, Circle, Cross };
+    Type	type() const		{ return t; }
+    void	setType( Type type )	{ t = type; repaint(); }
+    TQSizePolicy sizePolicy() const
+    { return TQSizePolicy( TQSizePolicy::Preferred, TQSizePolicy::Preferred ); }
+    TQSize sizeHint() const { return TQSize( 32, 32 ); }
+    TQSize minimumSizeHint() const { return TQSize( 10, 10 ); }
+protected:
+    void	drawButtonLabel( TQPainter * );
+private:
+    Type t;
+};
+
+// Using template vector to make vector-class of TicTacButton.
+// This vector is used by the TicTacGameBoard class defined below.
+
+typedef TQPtrVector<TicTacButton>	TicTacButtons;
+typedef TQMemArray<int>		TicTacArray;
+
+
+// --------------------------------------------------------------------------
+// TicTacGameBoard implements the tic-tac-toe game board.
+// TicTacGameBoard is a composite widget that contains N x N TicTacButtons.
+// N is specified in the constructor.
+//
+
+class TicTacGameBoard : public TQWidget
+{
+    Q_OBJECT
+public:
+    TicTacGameBoard( int n, TQWidget *parent=0, const char *name=0 );
+   ~TicTacGameBoard();
+    enum	State { Init, HumansTurn, HumanWon, ComputerWon, NobodyWon };
+    State	state() const		{ return st; }
+    void	computerStarts( bool v );
+    void        newGame();
+signals:
+    void	finished();			// game finished
+private slots:
+    void	buttonClicked();
+private:
+    void        setState( State state ) { st = state; }
+    void	updateButtons();
+    int	checkBoard( TicTacArray * );
+    void	computerMove();
+    State	st;
+    int		nBoard;
+    bool	comp_starts;
+    TicTacArray *btArray;
+    TicTacButtons *buttons;
+};
+
+
+// --------------------------------------------------------------------------
+// TicTacToe implements the complete game.
+// TicTacToe is a composite widget that contains a TicTacGameBoard and
+// two push buttons for starting the game and tquitting.
+//
+
+class TicTacToe : public TQWidget
+{
+    Q_OBJECT
+public:
+    TicTacToe( int boardSize=3, TQWidget *parent=0, const char *name=0 );
+private slots:
+    void	newGameClicked();
+    void	gameOver();
+private:
+    void	newState();
+    TQComboBox	*whoStarts;
+    TQPushButton *newGame;
+    TQPushButton *tquit;
+    TQLabel	*message;
+    TicTacGameBoard *board;
+};
+
+
+#endif // TICTAC_H
diff --git a/examples/tictac/tictac.pro b/examples/tictac/tictac.pro
new file mode 100644
index 000000000..8ce064084
--- /dev/null
+++ b/examples/tictac/tictac.pro
@@ -0,0 +1,11 @@
+TEMPLATE	= app
+TARGET		= tictac
+
+CONFIG		+= qt warn_on release
+DEPENDPATH	= ../../include
+
+REQUIRES	= large-config
+
+HEADERS		= tictac.h
+SOURCES		= main.cpp \
+		  tictac.cpp