---

TxLinePlotData.h

Go to the documentation of this file.

//-------------------------------------------------------------------
//
// File:        TxLinePlotData.h
//
// Purpose:        Interface for holder of line plot data
//
// Version:        $Id: TxLinePlotData.h,v 1.4 2002/04/05 21:53:55 kgl Exp $
//
// Copyright 2001, tech-X Corporation
//
//-------------------------------------------------------------------

#ifndef TX_LINE_PLOT_DATA_H
#define TX_LINE_PLOT_DATA_H

// unix includes
#include <txc_assert.h>

// txmodel includes
#include "TxPlotData.h"
#include "TxLinePlotDesc.h"

// txmath includes
#include <TxThroughStream.h>

class TxLinePlotData : public TxPlotData {

  public:

    TxLinePlotData();

    virtual ~TxLinePlotData();

    virtual void initialCalculation() {}

   virtual void printInitialCalculation() {}

    virtual TXSTD::string getClassID() const { return "TxLinePlotData";}

    // virtual int read(istream&);

    // virtual int write(ostream&) const;

    virtual void restart();

    virtual void paramsChanged();

    virtual void optionsChanged();

    virtual void stringsChanged();

    int getNumValuesCalculated() const { return getNumColumns();}

    int getNumSeries(){ return dataName.size();}

    int getNumSeries(int i){ return txlpd[i].getNumSeries();}

    int getMaxNumSeries(){ return getMaxNumRows();}

    const double* getDataRow(int i){ return getDataPtr(i,0);}

    const double* getXSeries(int ipl, int iseries) {
        return getDataRow( txlpd[ipl].getXIndex(iseries) );
    }

    const double* getYSeries(int ipl, int iseries) {
        return getDataRow( txlpd[ipl].getYIndex(iseries) );
    }

    const double* getXSeries(int ipl, int iseries, int istart) {
        return getDataPtr(txlpd[ipl].getXIndex(iseries), istart);
    }

    const double* getYSeries(int ipl, int iseries, int istart) {
        return getDataPtr(txlpd[ipl].getYIndex(iseries), istart);
    }

    int clearPlots() {
      // cout << "claerPlots: " << txlpd.size() << endl;
      txlpd.clear();
      return 0;
    }

    int isConnected() const {return iconnect;}

    virtual int getNumPlots() const { return txlpd.size();}

    virtual const TXSTD::string getTitle(int i) const { return txlpd[i].getTitle();}

    virtual const TXSTD::string getXLabel(int i) const { return txlpd[i].getXLabel();}

    virtual double getXMin(int i) const { return txlpd[i].getXMin();}

    virtual double getXMinPlot(int i) const { return txlpd[i].getXMinPlot();}

    virtual double getXMax(int i) const { return txlpd[i].getXMax();}

    virtual double getXMaxPlot(int i) const { return txlpd[i].getXMaxPlot();}

    virtual const TXSTD::string getYLabel(int i) const { return txlpd[i].getYLabel();}

    virtual double getYMin(int i) const { return txlpd[i].getYMin();}

    virtual double getYMinPlot(int i) const { return txlpd[i].getYMinPlot();}

    virtual double getYMax(int i) const { return txlpd[i].getYMax();}

    virtual double getYMaxPlot(int i) const { return txlpd[i].getYMaxPlot();}

    int appendPlotDesc(const TXSTD::string&, const TXSTD::string&, const TXSTD::string&, int, int);

    void appendSeriesToPlot(int, int, int);

    void setXMin(int i, double d){ txlpd[i].setXMin(d);}

    void setXMinPlot(int i, double d){ txlpd[i].setXMinPlot(d);}

    void setXMinAuto(int i, int a){ txlpd[i].setXMinAuto(a);}

    void setXMinNice(int i, int a){ txlpd[i].setXMinNice(a);}

    void setXMax(int i, double d){ txlpd[i].setXMax(d);}

    void setXMaxPlot(int i, double d){ txlpd[i].setXMaxPlot(d); }

    void setXMaxAuto(int i, int a){ txlpd[i].setXMaxAuto(a);}

    void setXMaxNice(int i, int a){ txlpd[i].setXMaxNice(a);}

    void setYMin(int i, double d){ txlpd[i].setYMin(d);}

    void setYMinPlot(int i, double d){ txlpd[i].setYMinPlot(d);}

    void setYMinAuto(int i, int a){ txlpd[i].setYMinAuto(a);}

    void setYMinNice(int i, int a){ txlpd[i].setYMinNice(a);}

    void setYMax(int i, double d){ txlpd[i].setYMax(d);}

    void setYMaxPlot(int i, double d){ txlpd[i].setYMaxPlot(d);}

    void setYMaxAuto(int i, int a){ txlpd[i].setYMaxAuto(a);}

    void setYMaxNice(int i, int a){ txlpd[i].setYMaxNice(a);}

    void disconnect() {iconnect = 0;} 

    virtual void calcLims() {
      int i;
      for(unsigned int i=0; i<txlpd.size(); i++) calcLims(i);
    }

    void setOutThroughStream(TxThroughStream& t) { 
      if(outThruStrmOwner) delete txcout;
      txcout = &t;
      outThruStrmOwner = false;
    }

    void setErrThroughStream(TxThroughStream& t) { 
      if(errThruStrmOwner) delete txcerr;
      txcerr = &t;
      errThruStrmOwner = false;
    }

    virtual TxThroughStream *getOutThroughStream() const { return txcout; }

    virtual TxThroughStream *getErrThroughStream() const { return txcerr; }

protected:

/*
 * The TxThroughStream output log 
 */
    TxThroughStream *txcout;

/*
 * The TxThroughStream error log 
 */
    TxThroughStream *txcerr;

/*
 * Whether I own the outThroughStream 
 */
    bool outThruStrmOwner;

/*
 * Whether I own the errThroughStream 
 */ 
    bool errThruStrmOwner;

    int appendSeries(const TXSTD::string&);

    void setNumValuesCalculated(int i){ setNumColumns(i);}

    void setMaxDataPoints(int i){ setMaxNumColumns(i);}

    void setMaxNumSeries(int i){ setMaxNumRows(i);}

    void appendValues(double* d);

    int iconnect;

  private:

    TxLinePlotData(const TxPlotData&);

    const TxLinePlotData& operator=(const TxPlotData&);

    virtual void updateLims(int);

    virtual void calcLims(int i){ txlpd[i].calcLims();}

    TXSTD::vector<TXSTD::string> dataName;

    TXSTD::vector<TxLinePlotDesc> txlpd;

};

#endif  // TX_LINE_PLOT_DATA_H

Copyright Tech-X Corporation, all rights reserved.