GPMG_MovieGraphDrawPanel.h

Go to the documentation of this file.

#ifndef GPMG_MovieGraphDrawPanel_H
#define GPMG_MovieGraphDrawPanel_H

#include "GPMG_DrawPanel.h"

#include "GPM_ModelGraph.h"
#include "GPMG_Project.h"
#include "GPMG_MovieThread.h"
#include "CORE_Time.h"

DEFINE_SPTR(GPMG_MovieGraphDrawPanel);
class GPMG_MovieGraphDrawPanel : public GPMG_DrawPanel { 
    SP_OBJECT(GPMG_MovieGraphDrawPanel);
    
    // ATTRIBUTES 
public:
  
private:

    //all files names of graph
    //without path
    vector<tString> mGraphFiles;

  

    // current file index
    int mFileIndex;

    //delay beetwen two file in ms
    static const tFlag PLAY;
    long int  mDelay;

    // sacle
    tReal mMinPoint[3],mMaxPoint[3];
    map<tString,tReal*> mBoundsValue;
    // ASSOCIATIONS

    SP::GPM_ModelGraph mCurrentGraph;
    
    SP::GPMG_MovieThread mMovieThread;
    SP::CORE_Time mTime;
    
    tBoolean mIsDrawnEnabled;
    
    
    // METHODS    
protected:
    // CONSTRUCTORS
    GPMG_MovieGraphDrawPanel(); 
  
  
    // DESTRUCTORS
    virtual ~GPMG_MovieGraphDrawPanel(void);  
  
  
  
  
public:
    // NEW
    static inline SP::GPMG_MovieGraphDrawPanel New() {
        SP::GPMG_MovieGraphDrawPanel p(new GPMG_MovieGraphDrawPanel(),
                                       GPMG_MovieGraphDrawPanel::Delete());
        p->setThis(p);
        return p;
    };
  
    virtual void toDoAfterThisSetting() {
        GPMG_DrawPanel::toDoAfterThisSetting();
        mMovieThread->setPanel(getThis());
    }

    // SET
protected:
    void initAttributes();
  
public:
  
    

    inline void setGraphFiles(const vector<tString>& files,
                              const tReal minPoint[3],
                              const tReal maxPoint[3],
                              const map<tString,tReal*>& bounds) {
        // store the graph file names
        int i,n=files.size();
        mGraphFiles.resize(n);
        for (i=0;i<n;i++) {
            mGraphFiles[i]=files[i];
        }

     
        
        // update the scales of the all the graphs
        setScales(minPoint,maxPoint,bounds);
        
        // set the graph file to first index
        mFileIndex=1;
      
        goToFirst();

        enableMovieMenus();
    }
    void clearGraphs();

    void addGraph(const GPM_ModelGraph& graph,
                  const tString& file,
                  const tReal minPoint[3],
                  const tReal maxPoint[3],
                  const map<tString,tReal*>& bounds);
    
    void clearScales();
    void setScales(const tReal minPoint[3],
                   const tReal maxPoint[3],
                   const map<tString,tReal*>& bounds);
    
    
 

    inline void setDelay(const int& i) {
        mDelay=i*1000;
    }
    // GET
    virtual tFlag getGraphType(const GPM_Graph* graph) const {
          return  GPMG_Project::RESULT_GRAPH;
        
    }
  
    // OTHERS 
public:
   
    // SAVER & LOADER  methods
     
    virtual void loadFromUIClass(const UI_Class& mclass);
    virtual void saveToUIClass(UI_Class& mclass) const;

    
protected: 

    // DRAW methods
    
    virtual tBoolean paintElements();

    virtual void computeVertexBounds(double& xMin,double& yMin,double& xMax,double& yMax) const;
  
    virtual void computeNodesScale();
    
    virtual void computePortsScale();
    
    virtual void computeEdgesScale();

  

public:
    // MOVIE methods
    // 
    inline void next() {
        next(1);
    }

    inline tBoolean hasNext() const {
        return (mFileIndex<((int)mGraphFiles.size())-1);
    }
    inline tBoolean hasPrevious() const {
        return (mFileIndex>0);
    }
    inline tBoolean isOnFirst() const {
        return (mFileIndex==0);
    }
    inline tBoolean isOnLast() const {
        return (mFileIndex==((int)mGraphFiles.size())-1);
    }

    void next(const int& d);
    
    void previous() {
        next(-1);
    }
    
    inline void goToFirst() {
        
        if (mFileIndex==0) return;
        mFileIndex=1;
        next(-1);    
    }
    
    inline void goToLast() {
        if (mFileIndex==((int)(mGraphFiles.size())-1)) return;
        mFileIndex=mGraphFiles.size();
        next(-1);
    }

    
    void play(const tBoolean& isLoopOn);
    
    void stop();
 

    void save(const tString& prefix);

    void threadHasFinished(const tFlag& action);
    void threadHasBeenSuspended(const int& steap,const tFlag& action);
   
private:
 
    void loadGraph(GPM_ModelGraph& graph,CORE_Out *out);
    
    void showCurrentGraph();
    

    void drawGraph();

    void drawVertices(const tBoolean& areNodesShown,
                      const tBoolean& arePortsShown,
                      const tReal& xmin,
                      const tReal& xmax,
                      const tReal& ymin,
                      const tReal& ymax);
    
    void drawEdges(const tReal& xmin,
                   const tReal& xmax,
                   const tReal& ymin,
                   const tReal& ymax,
                   const tReal& width);
    
  

    void enableMovieMenus();
};
#endif