`7ad6d3f`

refactor, focus issues fixed?, stable I think

Authored by

espadonne 10 months ago

SHA: 7ad6d3f464543ccd5f1fc0a68af294517a65352f
Parents: 24cbe9c
Tree: 8e1cf94

16 changed files

Status	File	+	-
M	`src/wulftp/__init__.py`	6	2
A	`src/wulftp/core/__init__.py`	27	0
A	`src/wulftp/core/constants.py`	166	0
A	`src/wulftp/core/file_transfer.py`	181	0
A	`src/wulftp/core/ssh_manager.py`	65	0
A	`src/wulftp/main.py`	30	0
A	`src/wulftp/models/__init__.py`	13	0
R	`src/wulftp/remote_model.py` → `src/wulftp/models/remote_model.py`	0	0
D	`src/wulftp/sftp_backend.py`	0	61
A	`src/wulftp/ui/__init__.py`	23	0
A	`src/wulftp/ui/components.py`	566	0
A	`src/wulftp/ui/main_window.py`	730	0
A	`src/wulftp/ui/widgets.py`	81	0
A	`src/wulftp/utils/__init__.py`	25	0
A	`src/wulftp/utils/helpers.py`	326	0
D	`src/wulftp/wulftp.py`	0	1467

src/wulftp/__init__.pymodified

  """
 -package entry point for wulftp.
 +wulFTP - A modern SFTP client with PyQt6.
  """
 -from .wulftp import main
 +from .main import main
++
 +__version__ = "0.1.0"
 +__author__ = "mfw"
 +__all__ = ["main"]

src/wulftp/core/__init__.pyadded

 +"""Core functionality for wulFTP."""
++
 +from .constants import Icons, FileTypes, AppConfig, Styles, Permissions
 +from .file_transfer import (
 +    FileTransferManager,
 +    TransferWorker,
 +    DirectoryTransferWorker,
 +    WorkerSignals
 +)
 +from .ssh_manager import SSHHost, load_ssh_config
++
 +__all__ = [
 +    # Constants
 +    "Icons",
 +    "FileTypes",
 +    "AppConfig",
 +    "Styles",
 +    "Permissions",
 +    # File transfer
 +    "FileTransferManager",
 +    "TransferWorker",
 +    "DirectoryTransferWorker",
 +    "WorkerSignals",
 +    # SSH management
 +    "SSHHost",
 +    "load_ssh_config"
 +]

src/wulftp/core/constants.pyadded

 +"""Constants and configuration for wulFTP."""
++
 +from dataclasses import dataclass
 +from typing import Tuple, List
++
++
 +@dataclass
 +class IconConfig:
 +    """Icon configuration with name and color"""
 +    name: str
 +    color: str = "#000000"
++
 +    def to_tuple(self) -> Tuple[str, dict]:
 +        """Convert to tuple for qtawesome"""
 +        return (self.name, {"color": self.color})
++
++
 +class Icons:
 +    """Application icons"""
 +    # Connection
 +    CONNECT = IconConfig("fa5s.plug", "#4CAF50")
 +    DISCONNECT = IconConfig("fa5s.unlink", "#F44336")
 +    CONNECTED = IconConfig("fa5s.link", "#4CAF50")
 +    DISCONNECTED = IconConfig("fa5s.unlink", "#F44336")
++
 +    # File operations
 +    UPLOAD = IconConfig("fa5s.upload", "#4CAF50")
 +    DOWNLOAD = IconConfig("fa5s.download", "#2196F3")
 +    DELETE = IconConfig("fa5s.trash", "#F44336")
 +    DELETE_DISABLED = IconConfig("fa5s.trash", "#888888")
 +    REFRESH = IconConfig("fa5s.sync", "#FF9800")
++
 +    # Navigation
 +    UP = IconConfig("fa5s.arrow-up")
 +    HOME = IconConfig("fa5s.home")
 +    FOLDER_NEW = IconConfig("fa5s.folder-plus", "#FF9800")
++
 +    # File types
 +    FOLDER = IconConfig("fa5s.folder", "#FFD93D")
 +    FOLDER_OPEN = IconConfig("fa5s.folder-open")
 +    FILE = IconConfig("fa5s.file", "#6C757D")
 +    FILE_TEXT = IconConfig("fa5s.file-alt", "#6C757D")
 +    FILE_CODE = IconConfig("fa5s.file-code", "#28A745")
 +    FILE_IMAGE = IconConfig("fa5s.file-image", "#17A2B8")
 +    FILE_AUDIO = IconConfig("fa5s.file-audio", "#FD7E14")
 +    FILE_VIDEO = IconConfig("fa5s.file-video", "#DC3545")
 +    FILE_ARCHIVE = IconConfig("fa5s.file-archive", "#6F42C1")
 +    FILE_PDF = IconConfig("fa5s.file-pdf", "#DC3545")
 +    LINK = IconConfig("fa5s.link")
++
++
 +class FileTypes:
 +    """File type extensions grouped by category"""
 +    TEXT = [".txt", ".md", ".log", ".rst", ".tex", ".rtf"]
 +    CODE = [".py", ".js", ".cpp", ".c", ".java", ".cs", ".rb", ".go", ".rs",
 +            ".php", ".swift", ".kt", ".scala", ".r", ".m", ".h", ".hpp",
 +            ".css", ".html", ".xml", ".json", ".yaml", ".yml", ".toml"]
 +    IMAGE = [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg", ".ico",
 +             ".webp", ".tiff", ".tif", ".raw", ".heic"]
 +    AUDIO = [".mp3", ".wav", ".flac", ".ogg", ".m4a", ".aac", ".wma",
 +             ".opus", ".ape", ".mid", ".midi"]
 +    VIDEO = [".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".webm",
 +             ".m4v", ".mpg", ".mpeg", ".3gp"]
 +    ARCHIVE = [".zip", ".tar", ".gz", ".bz2", ".xz", ".7z", ".rar",
 +               ".tar.gz", ".tar.bz2", ".tar.xz", ".tgz"]
 +    PDF = [".pdf"]
++
 +    @classmethod
 +    def get_category(cls, extension: str) -> str:
 +        """Get the category for a file extension"""
 +        ext = extension.lower()
 +        if ext in cls.TEXT:
 +            return "text"
 +        elif ext in cls.CODE:
 +            return "code"
 +        elif ext in cls.IMAGE:
 +            return "image"
 +        elif ext in cls.AUDIO:
 +            return "audio"
 +        elif ext in cls.VIDEO:
 +            return "video"
 +        elif ext in cls.ARCHIVE:
 +            return "archive"
 +        elif ext in cls.PDF:
 +            return "pdf"
 +        else:
 +            return "file"
++
++
 +class AppConfig:
 +    """Application configuration"""
 +    # Window settings
 +    WINDOW_TITLE = "wulFTP - Family Backup Tool"
 +    WINDOW_X = 100
 +    WINDOW_Y = 100
 +    WINDOW_WIDTH = 1200
 +    WINDOW_HEIGHT = 800
++
 +    # UI settings
 +    ICON_SIZE = 24
 +    STATUS_MESSAGE_TIMEOUT = 3000
++
 +    # Pane settings
 +    SPLITTER_SIZES = [600, 600]
++
 +    # Toolbar settings
 +    HOST_COMBO_MIN_WIDTH = 250
 +    HOST_COMBO_MAX_WIDTH = 350
 +    CUSTOM_HOST_MAX_WIDTH = 150
 +    CUSTOM_USER_MAX_WIDTH = 100
++
 +    # Navigation button size
 +    NAV_BUTTON_SIZE = 30
++
 +    # Column widths
 +    COLUMN_SIZE = 100
 +    COLUMN_TYPE = 100
 +    COLUMN_DATE = 120
++
 +    # Connection settings
 +    CONNECTION_TIMEOUT = 10
++
 +    # UI Messages
 +    MSG_CONNECTED = "Connected to {}"
 +    MSG_DISCONNECTED = "Disconnected"
 +    MSG_CONNECTING = "Connecting..."
 +    MSG_UPLOAD_DIR = "Uploading directory: {}"
 +    MSG_DOWNLOAD_DIR = "Downloading directory: {}"
 +    MSG_TRANSFER_COMPLETE = "Transfer complete"
 +    MSG_DELETE_COMPLETE = "Deleted {} item(s)"
 +    MSG_CREATE_DIR = "Created directory: {}"
 +    MSG_CREATE_REMOTE_DIR = "Created remote directory: {}"
++
++
 +class Styles:
 +    """UI Styles"""
 +    PATH_EDIT = """
 +        QLineEdit {
 +            background-color: #2b2b2b;
 +            color: #ffffff;
 +            border: 1px solid #555555;
 +            padding: 4px;
 +            font-family: monospace;
 +        }
 +    """
++
 +    TITLE_LABEL = "font-weight: bold; font-size: 14px;"
++
++
 +class Permissions:
 +    """Unix permission bits"""
 +    # File types
 +    S_IFDIR = 0o040000  # directory
 +    S_IFREG = 0o100000  # regular file
 +    S_IFLNK = 0o120000  # symbolic link
++
 +    # Permissions
 +    S_IRUSR = 0o400  # owner read
 +    S_IWUSR = 0o200  # owner write
 +    S_IXUSR = 0o100  # owner execute
 +    S_IRGRP = 0o040  # group read
 +    S_IWGRP = 0o020  # group write
 +    S_IXGRP = 0o010  # group execute
 +    S_IROTH = 0o004  # other read
 +    S_IWOTH = 0o002  # other write
 +    S_IXOTH = 0o001  # other execute

src/wulftp/core/file_transfer.pyadded

 +"""File transfer operations for wulFTP."""
++
 +import os
 +import stat
 +from typing import Optional
++
 +from PyQt6.QtCore import QObject, QRunnable, pyqtSignal
++
++
 +class WorkerSignals(QObject):
 +    """Signals for thread workers"""
++
 +    finished = pyqtSignal()
 +    error = pyqtSignal(str)
 +    progress = pyqtSignal(int)
 +    result = pyqtSignal(object)
++
++
 +class TransferWorker(QRunnable):
 +    """Worker for file transfers"""
++
 +    def __init__(self, sftp, source: str, dest: str, is_upload: bool = True):
 +        super().__init__()
 +        self.sftp = sftp
 +        self.source = source
 +        self.dest = dest
 +        self.is_upload = is_upload
 +        self.signals = WorkerSignals()
++
 +    def run(self):
 +        """Execute the transfer"""
 +        try:
 +            if self.is_upload:
 +                self.sftp.put(self.source, self.dest, callback=self._progress_callback)
 +            else:
 +                self.sftp.get(self.source, self.dest, callback=self._progress_callback)
 +            self.signals.finished.emit()
 +        except Exception as e:
 +            self.signals.error.emit(str(e))
++
 +    def _progress_callback(self, transferred: int, total: int):
 +        """Update progress during transfer"""
 +        if total > 0:
 +            progress = int((transferred / total) * 100)
 +            self.signals.progress.emit(progress)
++
++
 +class DirectoryTransferWorker(QRunnable):
 +    """Worker for directory transfers"""
++
 +    def __init__(self, sftp, source_dir: str, dest_dir: str, is_upload: bool = True):
 +        super().__init__()
 +        self.sftp = sftp
 +        self.source_dir = source_dir
 +        self.dest_dir = dest_dir
 +        self.is_upload = is_upload
 +        self.signals = WorkerSignals()
 +        self.total_files = 0
 +        self.processed_files = 0
++
 +    def run(self):
 +        """Execute the directory transfer"""
 +        try:
 +            if self.is_upload:
 +                self._upload_directory(self.source_dir, self.dest_dir)
 +            else:
 +                self._download_directory(self.source_dir, self.dest_dir)
 +            self.signals.finished.emit()
 +        except Exception as e:
 +            self.signals.error.emit(str(e))
++
 +    def _count_files(self, local_path: str) -> int:
 +        """Count total files in a local directory recursively"""
 +        count = 0
 +        for root, dirs, files in os.walk(local_path):
 +            count += len(files)
 +        return count
++
 +    def _count_remote_files(self, remote_path: str) -> int:
 +        """Count total files in a remote directory recursively"""
 +        count = 0
 +        try:
 +            for item in self.sftp.listdir_attr(remote_path):
 +                item_path = os.path.join(remote_path, item.filename)
 +                if stat.S_ISDIR(item.st_mode):
 +                    count += self._count_remote_files(item_path)
 +                else:
 +                    count += 1
 +        except:
 +            pass
 +        return count
++
 +    def _upload_directory(self, local_path: str, remote_path: str):
 +        """Recursively upload a directory"""
 +        # Count total files first
 +        if self.total_files == 0:
 +            self.total_files = self._count_files(local_path)
++
 +        # Create remote directory
 +        try:
 +            self.sftp.mkdir(remote_path)
 +        except:
 +            # Directory might already exist
 +            pass
++
 +        # Upload contents
 +        for item in os.listdir(local_path):
 +            local_item = os.path.join(local_path, item)
 +            remote_item = os.path.join(remote_path, item).replace('\\', '/')
++
 +            if os.path.isdir(local_item):
 +                self._upload_directory(local_item, remote_item)
 +            else:
 +                # Upload file
 +                self.sftp.put(local_item, remote_item)
 +                self.processed_files += 1
 +                if self.total_files > 0:
 +                    progress = int((self.processed_files / self.total_files) * 100)
 +                    self.signals.progress.emit(progress)
++
 +    def _download_directory(self, remote_path: str, local_path: str):
 +        """Recursively download a directory"""
 +        # Count total files first
 +        if self.total_files == 0:
 +            self.total_files = self._count_remote_files(remote_path)
++
 +        # Create local directory
 +        os.makedirs(local_path, exist_ok=True)
++
 +        # Download contents
 +        for item in self.sftp.listdir_attr(remote_path):
 +            remote_item = os.path.join(remote_path, item.filename).replace('\\', '/')
 +            local_item = os.path.join(local_path, item.filename)
++
 +            if stat.S_ISDIR(item.st_mode):
 +                self._download_directory(remote_item, local_item)
 +            else:
 +                # Download file
 +                self.sftp.get(remote_item, local_item)
 +                self.processed_files += 1
 +                if self.total_files > 0:
 +                    progress = int((self.processed_files / self.total_files) * 100)
 +                    self.signals.progress.emit(progress)
++
++
 +class FileTransferManager:
 +    """Manages file transfer operations"""
++
 +    def __init__(self, sftp, threadpool):
 +        self.sftp = sftp
 +        self.threadpool = threadpool
++
 +    def transfer_file(self, source: str, dest: str, is_upload: bool,
 +                     progress_callback=None, complete_callback=None, error_callback=None):
 +        """Start a single file transfer"""
 +        worker = TransferWorker(self.sftp, source, dest, is_upload)
++
 +        if progress_callback:
 +            worker.signals.progress.connect(progress_callback)
 +        if complete_callback:
 +            worker.signals.finished.connect(complete_callback)
 +        if error_callback:
 +            worker.signals.error.connect(error_callback)
++
 +        self.threadpool.start(worker)
 +        return worker
++
 +    def transfer_directory(self, source_dir: str, dest_dir: str, is_upload: bool,
 +                          progress_callback=None, complete_callback=None, error_callback=None):
 +        """Start a directory transfer"""
 +        worker = DirectoryTransferWorker(self.sftp, source_dir, dest_dir, is_upload)
++
 +        if progress_callback:
 +            worker.signals.progress.connect(progress_callback)
 +        if complete_callback:
 +            worker.signals.finished.connect(complete_callback)
 +        if error_callback:
 +            worker.signals.error.connect(error_callback)
++
 +        self.threadpool.start(worker)
 +        return worker

src/wulftp/core/ssh_manager.pyadded

 +"""SSH/SFTP connection management for wulFTP."""
++
 +import os
 +from dataclasses import dataclass
 +from pathlib import Path
 +from typing import Dict, Optional
++
 +import paramiko
 +from paramiko import SSHConfig
 +from dotenv import load_dotenv
++
 +# Load environment variables
 +load_dotenv()
++
++
 +@dataclass
 +class SSHHost:
 +    """Represents an SSH host configuration."""
 +    alias: str
 +    hostname: str
 +    port: int = 22
 +    user: Optional[str] = None
 +    key_file: Optional[str] = None
++
 +    def display_name(self) -> str:
 +        """Get display name for UI."""
 +        if self.user:
 +            return f"{self.alias} ({self.user}@{self.hostname})"
 +        return f"{self.alias} ({self.hostname})"
++
++
 +def load_ssh_config() -> Dict[str, SSHHost]:
 +    """Load SSH hosts from ~/.ssh/config and environment."""
 +    hosts = {}
 +    config_path = Path.home() / ".ssh" / "config"
++
 +    if config_path.exists():
 +        config = SSHConfig()
 +        with open(config_path) as f:
 +            config.parse(f)
++
 +        for host in config.get_hostnames():
 +            if host == "*":
 +                continue
++
 +            cfg = config.lookup(host)
 +            hosts[host] = SSHHost(
 +                alias=host,
 +                hostname=cfg.get("hostname", host),
 +                port=int(cfg.get("port", 22)),
 +                user=cfg.get("user"),
 +                key_file=cfg.get("identityfile", [None])[0],
 +            )
++
 +    # Add custom hosts from environment
 +    if os.getenv("WULFTP_HOST"):
 +        hosts["env_default"] = SSHHost(
 +            alias="Default",
 +            hostname=os.getenv("WULFTP_HOST"),
 +            port=int(os.getenv("WULFTP_PORT", "22")),
 +            user=os.getenv("WULFTP_USER"),
 +            key_file=os.getenv("WULFTP_KEY"),
 +        )
++
 +    return hosts

src/wulftp/main.pyadded

 +"""Main entry point for wulFTP application."""
++
 +import sys
 +from dotenv import load_dotenv
 +from PyQt6.QtWidgets import QApplication
++
 +from .ui import WulFTPClient
++
 +# Load environment variables
 +load_dotenv()
++
++
 +def create_application():
 +    """Create and configure the Qt application."""
 +    app = QApplication(sys.argv)
 +    app.setApplicationName("wulFTP")
 +    app.setStyle("Fusion")
 +    return app
++
++
 +def main():
 +    """Application entry point."""
 +    app = create_application()
 +    window = WulFTPClient()
 +    window.show()
 +    sys.exit(app.exec())
++
++
 +if __name__ == "__main__":
 +    main()

src/wulftp/models/__init__.pyadded

 +"""Data models for wulFTP."""
++
 +from .remote_model import (
 +    RemoteFileSystemModel,
 +    RemoteFileInfo,
 +    RemoteColumn
 +)
++
 +__all__ = [
 +    "RemoteFileSystemModel",
 +    "RemoteFileInfo",
 +    "RemoteColumn"
 +]

src/wulftp/remote_model.py → src/wulftp/models/remote_model.pyrenamed (62% similarity)

  import stat
  from datetime import datetime
  from enum import IntEnum
 -from typing import Any, Dict, List, Optional, Union
 +from typing import Any, Dict, List, Optional, Union, Set
  import qtawesome as qta
  from paramiko import SFTPAttributes, SFTPClient
+ )
  from PyQt6.QtGui import QIcon
 +from ..core.constants import Icons, FileTypes
 +from ..utils import (
 +    format_bytes,
 +    format_timestamp,
 +    format_permissions,
 +    get_file_type_description,
 +    is_hidden_file
 +)
