SpikeStreamMainWindow.cpp

Go to the documentation of this file.

/***************************************************************************
 *   SpikeStream Application                                               *
 *   Copyright (C) 2007 by David Gamez                                     *
 *   david@davidgamez.eu                                                   *
 *   Version 0.1                                                           *
 *                                                                         *
 *   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.             *
 ***************************************************************************/

//SpikeStream includes
#include "SpikeStreamMainWindow.h"
#include "LogWriter.h"
#include "Debug.h"
#include "Utilities.h"
#include "Tester.h"
#include "GlobalVariables.h"
#include "DatabaseManager.h"
#include "PatternDialog.h"
#include "ProbeDialog.h"
#include "ConfigLoader.h"
#include "ConnectionMatrixLoader.h"

//Qt includes
#include <qsplitter.h>
#include <qsplashscreen.h>
#include <qpixmap.h>
#include <qmenubar.h>
#include <qmessagebox.h>
#include <qapplication.h>
#include <qaccel.h>
#include <qfile.h>
#include <qscrollview.h>
#include <qvbox.h>
#include <qfiledialog.h>

//Other includes
#include <mysql++.h>
#include <string>
using namespace std;
using namespace mysqlpp;


//Declare static variables here for linking
QString SpikeStreamMainWindow::workingDirectory = "";
SpikeStreamMainWindow* SpikeStreamMainWindow::spikeStrMainWin;
SpikeStreamApplication* SpikeStreamMainWindow::spikeStreamApplication;


