694 lines
28 KiB
Python
694 lines
28 KiB
Python
#!/usr/bin/python3
|
|
import sys, os, subprocess, socket
|
|
from pathlib import Path
|
|
from PySide6 import QtCore, QtGui, QtWidgets
|
|
from pynput import keyboard
|
|
|
|
from core.file_search import find
|
|
from core.web_search import MullvadLetaWrapper
|
|
from core.discord_presence import presence
|
|
from core.app_launcher import list_apps, launch
|
|
from core.updater import update_repository, is_update_available
|
|
from core.dukto import DuktoProtocol, Peer
|
|
|
|
ASSET = Path(__file__).parent / "assets" / "2ktan.png"
|
|
|
|
class AppLauncherDialog(QtWidgets.QDialog):
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent)
|
|
self.setWindowTitle("App Launcher")
|
|
self.setMinimumSize(600, 400)
|
|
|
|
# Main layout
|
|
layout = QtWidgets.QVBoxLayout()
|
|
|
|
# Search box
|
|
self.search_box = QtWidgets.QLineEdit()
|
|
self.search_box.setPlaceholderText("Search applications...")
|
|
self.search_box.textChanged.connect(self.filter_apps)
|
|
layout.addWidget(self.search_box)
|
|
|
|
# Apps list widget
|
|
self.list_widget = QtWidgets.QListWidget()
|
|
self.list_widget.itemClicked.connect(self.launch_app)
|
|
layout.addWidget(self.list_widget)
|
|
|
|
# Buttons
|
|
button_layout = QtWidgets.QHBoxLayout()
|
|
close_button = QtWidgets.QPushButton("Close")
|
|
close_button.clicked.connect(self.close)
|
|
|
|
button_layout.addStretch()
|
|
button_layout.addWidget(close_button)
|
|
layout.addLayout(button_layout)
|
|
|
|
self.setLayout(layout)
|
|
|
|
# Load apps
|
|
self.load_apps()
|
|
|
|
# Focus search box
|
|
self.search_box.setFocus()
|
|
|
|
def load_apps(self):
|
|
try:
|
|
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) #type: ignore
|
|
self.apps = list_apps()
|
|
self.apps.sort(key=lambda x: x.name.lower())
|
|
self.populate_list(self.apps)
|
|
except Exception as e:
|
|
QtWidgets.QMessageBox.critical(self, "Error", f"Failed to load applications: {e}")
|
|
finally:
|
|
QtWidgets.QApplication.restoreOverrideCursor()
|
|
|
|
def populate_list(self, apps):
|
|
self.list_widget.clear()
|
|
for app in apps:
|
|
item = QtWidgets.QListWidgetItem(app.name)
|
|
item.setData(QtCore.Qt.UserRole, app) #type: ignore
|
|
|
|
# Try to load the icon
|
|
if app.icon:
|
|
icon = QtGui.QIcon.fromTheme(app.icon)
|
|
if not icon.isNull():
|
|
item.setIcon(icon)
|
|
|
|
self.list_widget.addItem(item)
|
|
|
|
def filter_apps(self, text):
|
|
if not text:
|
|
self.populate_list(self.apps)
|
|
return
|
|
|
|
text_lower = text.lower()
|
|
filtered_apps = [app for app in self.apps if text_lower in app.name.lower()]
|
|
self.populate_list(filtered_apps)
|
|
|
|
def launch_app(self, item: QtWidgets.QListWidgetItem):
|
|
if not item:
|
|
return
|
|
|
|
app = item.data(QtCore.Qt.UserRole) #type: ignore
|
|
if app:
|
|
try:
|
|
launch(app)
|
|
self.close()
|
|
except Exception as e:
|
|
QtWidgets.QMessageBox.critical(self, "Launch Error",
|
|
f"Failed to launch {app.name}: {e}")
|
|
|
|
|
|
class FileSearchResults(QtWidgets.QDialog):
|
|
def __init__(self, results, parent=None):
|
|
super().__init__(parent)
|
|
self.setWindowTitle("Search Results")
|
|
self.setMinimumSize(600, 400)
|
|
|
|
# results list widget
|
|
self.list_widget = QtWidgets.QListWidget()
|
|
self.list_widget.addItems(results)
|
|
self.list_widget.itemDoubleClicked.connect(self.open_file_location)
|
|
|
|
# layout
|
|
layout = QtWidgets.QVBoxLayout()
|
|
layout.addWidget(self.list_widget)
|
|
self.setLayout(layout)
|
|
|
|
def open_file_location(self, item: QtWidgets.QListWidgetItem):
|
|
file_path = item.text()
|
|
if os.path.exists(file_path):
|
|
directory = os.path.dirname(file_path)
|
|
url = QtCore.QUrl.fromLocalFile(directory)
|
|
QtGui.QDesktopServices.openUrl(url)
|
|
|
|
|
|
class WebSearchResults(QtWidgets.QDialog):
|
|
def __init__(self, results, parent=None):
|
|
super().__init__(parent)
|
|
self.setWindowTitle(f"Web Search Results - {results['query']}")
|
|
self.setMinimumSize(800, 600)
|
|
|
|
self.results = results
|
|
|
|
# Main layout
|
|
layout = QtWidgets.QVBoxLayout()
|
|
|
|
# Info label
|
|
info_text = f"Engine: {results['engine']} | Page: {results['page']}"
|
|
if results.get('cached'):
|
|
info_text += " | (Cached results)"
|
|
info_label = QtWidgets.QLabel(info_text)
|
|
info_label.setStyleSheet("color: gray; font-size: 10px; padding: 5px;")
|
|
layout.addWidget(info_label)
|
|
|
|
# Scroll area
|
|
scroll = QtWidgets.QScrollArea()
|
|
scroll.setWidgetResizable(True)
|
|
scroll.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) # type: ignore
|
|
|
|
# Container
|
|
container = QtWidgets.QWidget()
|
|
container_layout = QtWidgets.QVBoxLayout(container)
|
|
container_layout.setSpacing(15)
|
|
|
|
# Add infobox
|
|
if results.get('infobox'):
|
|
infobox_widget = self._create_infobox_widget(results['infobox'])
|
|
container_layout.addWidget(infobox_widget)
|
|
|
|
# Separator
|
|
line = QtWidgets.QFrame()
|
|
line.setFrameShape(QtWidgets.QFrame.HLine) #type: ignore
|
|
line.setFrameShadow(QtWidgets.QFrame.Sunken) #type: ignore
|
|
container_layout.addWidget(line)
|
|
|
|
# Add news
|
|
if results.get('news'):
|
|
news_label = QtWidgets.QLabel("News")
|
|
news_label.setStyleSheet("border: 1px solid #e0e0e0; border-radius: 3px; padding: 8px;")
|
|
container_layout.addWidget(news_label)
|
|
|
|
for news_item in results['news'][:5]: # Show first 5 news items
|
|
news_widget = self._create_news_widget(news_item)
|
|
container_layout.addWidget(news_widget)
|
|
|
|
# Separator
|
|
line = QtWidgets.QFrame()
|
|
line.setFrameShape(QtWidgets.QFrame.HLine) #type: ignore
|
|
line.setFrameShadow(QtWidgets.QFrame.Sunken) #type: ignore
|
|
container_layout.addWidget(line)
|
|
|
|
# Add results
|
|
for result in results.get('results', []):
|
|
result_widget = self._create_result_widget(result)
|
|
container_layout.addWidget(result_widget)
|
|
|
|
container_layout.addStretch()
|
|
scroll.setWidget(container)
|
|
layout.addWidget(scroll)
|
|
|
|
# Navigation buttons
|
|
nav_layout = QtWidgets.QHBoxLayout()
|
|
|
|
if results['page'] > 1:
|
|
prev_button = QtWidgets.QPushButton("← Previous Page")
|
|
prev_button.clicked.connect(lambda: self.load_page(results['page'] - 1))
|
|
nav_layout.addWidget(prev_button)
|
|
|
|
nav_layout.addStretch()
|
|
|
|
if results.get('has_next_page'):
|
|
next_button = QtWidgets.QPushButton("Next Page →")
|
|
next_button.clicked.connect(lambda: self.load_page(results['page'] + 1))
|
|
nav_layout.addWidget(next_button)
|
|
|
|
layout.addLayout(nav_layout)
|
|
|
|
self.setLayout(layout)
|
|
|
|
def _create_infobox_widget(self, infobox):
|
|
widget = QtWidgets.QFrame()
|
|
widget.setFrameShape(QtWidgets.QFrame.StyledPanel) #type: ignore
|
|
widget.setStyleSheet("border: 1px solid #e0e0e0; border-radius: 3px; padding: 8px;")
|
|
|
|
layout = QtWidgets.QVBoxLayout(widget)
|
|
|
|
# Title
|
|
title = QtWidgets.QLabel(infobox.get('title', ''))
|
|
title.setStyleSheet("font-weight: bold; font-size: 16px;")
|
|
title.setWordWrap(True)
|
|
layout.addWidget(title)
|
|
|
|
# Subtitle
|
|
if infobox.get('subtitle'):
|
|
subtitle = QtWidgets.QLabel(infobox['subtitle'])
|
|
subtitle.setStyleSheet("color: gray; font-size: 12px;")
|
|
subtitle.setWordWrap(True)
|
|
layout.addWidget(subtitle)
|
|
|
|
# URL
|
|
if infobox.get('url'):
|
|
url_label = QtWidgets.QLabel(f'<a href="{infobox["url"]}">{infobox["url"]}</a>')
|
|
url_label.setOpenExternalLinks(True)
|
|
url_label.setStyleSheet("color: blue; font-size: 11px;")
|
|
layout.addWidget(url_label)
|
|
|
|
# Description
|
|
if infobox.get('description'):
|
|
desc = QtWidgets.QLabel(infobox['description'])
|
|
desc.setWordWrap(True)
|
|
desc.setStyleSheet("margin-top: 5px;")
|
|
layout.addWidget(desc)
|
|
|
|
return widget
|
|
|
|
def _create_news_widget(self, news_item):
|
|
widget = QtWidgets.QFrame()
|
|
widget.setFrameShape(QtWidgets.QFrame.Box) #type: ignore
|
|
widget.setStyleSheet("border: 1px solid #e0e0e0; border-radius: 3px; padding: 8px;")
|
|
|
|
layout = QtWidgets.QVBoxLayout(widget)
|
|
layout.setSpacing(3)
|
|
|
|
# Source
|
|
source_label = QtWidgets.QLabel(news_item.get('source', ''))
|
|
source_label.setStyleSheet("color: green; font-size: 10px;")
|
|
layout.addWidget(source_label)
|
|
|
|
# Title (clickable)
|
|
title = QtWidgets.QLabel(f'<a href="{news_item["url"]}">{news_item.get("title", "")}</a>')
|
|
title.setOpenExternalLinks(True)
|
|
title.setWordWrap(True)
|
|
title.setStyleSheet("font-size: 12px;")
|
|
layout.addWidget(title)
|
|
|
|
# Timestamp
|
|
if news_item.get('timestamp'):
|
|
time_label = QtWidgets.QLabel(news_item['timestamp'])
|
|
time_label.setStyleSheet("color: gray; font-size: 9px;")
|
|
layout.addWidget(time_label)
|
|
|
|
return widget
|
|
|
|
def _create_result_widget(self, result):
|
|
widget = QtWidgets.QFrame()
|
|
widget.setFrameShape(QtWidgets.QFrame.NoFrame) #type: ignore
|
|
widget.setStyleSheet("padding: 5px;")
|
|
|
|
layout = QtWidgets.QVBoxLayout(widget)
|
|
layout.setSpacing(5)
|
|
|
|
# Display URL
|
|
if result.get('display_url'):
|
|
url_label = QtWidgets.QLabel(result['display_url'])
|
|
url_label.setStyleSheet("color: green; font-size: 11px;")
|
|
layout.addWidget(url_label)
|
|
|
|
# Title
|
|
title = QtWidgets.QLabel(f'<a href="{result["url"]}">{result.get("title", "")}</a>')
|
|
title.setOpenExternalLinks(True)
|
|
title.setWordWrap(True)
|
|
title.setStyleSheet("font-size: 14px; color: #1a0dab;")
|
|
layout.addWidget(title)
|
|
|
|
# Snippet
|
|
if result.get('snippet'):
|
|
snippet = QtWidgets.QLabel(result['snippet'])
|
|
snippet.setWordWrap(True)
|
|
snippet.setStyleSheet("color: #545454; font-size: 12px;")
|
|
layout.addWidget(snippet)
|
|
|
|
return widget
|
|
|
|
def load_page(self, page_num):
|
|
try:
|
|
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) # type: ignore
|
|
leta = MullvadLetaWrapper(engine=self.results['engine'])
|
|
new_results = leta.search(self.results['query'], page=page_num)
|
|
|
|
# Close current dialog and open new one
|
|
new_dialog = WebSearchResults(new_results, self.parent())
|
|
new_dialog.show()
|
|
self.close()
|
|
|
|
except Exception as e:
|
|
QtWidgets.QMessageBox.critical(self, "Search Error", str(e))
|
|
finally:
|
|
QtWidgets.QApplication.restoreOverrideCursor()
|
|
|
|
|
|
class MainWindow(QtWidgets.QMainWindow):
|
|
show_menu_signal = QtCore.Signal()
|
|
# Dukto signals for thread-safety
|
|
peer_added_signal = QtCore.Signal(object)
|
|
peer_removed_signal = QtCore.Signal(object)
|
|
incoming_connection_signal = QtCore.Signal(str, object)
|
|
dukto_error_signal = QtCore.Signal(str)
|
|
transfer_progress_signal = QtCore.Signal(int, int)
|
|
transfer_complete_signal = QtCore.Signal(str)
|
|
text_received_signal = QtCore.Signal(str, str)
|
|
|
|
def __init__(self, restart=False, no_quit=False, super_menu=True):
|
|
super().__init__()
|
|
|
|
flags = (
|
|
QtCore.Qt.FramelessWindowHint #type: ignore
|
|
| QtCore.Qt.WindowStaysOnTopHint #type: ignore
|
|
| QtCore.Qt.Tool #type: ignore
|
|
| QtCore.Qt.WindowDoesNotAcceptFocus #type: ignore
|
|
)
|
|
|
|
self.setWindowFlags(flags)
|
|
self.setAttribute(QtCore.Qt.WA_TranslucentBackground) #type: ignore
|
|
pix = QtGui.QPixmap(str(ASSET))
|
|
|
|
self.label = QtWidgets.QLabel(self)
|
|
self.label.setPixmap(pix)
|
|
self.label.resize(pix.size())
|
|
self.resize(pix.size())
|
|
|
|
img = pix.toImage()
|
|
mask_img = img.createAlphaMask()
|
|
mask = QtGui.QBitmap.fromImage(mask_img)
|
|
self.setMask(mask)
|
|
|
|
self.super_menu = super_menu
|
|
self.progress_dialog = None
|
|
|
|
self.tray = QtWidgets.QSystemTrayIcon(self)
|
|
self.tray.setIcon(QtGui.QIcon(str(ASSET)))
|
|
|
|
# RIGHT MENU
|
|
right_menu = QtWidgets.QMenu()
|
|
right_menu.addAction("Launch App", self.start_app_launcher)
|
|
right_menu.addAction("Search Files", self.start_file_search)
|
|
right_menu.addAction("Search Web", self.start_web_search)
|
|
self.dukto_peers_menu_right = right_menu.addMenu("Dukto")
|
|
self.dukto_peers_menu_right.setEnabled(False)
|
|
right_menu.addSeparator()
|
|
right_menu.addAction("Check for updates", self.update_git)
|
|
if restart:
|
|
right_menu.addAction("Restart", self.restart_application)
|
|
right_menu.addAction("Hide/Show", self.toggle_visible)
|
|
right_menu.addSeparator()
|
|
if not no_quit:
|
|
right_menu.addAction("Quit", self.quit_application)
|
|
self.tray.setContextMenu(right_menu)
|
|
self.tray.activated.connect(self.handle_tray_activated)
|
|
self.tray.show()
|
|
|
|
# LEFT MENU
|
|
self.left_menu = QtWidgets.QMenu()
|
|
self.left_menu.addAction("Launch App", self.start_app_launcher)
|
|
self.left_menu.addAction("Search Files", self.start_file_search)
|
|
self.left_menu.addAction("Search Web", self.start_web_search)
|
|
self.dukto_peers_menu_left = self.left_menu.addMenu("Dukto")
|
|
self.dukto_peers_menu_left.setEnabled(False)
|
|
|
|
# Dukto peer menu storage
|
|
self.dukto_peer_menus = {}
|
|
|
|
# always on top timer
|
|
self.stay_on_top_timer = QtCore.QTimer(self)
|
|
self.stay_on_top_timer.timeout.connect(self.ensure_on_top)
|
|
self.stay_on_top_timer.start(1000)
|
|
|
|
# Super key
|
|
self.show_menu_signal.connect(self.show_menu)
|
|
self.start_hotkey_listener()
|
|
|
|
# Init Dukto Protocol
|
|
self.init_dukto()
|
|
|
|
def init_dukto(self):
|
|
self.dukto = DuktoProtocol()
|
|
|
|
# Connect signals to slots
|
|
self.peer_added_signal.connect(self.add_dukto_peer_slot)
|
|
self.peer_removed_signal.connect(self.remove_dukto_peer_slot)
|
|
self.incoming_connection_signal.connect(self.handle_incoming_transfer_slot)
|
|
self.dukto_error_signal.connect(self.handle_dukto_error_slot)
|
|
self.transfer_progress_signal.connect(self.update_transfer_progress_slot)
|
|
self.transfer_complete_signal.connect(self.finish_transfer_slot)
|
|
self.text_received_signal.connect(self.show_received_text_slot)
|
|
|
|
# Assign callbacks that emit signals
|
|
self.dukto.on_peer_added = lambda peer: self.peer_added_signal.emit(peer)
|
|
self.dukto.on_peer_removed = lambda peer: self.peer_removed_signal.emit(peer)
|
|
self.dukto.on_incoming_connection = lambda ip, conn: self.incoming_connection_signal.emit(ip, conn)
|
|
self.dukto.on_error = lambda msg: self.dukto_error_signal.emit(msg)
|
|
|
|
def on_receive_start(sender_ip):
|
|
peer_name = self.dukto.peers.get(sender_ip, Peer(sender_ip, sender_ip)).signature
|
|
# Use QTimer to ensure this runs on the main thread
|
|
QtCore.QTimer.singleShot(0, lambda: self.start_transfer_progress_slot(f"Receiving from {peer_name}..."))
|
|
self.dukto.on_receive_start = on_receive_start
|
|
|
|
self.dukto.on_transfer_progress = lambda total, current: self.transfer_progress_signal.emit(current, total)
|
|
self.dukto.on_receive_complete = lambda files, size: self.transfer_complete_signal.emit("Files received successfully!")
|
|
self.dukto.on_send_complete = lambda files: self.transfer_complete_signal.emit("Files sent successfully!")
|
|
self.dukto.on_receive_text = lambda text, size: self.text_received_signal.emit(
|
|
self.dukto.peers.get("unknown", Peer("unknown", "An unknown user")).signature, text
|
|
)
|
|
|
|
self.dukto.initialize()
|
|
self.dukto.say_hello()
|
|
|
|
def show_menu(self):
|
|
self.left_menu.popup(QtGui.QCursor.pos())
|
|
|
|
def on_press(self, key):
|
|
if self.super_menu:
|
|
if key == keyboard.Key.cmd:
|
|
self.show_menu_signal.emit()
|
|
|
|
def start_hotkey_listener(self):
|
|
self.listener = keyboard.Listener(on_press=self.on_press)
|
|
self.listener.start()
|
|
|
|
def closeEvent(self, event):
|
|
self.listener.stop()
|
|
super().closeEvent(event)
|
|
|
|
def ensure_on_top(self):
|
|
if self.isVisible():
|
|
self.raise_()
|
|
|
|
def showEvent(self, event):
|
|
super().showEvent(event)
|
|
self.raise_()
|
|
|
|
def mousePressEvent(self, event: QtGui.QMouseEvent):
|
|
if event.button() == QtCore.Qt.LeftButton: #type: ignore
|
|
self.left_menu.popup(event.globalPosition().toPoint())
|
|
|
|
elif event.button() == QtCore.Qt.RightButton: #type: ignore
|
|
self.tray.contextMenu().popup(event.globalPosition().toPoint())
|
|
|
|
def handle_tray_activated(self, reason):
|
|
if reason == QtWidgets.QSystemTrayIcon.ActivationReason.Trigger:
|
|
self.left_menu.popup(QtGui.QCursor.pos())
|
|
|
|
def toggle_visible(self):
|
|
self.setVisible(not self.isVisible())
|
|
|
|
def start_app_launcher(self):
|
|
self.app_launcher_dialog = AppLauncherDialog(self)
|
|
self.app_launcher_dialog.move(QtGui.QCursor.pos())
|
|
self.app_launcher_dialog.show()
|
|
|
|
def start_file_search(self):
|
|
dialog = QtWidgets.QInputDialog(self)
|
|
dialog.setWindowTitle("File Search")
|
|
dialog.setLabelText("Enter search pattern:")
|
|
dialog.move(QtGui.QCursor.pos())
|
|
|
|
ok = dialog.exec()
|
|
pattern = dialog.textValue()
|
|
|
|
if ok and pattern:
|
|
try:
|
|
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) #type: ignore
|
|
results = find(pattern, root='~')
|
|
except RuntimeError as e:
|
|
QtWidgets.QMessageBox.critical(self, "Search Error", str(e))
|
|
return
|
|
finally:
|
|
QtWidgets.QApplication.restoreOverrideCursor()
|
|
|
|
if results:
|
|
self.results_dialog = FileSearchResults(results, self)
|
|
self.results_dialog.show()
|
|
else:
|
|
reply = QtWidgets.QMessageBox.question(self, "No Results", "Sorry, I couldn't find anything in your home folder. Would you like me to search the root folder?",
|
|
QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No, QtWidgets.QMessageBox.StandardButton.No)
|
|
if reply == QtWidgets.QMessageBox.StandardButton.Yes:
|
|
try:
|
|
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) # type: ignore
|
|
results = find(pattern, root='/')
|
|
except RuntimeError as e:
|
|
QtWidgets.QMessageBox.critical(self, "Search Error", str(e))
|
|
return
|
|
finally:
|
|
QtWidgets.QApplication.restoreOverrideCursor()
|
|
|
|
if results:
|
|
self.results_dialog = FileSearchResults(results, self)
|
|
self.results_dialog.show()
|
|
else:
|
|
QtWidgets.QMessageBox.information(self, "No Results", "Sorry, I couldn't find anything in the root folder either.")
|
|
|
|
def start_web_search(self):
|
|
dialog = QtWidgets.QInputDialog(self)
|
|
dialog.setWindowTitle("Web Search")
|
|
dialog.setLabelText("Enter search query:")
|
|
dialog.move(QtGui.QCursor.pos())
|
|
|
|
ok = dialog.exec()
|
|
query = dialog.textValue()
|
|
|
|
if ok and query:
|
|
try:
|
|
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) #type: ignore
|
|
leta = MullvadLetaWrapper(engine="brave")
|
|
results = leta.search(query)
|
|
|
|
if results and results.get('results'):
|
|
self.web_results_dialog = WebSearchResults(results, self)
|
|
self.web_results_dialog.show()
|
|
else:
|
|
QtWidgets.QMessageBox.information(self, "No Results", "No web search results found.")
|
|
|
|
except Exception as e:
|
|
QtWidgets.QMessageBox.critical(self, "Search Error", str(e))
|
|
finally:
|
|
QtWidgets.QApplication.restoreOverrideCursor()
|
|
|
|
def update_git(self):
|
|
update_available = is_update_available()
|
|
|
|
if not update_available:
|
|
QtWidgets.QMessageBox.information(self, "No Updates", "You are already on the latest version.")
|
|
return
|
|
else:
|
|
reply = QtWidgets.QMessageBox.question(self, "Update Available",
|
|
"An update is available. Would you like to download and install it now?",
|
|
QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
|
|
QtWidgets.QMessageBox.StandardButton.Yes)
|
|
if reply == QtWidgets.QMessageBox.StandardButton.No:
|
|
return
|
|
|
|
status, message = update_repository()
|
|
|
|
if status == "UPDATED":
|
|
reply = QtWidgets.QMessageBox.question(self, "Update Successful",
|
|
f"{message}\n\nWould you like to restart now to apply the changes?",
|
|
QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
|
|
QtWidgets.QMessageBox.StandardButton.Yes)
|
|
if reply == QtWidgets.QMessageBox.StandardButton.Yes:
|
|
self.restart_application()
|
|
|
|
elif status == "FAILED":
|
|
QtWidgets.QMessageBox.critical(self, "Update Failed", message)
|
|
|
|
def restart_application(self):
|
|
self.dukto.shutdown()
|
|
presence.end()
|
|
args = [sys.executable] + sys.argv
|
|
subprocess.Popen(args)
|
|
QtWidgets.QApplication.quit()
|
|
|
|
def quit_application(self):
|
|
self.dukto.shutdown()
|
|
QtWidgets.QApplication.quit()
|
|
|
|
# --- Dukto Slots ---
|
|
def add_dukto_peer_slot(self, peer: Peer):
|
|
if not self.dukto_peers_menu_left.isEnabled():
|
|
self.dukto_peers_menu_left.setEnabled(True)
|
|
self.dukto_peers_menu_right.setEnabled(True)
|
|
|
|
peer_menu_left = QtWidgets.QMenu(peer.signature, self.dukto_peers_menu_left)
|
|
peer_menu_right = QtWidgets.QMenu(peer.signature, self.dukto_peers_menu_right)
|
|
|
|
for menu in [peer_menu_left, peer_menu_right]:
|
|
send_files_action = menu.addAction("Send Files...")
|
|
send_files_action.triggered.connect(lambda: self.send_files_to_peer(peer))
|
|
send_text_action = menu.addAction("Send Text...")
|
|
send_text_action.triggered.connect(lambda: self.send_text_to_peer(peer))
|
|
|
|
self.dukto_peers_menu_left.addMenu(peer_menu_left)
|
|
self.dukto_peers_menu_right.addMenu(peer_menu_right)
|
|
self.dukto_peer_menus[peer.address] = (peer_menu_left, peer_menu_right)
|
|
|
|
def remove_dukto_peer_slot(self, peer: Peer):
|
|
if peer.address in self.dukto_peer_menus:
|
|
menus = self.dukto_peer_menus.pop(peer.address)
|
|
self.dukto_peers_menu_left.removeAction(menus[0].menuAction())
|
|
self.dukto_peers_menu_right.removeAction(menus[1].menuAction())
|
|
|
|
if not self.dukto_peer_menus:
|
|
self.dukto_peers_menu_left.setEnabled(False)
|
|
self.dukto_peers_menu_right.setEnabled(False)
|
|
|
|
def handle_incoming_transfer_slot(self, sender_ip: str, conn: socket.socket):
|
|
peer = self.dukto.peers.get(sender_ip)
|
|
peer_name = peer.signature if peer else sender_ip
|
|
|
|
reply = QtWidgets.QMessageBox.question(self, "Incoming Transfer",
|
|
f"Accept incoming files from {peer_name}?",
|
|
QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
|
|
QtWidgets.QMessageBox.StandardButton.Yes)
|
|
|
|
if reply == QtWidgets.QMessageBox.StandardButton.Yes:
|
|
self.dukto.start_receiving(conn, sender_ip)
|
|
else:
|
|
conn.close()
|
|
|
|
def send_files_to_peer(self, peer: Peer):
|
|
file_dialog = QtWidgets.QFileDialog(self)
|
|
file_dialog.setFileMode(QtWidgets.QFileDialog.FileMode.ExistingFiles)
|
|
if file_dialog.exec():
|
|
files = file_dialog.selectedFiles()
|
|
if files:
|
|
self.start_transfer_progress_slot(f"Sending to {peer.signature}...")
|
|
self.dukto.send_file(peer.address, files, peer.port)
|
|
|
|
def send_text_to_peer(self, peer: Peer):
|
|
text, ok = QtWidgets.QInputDialog.getMultiLineText(self, "Send Text", f"Enter text to send to {peer.signature}:")
|
|
if ok and text:
|
|
self.dukto.send_text(peer.address, text, peer.port)
|
|
|
|
def handle_dukto_error_slot(self, message: str):
|
|
QtWidgets.QMessageBox.critical(self, "Dukto Error", message)
|
|
if self.progress_dialog:
|
|
self.progress_dialog.close()
|
|
self.progress_dialog = None
|
|
|
|
def start_transfer_progress_slot(self, title: str):
|
|
self.progress_dialog = QtWidgets.QProgressDialog(title, "Cancel", 0, 100, self)
|
|
self.progress_dialog.setWindowModality(QtCore.Qt.WindowModality.WindowModal)
|
|
self.progress_dialog.setValue(0)
|
|
self.progress_dialog.show()
|
|
|
|
def update_transfer_progress_slot(self, current: int, total: int):
|
|
if self.progress_dialog:
|
|
self.progress_dialog.setMaximum(total)
|
|
self.progress_dialog.setValue(current)
|
|
|
|
def finish_transfer_slot(self, message: str):
|
|
if self.progress_dialog:
|
|
self.progress_dialog.close()
|
|
self.progress_dialog = None
|
|
QtWidgets.QMessageBox.information(self, "Transfer Complete", message)
|
|
|
|
def show_received_text_slot(self, sender_name: str, text: str):
|
|
QtWidgets.QMessageBox.information(self, f"Text from {sender_name}", text)
|
|
|
|
|
|
def main():
|
|
app = QtWidgets.QApplication(sys.argv)
|
|
app.setApplicationName("CLARA")
|
|
|
|
restart = "--restart" in sys.argv
|
|
no_quit = "--no-quit" in sys.argv
|
|
super_menu = not "--no-super" in sys.argv
|
|
pet = MainWindow(restart=restart, no_quit=no_quit, super_menu=super_menu)
|
|
presence.start()
|
|
|
|
# bottom right corner
|
|
screen_geometry = app.primaryScreen().availableGeometry()
|
|
pet_geometry = pet.frameGeometry()
|
|
x = screen_geometry.width() - pet_geometry.width()
|
|
y = screen_geometry.height() - pet_geometry.height()
|
|
pet.move(x, y)
|
|
|
|
pet.show()
|
|
|
|
app.aboutToQuit.connect(presence.end)
|
|
app.aboutToQuit.connect(pet.dukto.shutdown)
|
|
sys.exit(app.exec())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() |