++
  class RemoteFileInfo:
      """Represents a remote file or directory"""
      @property
      def is_hidden(self) -> bool:
          """Check if this is a hidden file (starts with .)"""
 -        return self.name.startswith(".")
 +        return is_hidden_file(self.name)
      @property
      def size_str(self) -> str:
          """Human-readable file size"""
          if self.is_dir:
              return ""
+-
 -        size = self.attr.st_size
 -        for unit in ["B", "KB", "MB", "GB", "TB"]:
 -            if size < 1024.0:
 -                return f"{size:.1f} {unit}"
 -            size /= 1024.0
 -        return f"{size:.1f} PB"
 +        return format_bytes(self.attr.st_size)
      @property
      def modified_str(self) -> str:
          """Human-readable modification time"""
 -        if self.attr.st_mtime:
 -            dt = datetime.fromtimestamp(self.attr.st_mtime)
 -            return dt.strftime("%Y-%m-%d %H:%M")
 -        return ""
 +        return format_timestamp(self.attr.st_mtime)
      @property
      def permissions_str(self) -> str:
          """Unix-style permissions string"""
 -        mode = self.attr.st_mode
 -        perms = ["-"] * 10
+-
 -        # File type
 -        if stat.S_ISDIR(mode):
 -            perms[0] = "d"
 -        elif stat.S_ISLNK(mode):
 -            perms[0] = "l"
 -        elif stat.S_ISREG(mode):
 -            perms[0] = "-"
+-
 -        # Permissions
 -        mode_bits = [
 -            (stat.S_IRUSR, 1, "r"),
 -            (stat.S_IWUSR, 2, "w"),
 -            (stat.S_IXUSR, 3, "x"),
 -            (stat.S_IRGRP, 4, "r"),
 -            (stat.S_IWGRP, 5, "w"),
 -            (stat.S_IXGRP, 6, "x"),
 -            (stat.S_IROTH, 7, "r"),
 -            (stat.S_IWOTH, 8, "w"),
 -            (stat.S_IXOTH, 9, "x"),
 -        ]
+-
 -        for bit, pos, char in mode_bits:
 -            if mode & bit:
 -                perms[pos] = char
+-
 -        return "".join(perms)
 +        return format_permissions(self.attr.st_mode)
      def icon(self) -> QIcon:
          """Get appropriate icon for file type"""
                                           options=[{}, {"scale_factor": 0.6,
                                                        "offset": (0.4, 0.4)}])
              elif self.is_dir:
 -                self._icon = qta.icon("fa5s.folder", color="#FFD93D")
 +                self._icon = qta.icon(Icons.FOLDER.name, color=Icons.FOLDER.color)
              else:
                  # File icon based on extension
                  ext = os.path.splitext(self.name)[1].lower()
 -                if ext in [".txt", ".md", ".log"]:
 -                    self._icon = qta.icon("fa5s.file-alt", color="#6C757D")
 -                elif ext in [".py", ".js", ".cpp", ".c", ".java"]:
 -                    self._icon = qta.icon("fa5s.file-code", color="#28A745")
 -                elif ext in [".jpg", ".png", ".gif", ".bmp"]:
 -                    self._icon = qta.icon("fa5s.file-image", color="#17A2B8")
 -                elif ext in [".mp3", ".wav", ".flac", ".ogg"]:
 -                    self._icon = qta.icon("fa5s.file-audio", color="#FD7E14")
 -                elif ext in [".mp4", ".avi", ".mkv", ".mov"]:
 -                    self._icon = qta.icon("fa5s.file-video", color="#DC3545")
 -                elif ext in [".zip", ".tar", ".gz", ".7z", ".rar"]:
 -                    self._icon = qta.icon("fa5s.file-archive", color="#6F42C1")
 -                elif ext in [".pdf"]:
 -                    self._icon = qta.icon("fa5s.file-pdf", color="#DC3545")
++
 +                # Check file types
 +                if ext in FileTypes.TEXT:
 +                    self._icon = qta.icon(Icons.FILE_TEXT.name, color=Icons.FILE_TEXT.color)
 +                elif ext in FileTypes.CODE:
 +                    self._icon = qta.icon(Icons.FILE_CODE.name, color=Icons.FILE_CODE.color)
 +                elif ext in FileTypes.IMAGE:
 +                    self._icon = qta.icon(Icons.FILE_IMAGE.name, color=Icons.FILE_IMAGE.color)
 +                elif ext in FileTypes.AUDIO:
 +                    self._icon = qta.icon(Icons.FILE_AUDIO.name, color=Icons.FILE_AUDIO.color)
 +                elif ext in FileTypes.VIDEO:
 +                    self._icon = qta.icon(Icons.FILE_VIDEO.name, color=Icons.FILE_VIDEO.color)
 +                elif ext in FileTypes.ARCHIVE:
 +                    self._icon = qta.icon(Icons.FILE_ARCHIVE.name, color=Icons.FILE_ARCHIVE.color)
 +                elif ext in FileTypes.PDF:
 +                    self._icon = qta.icon(Icons.FILE_PDF.name, color=Icons.FILE_PDF.color)
                  else:
 -                    self._icon = qta.icon("fa5s.file", color="#6C757D")
 +                    self._icon = qta.icon(Icons.FILE.name, color=Icons.FILE.color)
          return self._icon
      directoryLoaded = pyqtSignal(str)  # Emitted when a directory is loaded
      errorOccurred = pyqtSignal(str)    # Emitted on errors
      filesDropped = pyqtSignal(list, str)  # Emitted when files are dropped (files, target_directory)
 +    rootPathChanged = pyqtSignal(str)  # Emitted when the root path changes
      def __init__(self, sftp: Optional[SFTPClient] = None, parent: Optional[QObject] = None):
          super().__init__(parent)
          self.sftp = sftp
          self.root_path = "/"
 +        self.current_root_path = "/"  # The path that's currently shown as root
          # Create a proper root item with valid attributes
          root_attr = SFTPAttributes()
          self.show_hidden = False
          self.show_full_details = False
 -        # Cache for performance (even though we're fetching fresh,
 -        # we cache during a single view session)
 +        # Cache for performance
          self._path_cache: Dict[str, List[RemoteFileInfo]] = {}
 -        # Track which directories are expanded
 -        self._expanded_paths: set[str] = set()
 +        # Track expanded directories
 +        self._expanded_paths: Set[str] = set()
      def set_sftp(self, sftp: SFTPClient):
          """Set or update the SFTP connection"""
          self.beginResetModel()
          self.sftp = sftp
          self._path_cache.clear()
 +        self._expanded_paths.clear()
          self.root_item.children = None
 +        self.current_root_path = "/"
          self.endResetModel()
          if sftp:
              self.load_directory("/")
 +    def set_root_path(self, path: str):
 +        """Set the root path to display (like QFileSystemModel's setRootPath)"""
 +        if not self.sftp:
 +            return
++
 +        # Don't reset if we're already at this path
 +        if path == self.current_root_path:
 +            # Just reload the directory without resetting
 +            self.load_directory(path)
 +            return
++
 +        self.beginResetModel()
 +        self.current_root_path = path
 +        self._path_cache.clear()
++
 +        # Create a new root item for this path
 +        try:
 +            # Get attributes for the new root
 +            attrs = self.sftp.stat(path)
 +            self.root_item = RemoteFileInfo(attrs, os.path.basename(path) if path != "/" else "/",
 +                                          os.path.dirname(path) if path != "/" else "")
 +            self.root_item.full_path = path
 +            self.root_item.children = None
++
 +            # Load the directory
 +            self.load_directory(path)
++
 +        except Exception as e:
 +            self.errorOccurred.emit(f"Failed to change to directory: {str(e)}")
 +            # Restore to root on error
 +            self.current_root_path = "/"
 +            root_attr = SFTPAttributes()
 +            root_attr.st_mode = stat.S_IFDIR | 0o755
 +            root_attr.st_size = 0
 +            root_attr.st_mtime = 0
 +            root_attr.filename = "/"
 +            self.root_item = RemoteFileInfo(root_attr, "/", "")
 +            self.root_item.children = []
++
 +        self.endResetModel()
 +        self.rootPathChanged.emit(self.current_root_path)
++
 +    def rootPath(self) -> str:
 +        """Get the current root path"""
 +        return self.current_root_path
++
      def set_show_hidden(self, show: bool):
          """Toggle showing hidden files"""
          if self.show_hidden != show:
          """Toggle showing full file details (permissions)"""
          if self.show_full_details != show:
              self.show_full_details = show
 -            # Just emit dataChanged for the permissions column
 +            # Only emit dataChanged if we have data
              if self.root_item.children:
                  self.dataChanged.emit(
                      self.index(0, RemoteColumn.PERMISSIONS),
 -                    self.index(self.rowCount() - 1, RemoteColumn.PERMISSIONS)
 +                    self.index(len(self.root_item.children) - 1, RemoteColumn.PERMISSIONS)
+                 )
 +    def track_expansion(self, path: str, expanded: bool):
 +        """Track whether a directory is expanded"""
 +        if expanded:
 +            self._expanded_paths.add(path)
 +        else:
 +            self._expanded_paths.discard(path)
++
 +    def is_path_expanded(self, path: str) -> bool:
 +        """Check if a path was previously expanded"""
 +        return path in self._expanded_paths
++
      def load_directory(self, path: str) -> bool:
          """Load directory contents from SFTP"""
          if not self.sftp:
              items = []
              for attr in attrs:
                  name = attr.filename
 -                if not self.show_hidden and name.startswith("."):
 +                if not self.show_hidden and is_hidden_file(name):
                      continue
                  file_info = RemoteFileInfo(attr, name, path)
              # Update cache
              self._path_cache[path] = items
 +            # If this is the root directory we're viewing
 +            if path == self.current_root_path:
 +                # Update root item's children
 +                if items:
 +                    self.beginInsertRows(QModelIndex(), 0, len(items) - 1)
++
 +                self.root_item.children = items
 +                for item in items:
 +                    item.parent = self.root_item
++
 +                if items:
 +                    self.endInsertRows()
 +            else:
                  # Find the parent item for this path
                  parent_item = self._find_item_by_path(path)
                  if parent_item:
      def refresh(self, preserve_state: bool = True):
          """Refresh current view"""
 -        if self.root_item.children is not None:
 +        if not self.sftp:
 +            return
++
          if preserve_state:
 -                # Smart refresh - only reload directories that are already loaded
 -                self._smart_refresh(self.root_item)
 +            # Smart refresh - update only the current directory without resetting the tree
 +            self._refresh_directory(self.current_root_path)
++
 +            # Also refresh any expanded subdirectories
 +            for expanded_path in list(self._expanded_paths):
 +                if expanded_path.startswith(self.current_root_path) and expanded_path != self.current_root_path:
 +                    self._refresh_directory(expanded_path)
          else:
 -                # Full refresh - clear everything and start over
 +            # Full refresh - this will collapse everything
              self._path_cache.clear()
 +            self._expanded_paths.clear()
              self.beginResetModel()
              self.root_item.children = None
              self.endResetModel()
 -                self.load_directory("/")
+-
 -    def _smart_refresh(self, item: RemoteFileInfo):
 -        """Recursively refresh only loaded directories"""
 -        if item.children is not None and self.sftp:
 -            # This directory is loaded, refresh it
 -            try:
 -                # Fetch fresh listing
 -                attrs = self.sftp.listdir_attr(item.full_path if item != self.root_item else "/")
+-
 -                # Convert to RemoteFileInfo objects
 -                new_items = []
 -                for attr in attrs:
 -                    name = attr.filename
 -                    if not self.show_hidden and name.startswith("."):
 -                        continue
+-
 -                    path = item.full_path if item != self.root_item else "/"
 -                    file_info = RemoteFileInfo(attr, name, path)
 -                    new_items.append(file_info)
+-
 -                # Sort: directories first, then by name
 -                new_items.sort(key=lambda x: (not x.is_dir, x.name.lower()))
+-
 -                # Find which children need to be preserved (already expanded)
 -                expanded_children = {}
 -                if item.children:
 -                    for child in item.children:
 -                        if child.children is not None:  # This child was expanded
 -                            expanded_children[child.name] = child
+-
 -                # Update the model
 -                parent_index = self._get_index_for_item(item)
+-
 -                # Remove old children
 -                if item.children:
 -                    self.beginRemoveRows(parent_index, 0, len(item.children) - 1)
 -                    item.children = []
 -                    self.endRemoveRows()
 +            self.load_directory(self.current_root_path)
 -                # Add new children
 -                if new_items:
 -                    self.beginInsertRows(parent_index, 0, len(new_items) - 1)
 -                    item.children = new_items
 -                    for child in new_items:
 -                        child.parent = item
 -                        # If this child was previously expanded, restore its state
 -                        if child.name in expanded_children:
 -                            old_child = expanded_children[child.name]
 -                            child.children = old_child.children
 -                            # Update parent references
 -                            if child.children:
 -                                for grandchild in child.children:
 -                                    grandchild.parent = child
 -                    self.endInsertRows()
+-
 -                # Recursively refresh expanded children
 -                for child in item.children or []:
 -                    if child.children is not None:
 -                        self._smart_refresh(child)
+-
 -                # Update cache
 -                path = item.full_path if item != self.root_item else "/"
 -                self._path_cache[path] = new_items
+-
 -            except Exception as e:
 -                # Silently handle errors during refresh
 -                pass
+-
 -    def _refresh_single_directory(self, item: RemoteFileInfo):
 -        """Refresh a single directory without affecting the rest of the tree"""
 -        if not self.sftp or item.children is None:
 +    def _refresh_directory(self, path: str):
 +        """Refresh a specific directory without affecting the tree structure"""
 +        if not self.sftp:
              return
          try:
 -            # Fetch fresh listing
 -            path = item.full_path if item != self.root_item else "/"
 +            # Get the current directory listing
              attrs = self.sftp.listdir_attr(path)
              # Convert to RemoteFileInfo objects
              new_items = []
              for attr in attrs:
                  name = attr.filename
 -                if not self.show_hidden and name.startswith("."):
 +                if not self.show_hidden and is_hidden_file(name):
                      continue
                  file_info = RemoteFileInfo(attr, name, path)
              # Sort: directories first, then by name
              new_items.sort(key=lambda x: (not x.is_dir, x.name.lower()))
 -            # Find which children need to be preserved (already expanded)
 -            expanded_children = {}
 -            if item.children:
 -                for child in item.children:
 -                    if child.children is not None:  # This child was expanded
 -                        expanded_children[child.name] = child
 +            # Find the parent item for this path
 +            if path == self.current_root_path:
 +                parent_item = self.root_item
 +                parent_index = QModelIndex()
 +            else:
 +                parent_item = self._find_item_by_path(path)
 +                if not parent_item:
 +                    return
 +                parent_index = self._get_index_for_item(parent_item)
++
 +            # Get old children
 +            old_children = parent_item.children or []
 -            # Update the model
 -            parent_index = self._get_index_for_item(item)
 +            # Create lookup maps
 +            old_map = {child.name: child for child in old_children}
 +            new_map = {item.name: item for item in new_items}
 -            # Remove old children
 -            if item.children:
 -                self.beginRemoveRows(parent_index, 0, len(item.children) - 1)
 -                item.children = []
 +            # Find what needs to be removed, added, or updated
 +            to_remove = [child for child in old_children if child.name not in new_map]
 +            to_add = [item for item in new_items if item.name not in old_map]
 +            to_update = [(old_map[name], new_map[name]) for name in new_map if name in old_map]
++
 +            # Remove items that no longer exist
 +            for child in to_remove:
 +                row = old_children.index(child)
 +                self.beginRemoveRows(parent_index, row, row)
 +                old_children.remove(child)
                  self.endRemoveRows()
 -            # Add new children
 -            if new_items:
 -                self.beginInsertRows(parent_index, 0, len(new_items) - 1)
 -                item.children = new_items
 -                for child in new_items:
 -                    child.parent = item
 -                    # If this child was previously expanded, restore its state
 -                    if child.name in expanded_children:
 -                        old_child = expanded_children[child.name]
 -                        child.children = old_child.children
 -                        # Update parent references
 -                        if child.children:
 -                            for grandchild in child.children:
 -                                grandchild.parent = child
 +            # Update existing items (preserving children if they're directories)
 +            for old_item, new_item in to_update:
 +                # Update attributes but preserve children and expansion state
 +                old_item.attr = new_item.attr
 +                old_item._icon = None  # Force icon refresh
 +                row = old_children.index(old_item)
 +                # Emit data changed for this row
 +                idx_start = self.index(row, 0, parent_index)
 +                idx_end = self.index(row, self.columnCount() - 1, parent_index)
 +                self.dataChanged.emit(idx_start, idx_end)
++
 +            # Add new items
 +            if to_add:
 +                # Find insertion point to maintain sort order
 +                insert_row = len(old_children)
 +                self.beginInsertRows(parent_index, insert_row, insert_row + len(to_add) - 1)
 +                for item in to_add:
 +                    item.parent = parent_item
 +                    old_children.append(item)
                  self.endInsertRows()
 -            else:
 -                # No children, just set empty list
 -                item.children = []
++
 +                # Re-sort the children
 +                old_children.sort(key=lambda x: (not x.is_dir, x.name.lower()))
++
 +            # Update parent's children reference
 +            parent_item.children = old_children
              # Update cache
 -            self._path_cache[path] = new_items
 +            self._path_cache[path] = old_children
          except Exception as e:
 -            # Silently handle errors during refresh
 -            pass
 +            # On error, just do a full reload of this directory
 +            self.load_directory(path)
 -    def mark_expanded(self, path: str):
 -        """Mark a directory as expanded"""
 -        self._expanded_paths.add(path)
 +    def _find_item_by_path(self, path: str) -> Optional[RemoteFileInfo]:
 +        """Find item by path traversing the tree"""
 +        if path == self.current_root_path:
 +            return self.root_item
 -    def mark_collapsed(self, path: str):
 -        """Mark a directory as collapsed"""
 -        self._expanded_paths.discard(path)
 +        # If the path is not under our current root, return None
 +        if not path.startswith(self.current_root_path):
 +            return None
 -    def is_expanded(self, path: str) -> bool:
 -        """Check if a directory is marked as expanded"""
 -        return path in self._expanded_paths
 +        # Get relative path from current root
 +        if self.current_root_path == "/":
 +            relative_path = path[1:]  # Remove leading /
 +        else:
 +            relative_path = path[len(self.current_root_path):].lstrip("/")
 -    def _find_item_by_path(self, path: str) -> Optional[RemoteFileInfo]:
 -        """Find item by path traversing the tree"""
 -        if path == "/" or path == "":
 +        if not relative_path:
              return self.root_item
          # Split path and traverse
 -        parts = path.strip("/").split("/")
 +        parts = relative_path.split("/")
          current = self.root_item
          for part in parts:
              elif col == RemoteColumn.SIZE:
                  return item.size_str
              elif col == RemoteColumn.TYPE:
 -                if item.is_link:
 -                    return "Link"
 -                elif item.is_dir:
 -                    return "Folder"
 -                else:
 -                    ext = os.path.splitext(item.name)[1]
 -                    return f"{ext[1:].upper()} File" if ext else "File"
 +                return get_file_type_description(item.name, item.is_dir, item.is_link)
              elif col == RemoteColumn.MODIFIED:
                  return item.modified_str
              elif col == RemoteColumn.PERMISSIONS and self.show_full_details:
      def hasChildren(self, parent: QModelIndex = QModelIndex()) -> bool:
          """Check if item has children (is a directory)"""
          item = self._get_item(parent)
 +        # For the flat view mode, only root has children
 +        if self.current_root_path != "/":
 +            return not parent.isValid()
 +        # For tree mode, directories have children
          return item.is_dir if item else False
      def canFetchMore(self, parent: QModelIndex) -> bool:
          """Check if we need to fetch children for this item"""
 +        # In flat view mode, we don't fetch more
 +        if self.current_root_path != "/" and parent.isValid():
 +            return False