/*! Constructor. */
SpikeStreamMainWindow::SpikeStreamMainWindow(SpikeStreamApplication *ssApp) : QMainWindow( 0, "SpikeStream", WDestructiveClose ){
        //Store a static reference to itself so that it can be accessed from anywhere
        spikeStrMainWin = this;

        //Store reference to spike stream application
        spikeStreamApplication = ssApp;

        //Get the working directory, which should be defined by the SPIKESTREAM_ROOT variable
        workingDirectory = getenv("SPIKESTREAM_ROOT");

        //Working directory is essential, so exit if it is not defined.
        if( workingDirectory == ""){
                cerr<<"CANNOT FIND SPIKESTREAM_ROOT VARIABLE. THIS MUST BE DEFINED FOR APPLICATION TO WORK, EXITING"<<endl;
                QMessageBox::critical( 0, "SpikeStream", "SPIKESTREAM_ROOT variable is not defined.\nApplication will now exit.");
                delete this;
                exit(1);
        }
        else if( !QFile::exists(workingDirectory) ){
                cerr<<"SPIKESTREAM_ROOT VARIABLE POINTS TO AN INVALID DIRECTORY: "<<workingDirectory<<endl;
                QMessageBox::critical( 0, "SpikeStream", "SPIKESTREAM_ROOT variable does not point to a valid directory.\nApplication will now exit.");
                delete this;
                exit(1);
        }
        else {
                #ifdef PATH_DEBUG
                        cout<<"Working directory: "<<workingDirectory<<endl;
                #endif//PATH_DEBUG
        }

        //Set up splash screen to give feedback whilst application is loading
        QSplashScreen *splashScreen = 0;
        QPixmap splashPixmap(workingDirectory + "/images/spikestream_splash.png" );
        splashScreen = new QSplashScreen( splashPixmap );
        splashScreen->show();


        //Set up config
        ConfigLoader* configLoader;
        if(QFile::exists(workingDirectory +  "/spikestream.config")){
                configLoader = new ConfigLoader(workingDirectory + "/spikestream.config");
        }
        else{
                cerr<<"Cannot find configuration file at "<<workingDirectory<<"/spikestream.config"<<endl;
                QMessageBox::critical( 0, "Config Error", "Cannot find configuration file\nApplication will now exit.");
                exit(1);        
        }
        

        //Set up the logging
        //Load the log level from the configuration file: 0 disables logging, 1 enables medium logging, 2 enables full logging
        int logLev = 0;
        try{
                logLev = Utilities::getInt(configLoader->getStringData("log_level"));
        }
        catch(std::exception& er){// Catch-all for std exceptions
                cerr<<"SpikeStreamMainWindow: STD EXCEPTION \""<<er.what()<<"\""<<endl;
                QString errorString = "Exception thrown getting log level: \"";
                errorString += er.what();
                errorString += "\"";
                QMessageBox::critical( 0, "Config Error", errorString);
        }

        if(logLev == 0)
                LogWriter::disableLogging();
        else{//Logging is enabled
                //Set the log level
                if(logLev == 1 || logLev == 2)
                        LogWriter::setLogLevel(logLev);
                else{
                        cerr<<"SpikeStreamMainWindow: LOG LEVEL SHOULD BE 0, 1 OR 2"<<endl;
                        LogWriter::setLogLevel(1);
                }
                
                //Find the log file
                if(QFile::exists(workingDirectory + "/SpikeStream.log")){
                        QString logPath = workingDirectory + "/SpikeStream.log";
                        LogWriter::setLogPath(logPath.ascii());
                }
                else{
                        cerr<<"Cannot find log file. Creating new file."<<endl;
                        LogWriter::setLogPath(workingDirectory + "/SpikeStream.log");
                }
                
                //Check to see if it has reached its maximum size defined in config file. 
                //Disable logging if it is too big
                unsigned int maxLogSize = 100000;
                try{
                        maxLogSize = Utilities::getUInt(configLoader->getStringData("Max_log_size"));
                }
                catch(std::exception& er){// Catch-all for std exceptions
                        cerr<<"SpikeStreamMainWindow: STD EXCEPTION \""<<er.what()<<"\""<<endl;
                        QString errorString = "Exception thrown geting max log size: \"";
                        errorString += er.what();
                        errorString += "\"";
                        QMessageBox::critical( 0, "Config Error", errorString);
                }

                QFile logFile(workingDirectory + "/SpikeStream.log");
                if(logFile.size() > maxLogSize){
                        cerr<<"Log file is full. Logging disabled. [ Max_log_size: "<<maxLogSize<<"; Current log size: "<<logFile.size()<<" ]"<<endl;
                        LogWriter::disableLogging();    
                }
                
                //Write the date and time to the log.
                LogWriter::writeDate();
        }
        
        //Set up the Network database interface and connect to it
        //This will be used by many other classes, so keep reference to it
        networkDBInterface = new DBInterface(
                configLoader->getCharData("neuralNetworkHost"), 
                configLoader->getCharData("neuralNetworkUser"), 
                configLoader->getCharData("neuralNetworkPassword"), 
                configLoader->getCharData("neuralNetworkDatabase")
        );
        if(!networkDBInterface->connectToDatabase(true)){//Exceptions enabled
                QMessageBox::critical (this, "Initialisation failure", "Connection to NeuralNetwork database failed");
                exit(1);
        }

        //Set up the archive database interface and connect to it
        archiveDBInterface = new DBInterface(
                configLoader->getCharData("archiveHost"), 
                configLoader->getCharData("archiveUser"), 
                configLoader->getCharData("archivePassword"), 
                configLoader->getCharData("archiveDatabase")
        );
        if(!archiveDBInterface->connectToDatabase(true)){//Exceptions enabled
                QMessageBox::critical (this, "Initialisation failure", "Connection to NeuralArchive database failed");
                exit(1);
        }

        //Set up the pattern database interface and connect to it
        patternDBInterface = new DBInterface(
                configLoader->getCharData("patternHost"), 
                configLoader->getCharData("patternUser"), 
                configLoader->getCharData("patternPassword"), 
                configLoader->getCharData("patternDatabase")
        );
        if(!patternDBInterface->connectToDatabase(true)){//Exceptions enabled
                QMessageBox::critical (this, "Initialisation failure", "Connection to Patterns database failed");
                exit(1);
        }

        //Set up the device database interface and connect to it
        deviceDBInterface = new DBInterface(
                configLoader->getCharData("deviceHost"), 
                configLoader->getCharData("deviceUser"), 
                configLoader->getCharData("devicePassword"), 
                configLoader->getCharData("deviceDatabase")
        );
        if(!deviceDBInterface->connectToDatabase(true)){//Exceptions enabled
                QMessageBox::critical (this, "Initialisation failure", "Connection to Devices database failed");
                exit(1);
        }

        //Get the default location for saving and loading databases
        defaultFileLocation = configLoader->getCharData("default_file_location");

        //Set up tester to run any code that needs testing
        //Tester *tester = new Tester();
        //delete tester;

        //Set up menus. 
        //Add file menu.
        QPopupMenu * fileMenu = new QPopupMenu(this);
        menuBar()->insertItem("File", fileMenu);
        fileMenu->insertItem("Clear databases", this, SLOT(clearDatabases()), CTRL+Key_R);
        fileMenu->insertItem("Load databases", this, SLOT(loadDatabases()), CTRL+Key_L);
        fileMenu->insertItem("Save databases", this, SLOT(saveDatabases()), CTRL+Key_S);
        fileMenu->insertSeparator();
        fileMenu->insertItem("Import connection matrix", this, SLOT(importConnectionMatrix()), CTRL+Key_I);
        fileMenu->insertSeparator();
        fileMenu->insertItem("Quit", qApp, SLOT(closeAllWindows()), CTRL+Key_Q);

        //Add refresh menu for when changes have been made in the database independently of the application
        QPopupMenu *viewMenu = new QPopupMenu(this);
        menuBar()->insertItem("View", viewMenu);
        viewMenu->insertItem("Reload devices", this, SLOT(reloadDevices()), CTRL+Key_D);
        viewMenu->insertItem("Reload patterns", this, SLOT(reloadPatterns()), CTRL+Key_P);
        viewMenu->insertItem("Reload everything", this, SLOT(reloadEverything()), SHIFT+Key_F5);

        //Add tools menu for pattern manager and probe
        QPopupMenu *toolsMenu = new QPopupMenu(this);
        menuBar()->insertItem("Tools", toolsMenu);
        toolsMenu->insertItem("Pattern manager", this, SLOT(managePatterns()), Key_F6);
        toolsMenu->insertItem("Probe manager", this, SLOT(manageProbes()), Key_F7);

        //Add help menu
        QPopupMenu *helpMenu = new QPopupMenu(this);
        menuBar()->insertItem("Help", helpMenu);
        helpMenu->insertItem("About", this , SLOT(about()), Key_F12);
        
        
        //Set up panes
        //Set up main splitter, which will divide graphical view from editor/viewer/simulator windows
        QSplitter *mainSplitterWidget = new QSplitter(this);
        tabWidget = new QTabWidget(mainSplitterWidget);
        
        //Set up editor window and add to tab widget
        QSplitter *layerSplitterWidget = new QSplitter( tabWidget);
        layerWidget = new LayerWidget(layerSplitterWidget, networkDBInterface, deviceDBInterface);
        connectionWidget = new ConnectionWidget(layerSplitterWidget, networkDBInterface, deviceDBInterface);
        layerSplitterWidget->setOrientation(Qt::Vertical);
        tabWidget->addTab(layerSplitterWidget, "Editor");
        

        //Create network viewer for right half of screen
        unsigned int maxAutoLoadConnGrpSize = 1000000;
        try{
                maxAutoLoadConnGrpSize = Utilities::getUInt(configLoader->getStringData("max_autoload_conngrp_size"));
        }
        catch(std::exception& er){// Catch-all for std exceptions
                cerr<<"SpikeStreamMainWindow: STD EXCEPTION \""<<er.what()<<"\""<<endl;
                QString errorString = "Exception thrown getting maxAutoLoadConnGrpSize: \"";
                errorString += er.what();
                errorString += "\"";
                QMessageBox::critical( 0, "Config Error", errorString);
        }

        networkViewer = new NetworkViewer(mainSplitterWidget, splashScreen, networkDBInterface, maxAutoLoadConnGrpSize);
        networkViewer->setMinimumSize(200, 60);
        networkViewer->setBaseSize(700, 60);


        //Set up viewer tab
        QScrollView* nwViewerPropScrollView = new QScrollView(this);
        QVBox* nwViewerPropViewBox = new QVBox(nwViewerPropScrollView->viewport());
        nwViewerPropViewBox->setMinimumSize(1000,800);
        nwViewerPropScrollView->addChild(nwViewerPropViewBox);
        networkViewerProperties = new NetworkViewerProperties(nwViewerPropViewBox, networkViewer, networkDBInterface);
        networkViewerProperties->setMinimumSize(800, 600);
        tabWidget->addTab(nwViewerPropScrollView, "Viewer");


        //Set up simulator tab
        QScrollView* simulationScrollView = new QScrollView(this);
        QVBox* simulationViewBox = new QVBox(simulationScrollView->viewport());
        simulationViewBox->setMinimumSize(1000,800);
        simulationScrollView->addChild(simulationViewBox);
        QSplitter *simulationSplitterWidget = new QSplitter(simulationViewBox);
        simulationSplitterWidget->setOrientation(Qt::Vertical);
        simulationWidget = new SimulationWidget(simulationSplitterWidget, networkDBInterface, archiveDBInterface, patternDBInterface, deviceDBInterface);
        simulationManager = simulationWidget->getSimulationManager();

        //Set up the simulation manager with the maximum load time
        int maxLoadTime_sec = 200;
        try{
                maxLoadTime_sec = Utilities::getInt(configLoader->getStringData("max_neuron_data_load_time"));
        }
        catch(std::exception& er){// Catch-all for std exceptions
                cerr<<"SpikeStreamMainWindow: STD EXCEPTION \""<<er.what()<<"\""<<endl;
                QString errorString = "Exception thrown getting max neuron data load time: \"";
                errorString += er.what();
                errorString += "\"";
                QMessageBox::critical( 0, "Config Error", errorString);
        }
        simulationManager->setMaxNeurDataLoadTime_sec(maxLoadTime_sec);

        //Set up monitor area at bottom of simulation tab
        MonitorArea *simulationMonitorArea = new MonitorArea(networkDBInterface, simulationManager, simulationSplitterWidget);
        simulationMonitorArea->setMinimumSize(60, 200);
        simulationWidget->setMonitorArea(simulationMonitorArea);
        tabWidget->addTab(simulationScrollView, "Simulation");


        //Set up archive tab
        QScrollView* archiveScrollView = new QScrollView(this);
        QVBox* archiveViewBox = new QVBox(archiveScrollView->viewport());
        archiveViewBox->setMinimumSize(1000, 800);
        archiveScrollView->addChild(archiveViewBox);
        QSplitter *archiveSplitterWidget = new QSplitter(archiveViewBox);
        archiveSplitterWidget->setOrientation(Qt::Vertical);
        archiveWidget = new ArchiveWidget(archiveSplitterWidget, archiveDBInterface);
        archiveManager = archiveWidget->getArchiveManager();

        MonitorArea *archiveMonitorArea = new MonitorArea(archiveManager, archiveSplitterWidget);
        archiveMonitorArea->setMinimumSize(60, 200);
        archiveWidget->setMonitorArea(archiveMonitorArea);
        tabWidget->addTab(archiveScrollView, "Archive");
        

        //Set up layer widget connections
        layerWidget->setConnectionWidget(connectionWidget);
        
        //Set up network viewer references
        networkViewer->setNetworkViewerProperties((QWidget*)networkViewerProperties);

        //Set up an accelerator to switch between the tabs
        keyboardAccelerator = new QAccel( this );
        
        //Add all  the key combinations that will be required.
        keyboardAccelerator->insertItem(Key_F1);
        keyboardAccelerator->insertItem(Key_F2);
        keyboardAccelerator->insertItem(Key_F3);
        keyboardAccelerator->insertItem(Key_F4);

         //Connect up accelerator with the method that will process the key events
         connect (keyboardAccelerator, SIGNAL(activated(int)), this, SLOT(acceleratorKeyPressed(int)));

        //Finish off
        QPixmap iconPixmap(workingDirectory + "/images/spikestream_icon_64.png" );
        setIcon(iconPixmap);
    setCentralWidget( mainSplitterWidget );
        setWindowState(Qt::WindowMaximized);
        
        //Get rid of splash screen if it is showing
        if(splashScreen){
                splashScreen->finish( this );
                delete splashScreen;
        }
        
        //Delete config loader
        delete configLoader;
}


