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 "solution.h"
#include "solutionmatrix.h"
#include "solutionint.h"

#include "containervector.h"
#include "containerlist.h"
#include "containerhash.h"
#include "containermnvector.h"
#include "containerminimalvector.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_storage = StorageInt;
    m_sortalgo = SortMinimalVector;
    m_solutions = NULL;
    m_queens = NULL;
        m_sol = 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;
        
        if (m_solutions != NULL)
                delete m_solutions;
        if (m_sol != NULL)
                delete m_sol;
}

void QueensMain::start()
{
    m_sizeSelector->setEnabled( false );
    m_start->setEnabled( false );
    m_stop->setEnabled( true );
    m_list->clear();
    m_status->setText( QString("Searching ...") );
    
        m_board->setMatrix(0);
        
    if (m_queens != NULL) {
        m_queens->wait();
        delete m_queens;
                m_queens = 0;
    }    
    
    if (m_solutions != NULL)
         delete m_solutions;
    switch (m_sortalgo) {
            case SortList:
                    m_solutions = new ContainerList(this);
                    break;
            case SortVector:
                    m_solutions = new ContainerVector(this);
                    break;
            case SortHash:
                    m_solutions = new ContainerHash(this);
                    break;
            case SortMNVector:
                    m_solutions = new ContainerMNVector(this);
                    break;
                case SortMinimalVector:
                        m_solutions = new ContainerMinimalVector(this);
                        break;
    }
        
        if (m_sol != NULL)
                delete m_sol;
        
        switch(this->m_storage) {
                case StorageInt:
                        m_sol = new SolutionInt(m_sizeSelector->value());
                        break;
                case StorageMatrix:
                        m_sol = new SolutionMatrix(m_sizeSelector->value());
                        break;
        }


    m_elapsed.start();
    m_time.start();
    m_queens = new Queens(this, m_sol, 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->totalSolutions();
        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 *sortCaption = new QLabel("<b><i>Container class</i></b>", this);
        sortCaption->setAlignment( Qt::AlignCenter );
        contextMenu->insertItem( sortCaption );

        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);
        contextMenu->insertItem("Minimal Vector", this, SLOT(sortMinimalVector()), 0, 5);
        
        QLabel *storageCaption = new QLabel("<b><i>Solution class</i></b>", this);
        storageCaption->setAlignment( Qt::AlignCenter );
        contextMenu->insertItem( storageCaption );
        contextMenu->insertItem("Matrix Solution", this, SLOT( storageMatrix() ), 0, 6);
        contextMenu->insertItem("Int Solution", this, SLOT( storageInt() ), 0, 7);


        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;
                case SortMinimalVector:
                        contextMenu->setItemChecked( 5, true);
                        break;
        }       
        
        switch (m_storage) {
                case StorageMatrix:
                        contextMenu->setItemChecked(6, true);
                        break;
                case StorageInt:
                        contextMenu->setItemChecked(7, 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;
}

void QueensMain::sortMinimalVector()
{
        m_sortalgo = SortMinimalVector;
}


void QueensMain::storageInt()
{
        m_storage = StorageInt;
}

void QueensMain::storageMatrix()
{
        m_storage = StorageMatrix;
}
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	torben	2
31	torben	1	#include "queensmain.h"
32			#include "board.h"
33			#include "queens.h"
34	torben	5
35	torben	2	#include "solution.h"
36	torben	5	#include "solutionmatrix.h"
37			#include "solutionint.h"
38	torben	1
39	torben	4	#include "containervector.h"
40			#include "containerlist.h"
41			#include "containerhash.h"
42			#include "containermnvector.h"
43	torben	13	#include "containerminimalvector.h"
44	torben	4
45	torben	1	#include "config.h"
46
47	torben	2
48	torben	5
49	torben	1	QueensMain::QueensMain(QWidget parent, const char name)
50			: QDialog(parent, name)
51			{
52			QVBoxLayout *mainlayout = new QVBoxLayout( this );
53
54			m_board = new Board( this );
55
56			m_start = new QPushButton("Start", this);
57			m_quit = new QPushButton("Quit", this);
58			m_stop = new QPushButton("Stop", this);
59			m_stop->setEnabled( false );
60
61			QHBoxLayout *upperlayout = new QHBoxLayout( mainlayout );
62			QVBoxLayout *left = new QVBoxLayout( upperlayout );
63
64			upperlayout->add( m_board );
65			m_list = new QListBox( this );
66
67			m_list->setMinimumWidth( 180 );
68			m_sizeSelector = new QSpinBox( this );
69			m_status = new QLabel( this );
70
71			left->add( m_list );
72			left->add( m_sizeSelector );
73
74			QHBoxLayout *buttons = new QHBoxLayout( mainlayout );
75			buttons->add( m_start );
76			buttons->add( m_stop );
77			buttons->add( m_quit );
78
79			mainlayout->add( m_status );
80
81			m_sizeSelector->setMinValue( MIN_SIZE );
82			m_sizeSelector->setMaxValue( MAX_SIZE );
83			m_sizeSelector->setValue( 8 );
84			m_board->setSize( 8 );
85
86	torben	10	m_storage = StorageInt;
87	torben	17	m_sortalgo = SortMinimalVector;
88	torben	1	m_solutions = NULL;
89			m_queens = NULL;
90	torben	4	m_sol = NULL;
91	torben	1
92			connect(m_quit,
93			SIGNAL( clicked() ),
94			qApp,
95			SLOT( quit() )
96			);
97
98			connect(m_sizeSelector,
99			SIGNAL( valueChanged(int) ),
100			this,
101			SLOT( resize(int) )
102			);
103
104			connect(m_start,
105			SIGNAL( clicked() ),
106			this,
107			SLOT( start() )
108			);
109
110			connect(m_stop,
111			SIGNAL( clicked() ),
112			this,
113			SLOT( stop() )
114			);
115
116			connect(m_list,
117			SIGNAL( selectionChanged() ),
118			this,
119			SLOT( showSolution() )
120			);
121
122			connect( qApp,
123			SIGNAL( lastWindowClosed() ),
124			qApp,
125			SLOT( quit() )
126			);
127			}
128
129
130			QueensMain::~QueensMain()
131			{
132			delete m_board;
133	torben	7
134			if (m_solutions != NULL)
135			delete m_solutions;
136			if (m_sol != NULL)
137			delete m_sol;
138	torben	1	}
139
140			void QueensMain::start()
141			{
142			m_sizeSelector->setEnabled( false );
143			m_start->setEnabled( false );
144			m_stop->setEnabled( true );
145			m_list->clear();
146			m_status->setText( QString("Searching ...") );
147
148	torben	6	m_board->setMatrix(0);
149
150	torben	1	if (m_queens != NULL) {
151			m_queens->wait();
152			delete m_queens;
153	torben	7	m_queens = 0;
154	torben	1	}
155
156			if (m_solutions != NULL)
157			delete m_solutions;
158			switch (m_sortalgo) {
159			case SortList:
160	torben	4	m_solutions = new ContainerList(this);
161	torben	1	break;
162			case SortVector:
163	torben	4	m_solutions = new ContainerVector(this);
164	torben	1	break;
165			case SortHash:
166	torben	4	m_solutions = new ContainerHash(this);
167	torben	1	break;
168			case SortMNVector:
169	torben	4	m_solutions = new ContainerMNVector(this);
170	torben	1	break;
171	torben	13	case SortMinimalVector:
172			m_solutions = new ContainerMinimalVector(this);
173			break;
174	torben	1	}
175	torben	2
176			if (m_sol != NULL)
177			delete m_sol;
178
179			switch(this->m_storage) {
180			case StorageInt:
181	torben	5	m_sol = new SolutionInt(m_sizeSelector->value());
182	torben	2	break;
183			case StorageMatrix:
184	torben	5	m_sol = new SolutionMatrix(m_sizeSelector->value());
185	torben	2	break;
186			}
187	torben	1
188	torben	2
189	torben	1	m_elapsed.start();
190			m_time.start();
191	torben	4	m_queens = new Queens(this, m_sol, m_solutions, m_sizeSelector->value() ,false);
192	torben	1	m_queens->start();
193			}
194
195			void QueensMain::stop()
196			{
197			m_solutions->halt();
198			m_queens->stop();
199			m_queens->wait();
200
201			int num = m_solutions->numSolutions();
202			m_status->setText( QString("Aborted. Found ") + QString::number(num,10).append(" solutions") );
203			m_list->clear();
204			for (int i=1; i<=num; i++)
205			m_list->insertItem( QString("Solution no ") + QString::number(i,10), i);
206
207			delete m_queens;
208			m_queens = NULL;
209
210			m_list->setEnabled( true );
211			m_sizeSelector->setEnabled( true );
212			m_start->setEnabled( true );
213			m_stop->setEnabled( false );
214			}
215
216			void QueensMain::foundSolution()
217			{
218			int num = m_solutions->numSolutions();
219			if (m_elapsed.elapsed() > 500)
220			{
221			m_status->setText( QString("Searching ... found ") + QString::number(num,10).append(" solutions") );
222			m_elapsed.restart();
223			}
224			}
225
226			void QueensMain::finishedSearch()
227			{
228			uniqueSolutions();
229			m_sizeSelector->setEnabled( true );
230			m_start->setEnabled( true );
231			m_stop->setEnabled( false );
232			}
233
234
235			void QueensMain::showSolution()
236			{
237			int index = m_list->currentItem();
238	torben	2	Solution* sol = m_solutions->solution( index );
239	torben	4	m_board->setMatrix( sol );
240	torben	1	}
241
242			void QueensMain::resize(int size)
243			{
244			m_board->setSize( size );
245			m_board->repaint( true );
246			m_list->clear();
247			}
248
249			QString QueensMain::elapsed()
250			{
251			int time = m_time.elapsed();
252			int msec = time % 1000;
253			int sec = time / 1000;
254			int min = sec / 60;
255			sec %= 60;
256			QString smsec = (QString::number(msec)).rightJustify(3, '0');
257			QString ssec = (QString::number(sec)).rightJustify(2,'0');
258
259			QString res;
260			if (min!=0)
261			res = QString("%1:%2.%3").arg(min).arg(ssec).arg(smsec);
262			else
263			res = QString("%1.%2").arg(sec).arg(smsec);
264			return res;
265			}
266
267			void QueensMain::uniqueSolutions()
268			{
269	torben	15	m_totalcount = m_solutions->totalSolutions();
270	torben	1	m_status->setText( QString("sorting ") + QString::number(m_totalcount,10).append(" solutions...") );
271
272			m_elapsed.restart();
273			m_solutions->uniqueSolutions();
274
275			int uniq = m_solutions->numSolutions();
276
277
278			QString msg;
279			msg = QString( "Found %1 unique solutions, of %2 total solutions. Time elapsed: %3" ).arg(uniq).arg(m_totalcount).arg( elapsed() );
280
281			m_list->clear();
282			for (int i=1; i<=uniq; i++)
283			m_list->insertItem( QString("Unique solution no ") + QString::number(i,10), i);
284
285			m_status->setText( msg );
286			}
287
288			void QueensMain::contextMenuEvent( QContextMenuEvent *event)
289			{
290			QPopupMenu *contextMenu = new QPopupMenu( this );
291			contextMenu->setCheckable( true );
292	torben	8	QLabel *sortCaption = new QLabel("<b><i>Container class</i></b>", this);
293	torben	2	sortCaption->setAlignment( Qt::AlignCenter );
294			contextMenu->insertItem( sortCaption );
295	torben	1
296			contextMenu->insertItem("List", this, SLOT( sortList() ), 0, 1);
297			contextMenu->insertItem("Vector", this, SLOT( sortVector() ), 0, 2);
298			contextMenu->insertItem("Hash", this, SLOT( sortHash() ), 0, 3);
299			contextMenu->insertItem("M*N Vector", this, SLOT(sortMNVector()), 0, 4);
300	torben	13	contextMenu->insertItem("Minimal Vector", this, SLOT(sortMinimalVector()), 0, 5);
301	torben	2
302	torben	8	QLabel *storageCaption = new QLabel("<b><i>Solution class</i></b>", this);
303			storageCaption->setAlignment( Qt::AlignCenter );
304	torben	2	contextMenu->insertItem( storageCaption );
305	torben	13	contextMenu->insertItem("Matrix Solution", this, SLOT( storageMatrix() ), 0, 6);
306			contextMenu->insertItem("Int Solution", this, SLOT( storageInt() ), 0, 7);
307	torben	1
308	torben	2
309	torben	1	switch (m_sortalgo) {
310			case SortList:
311			contextMenu->setItemChecked( 1, true);
312			break;
313			case SortVector:
314			contextMenu->setItemChecked( 2, true);
315			break;
316			case SortHash:
317			contextMenu->setItemChecked( 3, true);
318			break;
319			case SortMNVector:
320			contextMenu->setItemChecked( 4, true);
321			break;
322	torben	13	case SortMinimalVector:
323			contextMenu->setItemChecked( 5, true);
324			break;
325	torben	1	}
326
327	torben	2	switch (m_storage) {
328			case StorageMatrix:
329	torben	13	contextMenu->setItemChecked(6, true);
330	torben	2	break;
331			case StorageInt:
332	torben	13	contextMenu->setItemChecked(7, true);
333	torben	2	break;
334			}
335
336
337	torben	1	contextMenu->exec( event->globalPos() );
338			delete contextMenu;
339			}
340
341			void QueensMain::duplicateRemoved()
342			{
343			if (m_elapsed.elapsed() > 500)
344			{
345			int uniq = m_solutions->getUniqueRemoved();
346			QString status;
347			status = QString ("Sorting %1 solutions. So far identified %2 duplicates").arg(m_totalcount).arg(uniq);
348			m_status->setText(status);
349			m_elapsed.restart();
350			}
351			}
352
353			void QueensMain::sortList()
354			{
355			m_sortalgo = SortList;
356			}
357
358			void QueensMain::sortVector()
359			{
360			m_sortalgo = SortVector;
361			}
362
363			void QueensMain::sortHash()
364			{
365			m_sortalgo = SortHash;
366			}
367
368			void QueensMain::sortMNVector()
369			{
370			m_sortalgo = SortMNVector;
371			}
372
373	torben	13	void QueensMain::sortMinimalVector()
374			{
375			m_sortalgo = SortMinimalVector;
376			}
377
378
379	torben	2	void QueensMain::storageInt()
380			{
381			m_storage = StorageInt;
382			}
383
384			void QueensMain::storageMatrix()
385			{
386			m_storage = StorageMatrix;
387			}