1154 lines
51 KiB
Python
1154 lines
51 KiB
Python
import os
|
|
import shutil
|
|
import tkinter as tk
|
|
from tkinter import ttk
|
|
from datetime import datetime
|
|
import subprocess
|
|
import json
|
|
from shared_libs.message import MessageDialog
|
|
from shared_libs.common_tools import IconManager, Tooltip
|
|
|
|
# Helper to make icon paths robust, so the script can be run from anywhere
|
|
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
|
|
MAX_ITEMS_TO_DISPLAY = 1000
|
|
|
|
|
|
def get_xdg_user_dir(dir_key, fallback_name):
|
|
home = os.path.expanduser("~")
|
|
fallback_path = os.path.join(home, fallback_name)
|
|
config_path = os.path.join(home, ".config", "user-dirs.dirs")
|
|
|
|
if not os.path.exists(config_path):
|
|
return fallback_path
|
|
|
|
try:
|
|
with open(config_path, 'r') as f:
|
|
for line in f:
|
|
line = line.strip()
|
|
if line.startswith(f"{dir_key}="):
|
|
path = line.split('=', 1)[1].strip().strip('"')
|
|
path = path.replace('$HOME', home)
|
|
if not os.path.isabs(path):
|
|
path = os.path.join(home, path)
|
|
return path
|
|
except Exception:
|
|
pass
|
|
return fallback_path
|
|
|
|
|
|
class CustomFileDialog(tk.Toplevel):
|
|
def __init__(self, parent, initial_dir=None, filetypes=None):
|
|
super().__init__(parent)
|
|
self.parent = parent
|
|
self.title("Datei auswählen")
|
|
self.geometry("1100x850")
|
|
self.minsize(650, 400)
|
|
self.transient(parent)
|
|
self.grab_set()
|
|
|
|
self.selected_file = None
|
|
self.current_dir = os.path.abspath(
|
|
initial_dir) if initial_dir else os.path.expanduser("~")
|
|
self.filetypes = filetypes if filetypes else [("Alle Dateien", "*.* ")]
|
|
self.current_filter_pattern = self.filetypes[0][1]
|
|
self.history = []
|
|
self.history_pos = -1
|
|
self.view_mode = tk.StringVar(value="icons")
|
|
self.show_hidden_files = tk.BooleanVar(value=False)
|
|
self.resize_job = None
|
|
self.last_width = 0
|
|
self.sidebar_buttons = []
|
|
self.device_buttons = []
|
|
self.search_results = [] # Store search results
|
|
self.search_mode = False # Track if in search mode
|
|
self.original_path_text = "" # Store original path text
|
|
|
|
self.icon_manager = IconManager()
|
|
self.create_styles()
|
|
self.create_widgets()
|
|
self.navigate_to(self.current_dir)
|
|
|
|
def get_file_icon(self, filename, size='large'):
|
|
ext = os.path.splitext(filename)[1].lower()
|
|
if ext == '.svg':
|
|
return self.icon_manager.get_icon(f'warning_{size}')
|
|
if ext == '.py':
|
|
return self.icon_manager.get_icon(f'python_{size}')
|
|
if ext == '.pdf':
|
|
return self.icon_manager.get_icon(f'pdf_{size}')
|
|
if ext in ['.tar', '.zip', '.rar', '.7z', '.gz']:
|
|
return self.icon_manager.get_icon(f'archive_{size}')
|
|
if ext in ['.mp3', '.wav', '.ogg', '.flac']:
|
|
return self.icon_manager.get_icon(f'audio_{size}')
|
|
if ext in ['.mp4', '.mkv', '.avi', '.mov']:
|
|
return self.icon_manager.get_icon(f'video_{size}') if size == 'large' else self.icon_manager.get_icon('video_small_file')
|
|
if ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp']:
|
|
return self.icon_manager.get_icon(f'picture_{size}')
|
|
if ext == '.iso':
|
|
return self.icon_manager.get_icon(f'iso_{size}')
|
|
return self.icon_manager.get_icon(f'file_{size}')
|
|
|
|
def create_styles(self):
|
|
style = ttk.Style(self)
|
|
base_bg = self.cget('background')
|
|
self.is_dark = sum(self.winfo_rgb(base_bg)) / 3 < 32768
|
|
|
|
if self.is_dark:
|
|
self.selection_color = "#4a6984" # Darker blue for selection
|
|
self.icon_bg_color = "#3c3c3c" # Lighter background for content
|
|
self.accent_color = "#2a2a2a" # Darker accent for the bottom
|
|
self.header = "#2b2b2b" # Dark Color for Header and round buttons in Header
|
|
self.hover_extrastyle = "#4a4a4a" # Hover Color for Buttons in header and Sidebar
|
|
self.hover_extrastyle2 = "#494949"
|
|
self.sidebar_color = "#333333"
|
|
self.bottom_color = self.accent_color
|
|
self.color_foreground = "#ffffff"
|
|
self.freespace_background = self.sidebar_color
|
|
|
|
else:
|
|
self.selection_color = "#cce5ff" # Light blue for selection
|
|
self.icon_bg_color = base_bg # Main background for content
|
|
self.accent_color = "#e0e0e0"
|
|
# Light Color for Header and round buttons in Header
|
|
self.header = "#d9d9d9"
|
|
# Hover Color for Buttons in header and Sidebar
|
|
self.hover_extrastyle = "#f5f5f5"
|
|
self.hover_extrastyle2 = "#494949" # Hover Color for Buttons in Sidebar
|
|
self.sidebar_color = "#e7e7e7"
|
|
self.bottom_color = "#cecece"
|
|
self.freespace_background = self.sidebar_color
|
|
self.color_foreground = "#000000"
|
|
|
|
style.configure("Header.TButton.Borderless.Round",
|
|
background=self.header)
|
|
|
|
style.map("Header.TButton.Borderless.Round", background=[
|
|
('active', self.hover_extrastyle)])
|
|
|
|
# Style for active/pressed header buttons
|
|
style.configure("Header.TButton.Active.Round",
|
|
background=self.selection_color)
|
|
|
|
# Copy layout from the base style
|
|
style.layout("Header.TButton.Active.Round",
|
|
style.layout("Header.TButton.Borderless.Round"))
|
|
|
|
style.map("Header.TButton.Active.Round", background=[
|
|
('active', self.selection_color)])
|
|
|
|
style.configure("Dark.TButton.Borderless", anchor="w",
|
|
background=self.sidebar_color, foreground=self.color_foreground, padding=(20, 5, 0, 5))
|
|
|
|
style.map("Dark.TButton.Borderless", background=[
|
|
('active', self.hover_extrastyle2)])
|
|
|
|
style.configure("Accent.TFrame", background=self.header)
|
|
style.configure("Accent.TLabel", background=self.header)
|
|
style.configure("AccentBottom.TFrame", background=self.bottom_color)
|
|
style.configure("AccentBottom.TLabel", background=self.bottom_color)
|
|
style.configure("Sidebar.TFrame", background=self.sidebar_color)
|
|
|
|
style.configure("Content.TFrame", background=self.icon_bg_color)
|
|
style.configure("Item.TFrame", background=self.icon_bg_color)
|
|
style.map('Item.TFrame', background=[
|
|
('selected', self.selection_color)])
|
|
style.configure("Item.TLabel", background=self.icon_bg_color)
|
|
style.map('Item.TLabel', background=[('selected', self.selection_color)], foreground=[
|
|
('selected', "black" if not self.is_dark else "white")])
|
|
style.configure("Icon.TLabel", background=self.icon_bg_color)
|
|
style.map('Icon.TLabel', background=[
|
|
('selected', self.selection_color)])
|
|
|
|
style.configure("Treeview.Heading", relief="flat",
|
|
borderwidth=0, font=('TkDefaultFont', 10, 'bold'))
|
|
style.configure("Treeview", rowheight=32, pady=2,
|
|
background=self.icon_bg_color, fieldbackground=self.icon_bg_color, borderwidth=0)
|
|
style.map("Treeview", background=[('selected', self.selection_color)], foreground=[
|
|
('selected', "black" if not self.is_dark else "white")])
|
|
|
|
style.configure("TButton.Borderless.Round", anchor="w")
|
|
style.configure("Small.Horizontal.TProgressbar", thickness=8)
|
|
|
|
def create_widgets(self):
|
|
# Main container
|
|
main_frame = ttk.Frame(self, style='Accent.TFrame')
|
|
main_frame.pack(fill="both", expand=True)
|
|
main_frame.grid_rowconfigure(2, weight=1)
|
|
main_frame.grid_columnconfigure(0, weight=1)
|
|
|
|
# Top bar for navigation and path
|
|
top_bar = ttk.Frame(
|
|
main_frame, style='Accent.TFrame', padding=(0, 5, 0, 5))
|
|
top_bar.grid(row=0, column=0, columnspan=2, sticky="ew")
|
|
top_bar.grid_columnconfigure(1, weight=1)
|
|
|
|
# Navigation buttons
|
|
nav_buttons_container = ttk.Frame(top_bar, style='Accent.TFrame')
|
|
nav_buttons_container.grid(row=0, column=0, sticky="w")
|
|
|
|
self.back_button = ttk.Button(
|
|
nav_buttons_container, image=self.icon_manager.get_icon('back'), command=self.go_back, state=tk.DISABLED, style="Header.TButton.Borderless.Round")
|
|
self.back_button.pack(side="left", padx=10)
|
|
Tooltip(self.back_button, "Zurück")
|
|
|
|
self.forward_button = ttk.Button(
|
|
nav_buttons_container, image=self.icon_manager.get_icon('forward'), command=self.go_forward, state=tk.DISABLED, style="Header.TButton.Borderless.Round")
|
|
self.forward_button.pack(side="left")
|
|
Tooltip(self.forward_button, "Vorwärts")
|
|
|
|
self.home_button = ttk.Button(nav_buttons_container, image=self.icon_manager.get_icon('home'), command=lambda: self.navigate_to(
|
|
os.path.expanduser("~")), style="Header.TButton.Borderless.Round")
|
|
self.home_button.pack(side="left", padx=10)
|
|
Tooltip(self.home_button, "Home")
|
|
|
|
# Path entry
|
|
self.path_entry = ttk.Entry(top_bar)
|
|
self.path_entry.grid(row=0, column=1, sticky="ew")
|
|
self.path_entry.bind(
|
|
"<Return>", lambda e: self.navigate_to(self.path_entry.get()))
|
|
|
|
# Search, view switch and hidden files button
|
|
right_top_bar_frame = ttk.Frame(top_bar, style='Accent.TFrame')
|
|
right_top_bar_frame.grid(row=0, column=2, sticky="e")
|
|
|
|
# Search button and options container
|
|
search_container = ttk.Frame(
|
|
right_top_bar_frame, style='Accent.TFrame')
|
|
search_container.pack(side="left", padx=(0, 10))
|
|
|
|
self.search_button = ttk.Button(search_container, image=self.icon_manager.get_icon('search_small'),
|
|
command=self.toggle_search_mode, style="Header.TButton.Borderless.Round")
|
|
self.search_button.pack(side="left")
|
|
Tooltip(self.search_button, "Suchen")
|
|
|
|
# Search options frame (initially hidden, next to search button)
|
|
self.search_options_frame = ttk.Frame(
|
|
search_container, style='Accent.TFrame')
|
|
|
|
# Recursive search toggle button
|
|
self.recursive_search = tk.BooleanVar(value=True)
|
|
self.recursive_button = ttk.Button(self.search_options_frame, image=self.icon_manager.get_icon('recursive_small'),
|
|
command=self.toggle_recursive_search,
|
|
style="Header.TButton.Active.Round")
|
|
self.recursive_button.pack(side="left", padx=2)
|
|
Tooltip(self.recursive_button, "Rekursive Suche ein/ausschalten")
|
|
|
|
view_switch = ttk.Frame(right_top_bar_frame,
|
|
padding=(5, 0), style='Accent.TFrame')
|
|
view_switch.pack(side="left")
|
|
|
|
self.icon_view_button = ttk.Button(view_switch, image=self.icon_manager.get_icon('icon_view'),
|
|
command=self.set_icon_view, style="Header.TButton.Active.Round")
|
|
self.icon_view_button.pack(side="left", padx=(50, 10))
|
|
Tooltip(self.icon_view_button, "Kachelansicht")
|
|
|
|
self.list_view_button = ttk.Button(view_switch, image=self.icon_manager.get_icon('list_view'),
|
|
command=self.set_list_view, style="Header.TButton.Borderless.Round")
|
|
self.list_view_button.pack(side="left")
|
|
Tooltip(self.list_view_button, "Listenansicht")
|
|
|
|
self.hidden_files_button = ttk.Button(
|
|
right_top_bar_frame, image=self.icon_manager.get_icon('hide'), command=self.toggle_hidden_files, style="Header.TButton.Borderless.Round")
|
|
self.hidden_files_button.pack(side="left", padx=10)
|
|
Tooltip(self.hidden_files_button, "Versteckte Dateien anzeigen")
|
|
|
|
# Horizontal separator
|
|
separator_color = "#000000" if self.is_dark else "#9c9c9c"
|
|
tk.Frame(main_frame, height=1, bg=separator_color).grid(
|
|
row=1, column=0, columnspan=2, sticky="ew")
|
|
|
|
# PanedWindow for resizable sidebar and content
|
|
paned_window = ttk.PanedWindow(main_frame, orient=tk.HORIZONTAL)
|
|
paned_window.grid(row=2, column=0, columnspan=2, sticky="nsew")
|
|
|
|
# Sidebar
|
|
sidebar_frame = ttk.Frame(
|
|
paned_window, style="Sidebar.TFrame", padding=(0, 0, 0, 0), width=200)
|
|
# Prevent content from resizing the frame
|
|
sidebar_frame.grid_propagate(False)
|
|
sidebar_frame.bind("<Configure>", self.on_sidebar_resize)
|
|
# Use weight=0 to give it a fixed size
|
|
paned_window.add(sidebar_frame, weight=0)
|
|
|
|
# No weight on any row - let storage stay at bottom
|
|
sidebar_buttons_frame = ttk.Frame(
|
|
sidebar_frame, style="Sidebar.TFrame", padding=(0, 15, 0, 0))
|
|
sidebar_buttons_frame.grid(
|
|
row=0, column=0, sticky="nsew")
|
|
sidebar_buttons_config = [
|
|
{'name': 'Computer',
|
|
'icon': self.icon_manager.get_icon('computer_small'), 'path': '/'},
|
|
{'name': 'Downloads', 'icon': self.icon_manager.get_icon('downloads_small'), 'path': get_xdg_user_dir(
|
|
"XDG_DOWNLOAD_DIR", "Downloads")},
|
|
{'name': 'Dokumente', 'icon': self.icon_manager.get_icon('documents_small'), 'path': get_xdg_user_dir(
|
|
"XDG_DOCUMENTS_DIR", "Documents")},
|
|
{'name': 'Bilder', 'icon': self.icon_manager.get_icon('pictures_small'), 'path': get_xdg_user_dir(
|
|
"XDG_PICTURES_DIR", "Pictures")},
|
|
{'name': 'Musik', 'icon': self.icon_manager.get_icon('music_small'), 'path': get_xdg_user_dir(
|
|
"XDG_MUSIC_DIR", "Music")},
|
|
{'name': 'Videos', 'icon': self.icon_manager.get_icon('video_small'), 'path': get_xdg_user_dir(
|
|
"XDG_VIDEO_DIR", "Videos")},
|
|
]
|
|
for config in sidebar_buttons_config:
|
|
btn = ttk.Button(sidebar_buttons_frame, text=f" {config['name']}", image=config['icon'],
|
|
compound="left", command=lambda p=config['path']: self.navigate_to(p), style="Dark.TButton.Borderless")
|
|
btn.pack(fill="x", pady=1)
|
|
self.sidebar_buttons.append((btn, f" {config['name']}"))
|
|
|
|
# Horizontal separator
|
|
separator_color = "#a9a9a9" if self.is_dark else "#7c7c7c"
|
|
tk.Frame(sidebar_frame, height=1, bg=separator_color).grid(
|
|
row=1, column=0, sticky="ew", padx=20, pady=15)
|
|
|
|
# Mounted devices with scrollable frame
|
|
mounted_devices_frame = ttk.Frame(
|
|
sidebar_frame, style="Sidebar.TFrame")
|
|
mounted_devices_frame.grid(row=2, column=0, sticky="nsew", padx=10)
|
|
# Don't expand devices frame so storage stays in position
|
|
mounted_devices_frame.grid_columnconfigure(0, weight=1)
|
|
|
|
ttk.Label(mounted_devices_frame, text="Geräte:", background=self.sidebar_color,
|
|
foreground=self.color_foreground).grid(row=0, column=0, sticky="ew", padx=10, pady=(5, 0))
|
|
|
|
# Create scrollable canvas for devices
|
|
self.devices_canvas = tk.Canvas(mounted_devices_frame, highlightthickness=0,
|
|
bg=self.sidebar_color, height=150, width=180)
|
|
self.devices_scrollbar = ttk.Scrollbar(mounted_devices_frame, orient="vertical",
|
|
command=self.devices_canvas.yview)
|
|
self.devices_canvas.configure(
|
|
yscrollcommand=self.devices_scrollbar.set)
|
|
|
|
self.devices_canvas.grid(row=1, column=0, sticky="nsew")
|
|
# Scrollbar initially hidden
|
|
|
|
# Create scrollable frame inside canvas
|
|
self.devices_scrollable_frame = ttk.Frame(
|
|
self.devices_canvas, style="Sidebar.TFrame")
|
|
self.devices_canvas_window = self.devices_canvas.create_window(
|
|
(0, 0), window=self.devices_scrollable_frame, anchor="nw")
|
|
|
|
# Bind events for showing/hiding scrollbar on hover
|
|
self.devices_canvas.bind("<Enter>", self._on_devices_enter)
|
|
self.devices_canvas.bind("<Leave>", self._on_devices_leave)
|
|
self.devices_scrollable_frame.bind("<Enter>", self._on_devices_enter)
|
|
self.devices_scrollable_frame.bind("<Leave>", self._on_devices_leave)
|
|
|
|
# Bind canvas width to scrollable frame width
|
|
def _configure_devices_canvas(event):
|
|
self.devices_canvas.configure(
|
|
scrollregion=self.devices_canvas.bbox("all"))
|
|
canvas_width = event.width
|
|
self.devices_canvas.itemconfig(
|
|
self.devices_canvas_window, width=canvas_width)
|
|
|
|
self.devices_scrollable_frame.bind("<Configure>", lambda e: self.devices_canvas.configure(
|
|
scrollregion=self.devices_canvas.bbox("all")))
|
|
self.devices_canvas.bind("<Configure>", _configure_devices_canvas)
|
|
|
|
# Mouse wheel scrolling for devices area
|
|
def _on_devices_mouse_wheel(event):
|
|
if event.num == 4: # Scroll up on Linux
|
|
delta = -1
|
|
elif event.num == 5: # Scroll down on Linux
|
|
delta = 1
|
|
else: # MouseWheel event for Windows/macOS
|
|
delta = -1 * int(event.delta / 120)
|
|
self.devices_canvas.yview_scroll(delta, "units")
|
|
|
|
# Bind mouse wheel to canvas and scrollable frame
|
|
for widget in [self.devices_canvas, self.devices_scrollable_frame]:
|
|
widget.bind("<MouseWheel>", _on_devices_mouse_wheel)
|
|
widget.bind("<Button-4>", _on_devices_mouse_wheel)
|
|
widget.bind("<Button-5>", _on_devices_mouse_wheel)
|
|
|
|
# Populate devices
|
|
for device_name, mount_point, removable in self._get_mounted_devices():
|
|
icon = self.icon_manager.get_icon(
|
|
'usb_small') if removable else self.icon_manager.get_icon('device_small')
|
|
button_text = f" {device_name}"
|
|
if len(device_name) > 15: # Static wrapping for long names
|
|
button_text = f" {device_name[:15]}\n{device_name[15:]}"
|
|
|
|
btn = ttk.Button(self.devices_scrollable_frame, text=button_text, image=icon,
|
|
compound="left", command=lambda p=mount_point: self.navigate_to(p), style="Dark.TButton.Borderless")
|
|
btn.pack(fill="x", pady=1)
|
|
self.device_buttons.append((btn, button_text))
|
|
|
|
# Bind mouse wheel to device buttons too
|
|
btn.bind("<MouseWheel>", _on_devices_mouse_wheel)
|
|
btn.bind("<Button-4>", _on_devices_mouse_wheel)
|
|
btn.bind("<Button-5>", _on_devices_mouse_wheel)
|
|
|
|
# Bind hover events for scrollbar visibility
|
|
btn.bind("<Enter>", self._on_devices_enter)
|
|
btn.bind("<Leave>", self._on_devices_leave)
|
|
|
|
try:
|
|
total, used, _ = shutil.disk_usage(mount_point)
|
|
progress_bar = ttk.Progressbar(
|
|
self.devices_scrollable_frame, orient="horizontal", length=100, mode="determinate", style='Small.Horizontal.TProgressbar')
|
|
progress_bar.pack(fill="x", pady=(2, 8), padx=25)
|
|
progress_bar['value'] = (used / total) * 100
|
|
|
|
# Bind mouse wheel to progress bars too
|
|
progress_bar.bind("<MouseWheel>", _on_devices_mouse_wheel)
|
|
progress_bar.bind("<Button-4>", _on_devices_mouse_wheel)
|
|
progress_bar.bind("<Button-5>", _on_devices_mouse_wheel)
|
|
|
|
# Bind hover events for scrollbar visibility
|
|
progress_bar.bind("<Enter>", self._on_devices_enter)
|
|
progress_bar.bind("<Leave>", self._on_devices_leave)
|
|
except (FileNotFoundError, PermissionError):
|
|
# In case of errors (e.g., unreadable drive), just skip the progress bar
|
|
pass
|
|
|
|
# Separator before storage
|
|
tk.Frame(sidebar_frame, height=1, bg=separator_color).grid(
|
|
row=3, column=0, sticky="ew", padx=20, pady=15)
|
|
|
|
# Storage section at bottom - use pack instead of grid to stay at bottom
|
|
storage_frame = ttk.Frame(sidebar_frame, style="Sidebar.TFrame")
|
|
storage_frame.grid(row=5, column=0, sticky="sew", padx=10, pady=10)
|
|
self.storage_label = ttk.Label(
|
|
storage_frame, text="Freier Speicher:", background=self.freespace_background)
|
|
self.storage_label.pack(fill="x", padx=10)
|
|
self.storage_bar = ttk.Progressbar(
|
|
storage_frame, orient="horizontal", length=100, mode="determinate")
|
|
self.storage_bar.pack(fill="x", pady=(2, 5), padx=15)
|
|
|
|
# Content area
|
|
content_frame = ttk.Frame(paned_window, padding=(
|
|
0, 0, 0, 0), style="AccentBottom.TFrame")
|
|
paned_window.add(content_frame, weight=1)
|
|
|
|
content_frame.grid_rowconfigure(0, weight=1)
|
|
content_frame.grid_columnconfigure(0, weight=1)
|
|
|
|
self.file_list_frame = ttk.Frame(
|
|
content_frame, style="AccentBottom.TFrame")
|
|
self.file_list_frame.grid(row=0, column=0, sticky="nsew")
|
|
self.bind("<Configure>", self.on_window_resize)
|
|
|
|
# Bottom controls
|
|
bottom_controls_frame = ttk.Frame(
|
|
content_frame, style="AccentBottom.TFrame")
|
|
bottom_controls_frame.grid(row=1, column=0, sticky="ew", pady=(5, 0))
|
|
bottom_controls_frame.grid_columnconfigure(1, weight=1)
|
|
|
|
self.status_bar = ttk.Label(
|
|
bottom_controls_frame, text="", anchor="w", style="AccentBottom.TLabel")
|
|
self.status_bar.grid(row=0, column=1, columnspan=3,
|
|
sticky="ew", padx=10, pady=10)
|
|
|
|
ttk.Button(bottom_controls_frame, text="Öffnen",
|
|
command=self.on_open).grid(row=0, column=0, padx=(10, 0))
|
|
ttk.Button(bottom_controls_frame, text="Speichern",
|
|
command=self.on_save).grid(row=1, column=0, padx=(10, 0))
|
|
ttk.Button(bottom_controls_frame, text="Abbrechen",
|
|
command=self.on_cancel).grid(row=1, column=1, columnspan=3, padx=(10, 0))
|
|
|
|
self.filter_combobox = ttk.Combobox(
|
|
bottom_controls_frame, values=[ft[0] for ft in self.filetypes], state="readonly")
|
|
self.filter_combobox.grid(
|
|
row=1, column=2, sticky="w", padx=(0, 10), pady=(5, 10))
|
|
self.filter_combobox.bind(
|
|
"<<ComboboxSelected>>", self.on_filter_change)
|
|
self.filter_combobox.set(self.filetypes[0][0])
|
|
|
|
def toggle_hidden_files(self):
|
|
self.show_hidden_files.set(not self.show_hidden_files.get())
|
|
if self.show_hidden_files.get():
|
|
self.hidden_files_button.config(
|
|
image=self.icon_manager.get_icon('unhide'))
|
|
Tooltip(self.hidden_files_button, "Versteckte Dateien ausblenden")
|
|
else:
|
|
self.hidden_files_button.config(
|
|
image=self.icon_manager.get_icon('hide'))
|
|
Tooltip(self.hidden_files_button, "Versteckte Dateien anzeigen")
|
|
self.populate_files()
|
|
|
|
def on_window_resize(self, event):
|
|
new_width = self.file_list_frame.winfo_width()
|
|
if self.view_mode.get() == "icons" and abs(new_width - self.last_width) > 50:
|
|
if self.resize_job:
|
|
self.after_cancel(self.resize_job)
|
|
self.resize_job = self.after(200, self.populate_files)
|
|
self.last_width = new_width
|
|
|
|
def on_sidebar_resize(self, event):
|
|
current_width = event.width
|
|
# Define a threshold for when to hide/show text
|
|
threshold_width = 100 # Adjust this value as needed
|
|
|
|
if current_width < threshold_width:
|
|
# Hide text, show only icons
|
|
for btn, original_text in self.sidebar_buttons:
|
|
btn.config(text="", compound="top")
|
|
for btn, original_text in self.device_buttons:
|
|
btn.config(text="", compound="top")
|
|
else:
|
|
# Show text
|
|
for btn, original_text in self.sidebar_buttons:
|
|
btn.config(text=original_text, compound="left")
|
|
for btn, original_text in self.device_buttons:
|
|
btn.config(text=original_text, compound="left")
|
|
|
|
def _on_devices_enter(self, event):
|
|
"""Show scrollbar when mouse enters devices area"""
|
|
self.devices_scrollbar.grid(row=1, column=1, sticky="ns")
|
|
|
|
def _on_devices_leave(self, event):
|
|
"""Hide scrollbar when mouse leaves devices area"""
|
|
# Check if mouse is really leaving the devices area
|
|
x, y = event.x_root, event.y_root
|
|
widget_x = self.devices_canvas.winfo_rootx()
|
|
widget_y = self.devices_canvas.winfo_rooty()
|
|
widget_width = self.devices_canvas.winfo_width()
|
|
widget_height = self.devices_canvas.winfo_height()
|
|
|
|
# Add small buffer to prevent flickering
|
|
buffer = 5
|
|
if not (widget_x - buffer <= x <= widget_x + widget_width + buffer and
|
|
widget_y - buffer <= y <= widget_y + widget_height + buffer):
|
|
self.devices_scrollbar.grid_remove()
|
|
|
|
def toggle_search_mode(self):
|
|
"""Toggle between search mode and normal mode"""
|
|
if not self.search_mode:
|
|
# Enter search mode
|
|
self.search_mode = True
|
|
self.original_path_text = self.path_entry.get()
|
|
self.path_entry.delete(0, tk.END)
|
|
self.path_entry.insert(0, "Suchbegriff eingeben...")
|
|
self.path_entry.bind("<Return>", self.execute_search)
|
|
self.path_entry.bind("<FocusIn>", self.clear_search_placeholder)
|
|
|
|
# Show search options
|
|
self.search_options_frame.pack(side="left", padx=(5, 0))
|
|
else:
|
|
# Exit search mode
|
|
self.search_mode = False
|
|
self.path_entry.delete(0, tk.END)
|
|
self.path_entry.insert(0, self.original_path_text)
|
|
self.path_entry.bind(
|
|
"<Return>", lambda e: self.navigate_to(self.path_entry.get()))
|
|
self.path_entry.unbind("<FocusIn>")
|
|
|
|
# Hide search options
|
|
self.search_options_frame.pack_forget()
|
|
|
|
# Return to normal file view
|
|
self.populate_files()
|
|
|
|
def toggle_recursive_search(self):
|
|
"""Toggle recursive search on/off and update button style"""
|
|
self.recursive_search.set(not self.recursive_search.get())
|
|
if self.recursive_search.get():
|
|
self.recursive_button.configure(
|
|
style="Header.TButton.Active.Round")
|
|
else:
|
|
self.recursive_button.configure(
|
|
style="Header.TButton.Borderless.Round")
|
|
|
|
def set_icon_view(self):
|
|
"""Set icon view and update button styles"""
|
|
self.view_mode.set("icons")
|
|
self.icon_view_button.configure(style="Header.TButton.Active.Round")
|
|
self.list_view_button.configure(
|
|
style="Header.TButton.Borderless.Round")
|
|
self.populate_files()
|
|
|
|
def set_list_view(self):
|
|
"""Set list view and update button styles"""
|
|
self.view_mode.set("list")
|
|
self.list_view_button.configure(style="Header.TButton.Active.Round")
|
|
self.icon_view_button.configure(
|
|
style="Header.TButton.Borderless.Round")
|
|
self.populate_files()
|
|
|
|
def clear_search_placeholder(self, event):
|
|
"""Clear placeholder text when focus enters search field"""
|
|
if self.path_entry.get() == "Suchbegriff eingeben...":
|
|
self.path_entry.delete(0, tk.END)
|
|
|
|
def execute_search(self, event):
|
|
"""Execute search when Enter is pressed in search mode"""
|
|
search_term = self.path_entry.get().strip()
|
|
if not search_term or search_term == "Suchbegriff eingeben...":
|
|
return
|
|
|
|
# Clear previous search results
|
|
self.search_results.clear()
|
|
|
|
# Determine search directories
|
|
search_dirs = [self.current_dir]
|
|
|
|
# If searching from home directory, also include XDG directories
|
|
home_dir = os.path.expanduser("~")
|
|
if os.path.abspath(self.current_dir) == os.path.abspath(home_dir):
|
|
xdg_dirs = [
|
|
get_xdg_user_dir("XDG_DOWNLOAD_DIR", "Downloads"),
|
|
get_xdg_user_dir("XDG_DOCUMENTS_DIR", "Documents"),
|
|
get_xdg_user_dir("XDG_PICTURES_DIR", "Pictures"),
|
|
get_xdg_user_dir("XDG_MUSIC_DIR", "Music"),
|
|
get_xdg_user_dir("XDG_VIDEO_DIR", "Videos")
|
|
]
|
|
# Add XDG directories that exist and are not already in home
|
|
for xdg_dir in xdg_dirs:
|
|
if (os.path.exists(xdg_dir) and
|
|
os.path.abspath(xdg_dir) != os.path.abspath(home_dir) and
|
|
xdg_dir not in search_dirs):
|
|
search_dirs.append(xdg_dir)
|
|
|
|
try:
|
|
all_files = []
|
|
|
|
# Search in each directory
|
|
for search_dir in search_dirs:
|
|
if not os.path.exists(search_dir):
|
|
continue
|
|
|
|
# Change to directory and use relative paths to avoid path issues
|
|
original_cwd = os.getcwd()
|
|
try:
|
|
os.chdir(search_dir)
|
|
|
|
# Build find command based on recursive setting (use . for current directory)
|
|
if self.recursive_search.get():
|
|
find_cmd = ['find', '.', '-iname',
|
|
f'*{search_term}*', '-type', 'f']
|
|
else:
|
|
find_cmd = ['find', '.', '-maxdepth', '1',
|
|
'-iname', f'*{search_term}*', '-type', 'f']
|
|
|
|
result = subprocess.run(
|
|
find_cmd, capture_output=True, text=True, timeout=30)
|
|
|
|
if result.returncode == 0:
|
|
files = result.stdout.strip().split('\n')
|
|
# Convert relative paths back to absolute paths
|
|
directory_files = []
|
|
for f in files:
|
|
if f and f.startswith('./'):
|
|
abs_path = os.path.join(
|
|
search_dir, f[2:]) # Remove './' prefix
|
|
if os.path.isfile(abs_path):
|
|
directory_files.append(abs_path)
|
|
all_files.extend(directory_files)
|
|
|
|
finally:
|
|
os.chdir(original_cwd)
|
|
|
|
# Remove duplicates while preserving order
|
|
seen = set()
|
|
unique_files = []
|
|
for file_path in all_files:
|
|
if file_path not in seen:
|
|
seen.add(file_path)
|
|
unique_files.append(file_path)
|
|
|
|
# Filter based on currently selected filter pattern
|
|
self.search_results = []
|
|
for file_path in unique_files:
|
|
filename = os.path.basename(file_path)
|
|
if self._matches_filetype(filename):
|
|
self.search_results.append(file_path)
|
|
|
|
# Show search results in TreeView
|
|
if self.search_results:
|
|
self.show_search_results_treeview()
|
|
else:
|
|
MessageDialog(
|
|
message_type="info",
|
|
text=f"Keine Dateien mit '{search_term}' gefunden.",
|
|
title="Suche",
|
|
master=self
|
|
).show()
|
|
|
|
except subprocess.TimeoutExpired:
|
|
MessageDialog(
|
|
message_type="error",
|
|
text="Suche dauert zu lange und wurde abgebrochen.",
|
|
title="Suche",
|
|
master=self
|
|
).show()
|
|
except Exception as e:
|
|
MessageDialog(
|
|
message_type="error",
|
|
text=f"Fehler bei der Suche: {e}",
|
|
title="Suchfehler",
|
|
master=self
|
|
).show()
|
|
|
|
def show_search_results_treeview(self):
|
|
"""Show search results in TreeView format"""
|
|
# Clear current file list and replace with search results
|
|
for widget in self.file_list_frame.winfo_children():
|
|
widget.destroy()
|
|
|
|
# Create TreeView for search results
|
|
tree_frame = ttk.Frame(self.file_list_frame)
|
|
tree_frame.pack(fill='both', expand=True)
|
|
tree_frame.grid_rowconfigure(0, weight=1)
|
|
tree_frame.grid_columnconfigure(0, weight=1)
|
|
|
|
columns = ("path", "size", "modified")
|
|
search_tree = ttk.Treeview(
|
|
tree_frame, columns=columns, show="tree headings")
|
|
|
|
# Configure columns
|
|
search_tree.heading("#0", text="Dateiname", anchor="w")
|
|
search_tree.column("#0", anchor="w", width=200, stretch=True)
|
|
search_tree.heading("path", text="Pfad", anchor="w")
|
|
search_tree.column("path", anchor="w", width=300, stretch=True)
|
|
search_tree.heading("size", text="Größe", anchor="e")
|
|
search_tree.column("size", anchor="e", width=100, stretch=False)
|
|
search_tree.heading("modified", text="Geändert am", anchor="w")
|
|
search_tree.column("modified", anchor="w", width=160, stretch=False)
|
|
|
|
# Add scrollbars
|
|
v_scrollbar = ttk.Scrollbar(
|
|
tree_frame, orient="vertical", command=search_tree.yview)
|
|
h_scrollbar = ttk.Scrollbar(
|
|
tree_frame, orient="horizontal", command=search_tree.xview)
|
|
search_tree.configure(yscrollcommand=v_scrollbar.set,
|
|
xscrollcommand=h_scrollbar.set)
|
|
|
|
search_tree.grid(row=0, column=0, sticky='nsew')
|
|
v_scrollbar.grid(row=0, column=1, sticky='ns')
|
|
h_scrollbar.grid(row=1, column=0, sticky='ew')
|
|
|
|
# Populate with search results
|
|
for file_path in self.search_results:
|
|
try:
|
|
filename = os.path.basename(file_path)
|
|
directory = os.path.dirname(file_path)
|
|
stat = os.stat(file_path)
|
|
size = self._format_size(stat.st_size)
|
|
modified_time = datetime.fromtimestamp(
|
|
stat.st_mtime).strftime('%d.%m.%Y %H:%M')
|
|
|
|
icon = self.get_file_icon(filename, 'small')
|
|
search_tree.insert("", "end", text=f" {filename}", image=icon,
|
|
values=(directory, size, modified_time))
|
|
except (FileNotFoundError, PermissionError):
|
|
continue
|
|
|
|
# Bind double-click to select file
|
|
def on_search_double_click(event):
|
|
selection = search_tree.selection()
|
|
if selection:
|
|
item = search_tree.item(selection[0])
|
|
filename = item['text'].strip()
|
|
directory = item['values'][0]
|
|
full_path = os.path.join(directory, filename)
|
|
|
|
# Select the file and close dialog
|
|
self.selected_file = full_path
|
|
self.destroy()
|
|
|
|
search_tree.bind("<Double-1>", on_search_double_click)
|
|
|
|
def _unbind_mouse_wheel_events(self):
|
|
# Unbind all mouse wheel events from the root window
|
|
self.unbind_all("<MouseWheel>")
|
|
self.unbind_all("<Button-4>")
|
|
self.unbind_all("<Button-5>")
|
|
|
|
def populate_files(self):
|
|
# Unbind previous global mouse wheel events
|
|
self._unbind_mouse_wheel_events()
|
|
|
|
for widget in self.file_list_frame.winfo_children():
|
|
widget.destroy()
|
|
self.path_entry.delete(0, tk.END)
|
|
self.path_entry.insert(0, self.current_dir)
|
|
self.selected_file = None
|
|
self.update_status_bar()
|
|
if self.view_mode.get() == "list":
|
|
self.populate_list_view()
|
|
else:
|
|
self.populate_icon_view()
|
|
|
|
def _get_sorted_items(self):
|
|
try:
|
|
items = os.listdir(self.current_dir)
|
|
num_items = len(items)
|
|
warning_message = None
|
|
if num_items > MAX_ITEMS_TO_DISPLAY:
|
|
warning_message = f"Zeige {MAX_ITEMS_TO_DISPLAY} von {num_items} Einträgen."
|
|
items = items[:MAX_ITEMS_TO_DISPLAY]
|
|
dirs = sorted([d for d in items if os.path.isdir(
|
|
os.path.join(self.current_dir, d))], key=str.lower)
|
|
files = sorted([f for f in items if not os.path.isdir(
|
|
os.path.join(self.current_dir, f))], key=str.lower)
|
|
return (dirs + files, None, warning_message)
|
|
except PermissionError:
|
|
return ([], "Zugriff verweigert.", None)
|
|
except FileNotFoundError:
|
|
return ([], "Verzeichnis nicht gefunden.", None)
|
|
|
|
def populate_icon_view(self):
|
|
canvas = tk.Canvas(self.file_list_frame,
|
|
highlightthickness=0, bg=self.icon_bg_color)
|
|
v_scrollbar = ttk.Scrollbar(
|
|
self.file_list_frame, orient="vertical", command=canvas.yview)
|
|
canvas.pack(side="left", fill="both", expand=True)
|
|
v_scrollbar.pack(side="right", fill="y")
|
|
container_frame = ttk.Frame(canvas, style="Content.TFrame")
|
|
canvas.create_window((0, 0), window=container_frame, anchor="nw")
|
|
container_frame.bind("<Configure>", lambda e: canvas.configure(
|
|
scrollregion=canvas.bbox("all")))
|
|
|
|
def _on_mouse_wheel(event):
|
|
# Determine the scroll direction and magnitude
|
|
if event.num == 4: # Scroll up on Linux
|
|
delta = -1
|
|
elif event.num == 5: # Scroll down on Linux
|
|
delta = 1
|
|
else: # MouseWheel event for Windows/macOS
|
|
delta = -1 * int(event.delta / 120)
|
|
canvas.yview_scroll(delta, "units")
|
|
|
|
# Bind mouse wheel events to the canvas and the container frame
|
|
for widget in [canvas, container_frame]:
|
|
widget.bind("<MouseWheel>", _on_mouse_wheel)
|
|
widget.bind("<Button-4>", _on_mouse_wheel)
|
|
widget.bind("<Button-5>", _on_mouse_wheel)
|
|
|
|
items, error, warning = self._get_sorted_items()
|
|
if warning:
|
|
self.status_bar.config(text=warning)
|
|
if error:
|
|
ttk.Label(container_frame, text=error).pack(pady=20)
|
|
return
|
|
|
|
item_width, item_height = 125, 100
|
|
frame_width = self.file_list_frame.winfo_width()
|
|
col_count = max(1, frame_width // item_width - 1)
|
|
row, col = 0, 0
|
|
for name in items:
|
|
if not self.show_hidden_files.get() and name.startswith('.'):
|
|
continue
|
|
path = os.path.join(self.current_dir, name)
|
|
is_dir = os.path.isdir(path)
|
|
if not is_dir and not self._matches_filetype(name):
|
|
continue
|
|
|
|
item_frame = ttk.Frame(
|
|
container_frame, width=item_width, height=item_height, style="Item.TFrame")
|
|
item_frame.grid(row=row, column=col, padx=5, ipadx=25, pady=5)
|
|
item_frame.grid_propagate(False)
|
|
icon = self.icon_manager.get_icon('folder_large') if is_dir else self.get_file_icon(
|
|
name, 'large')
|
|
icon_label = ttk.Label(item_frame, image=icon, style="Icon.TLabel")
|
|
icon_label.pack(pady=(10, 5))
|
|
name_label = ttk.Label(item_frame, text=self.shorten_text(
|
|
name, 14), anchor="center", style="Item.TLabel")
|
|
name_label.pack(fill="x", expand=True)
|
|
Tooltip(item_frame, name)
|
|
# Bind events to all individual widgets so scrolling works everywhere
|
|
for widget in [item_frame, icon_label, name_label]:
|
|
widget.bind("<Double-Button-1>", lambda e,
|
|
p=path: self.on_item_double_click(p))
|
|
widget.bind("<Button-1>", lambda e, p=path,
|
|
f=item_frame: self.on_item_select(p, f))
|
|
widget.bind("<MouseWheel>", _on_mouse_wheel)
|
|
widget.bind("<Button-4>", _on_mouse_wheel)
|
|
widget.bind("<Button-5>", _on_mouse_wheel)
|
|
|
|
col = (col + 1) % col_count
|
|
if col == 0:
|
|
row += 1
|
|
|
|
def populate_list_view(self):
|
|
tree_frame = ttk.Frame(self.file_list_frame)
|
|
tree_frame.pack(fill='both', expand=True)
|
|
tree_frame.grid_rowconfigure(0, weight=1)
|
|
tree_frame.grid_columnconfigure(0, weight=1)
|
|
|
|
columns = ("size", "type", "modified")
|
|
self.tree = ttk.Treeview(
|
|
tree_frame, columns=columns, show="tree headings")
|
|
|
|
# Tree Column (#0)
|
|
self.tree.heading("#0", text="Name", anchor="w")
|
|
self.tree.column("#0", anchor="w", width=250, stretch=True)
|
|
|
|
# Other Columns
|
|
self.tree.heading("size", text="Größe", anchor="e")
|
|
self.tree.column("size", anchor="e", width=120, stretch=False)
|
|
self.tree.heading("type", text="Typ", anchor="w")
|
|
self.tree.column("type", anchor="w", width=120, stretch=False)
|
|
self.tree.heading("modified", text="Geändert am", anchor="w")
|
|
self.tree.column("modified", anchor="w", width=160, stretch=False)
|
|
|
|
v_scrollbar = ttk.Scrollbar(
|
|
tree_frame, orient="vertical", command=self.tree.yview)
|
|
h_scrollbar = ttk.Scrollbar(
|
|
tree_frame, orient="horizontal", command=self.tree.xview)
|
|
self.tree.configure(yscrollcommand=v_scrollbar.set,
|
|
xscrollcommand=h_scrollbar.set)
|
|
|
|
self.tree.grid(row=0, column=0, sticky='nsew')
|
|
v_scrollbar.grid(row=0, column=1, sticky='ns')
|
|
h_scrollbar.grid(row=1, column=0, sticky='ew')
|
|
|
|
self.tree.bind("<Double-1>", self.on_list_double_click)
|
|
self.tree.bind("<<TreeviewSelect>>", self.on_list_select)
|
|
|
|
items, error, warning = self._get_sorted_items()
|
|
if warning:
|
|
self.status_bar.config(text=warning)
|
|
if error:
|
|
self.tree.insert("", "end", text=error, values=())
|
|
return
|
|
|
|
for name in items:
|
|
if not self.show_hidden_files.get() and name.startswith('.'):
|
|
continue
|
|
path = os.path.join(self.current_dir, name)
|
|
is_dir = os.path.isdir(path)
|
|
if not is_dir and not self._matches_filetype(name):
|
|
continue
|
|
try:
|
|
stat = os.stat(path)
|
|
modified_time = datetime.fromtimestamp(
|
|
stat.st_mtime).strftime('%d.%m.%Y %H:%M')
|
|
if is_dir:
|
|
icon, file_type, size = self.icon_manager.get_icon(
|
|
'folder_small'), "Ordner", ""
|
|
else:
|
|
icon, file_type, size = self.get_file_icon(
|
|
name, 'small'), "Datei", self._format_size(stat.st_size)
|
|
self.tree.insert("", "end", text=f" {name}", image=icon, values=(
|
|
size, file_type, modified_time))
|
|
except (FileNotFoundError, PermissionError):
|
|
continue
|
|
|
|
def on_item_select(self, path, item_frame):
|
|
if hasattr(self, 'selected_item_frame') and self.selected_item_frame.winfo_exists():
|
|
self.selected_item_frame.state(['!selected'])
|
|
for child in self.selected_item_frame.winfo_children():
|
|
if isinstance(child, ttk.Label):
|
|
child.state(['!selected'])
|
|
item_frame.state(['selected'])
|
|
for child in item_frame.winfo_children():
|
|
if isinstance(child, ttk.Label):
|
|
child.state(['selected'])
|
|
self.selected_item_frame = item_frame
|
|
self.selected_file = path
|
|
self.update_status_bar()
|
|
|
|
def on_list_select(self, event):
|
|
if not self.tree.selection():
|
|
return
|
|
item_id = self.tree.selection()[0]
|
|
item_text = self.tree.item(item_id, 'text').strip()
|
|
self.selected_file = os.path.join(self.current_dir, item_text)
|
|
self.update_status_bar()
|
|
|
|
def _handle_unsupported_file(self, path):
|
|
if path.lower().endswith('.svg'):
|
|
self.status_bar.config(
|
|
text="SVG-Dateien werden nicht unterstützt.")
|
|
return True
|
|
return False
|
|
|
|
def on_item_double_click(self, path):
|
|
if self._handle_unsupported_file(path):
|
|
return
|
|
if os.path.isdir(path):
|
|
self.navigate_to(path)
|
|
else:
|
|
self.selected_file = path
|
|
self.destroy()
|
|
|
|
def on_list_double_click(self, event):
|
|
if not self.tree.selection():
|
|
return
|
|
item_id = self.tree.selection()[0]
|
|
item_text = self.tree.item(item_id, 'text').strip()
|
|
path = os.path.join(self.current_dir, item_text)
|
|
if self._handle_unsupported_file(path):
|
|
return
|
|
if os.path.isdir(path):
|
|
self.navigate_to(path)
|
|
else:
|
|
self.selected_file = path
|
|
self.destroy()
|
|
|
|
def on_filter_change(self, event):
|
|
selected_desc = self.filter_combobox.get()
|
|
for desc, pattern in self.filetypes:
|
|
if desc == selected_desc:
|
|
self.current_filter_pattern = pattern
|
|
break
|
|
self.populate_files()
|
|
|
|
def navigate_to(self, path):
|
|
try:
|
|
real_path = os.path.realpath(
|
|
os.path.abspath(os.path.expanduser(path)))
|
|
if not os.path.isdir(real_path):
|
|
self.status_bar.config(
|
|
text=f"Fehler: Verzeichnis '{os.path.basename(path)}' nicht gefunden.")
|
|
return
|
|
if not os.access(real_path, os.R_OK):
|
|
self.status_bar.config(
|
|
text=f"Zugriff auf '{os.path.basename(path)}' verweigert.")
|
|
return
|
|
self.current_dir = real_path
|
|
if self.history_pos < len(self.history) - 1:
|
|
self.history = self.history[:self.history_pos + 1]
|
|
if not self.history or self.history[-1] != self.current_dir:
|
|
self.history.append(self.current_dir)
|
|
self.history_pos = len(self.history) - 1
|
|
self.populate_files()
|
|
self.update_nav_buttons()
|
|
self.update_status_bar()
|
|
except Exception as e:
|
|
self.status_bar.config(text=f"Fehler: {e}")
|
|
|
|
def go_back(self):
|
|
if self.history_pos > 0:
|
|
self.history_pos -= 1
|
|
self.current_dir = self.history[self.history_pos]
|
|
self.populate_files()
|
|
self.update_nav_buttons()
|
|
self.update_status_bar()
|
|
|
|
def go_forward(self):
|
|
if self.history_pos < len(self.history) - 1:
|
|
self.history_pos += 1
|
|
self.current_dir = self.history[self.history_pos]
|
|
self.populate_files()
|
|
self.update_nav_buttons()
|
|
self.update_status_bar()
|
|
|
|
def update_nav_buttons(self):
|
|
self.back_button.config(
|
|
state=tk.NORMAL if self.history_pos > 0 else tk.DISABLED)
|
|
self.forward_button.config(state=tk.NORMAL if self.history_pos < len(
|
|
self.history) - 1 else tk.DISABLED)
|
|
|
|
def update_status_bar(self):
|
|
try:
|
|
total, used, free = shutil.disk_usage(self.current_dir)
|
|
free_str = self._format_size(free)
|
|
self.storage_label.config(text=f"Freier Speicher: {free_str}")
|
|
self.storage_bar['value'] = (used / total) * 100
|
|
|
|
status_text = ""
|
|
if self.selected_file and os.path.exists(self.selected_file) and not os.path.isdir(self.selected_file):
|
|
size = os.path.getsize(self.selected_file)
|
|
size_str = self._format_size(size)
|
|
status_text = f"'{os.path.basename(self.selected_file)}' Größe: {size_str}"
|
|
self.status_bar.config(text=status_text)
|
|
except FileNotFoundError:
|
|
self.status_bar.config(text="Verzeichnis nicht gefunden")
|
|
self.storage_label.config(text="Freier Speicher: Unbekannt")
|
|
self.storage_bar['value'] = 0
|
|
|
|
def on_open(self):
|
|
if self.selected_file and os.path.isfile(self.selected_file):
|
|
if self._handle_unsupported_file(self.selected_file):
|
|
return
|
|
self.destroy()
|
|
|
|
def on_save(self):
|
|
pass
|
|
|
|
def on_cancel(self):
|
|
self.selected_file = None
|
|
self.destroy()
|
|
|
|
def get_selected_file(self):
|
|
return self.selected_file
|
|
|
|
def _matches_filetype(self, filename):
|
|
if self.current_filter_pattern == "*.*":
|
|
return True
|
|
patterns = self.current_filter_pattern.replace(
|
|
"*.", "").lower().split()
|
|
fn_lower = filename.lower()
|
|
for p in patterns:
|
|
if fn_lower.endswith(p):
|
|
return True
|
|
return False
|
|
|
|
def _format_size(self, size_bytes):
|
|
if size_bytes is None:
|
|
return ""
|
|
if size_bytes < 1024:
|
|
return f"{size_bytes} B"
|
|
if size_bytes < 1024**2:
|
|
return f"{size_bytes/1024:.1f} KB"
|
|
if size_bytes < 1024**3:
|
|
return f"{size_bytes/1024**2:.1f} MB"
|
|
return f"{size_bytes/1024**3:.1f} GB"
|
|
|
|
def shorten_text(self, text, max_len):
|
|
return text if len(text) <= max_len else text[:max_len-3] + "..."
|
|
|
|
def _get_mounted_devices(self):
|
|
devices = []
|
|
root_disk_name = None
|
|
try:
|
|
result = subprocess.run(['lsblk', '-J', '-o', 'NAME,MOUNTPOINT,FSTYPE,SIZE,RO,RM,TYPE,LABEL,PKNAME'],
|
|
capture_output=True, text=True, check=True)
|
|
data = json.loads(result.stdout)
|
|
|
|
# First pass: Find the root disk name
|
|
for block_device in data.get('blockdevices', []):
|
|
if 'children' in block_device:
|
|
for child_device in block_device['children']:
|
|
if child_device.get('mountpoint') == '/':
|
|
root_disk_name = block_device.get('name')
|
|
break
|
|
if root_disk_name:
|
|
break
|
|
|
|
# Second pass: Collect devices based on new criteria
|
|
for block_device in data.get('blockdevices', []):
|
|
# Process main device if it has a mountpoint
|
|
if block_device.get('mountpoint') and \
|
|
block_device.get('type') not in ['loop', 'rom'] and \
|
|
block_device.get('mountpoint') != '/': # Exclude root mountpoint itself
|
|
|
|
# Exclude non-removable partitions of the root disk
|
|
if block_device.get('name').startswith(root_disk_name) and not block_device.get('rm', False):
|
|
pass # Skip this device
|
|
else:
|
|
name = block_device.get('name')
|
|
mountpoint = block_device.get('mountpoint')
|
|
label = block_device.get('label')
|
|
removable = block_device.get('rm', False)
|
|
|
|
display_name = label if label else name
|
|
devices.append((display_name, mountpoint, removable))
|
|
|
|
# Process children (partitions)
|
|
if 'children' in block_device:
|
|
for child_device in block_device['children']:
|
|
if child_device.get('mountpoint') and \
|
|
child_device.get('type') not in ['loop', 'rom'] and \
|
|
child_device.get('mountpoint') != '/': # Exclude root mountpoint itself
|
|
|
|
# Exclude non-removable partitions of the root disk
|
|
if block_device.get('name') == root_disk_name and not child_device.get('rm', False):
|
|
pass # Skip this partition
|
|
else:
|
|
name = child_device.get('name')
|
|
mountpoint = child_device.get('mountpoint')
|
|
label = child_device.get('label')
|
|
removable = child_device.get('rm', False)
|
|
|
|
display_name = label if label else name
|
|
devices.append(
|
|
(display_name, mountpoint, removable))
|
|
|
|
except Exception as e:
|
|
print(f"Error getting mounted devices: {e}")
|
|
return devices
|