/*! Destructor. */
SpikeStreamMainWindow::~SpikeStreamMainWindow(){
        #ifdef MEMORY_DEBUG
                cout<<"DELETING SPIKE STREAM MAIN WINDOW"<<endl;
        #endif//MEMORY_DEBUG
        
        //First need to stop the simulation if it is running
        if(simulationManager->isInitialised()){
                simulationManager->destroySimulation();
                cout<<"Waiting for simulation to finish"<<endl;
                bool threadFinished = simulationManager->wait(10000);
                if(!threadFinished)
                        cerr<<"Simulation manager cannot be shut down cleanly within 10 seconds. Killing thread"<<endl;
        }
        
        //Need to stop archive manager if it is running
        if(archiveManager->isRunning()){
                archiveManager->stopArchive();
                cout<<"Waiting for archive manager to finish"<<endl;
                bool threadFinished = archiveManager->wait(10000);
                if(!threadFinished)
                        cerr<<"Archive manager cannot be shut down cleanly within 10 seconds. Killing thread"<<endl;
        }

        //Delete all the database handling classes
        delete networkDBInterface;
        delete archiveDBInterface;
        delete patternDBInterface;
        delete deviceDBInterface;
}


//--------------------------------------------------------------------------
//------------------------------ PUBLIC METHODS ----------------------------
//--------------------------------------------------------------------------

