src/traceview.h

/***************************************************************************
                          traceview.h  -  description
                             -------------------
    begin                : Wed Mar 17 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 TRACEVIEW_H
#define TRACEVIEW_H

// include files for QT
#include <qwidget.h>
#include <qpixmap.h>
#include <qdict.h> 
#include <qpair.h>
#include <qimage.h>

//include files for the application
#include "baseframe.h"
#include "tracesprovider.h"
#include "eventdata.h"

//Inclused files for KDE
#include <kstatusbar.h>

//include files for c/c++ libraries
#include <math.h>

// forward declaration of the Neuroscope classes
class ChannelColors;
class ItemColors;
class ClustersProvider;
class EventsProvider;

class TraceView : public BaseFrame  {
   Q_OBJECT
public:
     TraceView(TracesProvider& tracesProvider,bool greyScale,bool multiColumns,bool verticalLines,
            bool raster,bool waveforms,bool labelsDisplay,QValueList<int>& channelsToDisplay,int unitGain,int acquisitionGain,long start,long timeFrameWidth,
            ChannelColors* channelColors,QMap<int, QValueList<int> >* groupsChannels,QMap<int,int>* channelsGroups,
            QValueList<int>& channelOffsets,QValueList<int>& gains,const QValueList<int>& skippedChannels, int rasterHeight,QImage backgroundImage,QWidget* parent=0, const char* name=0,QColor backgroundColor = Qt::black,KStatusBar* statusBar = 0L,
            int minSize = 500, int maxSize = 4000, int windowTopLeft = -500,int windowBottomRight = 1001, int border = 0);


  
     ~TraceView();

  enum {SELECT = ZOOM+1,MEASURE = ZOOM+2,SELECT_TIME = ZOOM+3,SELECT_EVENT = ZOOM+4,ADD_EVENT = ZOOM+5,DRAW_LINE = ZOOM+6};
  

  void setMultiColumns(bool multiple);

  void setClusterVerticalLines(bool lines);

  void setClusterRaster(bool raster);

  void setClusterWaveforms(bool waveforms);
  

  void setGreyScale(bool grey);
  
  void displayTimeFrame(long start,long timeFrameWidth);

  void showChannels(const QValueList<int>& channelsToShow);
  
  void increaseAllAmplitude();

  void decreaseAllAmplitude();

  void increaseSelectedChannelsAmplitude(const QValueList<int>& channelIds);

  void decreaseSelectedChannelsAmplitude(const QValueList<int>& channelIds);

  void setGains(int gain,int acquisitionGain);
  
  void channelColorUpdate(int channelId,bool active);

  inline void groupColorUpdate(int groupId,bool active){
   //Everything has to be redraw
   drawContentsMode = REDRAW ;
    if(active) update();    
  };  
  
  inline void updateDrawing(){  
   if(retrieveClusterData) updateClusterData(true);
   else{
    //Everything has to be redraw
    drawContentsMode = REDRAW ;
    update();
   }   
  };

  void groupsModified(bool active);

  inline void setMode(BaseFrame::Mode selectedMode,bool active){  
   Mode previousMode = mode;
   mode = selectedMode;
   if(selectedMode == SELECT){
    setCursor(selectCursor);
    drawRubberBand(false); 
   }
   if(selectedMode == SELECT_EVENT){
    setCursor(selectEventCursor);
    drawRubberBand(false);
   }
   if(selectedMode == ADD_EVENT){
    setCursor(addEventCursor);
    drawRubberBand(false);
   }
   if(selectedMode == ZOOM){
    setCursor(zoomCursor); 
    drawRubberBand(false); 
   } 
   if(selectedMode == MEASURE){
    drawRubberBand(true);
    setCursor(measureCursor);
   }
   if(selectedMode == SELECT_TIME){
    drawRubberBand(true,true);
    setCursor(selectTimeCursor);
   }
   if(selectedMode == DRAW_LINE){
    setCursor(drawLineCursor);
    drawRubberBand(false); 
   }   
   if(previousMode == SELECT){
    selectedChannels.clear();
    drawContentsMode = REDRAW;
    if(active) update();     
   }
   if(previousMode == SELECT_EVENT){
    selectedEvent.first = "";
    selectedEvent.second = 0;
    drawContentsMode = REDRAW;
    if(active) update();
   }
   if(previousMode == ADD_EVENT){
    newEventPosition = -1;
   }
   if(previousMode == DRAW_LINE){
    linePositions.clear();
   }
  };

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

  void resetOffsets(const QMap<int,int>& selectedChannelDefaultOffsets);

  void resetGains(const QValueList<int>& selectedChannels);

  void reset();
  
  void showHideLabels(bool show);

  inline void showCalibration(bool show,bool active){
   drawContentsMode = REDRAW;
   showCalibrationScale = show;
   if(active) update(); 
  };

  void addClusterProvider(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);

  void showClusters(QString name,QValueList<int>& clustersToShow);

  void clusterColorUpdate(QString name,int clusterId,bool active);


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

  void removeEventProvider(QString name,bool active);

  void showEvents(QString name,QValueList<int>& eventsToShow);

  void eventColorUpdate(QString name,int eventId,bool active);
  
  void print(QPainter& printPainter,QPaintDeviceMetrics& metrics,bool whiteBackground);

  void showNextEvent();

  void showPreviousEvent();

  inline void updateEvents(QString providerName,bool active){
   if(!eventProvidersToUpdate.contains(providerName)) eventProvidersToUpdate.append(providerName);
   if(active) update();
  };

  void updateEvents(QString providerName,QValueList<int>& eventsToShow,bool active);

  void removeEvent();

  void showNextCluster();

  void showPreviousCluster();

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

  void updateNoneBrowsingClusterList(QString providerName,const QValueList<int>& clustersToNotBrowse);

  void updateWaveformInformation(int nbSamplesBefore,int nbSamplesAfter,bool active);

  inline void samplingRateModified(long long length){
   recordingLength = length;
   int samplingRate = tracesProvider.getSamplingRate();
   timeStepUnit = timeStep = static_cast<float>(static_cast<float>(1000) / static_cast<float>(samplingRate));
  };

  void updateClusterData(bool active);
  
  void updateClusters(QString name,QValueList<int>& clustersToShow,ItemColors* clusterColors,bool active);
  
  void increaseRatio();
  
  void decreaseRatio();
  
  void getCurrentEventInformation(long startTime,long endTime,QObject* initiator);
  
  void traceBackgroundImageUpdate(QImage traceBackgroundImage,bool active);
  
public slots:
  void dataAvailable(Array<dataType>& data,QObject* initiator);

  void dataAvailable(Array<dataType>& data,QObject* initiator,QString providerName);

  void dataAvailable(Array<dataType>& times,Array<int>& ids,QObject* initiator,QString providerName);
  
  void nextClusterDataAvailable(Array<dataType>& data,QObject* initiator,QString providerName,long startingTime,long startingTimeInRecordingUnits);

  void previousClusterDataAvailable(Array<dataType>& data,QObject* initiator,QString providerName,long startingTime,long startingTimeInRecordingUnits);

  void nextEventDataAvailable(Array<dataType>& times,Array<int>& ids,QObject* initiator,QString providerName,long startingTime);

  void previousEventDataAvailable(Array<dataType>& times,Array<int>& ids,QObject* initiator,QString providerName,long startingTime);

  inline void eventToAddProperties(QString providerName,QString eventDescription){
   //If an event is being modified, this function can be called with eventDescription set to empty,
   //this should not be taken into account.
   if(!eventBeingModified){
    eventDescriptionToCreate = eventDescription;
    eventProvider = providerName;     
   }
  };
  
  void skipStatusChanged(const QValueList<int>& skippedChannels);

  inline int getRasterHeight(){return rasterHeight;};
  
  
signals:
  void channelsSelected(const QValueList<int>& selectedIds);
  void setStartAndDuration(long time,long duration);
  void eventModified(QString providerName,int selectedEventId,double time,double newTime);
  void eventRemoved(QString providerName,int selectedEventId,double time);
  void eventAdded(QString providerName,QString addedEventDescription,double time);
  void eventsAvailable(QDict<EventData>& eventsData,QMap<QString, QValueList<int> >& selectedEvents,QDict<ItemColors>& providerItemColors,QObject* initiator,double samplingRate);

protected:
  void drawContents(QPainter* painter);

  void mouseMoveEvent(QMouseEvent* event);

  inline void resizeEvent(QResizeEvent* event){
   drawContentsMode = REDRAW;
   resized = true;
  };

  void mousePressEvent(QMouseEvent* event);

  void mouseReleaseEvent(QMouseEvent* event);  

  void mouseDoubleClickEvent(QMouseEvent* event);
  
private:

  bool greyScaleMode;

  KStatusBar* statusBar;

  TracesProvider& tracesProvider;

  bool multiColumns;

  bool verticalLines;

  bool raster;

  bool waveforms;

  QValueList<int> shownChannels;
  
  bool dataReady;

  Array<dataType> data;

  QValueList<int>& channelOffsets;
  
  QValueList<float> channelFactors;

  QValueList<int>& gains;
  
  int traceVspace;

  int nbChannels;

  int peakPositionInWaveform;

  int nbSamplesInWaveform;
    
  long startTime;

  long endTime;

  ChannelColors* channelColors;
   
  QMap<int, QValueList<int> >* groupsChannels;

  QMap<int,int>* channelsGroups;
  
  QMap<int, QValueList<int> > shownGroupsChannels;

  long abscissaMin;

  long abscissaMax;

  long ordinateMin;

  long ordinateMax;

  int borderX;

  int borderY;

  int Yshift;

  int Xshift;

  int Xstep;

  int XGroupSpace;

  int Yspace;

  int YGroupSpace;

  int YTracesRasterSeparator;

  int YRasterSpace;

  long X0;

  long Y0;

  long Y0Raster;

  QPixmap doublebuffer;
  
  QImage background;

  QPixmap scaledBackground;
  

  float timeStep;

  float timeStepUnit;

  int acquisitionGain;
  
  int unitGain;

  float alpha;

  QValueList<float> channelDisplayGains;
  
  int nbClusters;

  int rasterHeight;

  long timeFrameWidth;

  QMap<int,int> channelsStartingOrdinate;

  QMap<int,int> channelsStartingAbscissa;

  static const int XMARGIN;

  static const int YMARGIN;

  int xMargin;

  int yMargin;

  bool columnDisplayChanged;

  bool resized;

  QValueList<int> selectedChannels;

  bool groupsChanged;

  int previousDragOrdinate;

  int lastClickOrdinate;

  /*Boolean used to update the display after a change in the number of samples per trace.**/
  bool nbSamplesModified;
   
  /*Boolean used to update the display after a change in the selection of the traces.**/
  bool alreadySelected;

  bool isInit;

  int screenResolution;

  int channelforVoltageComputation;

  int startingIndex;

  QCursor selectCursor;
  
  QCursor measureCursor;

  QCursor selectTimeCursor;

  QCursor selectEventCursor;

  QCursor addEventCursor;

  QCursor drawLineCursor;
  
  bool showLabels;

  bool showCalibrationScale;


  float downSampling;

  bool zoomed;

  /***Boolean indicating that the view has been zoomed for the no zoom state.*/
  bool firstZoom;
  
  /***Boolean indicating that the view has been zoomed and a reset has been asked.
  * If so the original down sampling has to be restore.*/
  bool doubleClick;

  float initialDownSampling;

  float zoomFactor;

  /***Boolean indicating that the view has been zoomed to the maximum.*/  
  bool maxZoomReached;

  /***Boolean indicating that the view has been zoomed out.*/  
  bool zoomOut;
  
  QRect initialWindow;

  QRect previousWindow;

  int traceWidth;

  int initialXGroupSpace;

  int initialXshift;

  int initialTraceWidth;

  QMap<int, QValueList<int> > selectedClusters;

  struct ClusterData{
    Array<dataType> data;
    bool ready;

    ClusterData(Array<dataType> d,bool status){
      data = d;
      ready = status;
    };
    ClusterData(){
     ready = false; 
    };
    void setStatus(bool status){ready = status;};
    void setData(Array<dataType>& d){data = d;};
    bool status(){return ready;};
    Array<dataType>& getData(){return data;};
    
    ~ClusterData(){};
  };
  
  QDict<ClusterData> clustersData;

  QDict<ClustersProvider> clusterProviders;

  QDict<ItemColors> providerItemColors;

  QValueList<QString> clustersOrder;
    
  QValueList<int> rasterOrdinates;

  QValueList<int> rasterAbscisses;

  QMap<int, QValueList<int> >* groupClusterFiles;

  /*Map between the channel ids and the spike group ids. */
  QMap<int,int>* channelClusterFiles;

  /*Number of samples before the sample of the peak are contained in the waveform of a spike.*/
  int nbSamplesBefore;

  /*Number of samples after the sample of the peak are contained in the waveform of a spike.*/
  int nbSamplesAfter;

  /*True if the view is currently been printed, false otherwise.**/
  bool printState;
  
  QMap<QString, QValueList<int> > selectedEvents;

  QPair<QString,long> nextClusterProvider;

  QPair<QString,long> previousClusterProvider;

  QString clusterProviderToSkip;
  
  long startTimeInRecordingUnits;
  
  long previousStartTimeInRecordingUnits;

  bool spikeBrowsing;
  
  QDict<EventData> eventsData;

  QDict<EventsProvider> eventProviders;

  QPair<QString,long> nextEventProvider;

  QPair<QString,long> previousEventProvider;

  QString eventProviderToSkip;

  long long recordingLength;

  QPair<QString,int> selectedEvent;

  int previousDragAbscissa;

  int lastClickAbscissa;

  QValueList<int> selectedEventPosition;

  bool startEventDragging;

  QValueList<QString> eventProvidersToUpdate;

  int newEventPosition;

  QString eventDescriptionToCreate;

  QString eventProvider;

  bool eventBeingModified;

  QMap<QString, QValueList<int> > clustersNotUsedForBrowsing;

  QMap<QString, QValueList<int> > eventsNotUsedForBrowsing;
  
  bool retrieveClusterData;
  
  /*List of skipped channels.*/
  QValueList<int> skippedChannels;
  
  /*List of positions for the current lines to be drawn.*/
  QValueList<int> linePositions;
  
 //***************Functions************
 
 void updateWindow();

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

 void drawTraces(QPainter& painter);

 void drawTraces(QValueList<int> channels,bool highlight); 

 void drawTrace(QPainter& painter,int limit,int basePosition,int X,int channelId,int nbSamplesToDraw,bool mouseMoveEvent = false);
   
 void drawChannelIdsAndGain(QPainter& painter);

 void computeChannelDisplayGain();

 void computeChannelDisplayGain(const QValueList<int>& selectedChannels);

 void drawCalibrationScale(QPainter& painter);

 void correctZoom(QRect& r);


 void drawEvent(QString providerName,int selectedEventId,dataType selectedEventIndex,bool highlight);
 
 void drawTimeLine(int x,bool initialLine,bool eraseLine = false);
 
  void scaleBackgroundImage();

};

#endif

---