src/neuroscope.h

/***************************************************************************
                          neuroscope.h  -  description
                             -------------------
    begin                : Wed Feb 25 19:05:25 EST 2004
    copyright            : (C) 2004 by Lynn Hazan
    email                : lynn.hazan.myrealbox.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef NEUROSCOPE_H
#define NEUROSCOPE_H
 

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

// include files for KDE 
#include <kapp.h>
#include <klocale.h>
#include <kdockwidget.h>
#include <kaccel.h>
#include <kaction.h>
#include <kurl.h>
#include <kcolorbutton.h>
#include <kdeprint/kprintdialogpage.h>
#include <kpopupmenu.h>

//QT include files
#include <qcheckbox.h>

//application specific include files
#include "neuroscopeview.h"

// forward declaration of the Neuroscope classes
class NeuroscopeDoc;
class PrefDialog;
class PropertiesDialog;
class ChannelPalette;
class ItemPalette;

class NeuroscopeApp : public KDockMainWindow
{
  Q_OBJECT

  friend class NeuroscopeView;

  public:
    NeuroscopeApp();
    ~NeuroscopeApp();

    void openDocumentFile(const KURL& url=0);
    
    NeuroscopeDoc* getDocument() const;

    NeuroscopeView* activeView();

    void setFileProperties(QString channelNb,QString SR,QString resolution,QString offset,QString voltageRange,
                          QString amplification,QString screenGain,QString timeWindow);

    void displayFileProperties(int channelNb,double SR,int resolution,int offset,int voltageRange,int amplification,
                              float screenGain,int currentNbSamples,int currentPeakIndex,double videoSamplingRate,
                              int width, int height, QString backgroundImage,int rotation,int flip,
                              double acquisitionSystemSamplingRate,bool isaDatFile,bool positionsBackground,QString traceBackgroundImage);

   void resizePalettePanel();

   void createDisplay(QValueList<int>* channelsToDisplay,bool verticalLines,bool raster,bool waveforms,bool showLabels,
                       bool multipleColumns,bool greyMode,QValueList<int> offsets,QValueList<int> channelGains,
                       QValueList<int> selectedChannels,long startTime,long duration,int rasterHeight,QString tabLabel = "");

   void createClusterPalette(QString clusterFileId);

   void addClusterFile(QString clusterFileId);
   
   void createEventPalette(QString eventFileId);

   void addEventFile(QString eventFileId);

   ItemPalette* getEventPalette();

   inline QColor getBackgroundColor()const{return backgroundColor;}   ;

   inline void positionFileLoaded(){
    isPositionFileLoaded = true;
    slotStateChanged("positionState");
   };
      
   inline bool isClusterFilesLoaded()const{return !clusterFileList.isEmpty();};   
    
   inline bool isApositionFileLoaded()const{return isPositionFileLoaded;};   
   
  public slots:

  void slotEventModified(QString providerName,int selectedEventId,double time,double newTime);

  void removeEvent();

  void slotEventRemoved(QString providerName,int selectedEventId,double time);
  
  void addEvent();

  void slotEventGroupSelected(QString eventGroupName);

  void slotEventAdded(QString providerName,QString addedEventDescription,double time);

  inline void positionViewClosed(){positionViewToggle->setChecked(false);};

  inline void slotNoClustersToBrowse(){slotStateChanged("noClusterBrowsingState");};

  inline void slotClustersToBrowse(){slotStateChanged("clusterBrowsingState");};

  inline void slotNoEventsToBrowse(){slotStateChanged("noEventBrowsingState");};
  
  inline void slotEventsToBrowse(){slotStateChanged("eventBrowsingState");};

  protected:
    void initActions();
    void initStatusBar();
       
    void initDisplay(QValueList<int>* channelsToDisplay,QValueList<int> offsets,QValueList<int> channelGains,
                    QValueList<int> selectedChannels,QMap<int,bool>& skipStatus,int rasterHeight=-1,long duration = 1000,long startTime = 0,QString tabLabel = "");
    
    virtual bool queryClose();
    
    virtual bool queryExit();
    
    virtual void saveProperties(KConfig* config);
    
    virtual void readProperties(KConfig* config);

    
    void customEvent (QCustomEvent* event);
    
  private slots:
    void slotFileOpen();

    void slotLoadClusterFiles();

    void slotCloseClusterFile();
    
    void slotLoadEventFiles();

    void slotCreateEventFile();
    
    void slotCloseEventFile();

    void slotLoadPositionFile();

    void slotClosePositionFile();
    
    void slotFileOpenRecent(const KURL& url);

    void slotFileProperties();
    
    void slotFileClose();

    void slotFilePrint();

    void slotFileQuit();

    void slotViewMainToolBar();

    void slotViewToolBar();

    void slotViewStatusBar();

    void slotViewParameterBar();

    void slotShowCalibration();
    
    void slotStatusMsg(const QString &text);

    void slotKeyBindings();

    /*Slots for the tools menu.*/
    void slotSelect();
    
    void slotZoom();

    void slotMeasure();

    void slotSelectTime();
    
    void slotSelectEvent();

    void executePreferencesDlg();

    void applyPreferences();

    void initializePreferences();

    void slotSingleChannelColorUpdate(int channelId);

    void slotChannelGroupColorUpdate(int groupId);

    //void slotChannelsColorUpdate(QValueList<int> selectedChannels);

    void slotApplyDisplayColor();

    void slotApplySpikeColor();
          
    void slotUpdateShownChannels(const QValueList<int>& selectedChannels);

    void slotUpdateHiddenChannels(const QValueList<int>& hiddenChannels);

    void slotDefaultSetUp(QMap<int,int>& channelDefaultOffsets,QMap<int,bool>& skipStatus);

    void slotSetUp(QValueList<int>* channelsToDisplay,bool verticalLines,bool raster,bool waveforms,bool showLabels,bool multipleColumns,
                   bool greyMode,QValueList<int> offsets,QValueList<int> channelGains,QValueList<int> selectedChannels,QMap<int,bool>& skipStatus,
                   long startTime,long duration,QString tabLabel,bool positionView,int rasterHeight,bool showEventsInPositionView);
                                                       
    void slotSetGreyScale();

    void slotCreateGroup();

    void slotSelectAll();

    void slotDeselectAll();

    void slotSelectAllWO01();
    
    void slotDisplayMode();

    void slotClustersVerticalLines();
    
    void slotClustersRaster();

    void slotClustersWaveforms();

    void slotDiscardChannels();

    void slotDiscardSpikeChannels();
    
    void slotChannelsDiscarded(const QValueList<int>& discarded);
   
    void slotShowChannels();

    void slotHideChannels();

    void slotTabChange(QWidget* widget);

    void slotPaletteTabChange(QWidget* widget);

    void slotDisplayClose();

   void slotRenameActiveDisplay();

   void slotNewDisplay();

   void slotEditMode();

   void slotSynchronize();

   void slotGroupsModified();

   void slotSelectChannelsInPalette(const QValueList<int>& selectedIds);

   inline void slotIncreaseAllChannelsAmplitude(){activeView()->increaseAllChannelsAmplitude();};

   inline void slotDecreaseAllChannelsAmplitude(){activeView()->decreaseAllChannelsAmplitude();};
   
   void slotIncreaseSelectedChannelsAmplitude();

   void slotDecreaseSelectedChannelsAmplitude();

   void slotChannelsSelected(const QValueList<int>& selectedIds);

   void slotResetOffsets();

   void slotResetGains();
   
   void saveSession();

   void slotSessionSaveAs();

   void slotShowLabels();

   void slotClusterColorUpdate(int clusterId,QString groupName);

   void slotUpdateShownClusters(const QMap<QString,QValueList<int> >& selection);
   
   void slotShowNextCluster();

   void slotShowPreviousCluster();

   void slotEventColorUpdate(int eventId,QString groupName);

   void slotUpdateShownEvents(const QMap<QString,QValueList<int> >& selection);

   void slotShowNextEvent();

   void slotShowPreviousEvent();

   void slotUndo();
   
   void slotRedo();

   void slotAddEventAboutToShow();

   void slotAddEventActivated(int index);
   
   void slotAddEventButtonActivated(int index);

   void slotShowPositionView();

   void slotUpdateEventsToSkip(QString groupName,const QValueList<int>& eventsToSkip);

   void slotUpdateClustersToSkip(QString groupName,const QValueList<int>& clustersToSkip);
    
   void slotKeepChannels();

   void slotSkipChannels();
  
   /*Sets the current channel offsets has the default offsets.*/
   void slotSetDefaultOffsets();
   
   /*Resets the channel default offsets to zero.*/
   void slotResetDefaultOffsets();
   
   void slotDrawTimeLine();
   
   void slotIncreaseRasterHeight();
   
   void slotDecreaseRasterHeight();
   
   void slotShowEventsInPositionView();
   
  private:
    KConfig *config;
 
    NeuroscopeDoc *doc;

    PrefDialog* prefDialog;

    //Action and toolbar pointers
    KRecentFilesAction* fileOpenRecent;
    KToggleAction* viewMainToolBar;
    KToggleAction* viewToolBar;
    KToggleAction* viewStatusBar;
    KToggleAction* viewParameterBar;
    KToggleAction* greyScale;
    KToggleAction* displayMode;
    KToggleAction* clusterVerticalLines;
    KToggleAction* clusterRaster;
    KToggleAction* clusterWaveforms;
    KToggleAction* editMode;
    KToggleAction* showHideLabels;
    KToggleAction* calibrationBar;
    KPopupMenu* addEventPopup;
    KSelectAction* addEventMenu;
    KToolBarPopupAction* addEventToolBarAction;
    KToggleAction* positionViewToggle;
    KToggleAction* showEventsInPositionView;
    
    int displayCount;

    KDockWidget* mainDock;

    KDockWidget* displayPanel;

    KDockWidget* spikePanel;

    ChannelPalette* displayChannelPalette;
    
    ChannelPalette* spikeChannelPalette;

    KDockTabGroup* tabsParent;

    KDockTabGroup* paletteTabsParent;

    KDockWidget* palettePanel;

    bool isInit;

    int channelNbDefault;

    double datSamplingRateDefault;

    double eegSamplingRateDefault;

    float screenGainDefault;

    int voltageRangeDefault;

    int amplificationDefault;

    bool groupsModified;    
    
    bool colorModified;
    
    bool eventsModified;

    int initialOffsetDefault;

    int resolutionDefault;

    PropertiesDialog* propertiesDialog;

    QColor backgroundColor;

    bool select;

    QString filePath;

    long initialTimeWindow;

    KPrinter* printer;

    QValueList<QString> clusterFileList;
    
    QValueList<QString> eventFileList;

    bool displayPaletteHeaders;

    int eventPosition;

    int clusterPosition;

    int currentNbUndo;

    int currentNbRedo;

    int eventIndex;
    
    int buttonEventIndex;

    QString eventLabelToCreate;

   QString eventProvider;

   bool undoRedoInprocess;

   int nbSamplesDefault;
   int peakIndexDefault;

   double videoSamplingRateDefault;

   int videoWidthDefault;
   int videoHeightDefault;
   QString backgroundImageDefault;
   
   QString traceBackgroundImageDefault;
   
   int rotationDefault;
   int flipDefault;

   bool isPositionFileLoaded;
   
   bool drawPositionsOnBackgroundDefault;

  //Functions
  
   void initItemPanel();

   void resetState();

   void loadClusterFiles(KURL::List urls);

   void loadEventFiles(KURL::List urls);   

   void loadPositionFile(KURL url);
   
 class printDialogPage : public KPrintDialogPage{
  public:
   inline printDialogPage(QWidget* parent = 0,const char* name = 0): KPrintDialogPage(parent,name){
    setTitle(i18n("Background Color"));
    backgroundColor = new QCheckBox("Use white background",this);
    backgroundColor->adjustSize();
   };

    inline void getOptions(QMap<QString,QString>& opts,bool incldef){
      opts["kde-neuroscope-backgroundColor"] = (backgroundColor->isChecked() ? "1" : "-1");
    };

    inline void setOptions(const QMap<QString,QString>& opts){
     backgroundColor->setChecked(opts["kde-neuroscope-backgroundColor"] == "1"); 
    };

    inline bool isValid(QString& message){return true;};

  private:
    QCheckBox* backgroundColor;
  };
 
  void updateBrowsingStatus();
};

#endif // NEUROSCOPE_H

---