/*! Returns a reference to the network viewer. */
NetworkViewer* SpikeStreamMainWindow::getNetworkViewer(){
        return networkViewer;
}


/*! Reloads just the details about the connections assuming that the connection
        groups have remained the same. */
void SpikeStreamMainWindow::reloadConnectionDetails(){
        networkViewerProperties->reloadConnectionDetails();
}



/*! Reloads connections after a class has made changes to the database. */
void SpikeStreamMainWindow::reloadConnections(){
        networkViewerProperties->reloadConnections();
        simulationWidget->reloadConnectionGroups();
}


/*! Reloads neurons after a change has been made to the database. */
void SpikeStreamMainWindow::reloadNeuronGroups(){
        networkViewerProperties->reloadNeuronGroups();
        simulationWidget->reloadNeuronGroups();
        connectionWidget->reloadConnections();
}


/*! When viewing individual neurons this method sets the from
        neuron number in the Simulation Widget, which can be used to
        fire a neuron or select a neuron for monitoring during a 
        simulation. */
void SpikeStreamMainWindow::setFromNeuronID(unsigned int neurGrpID, unsigned int fromNeurNum){
        simulationWidget->setFromNeuronID(neurGrpID, fromNeurNum);
}


/*! When viewing individual neurons this method sets the to
        neuron number in the Simulation Widget, which can be used to
        select a synapse for monitoring during a simulation. */