++
          item = self._get_item(parent)
 -        # Check cache first to avoid redundant fetches
          if item and item.is_dir and item.children is None:
              # Check if we already have it cached
              if item.full_path in self._path_cache:
          # Get the target directory
          if parent.isValid():
              target_item = self._get_item(parent)
 -            target_path = target_item.full_path if target_item else "/"
 +            target_path = target_item.full_path if target_item else self.current_root_path
          else:
 -            target_path = "/"
 +            target_path = self.current_root_path
          # Extract local file paths from URLs
          local_paths = []

src/wulftp/sftp_backend.pydeleted

 -import paramiko
+-
+-
 -class SFTPBackend:
 -    """
 -    simple wrapper for SFTP operations using Paramiko.
 -    """
+-
 -    def __init__(self):
 -        self.ssh = None
 -        self.sftp = None
+-
 -    def connect(
 -        self,
 -        host: str,
 -        port: int,
 -        username: str,
 -        key_path: str,
 -        passphrase: str | None = None,
 -    ):
 -        """
 -        establish an SSH connection and open an SFTP session.
 -        Raises Paramiko exceptions on failure.
 -        """
 -        self.ssh = paramiko.SSHClient()
 -        self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 -        if passphrase:
 -            pkey = paramiko.RSAKey.from_private_key_file(key_path, password=passphrase)
 -            self.ssh.connect(hostname=host, port=port, username=username, pkey=pkey)
 -        else:
 -            self.ssh.connect(
 -                hostname=host, port=port, username=username, key_filename=key_path
 -            )
 -        self.sftp = self.ssh.open_sftp()
+-
 -    def listdir(self, path: str = ".") -> list[str]:
 -        """
 -        return the list of entries in the remote directory.
 -        """
 -        return self.sftp.listdir(path)
+-
 -    def upload(self, local_path: str, remote_path: str) -> None:
 -        """
 -        upload a local file to the specified remote path.
 -        """
 -        self.sftp.put(local_path, remote_path)
+-
 -    def download(self, remote_path: str, local_path: str) -> None:
 -        """
 -        download a remote file to the specified local path.
 -        """
 -        self.sftp.get(remote_path, local_path)
+-
 -    def close(self) -> None:
 -        """
 -        close the SFTP session and underlying SSH connection.
 -        """
 -        if self.sftp:
 -            self.sftp.close()
 -        if self.ssh:
 -            self.ssh.close()

src/wulftp/ui/__init__.pyadded

 +"""UI components for wulFTP."""
++
 +from .widgets import LocalTreeView
 +from .components import (
 +    ConnectionToolbar,
 +    FilePane,
 +    LocalFilePane,
 +    RemoteFilePane,
 +    FileTransferToolbar,
 +    FileContextMenu
 +)
 +from .main_window import WulFTPClient
++
 +__all__ = [
 +    "LocalTreeView",
 +    "ConnectionToolbar",
 +    "FilePane",
 +    "LocalFilePane",
 +    "RemoteFilePane",
 +    "FileTransferToolbar",
 +    "FileContextMenu",
 +    "WulFTPClient"
 +]

src/wulftp/ui/components.pyadded

 +"""UI Components for wulFTP."""
++
 +import os
 +from typing import Optional, List, Tuple
 +import qtawesome as qta
 +from PyQt6.QtCore import Qt, pyqtSignal, QModelIndex, QDir
 +from PyQt6.QtGui import QAction, QFileSystemModel
 +from PyQt6.QtWidgets import (
 +    QWidget, QToolBar, QLabel, QComboBox, QLineEdit,
 +    QPushButton, QHBoxLayout, QVBoxLayout, QTreeView,
 +    QHeaderView, QSizePolicy, QAbstractItemView,
 +    QMenu
 +)
++
 +from ..core import Icons, AppConfig, Styles
 +from ..models import RemoteFileSystemModel
 +from ..ui.widgets import LocalTreeView
++
++
 +class ConnectionToolbar(QToolBar):
 +    """Connection toolbar with host selection and connect button."""
++
 +    # Signals
 +    connectRequested = pyqtSignal()
 +    disconnectRequested = pyqtSignal()
 +    hostChanged = pyqtSignal(object)  # SSHHost or None
++
 +    def __init__(self, ssh_hosts: dict, parent=None):
 +        super().__init__(parent)
 +        self.ssh_hosts = ssh_hosts
 +        self._setup_ui()
++
 +    def _setup_ui(self):
 +        """Initialize the toolbar UI."""
 +        self.setMovable(False)
++
 +        # Host dropdown
 +        self.addWidget(QLabel(" Host: "))
 +        self.host_combo = QComboBox()
 +        self.host_combo.setMinimumWidth(AppConfig.HOST_COMBO_MIN_WIDTH)
 +        self.host_combo.setMaximumWidth(AppConfig.HOST_COMBO_MAX_WIDTH)
++
 +        # Populate hosts
 +        for host in self.ssh_hosts.values():
 +            self.host_combo.addItem(host.display_name(), host)
++
 +        # Add custom option
 +        self.host_combo.addItem("Custom...", None)
 +        self.host_combo.currentIndexChanged.connect(self._on_host_changed)
 +        self.addWidget(self.host_combo)
++
 +        # Custom host fields (hidden by default)
 +        self.custom_host = QLineEdit()
 +        self.custom_host.setPlaceholderText("hostname")
 +        self.custom_host.setVisible(False)
 +        self.custom_host.setMaximumWidth(AppConfig.CUSTOM_HOST_MAX_WIDTH)
 +        self.addWidget(self.custom_host)
++
 +        self.custom_user = QLineEdit()
 +        self.custom_user.setPlaceholderText("username")
 +        self.custom_user.setVisible(False)
 +        self.custom_user.setMaximumWidth(AppConfig.CUSTOM_USER_MAX_WIDTH)
 +        self.addWidget(self.custom_user)
++
 +        # Connect button
 +        self.connect_btn = QPushButton()
 +        self.connect_btn.setIcon(qta.icon(Icons.CONNECT.name, color=Icons.CONNECT.color))
 +        self.connect_btn.setText("Connect")
 +        self.connect_btn.clicked.connect(self._on_connect_clicked)
 +        self.addWidget(self.connect_btn)
++
 +        # Connection indicator
 +        self.conn_indicator = QLabel()
 +        self.update_connection_status(False)
 +        self.addWidget(self.conn_indicator)
++
 +    def _on_host_changed(self, index):
 +        """Handle host selection change."""
 +        host = self.host_combo.currentData()
 +        is_custom = host is None
++
 +        self.custom_host.setVisible(is_custom)
 +        self.custom_user.setVisible(is_custom)
 +        self.hostChanged.emit(host)
++
 +    def _on_connect_clicked(self):
 +        """Handle connect button click."""
 +        if self.connect_btn.text() == "Connect":
 +            self.connectRequested.emit()
 +        else:
 +            self.disconnectRequested.emit()
++
 +    def update_connection_status(self, connected: bool):
 +        """Update connection indicators."""
 +        if connected:
 +            icon = qta.icon(Icons.CONNECTED.name, color=Icons.CONNECTED.color)
 +            self.connect_btn.setText("Disconnect")
 +            self.connect_btn.setIcon(qta.icon(Icons.DISCONNECT.name, color=Icons.DISCONNECT.color))
 +        else:
 +            icon = qta.icon(Icons.DISCONNECTED.name, color=Icons.DISCONNECTED.color)
 +            self.connect_btn.setText("Connect")
 +            self.connect_btn.setIcon(qta.icon(Icons.CONNECT.name, color=Icons.CONNECT.color))
++
 +        self.conn_indicator.setPixmap(icon.pixmap(AppConfig.ICON_SIZE, AppConfig.ICON_SIZE))
++
 +    def get_connection_params(self) -> dict:
 +        """Get current connection parameters."""
 +        host_data = self.host_combo.currentData()
++
 +        if host_data:
 +            return {
 +                "hostname": host_data.hostname,
 +                "port": host_data.port,
 +                "username": host_data.user,
 +                "key_file": host_data.key_file,
 +            }
 +        else:
 +            return {
 +                "hostname": self.custom_host.text(),
 +                "port": 22,
 +                "username": self.custom_user.text(),
 +                "key_file": None,
 +            }
++
++
 +class FileTransferToolbar(QToolBar):
 +    """File transfer operations toolbar."""
++
 +    # Signals
 +    uploadRequested = pyqtSignal()
 +    downloadRequested = pyqtSignal()
 +    deleteRequested = pyqtSignal()
 +    refreshRequested = pyqtSignal()
 +    showHiddenToggled = pyqtSignal(bool)
 +    showDetailsToggled = pyqtSignal(bool)
++
 +    def __init__(self, parent=None):
 +        super().__init__(parent)
 +        self._setup_ui()
 +        self._connected = False
++
 +    def _setup_ui(self):
 +        """Initialize the toolbar UI."""
 +        self.setMovable(False)
++
 +        # Upload action
 +        self.upload_action = QAction(
 +            qta.icon(Icons.UPLOAD.name, color=Icons.UPLOAD.color), "Upload Selected", self
 +        )
 +        self.upload_action.triggered.connect(self.uploadRequested.emit)
 +        self.upload_action.setEnabled(False)
 +        self.addAction(self.upload_action)
++
 +        # Download action
 +        self.download_action = QAction(
 +            qta.icon(Icons.DOWNLOAD.name, color=Icons.DOWNLOAD.color), "Download Selected", self
 +        )
 +        self.download_action.triggered.connect(self.downloadRequested.emit)
 +        self.download_action.setEnabled(False)
 +        self.addAction(self.download_action)
++
 +        self.addSeparator()
++
 +        # Delete action
 +        self.delete_action = QAction(
 +            qta.icon(Icons.DELETE.name, color=Icons.DELETE.color), "Delete Selected", self
 +        )
 +        self.delete_action.triggered.connect(self.deleteRequested.emit)
 +        self.delete_action.setEnabled(True)  # Always enabled
 +        self.addAction(self.delete_action)
++
 +        self.addSeparator()
++
 +        # Refresh action
 +        refresh_action = QAction(
 +            qta.icon(Icons.REFRESH.name, color=Icons.REFRESH.color), "Refresh", self
 +        )
 +        refresh_action.triggered.connect(self.refreshRequested.emit)
 +        self.addAction(refresh_action)
++
 +        # Add spacer to push settings to the right
 +        spacer = QWidget()
 +        spacer.setSizePolicy(
 +            QSizePolicy.Policy.Expanding,
 +            QSizePolicy.Policy.Expanding
 +        )
 +        self.addWidget(spacer)
++
 +        # Settings actions
 +        self.show_hidden_action = QAction("Show Hidden Files", self)
 +        self.show_hidden_action.setCheckable(True)
 +        self.show_hidden_action.setChecked(False)
 +        self.show_hidden_action.toggled.connect(self.showHiddenToggled.emit)
 +        self.addAction(self.show_hidden_action)
++
 +        self.show_details_action = QAction("Show Full Details", self)
 +        self.show_details_action.setCheckable(True)
 +        self.show_details_action.setChecked(False)
 +        self.show_details_action.toggled.connect(self.showDetailsToggled.emit)
 +        self.addAction(self.show_details_action)
++
 +    def set_connection_state(self, connected: bool):
 +        """Update toolbar based on connection state."""
 +        self._connected = connected
 +        self.upload_action.setEnabled(connected)
 +        self.download_action.setEnabled(connected)
++
 +    def update_delete_button(self, has_selection: bool):
 +        """Update delete button appearance based on selection."""
 +        if has_selection:
 +            self.delete_action.setIcon(qta.icon(Icons.DELETE.name, color=Icons.DELETE.color))
 +        else:
 +            self.delete_action.setIcon(qta.icon(Icons.DELETE_DISABLED.name, color=Icons.DELETE_DISABLED.color))
++
++
 +class FilePane(QWidget):
 +    """File browser pane for local or remote files."""
++
 +    # Signals
 +    navigateUp = pyqtSignal()
 +    navigateHome = pyqtSignal()
 +    createDirectory = pyqtSignal()
 +    itemDoubleClicked = pyqtSignal(object)  # QModelIndex
++
 +    def __init__(self, title: str, parent=None):
 +        super().__init__(parent)
 +        self.title = title
 +        self._setup_ui()
++
 +    def _setup_ui(self):
 +        """Initialize the pane UI."""
 +        layout = QVBoxLayout(self)
 +        layout.setContentsMargins(5, 5, 5, 5)
 +        layout.setSpacing(5)
++
 +        # Header with navigation
 +        header = QWidget()
 +        header_layout = QHBoxLayout(header)
 +        header_layout.setContentsMargins(0, 0, 0, 0)
++
 +        # Title
 +        title_label = QLabel(self.title)
 +        title_label.setStyleSheet(Styles.TITLE_LABEL)
 +        header_layout.addWidget(title_label)
++
 +        header_layout.addStretch()
++
 +        # Navigation buttons
 +        self.up_btn = QPushButton()
 +        self.up_btn.setIcon(qta.icon(Icons.UP.name, color=Icons.UP.color))
 +        self.up_btn.setMaximumSize(AppConfig.NAV_BUTTON_SIZE, AppConfig.NAV_BUTTON_SIZE)
 +        self.up_btn.setToolTip("Go up one directory")
 +        self.up_btn.clicked.connect(self.navigateUp.emit)
 +        header_layout.addWidget(self.up_btn)
++
 +        self.home_btn = QPushButton()
 +        self.home_btn.setIcon(qta.icon(Icons.HOME.name, color=Icons.HOME.color))
 +        self.home_btn.setMaximumSize(AppConfig.NAV_BUTTON_SIZE, AppConfig.NAV_BUTTON_SIZE)
 +        self.home_btn.setToolTip("Go to home directory")
 +        self.home_btn.clicked.connect(self.navigateHome.emit)
 +        header_layout.addWidget(self.home_btn)
++
 +        # Create directory button
 +        self.create_dir_btn = QPushButton()
 +        self.create_dir_btn.setIcon(qta.icon(Icons.FOLDER_NEW.name, color=Icons.FOLDER_NEW.color))
 +        self.create_dir_btn.setMaximumSize(AppConfig.NAV_BUTTON_SIZE, AppConfig.NAV_BUTTON_SIZE)
 +        self.create_dir_btn.setToolTip("Create new directory")
 +        self.create_dir_btn.clicked.connect(self.createDirectory.emit)
 +        header_layout.addWidget(self.create_dir_btn)
++
 +        layout.addWidget(header)
++
 +        # Path display
 +        self.path_edit = QLineEdit()
 +        self.path_edit.setReadOnly(True)
 +        self.path_edit.setStyleSheet(Styles.PATH_EDIT)
 +        layout.addWidget(self.path_edit)
++
 +        # File view (to be set by caller)
 +        self.tree_view = None
++
 +    def set_tree_view(self, tree_view: QTreeView):
 +        """Set the tree view for this pane."""
 +        self.tree_view = tree_view
 +        self.layout().addWidget(tree_view)
++
 +        # Connect double-click
 +        tree_view.doubleClicked.connect(self.itemDoubleClicked.emit)
++
 +    def set_path(self, path: str):
 +        """Update the path display."""
 +        self.path_edit.setText(path)
++
 +    def get_path(self) -> str:
 +        """Get the current path."""
 +        return self.path_edit.text()
++
++
 +class LocalFilePane(FilePane):
 +    """File browser pane specifically for local files."""
++
 +    def __init__(self, parent=None):
 +        super().__init__("Local Files", parent)
 +        self._setup_file_view()
++
 +    def _setup_file_view(self):
 +        """Set up the local file view."""
 +        # Local file system model
 +        self.model = QFileSystemModel()
 +        self.model.setRootPath(QDir.homePath())
++
 +        # Use custom tree view for local files
 +        self.tree_view = LocalTreeView()
 +        self.tree_view.setModel(self.model)
 +        self.tree_view.setRootIndex(self.model.index(QDir.homePath()))
 +        self.tree_view.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
++
 +        # Enable drag from local view
 +        self.tree_view.setDragEnabled(True)
 +        self.tree_view.setDefaultDropAction(Qt.DropAction.CopyAction)
 +        self.tree_view.setDropIndicatorShown(True)
++
 +        # Configure columns
 +        self.tree_view.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
 +        self.tree_view.setColumnWidth(1, AppConfig.COLUMN_SIZE)  # Size
 +        self.tree_view.setColumnWidth(2, AppConfig.COLUMN_TYPE)  # Type
 +        self.tree_view.setColumnWidth(3, AppConfig.COLUMN_DATE)  # Date
++
 +        # Context menu
 +        self.tree_view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
++
 +        # Set initial path
 +        self.set_path(QDir.homePath())
++
 +        # Add tree view to layout
 +        self.set_tree_view(self.tree_view)
++
 +        # Connect double-click handler
 +        self.tree_view.doubleClicked.connect(self._on_double_click)
++
 +    def _on_double_click(self, index: QModelIndex):
 +        """Handle double-click on local file."""
 +        if self.model.isDir(index):
 +            self.tree_view.setRootIndex(index)
 +            self.set_path(self.model.filePath(index))
++
 +    def navigate_up(self):
 +        """Navigate up one directory."""
 +        current = self.tree_view.rootIndex()
 +        parent = self.model.parent(current)
 +        if parent.isValid():
 +            self.tree_view.setRootIndex(parent)
 +            self.set_path(self.model.filePath(parent))
++
 +    def navigate_home(self):
 +        """Navigate to home directory."""
 +        home_index = self.model.index(QDir.homePath())
 +        self.tree_view.setRootIndex(home_index)
 +        self.set_path(QDir.homePath())
++
 +        # Restore focus after navigation
 +        self.window().raise_()
 +        self.window().activateWindow()
++
 +    def get_selected_items(self) -> List[Tuple[str, bool]]:
 +        """Get selected items as list of (path, is_dir) tuples."""
 +        items = []
 +        for index in self.tree_view.selectedIndexes():
 +            if index.column() == 0:  # Only process name column
 +                path = self.model.filePath(index)
 +                is_dir = self.model.isDir(index)
 +                items.append((path, is_dir))
 +        return items
++
++
 +class RemoteFilePane(FilePane):
 +    """File browser pane specifically for remote files."""
++
 +    def __init__(self, parent=None):
 +        super().__init__("Remote Files", parent)
 +        self._setup_file_view()
++
 +    def _setup_file_view(self):
 +        """Set up the remote file view."""
 +        # Remote file system model
 +        self.model = RemoteFileSystemModel()
++
 +        # Tree view for remote files
 +        self.tree_view = QTreeView()
 +        self.tree_view.setModel(self.model)
 +        self.tree_view.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
++
 +        # Enable drag and drop
 +        self.tree_view.setDragEnabled(True)
 +        self.tree_view.setAcceptDrops(True)
 +        self.tree_view.setDefaultDropAction(Qt.DropAction.CopyAction)
 +        self.tree_view.setDropIndicatorShown(True)
