NemoWidget.h

Go to the documentation of this file.

#ifndef NEMOWIDGET_H
#define NEMOWIDGET_H

//SpikeStream includes
#include "MembranePotentialGraphDialog.h"
#include "NemoWrapper.h"
#include "SpikeRasterDialog.h"
#include "SpikeStreamTypes.h"
#include "RGBColor.h"

//Qt includes
#include <QAction>
#include <QCheckBox>
#include <QComboBox>
#include <QGroupBox>
#include <QLabel>
#include <QLineEdit>
#include <QMutex>
#include <QProgressDialog>
#include <QPushButton>
#include <QRadioButton>
#include <QTimer>
#include <QToolBar>
#include <QWidget>

namespace spikestream {

        class NemoWidget : public QWidget {
                Q_OBJECT

                public:
                        NemoWidget(QWidget* parent = 0);
                        ~NemoWidget();

                private slots:
                        void archiveStateChanged(int state);
                        void checkLoadingProgress();
                        void checkResetWeightsProgress();
                        void checkSaveWeightsProgress();
                        void deleteMembranePotentialGraphDialog(int);
                        void deleteRasterPlotDialog(int);
                        void experimentEnded();
                        void experimentStarted();
                        void injectNoiseButtonClicked();
                        void injectPatternButtonClicked();
                        void loadPattern(QString comboStr);
                        void loadSimulation();
                        void memPotGraphButtonClicked();
                        void monitorChanged(int state);
                        void monitorNeuronsStateChanged(int monitorType);
                        void nemoWrapperFinished();
                        void networkChanged();
                        void rasterButtonClicked();
                        void resetWeights();
                        void setArchiveDescription();
                        void setNeuronParameters();
                        void setNemoParameters();
                        void setSynapseParameters();
                        void saveWeights();
                        void setMonitorWeights(bool enable);
                        void simulationRateChanged(int comboIndex);
                        void simulationStopped();
                        void startSimulation();
                        void startStopSimulation();
                        void stepSimulation();
                        void stopSimulation();
                        void sustainNoiseChanged(bool enabled);
                        void sustainPatternChanged(bool enabled);
                        void unloadSimulation(bool confirmWithUser=true);
                        void updateProgress(int stepsCompleted, int totalSteps);
                        void updateTimeStep(unsigned int timeStep);
                        void updateTimeStep(unsigned int timeStep, const QList<unsigned>& neuronIDList);
                        void updateTimeStep(unsigned int timeStep, const QHash<unsigned, float>& membranePotentialMap);

                private:
                        //========================  VARIABLES  ========================
                        NemoWrapper* nemoWrapper;

                        QGroupBox* mainGroupBox;

                        QGroupBox* monitorGroupBox;

                        QGroupBox* injectGroupBox;

                        QWidget* controlsWidget;

                        QPushButton* loadButton;

                        QPushButton* unloadButton;

                        QPushButton* neuronParametersButton;

                        QPushButton* synapseParametersButton;

                        QPushButton* nemoParametersButton;

                        QToolBar* toolBar;

                        QAction* playAction;

                        QAction* stopAction;

                        QAction* stepAction;

                        QRadioButton* noMonitorNeuronsButton;

                        QRadioButton* monitorFiringNeuronsButton;

                        QRadioButton* monitorMemPotNeuronsButton;

                        QPushButton* rasterButton;

                        QCheckBox* monitorWeightsCheckBox;

                        QCheckBox* archiveCheckBox;

                        QLineEdit* archiveDescriptionEdit;

                        QPushButton* setArchiveDescriptionButton;

                        QComboBox* simulationRateCombo;

                        QLabel* timeStepLabel;

                        QPushButton* saveWeightsButton;

                        QPushButton* resetWeightsButton;

                        QProgressDialog* progressDialog;

                        QMutex mutex;

                        bool taskCancelled;

                        RGBColor* neuronColor;

                        QTimer* loadingTimer;

                        QTimer* heavyTaskTimer;

                        bool updatingProgress;

                        QCheckBox* sustainNoiseChkBox;

                        QPushButton* injectNoiseButton;

                        QComboBox* injectNoisePercentCombo;

                        QComboBox* injectNoiseCurrentCombo;

                        QComboBox* injectNoiseNeuronGroupCombo;

                        QComboBox* injectPatternNeurGrpCombo;

                        QComboBox* patternCombo;

                        QComboBox* patternCurrentCombo;

                        QPushButton* injectPatternButton;

                        QCheckBox* sustainPatternChkBox;

                        QHash<QString, Pattern> patternMap;

                        QHash<int, RGBColor*> heatColorMap;

                        unsigned rasterDialogCtr;

                        QHash<unsigned,  SpikeRasterDialog*> rasterDialogMap;

                        QPushButton* memPotGraphButton;

                        QHash<unsigned,  MembranePotentialGraphDialog*> memPotGraphDialogMap;

                        //=======================  METHODS  =========================
                        bool checkForErrors();
                        void checkWidgetEnabled();
                        void createMembranePotentialColors();
                        void fillPatternCurrentCombo();
                        QString getFilePath(QString fileFilter);
                        unsigned getNeuronGroupID(QString neurGrpStr);
                        QString getPatternKey(const QString& patternComboText);
                        QToolBar* getToolBar();
                        void loadNeuronGroups();
                        void setInjectNoise(bool sustain);
                        void setInjectionPattern(bool sustain);
        };

}

#endif//NEMOWIDGET_H