performanceMonitorGraph.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2021 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/

#pragma once

#include <vrfGuiCommonQt/vrfGuiCommonQt.h>
#include <QtWidgets/QWidget>
#include <vlpi/simulationAddress.h>
#include <vector>

class QVBoxLayout;
class QScrollArea;
class QLabel;
class QHBoxLayout;
class QPaintEvent;
class QGridLayout;
class QSpinBox;
class QFrame;

namespace makVrv
{
   class DtDe;
}

namespace makVrf
{
   class DtPerformanceMonitorGraph;
   class DtPerformanceBar;
   static const int OTHER_TIME = 500;

   class DT_DLL_VRFGUICOMMONQT DtPerformanceData : public QWidget
   {
      Q_OBJECT;

   public:
      DtPerformanceData(makVrv::DtDe& de, QWidget* parent);
      virtual ~DtPerformanceData();

      virtual void showData(const DtPerformanceBar*);
      virtual void clear();
      virtual void setBarUnits(const QString&);

      const DtPerformanceBar* performanceBar() const
      {
         return myPerformanceBar;
      }

      virtual void update();
      virtual void setNumberOfCPUs(short);
      virtual void setNumberOfTickThreads(short);
      virtual void setMinFrameRate(double);
      virtual void setMaxFrameRate(double);
      virtual void setLatency(double);
      virtual void setPingingServer(bool b);
      virtual void updateObjectCounts();

      virtual void setBarColor(int section, const QColor&);

   protected:
      virtual void addSectionTime(int section, const QString& title, bool actualTime = false, int indent = 0, const QColor& color = Qt::transparent, bool hiddenSection = false);
      virtual void addSectionTime(int section, int basedOnSection, const QString& title, bool actualTime = false, int indent = 0, const QColor& color = Qt::transparent, bool hiddenSection = false);

   protected slots:
      virtual void setNumberOfTickThreads(int);

   protected:
      makVrv::DtDe& myDe;
      QString myBarUnits;
      const DtPerformanceBar* myPerformanceBar;

   public:
      QHBoxLayout* myMainLayout;
      QGridLayout* myDataLayout;
      QGridLayout* myTimesLayout;
      QFrame* mySeparatorLine;
      QLabel* myBackendTitle;
      QLabel* myBackendLabel;
      QLabel* myTickThreadsLabel;
      QSpinBox* myTickThreads;
      QLabel* myCoresLabel;
      QLabel* myNumberOfCores;
      QLabel* mySimulatedObjectsLabel;
      QLabel* mySimulatedObjects;
      QLabel* myMinFrameRateLabel;
      QLabel* myMinFrameRate;
      QLabel* myMaxFrameRateLabel;
      QLabel* myMaxFrameRate;
      QLabel* myLatencyLabel;
      QLabel* myLatency;

      struct SectionTime
      {
         QLabel* title = nullptr;
         QLabel* value = nullptr;
         QLabel* colorLabel = nullptr;
         QHBoxLayout* layout = nullptr;
         double time = 0.;
         bool actualTime = true;
         int basedOnSection = -1;
         bool hidden = false;
      };

      std::map<int, SectionTime> mySectionTimes;
   };

   class DT_DLL_VRFGUICOMMONQT DtPerformanceBarTimes : public QWidget
   {
      Q_OBJECT

   public:
      DtPerformanceBarTimes(makVrv::DtDe&, DtPerformanceMonitorGraph* parent);
      virtual ~DtPerformanceBarTimes();

      virtual void setTime(int section, double time);
      virtual void setTotalTime(double );
      virtual void setBarUnits(const QString&);
      virtual void addSectionInformation(int section, const QColor& color, const QString& title, const std::vector<int>& subtractOff = std::vector<int>(), bool hiddenSection = false);
      virtual void setBarColor(int section, const QColor&);
      virtual double timeFor(int section) const;

   signals:
      void barSelected();

   protected:
      virtual void paintEvent(QPaintEvent*);
      virtual void mouseMoveEvent(QMouseEvent*);
      virtual void mouseReleaseEvent(QMouseEvent*);
      virtual void updateToolTip(int);
      virtual bool eventFilter(QObject*, QEvent*);
      virtual void updateToolTip(const QPoint&);
      virtual int indexForSection(int);

   protected:
      DtPerformanceMonitorGraph* myPerformanceMonitorGraph;
      double myTotalTime;
      struct Section
      {
         Section() : time(0.), totalTime(0.), section(-1) {};

         int section;
         double time;
         double totalTime;
         QRectF coverage;
         QString title;
         QColor color;
         std::vector<int> subtractOff;
         bool hidden = false;
      };

      std::vector<Section> mySectionTimes;
      int myOverSection;
      QString myBarUnits;
      makVrv::DtDe& myDe;
      std::map<int, int> myIndexForSection;
      std::vector<int> mySubtractOff;
   };

   class DT_DLL_VRFGUICOMMONQT DtPerformanceBar : public QObject
   {
      Q_OBJECT

   public:
      DtPerformanceBar(makVrv::DtDe& de, DtPerformanceMonitorGraph* parent, const QString& title);
      virtual ~DtPerformanceBar();

      virtual void setBarUnits(const QString&);

