src/neuroscopedoc.h

/***************************************************************************
                          neuroscopedoc.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 NEUROSCOPEDOC_H
#define NEUROSCOPEDOC_H

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

// include files for QT
#include <qobject.h>
#include <qstring.h>
#include <qptrlist.h>
#include <qpair.h>

// include files for KDE
#include <kurl.h>

//include files for the application
#include "channelpalette.h"
#include "dataprovider.h"
#include "eventsprovider.h"


// forward declaration of the Neuroscope classes
class NeuroscopeView;
class NeuroscopeApp;
class ChannelColors;
class TracesProvider;
class NeuroscopeXmlReader;
class ItemColors;
class ItemPalette;

class NeuroscopeDoc : public QObject
{
  Q_OBJECT
  
 private: 
    KURL docUrl;

    KURL sessionUrl;
    
    KURL parameterUrl;
    
    ChannelPalette& displayChannelPalette;

    ChannelPalette& spikeChannelPalette;

    int channelNb;

    double samplingRate;

    int initialOffset;

    int gain;

    int acquisitionGain;

    float screenGain;

    int voltageRange;

    int amplification;

    int resolution;

    int resolutionDefault;

    int channelNbDefault;

    double datSamplingRateDefault;

    double eegSamplingRateDefault;

    double videoSamplingRateDefault;

    int initialOffsetDefault;

    int gainDefault;

    int acquisitionGainDefault;
    
    float screenGainDefault;

    int voltageRangeDefault;

    int amplificationDefault;

    QMap<int,int> displayChannelsGroups;

    QMap<int, QValueList<int> > displayGroupsChannels;

    QMap<int,int> channelsSpikeGroups;

    QMap<int, QValueList<int> > spikeGroupsChannels;

    bool isCommandLineProperties;

    ChannelColors* channelColorList;

    /*Map given the of channels default offsets.*/
    QMap<int,int> channelDefaultOffsets;
    
    TracesProvider* tracesProvider;

    QWidget* parent;    

    QString baseName;

    double datSamplingRate;

    double eegSamplingRate;

    double videoSamplingRate;
    
    int nbSamples;

    int peakSampleIndex;

    int nbSamplesDefault;

    int peakSampleIndexDefault;

    float waveformLength;
    
    float indexLength;
    
    float waveformLengthDefault;
    
    float indexLengthDefault;
        
    QDict<DataProvider> providers;

    QMap<QString,KURL> providerUrls;

    QString lastLoadedProvider;
        
    QDict<ItemColors> providerItemColors;

    QMap<QString,double> extensionSamplingRates;

    QMap<int, QValueList<int> > displayGroupsClusterFile;

    QString extension;

    /*The value to use as the length for the event descriptions in the event palette for the the last loaded event provider.*/
    int lastEventProviderGridX;

    int eventPosition;

    int clusterPosition;

    QString undoRedoProviderName;

    int undoRedoEventId;

    double modifiedEventTime;

    double undoRedoEventTime;

    bool newEventDescriptionCreated;

    QPair<QString,QString> removedDescription;    

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

    int videoWidth;
    int videoHeight;
    QString backgroundImage;
    
    QString traceBackgroundImage;
    
    int rotation;
    int flip;
    
    QImage transformedBackground;
    
    bool drawPositionsOnBackground;
    
    bool drawPositionsOnBackgroundDefault;
    
    bool positionFileOpenOnce;
    
    QString positionFileExtension;
    
    QMap<int,bool> skipStatus;
    
    double upsamplingRate;

    //Functions

    void loadSession(NeuroscopeXmlReader reader);

    void loadDocumentInformation(NeuroscopeXmlReader reader);

    void computeClusterFilesMapping();

    QImage transformBackgroundImage(bool useWhiteBackground = false);
        
  public:

    enum OpenSaveCreateReturnMessage {OK=0,OPEN_ERROR=1,DOWNLOAD_ERROR=3,INCORRECT_FILE=4,SAVE_ERROR=5,
                               UPLOAD_ERROR=6,INCORRECT_CONTENT=7,CREATION_ERROR=8,PARSE_ERROR=9,MISSING_FILE=10,
                               ALREADY_OPENED=11,NOT_WRITABLE=12};
      
    NeuroscopeDoc(QWidget* parent,ChannelPalette& displayChannelPalette,ChannelPalette& spikeChannelPalette,int channelNbDefault,double datSamplingRateDefault,
                  double eegSamplingRateDefault, int initialOffset,int voltageRangeDefault,int amplificationDefault,float screenGainDefault,int resolutionDefault,
                  int eventPosition,int clusterPosition,int nbSamples, int peakSampleIndex,double videoSamplingRate, int width, int height, QString backgroundImage, QString traceBackgroundImage,
                    int rotation,int flip,bool positionsBackground);
    ~NeuroscopeDoc();

    void addView(NeuroscopeView* view);
    
    void removeView(NeuroscopeView* view);
    
    void closeDocument();
    
    int openDocument(const KURL& url);

    OpenSaveCreateReturnMessage saveSession();

    int saveEventFiles();
    
    inline OpenSaveCreateReturnMessage saveSession(KURL newSessionUrl){
     sessionUrl = newSessionUrl;
     return saveSession();  
    };
    
    OpenSaveCreateReturnMessage createEventFile(KURL eventUrl,NeuroscopeView*activeView);
    
    const KURL& url() const;
    
    void setURL(const KURL& url);

    void singleChannelColorUpdate(int channelId,NeuroscopeView* activeView);

    void clusterColorUpdate(QString providerName,int clusterId,NeuroscopeView* activeView);
    
    void eventColorUpdate(QString providerName,int eventId,NeuroscopeView* activeView);

    void channelGroupColorUpdate(int groupId,NeuroscopeView* activeView);
    
    //void channelsColorUpdate(QValueList<int>selectedChannels,NeuroscopeView& view);

    void groupsModified(NeuroscopeView* activeView);
       
   void setBackgroundColor(QColor backgroundColor);
   
   void setTraceBackgroundImage(QString traceBackgroundImagePath);   

   void setInitialOffset(int offset);

   void setGains(int voltageRange,int amplification,float screenGain);

   void setResolution(int resolution);

   void setSamplingRate(double rate);

   void setAcquisitionSystemSamplingRate(double rate);

   void setChannelNb(int nb);
           
   inline int getInitialOffset()const{return initialOffset;};

   inline int getAcquisitionGain()const{return acquisitionGain;};

   inline int getGain()const{return gain;};

   inline int getVoltageRange()const{return voltageRange;};

   inline int getAmplification()const{return amplification;};

   inline float getScreenGain()const{return screenGain;};

   inline int getResolution()const{return resolution;};

   inline double getSamplingRate()const{return samplingRate;};


   inline double getAcquisitionSystemSamplingRate()const{return datSamplingRate;};

   inline bool getPositionsBackground()const{return drawPositionsOnBackground;};
    

   inline void setDefaultGains(int voltageRangeDefault,int amplificationDefault,float screenGainDefault){
    acquisitionGainDefault = static_cast<int>(0.5 +
                       static_cast<float>(pow(static_cast<double>(2),static_cast<double>(resolutionDefault))
                       / static_cast<float>(voltageRangeDefault * 1000))
                       * amplificationDefault);

    gainDefault = static_cast<int>(0.5 + screenGainDefault * acquisitionGainDefault);
    this->voltageRangeDefault = voltageRangeDefault;
    this->amplificationDefault = amplificationDefault;
    this->screenGainDefault = screenGainDefault;
   };

   inline void setVoltageRange(int range){
    voltageRange = range;
    acquisitionGain = static_cast<int>(0.5 +
                       static_cast<float>(pow(static_cast<double>(2),static_cast<double>(resolution))
                       / static_cast<float>(voltageRange * 1000))
                       * amplification);

    gain = static_cast<int>(0.5 + screenGain * acquisitionGain);
   };

   inline void setAmplification(int amplification){
    this->amplification = amplification;
    acquisitionGain = static_cast<int>(0.5 +
                       static_cast<float>(pow(static_cast<double>(2),static_cast<double>(resolution))
                       / static_cast<float>(voltageRange * 1000))
                       * amplification);

    gain = static_cast<int>(0.5 + screenGain * acquisitionGain);
   };

   inline void setScreenGain(float gain){
    screenGain = gain;
    acquisitionGain = static_cast<int>(0.5 +
                       static_cast<float>(pow(static_cast<double>(2),static_cast<double>(resolution))
                       / static_cast<float>(voltageRange * 1000))
                       * amplification);

    gain = static_cast<int>(0.5 + screenGain * acquisitionGain);
   };
   
   inline void setDefaultInitialOffset(int offset){initialOffsetDefault = offset;};

   inline void setDefaultResolution(int resolution){resolutionDefault = resolution;};

   inline void setDefaultEegSamplingRate(double rate){eegSamplingRateDefault = rate;};

   inline void setDefaultDatSamplingRate(double rate){datSamplingRateDefault = rate;};

   inline void setDefaultChannelNb(int nb){channelNbDefault = nb;};
   
   inline void setDefaultTraceBackgroundImage(QString traceBackgroundImagePath){
          traceBackgroundImageDefault = traceBackgroundImagePath;
     }
 
   inline void propertiesFromCommandLine(){isCommandLineProperties = true;};

   inline ChannelColors* channelColors() const {return channelColorList;} ;

   inline TracesProvider& tracesDataProvider() const {return *tracesProvider;};

   inline QMap<int,int>* getDisplayChannelsGroups() {return &displayChannelsGroups;};

   inline QMap<int, QValueList<int> >* getDisplayGroupsChannels() {return &displayGroupsChannels;};   

   inline QMap<int,int>* getChannelsSpikeGroups() {return &channelsSpikeGroups;};

   inline QMap<int, QValueList<int> >* getSpikeGroupsChannels() {return &spikeGroupsChannels;};

   void selectAllChannels(NeuroscopeView& activeView,bool editMode);

   void deselectAllChannels(NeuroscopeView& activeView,bool editMode);

   void synchronize();

   inline void updateFileProperties(int channelNb,double SR,int resolution,int offset,int voltageRange,int amplification,
                                    float screenGain,int newNbSamples,int newPeakSampleIndex,double videoSamplingRate,
                                    int width, int height, QString backgroundImage, QString traceBackgroundImage,int rotation,int flip,double acquisitionSystemSamplingRate,
                                    bool positionsBackground){
    this->channelNb = channelNb;
    if(extension != "dat") samplingRate = SR;
    else samplingRate = acquisitionSystemSamplingRate;
    datSamplingRate = acquisitionSystemSamplingRate;
    this->voltageRange = voltageRange;
    this->amplification = amplification;
    this->screenGain = screenGain;
    this->resolution = resolution;
    initialOffset = offset;
    nbSamples = newNbSamples;
    peakSampleIndex = newPeakSampleIndex;
    this->videoSamplingRate = videoSamplingRate;
    videoWidth = width;
    videoHeight = height;
    this->backgroundImage = backgroundImage;    
    this->traceBackgroundImage = traceBackgroundImage;
    this->rotation = rotation;
    this->flip = flip;
    drawPositionsOnBackground = positionsBackground;

     acquisitionGain = static_cast<int>(0.5 +
                    static_cast<float>(pow(static_cast<double>(2),static_cast<double>(resolution))
                    / static_cast<float>(voltageRange * 1000))
                    * amplification);

    gain = static_cast<int>(0.5 + screenGain * acquisitionGain);
   };

   inline bool isCurrentFileAdatFile(){
    if(extension == "dat") return true;
    else return false;
   };
   
   inline QString documentBaseName(){return baseName;};

   QString sessionPath() const;

   long long recordingLength();

   bool isADocumentToClose();

   void setNoneEditMode(NeuroscopeView* activeView);

    bool canCloseDocument(NeuroscopeApp* mainWindow,QString callingMethod);

    void showCalibration(bool show,NeuroscopeView* activeView);

    inline QString lastLoadedProviderName(){return lastLoadedProvider;};
    
    inline ItemColors* providerColorList(QString fileName){return providerItemColors[fileName];};

    OpenSaveCreateReturnMessage loadClusterFile(KURL clusterUrl,NeuroscopeView* activeView);

    OpenSaveCreateReturnMessage loadClusterFile(KURL clusterUrl,QMap<EventDescription,QColor>& itemColors,QDateTime lastModified,bool firstFile);


    OpenSaveCreateReturnMessage loadPositionFile(KURL url,NeuroscopeView*activeView);

    OpenSaveCreateReturnMessage loadPositionFile(QString filePath);
    
    void removeClusterFile(QString providerName,NeuroscopeView* activeView);

    OpenSaveCreateReturnMessage loadEventFile(KURL eventUrl,NeuroscopeView* activeView);

    OpenSaveCreateReturnMessage loadEventFile(KURL eventUrl,QMap<EventDescription,QColor>& itemColors,QDateTime lastModified,bool firstFile);
    
    void removeEventFile(QString providerName,NeuroscopeView* activeView,bool lastFile);

    void setProviders(NeuroscopeView* activeView);

    void showAllClustersExcept(ItemPalette* clusterPalette,NeuroscopeView* activeView,QValueList<int> clustersToHide);

    void deselectAllClusters(ItemPalette* clusterPalette,NeuroscopeView* activeView);


    void showAllEvents(ItemPalette* eventPalette,NeuroscopeView* activeView);

    void deselectAllEvents(ItemPalette* eventPalette,NeuroscopeView* activeView);

    inline int getLastEventProviderGridX() const {return lastEventProviderGridX;};

    void setEventPosition(int position);

    void setClusterPosition(int position);
    
    void eventModified(QString providerName,int selectedEventId,double time,double newTime,NeuroscopeView* activeView);

    void eventRemoved(QString providerName,int selectedEventId,double time,NeuroscopeView* activeView);

    void undo(NeuroscopeView* activeView);

    void redo(NeuroscopeView* activeView);

    void eventAdded(QString providerName,QString addedEventDescription,double time,NeuroscopeView* activeView);

    
    QValueList<EventDescription> eventIds(QString providerName);


    void setWaveformInformation(int nb,int index,NeuroscopeView* activeView);


    inline void setDefaultWaveformInformation(int nb,int index){
     nbSamplesDefault = nb;
     peakSampleIndexDefault = index;      
    };

    inline int getNbSamples()const{return nbSamples;};

    inline int getPeakIndex()const{return peakSampleIndex;};


   void setPositionInformation(double videoSamplingRate, int width, int height, QString backgroundImage,
                    int rotation,int flip,bool positionsBackground,NeuroscopeView* activeView);

   void setDefaultPositionInformation(double videoSamplingRate, int width, int height, QString backgroundImage,int rotation,int flip,bool positionsBackground);
   
   inline double getVideoSamplingRate()const{return videoSamplingRate;};

   inline int getChannelNb()const{return channelNb;};

   inline int getWidth()const{return videoWidth;};

   inline int getHeight()const{return videoHeight;};

   inline QString getBackgroundImage()const{return backgroundImage;};

   inline QString getTraceBackgroundImage()const{return traceBackgroundImage;};

   inline int getRotation()const{return rotation;};

   inline int getFlip()const{return flip;};

   void removePositionFile(NeuroscopeView* activeView);

   void addPositionView(NeuroscopeView* activeView,QColor backgroundColor);
    
    class CloseDocumentEvent;
    friend class CloseDocumentEvent;

    inline CloseDocumentEvent* getCloseDocumentEvent(QString origin){
      return new CloseDocumentEvent(origin);
    };

    class CloseDocumentEvent : public QCustomEvent{
     //Only the method getCloseDocumentEvent of NeuroscopeDoc has access to the private part of CloseDocumentEvent,
     //the constructor of CloseDocumentEvent being private, only this method con create a new CloseDocumentEvent
     friend CloseDocumentEvent* NeuroscopeDoc::getCloseDocumentEvent(QString origin);

    public:
      inline QString methodOfOrigin(){return origin;};
      inline ~CloseDocumentEvent(){};

    private:
      CloseDocumentEvent(QString origin):QCustomEvent(QEvent::User + 200),origin(origin){};

      QString origin;
    };

    
   inline QImage getWhiteTrajectoryBackground(){
    if(!drawPositionsOnBackground) return QImage();
    return transformBackgroundImage(true); 
   };
    
   
   void updateSkippedChannelColors(bool whiteBackground,QColor backgroundColor);
   
   void updateSkipStatus();
   
   /*Sets the current channel offsets has the default offsets.
   * @param activeView the view containing the offsets to be used as default.   
   */
   void setDefaultOffsets(NeuroscopeView* activeView);
   
   void resetDefaultOffsets();
   
   inline  const QMap<int,int>& getChannelDefaultOffsets()const{return channelDefaultOffsets;};
   
  public slots:

   void slotNewEventDescriptionCreated(QString providerName,QMap<int,int> oldNewEventIds,QMap<int,int> newOldEventIds,QString eventDescriptionAdded);  

   void slotEventDescriptionRemoved(QString providerName,QMap<int,int> oldNewEventIds,QMap<int,int> newOldEventIds,int eventIdToRemove,QString eventDescriptionToRemove);
   
  signals:
    void noSession(QMap<int,int>& channelDefaultOffsets,QMap<int,bool>& skipStatus);

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

  public: 
    QPtrList<NeuroscopeView>* viewList;

    
};

#endif // NEUROSCOPEDOC_H

---