365 lines
14 KiB
Python
365 lines
14 KiB
Python
#!/usr/bin/env python3
|
|
from views import ActiveView, InactiveView
|
|
from data_loader import load_customers
|
|
from models import Customer
|
|
from PIL import Image, ImageDraw
|
|
import pystray
|
|
import threading
|
|
import sys
|
|
from gi.repository import Gtk, Gdk, GLib
|
|
import gi
|
|
gi.require_version('Gtk', '3.0')
|
|
|
|
|
|
class VPNManagerWindow:
|
|
def __init__(self):
|
|
self.customers = load_customers()
|
|
self.filtered_customers = self.customers.copy()
|
|
self.current_location = None # Track user's current location
|
|
|
|
# Create main window
|
|
self.window = Gtk.Window()
|
|
self.window.set_title("VPN Manager")
|
|
self.window.set_default_size(1200, 750)
|
|
self.window.connect("delete-event", self.quit_app_from_close)
|
|
self.window.connect("window-state-event", self.on_window_state_event)
|
|
|
|
# Set up minimal CSS for GNOME-style cards
|
|
self.setup_css()
|
|
|
|
# Create UI
|
|
self.setup_ui()
|
|
self.setup_system_tray()
|
|
|
|
# Start hidden
|
|
self.window.hide()
|
|
|
|
def setup_css(self):
|
|
"""Minimal CSS for GNOME-style cards"""
|
|
css_provider = Gtk.CssProvider()
|
|
css = """
|
|
.card {
|
|
background: @theme_base_color;
|
|
border-radius: 8px;
|
|
border: 1px solid @borders;
|
|
box-shadow: 0 1px 3px rgba(0,0,0,0.1);
|
|
padding: 16px;
|
|
margin: 6px;
|
|
}
|
|
"""
|
|
css_provider.load_from_data(css.encode())
|
|
|
|
# Apply CSS to default screen
|
|
screen = Gdk.Screen.get_default()
|
|
style_context = Gtk.StyleContext()
|
|
style_context.add_provider_for_screen(
|
|
screen, css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
|
|
)
|
|
|
|
def setup_ui(self):
|
|
# Use HeaderBar for native GNOME look
|
|
header_bar = Gtk.HeaderBar()
|
|
header_bar.set_show_close_button(True)
|
|
header_bar.set_title("VPN Manager")
|
|
header_bar.set_subtitle("Connection Manager")
|
|
self.window.set_titlebar(header_bar)
|
|
|
|
# Main container with proper spacing
|
|
main_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12)
|
|
main_vbox.set_margin_start(12)
|
|
main_vbox.set_margin_end(12)
|
|
main_vbox.set_margin_top(12)
|
|
main_vbox.set_margin_bottom(12)
|
|
self.window.add(main_vbox)
|
|
|
|
# Current location display
|
|
self.current_location_label = Gtk.Label()
|
|
self.current_location_label.set_markup("<i>Current location: Not set</i>")
|
|
self.current_location_label.set_halign(Gtk.Align.CENTER)
|
|
self.current_location_label.set_margin_bottom(8)
|
|
main_vbox.pack_start(self.current_location_label, False, False, 0)
|
|
|
|
# Search bar with SearchEntry
|
|
self.search_entry = Gtk.SearchEntry()
|
|
self.search_entry.set_placeholder_text(
|
|
"Search customers, locations, or hosts... (* for all)")
|
|
self.search_entry.connect("search-changed", self.filter_customers)
|
|
main_vbox.pack_start(self.search_entry, False, False, 0)
|
|
|
|
# Create a stack to switch between views
|
|
self.view_stack = Gtk.Stack()
|
|
self.view_stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
|
|
self.view_stack.set_transition_duration(200)
|
|
main_vbox.pack_start(self.view_stack, True, True, 0)
|
|
|
|
# Get callbacks for views
|
|
callbacks = self.get_callbacks()
|
|
|
|
# Create active view (shown by default)
|
|
self.active_view = ActiveView(callbacks)
|
|
self.view_stack.add_named(self.active_view.widget, "active")
|
|
|
|
# Create inactive view (shown when searching)
|
|
self.inactive_view = InactiveView(callbacks)
|
|
self.view_stack.add_named(self.inactive_view.widget, "inactive")
|
|
|
|
# Render initial data
|
|
self.render_customers()
|
|
|
|
def setup_system_tray(self):
|
|
# Create a simple icon for the system tray
|
|
def create_icon():
|
|
# Create a simple network icon
|
|
width = height = 64
|
|
image = Image.new('RGBA', (width, height), (0, 0, 0, 0))
|
|
draw = ImageDraw.Draw(image)
|
|
|
|
# Draw a simple network/VPN icon
|
|
# Outer circle
|
|
draw.ellipse([8, 8, 56, 56], outline=(50, 150, 50), width=4)
|
|
# Inner dot
|
|
draw.ellipse([26, 26, 38, 38], fill=(50, 150, 50))
|
|
# Connection lines
|
|
draw.line([32, 16, 32, 24], fill=(50, 150, 50), width=3)
|
|
draw.line([32, 40, 32, 48], fill=(50, 150, 50), width=3)
|
|
draw.line([16, 32, 24, 32], fill=(50, 150, 50), width=3)
|
|
draw.line([40, 32, 48, 32], fill=(50, 150, 50), width=3)
|
|
|
|
return image
|
|
|
|
# Simple approach: Create tray icon with direct action and minimal menu
|
|
self.tray_icon = pystray.Icon(
|
|
"VPN Manager",
|
|
create_icon(),
|
|
"VPN Manager - Double-click to open"
|
|
)
|
|
|
|
# Set direct click action
|
|
self.tray_icon.default_action = self.show_window_from_tray
|
|
|
|
# Also provide a right-click menu
|
|
menu = pystray.Menu(
|
|
pystray.MenuItem("Open VPN Manager",
|
|
self.show_window_from_tray, default=True),
|
|
pystray.MenuItem("Quit", self.quit_app)
|
|
)
|
|
self.tray_icon.menu = menu
|
|
|
|
# Start tray icon in separate thread
|
|
threading.Thread(target=self.tray_icon.run, daemon=True).start()
|
|
|
|
def get_callbacks(self):
|
|
"""Return callback functions for widget interactions"""
|
|
return {
|
|
'toggle_connection': self.toggle_connection,
|
|
'set_location_active': self.set_location_active,
|
|
'deactivate_location': self.deactivate_location,
|
|
'set_current_location': self.set_current_location,
|
|
'open_service': self.open_service,
|
|
'open_customer_service': self.open_customer_service
|
|
}
|
|
|
|
def render_customers(self):
|
|
# Check if we're in search mode
|
|
search_term = self.search_entry.get_text().strip()
|
|
is_searching = bool(search_term)
|
|
|
|
# Separate customers with active and inactive locations
|
|
customers_with_active = []
|
|
customers_with_inactive = []
|
|
|
|
for customer in self.filtered_customers:
|
|
active_locations = customer.get_active_locations()
|
|
inactive_locations = customer.get_inactive_locations()
|
|
|
|
# Prepare active locations (shown when not searching)
|
|
if active_locations:
|
|
customer_data = Customer(name=customer.name)
|
|
customer_data.services = customer.services
|
|
customer_data.locations = active_locations
|
|
customers_with_active.append(customer_data)
|
|
|
|
# Prepare inactive locations (shown when searching)
|
|
if inactive_locations:
|
|
customer_data = Customer(name=customer.name)
|
|
customer_data.services = customer.services
|
|
customer_data.locations = inactive_locations
|
|
customers_with_inactive.append(customer_data)
|
|
|
|
# Update views based on mode
|
|
if is_searching:
|
|
# Search mode: Switch to inactive view and update it
|
|
self.view_stack.set_visible_child_name("inactive")
|
|
self.inactive_view.update(customers_with_inactive, search_term)
|
|
else:
|
|
# Normal mode: Switch to active view and update it
|
|
self.view_stack.set_visible_child_name("active")
|
|
self.active_view.update(customers_with_active)
|
|
|
|
self.window.show_all()
|
|
|
|
def set_location_active(self, location, customer_name):
|
|
for customer in self.customers:
|
|
if customer.name == customer_name:
|
|
target_location = customer.get_location_by_name(location.name)
|
|
if target_location:
|
|
target_location.active = True
|
|
print(
|
|
f"Mock: Setting {customer.name} - {target_location.name} as active")
|
|
break
|
|
|
|
# Clear search and return to active view
|
|
self.search_entry.set_text("")
|
|
self.render_customers()
|
|
|
|
def deactivate_location(self, location, customer_name):
|
|
for customer in self.customers:
|
|
if customer.name == customer_name:
|
|
target_location = customer.get_location_by_name(location.name)
|
|
if target_location:
|
|
target_location.active = False
|
|
target_location.connected = False # Disconnect when deactivating
|
|
print(
|
|
f"Mock: Deactivating {customer.name} - {target_location.name}")
|
|
break
|
|
self.render_customers()
|
|
|
|
def set_current_location(self, location, customer_name):
|
|
"""Set the user's current location."""
|
|
for customer in self.customers:
|
|
if customer.name == customer_name:
|
|
target_location = customer.get_location_by_name(location.name)
|
|
if target_location:
|
|
self.current_location = (customer.name, target_location.name)
|
|
print(f"Current location set to: {customer.name} - {target_location.name}")
|
|
self.update_current_location_display()
|
|
break
|
|
|
|
def update_current_location_display(self):
|
|
"""Update the current location display label."""
|
|
if self.current_location:
|
|
customer_name, location_name = self.current_location
|
|
self.current_location_label.set_markup(
|
|
f"<i>📍 Current location: <b>{customer_name} - {location_name}</b></i>"
|
|
)
|
|
else:
|
|
self.current_location_label.set_markup("<i>Current location: Not set</i>")
|
|
|
|
def filter_customers(self, entry):
|
|
search_term = entry.get_text().strip()
|
|
|
|
# Check for wildcard - show all customers
|
|
if search_term == "*":
|
|
self.filtered_customers = self.customers.copy()
|
|
elif search_term:
|
|
# Normal search logic
|
|
search_term_lower = search_term.lower()
|
|
self.filtered_customers = []
|
|
for customer in self.customers:
|
|
# Check if search term matches customer name
|
|
if search_term_lower in customer.name.lower():
|
|
self.filtered_customers.append(customer)
|
|
continue
|
|
|
|
# Check customer services
|
|
if any(search_term_lower in service.name.lower() or
|
|
search_term_lower in service.url.lower() or
|
|
search_term_lower in service.service_type.lower()
|
|
for service in customer.services):
|
|
self.filtered_customers.append(customer)
|
|
continue
|
|
|
|
# Check locations and their hosts
|
|
for location in customer.locations:
|
|
# Check location name
|
|
if search_term_lower in location.name.lower():
|
|
self.filtered_customers.append(customer)
|
|
break
|
|
|
|
# Check hosts and their services in this location
|
|
def search_hosts(hosts):
|
|
for host in hosts:
|
|
if (search_term_lower in host.name.lower() or
|
|
search_term_lower in host.ip_address.lower() or
|
|
search_term_lower in host.host_type.value.lower() or
|
|
search_term_lower in host.description.lower()):
|
|
return True
|
|
|
|
# Check host services
|
|
if any(search_term_lower in service.name.lower() or
|
|
search_term_lower in str(service.port).lower() or
|
|
search_term_lower in service.service_type.value.lower()
|
|
for service in host.services):
|
|
return True
|
|
|
|
# Check sub-hosts recursively
|
|
if search_hosts(host.sub_hosts):
|
|
return True
|
|
return False
|
|
|
|
if search_hosts(location.hosts):
|
|
self.filtered_customers.append(customer)
|
|
break
|
|
else:
|
|
# Empty search - show all customers
|
|
self.filtered_customers = self.customers.copy()
|
|
|
|
self.render_customers()
|
|
|
|
def toggle_connection(self, location):
|
|
location.connected = not location.connected
|
|
status = "connected to" if location.connected else "disconnected from"
|
|
print(f"Mock: {status} {location.name} via {location.vpn_type.value}")
|
|
self.render_customers()
|
|
|
|
def open_service(self, service):
|
|
# Get the host IP from context - this would need to be passed properly in a real implementation
|
|
print(
|
|
f"Mock: Opening {service.service_type.value} service: {service.name} on port {service.port}")
|
|
|
|
def open_customer_service(self, customer_service):
|
|
print(
|
|
f"Mock: Opening customer service: {customer_service.name} at {customer_service.url}")
|
|
|
|
def show_window_from_tray(self, _icon=None, _item=None):
|
|
# Use GLib.idle_add to safely call GTK functions from the tray thread
|
|
GLib.idle_add(self._show_window_safe)
|
|
|
|
def _show_window_safe(self):
|
|
"""Safely show window in main GTK thread"""
|
|
self.window.deiconify()
|
|
self.window.present()
|
|
self.window.show_all()
|
|
return False # Don't repeat the idle call
|
|
|
|
def on_window_state_event(self, _widget, event):
|
|
"""Handle window state changes - hide to tray when minimized"""
|
|
if event.new_window_state & Gdk.WindowState.ICONIFIED:
|
|
self.window.hide()
|
|
return False
|
|
|
|
def quit_app_from_close(self, _widget=None, _event=None):
|
|
"""Quit app when close button is pressed"""
|
|
self.quit_app()
|
|
return False
|
|
|
|
def quit_app(self, _widget=None):
|
|
# Stop the tray icon
|
|
if hasattr(self, 'tray_icon'):
|
|
self.tray_icon.stop()
|
|
Gtk.main_quit()
|
|
sys.exit(0)
|
|
|
|
def run(self):
|
|
self.window.show_all()
|
|
Gtk.main()
|
|
|
|
|
|
def main():
|
|
app = VPNManagerWindow()
|
|
app.run()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|