src/tracewidget.h

/***************************************************************************
                          tracewidget.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 TRACEWIDGET_H
#define TRACEWIDGET_H

// include files for QT
#include <qwidget.h>
#include <qvbox.h>
#include <qspinbox.h>
#include <qvalidator.h>
#include <qlineedit.h>
#include <qlabel.h>
#include <qscrollbar.h>
#include <qhbox.h>
#include <qpainter.h>
#include <qstyle.h> 

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

//include files for the application
#include "traceview.h"

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

class TracesProvider;
class BaseFrame;
class ChannelColors;

class TraceWidget : public QVBox  {
   Q_OBJECT
   
public:
   TraceWidget(long startTime,long duration,bool greyScale,TracesProvider& tracesProvider,bool multiColumns,bool verticalLines,
             bool raster,bool waveforms,bool labelsDisplay,QValueList<int>& channelsToDisplay,int gain,int acquisitionGain,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 = 0, int maxSize = 4000, int windowTopLeft = -500,
             int windowBottomRight = 1001, int border = 0);

     ~TraceWidget();
 
        
 inline long timeFrameWidth() const {
   return timeWindow;
 };

 inline long timeFrameStart() const {
   return startTime;
 };
 
 inline void installEventFilter(const QObject* filterObject){
  QObject::installEventFilter(filterObject);
  view.installEventFilter(filterObject);
 };
  
public slots:

  void changeBackgroundColor(QColor color);

  void setGreyScale(bool grey);
  
  void moveToTime(long time);

  inline void setMultiColumns(bool multiple){view.setMultiColumns(multiple);};

  inline void setClusterVerticalLines(bool lines){view.setClusterVerticalLines(lines);};

  inline void setClusterRaster(bool raster){
   view.setClusterRaster(raster);
  };

  inline void setClusterWaveforms(bool waveforms){view.setClusterWaveforms(waveforms);};

  inline void slotChannelsSelected(const QValueList<int>& selectedIds) {emit channelsSelected(selectedIds);};

  virtual inline void setMode(BaseFrame::Mode selectedMode,bool active){view.setMode(selectedMode,active);};

  inline void showChannels(const QValueList<int>& channelsToShow){
   view.showChannels(channelsToShow); 
  };

  inline void showClusters(QString name,QValueList<int>& clustersToShow){
   view.showClusters(name,clustersToShow);
  };

  inline void showEvents(QString name,QValueList<int>& eventsToShow){
   view.showEvents(name,eventsToShow);
  };

  inline void channelColorUpdate(int channelId,bool active){view.channelColorUpdate(channelId,active);};

  inline void  clusterColorUpdate(QString name,int clusterId,bool active){view.clusterColorUpdate(name,clusterId,active);};
  
  inline void  eventColorUpdate(QString name,int eventId,bool active){view.eventColorUpdate(name,eventId,active);};

  inline void groupColorUpdate(int groupId,bool active){view.groupColorUpdate(groupId,active);};
  
  inline void increaseAllChannelsAmplitude(){view.increaseAllAmplitude();};

  inline void decreaseAllChannelsAmplitude(){view.decreaseAllAmplitude();};

  inline void increaseSelectedChannelsAmplitude(const QValueList<int>& channelIds){view.increaseSelectedChannelsAmplitude(channelIds);};

  inline void decreaseSelectedChannelsAmplitude(const QValueList<int>& channelIds){view.decreaseSelectedChannelsAmplitude(channelIds);};

  inline void setGains(int gain,int acquisitionGain){view.setGains(gain,acquisitionGain);};

  inline void updateDrawing(){view.updateDrawing();};

  inline void updateContents(){view.update();};

  inline void groupsModified(bool active){view.groupsModified(active);};

  inline void selectChannels(const QValueList<int>& selectedIds){view.selectChannels(selectedIds);};

  inline void resetOffsets(const QMap<int,int>& selectedChannelDefaultOffsets){view.resetOffsets(selectedChannelDefaultOffsets);};

  void resetGains(const QValueList<int>& selectedChannels){view.resetGains(selectedChannels);};

  inline void drawTraces(){view.displayTimeFrame(startTime,timeWindow);};

  inline void reset(){view.reset();};

  inline void showLabels(bool show){view.showHideLabels(show);};

  void slotSetStartAndDuration(long time,long duration);

  inline void showCalibration(bool show,bool active){view.showCalibration(show,active);};

  void samplingRateModified(long long length);

  inline 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){
   view.addClusterProvider(clustersProvider,name,clusterColors,active,clustersToShow,displayGroupsClusterFile,
                          channelsSpikeGroups,nbSamplesBefore,nbSamplesAfter,clustersToSkip);
  };
  
  inline void removeClusterProvider(QString name,bool active){
   view.removeClusterProvider(name,active);  
  };

  inline void addEventProvider(EventsProvider* eventsProvider,QString name,ItemColors* eventColors,bool active,
                                 QValueList<int>& eventsToShow,const QValueList<int>& eventsToNotBrowse){
   view.addEventProvider(eventsProvider,name,eventColors,active,eventsToShow,eventsToNotBrowse);
  };


  inline void removeEventProvider(QString name,bool active){
   view.removeEventProvider(name,active);
  };

  inline void print(QPainter& printPainter,QPaintDeviceMetrics& metrics,QString filePath,bool whiteBackground){

   QRect textRec = QRect(printPainter.viewport().left() + 5 ,printPainter.viewport().height() - 20,printPainter.viewport().width() - 5,20);
   QFont f("Helvetica",8);
   printPainter.setFont(f);
   printPainter.setPen(black); 
   printPainter.drawText(textRec,Qt::AlignAuto | Qt::AlignVCenter,
    QString("File: %1     Start time: %2 min %3 s %4 ms, Duration: %5 ms").arg(filePath).arg(startMinute->value()).arg(startSecond->value()).arg(startMilisecond->value()).arg(duration->displayText()));

   //Modify the viewport so the view will not draw on the legend
   QRect newViewport = QRect(printPainter.viewport().left(),printPainter.viewport().top(),printPainter.viewport().width(),printPainter.viewport().height());
   newViewport.setBottom(printPainter.viewport().bottom() - 20);   
   printPainter.setViewport(newViewport);
   view.print(printPainter,metrics,whiteBackground);
   printPainter.resetXForm();
  };

  inline void showNextCluster(){view.showNextCluster();};

  inline void showPreviousCluster(){view.showPreviousCluster();};

  inline void showNextEvent(){view.showNextEvent();};

  inline void showPreviousEvent(){view.showPreviousEvent();};

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

  inline void slotEventRemoved(QString providerName,int selectedEventId,double time){
   emit eventRemoved(providerName,selectedEventId,time); 
  };
  
  inline void updateEvents(bool active,QString providerName,double time,double newTime){
   long eventTime = static_cast<long>(floor(0.5 + time));
   long newEventTime = static_cast<long>(floor(0.5 + newTime));   
   if((eventTime >= startTime  && eventTime <= (startTime + timeWindow)) ||
      (newEventTime >= startTime  && newEventTime <= (startTime + timeWindow))) view.updateEvents(providerName,active);
  };

  inline void removeEvent(){view.removeEvent();};

  inline void updateEvents(bool active,QString providerName,double time){
   long eventTime = static_cast<long>(floor(0.5 + time));
   if((eventTime >= startTime  && eventTime <= (startTime + timeWindow))) view.updateEvents(providerName,active);
  };

  inline void eventToAddProperties(QString providerName,QString eventDescription){
    view.eventToAddProperties(providerName,eventDescription);
  };

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

  inline void updateEvents(QString providerName,QValueList<int>& eventsToShow,bool active){
    view.updateEvents(providerName,eventsToShow,active); 
  };

  inline void updateWaveformInformation(int nbSamplesBefore, int nbSamplesAfter,bool active){
   view.updateWaveformInformation(nbSamplesBefore,nbSamplesAfter,active);
  };

  inline void updateClusterData(bool active){view.updateClusterData(active);};

  inline void updateNoneBrowsingEventList(QString providerName,const QValueList<int>& eventsToNotBrowse){
   view.updateNoneBrowsingEventList(providerName,eventsToNotBrowse);
  };

  inline void updateNoneBrowsingClusterList(QString providerName,const QValueList<int>& clustersToNotBrowse){
   view.updateNoneBrowsingClusterList(providerName,clustersToNotBrowse);
  };

  virtual inline void dockBeingClosed(){emit parentDockBeingClosed(this);};
  
  inline void updateClusters(QString name,QValueList<int>& clustersToShow,ItemColors* clusterColors,bool active){
   view.updateClusters(name,clustersToShow,clusterColors,active);
  };
  
  inline void updateSkipStatus(const QValueList<int>& skippedChannels){view.skipStatusChanged(skippedChannels);};
  
  inline void increaseRasterHeight(){view.increaseRatio();};
  
  inline void decreaseRasterHeight(){view.decreaseRatio();};
  
  inline int getRasterHeight(){return view.getRasterHeight();};
  
  inline void slotEventsAvailable(QDict<EventData>& eventsData,QMap<QString, QValueList<int> >& selectedEvents,QDict<ItemColors>& providerItemColors,QObject* initiator,double samplingRate) {
   emit eventsAvailable(eventsData,selectedEvents,providerItemColors,initiator,samplingRate);
  };
  
  inline void getCurrentEventInformation(long startTime,long endTime,QObject* initiator){view.getCurrentEventInformation(startTime,endTime,initiator);};

  inline void traceBackgroundImageUpdate(QImage traceBackgroundImage,bool active){
     view.traceBackgroundImageUpdate(traceBackgroundImage,active);
  };

signals:
  void channelsSelected(const QValueList<int>& selectedIds);
  
  void updateStartAndDuration(long startTime,long timeWindow);

  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 parentDockBeingClosed(QWidget* viewWidget);
  
  void eventsAvailable(QDict<EventData>& eventsData,QMap<QString, QValueList<int> >& selectedEvents,QDict<ItemColors>& providerItemColors,QObject* initiator,double samplingRate);
   
protected:

  void keyPressEvent(QKeyEvent* event);
    
private:
  //Functions

  void initSelectionWidgets();

private slots:
  void slotStartMinuteTimeUpdated(int start);

  void slotStartSecondTimeUpdated(int start);

  void slotStartMilisecondTimeUpdated(int start);

  void slotDurationUpdated();

  void slotScrollBarUpdated();
  
private:  
  long timeWindow;

  TraceView view;
  
  long startTime;

  QSpinBox* startMinute;

  QSpinBox* startSecond;

  QSpinBox* startMilisecond;

  QLineEdit* duration;

  static const QString INITIAL_TRACES_TIME_WINDOW;

  QIntValidator validator;

  QLabel* durationLabel;
  QLabel* startLabel;

  bool isInit;

  QScrollBar* scrollBar;

  long long recordingLength;
  
  long lineStep;

  long pageStep;

  QHBox* selectionWidgets;

  int minutePart;

  int secondPart;

  int milisecondPart;
      
  bool updateView;  
    

  void correctStartTime();
  
};


#endif

---