ProjectData.h

Go to the documentation of this file.

#pragma once
#include <ipj/iface/Namespace.h>
#include <ipj/iface/PartProject.h>
#include <ipj/iface/ProjectModule.h>
#include <ipj/iface/ProjectScriptObject.h>
#include <ipj/iface/global.h>
#include <misc/gen/ElapseTimer.h>
#include <misc/gen/IniProfile.h>
#include <misc/gen/Sustain.h>
 
namespace sf
{
 
// Forward declarations.
class DataFilterList;
class CustomFields;
class ScanEntry;
 
class _IPJ_CLASS ProjectData final : public ProjectScriptObject
{
  public:
    ProjectData();
 
    ~ProjectData() override;
 
    void debug();
 
    void addPropertyPages(PropertySheetDialog* sheet);
 
    void addModulePropertyPages(PropertySheetDialog* sheet);
 
    bool read(std::istream& is);
 
    bool write(std::ostream& os);
 
    bool isValidPart();
 
    void createFrame(QWidget* parent);
 
    void destroyFrame();
 
    void setFrameSaveState(bool rd);
 
    QString getStateName();
 
    ScanEntry* addScan();
 
    enum EState
    {
      psNONE,
 
      psABORTED,
      psERROR,
      psDISABLED,
 
      psUNINITIALIZED,
      psINITIALIZING,
      psINITIALIZED,
      psINITFAILED,
 
      psREADY,
 
      psPREPARING,
      psPREPARED,
 
      psTOOLCHANGING,
      psTOOLCHANGED,
 
      psAPPROACHING,
      psAPPROACHED,
 
      psCHECKING,
      psCHECKED,
 
      psSCANNING,
      psSCANNED,
 
      psDATASAVING,
      psDATASAVED,
 
      psEVALUATING,
      psEVALUATED,
 
      psREPORTING,
      psREPORTED,
 
      psRETREATING,
      psRETREATED,
 
      psFINISHING,
      psFINISHED,
 
      psSUSPENDING,
      psSUSPENDED,
 
      psSTOPPING,
      psSTOPPED,
 
      psMOVING,
      psMOVED,
 
      psRESETTING,
      psRESUMING,
 
      psACCOMMODATING,
      psACCOMMODATED,
 
      psLASTENTRY
    };
 
    bool initialize();
 
    bool start(unsigned index);
 
    bool evaluate(unsigned index, int file_index = -1);
 
    bool moveToSysPos(ESystemPosition sp);
 
    bool moveToQuery(int scan);
 
    bool moveTo(int scan, int index, double frac = 0.0, bool rect = false);
    bool activate(unsigned index);
 
    bool suspend();
 
    bool stop();
 
    bool abort();
 
    bool rotate(int scan_entry);
 
    bool isRotating();
 
    bool finalize(int lock = 0);
 
    bool isFinalized() const;
 
    bool canInitialize();
 
    bool canStart(int scan_entry);
 
    bool canStop();
 
    bool canAbort();
 
    bool canSuspend();
 
    bool canRotate(int scan_entry);
 
    bool canEvaluate(int scan_entry);
 
    bool canFinalize(int lock = 0);
 
    bool canMoveTo();
 
    void clear();
 
    IniEnvelope GetScanIni(QString scan_area);
 
    ConfigStore GetPartStateIni();
 
    bool isScanArea(const QString& name);
 
    void removeScan(unsigned index);
 
    void moveScan(unsigned src, unsigned dest);
 
    void swapScan(unsigned idx1, unsigned idx2);
 
    int indexOf(ScanEntry*) const;
 
    int getScanListIndex(const ScanMethod* sm) const;
 
    bool disableProject(bool disable);
 
    bool storeFilterList(bool rd);
 
    const TCalibrationSets& getCalibrationSets();
 
    bool shouldWaitForEvent();
 
    inline ScanEntry* getActiveScan();
 
    int getActiveScanIndex();
 
    int getSelectedScanIndex();
 
    ScanEntry* getSelectedScan();
 
    double getScanProgress();
 
    QString getScanBinderName();
 
    void setScanBinderName(const QString& name);
 
    ScanBinder* GetScanBinder();
 
    InformationTypes::id_type getScanMethodIdOffset();
 
    InformationTypes::id_type getScanBinderIdOffset();
 
    std::string getNamePrefix();
 
    QString getErrorText();
 
    QWidget* getScanFrameParent();
 
    void setScanFrameParent(QWidget* parent);
 
    DataFilterList* getFilterList();
 
    QString getMediumName();
 
    void SetReportOptions(ReportOptions options);
 
    ReportOptions getReportOptions();
 
    QString getReportTemplate();
 
    void setReportTemplate(const QString& templ);
 
    TClosure<void, void*> onDirty;
 
    void setPartProject(const PartProject* part_project);
 
    PartProject* getPartProject() const;
 
    void setPartInspection(const TPartInspection* part_inspection);
 
    TPartInspection* getPartInspection() const;
 
    QWidget* getFrame();
 
