forked from Support/sp-hydra-veil-gui
262 lines
10 KiB
Python
262 lines
10 KiB
Python
from core.controllers.ProfileController import ProfileController
|
|
from core.services.profiles.attribute_filters import protocol_matches_profile_type, app_or_display_matches_profile_type
|
|
from core.controllers.profile_state.data_filters import protocol_is_supported_for_location
|
|
from gui.v2.presenters.data.location_data import get_location_display_data
|
|
from gui.v2.presenters.data.app_data import get_app_display_data
|
|
from gui.v2.presenters.data.protocol_data import get_protocol_button_data
|
|
from gui.v2.presenters.data.resolution_data import get_resolution_data, validate_selected_resolution
|
|
from gui.v2.presenters.data.type_data import get_profile_type_data
|
|
from gui.v2.presenters.image_tools.button_factory import create_button_image, create_resolution_button_image, blank_button
|
|
from core.errors.logger import logger
|
|
|
|
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
class RegistrationState:
|
|
def __init__(self, btn_path, profile_id: Optional[int] = None):
|
|
self.btn_path = btn_path
|
|
self.all_options = {}
|
|
self.selections = {}
|
|
self.order_map = {}
|
|
self.pixmap_cache = {}
|
|
self.profile_id = profile_id
|
|
|
|
# Maps a category to the function that validates its current selection.
|
|
self._filter_map = {
|
|
"protocol": self.is_protocol_valid,
|
|
"browser": self.is_app_valid,
|
|
"resolution": self.is_resolution_valid,
|
|
}
|
|
|
|
# Maps a "Trigger" category to the categories it affects.
|
|
self._dependency_map = {
|
|
"type": ["protocol", "browser", "resolution"],
|
|
"location": ["protocol"],
|
|
}
|
|
|
|
# Callbacks to notify the UI. Store functions here: { "Category": callback_func }
|
|
self.listeners = {}
|
|
|
|
# Gets this profile's available data:
|
|
if self.profile_id is not None:
|
|
logger.info(f"RegistrationState got a profile id of {self.profile_id}")
|
|
default_data = ProfileController.get_default_state_dict(profile_id)
|
|
else:
|
|
default_data = None
|
|
|
|
# Gets ALL available data:
|
|
self._load_all_data(default_data)
|
|
|
|
|
|
def register_listener(self, category, callback):
|
|
"""UI elements call this to be notified when their category changes."""
|
|
self.listeners[category] = callback
|
|
|
|
|
|
def _no_premade_choices(self, category: str, default_data: Optional[dict]):
|
|
"""For categories without premade choices, we see if default data is available. If not, then it's None"""
|
|
if default_data:
|
|
self.selections[category] = default_data.get(category)
|
|
else:
|
|
self.selections[category] = None
|
|
|
|
|
|
def _load_all_data(self, default_data: Optional[dict] = None):
|
|
"""Load the data for a given category, and then register that data"""
|
|
load_config = {
|
|
"type": (get_profile_type_data, 0),
|
|
"protocol": (get_protocol_button_data, 0),
|
|
"resolution": (get_resolution_data, 0),
|
|
"location": (get_location_display_data, 0),
|
|
"browser": (get_app_display_data, 0),
|
|
"name": (None, None)
|
|
}
|
|
for category, (loader_func, default_idx) in load_config.items():
|
|
if loader_func is None:
|
|
self._no_premade_choices(category=category, default_data=default_data)
|
|
continue
|
|
|
|
data = loader_func(self.btn_path)
|
|
self._register_category(category=category, data=data, default_data=default_data, default_idx=default_idx)
|
|
|
|
|
|
def _register_category(self, category: str, data: dict, default_data: Optional[dict], default_idx: int = 0):
|
|
"""Setup a category with a given data set and default index"""
|
|
if isinstance(data, list):
|
|
data = {item: item for item in data}
|
|
self.all_options[category] = data
|
|
self.order_map[category] = list(data.keys())
|
|
|
|
# Default selection logic
|
|
if default_data is not None:
|
|
# If default_data is provided, we use it exclusively.
|
|
# .get() returns None if the category key is missing.
|
|
self.selections[category] = default_data.get(category)
|
|
else:
|
|
# Fall back to index-based selection only if default_data was not provided.
|
|
ids = self.order_map[category]
|
|
self.selections[category] = ids[default_idx] if ids and default_idx < len(ids) else (ids[0] if ids else None)
|
|
|
|
|
|
def _ensure_valid(self, category):
|
|
"""Generic validator: resets selection to first valid option, or None if none exist."""
|
|
filter_func = self._filter_map.get(category)
|
|
if not filter_func:
|
|
return
|
|
|
|
current_val = self.selections.get(category)
|
|
# If current selection is invalid (or None), try to find a replacement
|
|
if current_val is None or not filter_func(current_val):
|
|
found_valid = False
|
|
for candidate_id in self.order_map.get(category, []):
|
|
if filter_func(candidate_id):
|
|
self.selections[category] = candidate_id
|
|
found_valid = True
|
|
break
|
|
|
|
# If no valid option is found, set to None to trigger blank image
|
|
if not found_valid:
|
|
self.selections[category] = None
|
|
|
|
def cycle_selection(self, category, direction):
|
|
ids = self.order_map.get(category, [])
|
|
if not ids:
|
|
self.selections[category] = None
|
|
self._notify(category)
|
|
return None
|
|
|
|
current_id = self.selections.get(category)
|
|
current_index = ids.index(current_id) if current_id in ids else 0
|
|
filter_func = self._filter_map.get(category)
|
|
|
|
found_valid = False
|
|
for i in range(1, len(ids) + 1):
|
|
next_index = (current_index + (i * direction)) % len(ids)
|
|
candidate_id = ids[next_index]
|
|
if filter_func is None or filter_func(candidate_id):
|
|
self.selections[category] = candidate_id
|
|
found_valid = True
|
|
break
|
|
|
|
# If we cycled through everything and found nothing valid, set to None
|
|
if not found_valid:
|
|
self.selections[category] = None
|
|
|
|
# Reactive Updates
|
|
dependents = self._dependency_map.get(category, [])
|
|
|
|
# 1. Notify the category that was just cycled
|
|
self._notify(category)
|
|
|
|
# 2. Check and notify all dependents (e.g., Type -> Browser)
|
|
for dep in dependents:
|
|
self._ensure_valid(dep)
|
|
self._notify(dep)
|
|
|
|
return self.get_current_image(category)
|
|
|
|
def _notify(self, category):
|
|
"""Triggers the UI callback for a specific category."""
|
|
if category in self.listeners:
|
|
self.listeners[category]()
|
|
|
|
|
|
def get_current_image(self, category):
|
|
"""Returns an image or a path to one depending on the category and data format"""
|
|
|
|
current_id = self.selections.get(category)
|
|
|
|
if current_id is None:
|
|
return blank_button(self.btn_path)
|
|
|
|
# Cache check
|
|
cache_key = f"{category}_{current_id}"
|
|
if cache_key in self.pixmap_cache:
|
|
return self.pixmap_cache[cache_key]
|
|
|
|
# 1. HANDLE DYNAMIC CATEGORIES FIRST
|
|
# These categories build images from the ID itself and don't need a lookup table
|
|
if category == "resolution":
|
|
res_img = create_resolution_button_image(
|
|
btn_path=f"{self.btn_path}/resolution_template.png",
|
|
resolution_text=str(current_id)
|
|
)
|
|
self.pixmap_cache[cache_key] = res_img
|
|
return res_img
|
|
|
|
# 2. HANDLE DATA-DRIVEN CATEGORIES
|
|
# Only perform the lookup for categories that actually use the all_options dictionary
|
|
try:
|
|
data = self.all_options[category][current_id]
|
|
except KeyError:
|
|
print(f"Error: {current_id} not found in {category} options. Returning blank.")
|
|
return blank_button(self.btn_path)
|
|
|
|
if data is None:
|
|
return blank_button(self.btn_path)
|
|
|
|
if isinstance(data, Path):
|
|
return data
|
|
|
|
if isinstance(data, dict):
|
|
pixmap = create_button_image(
|
|
first_line=data.get('name', ''),
|
|
fallback_image_path=data.get('path'),
|
|
second_line=data.get('second_line'),
|
|
existing_icon_path=data.get('existing_icon')
|
|
)
|
|
self.pixmap_cache[cache_key] = pixmap
|
|
return pixmap
|
|
else:
|
|
return blank_button(self.btn_path)
|
|
|
|
# Validation logic, used by the generic _ensure_valid
|
|
def is_app_valid(self, app_choice):
|
|
current_type = self.selections.get("type")
|
|
return app_or_display_matches_profile_type(app_choice=app_choice, profile_type=current_type)
|
|
|
|
def is_protocol_valid(self, protocol_id):
|
|
"""Checks if a protocol is valid by the other choices of type and location."""
|
|
current_type = self.selections.get("type")
|
|
current_location = self.selections.get("location")
|
|
|
|
if not protocol_matches_profile_type(protocol=protocol_id, profile_type=current_type):
|
|
return False
|
|
|
|
return protocol_is_supported_for_location(location_id=current_location, protocol_choice=protocol_id)
|
|
|
|
def is_resolution_valid(self, resolution_choice):
|
|
current_type = self.selections.get("type")
|
|
|
|
# same criteria as app:
|
|
if not app_or_display_matches_profile_type(app_choice=resolution_choice, profile_type=current_type):
|
|
return False
|
|
|
|
# plus size filter:
|
|
return validate_selected_resolution(resolution_choice)
|
|
|
|
def get_final_choices(self):
|
|
return self.selections
|
|
|
|
def set_selection(self, category, value):
|
|
"""Manually set a selection, validate it, and notify listeners."""
|
|
|
|
# 1. Validate the choice using the existing filter map
|
|
filter_func = self._filter_map.get(category)
|
|
if filter_func and not filter_func(value):
|
|
print(f"Invalid selection for {category}: {value}")
|
|
return False
|
|
|
|
# 2. Update the selection
|
|
self.selections[category] = value
|
|
|
|
# 3. Trigger reactive updates for dependents (e.g., if Type changed)
|
|
dependents = self._dependency_map.get(category, [])
|
|
for dep in dependents:
|
|
self._ensure_valid(dep)
|
|
self._notify(dep)
|
|
|
|
# 4. Notify the UI for this category
|
|
self._notify(category)
|
|
return True
|