void SpikeStreamMainWindow::setToNeuronID(unsigned int toNeurNum){
        simulationWidget->setToNeuronID(toNeurNum);
}


/*! When simulation is destroyed this passes this information
        on to other widgets. */
void SpikeStreamMainWindow::simulationDestroyed(){
        connectionWidget->simulationDestroyed();
        layerWidget->simulationDestroyed();
}


/*! When simulation is initialised this passes this information
        on to other widgets. */
void SpikeStreamMainWindow::simulationInitialised(){
        connectionWidget->simulationInitialised();
        layerWidget->simulationInitialised();
}


//-------------------------------------------------------------------------
//----------------------------------- SLOTS -------------------------------
//-------------------------------------------------------------------------

/*! Displays brief information about the application. */
void SpikeStreamMainWindow::about(){
    QMessageBox::about( this, "About", "SpikeStream\nVersion 0.1 alpha\nCreated by David Gamez: david@davidgamez.eu");
}

void SpikeStreamMainWindow::acceleratorKeyPressed(int acceleratorID){
        //Get the key sequence
        int keySequence = keyboardAccelerator->key(acceleratorID);
        
        //Change to a different tab
        switch(keySequence){
                case (Key_F1)://Edit tab
                        simulationWidget->hideOpenWindows();
                        archiveWidget->hideOpenWindows();
                        tabWidget->setCurrentPage(0);
                break;
                case (Key_F2)://Network viewer properties tab
                        simulationWidget->hideOpenWindows();
                        archiveWidget->hideOpenWindows();
                        tabWidget->setCurrentPage(1);
                break;
                case (Key_F3)://Simulation tab
                        simulationWidget->showOpenWindows();
                        archiveWidget->hideOpenWindows();
                        tabWidget->setCurrentPage(2);
                break;
                case(Key_F4)://Archive tab
                        simulationWidget->hideOpenWindows();
                        archiveWidget->showOpenWindows();
                        tabWidget->setCurrentPage(3);
                break;
                default:
                        cerr<<"SpikeStreamMainWindow: KEY SEQUENCE NOT RECOGNIZED: "<<keySequence<<endl;
        }
}


/*! Empties all databases except the Neuron, Synapse and Probe types. Useful when
        an error has led to out of date information in one of the tables. However all 
        data will be lost if this method is called. */