    ScanEntry* getScan(ssize_t index);
 
    ssize_t getScanCount();
 
    inline EState GetState();
 
    QString GetStateName(int state);
 
    QString getPart() const;
 
    void setDirty(bool tf = true);
 
    bool isDirty() const;
 
    ssize_t getScanMethodCount();
 
    std::string getScanMethodName(ssize_t index);
 
    TProjectFrame* GetProjectFrame();
 
    const ConfigStore& getConfigStore() const;
 
  protected:
    TSustain<ProjectData> _sustainEntry;
 
    bool sustain(const timespec& t);
 
    bool process(const timespec& ts);
 
    bool setError(const QString& error_text);
 
    bool setState(EState state);
 
    void attach(ScanEntry* entry);
 
    void detach(ScanEntry* entry);
 
    bool storeProfile(IniProfile& ini_profile, bool rd);
 
    void storeConfig(bool rd);
 
    bool initializeScans();
 
    const IdInfo* getInfo(const std::string& name) const override;
 
    bool getSetValue(const IdInfo* info, Value* value, Value::vector_type* params, bool flag_set) override;
 
    bool startDataSaving();
 
    bool isDataSavingReady() const;
 
  private:
    enum : int
    {
      weDISABLED = 0,
      weENABLED,
      weEVENT
    };
 
    void setExports(bool var_export);
 
    void SendCursorEvent(bool btn_dn, Qt::KeyboardModifiers shift, int index, double frac);
 
    bool GetGenericInfoList(StringList& strings);
 
    void UpdateScanStateChanges();
 
    struct _IPJ_CLASS InformationVariables
    {
        LocalVariable vState;
        LocalVariable vWaitForEvent;
        LocalVariable vPartProject;
        LocalVariable vPartInspection;
        LocalVariable vMediumName;
        CustomFields* Custom;
 
        struct _IPJ_CLASS DataCursor final : VariableHandler
        {
            DataCursor()
            {
              // Hook the handler for the mark related variables.
              vPopIndex.setHandler(this);
              vFraction.setHandler(this);
              vIndex.setHandler(this);
              vEvent.setHandler(this);
            }
 
            void variableEventHandler(EEvent, const Variable&, Variable&, bool) override;
 
            ProjectData* ProjData{nullptr};
            Value::int_type PopIndex{0};
            Value::flt_type Fraction{0};
            Value::int_type Index{0};
            int Event{0};
            bool Active{false};
            Variable vPopIndex;
            Variable vEvent;
            Variable vFraction;
            Variable vIndex;
        } FCursor;
    }* FVars;
 
    QWidget* FFrame;
    QWidget* FScanFrameParent;
    TVector<ScanEntry*> FScanList;
    PartProject* FPartProject;
    bool FDirty;
    int FActiveScanIndex;
    int FPrevScanIndex;
    int FQuitScanIndex;
    int FDataFileIndex;
    ScanMethod* ActiveScanMethod;
    EState FState, FPrevState, FResumeState;
    ElapseTimer FInitTimer;
    QString FErrorText;
    ElapseTimer FChangeTimer;
    bool FShouldStop;
    EState FEvalPreState;
    ScanBinder* FScanBinder;
    ConfigStore FSaveState;
    std::string FNamePrefix;
    std::string FNamePrefixCalibPre;
    std::string FNamePrefixCalibPost;
    Variable::PtrVector FLocalVars;
    void VarEvent(Variable::EEvent, const Variable&, Variable&, bool);
    TPartInspection* FPartInspection;
    int FFinalized;
    void HandleInspectionChange(const void*);
    TCalibrationSets* FCalibSets;
    void HandlePropertyPageApply(const void* sender);
    ReportOptions FReportOptions;
    QString FReportTemplate;
    TVariableHandler<ProjectData> _variableHandler;//
 
    friend class ScanEntry;
    friend class ProjectDataPropertyPage;
    friend class InformationVariables::DataCursor;
};
 
inline const TCalibrationSets& ProjectData::getCalibrationSets()
{
  return *FCalibSets;
}
 
inline QString ProjectData::getPart() const
{
  return FPartProject->getPart();
}
 
inline void ProjectData::setScanFrameParent(QWidget* parent)
{
  FScanFrameParent = parent;
}
 
inline ScanEntry* ProjectData::getScan(ssize_t index)
{
  return FScanList[index];
}
 
inline QString ProjectData::getStateName()
{
  return GetStateName(GetState());
}
 
inline ProjectData::EState ProjectData::GetState()
{
  return FState;
}
 
inline ScanEntry* ProjectData::getActiveScan()
{
  if (FActiveScanIndex >= 0)
    return getScan(FActiveScanIndex);
  return nullptr;
}
 
inline int ProjectData::getActiveScanIndex()
{
  return FActiveScanIndex;
}
 
inline ScanEntry* ProjectData::getSelectedScan()
{
  int sel = getSelectedScanIndex();
  if (sel >= 0)
    return getScan(sel);
  return nullptr;
}
 
}// namespace sf