++
 +        # Configure columns
 +        self.tree_view.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
 +        self.tree_view.setColumnWidth(1, AppConfig.COLUMN_SIZE)  # Size
 +        self.tree_view.setColumnWidth(2, AppConfig.COLUMN_TYPE)  # Type
 +        self.tree_view.setColumnWidth(3, AppConfig.COLUMN_DATE)  # Modified
++
 +        # Performance optimizations
 +        self.tree_view.setUniformRowHeights(True)
 +        self.tree_view.setAlternatingRowColors(True)
++
 +        # Context menu
 +        self.tree_view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
++
 +        # Connect model signals
 +        self.model.directoryLoaded.connect(lambda path: self.set_path(path))
++
 +        # Track expansion state
 +        self.tree_view.expanded.connect(self._on_item_expanded)
 +        self.tree_view.collapsed.connect(self._on_item_collapsed)
++
 +        # Add tree view to layout
 +        self.set_tree_view(self.tree_view)
++
 +        # Connect double-click handler
 +        self.tree_view.doubleClicked.connect(self._on_double_click)
++
 +        # Start disabled until connected
 +        self.setEnabled(False)
++
 +    def _on_item_expanded(self, index: QModelIndex):
 +        """Track when an item is expanded"""
 +        file_info = self.model.fileInfo(index)
 +        if file_info and file_info.is_dir:
 +            self.model.track_expansion(file_info.full_path, True)
++
 +    def _on_item_collapsed(self, index: QModelIndex):
 +        """Track when an item is collapsed"""
 +        file_info = self.model.fileInfo(index)
 +        if file_info and file_info.is_dir:
 +            self.model.track_expansion(file_info.full_path, False)
++
 +    def _on_double_click(self, index: QModelIndex):
 +        """Handle double-click on remote file."""
 +        if self.model.isDir(index):
 +            path = self.model.filePath(index)
 +            self.model.set_root_path(path)
 +            self.set_path(path)
++
 +    def navigate_up(self):
 +        """Navigate up one directory."""
 +        current_path = self.model.rootPath()
 +        if current_path and current_path != "/":
 +            parent_path = os.path.dirname(current_path)
 +            self.model.set_root_path(parent_path)
 +            self.set_path(parent_path)
++
 +    def navigate_home(self):
 +        """Navigate to home directory."""
 +        if self.model.sftp:
 +            try:
 +                # Try to get the home directory from SFTP
 +                home_path = self.model.sftp.normalize(".")
 +                self.model.set_root_path(home_path)
 +                self.set_path(home_path)
 +            except:
 +                # Fall back to root
 +                self.model.set_root_path("/")
 +                self.set_path("/")
++
 +        # Restore focus after navigation
 +        self.window().raise_()
 +        self.window().activateWindow()
++
 +    def get_selected_items(self) -> List[Tuple[str, bool, str]]:
 +        """Get selected items as list of (path, is_dir, name) tuples."""
 +        items = []
 +        for index in self.tree_view.selectedIndexes():
 +            if index.column() == 0:  # Only process name column
 +                file_info = self.model.fileInfo(index)
 +                if file_info:
 +                    items.append((file_info.full_path, file_info.is_dir, file_info.name))
 +        return items
++
 +    def set_show_hidden(self, show: bool):
 +        """Toggle showing hidden files."""
 +        self.model.set_show_hidden(show)
++
 +    def set_show_details(self, show: bool):
 +        """Toggle showing full details."""
 +        self.model.set_show_full_details(show)
 +        if show:
 +            self.tree_view.showColumn(4)  # Permissions column
 +        else:
 +            self.tree_view.hideColumn(4)
++
 +    def refresh(self):
 +        """Refresh the remote view."""
 +        if self.model.sftp:
 +            # Save expansion state before refresh
 +            expanded_paths = list(self.model._expanded_paths)
++
 +            # Refresh preserving state
 +            self.model.refresh(preserve_state=True)
++
 +            # Restore expansion state
 +            for path in expanded_paths:
 +                # Find the item and expand it
 +                item = self.model._find_item_by_path(path)
 +                if item:
 +                    index = self.model._get_index_for_item(item)
 +                    if index.isValid():
 +                        self.tree_view.setExpanded(index, True)
++
++
 +class FileContextMenu(QMenu):
 +    """Context menu for file operations."""
++
 +    # Signals
 +    uploadRequested = pyqtSignal()
 +    downloadRequested = pyqtSignal()
 +    deleteRequested = pyqtSignal()
 +    createDirectoryRequested = pyqtSignal()
 +    refreshRequested = pyqtSignal()
++
 +    def __init__(self, is_local: bool, has_selection: bool, is_connected: bool, parent=None):
 +        super().__init__(parent)
 +        self.is_local = is_local
 +        self.has_selection = has_selection
 +        self.is_connected = is_connected
 +        self._setup_menu()
++
 +    def _setup_menu(self):
 +        """Set up the context menu."""
 +        if self.is_connected:  # Only show transfer options when connected
 +            if self.is_local:
 +                upload_action = self.addAction(
 +                    qta.icon(Icons.UPLOAD.name, color=Icons.UPLOAD.color), "Upload"
 +                )
 +                upload_action.triggered.connect(self.uploadRequested.emit)
 +                upload_action.setEnabled(self.has_selection)
 +            else:
 +                download_action = self.addAction(
 +                    qta.icon(Icons.DOWNLOAD.name, color=Icons.DOWNLOAD.color), "Download"
 +                )
 +                download_action.triggered.connect(self.downloadRequested.emit)
 +                download_action.setEnabled(self.has_selection)
++
 +        self.addSeparator()
++
 +        # Create directory action
 +        create_dir_action = self.addAction(
 +            qta.icon(Icons.FOLDER_NEW.name, color=Icons.FOLDER_NEW.color), "Create Directory"
 +        )
 +        create_dir_action.triggered.connect(self.createDirectoryRequested.emit)
++
 +        # Delete action
 +        if self.has_selection:
 +            delete_action = self.addAction(
 +                qta.icon(Icons.DELETE.name, color=Icons.DELETE.color), "Delete"
 +            )
 +            delete_action.triggered.connect(self.deleteRequested.emit)
++
 +        self.addSeparator()
++
 +        refresh_action = self.addAction(
 +            qta.icon(Icons.REFRESH.name, color=Icons.REFRESH.color), "Refresh"
 +        )
 +        refresh_action.triggered.connect(self.refreshRequested.emit)

src/wulftp/ui/main_window.pyadded

 +"""Main application window for wulFTP."""
++
 +import os
 +import stat
 +import shutil
 +from typing import List, Optional
++
 +import paramiko
 +import qtawesome as qta
 +from PyQt6.QtCore import (
 +    Qt,
 +    QThreadPool,
 +    pyqtSlot,
 +    QTimer,
 +)
 +from PyQt6.QtWidgets import (
 +    QApplication,
 +    QLabel,
 +    QMainWindow,
 +    QMessageBox,
 +    QProgressBar,
 +    QSplitter,
 +    QStatusBar,
 +    QVBoxLayout,
 +    QWidget,
 +    QInputDialog,
 +)
++
 +from ..core import (
 +    FileTransferManager,
 +    AppConfig,
 +    load_ssh_config
 +)
 +from ..utils import format_status_message
 +from ..ui.components import (
 +    ConnectionToolbar,
 +    FileTransferToolbar,
 +    LocalFilePane,
 +    RemoteFilePane,
 +    FileContextMenu
 +)
++
++
 +class WulFTPClient(QMainWindow):
 +    """Main application window for wulFTP."""
++
 +    def __init__(self):
 +        super().__init__()
 +        self.ssh = None
 +        self.sftp = None
 +        self.threadpool = QThreadPool()
 +        self.transfer_manager = None
 +        self.ssh_hosts = load_ssh_config()
++
 +        self.init_ui()
 +        self._connect_signals()
++
 +    def init_ui(self):
 +        """Initialize the user interface."""
 +        self.setWindowTitle(AppConfig.WINDOW_TITLE)
 +        self.setGeometry(AppConfig.WINDOW_X, AppConfig.WINDOW_Y,
 +                        AppConfig.WINDOW_WIDTH, AppConfig.WINDOW_HEIGHT)
++
 +        # Central widget
 +        central = QWidget()
 +        self.setCentralWidget(central)
++
 +        # Main layout - no margins for maximum space
 +        layout = QVBoxLayout(central)
 +        layout.setContentsMargins(0, 0, 0, 0)
 +        layout.setSpacing(0)
++
 +        # Create status bar
 +        self._create_status_bar()
++
 +        # Create toolbars
 +        self._create_toolbars()
++
 +        # Create file panes
 +        splitter = self._create_file_panes()
 +        layout.addWidget(splitter)
++
 +        # Initial state
 +        self._update_connection_state(False)
 +        self._update_button_states()
++
 +    def _restore_focus(self):
 +        """Restore window focus - used after dialogs and operations."""
 +        QTimer.singleShot(100, lambda: (self.raise_(), self.activateWindow()))
++
 +    def _create_status_bar(self):
 +        """Create the status bar."""
 +        self.status_bar = QStatusBar()
 +        self.setStatusBar(self.status_bar)
++
 +        # Progress bar (hidden by default)
 +        self.progress_bar = QProgressBar()
 +        self.progress_bar.setVisible(False)
 +        self.status_bar.addPermanentWidget(self.progress_bar)
++
 +        # Connection status
 +        self.conn_status_label = QLabel(AppConfig.MSG_DISCONNECTED)
 +        self.status_bar.addPermanentWidget(self.conn_status_label)
++
 +    def _create_toolbars(self):
 +        """Create application toolbars."""
 +        # Connection toolbar
 +        self.connection_toolbar = ConnectionToolbar(self.ssh_hosts)
 +        self.addToolBar(self.connection_toolbar)
++
 +        # Separator
 +        self.addToolBarBreak()
++
 +        # File transfer toolbar
 +        self.transfer_toolbar = FileTransferToolbar()
 +        self.addToolBar(self.transfer_toolbar)
++
 +    def _create_file_panes(self) -> QSplitter:
 +        """Create the file browser panes."""
 +        splitter = QSplitter(Qt.Orientation.Horizontal)
 +        splitter.setContentsMargins(0, 0, 0, 0)
++
 +        # Local pane
 +        self.local_pane = LocalFilePane()
 +        splitter.addWidget(self.local_pane)
++
 +        # Remote pane
 +        self.remote_pane = RemoteFilePane()
 +        splitter.addWidget(self.remote_pane)
++
 +        # Set initial splitter sizes
 +        splitter.setSizes(AppConfig.SPLITTER_SIZES)
++
 +        return splitter
++
 +    def _connect_signals(self):
 +        """Connect all signals to their handlers."""
 +        # Connection toolbar signals
 +        self.connection_toolbar.connectRequested.connect(self.connect)
 +        self.connection_toolbar.disconnectRequested.connect(self.disconnect)
++
 +        # Transfer toolbar signals
 +        self.transfer_toolbar.uploadRequested.connect(self.upload_selected)
 +        self.transfer_toolbar.downloadRequested.connect(self.download_selected)
 +        self.transfer_toolbar.deleteRequested.connect(self.delete_selected)
 +        self.transfer_toolbar.refreshRequested.connect(self.refresh_views)
 +        self.transfer_toolbar.showHiddenToggled.connect(self.remote_pane.set_show_hidden)
 +        self.transfer_toolbar.showDetailsToggled.connect(self.remote_pane.set_show_details)
++
 +        # Local pane signals
 +        self.local_pane.navigateUp.connect(self.local_pane.navigate_up)
 +        self.local_pane.navigateHome.connect(self.local_pane.navigate_home)
 +        self.local_pane.createDirectory.connect(lambda: self._create_directory(True))
 +        self.local_pane.tree_view.remoteFilesDropped.connect(self._handle_remote_files_dropped)
 +        self.local_pane.tree_view.selectionModel().selectionChanged.connect(self._update_button_states)
 +        self.local_pane.tree_view.customContextMenuRequested.connect(
 +            lambda pos: self._show_context_menu(pos, True)
 +        )
++
 +        # Remote pane signals
 +        self.remote_pane.navigateUp.connect(self.remote_pane.navigate_up)
 +        self.remote_pane.navigateHome.connect(self.remote_pane.navigate_home)
 +        self.remote_pane.createDirectory.connect(lambda: self._create_directory(False))
 +        self.remote_pane.model.errorOccurred.connect(
 +            lambda err: QMessageBox.warning(self, "Error", err)
 +        )
 +        self.remote_pane.model.filesDropped.connect(self._handle_files_dropped)
 +        self.remote_pane.tree_view.selectionModel().selectionChanged.connect(self._update_button_states)
 +        self.remote_pane.tree_view.customContextMenuRequested.connect(
 +            lambda pos: self._show_context_menu(pos, False)
 +        )
++
 +    def _update_connection_state(self, connected: bool):
 +        """Update UI based on connection state."""
 +        # Update toolbars
 +        self.connection_toolbar.update_connection_status(connected)
 +        self.transfer_toolbar.set_connection_state(connected)
++
 +        # Update remote pane
 +        self.remote_pane.setEnabled(connected)
++
 +        # Update status bar
 +        if connected:
 +            self.conn_status_label.setText("Connected")
 +        else:
 +            self.conn_status_label.setText("Disconnected")
++
 +    def connect(self):
 +        """Establish SFTP connection."""
 +        try:
 +            params = self.connection_toolbar.get_connection_params()
++
 +            # Show status message immediately
 +            self.status_bar.showMessage(AppConfig.MSG_CONNECTING)
++
 +            # Process events to update UI
 +            QApplication.processEvents()
++
 +            # Create SSH client
 +            self.ssh = paramiko.SSHClient()
 +            self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
++
 +            # Connection parameters
 +            connect_kwargs = {
 +                "hostname": params["hostname"],
 +                "port": params["port"],
 +                "username": params["username"],
 +                "timeout": AppConfig.CONNECTION_TIMEOUT,
 +            }
++
 +            if params["key_file"] and os.path.exists(os.path.expanduser(params["key_file"])):
 +                connect_kwargs["key_filename"] = os.path.expanduser(params["key_file"])
++
 +            # Allow password fallback
 +            connect_kwargs["look_for_keys"] = True
 +            connect_kwargs["allow_agent"] = True
++
 +            self.ssh.connect(**connect_kwargs)
 +            self.sftp = self.ssh.open_sftp()
++
 +            # Create transfer manager
 +            self.transfer_manager = FileTransferManager(self.sftp, self.threadpool)
++
 +            # Update remote model with SFTP connection
 +            self.remote_pane.model.set_sftp(self.sftp)
++
 +            # Update UI
 +            self._update_connection_state(True)
++
 +            self.status_bar.showMessage(
 +                AppConfig.MSG_CONNECTED.format(params["hostname"]),
 +                AppConfig.STATUS_MESSAGE_TIMEOUT
 +            )
++
 +            # Defer focus restoration to ensure it happens after all UI updates
 +            # Using a slightly longer delay to ensure all connection-related
 +            # UI updates have completed
 +            QTimer.singleShot(200, lambda: (
 +                self.raise_(),
 +                self.activateWindow(),
 +                self.remote_pane.tree_view.setFocus()  # Also set focus to remote pane
 +            ))
++
 +        except Exception as e:
 +            QMessageBox.critical(
 +                self,
 +                "Connection Error",
 +                str(e)
 +            )
 +            self._update_connection_state(False)
 +            # Restore focus after error dialog
 +            self._restore_focus()
++
 +    def disconnect(self):
 +        """Close SFTP connection."""
 +        if self.sftp:
 +            self.sftp.close()
 +            self.sftp = None
 +        if self.ssh:
 +            self.ssh.close()
 +            self.ssh = None
++
 +        # Clear remote model
 +        self.remote_pane.model.set_sftp(None)
 +        self.transfer_manager = None
++
 +        self._update_connection_state(False)
 +        self.status_bar.showMessage(AppConfig.MSG_DISCONNECTED, AppConfig.STATUS_MESSAGE_TIMEOUT)
++
 +    def refresh_views(self):
 +        """Refresh both file views."""
 +        # Local is automatically updated by QFileSystemModel
 +        if self.sftp:
 +            self.remote_pane.refresh()
++
 +    def _update_button_states(self):
 +        """Update button states based on current selection."""
 +        # Check if anything is selected in either view
 +        local_has_selection = bool(self.local_pane.tree_view.selectedIndexes())
 +        remote_has_selection = bool(self.remote_pane.tree_view.selectedIndexes()) if self.sftp else False
++
 +        has_any_selection = local_has_selection or remote_has_selection
++
 +        # Update delete button appearance
 +        self.transfer_toolbar.update_delete_button(has_any_selection)
++
 +    def _show_context_menu(self, pos, is_local: bool):
 +        """Show context menu for file operations."""
 +        if is_local:
 +            view = self.local_pane.tree_view
 +            has_selection = bool(self.local_pane.get_selected_items())
 +        else:
 +            view = self.remote_pane.tree_view
 +            has_selection = bool(self.remote_pane.get_selected_items())
++
 +        menu = FileContextMenu(is_local, has_selection, bool(self.sftp))
++
 +        # Connect menu signals
 +        menu.uploadRequested.connect(self.upload_selected)
 +        menu.downloadRequested.connect(self.download_selected)
 +        menu.deleteRequested.connect(lambda: self._delete_selected(is_local))
 +        menu.createDirectoryRequested.connect(lambda: self._create_directory(is_local))
 +        menu.refreshRequested.connect(self.refresh_views)
++
 +        # Show menu at cursor position
 +        menu.exec(view.mapToGlobal(pos))
++
 +        # Restore focus after context menu
 +        QTimer.singleShot(100, lambda: self.activateWindow())
++
 +    def upload_selected(self):
 +        """Upload selected local files and directories."""
 +        if not self.sftp or not self.transfer_manager:
 +            return
++
 +        items = self.local_pane.get_selected_items()
 +        if not items:
 +            return
++
 +        # Separate files and directories
 +        files = [path for path, is_dir in items if not is_dir]
 +        directories = [path for path, is_dir in items if is_dir]
++
 +        # Handle directories first
 +        if directories:
 +            reply = QMessageBox.question(
 +                self,
 +                "Upload Directories",
 +                format_status_message("Upload", len(directories), "directory") + "?\n\n" +
 +                "This will recursively upload all contents.",
 +                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +                QMessageBox.StandardButton.Yes
 +            )
++
 +            self._restore_focus()  # Restore focus after dialog
++
 +            if reply == QMessageBox.StandardButton.Yes:
 +                for dir_path in directories:
 +                    dirname = os.path.basename(dir_path)
 +                    remote_base = self.remote_pane.model.rootPath()
 +                    remote_path = os.path.join(remote_base, dirname).replace('\\', '/')
++
 +                    self.transfer_manager.transfer_directory(
 +                        dir_path, remote_path, is_upload=True,
 +                        progress_callback=self._update_progress,
 +                        complete_callback=self._transfer_complete,
 +                        error_callback=self._transfer_error
 +                    )
++
 +                    self.progress_bar.setVisible(True)
 +                    self.progress_bar.setValue(0)
++
 +                    self.status_bar.showMessage(
 +                        AppConfig.MSG_UPLOAD_DIR.format(dirname),
 +                        AppConfig.STATUS_MESSAGE_TIMEOUT
 +                    )
++
 +        # Handle files
 +        if files:
 +            self._transfer_files(files, is_upload=True)
++
 +    def download_selected(self):
 +        """Download selected remote files and directories."""
 +        if not self.sftp or not self.transfer_manager:
 +            return
++
 +        items = self.remote_pane.get_selected_items()
 +        if not items:
 +            return
