canvas_usage_tracker.h

Go to the documentation of this file.

#ifndef YAZE_APP_GUI_CANVAS_CANVAS_USAGE_TRACKER_H
#define YAZE_APP_GUI_CANVAS_CANVAS_USAGE_TRACKER_H
 
#include <chrono>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
enum class CanvasUsage {
  kTilePainting,        // Drawing tiles on canvas
  kTileSelecting,       // Selecting tiles from canvas
  kSelectRectangle,     // Rectangle selection mode
  kColorPainting,       // Color painting mode
  kBitmapEditing,       // Direct bitmap editing
  kPaletteEditing,      // Palette editing mode
  kBppConversion,       // BPP format conversion
  kPerformanceMode,     // Performance monitoring mode
  kEntityManipulation,  // Generic entity manipulation
                        // (insertion/editing/deletion)
  kUnknown              // Unknown or mixed usage
};
 
enum class CanvasInteraction {
  kMouseClick,
  kMouseDrag,
  kMouseRelease,
  kKeyboardInput,
  kContextMenu,
  kModalOpen,
  kModalClose,
  kToolChange,
  kModeChange
};
 
struct CanvasUsageStats {
  CanvasUsage usage_mode = CanvasUsage::kUnknown;
  std::chrono::steady_clock::time_point session_start;
  std::chrono::milliseconds total_time{0};
  std::chrono::milliseconds active_time{0};
  std::chrono::milliseconds idle_time{0};
 
  // Interaction counts
  int mouse_clicks = 0;
  int mouse_drags = 0;
  int context_menu_opens = 0;
  int modal_opens = 0;
  int tool_changes = 0;
  int mode_changes = 0;
 
  // Performance metrics
  double average_operation_time_ms = 0.0;
  double max_operation_time_ms = 0.0;
  int total_operations = 0;
 
  // Canvas state
  ImVec2 canvas_size = ImVec2(0, 0);
  ImVec2 content_size = ImVec2(0, 0);
  float global_scale = 1.0F;
  float grid_step = 32.0F;
  bool enable_grid = true;
  bool enable_hex_labels = false;
  bool enable_custom_labels = false;
 
  void Reset() {
    usage_mode = CanvasUsage::kUnknown;
    session_start = std::chrono::steady_clock::now();
    total_time = std::chrono::milliseconds{0};
    active_time = std::chrono::milliseconds{0};
    idle_time = std::chrono::milliseconds{0};
    mouse_clicks = 0;
    mouse_drags = 0;
    context_menu_opens = 0;
    modal_opens = 0;
    tool_changes = 0;
    mode_changes = 0;
    average_operation_time_ms = 0.0;
    max_operation_time_ms = 0.0;
    total_operations = 0;
  }
};
 
class CanvasUsageTracker {
 public:
  CanvasUsageTracker() = default;
 
  void Initialize(const std::string& canvas_id);
 
  void SetUsageMode(CanvasUsage usage);
 
  void RecordInteraction(CanvasInteraction interaction,
                         const std::string& details = "");
 
  void RecordOperation(const std::string& operation_name, double time_ms);
 
  void UpdateCanvasState(const ImVec2& canvas_size, const ImVec2& content_size,
                         float global_scale, float grid_step, bool enable_grid,
                         bool enable_hex_labels, bool enable_custom_labels);
 
  const CanvasUsageStats& GetCurrentStats() const { return current_stats_; }
 
  const std::vector<CanvasUsageStats>& GetUsageHistory() const {
    return usage_history_;
  }
 
  std::string GetUsageModeName(CanvasUsage usage) const;
 
  ImVec4 GetUsageModeColor(CanvasUsage usage) const;
 
  std::vector<std::string> GetUsageRecommendations() const;
 
  std::string ExportUsageReport() const;
 
  void ClearHistory();
 
  void StartSession();
 
  void EndSession();
 
 private:
  std::string canvas_id_;
  CanvasUsageStats current_stats_;
  std::vector<CanvasUsageStats> usage_history_;
  std::chrono::steady_clock::time_point last_activity_;
  std::chrono::steady_clock::time_point session_start_;
 
  // Interaction history
  std::vector<std::pair<CanvasInteraction, std::string>> interaction_history_;
  std::unordered_map<std::string, std::vector<double>> operation_times_;
 
  // Helper methods
  void UpdateActiveTime();
  void UpdateIdleTime();
  void SaveCurrentStats();
  double CalculateAverageOperationTime(const std::string& operation_name) const;
  std::string FormatDuration(const std::chrono::milliseconds& duration) const;
};
 
class CanvasUsageManager {
 public:
  static CanvasUsageManager& Get();
 
  void RegisterTracker(const std::string& canvas_id,
                       std::shared_ptr<CanvasUsageTracker> tracker);
 
  std::shared_ptr<CanvasUsageTracker> GetTracker(const std::string& canvas_id);
 
  const std::unordered_map<std::string, std::shared_ptr<CanvasUsageTracker>>&
  GetAllTrackers() const {
    return trackers_;
  }
 
  CanvasUsageStats GetGlobalStats() const;
 
  std::string ExportGlobalReport() const;
 
  void ClearAllTrackers();
 
 private:
  CanvasUsageManager() = default;
  ~CanvasUsageManager() = default;
 
  std::unordered_map<std::string, std::shared_ptr<CanvasUsageTracker>>
      trackers_;
};
 
}  // namespace gui
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_CANVAS_CANVAS_USAGE_TRACKER_H