197 lines
9.0 KiB
C++
197 lines
9.0 KiB
C++
#pragma once
|
|
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <string>
|
|
#include <memory>
|
|
#include <SDL3/SDL.h>
|
|
#include "utils.h"
|
|
|
|
class Text;
|
|
|
|
class ServiceMenu
|
|
{
|
|
public:
|
|
// --- Métodos de Singleton ---
|
|
static void init(); // Inicializa la instancia única de ServiceMenu
|
|
static void destroy(); // Libera la instancia única de ServiceMenu
|
|
static ServiceMenu *get(); // Devuelve el puntero a la instancia única
|
|
|
|
// --- Métodos principales ---
|
|
void toggle(); // Muestra u oculta el menú de servicio
|
|
void render(); // Dibuja el menú de servicio en pantalla
|
|
void update(); // Actualiza el estado del menú de servicio
|
|
|
|
// --- Métodos de control de navegación ---
|
|
void setSelectorUp(); // Mueve el selector hacia arriba
|
|
void setSelectorDown(); // Mueve el selector hacia abajo
|
|
void adjustOption(bool adjust_up); // Ajusta el valor de la opción seleccionada
|
|
void selectOption(); // Selecciona la opción actual
|
|
void moveBack(); // Vuelve al grupo de opciones anterior
|
|
|
|
// --- Getters ---
|
|
bool isEnabled() const { return enabled_; } // Indica si el menú de servicio está activo
|
|
|
|
private:
|
|
// --- Tipos internos ---
|
|
using OptionPairs = std::vector<std::pair<std::string, std::string>>;
|
|
|
|
// --- Constantes ---
|
|
static constexpr const char *MENU_SOUND_ = "clock.wav"; // Sonido al navegar por el menú
|
|
static constexpr int OPTIONS_HORIZONTAL_PADDING_ = 20; // Relleno horizontal de las opciones
|
|
|
|
// --- Enumeraciones internas ---
|
|
enum class Aspect
|
|
{
|
|
ASPECT1, // Fondo opaco y proyecta sombra
|
|
ASPECT2 // Fondo translúcido
|
|
};
|
|
|
|
enum class SettingsGroup
|
|
{
|
|
VIDEO, // Configuraciones de vídeo
|
|
AUDIO, // Opciones de audio
|
|
GAME, // Opciones de juego
|
|
SYSTEM, // Opciones del sistema
|
|
MAIN // Menú principal
|
|
};
|
|
|
|
enum class OptionBehavior
|
|
{
|
|
ADJUST, // Modificable con izquierda/derecha
|
|
SELECT // Activable con ENTER
|
|
};
|
|
|
|
enum class ValueType
|
|
{
|
|
BOOL, // Valor booleano
|
|
INT, // Valor entero
|
|
FOLDER, // Referencia a otro grupo
|
|
NONE // Sin valor asociado
|
|
};
|
|
|
|
enum class GroupAlignment
|
|
{
|
|
CENTERED, // Opciones centradas
|
|
LEFT // Opciones alineadas a la izquierda
|
|
};
|
|
|
|
// --- Estructura de opción del menú ---
|
|
struct OptionEntry
|
|
{
|
|
std::string caption; // Texto visible en el menú
|
|
SettingsGroup group; // Categoría de la opción
|
|
OptionBehavior behavior; // Cómo se interactúa con la opción
|
|
void *linked_variable; // Puntero a la variable que controla la opción
|
|
ValueType type; // Tipo de la variable (bool, int, folder, none)
|
|
|
|
int min_value; // Valor mínimo (solo aplicable si type == INT)
|
|
int max_value; // Valor máximo (solo aplicable si type == INT)
|
|
int step_value; // Incremento al modificar la opción (solo aplicable si type == INT)
|
|
|
|
SettingsGroup target_group; // Grupo al que hace referencia la opción si es de tipo FOLDER
|
|
|
|
// Constructor para opciones de tipo BOOL, NONE o FOLDER
|
|
OptionEntry(std::string cap, SettingsGroup grp, OptionBehavior beh, void *var, ValueType t)
|
|
: caption(cap), group(grp), behavior(beh), linked_variable(var), type(t),
|
|
min_value(0), max_value(0), step_value(0), target_group(SettingsGroup::SYSTEM) {}
|
|
|
|
// Constructor para opciones de tipo INT con valores mínimos, máximos e incremento
|
|
OptionEntry(std::string cap, SettingsGroup grp, OptionBehavior beh, void *var, ValueType t, int min, int max, int step)
|
|
: caption(cap), group(grp), behavior(beh), linked_variable(var), type(t),
|
|
min_value(min), max_value(max), step_value(step), target_group(SettingsGroup::SYSTEM) {}
|
|
|
|
// Constructor para opciones de tipo FOLDER que referencian otro grupo
|
|
OptionEntry(std::string cap, SettingsGroup grp, OptionBehavior beh, SettingsGroup tgtGrp)
|
|
: caption(cap), group(grp), behavior(beh), linked_variable(nullptr), type(ValueType::FOLDER),
|
|
min_value(0), max_value(0), step_value(0), target_group(tgtGrp) {}
|
|
|
|
// Método para modificar el valor de la opción
|
|
void adjustValue(bool adjust_up)
|
|
{
|
|
if (linked_variable)
|
|
{
|
|
if (type == ValueType::INT)
|
|
{
|
|
int &value = *(static_cast<int *>(linked_variable));
|
|
int newValue = adjust_up ? value + step_value : value - step_value;
|
|
value = std::clamp(newValue, min_value, max_value);
|
|
}
|
|
else if (type == ValueType::BOOL)
|
|
{
|
|
bool &value = *(static_cast<bool *>(linked_variable));
|
|
value = !value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Método para obtener el valor como string
|
|
std::string getValueAsString() const
|
|
{
|
|
switch (type)
|
|
{
|
|
case ValueType::BOOL:
|
|
return (*(static_cast<bool *>(linked_variable))) ? "ON" : "OFF";
|
|
case ValueType::INT:
|
|
return std::to_string(*(static_cast<int *>(linked_variable)));
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
};
|
|
|
|
// --- Variables internas ---
|
|
bool enabled_ = false; // Indica si el menú de servicio está activo
|
|
SDL_FRect rect_; // Rectángulo que define el área del menú de servicio
|
|
std::shared_ptr<Text> element_text_; // Objeto para escribir el texto de los elementos
|
|
std::shared_ptr<Text> title_text_; // Objeto para escribir el texto del título
|
|
size_t selected_ = 0; // Índice del elemento del menú seleccionado
|
|
Uint32 counter_ = 0; // Contador interno
|
|
std::vector<OptionEntry> options_; // Listado con todas las opciones del menú de servicio
|
|
std::vector<OptionEntry> display_options_; // Opciones actualmente mostradas en pantalla
|
|
OptionPairs option_pairs_; // Opciones actuales del menú (filtradas por grupo)
|
|
SettingsGroup current_settings_group_; // Grupo de opciones actualmente activo
|
|
SettingsGroup previous_settings_group_; // Grupo de opciones anterior
|
|
Aspect aspect_ = Aspect::ASPECT2; // Estilo visual del menú
|
|
|
|
// --- Variables de aspecto ---
|
|
Color bg_color_ = SERV_MENU_BG_COLOR; // Color de fondo
|
|
Color title_color_ = SERV_MENU_TITLE_COLOR; // Color del título del menú
|
|
Color text_color_ = SERV_MENU_TEXT_COLOR; // Color del texto de los elementos
|
|
Color selected_color_ = SERV_MENU_SELECTED_COLOR; // Color del elemento seleccionado
|
|
int width_; // Ancho del menú
|
|
int height_; // Alto del menú
|
|
int line_height_; // Espacio entre elementos del menú
|
|
|
|
// --- Métodos internos: Anclaje y aspecto ---
|
|
void setAnchors(); // Establece el valor de las variables de anclaje
|
|
Color getSelectedColor() const; // Devuelve el color del elemento seleccionado
|
|
|
|
// --- Métodos internos: Gestión de opciones ---
|
|
void initializeOptions(); // Crea todas las opciones del menú de servicio
|
|
OptionPairs getOptionPairs(SettingsGroup group) const; // Devuelve las opciones como pares de strings para un grupo
|
|
std::vector<OptionEntry> getOptionsByGroup(SettingsGroup group) const; // Devuelve las opciones de un grupo
|
|
|
|
// --- Métodos internos: Lógica de menú ---
|
|
void applySettings(SettingsGroup group); // Aplica la configuración de un grupo
|
|
void updateMenu(SettingsGroup group); // Actualiza las opciones mostradas según el grupo
|
|
void reset(); // Reinicia el menú al estado inicial
|
|
|
|
// --- Métodos internos: Utilidades ---
|
|
void updateCounter(); // Actualiza el contador interno
|
|
int calculateMenuHeight() const; // Calcula la altura del menú
|
|
int findLargestGroupSize() const; // Devuelve el tamaño del grupo más grande
|
|
GroupAlignment getGroupAlignment(SettingsGroup group) const; // Devuelve la alineación del grupo
|
|
|
|
// --- Patrón Singleton ---
|
|
ServiceMenu(); // Constructor privado
|
|
~ServiceMenu() = default; // Destructor privado
|
|
ServiceMenu(const ServiceMenu &) = delete; // Evita la copia
|
|
ServiceMenu &operator=(const ServiceMenu &) = delete; // Evita la asignación
|
|
|
|
// --- Instancia Singleton ---
|
|
static ServiceMenu *instance_; // Instancia única del menú de servicio
|
|
|
|
// --- Método para reproducir el sonido del menú ---
|
|
void playMenuSound(); // Reproduce el sonido del menú
|
|
}; |