void SpikeStreamMainWindow::clearDatabases(){
        /* Check that we do not have a simulation initialised. */
        if(SimulationManager::isInitialised()){
                QMessageBox::warning(this, "Load Databases", "Databases cannot be loaded when a simulation is initialised.\nDestroy the simulation and try again.");
                return;
        }

        /* Check that playback of an archive is not currently in progress. */
        if(ArchiveManager::isRunning()){
                QMessageBox::warning(this, "Load Databases", "Databases cannot be loaded when an archive is being played back.\nStop archive playback and try again.");
                return;
        }


        //Check that user wants to overwrite current database
        int response = QMessageBox::warning(this, "Clear Databases", "This will overwrite all data in all databases except NeuronTypes, SynapseTypes and ProbeTypes.\nDo you want to continue?", QMessageBox::Yes, QMessageBox::No, 0);
        if(response != QMessageBox::Yes)
                return;

        //Unload archive if it is loaded. Database clearing will invalidate the query.
        archiveWidget->unloadArchive();

        //Execute queries to clear all databases
        try{

                //Clear NeuralNetwork database
                Query networkQuery = networkDBInterface->getQuery();

                //First do all the straightforward clearing
                networkQuery.reset();
                networkQuery<<"DELETE FROM Connections";
                networkQuery.execute();

                networkQuery.reset();
                networkQuery<<"DELETE FROM ConnectionGroups";
                networkQuery.execute();

                networkQuery.reset();
                networkQuery<<"DELETE FROM Neurons";
                networkQuery.execute();

                networkQuery.reset();
                networkQuery<<"DELETE FROM NeuronGroups";
                networkQuery.execute();

                networkQuery.reset();
                networkQuery<<"DELETE FROM Probes";
                networkQuery.execute();

                networkQuery.reset();
                networkQuery<<"DELETE FROM NoiseParameters";
                networkQuery.execute();

                networkQuery.reset();
                networkQuery<<"DELETE FROM GlobalParameters";
                networkQuery.execute();

                //Add single blank row to global parameters
                networkQuery.reset();
                networkQuery<<"INSERT INTO GlobalParameters () VALUES ()";
                networkQuery.execute();


                //Next clear the parameter tables. Need to find these by looking in the appropriate Types tables
                networkQuery.reset();
                networkQuery<<"SELECT ParameterTableName FROM NeuronTypes";
                Result neurTableNameRes = networkQuery.store();
                for(Result::iterator paramTableIter = neurTableNameRes.begin(); paramTableIter != neurTableNameRes.end(); ++paramTableIter){
                        Row tableNameRow (*paramTableIter);
                        networkQuery.reset();
                        networkQuery<<"DELETE FROM "<<(std::string)tableNameRow["ParameterTableName"];
                        networkQuery.execute();
                }

                networkQuery.reset();
                networkQuery<<"SELECT ParameterTableName FROM SynapseTypes";
                Result synapseTableNameRes = networkQuery.store();
                for(Result::iterator paramTableIter = synapseTableNameRes.begin(); paramTableIter != synapseTableNameRes.end(); ++paramTableIter){
                        Row tableNameRow (*paramTableIter);
                        networkQuery.reset();
                        networkQuery<<"DELETE FROM "<<(std::string)tableNameRow["ParameterTableName"];
                        networkQuery.execute();
                }

                networkQuery.reset();
                networkQuery<<"SELECT ParameterTableName FROM ProbeTypes";
                Result probeTableNameRes = networkQuery.store();
                for(Result::iterator paramTableIter = probeTableNameRes.begin(); paramTableIter != probeTableNameRes.end(); ++paramTableIter){
                        Row tableNameRow (*paramTableIter);
                        networkQuery.reset();
                        networkQuery<<"DELETE FROM "<<(std::string)tableNameRow["ParameterTableName"];
                        networkQuery.execute();
                }


                //Clear NeuralArchive database
                Query archiveQuery = archiveDBInterface->getQuery();

                archiveQuery.reset();
                archiveQuery<<"DELETE FROM NetworkData";
                archiveQuery.execute();

                archiveQuery.reset();
                archiveQuery<<"DELETE FROM NetworkModels";
                archiveQuery.execute();


                //Clear Patterns database
                Query patternsQuery = patternDBInterface->getQuery();

                patternsQuery.reset();
                patternsQuery<<"DELETE FROM PatternData";
                patternsQuery.execute();

                patternsQuery.reset();
                patternsQuery<<"DELETE FROM PatternDescriptions";
                patternsQuery.execute();


                //Clear Devices database
                Query devicesQuery = deviceDBInterface->getQuery();

                devicesQuery.reset();
                devicesQuery<<"DELETE FROM Devices";
                devicesQuery.execute();

                devicesQuery.reset();
                devicesQuery<<"DELETE FROM SIMNOSSpikeReceptors";
                devicesQuery.execute();

                devicesQuery.reset();
                devicesQuery<<"DELETE FROM SIMNOSComponents";
                devicesQuery.execute();

                devicesQuery.reset();
                devicesQuery<<"DELETE FROM SynchronizationDelay";
                devicesQuery.execute();

                //Refresh display
                reloadEverything();

        }
        catch (const BadQuery& er) {// Handle any query errors
                cerr<<"SpikeStreamMainWindow: MYSQL QUERY EXCEPTION \""<<er.what()<<"\""<<endl;
                QString errorString = "Bad query when clearing databases: \"";
                errorString += er.what();
                errorString += "\"";
                QMessageBox::critical( 0, "Clear Databases Error", errorString);
        }
        catch (const Exception& er) {// Catch-all for any other MySQL++ exceptions
                cerr<<"SpikeStreamMainWindow: MYSQL EXCEPTION \""<<er.what()<<"\""<<endl;
                QString errorString = "Exception thrown clearing databases: \"";
                errorString += er.what();
                errorString += "\"";
                QMessageBox::critical( 0, "Clear Databases Error", errorString);
        }
}


