queensgui/src/queensmain.cpp

/***************************************************************************
 *   Copyright (C) 2005 by Torben Nielsen   *
 *   torben@t-hoerup.dk   *
 *                                                                         *
 *   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 <qapplication.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qlistbox.h>
#include <qpopupmenu.h>
#include <qpushbutton.h>
#include <qspinbox.h>
#include <qstring.h>


#include "queensmain.h"
#include "board.h"
#include "queens.h"
#include "solutionvector.h"
#include "solutionlist.h"
#include "solutionhash.h"
#include "solutionmnvector.h"

#include "config.h"

QueensMain::QueensMain(QWidget *parent, const char *name)
 : QDialog(parent, name)
{
    QVBoxLayout *mainlayout = new QVBoxLayout( this );
     
    m_board = new Board( this );
      
    m_start = new QPushButton("Start", this);
    m_quit = new QPushButton("Quit", this);
    m_stop = new QPushButton("Stop", this);
    m_stop->setEnabled( false );
    
    QHBoxLayout *upperlayout = new QHBoxLayout( mainlayout );
    QVBoxLayout *left = new QVBoxLayout( upperlayout );

    upperlayout->add( m_board );        
    m_list = new QListBox( this );

    m_list->setMinimumWidth( 180 );
    m_sizeSelector = new QSpinBox( this );
    m_status = new QLabel( this );
    
    left->add( m_list );
    left->add( m_sizeSelector );
    
    QHBoxLayout *buttons = new QHBoxLayout( mainlayout );    
    buttons->add( m_start );
    buttons->add( m_stop );
    buttons->add( m_quit );
    
    mainlayout->add( m_status );
    
    m_sizeSelector->setMinValue( MIN_SIZE );
    m_sizeSelector->setMaxValue( MAX_SIZE );
    m_sizeSelector->setValue( 8 );
    m_board->setSize( 8 );
        
    m_sortalgo = SortList;
    m_solutions = NULL;
    m_queens = NULL;
    
    connect(m_quit, 
        SIGNAL( clicked() ), 
                qApp, 
                SLOT( quit() ) 
                );
        
    connect(m_sizeSelector, 
        SIGNAL( valueChanged(int) ), 
                this, 
                SLOT( resize(int) ) 
                );
        
    connect(m_start, 
        SIGNAL( clicked() ), 
                this, 
                SLOT( start() ) 
                );
        
    connect(m_stop, 
        SIGNAL( clicked() ), 
                this, 
                SLOT( stop() )
                );
        
    connect(m_list, 
        SIGNAL( selectionChanged() ), 
                this, 
                SLOT( showSolution() ) 
                );
        
    connect( qApp, 
        SIGNAL( lastWindowClosed() ), 
                qApp, 
                SLOT( quit() )
                );
}


QueensMain::~QueensMain()
{
    delete m_board;
}

void QueensMain::start()
{
    m_sizeSelector->setEnabled( false );
    m_start->setEnabled( false );
    m_stop->setEnabled( true );
    m_list->clear();
    m_status->setText( QString("Searching ...") );
    
    if (m_queens != NULL) {
        m_queens->wait();
        delete m_queens;
    }    
    
    if (m_solutions != NULL)
         delete m_solutions;
    switch (m_sortalgo) {
            case SortList:
                    m_solutions = new SolutionList(this);
                    break;
            case SortVector:
                    m_solutions = new SolutionVector(this);
                    break;
            case SortHash:
                    m_solutions = new SolutionHash(this);
                    break;
            case SortMNVector:
                    m_solutions = new SolutionMNVector(this);
                    break;
    }

    m_elapsed.start();
    m_time.start();
    m_queens = new Queens(this, m_solutions, m_sizeSelector->value() ,false);
    m_queens->start();
}

void QueensMain::stop()
{
    m_solutions->halt();
    m_queens->stop();
    m_queens->wait();
        
    int num = m_solutions->numSolutions();
    m_status->setText( QString("Aborted. Found ") + QString::number(num,10).append(" solutions") ); 
    m_list->clear();
    for (int i=1; i<=num; i++)
        m_list->insertItem( QString("Solution no ") + QString::number(i,10), i);
        
    delete m_queens;
    m_queens = NULL;
    
    m_list->setEnabled( true );
    m_sizeSelector->setEnabled( true );
    m_start->setEnabled( true );
    m_stop->setEnabled( false );
}

void QueensMain::foundSolution()
{
        int num = m_solutions->numSolutions();
    if (m_elapsed.elapsed() > 500) 
    {
        m_status->setText( QString("Searching ... found ") + QString::number(num,10).append(" solutions") );
                m_elapsed.restart();
    }
}

void QueensMain::finishedSearch()
{
        uniqueSolutions();
        m_sizeSelector->setEnabled( true );
        m_start->setEnabled( true );
        m_stop->setEnabled( false );
}


void QueensMain::showSolution()
{
        int index = m_list->currentItem();
        Solution sol = m_solutions->solution( index );
        m_board->setMatrix( sol );
}

void QueensMain::resize(int size)
{
        m_board->setSize( size );
        m_board->repaint( true );
        m_list->clear();
}

QString QueensMain::elapsed()
{
        int time = m_time.elapsed();
        int msec = time % 1000;
        int sec = time / 1000;
        int min = sec / 60;
        sec %= 60;
        QString smsec = (QString::number(msec)).rightJustify(3, '0');
        QString ssec = (QString::number(sec)).rightJustify(2,'0');
        
        QString res;
        if (min!=0)
                res = QString("%1:%2.%3").arg(min).arg(ssec).arg(smsec);
        else
                res = QString("%1.%2").arg(sec).arg(smsec);
        return res;
}

void QueensMain::uniqueSolutions()
{
        m_totalcount = m_solutions->numSolutions();
        m_status->setText( QString("sorting ") + QString::number(m_totalcount,10).append(" solutions...") );
        
        m_elapsed.restart();
        m_solutions->uniqueSolutions();
                
        int uniq = m_solutions->numSolutions();
        
        
        QString msg;
        msg = QString( "Found %1 unique solutions, of %2 total solutions. Time elapsed: %3" ).arg(uniq).arg(m_totalcount).arg( elapsed() );

        m_list->clear();
        for (int i=1; i<=uniq; i++)
                m_list->insertItem( QString("Unique solution no ") + QString::number(i,10), i);
        
        m_status->setText( msg ); 
}

void QueensMain::contextMenuEvent( QContextMenuEvent *event)
{
        QPopupMenu *contextMenu = new QPopupMenu( this );
        contextMenu->setCheckable( true );
        QLabel *caption = new QLabel("<b><i>Sort algorithm</i></b>", this);
        caption->setAlignment( Qt::AlignCenter );
        contextMenu->insertItem( caption );

        contextMenu->insertItem("List", this, SLOT( sortList() ), 0, 1);
        contextMenu->insertItem("Vector", this, SLOT( sortVector() ), 0, 2);
        contextMenu->insertItem("Hash", this, SLOT( sortHash() ), 0, 3);
        contextMenu->insertItem("M*N Vector", this, SLOT(sortMNVector()), 0, 4);

        switch (m_sortalgo) {
                case SortList:
                        contextMenu->setItemChecked( 1, true);
                        break;
                case SortVector:
                        contextMenu->setItemChecked( 2, true);
                        break;
                case SortHash:
                        contextMenu->setItemChecked( 3, true);
                        break;
                case SortMNVector:
                        contextMenu->setItemChecked( 4, true);
                        break;
        }       
        
        contextMenu->exec( event->globalPos() );
        delete contextMenu;
}

void QueensMain::duplicateRemoved()
{
        if (m_elapsed.elapsed() > 500)
        {
                int uniq = m_solutions->getUniqueRemoved(); 
                QString status;
                status = QString ("Sorting %1 solutions. So far identified %2 duplicates").arg(m_totalcount).arg(uniq);
                m_status->setText(status);
                m_elapsed.restart();
        }       
}

void QueensMain::sortList()
{
        m_sortalgo = SortList;
}

void QueensMain::sortVector()
{
        m_sortalgo = SortVector;
}

void QueensMain::sortHash()
{
        m_sortalgo = SortHash;
}

void QueensMain::sortMNVector()
{
        m_sortalgo = SortMNVector;
}
1	torben	1	/***************************************************************************
2			* Copyright (C) 2005 by Torben Nielsen *
3			* torben@t-hoerup.dk *
4			* *
5			* This program is free software; you can redistribute it and/or modify *
6			* it under the terms of the GNU General Public License as published by *
7			* the Free Software Foundation; either version 2 of the License, or *
8			* (at your option) any later version. *
9			* *
10			* This program is distributed in the hope that it will be useful, *
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13			* GNU General Public License for more details. *
14			* *
15			* You should have received a copy of the GNU General Public License *
16			* along with this program; if not, write to the *
17			* Free Software Foundation, Inc., *
18			* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19			***************************************************************************/
20			#include <qapplication.h>
21			#include <qlabel.h>
22			#include <qlayout.h>
23			#include <qlistbox.h>
24			#include <qpopupmenu.h>
25			#include <qpushbutton.h>
26			#include <qspinbox.h>
27			#include <qstring.h>
28
29
30			#include "queensmain.h"
31			#include "board.h"
32			#include "queens.h"
33			#include "solutionvector.h"
34			#include "solutionlist.h"
35			#include "solutionhash.h"
36			#include "solutionmnvector.h"
37
38			#include "config.h"
39
40			QueensMain::QueensMain(QWidget parent, const char name)
41			: QDialog(parent, name)
42			{
43			QVBoxLayout *mainlayout = new QVBoxLayout( this );
44
45			m_board = new Board( this );
46
47			m_start = new QPushButton("Start", this);
48			m_quit = new QPushButton("Quit", this);
49			m_stop = new QPushButton("Stop", this);
50			m_stop->setEnabled( false );
51
52			QHBoxLayout *upperlayout = new QHBoxLayout( mainlayout );
53			QVBoxLayout *left = new QVBoxLayout( upperlayout );
54
55			upperlayout->add( m_board );
56			m_list = new QListBox( this );
57
58			m_list->setMinimumWidth( 180 );
59			m_sizeSelector = new QSpinBox( this );
60			m_status = new QLabel( this );
61
62			left->add( m_list );
63			left->add( m_sizeSelector );
64
65			QHBoxLayout *buttons = new QHBoxLayout( mainlayout );
66			buttons->add( m_start );
67			buttons->add( m_stop );
68			buttons->add( m_quit );
69
70			mainlayout->add( m_status );
71
72			m_sizeSelector->setMinValue( MIN_SIZE );
73			m_sizeSelector->setMaxValue( MAX_SIZE );
74			m_sizeSelector->setValue( 8 );
75			m_board->setSize( 8 );
76
77			m_sortalgo = SortList;
78			m_solutions = NULL;
79			m_queens = NULL;
80
81			connect(m_quit,
82			SIGNAL( clicked() ),
83			qApp,
84			SLOT( quit() )
85			);
86
87			connect(m_sizeSelector,
88			SIGNAL( valueChanged(int) ),
89			this,
90			SLOT( resize(int) )
91			);
92
93			connect(m_start,
94			SIGNAL( clicked() ),
95			this,
96			SLOT( start() )
97			);
98
99			connect(m_stop,
100			SIGNAL( clicked() ),
101			this,
102			SLOT( stop() )
103			);
104
105			connect(m_list,
106			SIGNAL( selectionChanged() ),
107			this,
108			SLOT( showSolution() )
109			);
110
111			connect( qApp,
112			SIGNAL( lastWindowClosed() ),
113			qApp,
114			SLOT( quit() )
115			);
116			}
117
118
119			QueensMain::~QueensMain()
120			{
121			delete m_board;
122			}
123
124			void QueensMain::start()
125			{
126			m_sizeSelector->setEnabled( false );
127			m_start->setEnabled( false );
128			m_stop->setEnabled( true );
129			m_list->clear();
130			m_status->setText( QString("Searching ...") );
131
132			if (m_queens != NULL) {
133			m_queens->wait();
134			delete m_queens;
135			}
136
137			if (m_solutions != NULL)
138			delete m_solutions;
139			switch (m_sortalgo) {
140			case SortList:
141			m_solutions = new SolutionList(this);
142			break;
143			case SortVector:
144			m_solutions = new SolutionVector(this);
145			break;
146			case SortHash:
147			m_solutions = new SolutionHash(this);
148			break;
149			case SortMNVector:
150			m_solutions = new SolutionMNVector(this);
151			break;
152			}
153
154			m_elapsed.start();
155			m_time.start();
156			m_queens = new Queens(this, m_solutions, m_sizeSelector->value() ,false);
157			m_queens->start();
158			}
159
160			void QueensMain::stop()
161			{
162			m_solutions->halt();
163			m_queens->stop();
164			m_queens->wait();
165
166			int num = m_solutions->numSolutions();
167			m_status->setText( QString("Aborted. Found ") + QString::number(num,10).append(" solutions") );
168			m_list->clear();
169			for (int i=1; i<=num; i++)
170			m_list->insertItem( QString("Solution no ") + QString::number(i,10), i);
171
172			delete m_queens;
173			m_queens = NULL;
174
175			m_list->setEnabled( true );
176			m_sizeSelector->setEnabled( true );
177			m_start->setEnabled( true );
178			m_stop->setEnabled( false );
179			}
180
181			void QueensMain::foundSolution()
182			{
183			int num = m_solutions->numSolutions();
184			if (m_elapsed.elapsed() > 500)
185			{
186			m_status->setText( QString("Searching ... found ") + QString::number(num,10).append(" solutions") );
187			m_elapsed.restart();
188			}
189			}
190
191			void QueensMain::finishedSearch()
192			{
193			uniqueSolutions();
194			m_sizeSelector->setEnabled( true );
195			m_start->setEnabled( true );
196			m_stop->setEnabled( false );
197			}
198
199
200			void QueensMain::showSolution()
201			{
202			int index = m_list->currentItem();
203			Solution sol = m_solutions->solution( index );
204			m_board->setMatrix( sol );
205			}
206
207			void QueensMain::resize(int size)
208			{
209			m_board->setSize( size );
210			m_board->repaint( true );
211			m_list->clear();
212			}
213
214			QString QueensMain::elapsed()
215			{
216			int time = m_time.elapsed();
217			int msec = time % 1000;
218			int sec = time / 1000;
219			int min = sec / 60;
220			sec %= 60;
221			QString smsec = (QString::number(msec)).rightJustify(3, '0');
222			QString ssec = (QString::number(sec)).rightJustify(2,'0');
223
224			QString res;
225			if (min!=0)
226			res = QString("%1:%2.%3").arg(min).arg(ssec).arg(smsec);
227			else
228			res = QString("%1.%2").arg(sec).arg(smsec);
229			return res;
230			}
231
232			void QueensMain::uniqueSolutions()
233			{
234			m_totalcount = m_solutions->numSolutions();
235			m_status->setText( QString("sorting ") + QString::number(m_totalcount,10).append(" solutions...") );
236
237			m_elapsed.restart();
238			m_solutions->uniqueSolutions();
239
240			int uniq = m_solutions->numSolutions();
241
242
243			QString msg;
244			msg = QString( "Found %1 unique solutions, of %2 total solutions. Time elapsed: %3" ).arg(uniq).arg(m_totalcount).arg( elapsed() );
245
246			m_list->clear();
247			for (int i=1; i<=uniq; i++)
248			m_list->insertItem( QString("Unique solution no ") + QString::number(i,10), i);
249
250			m_status->setText( msg );
251			}
252
253			void QueensMain::contextMenuEvent( QContextMenuEvent *event)
254			{
255			QPopupMenu *contextMenu = new QPopupMenu( this );
256			contextMenu->setCheckable( true );
257			QLabel *caption = new QLabel("<b><i>Sort algorithm</i></b>", this);
258			caption->setAlignment( Qt::AlignCenter );
259			contextMenu->insertItem( caption );
260
261			contextMenu->insertItem("List", this, SLOT( sortList() ), 0, 1);
262			contextMenu->insertItem("Vector", this, SLOT( sortVector() ), 0, 2);
263			contextMenu->insertItem("Hash", this, SLOT( sortHash() ), 0, 3);
264			contextMenu->insertItem("M*N Vector", this, SLOT(sortMNVector()), 0, 4);
265
266			switch (m_sortalgo) {
267			case SortList:
268			contextMenu->setItemChecked( 1, true);
269			break;
270			case SortVector:
271			contextMenu->setItemChecked( 2, true);
272			break;
273			case SortHash:
274			contextMenu->setItemChecked( 3, true);
275			break;
276			case SortMNVector:
277			contextMenu->setItemChecked( 4, true);
278			break;
279			}
280
281			contextMenu->exec( event->globalPos() );
282			delete contextMenu;
283			}
284
285			void QueensMain::duplicateRemoved()
286			{
287			if (m_elapsed.elapsed() > 500)
288			{
289			int uniq = m_solutions->getUniqueRemoved();
290			QString status;
291			status = QString ("Sorting %1 solutions. So far identified %2 duplicates").arg(m_totalcount).arg(uniq);
292			m_status->setText(status);
293			m_elapsed.restart();
294			}
295			}
296
297			void QueensMain::sortList()
298			{
299			m_sortalgo = SortList;
300			}
301
302			void QueensMain::sortVector()
303			{
304			m_sortalgo = SortVector;
305			}
306
307			void QueensMain::sortHash()
308			{
309			m_sortalgo = SortHash;
310			}
311
312			void QueensMain::sortMNVector()
313			{
314			m_sortalgo = SortMNVector;
315			}