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 <string>
#include <vector>
#include <unordered_map>
#include <chrono>
#include <memory>
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
namespace canvas {
 
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
  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 canvas
}  // namespace gui
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_CANVAS_CANVAS_USAGE_TRACKER_H