source: fact/Evidence/GUI.h@ 20029

#ifndef GUI_H_SEEN
#define GUI_H_SEEN

#include <QtGui>
#include <QtConcurrentRun>

#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>
#include <qwt_plot_zoomer.h>
#include <qwt_plot_magnifier.h>
#include <qwt_plot_panner.h>
#include <qwt_picker_machine.h>
#include <qwt_scale_engine.h>
#include <qwt_analog_clock.h>
#include <qwt_scale_widget.h>
#include <qwt_plot_layout.h>
#include <qwt_legend.h>
#include <qwt_legend_label.h>
#include <qwt_symbol.h>
#include <qwt_plot_marker.h>
#include <qwt_color_map.h>
#include <qwt_date_scale_draw.h>

#include <limits>
#include <float.h>
#include <limits>

#include "dic.hxx"
#include "Evidence.h"

const QColor EddPlotBackgroundColor(Qt::yellow);

void OpenHistory(char *, int, int=-1);
bool SetStatus(QWidget *, QString, int, QString, int = -1);

// General Edd Widget: has Update() method called by DIM interface
class EddWidget {

  public:
        virtual void Update(const QString &, int, const QByteArray &, const QString &, const QString &, int=-1) = 0;
};


// Base class for Edd plot
// RemoveService() is pure virtual and needs to be implemented in the application class,
// it will be called through signal by context menu of legend entries 
class EddBasePlot: public QwtPlot {
  Q_OBJECT

  protected:    
    QMenu *Menu;
    QAction *StripAction;

  private:
    struct PlotItem {
      QwtPlotCurve *Signal;
          QVector<double> x;
          QVector<double> y;
      double Smallest;
      double Largest;
          double Mean;
          double Sigma;
    };
    QList<struct PlotItem> Items;

    QAction *YLogAction;
    QAction *NormAction;
    QAction *StyleAction;
    QAction *StatisticsAction;

    QwtPlotPanner *Panner;
    QwtPlotGrid *Grid;
    QwtPlotZoomer *Zoomer;
        QwtPlotMagnifier *Magnifier;
    QwtPicker *Picker;
        QRectF BBox;
        QwtPlotMarker *Stats;
        class EddLegend *Legend;
        bool MouseMoved;

  public:
    EddBasePlot(QWidget * = NULL);
    ~EddBasePlot();

        QTimer *Timer;
        bool NewData;
        QwtPlotCurve *NewCurve(QwtText);
        virtual void RemoveService(QwtPlotCurve *) = 0;
        void DeleteCurve(QwtPlotCurve *);
        void ClearCurve(unsigned int);
        void AddPoint(unsigned int, double, double);

  protected slots:
    void UpdatePlot();

  private slots:
        void ReDoStats();
    void HandleZoom(const QRectF &);
        void MouseSelection(const QPolygon &);
        void mousePressEvent(QMouseEvent *); 
        void mouseReleaseEvent(QMouseEvent *); 
        void mouseMoveEvent(QMouseEvent *); 
        void contextMenuEvent(QContextMenuEvent *);
    void MenuSetUpdateRate();        
    void MenuZoomOut();
    void MenuSaveASCII();
    void MenuSave();
    void MenuPrint();
        void MenuPlotHelp();
};
                  
// General indicator for DIM service
class EddLineDisplay: public QLineEdit, public EddWidget {
    Q_OBJECT

    QMenu *Menu;
    QPoint dragStart;
    QWidget *LastHist;
        
        QString ServiceName;
        int Index;
        
    void mousePressEvent(QMouseEvent *); 
    void mouseReleaseEvent(QMouseEvent *); 
    void mouseMoveEvent(QMouseEvent *); 
        
  public:
    EddLineDisplay(QString, int=-1, QWidget * = NULL);
    ~EddLineDisplay();
        void Update(const QString &, int, const QByteArray &, const QString &, const QString &, int = -1);

        bool ShowAsTime;
        
  private slots:
    void contextMenuEvent(QContextMenuEvent *);    
    void MenuOpenHistory();
    void MenuCopyService();
    void MenuCopyData();
};

// Sending command to DIM server
class EddCommand: public QLineEdit {
    Q_OBJECT

        QString Name;

