remoteControlPlaybackInterface.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/



#pragma once

#include "remoteControlDomainInterface.h"
#include "virtualConstructor.h"
#include "absoluteTime.h"

#include <vlutil/vlString.h>

class DtEntityIdentifier;
class DtLgrResponsePdu;
class DtFilename;
class DtOutputStream;

namespace MAKLogger
{

   class DT_DLL_LGRSIM DtRemoteControlPlaybackInterface : public DtRemoteControlDomainInterface
   {
   public:

      DT_VIRTUAL_CTR(DtRemoteControlPlaybackInterface,(DtRemoteControlInterface*))

      
      virtual ~DtRemoteControlPlaybackInterface();

   private:
      DtRemoteControlPlaybackInterface(const DtRemoteControlPlaybackInterface&);
      DtRemoteControlPlaybackInterface& operator=(const DtRemoteControlPlaybackInterface&);

   public:


      virtual const DtFilename& fileName() const;
      virtual void resetFileName(const DtFilename& name);


      virtual const DtAbsoluteTime& firstTime() const;
      virtual void resetFirstTime(const DtAbsoluteTime& time);


      virtual const DtAbsoluteTime& lastTime() const;
      virtual void resetLastTime(const DtAbsoluteTime& time);


      virtual const DtAbsoluteTime& startTime() const;
      virtual void resetStartTime(const DtAbsoluteTime& time);


      virtual const DtAbsoluteTime& stopTime() const;
      virtual void resetStopTime(const DtAbsoluteTime& time);


      virtual double playbackSpeed() const;
      virtual void resetPlaybackSpeed(double speed);


      virtual bool isFileOpened() const;
      virtual void resetIsFileOpened(bool isOpened);


      virtual bool isPlaying() const;
      virtual void resetIsPlaying(bool playing);


      virtual bool isPaused() const;
      virtual void resetIsPaused(bool paused);


      virtual bool isLoopAtEnd() const;
      virtual void resetIsLoopAtEnd(bool loopAtEnd);


      virtual bool isPlayOnLoad() const;
      virtual void resetIsPlayOnLoad(bool playOnLoad);


      virtual bool isPlaySkipping() const;
      virtual void resetIsPlaySkipping(bool skipping);