/*! Called when window is closed. 
        This is needed to invoke destructor of neuronapplication
        Could run a check on whether the user really wants to quit.
        However, this is not needed at present since everthing is stored in the database. */
void SpikeStreamMainWindow::closeEvent( QCloseEvent* ce ){
        //If simulation is initialised, check that user really wants to quit
        if(simulationManager->isInitialised()){
                int response = QMessageBox::warning(this, "Quit SpikeStream?", "Simulation is still initialised.\nDo you want to quit?", QMessageBox::Yes, QMessageBox::No, 0);
                if(response != QMessageBox::Yes){
                        return;
                }
        }
        ce->accept();
}


/*! Loads a neuron group and associated connections from a file. 
        This should be a comma separated matrix of connection weights. */
void SpikeStreamMainWindow::importConnectionMatrix(){
        /* Check that we do not have a simulation initialised. */
        if(SimulationManager::isInitialised()){
                QMessageBox::warning(this, "Import Connection Matrix", "Matrix cannot be loaded when a simulation is initialised.\nDestroy the simulation and try again.");
                return;
        }

        /* Check that playback of an archive is not currently in progress. */
        if(ArchiveManager::isRunning()){
                QMessageBox::warning(this, "Import Connection Matrix", "Matrix cannot be loaded when an archive is being played back.\nStop archive playback and try again.");
                return;
        }

        //Warn user about limitations
        int response = QMessageBox::warning(this, "Import ConnectionMatrix", "This is a preliminary method that will try create a new layer at position (0,0,0) with the default neuron and synapse types\n Make sure there is enough space for the new layer.\nDo you want to continue?", QMessageBox::Yes, QMessageBox::No, 0);
        if(response != QMessageBox::Yes)
                return;

        //Get the file name
        QString fileName = QFileDialog::getOpenFileName(defaultFileLocation, "All files (*.*)", this, "Load matrix dialog", "Choose a file to load" );
        if(fileName == NULL)
                return;

        //Unload archive if it is loaded. Database loading will invalidate the query if it changes the archive database.
        archiveWidget->unloadArchive();

        //Load from the file
        #ifdef LOAD_MATRIX_DEBUG
                cout<<"Loading connection matrix from file: "<<fileName<<endl;
        #endif//LOAD_MATRIX_DEBUG

        ConnectionMatrixLoader* matrixLoader = new ConnectionMatrixLoader(networkDBInterface);
        matrixLoader->loadConnectionMatrix(fileName);
        
        //Clean up database manager
        delete matrixLoader;

        //Reload the graphics
        reloadEverything();
}


/*! Loads databases from a file selected by the user.
        Launches database manager, which allows user to select which database to load. */
void SpikeStreamMainWindow::loadDatabases(){
        /* Check that we do not have a simulation initialised. */
        if(SimulationManager::isInitialised()){
                QMessageBox::warning(this, "Load Databases", "Databases cannot be loaded when a simulation is initialised.\nDestroy the simulation and try again.");
                return;
        }

        /* Check that playback of an archive is not currently in progress. */
        if(ArchiveManager::isRunning()){
                QMessageBox::warning(this, "Load Databases", "Databases cannot be loaded when an archive is being played back.\nStop archive playback and try again.");
                return;
        }


        //Check that user wants to overwrite current database
        int response = QMessageBox::warning(this, "Load Databases", "This will overwrite all data in the databases that are loaded including Neuron, Synapse and Probe types.\nDo you want to continue?", QMessageBox::Yes, QMessageBox::No, 0);
        if(response != QMessageBox::Yes)
                return;

        //Get the file name
        QString fileName = QFileDialog::getOpenFileName(defaultFileLocation, "Zipped SQL (*.sql.tar.gz)", this, "load database dialog", "Choose a file to load" );
        if(fileName == NULL)
                return;

        //Unload archive if it is loaded. Database loading will invalidate the query if it changes the archive database.
        archiveWidget->unloadArchive();

        //Do some sorting out on the name. The user may have typed .sql.zip at the end
        if(!fileName.endsWith(NEURON_APPLICATION_FILE_EXTENSION))
                fileName += NEURON_APPLICATION_FILE_EXTENSION;

        //Load from the file
        #ifdef LOAD_DATABASES_DEBUG
                cout<<"Loading databases from file: "<<fileName<<endl;
        #endif//SAVE_DATABASES_DEBUG

        DatabaseManager* dbManager = new DatabaseManager(this, fileName, false, networkDBInterface, archiveDBInterface, patternDBInterface, deviceDBInterface);
        dbManager->exec();
        
        //Clean up database manager
        delete dbManager;

        //Reload the graphics
        reloadEverything();
}


