Initial commit

Lts/Plugins/AudioVideoManagement/Gui/AVMenuEdit/avm_playback_menu.h

@@ -0,0 +1,223 @@
+/**
+  * @RDE_HEADER@
+  * AvmPlaybackMenu
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Fröbel, SLSE, 2017-06-26
+  */
+
+#pragma once
+
+#include "ui_avm_playback_menu.h"
+#include "interval_model.h"
+#include <LtsSession/lts_session.h>
+#include <AudioVideoManagement/ava_types.h>
+#include <AudioVideoManagement/Shared/playback_app.h>
+#include <AudioVideoManagement/logger.h>
+#include <MarkerManagement/mrk_ftc.h>
+#include <QString>
+#include <boost/optional.hpp>
+#include <memory>
+
+
+namespace MarkerManagement
+{
+class MarkerManagementDialogModel;
+class MarkerSortFilterProxyModel;
+class ForeignDataInterface;
+}
+
+namespace LtsUtils
+{
+class RequestHelper;
+}
+
+
+namespace AudioVideoManagement
+{
+
+class AvaSession;
+class AvaControl;
+class AvsSequence;
+class StreamNameMapping;
+class AvmPlaybackMenu;
+
+
+class QueryTimeline : public QObject
+{
+  Q_OBJECT
+private:
+  friend class AvmPlaybackMenu;
+
+  QueryTimeline(const AvaStream &stream, const AvaTimePoint &start, const AvaTimePoint &end, AvaControl *control);
+
+  AvaControl *m_avaCtrl { nullptr };
+
+private slots:
+  //void slotTimelineComplete(const AvaTimeline &timeline);
+
+signals:
+  void signalTimelineComplete(const AvaTimeline &timeline);
+};
+
+
+class AvmPlaybackMenu : public QWidget,
+    protected MarkerManagement::Interface::Ftc::MarkerModifyReplyHandler
+{
+  Q_OBJECT
+
+public:
+  explicit AvmPlaybackMenu(QWidget *parent = nullptr);
+  ~AvmPlaybackMenu();
+
+  bool init(LtsSession::LtsSession *session, AvaSession *avaSession, PlaybackAppHandle &&appHandle,
+            StreamNameMapping* streamNameMapping,  bool isAudio, bool insideTopicEditor,
+            const boost::optional<QString> &streamName = boost::none,
+            const boost::optional<AvaTimePoint> &startTime = boost::none, bool setInitialSearchContentMarkers = true);
+
+  void setPlaybackPreset(const QString &streamName, const AvaTimePoint &startTime, bool autostartPresetAfterInit);
+  void setMarkerPreset(int markerId, bool autostartPresetAfterInit);
+
+  QueryTimeline *queryTimeline(const AvaTimePoint &start, const AvaTimePoint &end);
+
+  void onMarkerModifyReply(const Core::FunctionReplyObject &replyObject) override final;
+
+  void retranslate();
+
+  //void setStreamTime(AvaTimePoint t);
+  void setStreamTime(qint64 time);
+  void hideStreamSelection();
+  qint64 getCurrentTime() const;
+  AvaSpeed getSpeed() const;
+  void setSpeed(AvaSpeed newSpeed);
+  int getVolume() const;
+  void setVolume(int newVolume);
+  void setStreamByName(const QString &name);
+  //QString selectedStreamName() const;
+  QString getInternalStreamName() const;
+  void setStreamName(const QString &internalStreamName);
+  bool getSkipPause() const;
+  void setSkipPause(bool bSkip);
+  void startPlayback(bool usePresets = false);
+  void setSavedPos(qint64 msecs);
+  int currentOffset() const { return m_currentOffset; }
+  void selectMarker(const MarkerManagement::Marker &marker);
+  void selectMarker(int markerId);
+
+signals:
+  void signalSetOverlay(QWidget *widget);
+  void signalUnsetOverlay();
+
+  void setTopicButtonStates(bool enable);
+  void markerSelected(const QString &description);
+
+  // both for topic editor
+  void signalSetStart(qint64 start);
+  void signalSetEnd(qint64 end);
+  void signalCurrentStreamChanged(const QString &displayName);
+  void signalTimezoneChanged(int timezoneHoursOffset);
+
+public slots:
+  void onStreamSelectionChanged(const QVector<AvaStream> &selectedStreams);
+
+private slots:
+  void onSessionEstablished();
+  void onDisconnected();
+
+  void onStreamListReceived(const QVector<AvaStream> &streams);
+  void onTimelineComplete(const AvaTimeline &timeline);
+  void onStreamPositionReceived(const QString &dialogId, const QString &streamName, AvaTimePoint);
+  void onVolumeReceived(AvaVolume db);
+  void onCommandQueueEmpty();
+
+  void onUiTimeChanged(AvaTimePoint t);
+  void onIntervalActivated(const QModelIndex &index);
+  void onMarkerClicked(const QModelIndex &index);
+  void onSetMarkerClicked();
+  void onStartClicked();
+  void onPauseClicked();
+  void onStopClicked();
+  void onSkipPauseClicked();
+  void onAllStreams();
+  void onIntervalBackwardClicked();
+  void onIntervalForwardClicked();
+  void onSpeedChanged();
+  void onVolumeChanged(int percent);
+  void onCurrentIntervalChanged(bool hasPreviousInterval, bool hasNextInterval, const QModelIndex &rowIndex);
+  void onStreamSelected();
+  void onMarkerStreamSelected();
+  void onStreamNameMappingChanged(/*int32_t mountingPointId, const QString &internalName, const QString &displayName*/);
+  void onAddStreamClip();
+  void onAddStreamMarker();
+  void onRemoveSelectedStreams();
+  void onTabChanged(int index);
+  void onPauseFromPlaybackApp();
+  void onResumeFromPlaybackApp();
+
+
+private:
+  enum class ButtonStates
+  {
+    AllOff,  //!< initial state when no stream is selected or when disconnected
+    Started,
+    Paused,
+    Stopped
+  };
+
+  void processPresets();
+  void preselectStream(const QString &fallbackInternalStreamName);
+  AvaSpeed currentSpeed() const;
+  void setButtonStates(ButtonStates);
+  void enableAll(bool enabled = true);
+  void disableAll() { enableAll(false); }
+  bool trySelectedStreams();
+  void addStream(QComboBox *cb);
+
+  void applyAvsPos();
+  void applyAvsVolume();
+  //void onStreamListReceived(const QVector<AvaStream> &streams);
+
+  PlaybackAppHandle                                                m_playbackApp;
+  bool                                                             m_isAudio = false;
+  StreamNameMapping                                               *m_streamNameMapping = nullptr;
+  boost::optional<QString>                                         m_presetStreamName;
+  boost::optional<int>                                             m_markerIdPreset;
+  boost::optional<AvaTimePoint>                                    m_presetStartTime;
+
+  class TimelineBuilder;
+  std::unique_ptr<TimelineBuilder>                                 m_timelineBuilder;
+
+  std::unique_ptr<Ui::Playback>                                    m_ui;
+
+  class TimeControl;
+  std::unique_ptr<TimeControl>                                     m_timeControl;
+
+  boost::optional<QVector<AvaStream>>                              m_selectedStreams;
+  IntervalModel                                                    m_intervalModel;
+  boost::optional<AvaTimePoint>                                    m_savedPos;
+  std::unique_ptr<MarkerManagement::MarkerManagementDialogModel>   m_markerModel;
+  std::unique_ptr<MarkerManagement::MarkerSortFilterProxyModel>    m_markerProxy;
+  AvaControl                                                      *m_avaCtrl = nullptr;
+  LtsSession::LtsSession                                          *m_session = nullptr;
+  bool                                                             m_skipEmpty = true;
+  ButtonStates                                                     m_currentButtonState;
+  std::shared_ptr<MarkerManagement::ForeignDataInterface>          m_mrkDataIfc;
+  boost::optional<AvaTimePoint>                                    m_lastAvsPos;
+  boost::optional<AvaVolume>                                       m_lastAvsVolume;
+  std::unique_ptr<LtsUtils::RequestHelper>                         m_requestHelper;
+  QVector<AvaStream>                                               m_streams;
+  boost::optional<AvaStream>                                       m_currentStream;
+  bool m_autostartOnce { false };
+  int                                                              m_maxSelectedStreams = 12;
+  bool m_queryTimelineActive { false };
+  int m_currentOffset = 0;
+
+  bool m_videoScreenSelectionDone { false };
+  bool m_timelineIsComplete { false };
+  ButtonStates m_buttonStateBeforePlaybackAppPause { ButtonStates::AllOff };
+
+  LOGGER_T m_logger;
+};
+
+} // namespace AudioVideoManagement