      virtual DtSequenceNumber openFile(const DtFilename& filename, bool constructFilePathAndName,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber closeFile(
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber play(
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber pause(
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber unPause(
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber stop(
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber setPlaybackSpeed(double speed, bool skipping,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber jumpToStart(
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber jumpToStop(
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber jumpToTime(const DtAbsoluteTime& time,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber skipTimeForward(const DtRelativeTime& time,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber skipTimeBackward(const DtRelativeTime& time,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber setStartStopTimes(const DtAbsoluteTime& startTime,
         const DtAbsoluteTime& stopTime,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber setLoopAtEnd(bool enable,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber setPlayOnLoad(bool enable,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());

      virtual DtSequenceNumber requestFileList(bool listDirs,
         const DtEntityIdentifier& destination=DtRemoteControlInterface::wildcardAddress());


      virtual void processResponse(const DtLgrResponsePdu& responsePdu);

      virtual void clearReceivedResponseCounts();

   public:

      static const char* commandToString(int command);

   protected:



      virtual void fileOpened(const DtEntityIdentifier& source, const DtString& fileName,
         const DtAbsoluteTime& firstTime, const DtAbsoluteTime& lastTime);

      virtual void fileOpened(const DtString& fileName,
         const DtAbsoluteTime& firstTime, const DtAbsoluteTime& lastTime);

      virtual void fileClosed(const DtEntityIdentifier& source);

      virtual void fileClosed();

      virtual void fileDoesNotExist(const DtEntityIdentifier& source, const DtString& filename);

      virtual void fileIncomplete(const DtEntityIdentifier& source, const DtString& filename, bool isIncomplete);

      virtual void fileInvalid(const DtEntityIdentifier& source, const DtString& filename, const DtString& reason);

      virtual void fileChanged(const DtEntityIdentifier& source);

      virtual void fileChanged();

      virtual void fileSaved(const DtEntityIdentifier& source);

      virtual void fileSaved();

      virtual void fileFormatCurrent(const DtEntityIdentifier& source, bool current);

      virtual void fileFormatCurrent(bool current);

      virtual void playbackChanged(const DtEntityIdentifier& source, bool currentlyPlaying);

      virtual void playbackChanged(bool currentlyPlaying);

      virtual void restarted(const DtEntityIdentifier& source);

      virtual void restarted();

      virtual void jumpTimeChanged(const DtEntityIdentifier& source, const DtAbsoluteTime& jumpTime);

      virtual void jumpTimeChanged(const DtAbsoluteTime& jumpTime);

      virtual void loopAtEndChanged(const DtEntityIdentifier& source, bool enabled);

      virtual void loopAtEndChanged(bool enabled);

      virtual void playOnLoadChanged(const DtEntityIdentifier& source, bool enabled);

      virtual void playOnLoadChanged(bool enabled);

      virtual void skippingPlaybackChanged(bool enabled);

      virtual void skippingPlaybackChanged(const DtEntityIdentifier& source, bool enabled );

      virtual void playbackSpeedChanged(const DtEntityIdentifier& source, double speed);

      virtual void playbackSpeedChanged(double speed);

      virtual void pausedChanged(const DtEntityIdentifier& source, bool paused);

      virtual void pausedChanged(bool paused);

      virtual void startStopTimesChanged(const DtEntityIdentifier& source, const DtAbsoluteTime& startTime,
         const DtAbsoluteTime& stopTime );

      virtual void startStopTimesChanged(const DtAbsoluteTime& startTime,
         const DtAbsoluteTime& stopTime );

      virtual void firstLastTimesChanged(const DtEntityIdentifier& source, const DtAbsoluteTime& firstTime,
         const DtAbsoluteTime& lastTime );

      virtual void firstLastTimesChanged(const DtAbsoluteTime& firstTime,
         const DtAbsoluteTime& lastTime );

      virtual void fileList(const DtEntityIdentifier& source,
         bool listIsDirs, const std::vector<DtString>& loggerFiles);

      virtual void fileList(DtOutputStream& outputStream, bool listIsDirs, const std::vector<DtString>& loggerFiles);



      virtual void setFirstTime(const DtAbsoluteTime& time, bool initialValue=false);

      virtual void setLastTime(const DtAbsoluteTime& time, bool initialValue=false);

      virtual void setStartTime(const DtAbsoluteTime& time, bool initialValue=false);

      virtual void setStopTime(const DtAbsoluteTime& time, bool initialValue=false);
   protected:

      DtFilename myFileName;
      DtAbsoluteTime myFirstTime;
      DtAbsoluteTime myLastTime;
      DtAbsoluteTime myStartTime;
      DtAbsoluteTime myStopTime;
      DtAbsoluteTime myJumpTime;
      DtAbsoluteTime myPendingJumpTime;
      std::vector<DtString> myFileList;
      bool myFileListIsDirs;
      bool myIsFileOpened;
      bool myIsPlaying;
      bool myPendingIsPlaying;
      bool myFileFormatCurrent;
      bool myPendingFileFormatCurrent;
      bool myLoopAtEnd;
      bool myPendingLoopAtEnd;
      bool myPlayOnLoad;
      bool myPendingPlayOnLoad;
      bool myPlaybackSkipping;
      bool myPendingPlaybackSkipping;
      double mySpeed;
      double myPendingSpeed;
      bool myIsPaused;
      bool myPendingIsPaused;

      int myReceivedFileOpened;
      int myReceivedFileClosed;
      int myReceivedFileDoesNotExist;
      int myReceivedFileIncomplete;
      int myReceivedFileInvalid;
      int myReceivedFileChanged;
      int myReceivedFileSaved;
      int myReceivedFileFormatCurrent;
      int myReceivedPlaybackChanged;
      int myReceivedRestarted;
      int myReceivedLoopAtEndChanged;
      int myReceivedPlayOnLoadChanged;
      int myReceivedSkippingPlaybackChanged;
      int myReceivedPlaybackSpeedChanged;
      int myReceivedPausedChanged;
      int myReceivedStartStopTimesChanged;
      int myReceivedFirstLastTimesChanged;
      int myReceivedJumpTimeChanged;

   };
}