hydraveil-gui/gui/v2/ui/pages/editor_page.py

1018 lines
41 KiB
Python
Executable file

import os
from PyQt6.QtWidgets import (
QLabel, QPushButton, QLineEdit, QTextEdit, QFrame, QDialog,
QVBoxLayout, QHBoxLayout, QMessageBox, QGraphicsDropShadowEffect
)
from PyQt6.QtGui import QPixmap, QIcon, QPainter, QColor, QTransform
from PyQt6.QtCore import Qt, QSize, QTimer, QPointF
from PyQt6 import QtCore, QtGui
from core.infrastructure.state_management.global_state_controller import is_synced
from core.controllers.ProfileController import ProfileController
from core.controllers.LocationController import LocationController
from core.models.Result import Result, ResultError
from core.controllers.profile_state.data_filters import get_supported_protocols_for_location
from core.models.BaseProfile import ProfileType
from gui.v2.ui.styles.css.editor_css import BUTTON_STYLE_ONE
from gui.v2.ui.pages.Page import Page
from gui.v2.ui.pages.browser_page import BrowserPage
from gui.v2.ui.pages.location_page import LocationPage
from gui.v2.ui.pages.screen_page import ScreenPage
from gui.v2.ui.popups.confirmation_popup import ConfirmationPopup
from gui.v2.ui.popups.error_popup import ErrorPopup
from gui.v2.workers.page_data_worker import PageDataWorker
from gui.v2.actions.menu_profiles import match_core_profiles
from gui.v2.actions.menu_coordinator import edit_profile, sync_now
class EditorPage(Page):
SINGBOX_PROTOCOLS = ("hysteria2", "vless")
PROTOCOL_BUTTON_ASSETS = {
"hysteria2": "hystria2",
}
def __init__(self, page_stack, main_window, prepared=None):
super().__init__("Editor", page_stack, main_window)
self.page_stack = page_stack
self.update_status = main_window
self.connection_manager = main_window.connection_manager
self.labels = []
self.buttons = []
self.title.setGeometry(570, 40, 185, 40)
self.title.setText("Edit Profile")
self.button_apply.setVisible(True)
self.button_apply.clicked.connect(self.go_selected)
self.button_back.setVisible(True)
try:
self.button_back.clicked.disconnect()
except TypeError:
pass
self.button_back.clicked.connect(self.go_back)
self.name_handle = QLabel(self)
self.name_handle.setGeometry(110, 70, 400, 30)
self.name_handle.setStyleSheet('color: #cacbcb;')
self.name_handle.setText("Profile Name:")
self.name_hint = QLabel(self)
self.name_hint.setGeometry(265, 100, 190, 20)
self.name_hint.setStyleSheet(
'color: #888888; font-size: 10px; font-style: italic;')
self.name_hint.setText("Click here to edit profile name")
self.name_hint.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
self.name = QLineEdit(self)
self.name.setPlaceholderText("Enter name")
self.name.setGeometry(265, 70, 190, 30)
self.name.setStyleSheet(
"color: cyan; border: 1px solid #666666; border-radius: 3px; background-color: rgba(0, 0, 0, 0.3);")
self.name.setCursor(QtCore.Qt.CursorShape.IBeamCursor)
self.name.focusInEvent = lambda event: self.name_hint.hide()
self.name.focusOutEvent = lambda event: self.name_hint.show(
) if not self.name.text() else self.name_hint.hide()
self.name.textChanged.connect(
lambda text: self.name_hint.hide() if text else self.name_hint.show())
self.temp_changes = {}
self.original_values = {}
self.res_hint_shown = False
self.display.setGeometry(QtCore.QRect(0, 60, 540, 405))
self.display.hide()
self.garaje = QLabel(self)
self.garaje.setGeometry(QtCore.QRect(0, 70, 540, 460))
self.brow_disp = QLabel(self)
self.brow_disp.setGeometry(QtCore.QRect(0, 50, 540, 460))
self.brow_disp.setPixmap(
QPixmap(os.path.join(self.btn_path, "browser only.png")))
self.brow_disp.hide()
self.brow_disp.lower()
self._prefetched_profiles = prepared
self._editor_workers = set()
self.is_synced = is_synced()
def showEvent(self, event):
"""Refresh data. This runs every time the widget is displayed"""
self.is_synced = is_synced()
@staticmethod
def prepare_data(custom_window):
return ProfileController.get_all()
def _selected_profiles_str(self):
menu_page = self.find_menu_page()
if menu_page is not None and menu_page.selected_profiles:
return ', '.join(
[f"Profile_{profile['profile_number']}" for profile in menu_page.selected_profiles])
profile_id = getattr(self.update_status, 'current_profile_id', None)
if profile_id is not None:
return f"Profile_{int(profile_id)}"
return ''
def update_name_value(self):
original_name = self.data_profile.get('name', '')
new_name = self.name.text()
if original_name != new_name:
self.update_temp_value('name', new_name)
else:
pass
def go_back(self):
selected_profiles_str = self._selected_profiles_str()
if self.has_unsaved_changes(selected_profiles_str):
self.show_unsaved_changes_popup()
else:
self.custom_window.navigator.navigate("menu")
def find_menu_page(self):
return self.custom_window.navigator.get_cached("menu")
def find_resume_page(self):
return self.custom_window.navigator.get_cached("resume")
def find_protocol_page(self):
return self.custom_window.navigator.get_cached("protocol")
def showEvent(self, event):
super().showEvent(event)
self.res_hint_shown = False
if self._selected_profile_in_cache():
self.extraccion()
return
worker = PageDataWorker("editor", EditorPage.prepare_data, self.custom_window)
worker.data_ready.connect(
lambda name, profiles: self._on_editor_data_ready(profiles))
worker.failed.connect(
lambda name, error: self._on_editor_data_failed(error))
worker.finished.connect(
lambda w=worker: self._cleanup_editor_worker(w))
self._editor_workers.add(worker)
worker.start()
def _on_editor_data_ready(self, profiles):
self._prefetched_profiles = profiles
self.extraccion()
def _on_editor_data_failed(self, error):
self.update_status.update_status(f"Editor data load failed: {error}")
self.extraccion()
def _cleanup_editor_worker(self, worker):
self._editor_workers.discard(worker)
worker.deleteLater()
def _selected_profile_in_cache(self):
if not self._prefetched_profiles:
return False
selected = self._selected_profiles_str()
if not selected:
return False
try:
profile_id = int(selected.split('_')[1])
except (IndexError, ValueError):
return False
return profile_id in self._prefetched_profiles
def extraccion(self):
self.data_profile = {}
for label in self.labels:
label.deleteLater()
self.labels = []
for button in self.buttons:
button.deleteLater()
self.buttons = []
selected_profiles_str = self._selected_profiles_str()
menu_page = self.find_menu_page()
if menu_page:
if self._prefetched_profiles is not None:
new_profiles = self._prefetched_profiles
else:
new_profiles = ProfileController.get_all()
self.profiles_data = match_core_profiles(
new_profiles,
getattr(self.update_status, "gui_config_file", None),
)
self.data_profile = self.profiles_data[selected_profiles_str].copy(
)
profile_id = int(selected_profiles_str.split('_')[1])
self.data_profile['id'] = profile_id
if selected_profiles_str in self.temp_changes:
for key, value in self.temp_changes[selected_profiles_str].items():
self.data_profile[key] = value
self.name.textChanged.connect(self.update_name_value)
self.evaluate_option_labels(self.data_profile, selected_profiles_str)
def evaluate_option_labels(self, data_profile, selected_profile_str):
"""Figure out which data can be changed, so the UI only displays those choices"""
protocol = data_profile.get("protocol", None)
profile_type = data_profile.get("connection", None)
location_codes = data_profile.get("location", None)
if not profile_type or not protocol or not location_codes:
error_msg = "This profile lacks a profile type, protocol, or location."
self.show_a_popup(message=error_msg, title="Missing fields")
return
print(f"in evaluate_option_labels, location_codes is {location_codes} and profile_type is {profile_type}")
supported_protocols_result = get_supported_protocols_for_location(location_codes=location_codes, profile_type=profile_type)
if not supported_protocols_result.valid:
error_msg = "This profile lacks supported locations."
self.show_a_popup(message=error_msg, title="Invalid location")
return
supported_protocols = supported_protocols_result.data
if not supported_protocols:
error_msg = "This profile lacks supported locations."
self.show_a_popup(message=error_msg, title="Invalid location")
if profile_type == "system-wide":
self.process_and_show_labels(data_profile, {
"protocol": supported_protocols,
"connection": ['system-wide'],
"location": self.connection_manager.get_location_list(),
}, selected_profile_str)
else:
# Session profiles can't change protocols yet.
self.process_and_show_labels(data_profile, {
"protocol": [protocol],
"connection": ['browser-only', 'system-wide'],
"location": self.connection_manager.get_location_list(),
"browser": self.connection_manager.get_browser_list(),
"dimentions": self.connection_manager.get_available_resolutions(data_profile.get('id', ''))
}, selected_profile_str)
# elif protocol in self.SINGBOX_PROTOCOLS:
# elif protocol == "residential" or protocol == "hidetor":
# self.process_and_show_labels(data_profile, {
# "protocol": ['residential', 'wireguard', 'hidetor'],
# "connection": ['tor', 'just proxy'],
# "location": self.connection_manager.get_location_list(),
# "browser": self.connection_manager.get_browser_list(),
# "dimentions": self.connection_manager.get_available_resolutions(data_profile.get('id', ''))
# }, selected_profile_str)
# elif protocol == "open":
# self.process_and_show_labels(data_profile, {
# "protocol": ['open']
# }, selected_profile_str)
def process_and_show_labels(self, data_profile, parameters, selected_profile_str):
"""Populate the images in the center of the arrows, on the right hand side, with relevant choices"""
protocol = data_profile.get('protocol', "")
connection = data_profile.get('connection', "")
location = data_profile.get('location', "")
profile_id = data_profile.get('id')
profile_obj = ProfileController.get(profile_id)
operator_name_string = profile_obj.location.operator.name
print(f"operator_name_string is {operator_name_string}")
country_garaje = location
name = data_profile.get('name', "")
self.name.setText(name)
if protocol == "hidetor":
if connection == "just proxy":
self.display.setPixmap(QPixmap(os.path.join(
self.btn_path, f"icon_{location}.png")))
else:
self.display.setPixmap(QPixmap(os.path.join(
self.btn_path, f"hdtor_{location}.png")))
self.display.show()
self.display.setGeometry(0, 100, 400, 394)
self.display.setScaledContents(True)
self.garaje.hide()
self.brow_disp.hide()
if protocol == "wireguard":
self.display.setGeometry(0, 60, 540, 405)
self.display.show()
self.display.setPixmap(QPixmap(os.path.join(
self.btn_path, f"wireguard_{location}.png")))
self.garaje.hide()
if connection == "browser-only":
is_supported = data_profile.get('browser_supported', False)
image_name = "browser only.png" if is_supported else "unsupported_browser_only.png"
self.brow_disp.setPixmap(
QPixmap(os.path.join(self.btn_path, image_name)))
self.brow_disp.show()
else:
self.brow_disp.hide()
if protocol in self.SINGBOX_PROTOCOLS:
if protocol == "vless":
self.display.setGeometry(0, 90, 540, 405)
else:
self.display.setGeometry(0, 60, 540, 405)
self.display.show()
# self.display.setPixmap(self._encrypted_proxy_display_pixmap(
# protocol, location).scaled(
if operator_name_string == 'Simplified Privacy':
singbox_image_path = f"{protocol}_{location}.png"
else:
singbox_image_path = "system_wide_global.png"
print(f"using singbox_image_path of {singbox_image_path}")
self.display.setPixmap(QPixmap(os.path.join(
self.btn_path, singbox_image_path)).scaled(
self.display.size(),
Qt.AspectRatioMode.KeepAspectRatio,
Qt.TransformationMode.SmoothTransformation))
self.garaje.hide()
self.brow_disp.hide()
if protocol == "residential":
self.display.setGeometry(0, 60, 540, 405)
self.brow_disp.show()
self.garaje.show()
self.display.hide()
if country_garaje:
country_garaje = 'brazil'
self.garaje.setPixmap(QPixmap(os.path.join(
self.btn_path, f"{country_garaje} garaje.png")))
# profile_id = data_profile.get('id')
# profile_obj = ProfileController.get(profile_id)
location_info = None
if location:
try:
if '_' in location:
country_code, location_code = location.split('_', 1)
location_info = LocationController.get(
country_code, location_code)
except Exception:
location_info = None
operator_name = ""
l_name = ""
o_name = ""
n_key = ""
if location_info:
if hasattr(location_info, 'operator') and location_info.operator:
operator_name = location_info.operator.name
o_name = location_info.operator.name
n_key = location_info.operator.nostr_public_key
l_name = f"{location_info.country_name}, {location_info.name}" if hasattr(
location_info, 'country_name') else ""
if operator_name != 'Simplified Privacy' and operator_name != "" and protocol not in ('hidetor', *self.SINGBOX_PROTOCOLS):
text_color = "white"
if profile_obj and profile_obj.is_session_profile():
text_color = "black"
l_img = QLabel(self)
l_img.setGeometry(20, 125, 150, 150)
pixmap_loc = QPixmap(os.path.join(
self.btn_path, f"icon_{location}.png"))
l_img.setPixmap(pixmap_loc)
l_img.setScaledContents(True)
l_img.show()
self.labels.append(l_img)
info_txt = QTextEdit(self)
info_txt.setGeometry(180, 120, 300, 250)
info_txt.setReadOnly(True)
info_txt.setFrameStyle(QFrame.Shape.NoFrame)
info_txt.setStyleSheet(
f"background: transparent; border: none; color: {text_color}; font-size: 19px;")
info_txt.setVerticalScrollBarPolicy(
Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
info_txt.setHorizontalScrollBarPolicy(
Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
info_txt.setWordWrapMode(
QtGui.QTextOption.WrapMode.WrapAtWordBoundaryOrAnywhere)
info_txt.setText(
f"Location: {l_name}\n\nOperator: {o_name}")
info_txt.show()
self.labels.append(info_txt)
nostr_txt = QTextEdit(self)
nostr_txt.setGeometry(20, 300, 450, 170)
nostr_txt.setReadOnly(True)
nostr_txt.setFrameStyle(QFrame.Shape.NoFrame)
nostr_txt.setStyleSheet(
f"background: transparent; border: none; color: {text_color}; font-size: 21px;")
nostr_txt.setVerticalScrollBarPolicy(
Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
nostr_txt.setHorizontalScrollBarPolicy(
Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
nostr_txt.setWordWrapMode(
QtGui.QTextOption.WrapMode.WrapAnywhere)
nostr_txt.setText(f"Nostr: {n_key}")
nostr_txt.show()
self.labels.append(nostr_txt)
for i, key in enumerate(parameters.keys()):
if key == 'browser':
browser_value = f"{data_profile.get(key, '')}"
split_value = browser_value.split(':', 1)
browser_type = split_value[0]
browser_version = split_value[1] if len(
split_value) > 1 else ''
browser_value = f"{browser_type} {browser_version}"
if browser_version == '':
browser_version = data_profile.get('browser_version', '')
browser_value = f"{browser_type} {browser_version}"
fallback_path = os.path.join(
self.btn_path, "default_browser_button.png")
normalized_browser = browser_value.strip().lower()
unknown_browser = (
not normalized_browser
or normalized_browser == "unknown"
or normalized_browser.startswith("unknown browser")
)
if connection == 'system-wide':
base_image = QPixmap()
elif unknown_browser:
base_image = QPixmap(fallback_path)
if base_image.isNull():
base_image = BrowserPage.create_browser_button_image(
"Browser", fallback_path, True)
else:
base_image = BrowserPage.create_browser_button_image(
browser_value, self.btn_path)
if base_image.isNull():
base_image = BrowserPage.create_browser_button_image(
browser_value, fallback_path, True)
elif key == 'location':
current_value = f"{data_profile.get(key, '')}"
image_path = os.path.join(
self.btn_path, f"button_{current_value}.png")
base_image = QPixmap(image_path)
locations = self.connection_manager.get_location_info(
current_value)
provider = locations.operator.name if locations and hasattr(
locations, 'operator') else None
fallback_path = os.path.join(
self.btn_path, "default_location_button.png")
if base_image.isNull():
if locations and hasattr(locations, 'country_name'):
location_name = locations.country_name
base_image = LocationPage.create_location_button_image(
location_name, fallback_path, provider)
else:
base_image = LocationPage.create_location_button_image(
current_value, fallback_path, provider)
else:
if locations and hasattr(locations, 'country_name'):
base_image = LocationPage.create_location_button_image(
f'{locations.country_code}_{locations.code}', fallback_path, provider, image_path)
else:
base_image = LocationPage.create_location_button_image(
current_value, fallback_path, provider, image_path)
elif key == 'dimentions':
current_value = f"{data_profile.get(key, '')}"
if current_value != 'None':
base_image = ScreenPage.create_resolution_button_image(
self, current_value)
else:
current_value = data_profile.get(key, '')
if key == 'protocol':
image_path = self._protocol_button_asset(current_value)
else:
image_path = os.path.join(
self.btn_path, f"{current_value}_button.png")
base_image = QPixmap(image_path)
if key == 'dimentions':
label = QPushButton(self)
label.setGeometry(565, 90 + i * 80, 185, 75)
label.setFlat(True)
label.setStyleSheet("border: none; background: transparent;")
original_icon = QIcon(base_image)
label.setIconSize(QSize(185, 75))
label.setCursor(QtCore.Qt.CursorShape.PointingHandCursor)
label.clicked.connect(self.show_custom_res_dialog)
template_path = os.path.join(
self.btn_path, "resolution_template_button.png")
template_pixmap = QPixmap(template_path).scaled(
187, 75) if os.path.exists(template_path) else None
if not getattr(self, 'res_hint_shown', False) and connection != 'system-wide':
self.res_hint_shown = True
if template_pixmap:
label.setIcon(QIcon(template_pixmap))
else:
label.setIcon(QIcon())
hint_label = QLabel("Click here to customize", label)
hint_label.setGeometry(15, 0, 155, 75)
hint_label.setWordWrap(True)
hint_label.setAlignment(
QtCore.Qt.AlignmentFlag.AlignCenter)
hint_label.setStyleSheet(
"color: #00ffff; font-weight: bold; font-size: 16px; background: transparent;")
hint_label.setCursor(
QtCore.Qt.CursorShape.PointingHandCursor)
hint_label.setAttribute(
QtCore.Qt.WidgetAttribute.WA_TransparentForMouseEvents)
shadow = QGraphicsDropShadowEffect(hint_label)
shadow.setBlurRadius(20)
shadow.setColor(QColor(0, 255, 255))
shadow.setOffset(0, 0)
hint_label.setGraphicsEffect(shadow)
def restore():
try:
if hint_label and not hint_label.isHidden():
hint_label.hide()
label.setIcon(original_icon)
except:
pass
QTimer.singleShot(3500, restore)
else:
label.setIcon(original_icon)
else:
label = QLabel(key, self)
label.setGeometry(565, 90 + i * 80, 185, 75)
label.setPixmap(base_image)
label.setScaledContents(True)
label.show()
self.labels.append(label)
try:
if key == 'browser':
value_index = [item.replace(
':', ' ') for item in parameters[key]].index(browser_value)
else:
value_index = parameters[key].index(current_value)
except ValueError:
value_index = 0
prev_button = QPushButton(self)
prev_button.setGeometry(535, 90 + i * 80, 30, 75)
prev_button.clicked.connect(
lambda _, k=key, idx=value_index: self.show_previous_value(k, idx, parameters))
prev_button.show()
icon_path = os.path.join(self.btn_path, f"UP_button.png")
icon = QPixmap(icon_path)
transform = QTransform().rotate(180)
rotated_icon = icon.transformed(transform)
prev_button.setIcon(QIcon(rotated_icon))
prev_button.setIconSize(prev_button.size())
if (key == 'location' or key == 'browser') and not is_synced():
w = prev_button.width()
h = prev_button.height()
outline_pix = QPixmap(w, h)
outline_pix.fill(Qt.GlobalColor.transparent)
painter = QPainter(outline_pix)
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
pen = QtGui.QPen(QColor(0, 255, 0))
pen.setWidth(3)
painter.setPen(pen)
painter.setBrush(Qt.BrushStyle.NoBrush)
left_points = [
QPointF(w*0.65, h*0.15), QPointF(w*0.25, h*0.50), QPointF(w*0.65, h*0.85)]
painter.drawPolygon(QtGui.QPolygonF(left_points))
painter.end()
prev_button.setIcon(QIcon(outline_pix))
prev_button.setIconSize(prev_button.size())
if (key == 'location' or key == 'browser') and not is_synced():
prev_button.setStyleSheet(BUTTON_STYLE_ONE)
self.buttons.append(prev_button)
next_button = QPushButton(self)
next_button.setGeometry(750, 90 + i * 80, 30, 75)
next_button.clicked.connect(
lambda _, k=key, idx=value_index: self.show_next_value(k, idx, parameters))
next_button.show()
self.buttons.append(next_button)
next_button.setIcon(
QIcon(os.path.join(self.btn_path, f"UP_button.png")))
next_button.setIconSize(next_button.size())
if (key == 'location' or key == 'browser') and not is_synced():
w = next_button.width()
h = next_button.height()
outline_pix_r = QPixmap(w, h)
outline_pix_r.fill(Qt.GlobalColor.transparent)
painter_r = QPainter(outline_pix_r)
painter_r.setRenderHint(QPainter.RenderHint.Antialiasing)
pen_r = QtGui.QPen(QColor(0, 255, 0))
pen_r.setWidth(3)
painter_r.setPen(pen_r)
painter_r.setBrush(Qt.BrushStyle.NoBrush)
right_points = [
QPointF(w*0.35, h*0.15), QPointF(w*0.75, h*0.50), QPointF(w*0.35, h*0.85)]
painter_r.drawPolygon(QtGui.QPolygonF(right_points))
painter_r.end()
next_button.setIcon(QIcon(outline_pix_r))
next_button.setIconSize(next_button.size())
if (key == 'location' or key == 'browser') and not is_synced():
next_button.setStyleSheet("""
QPushButton {
background-color: transparent;
border: none;
}
QPushButton:hover {
background-color: rgba(0, 255, 0, 0.1);
border-radius: 3px;
}
QPushButton:pressed {
background-color: rgba(0, 255, 0, 0.2);
border-radius: 3px;
}
""")
prev_button.setVisible(True)
next_button.setVisible(True)
# can't change profile type
if key == 'connection':
prev_button.setDisabled(True)
next_button.setDisabled(True)
# can't change session protocols (yet), because Tor is a different billing system than wireguard/vless/hy,
if connection == 'browser-only' and key == 'protocol':
prev_button.setDisabled(True)
next_button.setDisabled(True)
# disables session profile options for system-profiles, where they are not relevant:
if connection == 'system-wide' and (key == 'browser' or key == 'dimentions'):
prev_button.setVisible(False)
next_button.setVisible(False)
def _protocol_button_asset(self, protocol):
asset_name = self.PROTOCOL_BUTTON_ASSETS.get(protocol, protocol)
return os.path.join(self.btn_path, f"{asset_name}_button.png")
# def _encrypted_proxy_display_pixmap(self, protocol, location):
# pixmap = QPixmap(os.path.join(self.btn_path, f"{protocol}.png"))
# if pixmap.isNull():
# pixmap = QPixmap(os.path.join(self.btn_path, "system_wide_global.png"))
# if pixmap.isNull():
# return pixmap
# location_pixmap = QPixmap(os.path.join(
# self.btn_path, f"icon_mini_{location}.png"))
# if location_pixmap.isNull():
# location_pixmap = QPixmap(os.path.join(
# self.btn_path, "default_location_mini.png"))
# if location_pixmap.isNull():
# return pixmap
# icon_size = max(42, min(72, int(min(pixmap.width(), pixmap.height()) * 0.22)))
# location_pixmap = location_pixmap.scaled(
# icon_size,
# icon_size,
# Qt.AspectRatioMode.KeepAspectRatio,
# Qt.TransformationMode.SmoothTransformation)
# x = int(pixmap.width() * 0.58)
# if protocol == 'hysteria2':
# y = int(pixmap.height() * 0.35)
# else:
# y = int(pixmap.height() * 0.30)
# x = min(max(0, x), max(0, pixmap.width() - location_pixmap.width()))
# y = min(max(0, y), max(0, pixmap.height() - location_pixmap.height()))
# painter = QPainter(pixmap)
# painter.drawPixmap(x, y, location_pixmap)
# painter.end()
# return pixmap
# def on_sync_complete_for_edit_profile(self, available_locations, available_browsers, status, is_tor, locations, all_browsers):
# if status:
# self.update_status.update_status('Sync complete.')
# self.extraccion()
# else:
# self.update_status.update_status(
# 'Sync failed. Please try again later.')
def on_sync_complete(self, result: Result):
if result.valid:
self.is_synced = True
self.update_status.update_status('Sync complete.')
self.extraccion()
else:
self.update_status.update_status(
'Sync failed. Please try again later.')
def show_previous_value(self, key: str, index: int, parameters: dict) -> None:
if key == 'browser' or key == 'location':
if not is_synced():
self.update_status.update_status('Syncing in progress..')
sync_now(ui_caller=self.on_sync_complete)
# self.update_status.sync()
# self.update_status.worker_thread.sync_output.connect(
# self.on_sync_complete_for_edit_profile)
return
values = parameters.get(key, [])
if not values:
self.update_status.update_status(
f"No {key} data available. Sync the database and try again.")
return
previous_index = (index - 1) % len(values)
previous_value = values[previous_index]
self.update_temp_value(key, previous_value)
def show_next_value(self, key: str, index: int, parameters: dict) -> None:
if key == 'browser' or key == 'location':
if not is_synced():
self.update_status.update_status('Syncing in progress..')
sync_now(ui_caller=self.on_sync_complete)
# self.update_status.sync()
# self.update_status.worker_thread.sync_output.connect(
# self.on_sync_complete_for_edit_profile)
return
values = parameters.get(key, [])
if not values:
self.update_status.update_status(
f"No {key} data available. Sync the database and try again.")
return
next_index = (index + 1) % len(values)
next_value = values[next_index]
self.update_temp_value(key, next_value)
def update_temp_value(self, key: str, new_value: str) -> None:
selected_profiles_str = self._selected_profiles_str()
if selected_profiles_str not in self.temp_changes:
self.temp_changes[selected_profiles_str] = {}
self.original_values[selected_profiles_str] = self.data_profile.copy(
)
self.temp_changes[selected_profiles_str][key] = new_value
self.extraccion()
def show_custom_res_dialog(self):
dialog = QDialog(self)
dialog.setWindowTitle("Custom Resolution")
dialog.setFixedSize(300, 150)
dialog.setModal(True)
dialog.setStyleSheet("""
QDialog {
background-color: #2c3e50;
border: 2px solid #00ffff;
border-radius: 10px;
}
QLabel {
color: white;
font-size: 12px;
}
QLineEdit {
background-color: #34495e;
color: white;
border: 1px solid #00ffff;
border-radius: 5px;
padding: 5px;
font-size: 12px;
}
QPushButton {
background-color: #2c3e50;
color: white;
border: 2px solid #00ffff;
border-radius: 5px;
padding: 8px;
font-size: 12px;
}
QPushButton:hover {
background-color: #34495e;
}
""")
layout = QVBoxLayout()
input_layout = QHBoxLayout()
width_label = QLabel("Width:")
width_input = QLineEdit()
width_input.setPlaceholderText("1920")
height_label = QLabel("Height:")
height_input = QLineEdit()
height_input.setPlaceholderText("1080")
input_layout.addWidget(width_label)
input_layout.addWidget(width_input)
input_layout.addWidget(height_label)
input_layout.addWidget(height_input)
button_layout = QHBoxLayout()
ok_button = QPushButton("OK")
cancel_button = QPushButton("Cancel")
button_layout.addWidget(cancel_button)
button_layout.addWidget(ok_button)
layout.addLayout(input_layout)
layout.addLayout(button_layout)
dialog.setLayout(layout)
def validate_and_accept():
try:
width = int(width_input.text())
height = int(height_input.text())
if width <= 0 or height <= 0:
return
host_w = self.custom_window.host_screen_width
host_h = self.custom_window.host_screen_height
adjusted = False
if width > host_w:
width = host_w - 50
adjusted = True
if height > host_h:
height = host_h - 50
adjusted = True
if adjusted:
QMessageBox.information(
dialog, "Notice", "Adjusted to fit host size")
self.update_temp_value('dimentions', f"{width}x{height}")
dialog.accept()
except ValueError:
pass
ok_button.clicked.connect(validate_and_accept)
cancel_button.clicked.connect(dialog.reject)
width_input.returnPressed.connect(validate_and_accept)
height_input.returnPressed.connect(validate_and_accept)
dialog.exec()
def has_unsaved_changes(self, profile_str: str) -> bool:
return profile_str in self.temp_changes and bool(self.temp_changes[profile_str])
def show_apply_changes_popup(self, selected_profiles_str: str) -> bool:
if selected_profiles_str not in self.temp_changes:
return False
temp_changes = self.temp_changes[selected_profiles_str]
current_data = self.original_values[selected_profiles_str]
current_browser = f"{current_data.get('browser', '')} {current_data.get('browser_version', '')}"
if 'location' in temp_changes and temp_changes['location'] != current_data.get('location'):
message = "A new location would require a new subscription code.\nDo you want to proceed with erasing the old one?"
elif 'browser' in temp_changes and temp_changes['browser'] != current_browser:
message = "Changing the browser would delete all data associated with it. Proceed?"
else:
return False
self.popup = ConfirmationPopup(
self,
message=message,
action_button_text="Continue",
cancel_button_text="Cancel"
)
self.popup.setWindowModality(Qt.WindowModality.ApplicationModal)
self.popup.finished.connect(
lambda result: self.handle_apply_changes_response(result))
self.popup.show()
return True
def show_unsaved_changes_popup(self) -> None:
self.popup = ConfirmationPopup(
self,
message="You have unsaved changes. Do you want to continue?",
action_button_text="Continue",
cancel_button_text="Cancel"
)
self.popup.setWindowModality(Qt.WindowModality.ApplicationModal)
self.popup.finished.connect(
lambda result: self.handle_unsaved_changes_response(result))
self.popup.show()
def _refresh_menu_and_navigate(self):
menu_page = self.find_menu_page()
if menu_page is not None and hasattr(menu_page, 'refresh_menu_buttons'):
menu_page.refresh_menu_buttons()
self.custom_window.navigator.navigate("menu")
def handle_apply_changes_response(self, result: bool) -> None:
if result:
self.commit_changes()
self._refresh_menu_and_navigate()
def handle_unsaved_changes_response(self, result: bool) -> None:
if result:
self.temp_changes.clear()
self._refresh_menu_and_navigate()
def go_selected(self) -> None:
selected_profiles_str = self._selected_profiles_str()
if selected_profiles_str in self.temp_changes and self.temp_changes[selected_profiles_str]:
needs_confirmation = self.show_apply_changes_popup(
selected_profiles_str)
if not needs_confirmation:
self.commit_changes()
self._refresh_menu_and_navigate()
else:
self.custom_window.navigator.navigate("menu")
def commit_changes(self) -> None:
selected_profiles_str = self._selected_profiles_str()
if selected_profiles_str in self.temp_changes:
for key, new_value in self.temp_changes[selected_profiles_str].items():
self.update_core_profiles(key, new_value)
self.temp_changes.pop(selected_profiles_str, None)
self.original_values.pop(selected_profiles_str, None)
self._prefetched_profiles = None
def update_core_profiles(self, key, new_value):
"""Send to action module to update the profile data"""
profile_id = int(self.update_status.current_profile_id)
self.which_key_changed = key
edit_profile(
profile_id=profile_id,
key=key,
new_value=new_value,
ui_caller=self.recieve_edit_result
)
def recieve_edit_result(self, result: Result):
"""After edit is complete, display the result."""
if result.valid:
self.update_status.update_status(
f'Updated profile')
if self.which_key_changed == "resolution":
self.update_res = True
if result.data == "edit_to_session":
self.edit_to_session()
else:
self.show_a_popup(message=result.message, title=str(result.error_type.value))
self.update_status.update_status(result.message)
def edit_to_session(self):
id = int(self.update_status.current_profile_id)
profile = self.data_profile
default_app = 'firefox:123.0'
default_resolution = '1024x760'
location_code = self.connection_manager.get_location_info(
profile.get('location'))
connection_type = 'tor'
profile_data = {
'id': int(id),
'name': profile.get('name'),
'country_code': location_code.country_code,
'code': location_code.code,
'application': default_app,
'connection_type': connection_type,
'resolution': default_resolution,
}
resume_page = self.find_resume_page()
if resume_page:
resume_page.handle_core_action_create_profile(
'CREATE_SESSION_PROFILE', profile_data, 'session')
def show_a_popup(self, message: str, title: str = "Error"):
"""Display a popup with an error"""
error_popup = ErrorPopup(
choice=False,
title=title,
message=message,
end_app = False,
on_answer = None,
passed_result = None,
)
error_popup.show()