ScopeController.h

#pragma once
#include "helpers/ScopeButton.h"
#include "helpers/ScopeScanModeButton.h"
#include "helpers/ScopeNumber.h"
#include "parameters/Scope.h"
#include "ScopeDatatypes.h"
#include "BaseController.h"
#include "BaseController_p.h"

// We need the type of the FPGAStatus struct for FPGAFIFOStatus here
#include "devices\fpga\FPGAPhotonCounter.h"
#include "devices\fpga\FPGADigitalDemultiplexer.h"
#include "devices\fpga\FPGAAnalogIntegrator.h"
#include "devices\fpga\FPGAAnalogDemultiplexer.h"
#include "devices\fpga\FPGANoiseOutput.h"
#include "devices\fpga\FPGAResonanceScanner.h"
#include "devices\fpga\FPGAResonanceScanner_NI5771.h"

// Forward declarations
namespace scope {
    template<class T> class ScopeDatatypeBase;
    class ScannerVectorTypeHelper;
    typedef ScopeDatatypeBase<ScannerVectorTypeHelper> ScannerVectorType;
    namespace gui {
        class CChannelFrame;
        class CHistogramFrame;
    }
}

namespace scope {

class ScopeController
    : public BaseController<1, true> {

protected:
    class Impl;

    class ModeBasicImpl;

    class ModeLiveImpl;

protected:
    /*ScopeController(ScopeController& other);              // we need this copyable for std::bind to work...
    ScopeController& operator=(ScopeController& other); */

    Impl& GetImpl();

    Impl* const Pimpl() const;

public:
    struct FPUButtons {
        ScopeButton LeftButton;
        ScopeButton RightButton;
        ScopeButton UpButton;
        ScopeButton DownButton;
        ScopeButton SetZeroButton;
    };

    struct ScanModeButtons {
        std::map<ScannerVectorTypeHelper::Mode, ScopeScanModeButton> map;

        ScanModeButtons() {
            map.emplace(ScannerVectorTypeHelper::Mode::Bidirectional, ScopeScanModeButton(ScannerVectorTypeHelper::Mode::Bidirectional));
            map.emplace(ScannerVectorTypeHelper::Mode::LineStraight, ScopeScanModeButton(ScannerVectorTypeHelper::Mode::LineStraight));
            map.emplace(ScannerVectorTypeHelper::Mode::Planehopper, ScopeScanModeButton(ScannerVectorTypeHelper::Mode::Planehopper));
            map.emplace(ScannerVectorTypeHelper::Mode::ResonanceBiDi, ScopeScanModeButton(ScannerVectorTypeHelper::Mode::ResonanceBiDi));
            map.emplace(ScannerVectorTypeHelper::Mode::ResonanceHopper, ScopeScanModeButton(ScannerVectorTypeHelper::Mode::ResonanceHopper));
            map.emplace(ScannerVectorTypeHelper::Mode::Sawtooth, ScopeScanModeButton(ScannerVectorTypeHelper::Mode::Sawtooth));
        }
    };

    static parameters::Scope GuiParameters;

    static ScopeNumber<bool> ReadOnlyWhileScanning;

    static ScopeButton StartSingleButton;
    static ScopeButton StartLiveButton;
    static ScopeButton StartStackButton;
    static ScopeButton StartTimeseriesButton;
    static ScopeButton StartBehaviorButton;
    static ScopeButton StopButton;
    static ScopeButton QuitButton;
    static ScopeButton StackStartHereButton;
    static ScopeButton StackStopHereButton;

    static std::array<ScopeNumber<double>, SCOPE_NAREAS> SingleFrameProgress;

    static ScopeNumber<double> PlaneCounter;

    static std::array<ScopeNumber<double>, SCOPE_NAREAS> FrameCounter;

    static ScopeNumber<double> RepeatCounter;

    static ScopeNumber<double> TrialCounter;

    static ScopeNumber<double> TotalTime;

    static ScopeButton StageZeroButton;

    static std::array<FPUButtons, SCOPE_NAREAS> FPU;

    static std::array<ScanModeButtons, SCOPE_NAREAS> ScanMode;
public:
    ScopeController(void);

    ~ScopeController(void);

    void Version();

    std::wstring CurrentConfigFile() const;

    void PrepareQuit();

    bool LoadParameters(const std::wstring& filepath);

    bool SaveParameters(const std::wstring& filepath);

    void ZeroGalvoOutputs();

    void OpenCloseShutter(const uint32_t& _area, const bool& _open);

    bool GetShutterState(const uint32_t& _area) const;

    void TurnOnOffSwitchResonance(const uint32_t& _area, const bool& _on);

    bool GetSwitchResonanceState(const uint32_t& _area) const;

    void AttachFrame(gui::CChannelFrame* const cframe);
    void DetachFrame(gui::CChannelFrame* const cframe);
    void AttachFrame(gui::CHistogramFrame* const hframe);
    bool HistogramAlreadyAttached(const uint32_t& _area);
    void DetachFrame(gui::CHistogramFrame* const hframe);
    void SaveCurrentWindowPositions();

    void SetHistogramLimits(const uint32_t& _area, const uint32_t& _channel, const uint16_t& _lower, const uint16_t& _upper);

    void SavePreset(const uint32_t& _area, const CString& _name);

    void SelectPreset(const uint32_t& _area, const size_t& _n);

    void RegisterScanmodeCallback(std::function<void(const uint32_t&, const ScannerVectorType&)> _callback);
};

}