++
 +        # Separate files and directories
 +        files = [path for path, is_dir, name in items if not is_dir]
 +        directories = [(path, name) for path, is_dir, name in items if is_dir]
++
 +        # Handle directories first
 +        if directories:
 +            reply = QMessageBox.question(
 +                self,
 +                "Download Directories",
 +                format_status_message("Download", len(directories), "directory") + "?\n\n" +
 +                "This will recursively download all contents.",
 +                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +                QMessageBox.StandardButton.Yes
 +            )
++
 +            if reply == QMessageBox.StandardButton.Yes:
 +                for dir_path, dirname in directories:
 +                    local_base = self.local_pane.model.filePath(self.local_pane.tree_view.rootIndex())
 +                    local_path = os.path.join(local_base, dirname)
++
 +                    self.transfer_manager.transfer_directory(
 +                        dir_path, local_path, is_upload=False,
 +                        progress_callback=self._update_progress,
 +                        complete_callback=self._transfer_complete_download,
 +                        error_callback=self._transfer_error
 +                    )
++
 +                    self.progress_bar.setVisible(True)
 +                    self.progress_bar.setValue(0)
++
 +                    self.status_bar.showMessage(
 +                        AppConfig.MSG_DOWNLOAD_DIR.format(dirname),
 +                        AppConfig.STATUS_MESSAGE_TIMEOUT
 +                    )
++
 +        # Handle files
 +        if files:
 +            self._transfer_files(files, is_upload=False)
++
 +    def _transfer_files(self, files: List[str], is_upload: bool):
 +        """Transfer files with progress tracking."""
 +        if not self.transfer_manager:
 +            return
++
 +        for file_path in files:
 +            filename = os.path.basename(file_path)
++
 +            if is_upload:
 +                remote_base = self.remote_pane.model.rootPath()
 +                remote_path = os.path.join(remote_base, filename).replace('\\', '/')
 +                source, dest = file_path, remote_path
 +            else:
 +                local_base = self.local_pane.model.filePath(self.local_pane.tree_view.rootIndex())
 +                local_path = os.path.join(local_base, filename)
 +                source, dest = file_path, local_path
++
 +            self.transfer_manager.transfer_file(
 +                source, dest, is_upload,
 +                progress_callback=self._update_progress,
 +                complete_callback=self._transfer_complete,
 +                error_callback=self._transfer_error
 +            )
++
 +            self.progress_bar.setVisible(True)
 +            self.progress_bar.setValue(0)
++
 +    @pyqtSlot(int)
 +    def _update_progress(self, value):
 +        """Update progress bar."""
 +        self.progress_bar.setValue(value)
++
 +    @pyqtSlot()
 +    def _transfer_complete(self):
 +        """Handle transfer completion."""
 +        self.progress_bar.setVisible(False)
 +        if self.sftp:
 +            # Just refresh - the model will preserve state
 +            self.remote_pane.refresh()
 +        self.status_bar.showMessage(AppConfig.MSG_TRANSFER_COMPLETE, AppConfig.STATUS_MESSAGE_TIMEOUT)
++
 +    @pyqtSlot()
 +    def _transfer_complete_download(self):
 +        """Handle download completion - no need to refresh remote."""
 +        self.progress_bar.setVisible(False)
 +        self.status_bar.showMessage("Download complete", AppConfig.STATUS_MESSAGE_TIMEOUT)
++
 +    @pyqtSlot(str)
 +    def _transfer_error(self, error):
 +        """Handle transfer error."""
 +        self.progress_bar.setVisible(False)
 +        QMessageBox.critical(
 +            self,
 +            "Transfer Error",
 +            error
 +        )
++
 +    def _handle_files_dropped(self, local_paths: List[str], target_directory: str):
 +        """Handle files and directories dropped onto remote view."""
 +        if not self.sftp or not self.transfer_manager:
 +            return
++
 +        self.remote_pane.set_path(target_directory)
++
 +        # Separate files and directories
 +        files = []
 +        directories = []
++
 +        for local_path in local_paths:
 +            if os.path.isdir(local_path):
 +                directories.append(local_path)
 +            else:
 +                files.append(local_path)
++
 +        # Handle directories
 +        if directories:
 +            reply = QMessageBox.question(
 +                self,
 +                "Upload Directories",
 +                format_status_message("Upload", len(directories), "directory") + "?\n\n" +
 +                "This will recursively upload all contents.",
 +                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +                QMessageBox.StandardButton.Yes
 +            )
++
 +            if reply == QMessageBox.StandardButton.Yes:
 +                for dir_path in directories:
 +                    dirname = os.path.basename(dir_path)
 +                    remote_path = os.path.join(target_directory, dirname).replace('\\', '/')
++
 +                    self.transfer_manager.transfer_directory(
 +                        dir_path, remote_path, is_upload=True,
 +                        progress_callback=self._update_progress,
 +                        complete_callback=self._transfer_complete,
 +                        error_callback=self._transfer_error
 +                    )
++
 +                    self.progress_bar.setVisible(True)
 +                    self.progress_bar.setValue(0)
++
 +        # Handle files
 +        for local_path in files:
 +            filename = os.path.basename(local_path)
 +            remote_path = os.path.join(target_directory, filename).replace('\\', '/')
++
 +            self.transfer_manager.transfer_file(
 +                local_path, remote_path, is_upload=True,
 +                progress_callback=self._update_progress,
 +                complete_callback=self._transfer_complete,
 +                error_callback=self._transfer_error
 +            )
++
 +            self.progress_bar.setVisible(True)
 +            self.progress_bar.setValue(0)
++
 +        total_items = len(files) + len(directories)
 +        self.status_bar.showMessage(
 +            f"Uploading {total_items} item(s) to {target_directory}",
 +            AppConfig.STATUS_MESSAGE_TIMEOUT
 +        )
++
 +    def _handle_remote_files_dropped(self, remote_items: List[tuple], local_directory: str):
 +        """Handle remote files and directories dropped onto local view."""
 +        if not self.sftp or not self.transfer_manager:
 +            return
++
 +        # Separate files and directories
 +        files = []
 +        directories = []
++
 +        for remote_path, is_dir in remote_items:
 +            if is_dir:
 +                dirname = os.path.basename(remote_path)
 +                directories.append((remote_path, dirname))
 +            else:
 +                files.append(remote_path)
++
 +        # Handle directories
 +        if directories:
 +            reply = QMessageBox.question(
 +                self,
 +                "Download Directories",
 +                format_status_message("Download", len(directories), "directory") + "?\n\n" +
 +                "This will recursively download all contents.",
 +                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +                QMessageBox.StandardButton.Yes
 +            )
++
 +            if reply == QMessageBox.StandardButton.Yes:
 +                for remote_path, dirname in directories:
 +                    local_path = os.path.join(local_directory, dirname)
++
 +                    self.transfer_manager.transfer_directory(
 +                        remote_path, local_path, is_upload=False,
 +                        progress_callback=self._update_progress,
 +                        complete_callback=self._transfer_complete_download,
 +                        error_callback=self._transfer_error
 +                    )
++
 +                    self.progress_bar.setVisible(True)
 +                    self.progress_bar.setValue(0)
++
 +        # Handle files
 +        for remote_path in files:
 +            filename = os.path.basename(remote_path)
 +            local_path = os.path.join(local_directory, filename)
++
 +            self.transfer_manager.transfer_file(
 +                remote_path, local_path, is_upload=False,
 +                progress_callback=self._update_progress,
 +                complete_callback=self._transfer_complete_download,
 +                error_callback=self._transfer_error
 +            )
++
 +            self.progress_bar.setVisible(True)
 +            self.progress_bar.setValue(0)
++
 +        total_items = len(files) + len(directories)
 +        self.status_bar.showMessage(
 +            f"Downloading {total_items} item(s) to {local_directory}",
 +            AppConfig.STATUS_MESSAGE_TIMEOUT
 +        )
++
 +    def _create_directory(self, is_local: bool):
 +        """Create a new directory."""
 +        if is_local:
 +            current_path = self.local_pane.model.filePath(self.local_pane.tree_view.rootIndex())
 +        else:
 +            current_path = self.remote_pane.model.rootPath()
++
 +        name, ok = QInputDialog.getText(
 +            self,
 +            "Create Directory",
 +            "Directory name:"
 +        )
++
 +        if ok and name:
 +            try:
 +                if is_local:
 +                    new_path = os.path.join(current_path, name)
 +                    os.makedirs(new_path, exist_ok=True)
 +                    self.status_bar.showMessage(
 +                        AppConfig.MSG_CREATE_DIR.format(name),
 +                        AppConfig.STATUS_MESSAGE_TIMEOUT
 +                    )
 +                else:
 +                    if self.sftp:
 +                        new_path = os.path.join(current_path, name).replace('\\', '/')
 +                        self.sftp.mkdir(new_path)
 +                        self.remote_pane.refresh()
 +                        self.status_bar.showMessage(
 +                            AppConfig.MSG_CREATE_REMOTE_DIR.format(name),
 +                            AppConfig.STATUS_MESSAGE_TIMEOUT
 +                        )
 +            except Exception as e:
 +                QMessageBox.warning(
 +                    self,
 +                    "Error",
 +                    f"Failed to create directory: {str(e)}"
 +                )
++
 +    def _delete_selected(self, is_local: bool):
 +        """Delete selected files/directories."""
 +        if is_local:
 +            items = self.local_pane.get_selected_items()
 +            # Convert to expected format
 +            items = [(path, is_dir, os.path.basename(path)) for path, is_dir in items]
 +        else:
 +            items = self.remote_pane.get_selected_items()
++
 +        if not items:
 +            return
++
 +        # Confirm deletion
 +        msg = format_status_message("Delete", len(items), "item") + "?\n\n"
 +        for path, is_dir, name in items[:5]:  # Show first 5 items
 +            msg += f"{'[DIR] ' if is_dir else ''}{name}\n"
 +        if len(items) > 5:
 +            msg += f"... and {len(items) - 5} more"
++
 +        reply = QMessageBox.question(
 +            self,
 +            "Confirm Delete",
 +            msg,
 +            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +            QMessageBox.StandardButton.No
 +        )
++
 +        # Always restore focus after the dialog, regardless of the answer
 +        self._restore_focus()
++
 +        if reply == QMessageBox.StandardButton.Yes:
 +            errors = []
 +            for path, is_dir, name in items:
 +                try:
 +                    if is_local:
 +                        if is_dir:
 +                            shutil.rmtree(path)
 +                        else:
 +                            os.remove(path)
 +                    else:
 +                        if self.sftp:
 +                            if is_dir:
 +                                self._delete_remote_dir(path)
 +                            else:
 +                                self.sftp.remove(path)
 +                except Exception as e:
 +                    errors.append(f"{name}: {str(e)}")
++
 +            if errors:
 +                QMessageBox.warning(
 +                    self,
 +                    "Delete Errors",
 +                    "Some items could not be deleted:\n\n" + "\n".join(errors[:10])
 +                )
 +                # Restore focus after error dialog
 +                self._restore_focus()
 +            else:
 +                self.status_bar.showMessage(
 +                    AppConfig.MSG_DELETE_COMPLETE.format(len(items)),
 +                    AppConfig.STATUS_MESSAGE_TIMEOUT
 +                )
++
 +            # Refresh views
 +            if not is_local and self.sftp:
 +                self.remote_pane.refresh()
++
 +    def _delete_remote_dir(self, path: str):
 +        """Recursively delete remote directory."""
 +        if not self.sftp:
 +            return
++
 +        # List directory contents
 +        for item in self.sftp.listdir_attr(path):
 +            item_path = os.path.join(path, item.filename)
 +            if stat.S_ISDIR(item.st_mode):
 +                self._delete_remote_dir(item_path)
 +            else:
 +                self.sftp.remove(item_path)
++
 +        # Remove empty directory
 +        self.sftp.rmdir(path)
++
 +    def delete_selected(self):
 +        """Delete selected items from whichever view has focus."""
 +        # Determine which view has focus or has a selection
 +        local_selection = self.local_pane.get_selected_items()
 +        remote_selection = self.remote_pane.get_selected_items() if self.sftp else []
++
 +        if local_selection and (not remote_selection or self.local_pane.tree_view.hasFocus()):
 +            self._delete_selected(True)
 +        elif remote_selection:
 +            self._delete_selected(False)
 +        else:
 +            QMessageBox.information(
 +                self,
 +                "Delete",
 +                "Please select items to delete"
 +            )
 +            # Restore focus after info dialog
 +            self._restore_focus()

src/wulftp/ui/widgets.pyadded

 +"""Custom UI widgets for wulFTP."""
++
 +from PyQt6.QtCore import Qt, pyqtSignal
 +from PyQt6.QtGui import QDragEnterEvent, QDropEvent
 +from PyQt6.QtWidgets import QTreeView
++
++
 +class LocalTreeView(QTreeView):
 +    """Custom tree view for local files that handles remote file drops."""
++
 +    remoteFilesDropped = pyqtSignal(list, str)  # remote_items (path, is_dir), local_directory
++
 +    def __init__(self, parent=None):
 +        super().__init__(parent)
 +        self.setAcceptDrops(True)
++
 +    def dragEnterEvent(self, event: QDragEnterEvent):
 +        """Accept drops from remote files."""
 +        mime_data = event.mimeData()
++
 +        # Check if this is a remote file drop
 +        if mime_data.hasFormat("application/x-wulftp-remote"):
 +            event.acceptProposedAction()
 +        else:
 +            # Let the parent handle local file drags
 +            super().dragEnterEvent(event)
++
 +    def dragMoveEvent(self, event):
 +        """Handle drag move events."""
 +        mime_data = event.mimeData()
++
 +        if mime_data.hasFormat("application/x-wulftp-remote"):
 +            # Check if we're over a directory
 +            index = self.indexAt(event.position().toPoint())
 +            if index.isValid():
 +                model = self.model()
 +                if model and model.isDir(index):
 +                    event.acceptProposedAction()
 +                    return
 +            # Also accept drops on empty space (root directory)
 +            event.acceptProposedAction()
 +        else:
 +            super().dragMoveEvent(event)
++
 +    def dropEvent(self, event: QDropEvent):
 +        """Handle drops from remote files."""
 +        mime_data = event.mimeData()
++
 +        if mime_data.hasFormat("application/x-wulftp-remote"):
 +            # Get the target directory
 +            index = self.indexAt(event.position().toPoint())
 +            model = self.model()
++
 +            if index.isValid() and model:
 +                if model.isDir(index):
 +                    target_dir = model.filePath(index)
 +                else:
 +                    # Dropped on a file, use its parent directory
 +                    target_dir = model.filePath(model.parent(index))
 +            else:
 +                # Dropped on empty space, use root
 +                target_dir = model.rootPath() if model else ""
++
 +            # Get remote paths with type info
 +            remote_data = mime_data.data("application/x-wulftp-remote").data().decode('utf-8')
 +            remote_items = []
 +            for line in remote_data.split('\n'):
 +                if line.strip() and '|' in line:
 +                    path, type_flag = line.strip().rsplit('|', 1)
 +                    is_dir = type_flag == 'D'
 +                    remote_items.append((path, is_dir))
 +                elif line.strip():
 +                    # Fallback for old format
 +                    remote_items.append((line.strip(), False))
++
 +            if remote_items and target_dir:
 +                self.remoteFilesDropped.emit(remote_items, target_dir)
 +                event.acceptProposedAction()
 +        else:
 +            # Let parent handle local file operations
 +            super().dropEvent(event)

src/wulftp/utils/__init__.pyadded

 +"""Utility functions for wulFTP."""
++
 +from .helpers import (
 +    format_bytes,
 +    format_timestamp,
 +    format_permissions,
 +    sanitize_path,
 +    get_file_type_description,
 +    count_items,
 +    format_status_message,
 +    is_hidden_file,
 +    get_icon_for_file,
 +)
++
 +__all__ = [
 +    "format_bytes",
 +    "format_timestamp",
 +    "format_permissions",
 +    "sanitize_path",
 +    "get_file_type_description",
 +    "count_items",
 +    "format_status_message",
 +    "is_hidden_file",
 +    "get_icon_for_file",
 +]

src/wulftp/utils/helpers.pyadded

 +"""Utility functions for wulFTP."""
++
 +import os
 +import stat
 +from datetime import datetime
 +from typing import Tuple, Optional
++
++
 +def format_bytes(size: int) -> str:
 +    """
 +    Format bytes into human-readable string.
++
 +    Args:
 +        size: Size in bytes
++
 +    Returns:
 +        Human-readable size string (e.g., "1.5 MB")
 +    """
 +    if size < 0:
 +        return "0 B"
++
 +    units = ["B", "KB", "MB", "GB", "TB", "PB"]
++
 +    for unit in units[:-1]:
 +        if size < 1024.0:
 +            return f"{size:.1f} {unit}"
 +        size /= 1024.0
++
 +    return f"{size:.1f} {units[-1]}"
++
++
 +def format_timestamp(timestamp: Optional[int]) -> str:
 +    """
 +    Format Unix timestamp into human-readable string.
++
 +    Args:
 +        timestamp: Unix timestamp
++
 +    Returns:
 +        Formatted date string (YYYY-MM-DD HH:MM)
 +    """
 +    if not timestamp:
 +        return ""
++
 +    try:
 +        dt = datetime.fromtimestamp(timestamp)
 +        return dt.strftime("%Y-%m-%d %H:%M")
 +    except (ValueError, OSError):
 +        return ""
++
++
 +def format_permissions(mode: int) -> str:
 +    """
 +    Format Unix file permissions into readable string.
++
 +    Args:
 +        mode: File mode bits
++
 +    Returns:
 +        Permission string (e.g., "drwxr-xr-x")
 +    """
 +    perms = ["-"] * 10
++
 +    # File type
 +    if stat.S_ISDIR(mode):
 +        perms[0] = "d"
 +    elif stat.S_ISLNK(mode):
 +        perms[0] = "l"
 +    elif stat.S_ISREG(mode):
 +        perms[0] = "-"
 +    elif stat.S_ISBLK(mode):
 +        perms[0] = "b"
 +    elif stat.S_ISCHR(mode):
 +        perms[0] = "c"
 +    elif stat.S_ISFIFO(mode):
 +        perms[0] = "p"
 +    elif stat.S_ISSOCK(mode):
 +        perms[0] = "s"
++
 +    # Permission bits
 +    mode_bits = [
 +        (stat.S_IRUSR, 1, "r"),
 +        (stat.S_IWUSR, 2, "w"),
 +        (stat.S_IXUSR, 3, "x"),
 +        (stat.S_IRGRP, 4, "r"),
 +        (stat.S_IWGRP, 5, "w"),
 +        (stat.S_IXGRP, 6, "x"),
 +        (stat.S_IROTH, 7, "r"),
 +        (stat.S_IWOTH, 8, "w"),
 +        (stat.S_IXOTH, 9, "x"),
 +    ]
++
 +    for bit, pos, char in mode_bits:
 +        if mode & bit:
 +            perms[pos] = char
++
 +    # Special bits
 +    if mode & stat.S_ISUID:
 +        perms[3] = "s" if mode & stat.S_IXUSR else "S"
 +    if mode & stat.S_ISGID:
 +        perms[6] = "s" if mode & stat.S_IXGRP else "S"
 +    if mode & stat.S_ISVTX:
 +        perms[9] = "t" if mode & stat.S_IXOTH else "T"
++
 +    return "".join(perms)