        QString GetFormat();

  public:
    EddCommand(QString, QWidget * = NULL);

  private slots:
        void SendCommand();     
    void contextMenuEvent(QContextMenuEvent *);
        void MenuCommandHelp();   
};

// Graph class for history display 
class EddPlot: public EddBasePlot, public EddWidget {
    Q_OBJECT

    struct ItemDetails {
      QString Name;
          int Index;
          QwtPlotCurve *Curve;
    };
    QList<struct ItemDetails> List;

  private:
        QwtLegend *Legend;
        QTimer *SingleShot;
    QPoint dragStart;

    void dragEnterEvent(QDragEnterEvent *);
    void dropEvent(QDropEvent *);
                
  public:
    EddPlot(QString = QString(), int = 0, QWidget * = NULL);
    ~EddPlot();
    void AddService(QString, int = 0);
        void Update(const QString &, int, const QByteArray &, const QString &, const QString &, int = -1);

  public slots:
        void RemoveService(QwtPlotCurve *);
    void borderPath(QRect) {}; //Dummy method for qwtPicker, prevents QMetaObject::invokeMethod: No such method EddPlot::borderPath(QRect)
   
  private slots:
    void MenuPaste();
    void MenuCopyTimeScale();
        void MenuShowLastHour();
        void MenuShowLastDay();
        void MenuAllAsText();
};

// Scale showing date and time
class EddDateScale: public QwtDateScaleDraw {

  public:
        QwtText label(double) const;
};

// Legend and legend label with protected methods implemented
class EddLegend: public QwtLegend {

  protected:
        QWidget *createWidget(const QwtLegendData &) const;
};

class EddLegendLabel: public QwtLegendLabel {
    Q_OBJECT

    QMenu *Menu;
    QPoint dragStart;
        
  public:
        EddLegendLabel();

        void contextMenuEvent(QContextMenuEvent *);
        void mousePressEvent(QMouseEvent *);
        void mouseReleaseEvent(QMouseEvent *);
    void mouseMoveEvent(QMouseEvent *);
        
        QwtPlotCurve *Curve;
        QAction *ThickLineAction;

  private slots:
        void MenuOpenHistory();
        void MenuCopyService();
        void MenuThickLine(bool);
        void MenuRemove();
        
  signals:
        void DeleteCurve(QwtPlotCurve *);
};

// Text history and output class
class EddText: public QTextEdit, public EddWidget {
  Q_OBJECT

  private:
        QString Name;
        bool Pure;
        
  public:
    EddText(QString, bool = false, QWidget * = NULL);
    ~EddText();
        void Update(const QString &, int, const QByteArray &, const QString &, const QString &, int = -1);

        bool Accumulate;
};


// Interface to DIM system
class EddDim: public QObject, public DimInfo {
  Q_OBJECT

  public:
        struct HistItem {
          int Time;
          QVector<QPair<int, QByteArray> > DataRaw;
          QVector<QPair<int, QStringList> > DataText;
          QString Format;
        };

  private:
        struct Item {
          DimStampedInfo *DIMService;
          QList<QPair<class EddWidget *, int> > Subscribers;
          int TimeStamp;
          QByteArray ByteArray;
          QString Format;
          QString Text;
          QStringList Items;
        };

    QMap<QString, struct Item> ServiceList;
        QMap<QString, bool> IgnoreMap;
    QMutex *Mutex, IgnoreMutex;
    QMap<QString, struct HistItem> HistoryList;

        unsigned int Period;
        long long Volume;

        void infoHandler();

  private slots:
        void Update(QString, int, QByteArray, QString);
        void UpdateStatistics();

  public:
    EddDim();
    ~EddDim();

        void Subscribe(QString, class EddWidget *, int = -1);
        void Unsubscribe (QString, class EddWidget *, int = -1);
        void Ignore (QString, bool);
        struct HistItem GetHistory(QString);

  signals:
    void INT(QString, int, QByteArray = QByteArray(), QString = QString());
};

// Open new window
class EddWindow: public QPushButton {
  Q_OBJECT

  QMainWindow *M;
  QGridLayout *L;

  public:
    EddWindow(QString, QString);
        QGridLayout *Layout();
        QMainWindow *Window();
};

#endif