/*! Launches the pattern manager, which is used to load and delete patterns from the database. */
void SpikeStreamMainWindow::managePatterns(){
        PatternDialog* patternDialog = new PatternDialog(this, patternDBInterface);
        patternDialog->exec();
        delete patternDialog;
}


/*! Launches a probe manager, which enables the user to add or remove probes. */
void SpikeStreamMainWindow::manageProbes(){
        ProbeDialog* probeDialog = new ProbeDialog(this, networkDBInterface);
        probeDialog->exec();
        delete probeDialog;
}


/*! Menu item triggers this, which reloads the device table in the simulation widget. */
void SpikeStreamMainWindow::reloadDevices(){
        simulationWidget->reloadDevices();

}


/*! Reloads neuron groups and connections from the database. */
void SpikeStreamMainWindow::reloadEverything(){
        try{
                layerWidget->reloadNeuronGroups();
                connectionWidget->reloadConnections();
                simulationWidget->reloadNeuronGroups();
                simulationWidget->reloadConnectionGroups();
                networkViewerProperties->reloadConnections();
                networkViewerProperties->reloadNeuronGroups();
                networkViewer->reloadEverything();
        }
        catch (const BadQuery& er) {// Handle any query errors
                cerr<<"SpikeStreamMainWindow: MYSQL QUERY EXCEPTION \""<<er.what()<<"\""<<endl;
                QString errorString = "Bad query reloading everything: \"";
                errorString += er.what();
                errorString += "\"";
                QMessageBox::critical( 0, "Reload Error", errorString);
        }
        catch (const Exception& er) {// Catch-all for any other MySQL++ exceptions
                cerr<<"SpikeStreamMainWindow: MYSQL EXCEPTION \""<<er.what()<<"\""<<endl;
                QString errorString = "Exception thrown reloading everything: \"";
                errorString += er.what();
                errorString += "\"";
                QMessageBox::critical( 0, "Reload Error", errorString);
        }
        catch (std::exception& er) {// Catch-all for any other MySQL++ exceptions
                cerr<<"SpikeStreamMainWindow: MYSQL EXCEPTION \""<<er.what()<<"\""<<endl;
                QString errorString = "Exception thrown reloading everything: \"";
                errorString += er.what();
                errorString += "\"";
                QMessageBox::critical( 0, "Reload Error", errorString);
        }
}


/*! Reloads patterns after they have been added or deleted. */
void SpikeStreamMainWindow::reloadPatterns(){
        simulationWidget->reloadPatterns();
}


/*! Saves databases 
        Allows user to choose file and then launches database manager so that user can choose
        which databases to save. */
void SpikeStreamMainWindow::saveDatabases(){
    QString fileName = QFileDialog::getSaveFileName(defaultFileLocation, "Zipped SQL (*.sql.tar.gz)", this, "save file dialog", "Choose a filename to save under" );
        if(fileName == NULL)
                return;

        //First do some sorting out on the name. The user may have typed .sql.gz at the end
        if(!fileName.endsWith(NEURON_APPLICATION_FILE_EXTENSION))
                fileName += NEURON_APPLICATION_FILE_EXTENSION;

        //See if the file already exists and check if user wants to save if it does
        if(QFile::exists(fileName)){
                int response = QMessageBox::question(this, "Overwrite File?", "This file already exists.\nDo you want to overwrite it?", "Yes", "No", QString::null, 1, 0);
                if(response == 1)
                        return;
                else
                        QFile::remove(fileName);
        }
                
        //Save the file
        #ifdef SAVE_DATABASES_DEBUG
                cout<<"Saving databases in file: "<<fileName<<endl;
        #endif//SAVE_DATABASES_DEBUG

        DatabaseManager* dbManager = new DatabaseManager(this, fileName, true, networkDBInterface, archiveDBInterface, patternDBInterface, deviceDBInterface);
        dbManager->exec();

        //Clean up dbManager
        delete dbManager;
}

---