src/neuroscopeview.h

/***************************************************************************
                          neuroscopeview.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 NEUROSCOPEVIEW_H
#define NEUROSCOPEVIEW_H

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

//Include files for KDE
#include <kdockwidget.h>
#include <kstatusbar.h>
#include <kprinter.h>

// include files for Qt
#include <qwidget.h>
#include <qdict.h>
#include <qimage.h>

// application specific includes
#include "baseframe.h"
#include "positionview.h"
#include "globaleventsprovider.h"

class NeuroscopeApp;
class TracesProvider;
class ChannelColors;
class ClustersProvider;
class EventsProvider;
class PositionsProvider;
class ItemColors;
class TraceWidget;

//General C++ include files
#include <iostream>
using namespace std;


class NeuroscopeView : public KDockArea
{
  Q_OBJECT
  public:
    NeuroscopeView(NeuroscopeApp& mainWindow,QString label,long startTime,long duration,QColor backgroundColor,int wflags,KStatusBar * statusBar,QValueList<int>* channelsToDisplay,bool greyScale,
                  TracesProvider& tracesProvider,bool multiColumns,bool verticalLines,
                  bool raster,bool waveforms,bool labelsDisplay,int unitGain,int acquisitionGain,ChannelColors* channelColors,
                  QMap<int,QValueList<int> >* groupsChannels,QMap<int,int>* channelsGroups,
                  QValueList<int> offsets,QValueList<int> channelGains,QValueList<int> selected,QMap<int,bool> skipStatus,int rasterHeight,QString backgroundImagePath,
                  QWidget *parent = 0, const char *name=0);
    ~NeuroscopeView();

    void print(KPrinter* pPrinter,QString filePath,bool whiteBackground);

    inline void setGains(int gain,int acquisitionGain ){
     emit updateGains(gain,acquisitionGain); 
     emit drawTraces();
    };

    inline void updateBackgroundColor(QColor color){emit changeBackgroundColor(color);};

    inline void documentFeaturesModified(){emit drawTraces();};

    inline void samplingRateModified(long long recordingLength){
      emit newSamplingRate(recordingLength);
    }
    
    void setChannelNb(int nb);

    inline void showAllWidgets(){
      dockManager->activate();
      emit updateContents();
    };

    inline void setGreyScale(bool grey){
     greyScaleMode = grey;
     emit greyScale(grey);
    };

    inline bool getGreyScale() const {return greyScaleMode;};

    void shownChannelsUpdate(const QValueList<int>& channelsToShow);

    inline const QValueList<int>& channels() const {return *shownChannels;};

    void shownClustersUpdate(QString name,QValueList<int>& clustersToShow);
    
    void shownEventsUpdate(QString name,QValueList<int>& eventsToShow);

    void setMultiColumns(bool multiple);
    
    void setClusterVerticalLines(bool lines);

    void setClusterRaster(bool raster);

    void setClusterWaveforms(bool waveforms);
        
    inline bool getMultiColumns() const {return multiColumns;};

    inline bool getClusterVerticalLines() const {return verticalLines;};

    inline bool getClusterRaster() const {return raster;};

    inline bool getClusterWaveforms() const {return waveforms;};

   inline const QValueList<int>* getSelectedClusters(QString name) const{return selectedClusters[name];};
    
   inline const QValueList<int>* getSelectedEvents(QString name) const{return selectedEvents[name];};

   inline void setMode(BaseFrame::Mode selectedMode,bool active){
    if(selectedMode == 2) selectMode = true;
    else selectMode = false; 
    emit modeToSet(selectedMode,active);
   };

   inline bool isSelectionTool(){return selectMode;};
   
   inline void singleChannelColorUpdate(int channelId,bool active){emit channelColorUpdate(channelId,active);};
   
   inline void channelGroupColorUpdate(int groupId,bool active){emit groupColorUpdate(groupId,active);};
   
   inline void increaseAllChannelsAmplitude(){emit increaseAllAmplitude();};

   inline void decreaseAllChannelsAmplitude(){emit decreaseAllAmplitude();};
   
   inline void increaseSelectedChannelsAmplitude(const QValueList<int> selectedIds){
    //update the list of selected channels
    selectedChannels.clear();
    QValueList<int>::const_iterator selectedIterator;
    for(selectedIterator = selectedIds.begin(); selectedIterator != selectedIds.end(); ++selectedIterator)
     selectedChannels.append(*selectedIterator);

    emit increaseAmplitude(selectedIds);
   };

   inline void decreaseSelectedChannelsAmplitude(const QValueList<int> selectedIds){
    //update the list of selected channels
    selectedChannels.clear();
    QValueList<int>::const_iterator selectedIterator;
    for(selectedIterator = selectedIds.begin(); selectedIterator != selectedIds.end(); ++selectedIterator)
     selectedChannels.append(*selectedIterator);

    emit decreaseAmplitude(selectedIds);
   };

    inline void updateViewContents(){
      emit updateDrawing();
    };

    inline void groupsModified(bool active){emit groupsHaveBeenModified(active);};
    
   inline void selectChannels(const QValueList<int>& selectedIds){   
    selectedChannels.clear(); 
    QValueList<int>::const_iterator selectedIterator;
    for(selectedIterator = selectedIds.begin(); selectedIterator != selectedIds.end(); ++selectedIterator){
     selectedChannels.append(*selectedIterator);
    }
    
    emit channelsToBeSelected(selectedIds);
   };

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

   void resetGains(const QValueList<int>& selectedIds){
    //update the list of selected channels
    selectedChannels.clear();
    QValueList<int>::const_iterator selectedIterator;
    for(selectedIterator = selectedIds.begin(); selectedIterator != selectedIds.end(); ++selectedIterator)
     selectedChannels.append(*selectedIterator);

    emit resetChannelGains(selectedChannels);     
   };
   

   inline const QValueList<int>& getChannelOffset() const{return channelOffsets;};

   inline const QValueList<int>& getGains() const{return gains;};

   inline const QValueList<int>& getSelectedChannels() const{return selectedChannels;};

   inline void setSelectedChannels(const QValueList<int>& selectedIds){
    //update the list of selected channels
    selectedChannels.clear();
    QValueList<int>::const_iterator selectedIterator;
    for(selectedIterator = selectedIds.begin(); selectedIterator != selectedIds.end(); ++selectedIterator){
     selectedChannels.append(*selectedIterator);
    }    
   };

   inline void setTabName(QString newLabel){tabLabel = newLabel;};

   inline QString getTabName(){return tabLabel;};

  inline long getStartTime(){return startTime;};

  inline long getTimeWindow(){return timeWindow;};
   
  inline void showLabelsUpdate(bool status){
   labelsDisplay = status;
   emit showLabels(status);
  };

  inline bool getLabelStatus() const{return labelsDisplay;};

  inline void showCalibration(bool show,bool active){emit displayCalibration(show,active);};

  void setClusterProvider(ClustersProvider* clustersProvider,QString name,ItemColors* clusterColors,bool active,
                          QValueList<int>& clustersToShow,QMap<int, QValueList<int> >* displayGroupsClusterFile,QMap<int,int>* channelsSpikeGroups,
                          int nbSamplesBefore,int nbSamplesAfter,const QValueList<int>& clustersToSkip);

  void removeClusterProvider(QString name,bool active);

  inline void  clusterColorUpdate(QString name,int clusterId,bool active){emit clusterColorUpdated(name,clusterId,active);};

  inline void ignoreWaveformInformation(){ emit clusterWaveformsDisplay(false);};

  inline void showNextCluster(){emit nextCluster();};

  inline void showPreviousCluster(){emit previousCluster();};

  void setEventProvider(EventsProvider* eventsProvider,QString name,ItemColors* eventColors,bool active,
                          QValueList<int>& eventsToShow,const QValueList<int>& eventsToSkip);

  void removeEventProvider(QString name,bool active,bool lastFile);

  inline void  eventColorUpdate(QString name,int eventId,bool active){emit eventColorUpdated(name,eventId,active);};

  inline void showNextEvent(){
   emit nextEvent();
  };

  inline void showPreviousEvent(){
   emit previousEvent();
  };

  void updateEvents(QString providerName,int selectedEventId,float time,float newTime,bool active);

  inline void removeEvent(){
   emit eventToRemove();
   emit updateEventDisplay(); 
  };

  void updateEventsAfterRemoval(QString providerName,int eventId,float time,bool active);

  void updateEventsAfterAddition(QString providerName,int eventId,float time,bool active);

  inline void updateEvents(QString providerName,int eventId,float time,bool active){
   emit updateEvents(active,providerName,time); 
   emit updateEventDisplay();
  };

  inline void eventToAddProperties(QString providerName,QString eventDescription){emit newEventProperties(providerName,eventDescription);};

  void updateSelectedEventsIds(QString providerName,QMap<int,int>& oldNewEventIds,int addedEventId,bool active,bool added);

  void removePositionProvider(QString name,bool active);

  inline bool isPositionView()const {return isPositionFileShown;};

  void addPositionView(PositionsProvider* positionsProvider,QImage backgroundImage,QColor backgroundColor,long startTime,long duration,int width,int height,bool showEvents);

  inline void addPositionView(PositionsProvider* positionsProvider,QImage backgroundImage,QColor backgroundColor,int width,int height){
   addPositionView(positionsProvider,backgroundImage,backgroundColor,startTime,timeWindow,width,height,eventsInPositionView); 
  };

  void removePositionView();

  inline void updateClusterData(bool active){emit clusterProviderUpdated(active);};

  inline const QValueList<int>* getClustersNotUsedForBrowsing(QString name) const{return clustersNotUsedForBrowsing[name];};

  inline const QValueList<int>* getEventsNotUsedForBrowsing(QString name) const{return eventsNotUsedForBrowsing[name];};

  void updateNoneBrowsingEventList(QString providerName,const QValueList<int>& eventsToNotBrowse);

  void updateNoneBrowsingClusterList(QString providerName,const QValueList<int>& clustersToNotBrowse);
  
  inline void updateSkipStatus(const QValueList<int>& skippedChannels){emit skipStatusChanged(skippedChannels);};
  
  inline void increaseRasterHeight(){emit increaseTheRasterHeight();};
  
  inline void decreaseRasterHeight(){emit decreaseTheRasterHeight();};
  
  int getRasterHeight();
  
  inline int isEventsInPositionView()const{return eventsInPositionView;};
  
public slots:
    inline void slotChannelsSelected(const QValueList<int>& selectedIds){
    selectedChannels.clear();
    QValueList<int>::const_iterator selectedIterator;
    for(selectedIterator = selectedIds.begin(); selectedIterator != selectedIds.end(); ++selectedIterator)
     selectedChannels.append(*selectedIterator);

     emit channelsSelected(selectedIds);
    };

   inline void setStartAndDuration(long start,long duration){
    startTime = start;
    timeWindow = duration;
    emit timeChanged(start,duration);
   };

  inline void slotEventModified(QString providerName,int selectedEventId,double time,double newTime){
    emit eventModified(providerName,selectedEventId,time,newTime);
    emit updateEventDisplay();
  };

  inline void slotEventRemoved(QString providerName,int selectedEventId,double time){
   emit eventRemoved(providerName,selectedEventId,time);
   emit updateEventDisplay();
  };

  inline void slotEventAdded(QString providerName,QString addedEventDescription,double time){
   emit eventAdded(providerName,addedEventDescription,time);
  };

  inline void updateWaveformInformation(int nbSamplesBefore, int nbSamplesAfter,bool active){
   emit waveformInformationUpdated(nbSamplesBefore,nbSamplesAfter,active); 
  };


  inline void updatePositionInformation(int width, int height,QImage backgroundImage,bool newOrientation,bool active){
   emit positionInformationUpdated(width,height,backgroundImage,newOrientation,active);
  };
  

  void positionDockClosed(QWidget* view);
  
  void setEventsInPositionView(bool shown);
  
   inline void updateTraceBackgroundImage(QImage traceBackgroundImage,bool active){emit traceBackgroundImageUpdate(traceBackgroundImage,active);};

  
    
  signals:
    void changeBackgroundColor(QColor color);
    void updateContents();
    void greyScale(bool geyScale);
    void clusterWaveformsDisplay(bool waveforms);
    void clusterRasterDisplay(bool raster);
    void clusterVerticalLinesDisplay(bool lines);
    void multiColumnsDisplay(bool multi);
    void channelsSelected(const QValueList<int>& selectedIds);
    void modeToSet(BaseFrame::Mode selectedMode,bool active);
    void showChannels(const QValueList<int>& channelsToShow);
    void channelColorUpdate(int channelId,bool active);
    void groupColorUpdate(int groupId,bool active);
    void increaseAllAmplitude();
    void decreaseAllAmplitude();
    void increaseAmplitude(const QValueList<int>& selectedIds);
    void decreaseAmplitude(const QValueList<int>& selectedIds);
    void updateGains(int gain,int acquisitionGain);
    void updateDrawing();
    void groupsHaveBeenModified(bool);
    void channelsToBeSelected(const QValueList<int>& selectedIds);
    void resetChannelOffsets(const QMap<int,int>& selectedChannelDefaultOffsets);
    void resetChannelGains(const QValueList<int>& selectedChannels);
    void drawTraces();
    void reset();
    void showLabels(bool show);
    void displayCalibration(bool show,bool active);
    void newClusterProvider(ClustersProvider* clustersProvider,QString name,ItemColors* clusterColors,bool active,
                            QValueList<int>& clustersToShow,QMap<int, QValueList<int> >* displayGroupsClusterFile,
                            QMap<int,int>* channelsSpikeGroups,int nbSamplesBefore,int nbSamplesAfter,const QValueList<int>& clustersToSkip);
    void newSamplingRate(long long recordingLength);
    void clusterProviderRemoved(QString name,bool active);
    void showClusters(QString name,QValueList<int>& clustersToShow);
    void clusterColorUpdated(QString name,int clusterId,bool active);
    void nextCluster();
    void previousCluster();
    void print(QPainter& printPainter,QPaintDeviceMetrics& metrics,QString filePath,bool whiteBackground);
    void newEventProvider(EventsProvider* eventsProvider,QString name,ItemColors* eventColors,bool active,
                            QValueList<int>& eventsToShow,const QValueList<int>& eventsToSkip);
    void eventProviderRemoved(QString name,bool active,bool lastFile);
    void showEvents(QString name,QValueList<int>& eventsToShow);
    void eventColorUpdated(QString name,int eventId,bool active);
    void nextEvent();
    void previousEvent();
    void eventModified(QString providerName,int selectedEventId,double time,double newTime);
    void updateEvents(bool active,QString providerName,double time,double newTime);
    void eventToRemove();
    void eventRemoved(QString providerName,int selectedEventId,double time);
    void updateEvents(bool active,QString providerName,double time);
    void newEventProperties(QString providerName,QString eventId);
    void eventAdded(QString providerName,QString addedEventDescription,double time);
    void updateEvents(QString providerName,QValueList<int>& eventsToShow,bool active);
    void waveformInformationUpdated(int nbSamplesBefore,int nbSamplesAfter,bool active);
    void positionInformationUpdated(int width, int height,QImage backgroundImage,bool newOrientation,bool active);
    void timeChanged(long start,long duration);
    void positionViewClosed();
    void clusterProviderUpdated(bool active);
    void noneBrowsingClusterListUpdated(QString providerName,const QValueList<int>& clustersToNotBrowse);
    void noneBrowsingEventListUpdated(QString providerName,const QValueList<int>& eventsToNotBrowse);
    void skipStatusChanged(const QValueList<int>& skippedChannels);
    void decreaseTheRasterHeight();
    void increaseTheRasterHeight();
    void updateEventDisplay();
    void eventsShownInPositionView(bool shown);
    void traceBackgroundImageUpdate(QImage traceBackgroundImage,bool active);
                       
  private:

   QValueList<int>* shownChannels;

   NeuroscopeApp& mainWindow;
   
  bool greyScaleMode;

  KDockWidget* mainDock;

  bool multiColumns;

  bool verticalLines;

  bool raster;

  bool waveforms;
 
  bool selectMode;

  QValueList<int> channelOffsets;

  QValueList<int> gains;

  /*List of the currently selected channels.*/
  QValueList<int> selectedChannels;

  QString tabLabel;

  /*Starting time in miliseconds.*/
  long startTime;

  /*Time window in miliseconds.*/
  long timeWindow;

  bool labelsDisplay;

  QDict< QValueList<int> > selectedClusters;
  
  QDict< QValueList<int> > selectedEvents;

  QDict<QValueList<int> > clustersNotUsedForBrowsing;

  QDict<QValueList<int> > eventsNotUsedForBrowsing;
  
  bool isPositionFileShown;

  PositionView* positionView;
  
  TraceWidget* traceWidget;
  
  GlobalEventsProvider globalEventProvider;
  
  bool eventsInPositionView;
 };

#endif // NEUROSCOPEVIEW_H

---