mainwindow.h

/****************************************************************************
 * Copyright (c) 2014, Joel Kivelä, Erkki Koskenkorva, Oskari Leppäaho,
 * Mika Lehtinen and Petri Partanen.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the copyright holders nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
****************************************************************************/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <memory>

#include <QMainWindow>
#include <QPushButton>
#include <QSlider>

#include "userinterface.h"
#include "common.h"
#include "controller.h"
#include "scenewidget.h"

using cavapa::CalibrationPoint;

namespace Ui
{
class MainWindow;
}

namespace cavapa_gui
{
class MainWindow : public QMainWindow, public UserInterface
{
    Q_OBJECT
public:
    explicit MainWindow(QMainWindow* parent = 0);
    ~MainWindow();

    void addSource(SourceID source, SourceType type, FrameTime length,
                   const std::string& description) override;

    void calculationCanceled() override;

    void calculationCompleted() override;

    void calculationContinued() override;
    
    void calculationPaused() override;
    
    void calculationStarted() override;

    void calculationStopped() override;

    std::vector<std::string> getMarkerHistory() override;
    
    void newMeasurement() override;

    void openMeasurement() override;

    void removeSource(SourceID source) override;

    void setCalibrationPoints(
                SourceID source,
                const std::vector<CalibrationPoint>& points) override;
    
    void setCanPause(bool flag) override;
    
    void setCanSaveVideos(bool flag) override;

    void setLocation(int x, int y) override;

    void setMarkerHistory(const std::vector<std::string>& history) override;
    
    void setSize(int width, int height, bool fullscreen) override;

    void showMessage(const std::string& message,
                     ErrorLevel errorLevel) override;

    void sourcePaused(SourceID source) override;

    void sourcePlayStarted(SourceID source) override;

    void startInterface() override;

    void updateFrame(const FrameCapture& frame) override;

    void updateCalculation(const FrameStats& statistics) override;

    void updateGeneralSettings(const GeneralSettings& settings) override;

    void updateMarkers(const std::vector<GraphMarker>& markers) override;

    void updateMetadata(const Metadata& metadata) override;

    void updateSourceSettings(SourceID source,
                              const SourceSettings& settings) override;

    void updateStatistics(const std::vector<FrameStats>& stats) override;

private:
    bool askConfirmation(const std::string& question) override;
    
    std::shared_ptr<SceneWidget> getScene(SourceID id) const;

    void setAddCalibrationPointsEnabled(bool enable);
    
    void setGraphVisible(bool visible);

    void setSliderValueFromLineEdit(QObject* lineEdit, float scale,
                                    QSlider* slider);

    void updateSlidersFromScene();

    std::vector<std::shared_ptr<SceneWidget>> scenes; // Holds the scenes
    Ui::MainWindow* ui;
    bool calculationInProgress = false;
    bool canPause = false;
    bool canAddCalibrationPoints = false;
    GeneralSettings generalSettings;
    SceneWidget* activeScene;

private slots:
    void emitMarkersReady();
    
    void graphSettingsChanged();

    void removeScenes();

    void requestStatistics(FrameTime start, FrameTime stop, int points)
    {
        emit statisticsRequested(start, stop, points);
    }

    void changeActiveScene(SceneWidget* newActiveScene);

    void on_buttonStart_clicked();

    void on_actionOpen_video_triggered();

    void on_actionRefresh_cameras_triggered();

    void on_cancelButton_clicked();

    void on_actionSettings_triggered();

    void on_actionOpen_link_triggered();

    void on_actionAbout_triggered();

    void on_addStreamButton_clicked();

    void on_addVideoFileButton_clicked();

    void on_stopButton_clicked();

    void on_horizontalSliderHeight_sliderMoved(int position);

    void on_lineEditHeight_returnPressed();

    void on_horizontalSliderXRot_sliderMoved(int position);

    void on_lineEditXRot_returnPressed();

    void on_horizontalSliderYRot_sliderMoved(int position);

    void on_lineEditYRot_returnPressed();

    void on_horizontalSliderZRot_sliderMoved(int position);

    void on_lineEditZRot_returnPressed();

    void on_horizontalSliderFov_sliderMoved(int position);

    void on_lineEditFov_returnPressed();

    void on_actionOpen_existing_measurement_triggered();

    void on_actionNew_measurement_triggered();

    void on_sourceList_itemSelectionChanged();

    void on_actionRedo_current_measurement_triggered();

    void on_pauseButton_clicked();
    
    void on_continueButton_clicked();
    
    void on_pushButtonDefaultConfig_clicked();

protected:
    virtual void changeEvent(QEvent* event);

    virtual void closeEvent(QCloseEvent* event);

    virtual void moveEvent(QMoveEvent* event);

    virtual void resizeEvent(QResizeEvent* event);

signals:
    void calculationCancelRequested();
    
    void calculationContinueRequested();
    
    void calculationPauseRequested();
    
    void calculationStartRequested();
    
    void calculationStopRequested();
    
    void calibrationPointsReady(
        const std::vector<cavapa::CalibrationPoint>& points);
    
    void generalSettingsChanged(const GeneralSettings& settings);
    
    void graphPositionSelected(FrameTime time);
    
    void locationChanged(int x, int y);
    
    void markersReady(const std::vector<GraphMarker>& markers);
    
    void metadataOpened(const std::string& path);
    
    void metadataReady(const Metadata& metadata);
    
    void newMeasurementRequested();
    
    void openMeasurementRequested(const std::string& path);
    
    void redoMeasurementRequested();
    
    void refreshRequested();
    
    void sizeChanged(int width, int height, bool fullscreen);
    
    void sourceAddRequested(const std::string& path);
    
    void sourcePauseRequested(SourceID source);
    
    void sourcePlayRequested(SourceID source);
    
    void sourceRemoveRequested(SourceID source);
    
    void sourceSeekRequested(SourceID source, FrameTime position);
    
    void sourceSettingsChanged(SourceID source, const SourceSettings& settings);
    
    void sourceStepBackward(SourceID source);
    
    void sourceStepForward(SourceID source);
    
    void statisticsRequested(FrameTime start, FrameTime stop, int points);
    
    void interfaceClosed();
    
    void exportRequested(const ExportOptions& options);
};
} // namespace

#endif // MAINWINDOW_H