      virtual void setTime(int section, double time);
      virtual void setTotalTime(double d);
      virtual double totalTime() const;
      virtual void setFixedHeight(double d);
      virtual void setBarColor(int section, const QColor&);
      virtual void addSectionInformation(int section, const QColor& color, const QString& title, const std::vector<int>& subtractOff = std::vector<int>(), bool hiddenSection = false);
      virtual DtSimulationAddress backendAddress() const;
      virtual void setNumberOfCPUs(short);
      virtual void setFrameRate(double fps, double simTimeToRealTime);
      virtual void setLatency(double);
      double latency() const
      {
         return myLatency;
      }

      virtual void setMinFrameRate(double);
      double minFrameRate() const
      {
         return myFrameRateMin;
      }

      virtual void setMaxFrameRate(double);
      double maxFrameRate() const
      {
         return myFrameRateMax;
      }

      short numberOfCPUs() const
      {
         return myNumberOfCPUs;
      }

      virtual void setNumberOfTickThreads(short);
      short numberOfTickThreads() const
      {
         return myNumberOfTickThreads;
      }

      virtual void setPingingServer(bool);
      bool pingingServer() const
      {
         return myPingingServer;
      }

      virtual void setSelected(bool);

      virtual void setLatencyStatus(int);

      virtual double timeFor(int section) const;
      virtual QString title() const;

   protected:
      virtual void updateFrameTime();
      virtual void mouseReleaseEvent(QMouseEvent*);
      virtual bool eventFilter(QObject*, QEvent*);

   signals:
      void totalBarTimeChanged(double);
      void barSelected();
      void timeChanged(int, double);
      void numberOfCPUsChanged(short);
      void numberOfTickThreadsChanged(short);
      void maxFrameRateChanged(double);
      void minFrameRateChanged(double);
      void latencyChanged(double);
      void pingingServerChanged(bool);

   protected:
      QString myBarUnits;
      double myTotalBarTime;
      makVrv::DtDe& myDe;
      short myNumberOfCPUs;
      short myNumberOfTickThreads;
      double myFrameRate;
      double myFrameRateMin;
      double myFrameRateMax;
      double myLatency;
      bool myPingingServer;
      double mySimTimeToRealTime = 1.0;

   public:
      QHBoxLayout* myLayout;
      QLabel* myTitle;
      DtPerformanceBarTimes* myPerformanceBarTimes;
      QLabel* myTotalTime;
   };

   class DT_DLL_VRFGUICOMMONQT DtPerformanceMonitorGraph : public QWidget
   {
      Q_OBJECT

   public:

      DtPerformanceMonitorGraph(makVrv::DtDe& de, QWidget* parent = 0, const Qt::WindowFlags& flags = 0);

      virtual ~DtPerformanceMonitorGraph();

      virtual void setBarHeight(double);
      double barHeight() const
      {
         return myBarHeight;
      }

      virtual void setBarSpacing(double d);
      double barSpacing() const;

      virtual void addSectionInformation(int section, const QColor& color, const QString& title, const std::vector<int>& subtractOff = std::vector<int>(), bool hiddenSection = false);
      virtual void setBarColor(int secion, const QColor&);

      virtual void setBarUnits(const QString&);
      const QString& barUnits() const
      {
         return myBarUnits;
      }

      virtual DtPerformanceBar* addBar(const QString&);
      virtual void selectBar(const QString&);
      virtual void setLatencyStatus(const QString&, int);
      virtual QString selectedBar() const;
      virtual void removeBar(DtPerformanceBar*);
      virtual void removeAllBars();
      virtual const QColor& colorForSection(int) const;
      virtual const QString& titleForSection(int) const;
      virtual void objectCountsChanged();
      virtual void setPingingServer(const QString&);

      virtual int combine(const std::vector<int>& topSections, const std::vector<int>& bottomSections);

      struct CombinedInformation
      {
         std::vector<int> topSections;
         std::vector<int> bottomSections;
      };

      virtual CombinedInformation sectionIsCombinedWith(int section) const;

      virtual void split(int key);

   protected:
      virtual void selectBar(DtPerformanceBar* newBar);
      
   protected slots:
      virtual void barSelected();
      virtual void timeChanged(int section, double d);
      virtual void numberOfCPUsChanged(short);
      virtual void numberOfTickThreadsChanged(short);
      virtual void maxFrameRateChanged(double);
      virtual void minFrameRateChanged(double);
      virtual void latencyChanged(double);
      virtual void pingingServerChanged(bool);

   protected:
      double myBarHeight;

      struct SectionInformation
      {
         SectionInformation& operator=(const SectionInformation& rhs)
         {
            section = rhs.section;
            title = rhs.title;
            color = rhs.title;
            subtractOff = rhs.subtractOff;
            hidden = rhs.hidden;

            return *this;
         }

         int section;
         bool hidden = false;
         QString title;
         QColor color;
         std::vector<int> subtractOff;
      };

      std::vector<SectionInformation> mySectionInformation;
      QString myBarUnits;

      std::vector<DtPerformanceBar*> myPerformanceBars;

      makVrv::DtDe& myDe;
      DtPerformanceBar* mySelectedBar;

      typedef std::map<int, CombinedInformation> Combined;
      Combined myCombined;

   public:
      QVBoxLayout* myMainLayout;
      QScrollArea* myScrollArea;
      QWidget* myInsideWidget;
      QGridLayout* myInsideLayout;
      QFrame* mySeparatorLine;
      DtPerformanceData* myPerformanceData;
   };
}