src/tasklist_table_model.h - QPixmapCache - waterstone/TaskList_Demo

src/tasklist_table_model.h
157 строк5 KB
Peter Sakhno
Move TaskWatcher from the model module to a saparete module
21 янв 2026, 18:10
21 янв 2026, 18:10ef15936
#ifndef TASKLIST_TABLE_MODEL_H
#define TASKLIST_TABLE_MODEL_H

#include <map>
#include <set>
#include <list>
#include <chrono>
#include <optional>

#include <QPointer>
#include <QBasicTimer>
#include <QTimerEvent>
#include <QFutureWatcher>
#include <QAbstractTableModel>

#include "task_watcher.h"
#include "tasklist_ranges.h"

class TaskListTableModel;
using TaskListTableModelQP = QPointer<TaskListTableModel>;

class TaskListTableModel : public QAbstractTableModel
{
  Q_OBJECT

public:
  enum Column {
    ColumnBegin = 0,
    //
    TimestampColumn = ColumnBegin,
    CaptionColumn,
    ProgressColumn,
    ActionColumn,
    //
    ColumnEnd
  };

  explicit TaskListTableModel (QObject* parent = nullptr);

  // Header:
  QVariant headerData (int section, Qt::Orientation orientation,
                       int role = Qt::DisplayRole) const override;

  // Basic functionality:
  int rowCount (const QModelIndex& parent = QModelIndex ()) const override;
  int columnCount (const QModelIndex& parent = QModelIndex ()) const override;

  // Data manipulation:
  QVariant data (const QModelIndex& index,
                 int role = Qt::DisplayRole) const override;
  bool setData(const QModelIndex& index, const QVariant& value,
               int role = Qt::EditRole) override;

  // Rows manipulation:
  bool insertRows(int row, int count,
                  const QModelIndex& parent = QModelIndex());
  bool removeRows(int row, int count,
                  const QModelIndex& parent = QModelIndex());

  // Custom data manipulation API:
  bool HasActiveRows() const;
  bool HasActiveRows(const std::set<int>& selected_rows) const;

  QString GenerateTaskName() const;

  void AddTask(QString caption);

  bool RemoveAll();
  bool RemoveSelected(const std::set<int>& selected_rows);
  void ActivateSelected(const std::set<int>& selected_rows, bool active);

  // Blocking:
  void StopAllTasks();

private slots:
  void OnTaskStarted();
  void OnTaskProgress();
  void OnTaskFinished();

private:
  QVariant GetDisplayRole(const QModelIndex& index) const;
  QVariant GetUserRole(const QModelIndex& index) const;

  struct Task {
    using id_type = qulonglong;
    id_type id{ 0 };          // Task ID, {0} - invalid
    qint64 timestamp{ 0 };    // Task creation date-time
    int duration{ 3 };        // Duration in seconds for task simulation;
                              //  for simplicity valid duration can be
                              //  [DurationRange::Min; DurationRange::Max] sec;
                              //  if duration is not
                              //  [DurationRange::Min; DurationRange::Max] sec,
                              //  then duration is invalid and task time is
                              //  indeterminate
    QString caption;          // Task caption
    bool active{ false };     // Task run state
    int progress{ ProgressRange::bad() }; // If !active, then progress is bad;
                              //  if active and valid duration, then progress
                              //  is [ProgressRange::Min; ProgressRange::Max];
                              //  if active and invalid duration, then progress
                              //  is used for infinite animation and is
                              //  [AnimationRange::Min; AnimationRange::Max]
  };

  using TaskList = std::list<Task>;

  void UpdateTask(Task::id_type task_id, bool active, int progress);
  void DeleteTaskWatcher(Task::id_type task_id);
  bool SwitchTaskState(Task& task, bool new_state);

  void AnimateTask(Task::id_type task_id, bool animate);

  void timerEvent(QTimerEvent* event) override;


  class TaskIdCounter {
  public:
    using value_type = Task::id_type;

    TaskIdCounter(const TaskList& task_list) : m_task_list(task_list) {
    }

    auto operator()() {
      if (m_task_list.empty())
        m_task_id_counter = kTaskIdStart;
      return m_task_id_counter++;
    }

    operator auto() const {
      return m_task_list.empty() ? kTaskIdStart : m_task_id_counter;
    }

  private:
    static constexpr Task::id_type kTaskIdStart{ 1 };
    Task::id_type m_task_id_counter{ kTaskIdStart };
    const TaskList& m_task_list;
  };

  TaskList m_task_list;
  TaskIdCounter m_task_id_counter{ m_task_list };
  std::map <Task::id_type, TaskWatcherQP> m_task_watchers;
  std::set<Task::id_type> m_indeterminate_task_list_animation;
  QBasicTimer m_indeterminate_task_list_animation_timer;
  const AnimationRange::value_type kAnimationStep{ 6 };
  const std::chrono::milliseconds kAnimationTime{ 25 };

protected:
  // For unit test purposes only
  auto GetTaskIdCounter() const {
    return static_cast<Task::id_type>(m_task_id_counter);
  }
  auto GetTaskListData() const {
    return m_task_list;
  }
};

#endif // TASKLIST_TABLE_MODEL_H