++
++
 +def sanitize_path(path: str, is_remote: bool = False) -> str:
 +    """
 +    Sanitize and normalize a file path.
++
 +    Args:
 +        path: Path to sanitize
 +        is_remote: Whether this is a remote (Unix) path
++
 +    Returns:
 +        Sanitized path
 +    """
 +    if not path:
 +        return "/"
++
 +    # Normalize the path
 +    path = os.path.normpath(path)
++
 +    # For remote paths, always use forward slashes
 +    if is_remote:
 +        path = path.replace("\\", "/")
 +        # Ensure it starts with /
 +        if not path.startswith("/"):
 +            path = "/" + path
++
 +    return path
++
++
 +def get_file_type_description(filename: str, is_dir: bool = False, is_link: bool = False) -> str:
 +    """
 +    Get a human-readable file type description.
++
 +    Args:
 +        filename: Name of the file
 +        is_dir: Whether it's a directory
 +        is_link: Whether it's a symbolic link
++
 +    Returns:
 +        File type description (e.g., "Python File", "Folder")
 +    """
 +    if is_link:
 +        return "Link"
 +    elif is_dir:
 +        return "Folder"
++
 +    ext = os.path.splitext(filename)[1].lower()
++
 +    if not ext:
 +        return "File"
++
 +    # Common file type descriptions
 +    file_types = {
 +        # Text
 +        ".txt": "Text File",
 +        ".md": "Markdown File",
 +        ".log": "Log File",
 +        ".rst": "reStructuredText File",
++
 +        # Code
 +        ".py": "Python File",
 +        ".js": "JavaScript File",
 +        ".cpp": "C++ File",
 +        ".c": "C File",
 +        ".java": "Java File",
 +        ".cs": "C# File",
 +        ".rb": "Ruby File",
 +        ".go": "Go File",
 +        ".rs": "Rust File",
 +        ".php": "PHP File",
 +        ".swift": "Swift File",
 +        ".kt": "Kotlin File",
++
 +        # Web
 +        ".html": "HTML File",
 +        ".css": "CSS File",
 +        ".xml": "XML File",
 +        ".json": "JSON File",
 +        ".yaml": "YAML File",
 +        ".yml": "YAML File",
++
 +        # Images
 +        ".jpg": "JPEG Image",
 +        ".jpeg": "JPEG Image",
 +        ".png": "PNG Image",
 +        ".gif": "GIF Image",
 +        ".bmp": "Bitmap Image",
 +        ".svg": "SVG Image",
++
 +        # Documents
 +        ".pdf": "PDF Document",
 +        ".doc": "Word Document",
 +        ".docx": "Word Document",
 +        ".xls": "Excel Spreadsheet",
 +        ".xlsx": "Excel Spreadsheet",
++
 +        # Archives
 +        ".zip": "ZIP Archive",
 +        ".tar": "TAR Archive",
 +        ".gz": "GZIP Archive",
 +        ".rar": "RAR Archive",
 +        ".7z": "7-Zip Archive",
++
 +        # Media
 +        ".mp3": "MP3 Audio",
 +        ".wav": "WAV Audio",
 +        ".mp4": "MP4 Video",
 +        ".avi": "AVI Video",
 +        ".mkv": "MKV Video",
 +    }
++
 +    return file_types.get(ext, f"{ext[1:].upper()} File")
++
++
 +def count_items(items: list, include_hidden: bool = True) -> Tuple[int, int]:
 +    """
 +    Count files and directories in a list of items.
++
 +    Args:
 +        items: List of file items (with 'is_dir' attribute or second element as is_dir flag)
 +        include_hidden: Whether to include hidden files in count
++
 +    Returns:
 +        Tuple of (file_count, directory_count)
 +    """
 +    files = 0
 +    dirs = 0
++
 +    for item in items:
 +        # Handle different item formats
 +        if hasattr(item, 'is_hidden') and item.is_hidden and not include_hidden:
 +            continue
++
 +        # Check if it's a tuple (path, is_dir) or has is_dir attribute
 +        if isinstance(item, tuple) and len(item) >= 2:
 +            if item[1]:  # is_dir
 +                dirs += 1
 +            else:
 +                files += 1
 +        elif hasattr(item, 'is_dir'):
 +            if item.is_dir:
 +                dirs += 1
 +            else:
 +                files += 1
++
 +    return files, dirs
++
++
 +def format_status_message(action: str, count: int, item_type: str = "item") -> str:
 +    """
 +    Format a status message with proper pluralization.
++
 +    Args:
 +        action: Action being performed (e.g., "Uploaded", "Deleted")
 +        count: Number of items
 +        item_type: Type of item (e.g., "file", "directory")
++
 +    Returns:
 +        Formatted status message
 +    """
 +    if count == 1:
 +        return f"{action} 1 {item_type}"
 +    else:
 +        # Simple pluralization
 +        if item_type.endswith("y"):
 +            plural = item_type[:-1] + "ies"
 +        elif item_type.endswith("s"):
 +            plural = item_type + "es"
 +        else:
 +            plural = item_type + "s"
++
 +        return f"{action} {count} {plural}"
++
++
 +def is_hidden_file(name: str) -> bool:
 +    """
 +    Check if a file/directory is hidden.
++
 +    Args:
 +        name: File or directory name
++
 +    Returns:
 +        True if hidden, False otherwise
 +    """
 +    return name.startswith(".") and name not in [".", ".."]
++
++
 +def get_icon_for_file(filename: str, is_dir: bool = False, is_link: bool = False) -> Tuple[str, str]:
 +    """
 +    Get icon name and color for a file type.
++
 +    Args:
 +        filename: Name of the file
 +        is_dir: Whether it's a directory
 +        is_link: Whether it's a symbolic link
++
 +    Returns:
 +        Tuple of (icon_name, color) for use with qtawesome
 +    """
 +    from ..core import FileTypes
++
 +    if is_link:
 +        return ("fa5s.link", "#6C757D")
 +    elif is_dir:
 +        return ("fa5s.folder", "#FFD93D")
++
 +    ext = os.path.splitext(filename)[1].lower()
 +    category = FileTypes.get_category(ext)
++
 +    icon_map = {
 +        "text": ("fa5s.file-alt", "#6C757D"),
 +        "code": ("fa5s.file-code", "#28A745"),
 +        "image": ("fa5s.file-image", "#17A2B8"),
 +        "audio": ("fa5s.file-audio", "#FD7E14"),
 +        "video": ("fa5s.file-video", "#DC3545"),
 +        "archive": ("fa5s.file-archive", "#6F42C1"),
 +        "pdf": ("fa5s.file-pdf", "#DC3545"),
 +        "file": ("fa5s.file", "#6C757D"),
 +    }
++
 +    return icon_map.get(category, ("fa5s.file", "#6C757D"))

src/wulftp/wulftp.pydeleted

1467 lines changed — click to load

 -import os
 -import stat
 -import sys
 -import shutil
 -from dataclasses import dataclass
 -from pathlib import Path
 -from typing import Dict, List, Optional
+-
 -import paramiko
 -import qtawesome as qta
 -from dotenv import load_dotenv
 -from paramiko import SSHConfig
 -from PyQt6.QtCore import (
 -    QDir,
 -    QModelIndex,
 -    QObject,
 -    QRunnable,
 -    QSize,
 -    Qt,
 -    QThreadPool,
 -    pyqtSignal,
 -    pyqtSlot,
 -    QMimeData,
 -)
 -from PyQt6.QtGui import QAction, QFileSystemModel, QIcon, QDragEnterEvent, QDropEvent
 -from PyQt6.QtWidgets import (
 -    QAbstractItemView,
 -    QApplication,
 -    QCheckBox,
 -    QComboBox,
 -    QHBoxLayout,
 -    QHeaderView,
 -    QLabel,
 -    QLineEdit,
 -    QMainWindow,
 -    QMenu,
 -    QMessageBox,
 -    QProgressBar,
 -    QPushButton,
 -    QSplitter,
 -    QStatusBar,
 -    QToolBar,
 -    QTreeView,
 -    QVBoxLayout,
 -    QWidget,
 -    QSizePolicy,
 -    QInputDialog,
 -)
+-
 -# Load environment variables
 -load_dotenv()
+-
+-
 -@dataclass
 -class SSHHost:
 -    """Represents an SSH host configuration"""
+-
 -    alias: str
 -    hostname: str
 -    port: int = 22
 -    user: str = None
 -    key_file: str = None
+-
 -    def display_name(self):
 -        if self.user:
 -            return f"{self.alias} ({self.user}@{self.hostname})"
 -        return f"{self.alias} ({self.hostname})"
+-
+-
 -class WorkerSignals(QObject):
 -    """Signals for thread workers"""
+-
 -    finished = pyqtSignal()
 -    error = pyqtSignal(str)
 -    progress = pyqtSignal(int)
 -    result = pyqtSignal(object)
+-
+-
 -class TransferWorker(QRunnable):
 -    """Worker for file transfers"""
+-
 -    def __init__(self, sftp, source, dest, is_upload=True):
 -        super().__init__()
 -        self.sftp = sftp
 -        self.source = source
 -        self.dest = dest
 -        self.is_upload = is_upload
 -        self.signals = WorkerSignals()
+-
 -    def run(self):
 -        try:
 -            if self.is_upload:
 -                self.sftp.put(self.source, self.dest, callback=self._progress_callback)
 -            else:
 -                self.sftp.get(self.source, self.dest, callback=self._progress_callback)
 -            self.signals.finished.emit()
 -        except Exception as e:
 -            self.signals.error.emit(str(e))
+-
 -    def _progress_callback(self, transferred, total):
 -        if total > 0:
 -            progress = int((transferred / total) * 100)
 -            self.signals.progress.emit(progress)
+-
+-
 -class DirectoryTransferWorker(QRunnable):
 -    """Worker for directory transfers"""
+-
 -    def __init__(self, sftp, source_dir, dest_dir, is_upload=True):
 -        super().__init__()
 -        self.sftp = sftp
 -        self.source_dir = source_dir
 -        self.dest_dir = dest_dir
 -        self.is_upload = is_upload
 -        self.signals = WorkerSignals()
 -        self.total_files = 0
 -        self.processed_files = 0
+-
 -    def run(self):
 -        try:
 -            if self.is_upload:
 -                self._upload_directory(self.source_dir, self.dest_dir)
 -            else:
 -                self._download_directory(self.source_dir, self.dest_dir)
 -            self.signals.finished.emit()
 -        except Exception as e:
 -            self.signals.error.emit(str(e))
+-
 -    def _count_files(self, local_path):
 -        """Count total files in a local directory recursively"""
 -        count = 0
 -        for root, dirs, files in os.walk(local_path):
 -            count += len(files)
 -        return count
+-
 -    def _count_remote_files(self, remote_path):
 -        """Count total files in a remote directory recursively"""
 -        count = 0
 -        try:
 -            for item in self.sftp.listdir_attr(remote_path):
 -                item_path = os.path.join(remote_path, item.filename)
 -                if stat.S_ISDIR(item.st_mode):
 -                    count += self._count_remote_files(item_path)
 -                else:
 -                    count += 1
 -        except:
 -            pass
 -        return count
+-
 -    def _upload_directory(self, local_path, remote_path):
 -        """Recursively upload a directory"""
 -        # Count total files first
 -        if self.total_files == 0:
 -            self.total_files = self._count_files(local_path)
+-
 -        # Create remote directory
 -        try:
 -            self.sftp.mkdir(remote_path)
 -        except:
 -            # Directory might already exist
 -            pass
+-
 -        # Upload contents
 -        for item in os.listdir(local_path):
 -            local_item = os.path.join(local_path, item)
 -            remote_item = os.path.join(remote_path, item).replace('\\', '/')
+-
 -            if os.path.isdir(local_item):
 -                self._upload_directory(local_item, remote_item)
 -            else:
 -                # Upload file
 -                self.sftp.put(local_item, remote_item)
 -                self.processed_files += 1
 -                if self.total_files > 0:
 -                    progress = int((self.processed_files / self.total_files) * 100)
 -                    self.signals.progress.emit(progress)
+-
 -    def _download_directory(self, remote_path, local_path):
 -        """Recursively download a directory"""
 -        # Count total files first
 -        if self.total_files == 0:
 -            self.total_files = self._count_remote_files(remote_path)
+-
 -        # Create local directory
 -        os.makedirs(local_path, exist_ok=True)
+-
 -        # Download contents
 -        for item in self.sftp.listdir_attr(remote_path):
 -            remote_item = os.path.join(remote_path, item.filename).replace('\\', '/')
 -            local_item = os.path.join(local_path, item.filename)
+-
 -            if stat.S_ISDIR(item.st_mode):
 -                self._download_directory(remote_item, local_item)
 -            else:
 -                # Download file
 -                self.sftp.get(remote_item, local_item)
 -                self.processed_files += 1
 -                if self.total_files > 0:
 -                    progress = int((self.processed_files / self.total_files) * 100)
 -                    self.signals.progress.emit(progress)
+-
+-
 -class LocalTreeView(QTreeView):
 -    """Custom tree view for local files that handles remote file drops"""
+-
 -    remoteFilesDropped = pyqtSignal(list, str)  # remote_items (path, is_dir), local_directory
+-
 -    def __init__(self, parent=None):
 -        super().__init__(parent)
 -        self.setAcceptDrops(True)
+-
 -    def dragEnterEvent(self, event: QDragEnterEvent):
 -        """Accept drops from remote files"""
 -        mime_data = event.mimeData()
+-
 -        # Check if this is a remote file drop
 -        if mime_data.hasFormat("application/x-wulftp-remote"):
 -            event.acceptProposedAction()
 -        else:
 -            # Let the parent handle local file drags
 -            super().dragEnterEvent(event)
+-
 -    def dragMoveEvent(self, event):
 -        """Handle drag move events"""
 -        mime_data = event.mimeData()
+-
 -        if mime_data.hasFormat("application/x-wulftp-remote"):
 -            # Check if we're over a directory
 -            index = self.indexAt(event.position().toPoint())
 -            if index.isValid():
 -                model = self.model()
 -                if model and model.isDir(index):
 -                    event.acceptProposedAction()
 -                    return
 -            # Also accept drops on empty space (root directory)
 -            event.acceptProposedAction()
 -        else:
 -            super().dragMoveEvent(event)
+-
 -    def dropEvent(self, event: QDropEvent):
 -        """Handle drops from remote files"""
 -        mime_data = event.mimeData()
+-
 -        if mime_data.hasFormat("application/x-wulftp-remote"):
 -            # Get the target directory
 -            index = self.indexAt(event.position().toPoint())
 -            model = self.model()
+-
 -            if index.isValid() and model:
 -                if model.isDir(index):
 -                    target_dir = model.filePath(index)
 -                else:
 -                    # Dropped on a file, use its parent directory
 -                    target_dir = model.filePath(model.parent(index))
 -            else:
 -                # Dropped on empty space, use root
 -                target_dir = model.rootPath() if model else ""
+-
 -            # Get remote paths with type info
 -            remote_data = mime_data.data("application/x-wulftp-remote").data().decode('utf-8')
 -            remote_items = []
 -            for line in remote_data.split('\n'):
 -                if line.strip() and '|' in line:
 -                    path, type_flag = line.strip().rsplit('|', 1)
 -                    is_dir = type_flag == 'D'
 -                    remote_items.append((path, is_dir))
 -                elif line.strip():
 -                    # Fallback for old format
 -                    remote_items.append((line.strip(), False))
+-
 -            if remote_items and target_dir:
 -                self.remoteFilesDropped.emit(remote_items, target_dir)
 -                event.acceptProposedAction()
 -        else:
 -            # Let parent handle local file operations
 -            super().dropEvent(event)
+-
+-
 -class WulFTPClient(QMainWindow):
 -    def __init__(self):
 -        super().__init__()
 -        self.ssh = None
 -        self.sftp = None
 -        self.threadpool = QThreadPool()
 -        self.ssh_hosts = self._load_ssh_config()
+-
 -        # Import the model here to avoid circular imports
 -        from .remote_model import RemoteFileSystemModel
 -        self.remote_model = RemoteFileSystemModel()
+-
 -        self.init_ui()
+-
 -    def _load_ssh_config(self) -> Dict[str, SSHHost]:
 -        """Load SSH hosts from ~/.ssh/config"""
 -        hosts = {}
 -        config_path = Path.home() / ".ssh" / "config"
+-
 -        if config_path.exists():
 -            config = SSHConfig()
 -            with open(config_path) as f:
 -                config.parse(f)
+-
 -            for host in config.get_hostnames():
 -                if host == "*":
 -                    continue
+-
 -                cfg = config.lookup(host)
 -                hosts[host] = SSHHost(
 -                    alias=host,
 -                    hostname=cfg.get("hostname", host),
 -                    port=int(cfg.get("port", 22)),
 -                    user=cfg.get("user"),
 -                    key_file=cfg.get("identityfile", [None])[0],
 -                )
+-
 -        # Add custom hosts from environment
 -        if os.getenv("WULFTP_HOST"):
 -            hosts["env_default"] = SSHHost(
 -                alias="Default",
 -                hostname=os.getenv("WULFTP_HOST"),
 -                port=int(os.getenv("WULFTP_PORT", "22")),
 -                user=os.getenv("WULFTP_USER"),
 -                key_file=os.getenv("WULFTP_KEY"),
 -            )
+-
 -        return hosts
+-
 -    def init_ui(self):
 -        self.setWindowTitle("wulFTP - Family Backup Tool")
 -        self.setGeometry(100, 100, 1200, 800)
+-
 -        # Central widget
 -        central = QWidget()
 -        self.setCentralWidget(central)
+-
 -        # Main layout - no margins for maximum space
 -        layout = QVBoxLayout(central)
 -        layout.setContentsMargins(0, 0, 0, 0)
 -        layout.setSpacing(0)
+-
 -        # Status bar (create early so conn_status is available)
 -        self.status_bar = QStatusBar()
 -        self.setStatusBar(self.status_bar)
+-
 -        # Progress bar (hidden by default)
 -        self.progress_bar = QProgressBar()
 -        self.progress_bar.setVisible(False)
 -        self.status_bar.addPermanentWidget(self.progress_bar)
+-
 -        # Connection status
 -        self.conn_status = QLabel("Disconnected")
 -        self.status_bar.addPermanentWidget(self.conn_status)
+-
 -        # Create toolbar with connection controls
 -        self._create_toolbar()
+-
 -        # Create splitter for two-pane view - this is the main content
 -        splitter = QSplitter(Qt.Orientation.Horizontal)
 -        splitter.setContentsMargins(0, 0, 0, 0)
+-
 -        # Local pane
 -        self.local_pane = self._create_file_pane("Local Files", is_local=True)
 -        splitter.addWidget(self.local_pane)
+-
 -        # Remote pane
 -        self.remote_pane = self._create_file_pane("Remote Files", is_local=False)
 -        self.remote_pane.setEnabled(False)
 -        splitter.addWidget(self.remote_pane)
+-
 -        # Set initial splitter sizes
 -        splitter.setSizes([600, 600])
+-
 -        # Add splitter to main layout
 -        layout.addWidget(splitter)
+-
 -        # Initial button state update
 -        self._update_button_states()
+-
 -    def _create_toolbar(self):
 -        """Create main toolbar"""
 -        toolbar = QToolBar()
 -        toolbar.setMovable(False)  # Keep toolbar in place
 -        self.addToolBar(toolbar)
