ciTrack.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004
// All rights reserved.
//
// This code is the intellectual property of JRM Enterprises, Inc.
// It may not be used or released as source or compiled binary form
// without the prior written consent of JRM Enterprises, Inc.
//
// Original Author:  Ken George
// Date:       Nov 2004
//
//
//

#if !defined(_ciTRACK_H_)
#define _ciTRACK_H_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <fstream>
#include "clXML.h"
#include "clXMLNode.h"

#include "ciApi.h"
#include <string.h>

class CI_API ciTrack  
{
public:     // enumerations

    enum PlayMode
    {
        pause = 0,
        forwardPlay = 1,
        reversePlay = 2,
        forwardPause = 3,
        reversePause = 4,
        beginPause = 5,
        endPause = 6,
    };

public:     // methods

    // getStartTime
    double getStartTime() { return m_startTime; }

    // setStartTime
    void setStartTime( double time ) { m_startTime = time; }

    // getEndTime
    double getEndTime() { return m_endTime; }

    // setEndTime
    void setEndTime( double time ) { 
        m_endTime = time;
    }

    // getIncrement
    double getIncrement() { return m_increment; }

    // setIncrement
    void setIncrement(double time) { m_increment = time; }

    // getFrameRate
    double getFrameRate() { return m_frameRate; }

    // setFrameRate
    void setFrameRate(double rate) { m_frameRate = rate; }

    // getSpeed
    double getSpeed() { return m_speed; }

    // setSpeed
    void setSpeed(double speed) { m_speed = speed; }

    // getPlayDirection
    PlayMode getPlayMode() { return m_playMode; }

    // setPlayDirection
    void setPlayMode( PlayMode flag ) { m_playMode = flag; }

    // getLoopContinuous
    bool getLoopContinuous() { return m_loopContinuous; }

    // setLoopContinuous
    void setLoopContinuous( bool flag ) { m_loopContinuous = flag; }

    // getSimTime
    double getSimTime() { return m_currentSimTime; }

    // setSimTime
    void setSimTime( double time ) { m_currentSimTime = time; }

    // getSaveFrameCount
    int getSaveFrameCount() { return m_saveFileCount; }

    // setSaveFrameCount
    void setSaveFrameCount( int framecount ) { m_saveFileCount = framecount; }

    //setLinkTOD
    void setLinkTOD(bool linkTOD){m_linkTOD = linkTOD;}
    //getLinkTOD
    bool getLinkTOD(){return m_linkTOD;}

    //setSaveImagesDuringPlayback
    void setSaveImagesDuringPlayback(bool flag) { m_saveImagesDuringPlayback = flag; }

    //getSaveImagesDuringPlayback
    bool getSaveImagesDuringPlayback() { return m_saveImagesDuringPlayback; }

    //setUseFrames
    void setUseFrames(bool flag) { m_useFrames = flag; }

    //setSaveImagesDuringPlayback
    bool getUseFrames() { return m_useFrames; }

    //setUseFrames
    void setSaveFileName(string saveFileName) { m_saveFileName = saveFileName; }

    //setSaveImagesDuringPlayback
    string getSaveFileName() { return m_saveFileName; }

    //setRecordingVelocity
    void setRecordingVelocity(double recordingVelocity) { m_recordingVelocity = recordingVelocity; }

    //getRecordingVelocity
    double getRecordingVelocity() { return m_recordingVelocity; }

    // archive
    bool archive(std::ofstream &outf);

    // serialize
    bool serialize(char *filepath);

    //
    // loadXML
    //
    // \par Description:
    // Load attributes from an XML node
    //
    // \param clXMLNode* trackNode
    // \return bool
    //
    bool loadXML(clXMLNode* trackNode);

    //
    // parseXML
    //
    // \par Description:
    // Parses an XML document for specific tags
    //
    // \param clXML xmlDocument
    // \return bool
    //
    bool parseXML(clXML& xmlDocument);

    //loadXMLNode
    bool loadXMLNode(std::string tag, char *nodeString);
    //loadXMLNode
    bool loadXMLNode(std::string tag, bool *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, int *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, double *nodeBool);

    //
    // saveXML
    //
    // \par Description:
    // Saves XML nodes to an XML document
    //
    // \param clXML* xmlDocument
    //
    void saveXML(clXML* xmlDocument);

    // operator =
    ciTrack operator = (ciTrack &obj);

protected:  // methods

public:     // construction/destruction

    // ciTrack
    ciTrack();

    // ciTrack
    ciTrack(ciTrack &obj);

    virtual ~ciTrack();

protected:  // variables

    double  m_startTime;         
    double  m_endTime;           
   double   m_speed;                
    double  m_frameRate;         
    double  m_increment;         
    PlayMode   m_playMode;          
    bool m_loopContinuous;       
    double  m_currentSimTime;    
    int     m_saveFileCount;     
    bool m_linkTOD;
    bool    m_saveImagesDuringPlayback; 
    bool    m_useFrames;
    string  m_saveFileName;
    double  m_recordingVelocity;
    clXMLNode* m_parentNode;
private: // variables

};

#endif // _ciTRACK_H_