+-
 -        # Connection controls in toolbar
 -        # Host dropdown
 -        toolbar.addWidget(QLabel(" Host: "))
 -        self.host_combo = QComboBox()
 -        self.host_combo.setMinimumWidth(250)
 -        self.host_combo.setMaximumWidth(350)
+-
 -        # Populate hosts
 -        for host in self.ssh_hosts.values():
 -            self.host_combo.addItem(host.display_name(), host)
+-
 -        # Add custom option
 -        self.host_combo.addItem("Custom...", None)
 -        self.host_combo.currentIndexChanged.connect(self._on_host_changed)
 -        toolbar.addWidget(self.host_combo)
+-
 -        # Custom host fields (hidden by default)
 -        self.custom_host = QLineEdit()
 -        self.custom_host.setPlaceholderText("hostname")
 -        self.custom_host.setVisible(False)
 -        self.custom_host.setMaximumWidth(150)
 -        toolbar.addWidget(self.custom_host)
+-
 -        self.custom_user = QLineEdit()
 -        self.custom_user.setPlaceholderText("username")
 -        self.custom_user.setVisible(False)
 -        self.custom_user.setMaximumWidth(100)
 -        toolbar.addWidget(self.custom_user)
+-
 -        # Connect button
 -        self.connect_btn = QPushButton()
 -        self.connect_btn.setIcon(qta.icon("fa5s.plug", color="#4CAF50"))
 -        self.connect_btn.setText("Connect")
 -        self.connect_btn.clicked.connect(self.toggle_connection)
 -        toolbar.addWidget(self.connect_btn)
+-
 -        # Connection indicator
 -        self.conn_indicator = QLabel()
 -        self._update_connection_status(False)
 -        toolbar.addWidget(self.conn_indicator)
+-
 -        toolbar.addSeparator()
+-
 -        # Upload action
 -        upload_action = QAction(
 -            qta.icon("fa5s.upload", color="#4CAF50"), "Upload Selected", self
 -        )
 -        upload_action.triggered.connect(self.upload_selected)
 -        upload_action.setEnabled(False)
 -        toolbar.addAction(upload_action)
 -        self.upload_action = upload_action
+-
 -        # Download action
 -        download_action = QAction(
 -            qta.icon("fa5s.download", color="#2196F3"), "Download Selected", self
 -        )
 -        download_action.triggered.connect(self.download_selected)
 -        download_action.setEnabled(False)
 -        toolbar.addAction(download_action)
 -        self.download_action = download_action
+-
 -        toolbar.addSeparator()
+-
 -        # Delete action
 -        delete_action = QAction(
 -            qta.icon("fa5s.trash", color="#F44336"), "Delete Selected", self
 -        )
 -        delete_action.triggered.connect(self.delete_selected)
 -        delete_action.setEnabled(True)  # Always enabled
 -        toolbar.addAction(delete_action)
 -        self.delete_action = delete_action
+-
 -        toolbar.addSeparator()
+-
 -        # Refresh action
 -        refresh_action = QAction(
 -            qta.icon("fa5s.sync", color="#FF9800"), "Refresh", self
 -        )
 -        refresh_action.triggered.connect(self.refresh_views)
 -        toolbar.addAction(refresh_action)
+-
 -        # Add spacer to push settings to the right
 -        spacer = QWidget()
 -        spacer.setSizePolicy(
 -            QSizePolicy.Policy.Expanding,
 -            QSizePolicy.Policy.Expanding
 -        )
 -        toolbar.addWidget(spacer)
+-
 -        # Settings actions
 -        self.show_hidden_action = QAction("Show Hidden Files", self)
 -        self.show_hidden_action.setCheckable(True)
 -        self.show_hidden_action.setChecked(False)
 -        self.show_hidden_action.toggled.connect(self._toggle_hidden_files)
 -        toolbar.addAction(self.show_hidden_action)
+-
 -        self.show_details_action = QAction("Show Full Details", self)
 -        self.show_details_action.setCheckable(True)
 -        self.show_details_action.setChecked(False)
 -        self.show_details_action.toggled.connect(self._toggle_full_details)
 -        toolbar.addAction(self.show_details_action)
+-
 -    def _create_connection_bar(self):
 -        """Create connection controls"""
 -        widget = QWidget()
 -        layout = QHBoxLayout(widget)
 -        layout.setContentsMargins(8, 4, 8, 4)
+-
 -        # Host dropdown
 -        layout.addWidget(QLabel("Host:"))
 -        self.host_combo = QComboBox()
 -        self.host_combo.setMinimumWidth(250)
+-
 -        # Populate hosts
 -        for host in self.ssh_hosts.values():
 -            self.host_combo.addItem(host.display_name(), host)
+-
 -        # Add custom option
 -        self.host_combo.addItem("Custom...", None)
 -        self.host_combo.currentIndexChanged.connect(self._on_host_changed)
 -        layout.addWidget(self.host_combo)
+-
 -        # Custom host fields (hidden by default)
 -        self.custom_host = QLineEdit()
 -        self.custom_host.setPlaceholderText("hostname")
 -        self.custom_host.setVisible(False)
 -        layout.addWidget(self.custom_host)
+-
 -        self.custom_user = QLineEdit()
 -        self.custom_user.setPlaceholderText("username")
 -        self.custom_user.setVisible(False)
 -        layout.addWidget(self.custom_user)
+-
 -        # Connect button
 -        self.connect_btn = QPushButton("Connect")
 -        self.connect_btn.clicked.connect(self.toggle_connection)
 -        layout.addWidget(self.connect_btn)
+-
 -        # Connection indicator
 -        self.conn_indicator = QLabel()
 -        self._update_connection_status(False)
 -        layout.addWidget(self.conn_indicator)
+-
 -        layout.addStretch()
 -        return widget
+-
 -    def _create_file_pane(self, title: str, is_local: bool):
 -        """Create a file browser pane"""
 -        widget = QWidget()
 -        layout = QVBoxLayout(widget)
 -        layout.setContentsMargins(5, 5, 5, 5)
 -        layout.setSpacing(5)
+-
 -        # Header with navigation
 -        header = QWidget()
 -        header_layout = QHBoxLayout(header)
 -        header_layout.setContentsMargins(0, 0, 0, 0)
+-
 -        # Title
 -        title_label = QLabel(title)
 -        title_label.setStyleSheet("font-weight: bold; font-size: 14px;")
 -        header_layout.addWidget(title_label)
+-
 -        header_layout.addStretch()
+-
 -        # Navigation buttons
 -        up_btn = QPushButton()
 -        up_btn.setIcon(qta.icon("fa5s.arrow-up"))
 -        up_btn.setMaximumSize(30, 30)
 -        up_btn.setToolTip("Go up one directory")
 -        header_layout.addWidget(up_btn)
+-
 -        home_btn = QPushButton()
 -        home_btn.setIcon(qta.icon("fa5s.home"))
 -        home_btn.setMaximumSize(30, 30)
 -        home_btn.setToolTip("Go to home directory")
 -        header_layout.addWidget(home_btn)
+-
 -        # Create directory button
 -        create_dir_btn = QPushButton()
 -        create_dir_btn.setIcon(qta.icon("fa5s.folder-plus", color="#FF9800"))
 -        create_dir_btn.setMaximumSize(30, 30)
 -        create_dir_btn.setToolTip("Create new directory")
 -        create_dir_btn.clicked.connect(lambda: self._create_directory(is_local))
 -        header_layout.addWidget(create_dir_btn)
+-
 -        # Store reference to remote create dir button for enabling/disabling
 -        if not is_local:
 -            self.remote_create_dir_btn = create_dir_btn
+-
 -        layout.addWidget(header)
+-
 -        # Path display
 -        path_edit = QLineEdit()
 -        path_edit.setReadOnly(True)
 -        path_edit.setStyleSheet("""
 -            QLineEdit {
 -                background-color: #2b2b2b;
 -                color: #ffffff;
 -                border: 1px solid #555555;
 -                padding: 4px;
 -                font-family: monospace;
 -            }
 -        """)
 -        layout.addWidget(path_edit)
+-
 -        # File view
 -        if is_local:
 -            # Local file system model
 -            model = QFileSystemModel()
 -            model.setRootPath(QDir.homePath())
+-
 -            # Use custom tree view for local files
 -            view = LocalTreeView()
 -            view.setModel(model)
 -            view.setRootIndex(model.index(QDir.homePath()))
 -            view.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+-
 -            # Enable drag from local view
 -            view.setDragEnabled(True)
 -            view.setDefaultDropAction(Qt.DropAction.CopyAction)
+-
 -            # Drop is handled by LocalTreeView
 -            view.setDropIndicatorShown(True)
+-
 -            # Connect remote file drop signal
 -            view.remoteFilesDropped.connect(self._handle_remote_files_dropped)
+-
 -            # Configure columns
 -            view.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
 -            view.setColumnWidth(1, 100)  # Size
 -            view.setColumnWidth(2, 120)  # Type
 -            view.setColumnWidth(3, 120)  # Date
+-
 -            # Store references
 -            self.local_model = model
 -            self.local_view = view
 -            self.local_path = path_edit
 -            self.local_path.setText(QDir.homePath())
+-
 -            # Connect navigation
 -            up_btn.clicked.connect(lambda: self._navigate_up(True))
 -            home_btn.clicked.connect(lambda: self._navigate_home(True))
 -            view.doubleClicked.connect(lambda idx: self._on_local_double_click(idx))
+-
 -            # Connect selection change to update button states
 -            view.selectionModel().selectionChanged.connect(self._update_button_states)
+-
 -        else:
 -            # Remote file list with the new model
 -            view = QTreeView()
 -            view.setModel(self.remote_model)
 -            view.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+-
 -            # Enable drag from remote view and drop onto it
 -            view.setDragEnabled(True)
 -            view.setAcceptDrops(True)
 -            view.setDefaultDropAction(Qt.DropAction.CopyAction)
 -            view.setDropIndicatorShown(True)
+-
 -            # Configure columns
 -            view.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
 -            view.setColumnWidth(1, 100)  # Size
 -            view.setColumnWidth(2, 100)  # Type
 -            view.setColumnWidth(3, 120)  # Modified
+-
 -            # Performance optimizations
 -            view.setUniformRowHeights(True)
 -            view.setAlternatingRowColors(True)
+-
 -            # Store references
 -            self.remote_view = view
 -            self.remote_path = path_edit
 -            self.remote_cwd = "/"
+-
 -            # Connect model signals
 -            self.remote_model.directoryLoaded.connect(lambda path: self.remote_path.setText(path))
 -            self.remote_model.errorOccurred.connect(lambda err: QMessageBox.warning(self, "Error", err))
 -            self.remote_model.filesDropped.connect(self._handle_files_dropped)
+-
 -            # Connect navigation
 -            up_btn.clicked.connect(lambda: self._navigate_up(False))
 -            home_btn.clicked.connect(lambda: self._navigate_home(False))
 -            view.doubleClicked.connect(lambda idx: self._on_remote_double_click(idx))
+-
 -            # Connect single click to update path
 -            view.clicked.connect(lambda idx: self._on_remote_clicked(idx))
+-
 -            # Track expansion state
 -            view.expanded.connect(self._on_remote_expanded)
 -            view.collapsed.connect(self._on_remote_collapsed)
+-
 -            # Connect selection change to update button states
 -            view.selectionModel().selectionChanged.connect(self._update_button_states)
+-
 -        # Context menu
 -        view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
 -        view.customContextMenuRequested.connect(
 -            lambda pos: self._show_context_menu(pos, is_local)
 -        )
+-
 -        layout.addWidget(view)
 -        return widget
+-
 -    def _on_host_changed(self, index):
 -        """Handle host selection change"""
 -        host = self.host_combo.currentData()
 -        is_custom = host is None
+-
 -        self.custom_host.setVisible(is_custom)
 -        self.custom_user.setVisible(is_custom)
+-
 -    def _update_connection_status(self, connected: bool):
 -        """Update connection indicators"""
 -        if connected:
 -            icon = qta.icon("fa5s.link", color="#4CAF50")
 -            self.conn_status.setText("Connected")
 -            self.connect_btn.setText("Disconnect")
 -            self.connect_btn.setIcon(qta.icon("fa5s.unlink", color="#F44336"))
 -        else:
 -            icon = qta.icon("fa5s.unlink", color="#F44336")
 -            self.conn_status.setText("Disconnected")
 -            self.connect_btn.setText("Connect")
 -            self.connect_btn.setIcon(qta.icon("fa5s.plug", color="#4CAF50"))
+-
 -        self.conn_indicator.setPixmap(icon.pixmap(24, 24))
+-
 -        # Only update these if they exist (they might not during initialization)
 -        if hasattr(self, 'upload_action'):
 -            self.upload_action.setEnabled(connected)
 -        if hasattr(self, 'download_action'):
 -            self.download_action.setEnabled(connected)
 -        # Delete action is always enabled (not dependent on connection)
 -        if hasattr(self, 'remote_pane'):
 -            self.remote_pane.setEnabled(connected)
+-
 -    def toggle_connection(self):
 -        """Connect or disconnect from server"""
 -        if self.sftp:
 -            self.disconnect()
 -        else:
 -            self.connect()
+-
 -    def connect(self):
 -        """Establish SFTP connection"""
 -        # Store current focus widget
 -        focus_widget = QApplication.focusWidget()
+-
 -        try:
 -            host_data = self.host_combo.currentData()
+-
 -            if host_data:
 -                # Use predefined host
 -                hostname = host_data.hostname
 -                port = host_data.port
 -                username = host_data.user
 -                key_file = host_data.key_file
 -            else:
 -                # Use custom values
 -                hostname = self.custom_host.text()
 -                username = self.custom_user.text()
 -                port = 22
 -                key_file = None
+-
 -            # Create SSH client
 -            self.ssh = paramiko.SSHClient()
 -            self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+-
 -            # Try to connect with various authentication methods
 -            connect_kwargs = {
 -                "hostname": hostname,
 -                "port": port,
 -                "username": username,
 -                "timeout": 10,
 -            }
+-
 -            if key_file and os.path.exists(os.path.expanduser(key_file)):
 -                # Try different key types
 -                key_path = os.path.expanduser(key_file)
 -                try:
 -                    # Try to load key with auto-detection
 -                    connect_kwargs["key_filename"] = key_path
 -                except:
 -                    pass
+-
 -            # Allow password fallback
 -            connect_kwargs["look_for_keys"] = True
 -            connect_kwargs["allow_agent"] = True
+-
 -            self.ssh.connect(**connect_kwargs)
 -            self.sftp = self.ssh.open_sftp()
+-
 -            # Update remote model with SFTP connection
 -            self.remote_model.set_sftp(self.sftp)
+-
 -            # Update UI
 -            self._update_connection_status(True)
+-
 -            self.status_bar.showMessage(f"Connected to {hostname}", 3000)
+-
 -            # Restore focus
 -            if focus_widget:
 -                focus_widget.setFocus()
+-
 -        except Exception as e:
 -            QMessageBox.critical(
 -                self,
 -                "Connection Error",
 -                str(e),
 -                QMessageBox.StandardButton.Ok,
 -                QMessageBox.StandardButton.Ok
 -            )
 -            self._update_connection_status(False)
+-
 -            # Restore focus even on error
 -            if focus_widget:
 -                focus_widget.setFocus()
+-
 -    def disconnect(self):
 -        """Close SFTP connection"""
 -        if self.sftp:
 -            self.sftp.close()
 -            self.sftp = None
 -        if self.ssh:
 -            self.ssh.close()
 -            self.ssh = None
+-
 -        # Clear remote model
 -        self.remote_model.set_sftp(None)
+-
 -        self._update_connection_status(False)
 -        self.status_bar.showMessage("Disconnected", 3000)
+-
 -    def refresh_views(self):
 -        """Refresh both file views"""
 -        # Local is automatically updated by QFileSystemModel
 -        if self.sftp and self.remote_model:
 -            self.remote_model.refresh(preserve_state=True)
+-
 -    def _toggle_hidden_files(self, checked: bool):
 -        """Toggle showing hidden files in remote view"""
 -        self.remote_model.set_show_hidden(checked)
+-
 -    def _toggle_full_details(self, checked: bool):
 -        """Toggle showing full details (permissions) in remote view"""
 -        self.remote_model.set_show_full_details(checked)
 -        # Adjust column visibility
 -        if checked:
 -            self.remote_view.showColumn(4)  # Permissions column
 -        else:
 -            self.remote_view.hideColumn(4)
+-
 -    def _navigate_up(self, is_local: bool):
 -        """Navigate up one directory"""
 -        if is_local:
 -            current = self.local_view.rootIndex()
 -            parent = self.local_model.parent(current)
 -            if parent.isValid():
 -                self.local_view.setRootIndex(parent)
 -                self.local_path.setText(self.local_model.filePath(parent))
 -        else:
 -            # For remote, we navigate in the tree view
 -            current_path = self.remote_path.text()
 -            if current_path and current_path != "/":
 -                parent_path = os.path.dirname(current_path)
 -                # Find the parent item in the model
 -                parent_item = self.remote_model._find_item_by_path(parent_path)
 -                if parent_item:
 -                    parent_idx = self.remote_model._get_index_for_item(parent_item)
 -                    # Expand to show it
 -                    self.remote_view.expand(parent_idx)
 -                    # Update path display
 -                    self.remote_path.setText(parent_path)
+-
 -    def _navigate_home(self, is_local: bool):
 -        """Navigate to home directory"""
 -        if is_local:
 -            home_index = self.local_model.index(QDir.homePath())
 -            self.local_view.setRootIndex(home_index)
 -            self.local_path.setText(QDir.homePath())
 -        else:
 -            # Just update the path display for remote
 -            self.remote_path.setText("/")
+-
 -    def _on_remote_double_click(self, index: QModelIndex):
 -        """Handle double-click on remote file"""
 -        if self.remote_model.isDir(index):
 -            # Don't change the view root, just expand/collapse
 -            if self.remote_view.isExpanded(index):
 -                self.remote_view.collapse(index)
 -            else:
 -                self.remote_view.expand(index)
+-
 -            # Update path display
 -            path = self.remote_model.filePath(index)
 -            self.remote_path.setText(path)
+-
 -    def _on_remote_clicked(self, index: QModelIndex):
 -        """Handle single click on remote file"""
 -        # Update path display when item is selected
 -        path = self.remote_model.filePath(index)
 -        if path:
 -            self.remote_path.setText(path)
+-
 -    def _on_local_double_click(self, index: QModelIndex):
 -        """Handle double-click on local file"""
 -        if self.local_model.isDir(index):
 -            self.local_view.setRootIndex(index)
 -            self.local_path.setText(self.local_model.filePath(index))
+-
 -    def _update_button_states(self):
 -        """Update button states based on current selection"""
 -        # Check if anything is selected in either view
 -        local_has_selection = bool(self.local_view.selectedIndexes())
 -        remote_has_selection = bool(self.remote_view.selectedIndexes()) if self.sftp else False
+-
 -        has_any_selection = local_has_selection or remote_has_selection
+-
 -        # Update delete button - make it look disabled when nothing is selected
 -        if hasattr(self, 'delete_action'):
 -            if has_any_selection:
 -                self.delete_action.setIcon(qta.icon("fa5s.trash", color="#F44336"))
 -            else:
 -                self.delete_action.setIcon(qta.icon("fa5s.trash", color="#888888"))
+-
 -    def _on_remote_expanded(self, index: QModelIndex):
 -        """Track when a directory is expanded"""
 -        path = self.remote_model.filePath(index)
 -        if path:
 -            self.remote_model.mark_expanded(path)
+-
 -    def _on_remote_collapsed(self, index: QModelIndex):
 -        """Track when a directory is collapsed"""
 -        path = self.remote_model.filePath(index)
 -        if path:
 -            self.remote_model.mark_collapsed(path)
+-
 -    def _show_context_menu(self, pos, is_local: bool):
 -        """Show context menu for file operations"""
 -        menu = QMenu()
 -        view = self.local_view if is_local else self.remote_view
+-
 -        # Get selected items
 -        selection = view.selectedIndexes()
 -        has_selection = len(selection) > 0
+-
 -        if self.sftp:  # Only show transfer options when connected
 -            if is_local:
 -                upload_action = menu.addAction(
 -                    qta.icon("fa5s.upload", color="#4CAF50"), "Upload"
 -                )
 -                upload_action.triggered.connect(self.upload_selected)
 -                upload_action.setEnabled(has_selection)
 -            else:
 -                download_action = menu.addAction(
 -                    qta.icon("fa5s.download", color="#2196F3"), "Download"
 -                )
 -                download_action.triggered.connect(self.download_selected)
 -                download_action.setEnabled(has_selection)
+-
 -        menu.addSeparator()
+-
 -        # Create directory action
 -        create_dir_action = menu.addAction(
 -            qta.icon("fa5s.folder-plus", color="#FF9800"), "Create Directory"
 -        )
 -        create_dir_action.triggered.connect(lambda: self._create_directory(is_local))
+-
 -        # Delete action
 -        if has_selection:
 -            delete_action = menu.addAction(
 -                qta.icon("fa5s.trash", color="#F44336"), "Delete"
 -            )
 -            delete_action.triggered.connect(lambda: self._delete_selected(is_local))
+-
 -        menu.addSeparator()
+-
 -        refresh_action = menu.addAction(qta.icon("fa5s.sync"), "Refresh")
 -        refresh_action.triggered.connect(self.refresh_views)
+-
 -        # Show menu at cursor position
 -        menu.exec(view.mapToGlobal(pos))
+-
 -    def upload_selected(self):
 -        """Upload selected local files and directories"""
 -        if not self.sftp:
 -            return
+-
 -        selection = self.local_view.selectedIndexes()
 -        if not selection:
 -            return
+-
 -        # Get unique file/directory paths (avoiding duplicates from multiple columns)
 -        items = []
 -        for index in selection:
 -            if index.column() == 0:  # Only process name column
 -                path = self.local_model.filePath(index)
 -                is_dir = self.local_model.isDir(index)
 -                items.append((path, is_dir))
+-
 -        # Separate files and directories
 -        files = [path for path, is_dir in items if not is_dir]
 -        directories = [path for path, is_dir in items if is_dir]
+-
 -        # Handle directories first
 -        if directories:
 -            reply = QMessageBox.question(
 -                self,
 -                "Upload Directories",
 -                f"Upload {len(directories)} director{'y' if len(directories) == 1 else 'ies'}?\n\n" +
 -                "This will recursively upload all contents.",
 -                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 -                QMessageBox.StandardButton.Yes
 -            )
+-
 -            if reply == QMessageBox.StandardButton.Yes:
 -                for dir_path in directories:
 -                    dirname = os.path.basename(dir_path)
 -                    remote_base = self.remote_path.text() or "/"
 -                    remote_path = os.path.join(remote_base, dirname).replace('\\', '/')
+-
 -                    worker = DirectoryTransferWorker(self.sftp, dir_path, remote_path, is_upload=True)
+-
 -                    # Connect signals
 -                    worker.signals.progress.connect(self._update_progress)
 -                    worker.signals.finished.connect(self._transfer_complete)
 -                    worker.signals.error.connect(self._transfer_error)
+-
 -                    # Show progress bar
 -                    self.progress_bar.setVisible(True)
 -                    self.progress_bar.setValue(0)
+-
 -                    # Start transfer
 -                    self.threadpool.start(worker)
+-
 -                    self.status_bar.showMessage(f"Uploading directory: {dirname}", 3000)
+-
 -        # Handle files
 -        if files:
 -            self._transfer_files(files, is_upload=True)
+-
 -    def download_selected(self):
 -        """Download selected remote files and directories"""
 -        if not self.sftp:
 -            return
+-
 -        selection = self.remote_view.selectedIndexes()
 -        if not selection:
 -            return
+-
 -        # Get unique file/directory paths (avoiding duplicates from multiple columns)
 -        items = []
 -        for index in selection:
 -            if index.column() == 0:  # Only process name column
 -                file_info = self.remote_model.fileInfo(index)
 -                if file_info:
 -                    items.append((file_info.full_path, file_info.is_dir, file_info.name))
+-
 -        # Separate files and directories
 -        files = [path for path, is_dir, name in items if not is_dir]
 -        directories = [(path, name) for path, is_dir, name in items if is_dir]
+-
 -        # Handle directories first
 -        if directories:
 -            reply = QMessageBox.question(
 -                self,
 -                "Download Directories",
 -                f"Download {len(directories)} director{'y' if len(directories) == 1 else 'ies'}?\n\n" +
 -                "This will recursively download all contents.",
 -                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 -                QMessageBox.StandardButton.Yes
 -            )
+-
 -            if reply == QMessageBox.StandardButton.Yes:
 -                for dir_path, dirname in directories:
 -                    local_base = self.local_model.filePath(self.local_view.rootIndex())
 -                    local_path = os.path.join(local_base, dirname)
+-
 -                    worker = DirectoryTransferWorker(self.sftp, dir_path, local_path, is_upload=False)
+-
 -                    # Connect signals
 -                    worker.signals.progress.connect(self._update_progress)
 -                    worker.signals.finished.connect(self._transfer_complete_download)
 -                    worker.signals.error.connect(self._transfer_error)
+-
 -                    # Show progress bar
 -                    self.progress_bar.setVisible(True)
 -                    self.progress_bar.setValue(0)
+-
 -                    # Start transfer
 -                    self.threadpool.start(worker)
+-
 -                    self.status_bar.showMessage(f"Downloading directory: {dirname}", 3000)
+-
 -        # Handle files
 -        if files:
 -            self._transfer_files(files, is_upload=False)
+-
 -    def _transfer_files(self, files: List[str], is_upload: bool):
 -        """Transfer files with progress tracking"""
 -        for file_path in files:
 -            filename = os.path.basename(file_path)
+-
 -            if is_upload:
 -                # Get current remote directory from path display
 -                remote_base = self.remote_path.text() or "/"
 -                remote_path = os.path.join(remote_base, filename)
 -                worker = TransferWorker(self.sftp, file_path, remote_path, True)
 -            else:
 -                # Download to current local directory
 -                local_base = self.local_model.filePath(self.local_view.rootIndex())
 -                local_path = os.path.join(local_base, filename)
 -                worker = TransferWorker(self.sftp, file_path, local_path, False)
+-
 -            # Connect signals
 -            worker.signals.progress.connect(self._update_progress)
 -            worker.signals.finished.connect(self._transfer_complete)
 -            worker.signals.error.connect(self._transfer_error)
+-
 -            # Show progress bar
 -            self.progress_bar.setVisible(True)
 -            self.progress_bar.setValue(0)
+-
 -            # Start transfer
 -            self.threadpool.start(worker)
+-
 -    @pyqtSlot(int)
 -    def _update_progress(self, value):
 -        """Update progress bar"""
 -        self.progress_bar.setValue(value)
+-
 -    @pyqtSlot()
 -    def _transfer_complete(self):
 -        """Handle transfer completion"""
 -        self.progress_bar.setVisible(False)
 -        if hasattr(self, 'remote_model') and self.remote_model and self.sftp:
 -            # Only refresh the current directory shown in the path
 -            current_path = self.remote_path.text() or "/"
 -            parent_item = self.remote_model._find_item_by_path(current_path)
 -            if parent_item:
 -                self.remote_model._refresh_single_directory(parent_item)
 -        self.status_bar.showMessage("Transfer complete", 3000)
+-
 -    @pyqtSlot(str)
 -    def _transfer_error(self, error):
 -        """Handle transfer error"""
 -        self.progress_bar.setVisible(False)
 -        QMessageBox.critical(
 -            self,
 -            "Transfer Error",
 -            error,
 -            QMessageBox.StandardButton.Ok,
 -            QMessageBox.StandardButton.Ok
 -        )
+-
 -    def _handle_files_dropped(self, local_paths: List[str], target_directory: str):
 -        """Handle files and directories dropped onto remote view"""
 -        if not self.sftp:
 -            return
+-
 -        # Update remote path to show where files are being uploaded
 -        self.remote_path.setText(target_directory)
+-
 -        # Separate files and directories
 -        files = []
 -        directories = []
+-
 -        for local_path in local_paths:
 -            if os.path.isdir(local_path):
 -                directories.append(local_path)
 -            else:
 -                files.append(local_path)
+-
 -        # Handle directories
 -        if directories:
 -            reply = QMessageBox.question(
 -                self,
 -                "Upload Directories",
 -                f"Upload {len(directories)} director{'y' if len(directories) == 1 else 'ies'}?\n\n" +
 -                "This will recursively upload all contents.",
 -                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 -                QMessageBox.StandardButton.Yes
 -            )
+-
 -            if reply == QMessageBox.StandardButton.Yes:
 -                for dir_path in directories:
 -                    dirname = os.path.basename(dir_path)
 -                    remote_path = os.path.join(target_directory, dirname).replace('\\', '/')
+-
 -                    worker = DirectoryTransferWorker(self.sftp, dir_path, remote_path, is_upload=True)
+-
 -                    # Connect signals
 -                    worker.signals.progress.connect(self._update_progress)
 -                    worker.signals.finished.connect(self._transfer_complete)
 -                    worker.signals.error.connect(self._transfer_error)
+-
 -                    # Show progress bar
 -                    self.progress_bar.setVisible(True)
 -                    self.progress_bar.setValue(0)
+-
 -                    # Start transfer
 -                    self.threadpool.start(worker)
+-
 -        # Handle files
 -        for local_path in files:
 -            filename = os.path.basename(local_path)
 -            remote_path = os.path.join(target_directory, filename).replace('\\', '/')
+-
 -            # Create transfer worker
 -            worker = TransferWorker(self.sftp, local_path, remote_path, True)
+-
 -            # Connect signals
 -            worker.signals.progress.connect(self._update_progress)
 -            worker.signals.finished.connect(self._transfer_complete)
 -            worker.signals.error.connect(self._transfer_error)
+-
 -            # Show progress bar
 -            self.progress_bar.setVisible(True)
 -            self.progress_bar.setValue(0)
+-
 -            # Start transfer
 -            self.threadpool.start(worker)
+-
 -        total_items = len(files) + len(directories)
 -        self.status_bar.showMessage(f"Uploading {total_items} item(s) to {target_directory}", 3000)
+-
 -    def _handle_remote_files_dropped(self, remote_items: List[tuple], local_directory: str):
 -        """Handle remote files and directories dropped onto local view"""
 -        if not self.sftp:
 -            return
+-
 -        # Separate files and directories
 -        files = []
 -        directories = []
+-
 -        for remote_path, is_dir in remote_items:
 -            if is_dir:
 -                dirname = os.path.basename(remote_path)
 -                directories.append((remote_path, dirname))
 -            else:
 -                files.append(remote_path)
+-
 -        # Handle directories
 -        if directories:
 -            reply = QMessageBox.question(
 -                self,
 -                "Download Directories",
 -                f"Download {len(directories)} director{'y' if len(directories) == 1 else 'ies'}?\n\n" +
 -                "This will recursively download all contents.",
 -                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 -                QMessageBox.StandardButton.Yes
 -            )
+-
 -            if reply == QMessageBox.StandardButton.Yes:
 -                for remote_path, dirname in directories:
 -                    local_path = os.path.join(local_directory, dirname)
+-
 -                    worker = DirectoryTransferWorker(self.sftp, remote_path, local_path, is_upload=False)
+-
 -                    # Connect signals
 -                    worker.signals.progress.connect(self._update_progress)
 -                    worker.signals.finished.connect(self._transfer_complete_download)
 -                    worker.signals.error.connect(self._transfer_error)
+-
 -                    # Show progress bar
 -                    self.progress_bar.setVisible(True)
 -                    self.progress_bar.setValue(0)
+-
 -                    # Start transfer
 -                    self.threadpool.start(worker)
+-
 -        # Handle files
 -        for remote_path in files:
 -            filename = os.path.basename(remote_path)
 -            local_path = os.path.join(local_directory, filename)
+-
 -            # Create transfer worker for download
 -            worker = TransferWorker(self.sftp, remote_path, local_path, False)
+-
 -            # Connect signals
 -            worker.signals.progress.connect(self._update_progress)
 -            worker.signals.finished.connect(self._transfer_complete_download)
 -            worker.signals.error.connect(self._transfer_error)
+-
 -            # Show progress bar
 -            self.progress_bar.setVisible(True)
 -            self.progress_bar.setValue(0)
+-
 -            # Start transfer
 -            self.threadpool.start(worker)
+-
 -        total_items = len(files) + len(directories)
 -        self.status_bar.showMessage(f"Downloading {total_items} item(s) to {local_directory}", 3000)
+-
 -    @pyqtSlot()
 -    def _transfer_complete_download(self):
 -        """Handle download completion - no need to refresh remote"""
 -        self.progress_bar.setVisible(False)
 -        self.status_bar.showMessage("Download complete", 3000)
+-
 -    def _create_directory(self, is_local: bool):
 -        """Create a new directory"""
 -        if is_local:
 -            current_path = self.local_model.filePath(self.local_view.rootIndex())
 -        else:
 -            current_path = self.remote_path.text() or "/"
+-
 -        # Get directory name from user without stealing focus
 -        name, ok = QInputDialog.getText(
 -            self,
 -            "Create Directory",
 -            "Directory name:",
 -            flags=Qt.WindowType.WindowStaysOnTopHint
 -        )
+-
 -        if ok and name:
 -            try:
 -                if is_local:
 -                    new_path = os.path.join(current_path, name)
 -                    os.makedirs(new_path, exist_ok=True)
 -                    self.status_bar.showMessage(f"Created directory: {name}", 3000)
 -                else:
 -                    if self.sftp:
 -                        new_path = os.path.join(current_path, name)
 -                        self.sftp.mkdir(new_path)
 -                        # Only refresh the parent directory
 -                        parent_item = self.remote_model._find_item_by_path(current_path)
 -                        if parent_item:
 -                            self.remote_model._refresh_single_directory(parent_item)
 -                        self.status_bar.showMessage(f"Created remote directory: {name}", 3000)
 -            except Exception as e:
 -                QMessageBox.warning(
 -                    self,
 -                    "Error",
 -                    f"Failed to create directory: {str(e)}",
 -                    QMessageBox.StandardButton.Ok,
 -                    QMessageBox.StandardButton.Ok
 -                )
+-
 -    def _delete_selected(self, is_local: bool):
 -        """Delete selected files/directories"""
 -        view = self.local_view if is_local else self.remote_view
 -        selection = view.selectedIndexes()
+-
 -        if not selection:
 -            return
+-
 -        # Get unique items
 -        items = []
 -        for index in selection:
 -            if index.column() == 0:  # Only process name column
 -                if is_local:
 -                    path = self.local_model.filePath(index)
 -                    is_dir = self.local_model.isDir(index)
 -                    name = self.local_model.fileName(index)
 -                else:
 -                    file_info = self.remote_model.fileInfo(index)
 -                    if file_info:
 -                        path = file_info.full_path
 -                        is_dir = file_info.is_dir
 -                        name = file_info.name
 -                    else:
 -                        continue
 -                items.append((path, is_dir, name))
+-
 -        if not items:
 -            return
+-
 -        # Confirm deletion without stealing focus
 -        msg = f"Delete {len(items)} item(s)?\n\n"
 -        for path, is_dir, name in items[:5]:  # Show first 5 items
 -            msg += f"{'[DIR] ' if is_dir else ''}{name}\n"
 -        if len(items) > 5:
 -            msg += f"... and {len(items) - 5} more"
+-
 -        reply = QMessageBox.question(
 -            self,
 -            "Confirm Delete",
 -            msg,
 -            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 -            QMessageBox.StandardButton.No
 -        )
+-
 -        if reply == QMessageBox.StandardButton.Yes:
 -            errors = []
 -            for path, is_dir, name in items:
 -                try:
 -                    if is_local:
 -                        if is_dir:
 -                            shutil.rmtree(path)
 -                        else:
 -                            os.remove(path)
 -                    else:
 -                        if self.sftp:
 -                            if is_dir:
 -                                self._delete_remote_dir(path)
 -                            else:
 -                                self.sftp.remove(path)
 -                except Exception as e:
 -                    errors.append(f"{name}: {str(e)}")
+-
 -            if errors:
 -                QMessageBox.warning(
 -                    self,
 -                    "Delete Errors",
 -                    "Some items could not be deleted:\n\n" + "\n".join(errors[:10]),
 -                    QMessageBox.StandardButton.Ok,
 -                    QMessageBox.StandardButton.Ok
 -                )
 -            else:
 -                self.status_bar.showMessage(f"Deleted {len(items)} item(s)", 3000)
+-
 -            # Refresh views
 -            if is_local:
 -                # Local view auto-refreshes
 -                pass
 -            else:
 -                # For remote, only refresh the parent directories of deleted items
 -                if self.sftp:
 -                    # Get unique parent directories
 -                    parent_dirs = set()
 -                    for path, is_dir, name in items:
 -                        parent_dir = os.path.dirname(path)
 -                        parent_dirs.add(parent_dir)
+-
 -                    # Refresh each parent directory
 -                    for parent_dir in parent_dirs:
 -                        parent_item = self.remote_model._find_item_by_path(parent_dir)
 -                        if parent_item:
 -                            self.remote_model._refresh_single_directory(parent_item)
+-
 -    def _delete_remote_dir(self, path: str):
 -        """Recursively delete remote directory"""
 -        if not self.sftp:
 -            return
+-
 -        # List directory contents
 -        for item in self.sftp.listdir_attr(path):
 -            item_path = os.path.join(path, item.filename)
 -            if stat.S_ISDIR(item.st_mode):
 -                self._delete_remote_dir(item_path)
 -            else:
 -                self.sftp.remove(item_path)
+-
 -        # Remove empty directory
 -        self.sftp.rmdir(path)
+-
 -    def delete_selected(self):
 -        """Delete selected items from whichever view has focus"""
 -        # Determine which view has focus or has a selection
 -        local_selection = self.local_view.selectedIndexes()
 -        remote_selection = self.remote_view.selectedIndexes() if self.sftp else []
+-
 -        if local_selection and (not remote_selection or self.local_view.hasFocus()):
 -            self._delete_selected(True)
 -        elif remote_selection:
 -            self._delete_selected(False)
 -        else:
 -            QMessageBox.information(
 -                self,
 -                "Delete",
 -                "Please select items to delete",
 -                QMessageBox.StandardButton.Ok,
 -                QMessageBox.StandardButton.Ok
 -            )
+-
+-
 -def main():
 -    """Application entry point"""
 -    app = QApplication(sys.argv)
 -    app.setApplicationName("wulFTP")
+-
 -    # Set application style
 -    app.setStyle("Fusion")
+-
 -    window = WulFTPClient()
 -    window.show()
+-
 -    sys.exit(app.exec())
+-
+-
 -if __name__ == "__main__":
 -    main()