`0123c7c`

change up the ui, enable nav on remote

Authored by

espadonne 10 months ago

SHA: 0123c7ceada625dca0340cc1852f94c92499547e
Parents: 8901475
Tree: 751a4b4

3 changed files

Status	File	+	-
A	`src/wulftp/remote_model.py`	423	0
M	`src/wulftp/sftp_backend.py`	14	4
M	`src/wulftp/wulftp.py`	661	219

src/wulftp/remote_model.pyadded

 +import os
 +import stat
 +from datetime import datetime
 +from enum import IntEnum
 +from typing import Any, Dict, List, Optional, Union
++
 +import qtawesome as qta
 +from paramiko import SFTPAttributes, SFTPClient
 +from PyQt6.QtCore import (
 +    QAbstractItemModel,
 +    QDateTime,
 +    QModelIndex,
 +    QObject,
 +    Qt,
 +    QVariant,
 +    pyqtSignal,
 +)
 +from PyQt6.QtGui import QIcon
++
++
 +class RemoteFileInfo:
 +    """Represents a remote file or directory"""
++
 +    def __init__(self, attr: SFTPAttributes, name: str, parent_path: str = ""):
 +        self.attr = attr
 +        self.name = name
 +        self.parent_path = parent_path
 +        self.full_path = os.path.join(parent_path, name) if parent_path else name
 +        self.children: Optional[List[RemoteFileInfo]] = None
 +        self.parent: Optional[RemoteFileInfo] = None
 +        self._icon: Optional[QIcon] = None
++
 +    @property
 +    def is_dir(self) -> bool:
 +        """Check if this is a directory"""
 +        return stat.S_ISDIR(self.attr.st_mode)
++
 +    @property
 +    def is_link(self) -> bool:
 +        """Check if this is a symbolic link"""
 +        return stat.S_ISLNK(self.attr.st_mode)
++
 +    @property
 +    def is_hidden(self) -> bool:
 +        """Check if this is a hidden file (starts with .)"""
 +        return self.name.startswith(".")
++
 +    @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"
++
 +    @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 ""
++
 +    @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)
++
 +    def icon(self) -> QIcon:
 +        """Get appropriate icon for file type"""
 +        if self._icon is None:
 +            if self.is_link:
 +                # Symbolic link - show with link indicator
 +                if self.is_dir:
 +                    self._icon = qta.icon("fa5s.folder-open", "fa5s.link",
 +                                         options=[{}, {"scale_factor": 0.6,
 +                                                      "offset": (0.4, 0.4)}])
 +                else:
 +                    self._icon = qta.icon("fa5s.file", "fa5s.link",
 +                                         options=[{}, {"scale_factor": 0.6,
 +                                                      "offset": (0.4, 0.4)}])
 +            elif self.is_dir:
 +                self._icon = qta.icon("fa5s.folder", color="#FFD93D")
 +            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")
 +                else:
 +                    self._icon = qta.icon("fa5s.file", color="#6C757D")
++
 +        return self._icon
++
++
 +class RemoteColumn(IntEnum):
 +    """Column indices for the model"""
 +    NAME = 0
 +    SIZE = 1
 +    TYPE = 2
 +    MODIFIED = 3
 +    PERMISSIONS = 4
++
++
 +class RemoteFileSystemModel(QAbstractItemModel):
 +    """Model for displaying remote SFTP file system"""
++
 +    # Signals
 +    directoryLoaded = pyqtSignal(str)  # Emitted when a directory is loaded
 +    errorOccurred = pyqtSignal(str)    # Emitted on errors
++
 +    def __init__(self, sftp: Optional[SFTPClient] = None, parent: Optional[QObject] = None):
 +        super().__init__(parent)
 +        self.sftp = sftp
 +        self.root_path = "/"
++
 +        # Create a proper root item with valid attributes
 +        root_attr = SFTPAttributes()
 +        root_attr.st_mode = stat.S_IFDIR | 0o755  # Directory with rwxr-xr-x
 +        root_attr.st_size = 0
 +        root_attr.st_mtime = 0
 +        root_attr.filename = "/"
++
 +        self.root_item = RemoteFileInfo(root_attr, "/", "")
 +        self.root_item.children = []
++
 +        # Settings
 +        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)
 +        self._path_cache: Dict[str, List[RemoteFileInfo]] = {}
++
 +    def set_sftp(self, sftp: SFTPClient):
 +        """Set or update the SFTP connection"""
 +        self.beginResetModel()
 +        self.sftp = sftp
 +        self._path_cache.clear()
 +        self.root_item.children = None
 +        self.endResetModel()
++
 +        if sftp:
 +            self.load_directory("/")
++
 +    def set_show_hidden(self, show: bool):
 +        """Toggle showing hidden files"""
 +        if self.show_hidden != show:
 +            self.show_hidden = show
 +            self.refresh()
++
 +    def set_show_full_details(self, show: bool):
 +        """Toggle showing full file details (permissions)"""
 +        if self.show_full_details != show:
 +            self.show_full_details = show
 +            # Just emit dataChanged for the permissions column
 +            if self.root_item.children:
 +                self.dataChanged.emit(
 +                    self.index(0, RemoteColumn.PERMISSIONS),
 +                    self.index(self.rowCount() - 1, RemoteColumn.PERMISSIONS)
 +                )
++
 +    def load_directory(self, path: str) -> bool:
 +        """Load directory contents from SFTP"""
 +        if not self.sftp:
 +            return False
++
 +        try:
 +            # Normalize path
 +            path = os.path.normpath(path)
++
 +            # Fetch directory listing
 +            attrs = self.sftp.listdir_attr(path)
++
 +            # Convert to RemoteFileInfo objects
 +            items = []
 +            for attr in attrs:
 +                name = attr.filename
 +                if not self.show_hidden and name.startswith("."):
 +                    continue
++
 +                file_info = RemoteFileInfo(attr, name, path)
 +                items.append(file_info)
++
 +            # Sort: directories first, then by name
 +            items.sort(key=lambda x: (not x.is_dir, x.name.lower()))
++
 +            # Update cache
 +            self._path_cache[path] = items
++
 +            # Find the parent item for this path
 +            parent_item = self._find_item_by_path(path)
 +            if parent_item:
 +                # Update the parent's children
 +                parent_index = self._get_index_for_item(parent_item)
 +                if parent_index.isValid():
 +                    self.beginInsertRows(parent_index, 0, len(items) - 1)
 +                else:
 +                    self.beginInsertRows(QModelIndex(), 0, len(items) - 1)
++
 +                parent_item.children = items
 +                for item in items:
 +                    item.parent = parent_item
++
 +                self.endInsertRows()
++
 +            self.directoryLoaded.emit(path)
 +            return True
++
 +        except Exception as e:
 +            self.errorOccurred.emit(str(e))
 +            return False
++
 +    def _find_item_by_path(self, path: str) -> Optional[RemoteFileInfo]:
 +        """Find item by path traversing the tree"""
 +        if path == "/" or path == "":
 +            return self.root_item
++
 +        # Split path and traverse
 +        parts = path.strip("/").split("/")
 +        current = self.root_item
++
 +        for part in parts:
 +            if current.children is None:
 +                return None
++
 +            found = False
 +            for child in current.children:
 +                if child.name == part:
 +                    current = child
 +                    found = True
 +                    break
++
 +            if not found:
 +                return None
++
 +        return current
++
 +    def _get_index_for_item(self, item: RemoteFileInfo) -> QModelIndex:
 +        """Get QModelIndex for a RemoteFileInfo item"""
 +        if item == self.root_item:
 +            return QModelIndex()
++
 +        if item.parent and item.parent.children:
 +            row = item.parent.children.index(item)
 +            return self.createIndex(row, 0, item)
++
 +        return QModelIndex()
++
 +    def _get_item(self, index: QModelIndex) -> Optional[RemoteFileInfo]:
 +        """Get RemoteFileInfo from model index"""
 +        if index.isValid():
 +            return index.internalPointer()
 +        return self.root_item
++
 +    # QAbstractItemModel implementation
 +    def columnCount(self, parent: QModelIndex = QModelIndex()) -> int:
 +        """Number of columns"""
 +        return 5 if self.show_full_details else 4
++
 +    def rowCount(self, parent: QModelIndex = QModelIndex()) -> int:
 +        """Number of rows (files) in a directory"""
 +        parent_item = self._get_item(parent)
 +        if parent_item and parent_item.children is not None:
 +            return len(parent_item.children)
 +        return 0
++
 +    def index(self, row: int, column: int, parent: QModelIndex = QModelIndex()) -> QModelIndex:
 +        """Create model index for item"""
 +        if not self.hasIndex(row, column, parent):
 +            return QModelIndex()
++
 +        parent_item = self._get_item(parent)
 +        if parent_item and parent_item.children and row < len(parent_item.children):
 +            child_item = parent_item.children[row]
 +            return self.createIndex(row, column, child_item)
++
 +        return QModelIndex()
++
 +    def parent(self, index: QModelIndex) -> QModelIndex:
 +        """Get parent index"""
 +        if not index.isValid():
 +            return QModelIndex()
++
 +        child_item = index.internalPointer()
 +        parent_item = child_item.parent
++
 +        if parent_item == self.root_item:
 +            return QModelIndex()
++
 +        # Find row of parent
 +        if parent_item.parent and parent_item.parent.children:
 +            row = parent_item.parent.children.index(parent_item)
 +            return self.createIndex(row, 0, parent_item)
++
 +        return QModelIndex()
++
 +    def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole) -> Any:
 +        """Get data for display"""
 +        if not index.isValid():
 +            return None
++
 +        item = index.internalPointer()
 +        col = index.column()
++
 +        if role == Qt.ItemDataRole.DisplayRole:
 +            if col == RemoteColumn.NAME:
 +                return item.name
 +            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"
 +            elif col == RemoteColumn.MODIFIED:
 +                return item.modified_str
 +            elif col == RemoteColumn.PERMISSIONS and self.show_full_details:
 +                return item.permissions_str
++
 +        elif role == Qt.ItemDataRole.DecorationRole and col == RemoteColumn.NAME:
 +            return item.icon()
++
 +        elif role == Qt.ItemDataRole.TextAlignmentRole:
 +            if col == RemoteColumn.SIZE:
 +                return Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter
++
 +        return None
++
 +    def headerData(self, section: int, orientation: Qt.Orientation,
 +                   role: int = Qt.ItemDataRole.DisplayRole) -> Any:
 +        """Get header data"""
 +        if orientation == Qt.Orientation.Horizontal and role == Qt.ItemDataRole.DisplayRole:
 +            headers = ["Name", "Size", "Type", "Modified"]
 +            if self.show_full_details:
 +                headers.append("Permissions")
++
 +            if section < len(headers):
 +                return headers[section]
++
 +        return None
++
 +    def hasChildren(self, parent: QModelIndex = QModelIndex()) -> bool:
 +        """Check if item has children (is a directory)"""
 +        item = self._get_item(parent)
 +        return item.is_dir if item else False
++
 +    def canFetchMore(self, parent: QModelIndex) -> bool:
 +        """Check if we need to fetch children for this item"""
 +        item = self._get_item(parent)
 +        return item and item.is_dir and item.children is None
++
 +    def fetchMore(self, parent: QModelIndex):
 +        """Fetch children for a directory (lazy loading)"""
 +        item = self._get_item(parent)
 +        if item and item.is_dir and item.children is None:
 +            self.load_directory(item.full_path)
++
 +    def filePath(self, index: QModelIndex) -> str:
 +        """Get full path for an item"""
 +        item = self._get_item(index)
 +        return item.full_path if item else ""
++
 +    def fileName(self, index: QModelIndex) -> str:
 +        """Get filename for an item"""
 +        item = self._get_item(index)
 +        return item.name if item else ""
++
 +    def isDir(self, index: QModelIndex) -> bool:
 +        """Check if index points to a directory"""
 +        item = self._get_item(index)
 +        return item.is_dir if item else False
++
 +    def fileInfo(self, index: QModelIndex) -> Optional[RemoteFileInfo]:
 +        """Get RemoteFileInfo for an index"""
 +        return self._get_item(index)

src/wulftp/sftp_backend.pymodified

  import paramiko
++
  class SFTPBackend:
      """
      simple wrapper for SFTP operations using Paramiko.
          self.ssh = None
          self.sftp = None
 -    def connect(self, host: str, port: int, username: str, key_path: str, passphrase: str | None = 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.
              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.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]:
 +    def listdir(self, path: str = ".") -> list[str]:
          """
          return the list of entries in the remote directory.
          """
          if self.sftp:
              self.sftp.close()
          if self.ssh:
 -            self.ssh.close()
 +            self.ssh.close()

src/wulftp/wulftp.pymodified

  import os
 +import stat
  import sys
 +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 PyQt6.QtCore import Qt, QSize
 -from PyQt6.QtCore import pyqtSignal, QRunnable, QThreadPool
 +from paramiko import SSHConfig
 +from PyQt6.QtCore import (
 +    QDir,
 +    QModelIndex,
 +    QObject,
 +    QRunnable,
 +    QSize,
 +    Qt,
 +    QThreadPool,
 +    pyqtSignal,
 +    pyqtSlot,
 +)
 +from PyQt6.QtGui import QAction, QFileSystemModel, QIcon
  from PyQt6.QtWidgets import (
 -    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QLabel,
 -    QLineEdit, QToolButton, QPushButton, QListWidget, QFileDialog, QMessageBox, QFormLayout,
 +    QAbstractItemView,
 +    QApplication,
 +    QCheckBox,
 +    QComboBox,
 +    QHBoxLayout,
 +    QHeaderView,
 +    QLabel,
 +    QLineEdit,
 +    QMainWindow,
 +    QMenu,
 +    QMessageBox,
 +    QProgressBar,
 +    QPushButton,
 +    QSplitter,
 +    QStatusBar,
 +    QToolBar,
 +    QTreeView,
 +    QVBoxLayout,
 +    QWidget,
+ )
 -from .sftp_backend import SFTPBackend
++
 +# 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 UploadRunnable(QRunnable):
 -    """
 -    QRunnable for performing SFTP upload in a thread pool.
 -    Emits finish or error signals on completion.
 -    """
 -    def __init__(self, backend, local_path, remote_path, finish_signal, error_signal):
 +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.backend = backend
 -        self.local_path = local_path
 -        self.remote_path = remote_path
 -        self.finish_signal = finish_signal
 -        self.error_signal = error_signal
 +        self.sftp = sftp
 +        self.source = source
 +        self.dest = dest
 +        self.is_upload = is_upload
 +        self.signals = WorkerSignals()
      def run(self):
          try:
 -            self.backend.upload(self.local_path, self.remote_path)
 -            self.finish_signal.emit()
 +            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.error_signal.emit(str(e))
 +            self.signals.error.emit(str(e))
+-
 -# fetch default host/port from .env
 -load_dotenv()
 -DEFAULT_HOST = os.getenv('WULFTP_HOST', '')
 -DEFAULT_PORT = int(os.getenv('WULFTP_PORT', '22'))
 +    def _progress_callback(self, transferred, total):
 +        if total > 0:
 +            progress = int((transferred / total) * 100)
 +            self.signals.progress.emit(progress)
  class WulFTPClient(QMainWindow):
 -    # signals for thread-safe UI updates
 -    remote_refreshed = pyqtSignal()
 -    upload_error = pyqtSignal(str)
+-
      def __init__(self):
          super().__init__()
 -        self.backend = SFTPBackend()
 +        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()
 -        # setup thread pool and connect signals
 -        self.threadpool = QThreadPool()
 -        self.remote_refreshed.connect(self.refresh_remote)
 -        self.upload_error.connect(self.show_error)
 +    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):
 -        """build and arrange ui elements."""
 -        self.setWindowTitle('wulFTP POC')
 -        self.setWindowFlags(Qt.WindowType.Dialog | Qt.WindowType.WindowStaysOnTopHint)
 -        self.setAcceptDrops(False)
 +        self.setWindowTitle("wulFTP - Family Backup Tool")
 +        self.setGeometry(100, 100, 1200, 800)
++
 +        # Central widget
          central = QWidget()
          self.setCentralWidget(central)
 -        main_layout = QVBoxLayout()
 -        main_layout.setContentsMargins(8, 8, 8, 8)
 -        main_layout.setSpacing(8)
+-
 -        # form for connection fields
 -        form_layout = QFormLayout()
 -        form_layout.setHorizontalSpacing(8)
 -        form_layout.setVerticalSpacing(4)
+-
 -        # connection fields with defaults from env
 -        self.host_input = QLineEdit(DEFAULT_HOST)
 -        self.port_input = QLineEdit(str(DEFAULT_PORT))
 -        self.user_input = QLineEdit(os.getenv('WULFTP_USER', 'username'))
 -        self.key_input = QLineEdit(os.getenv('WULFTP_KEY', os.path.expanduser('~/.ssh/id_rsa')))
+-
 -        # all just for this ico button
 -        key_browse_btn = QToolButton()
 -        icon = qta.icon('fa6s.folder-open', color='#ADC8FF')
 -        key_browse_btn.setIcon(icon)
 -        key_browse_btn.setIconSize(QSize(16, 16))
 -        key_browse_btn.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
 -        key_browse_btn.setAutoRaise(False)
 -        key_browse_btn.setFixedSize(24, 24)
 -        key_browse_btn.clicked.connect(self.browse_key)
+-
 -        # for opt passphrase
 -        self.passphrase_input = QLineEdit()
 -        self.passphrase_input.setEchoMode(QLineEdit.EchoMode.Password)
+-
 -        connect_btn = QPushButton('connect')
 -        connect_btn.clicked.connect(self.connect_sftp)
+-
 -        # form layout for connection fields; needs work
 -        form_layout.addRow('Host:', self.host_input)
 -        form_layout.addRow('Port:', self.port_input)
 -        form_layout.addRow('User:', self.user_input)
+-
 -        # right group as a FormLayout
 -        right_form = QFormLayout()
 -        right_form.setHorizontalSpacing(8)
 -        right_form.setVerticalSpacing(4)
 -        right_form.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
+-
 -        # key input with browse ico btn
 -        key_row = QWidget()
 -        key_layout = QHBoxLayout(key_row)
 -        key_layout.setContentsMargins(0, 0, 0, 0)
 -        key_layout.setSpacing(4)
 -        key_layout.addWidget(self.key_input)
 -        key_layout.addWidget(key_browse_btn)
 -        right_form.addRow('Key:', key_row)
+-
 -        # passphrase row
 -        pass_widget = QWidget()
 -        pass_layout = QHBoxLayout(pass_widget)
 -        pass_layout.setContentsMargins(0, 0, 0, 0)
 -        pass_layout.addWidget(self.passphrase_input)
 -        right_form.addRow('Passphrase:', pass_widget)
+-
 -        self.status_icon = QLabel()
 -        self.status_icon.setAlignment(Qt.AlignmentFlag.AlignCenter)
+-
 -        # row for `connect` button/status ico
 -        connect_widget = QWidget()
 -        conn_layout = QHBoxLayout(connect_widget)
 -        conn_layout.setAlignment(Qt.AlignmentFlag.AlignBaseline)
 -        conn_layout.addWidget(connect_btn)
 -        conn_layout.addWidget(self.status_icon)
 -        right_form.addRow('', connect_widget)
+-
 -        # combine connection groups/forms side-by-side
 -        groups_layout = QHBoxLayout()
 -        groups_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
 -        groups_layout.setSpacing(12)
 -        groups_layout.addLayout(form_layout, 1)
 -        groups_layout.addLayout(right_form, 1)
 -        main_layout.addLayout(groups_layout)
+-
 -        # for the remote preview etc
 -        remote_layout = QVBoxLayout()
+-
 -        self.browse_file_btn = QPushButton('browse…')
 -        self.browse_file_btn.clicked.connect(self.browse_and_upload)
 -        self.browse_file_btn.setEnabled(False)
 -        remote_layout.addWidget(self.browse_file_btn)
+-
 -        # this needs rethinking?
 -        self.remote_list = QListWidget()
 -        self.remote_list.setEnabled(False)
 -        remote_layout.addWidget(self.remote_list)
 -        main_layout.addLayout(remote_layout)
+-
 -        central.setLayout(main_layout)
+-
 -        self.update_status_icon(False)
+-
 -    def update_status_icon(self, connected: bool):
 -        """display the connected/disconnected icon based on state."""
 -        if connected:
 -            icon = qta.icon('fa6s.link', color='#62FF8B')
 +        # Main layout
 +        layout = QVBoxLayout(central)
 +        layout.setContentsMargins(0, 0, 0, 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
 +        self._create_toolbar()
++
 +        # Connection bar
 +        conn_widget = self._create_connection_bar()
 +        layout.addWidget(conn_widget)
++
 +        # Create splitter for two-pane view
 +        splitter = QSplitter(Qt.Orientation.Horizontal)
++
 +        # 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])
 +        layout.addWidget(splitter)
++
 +    def _create_toolbar(self):
 +        """Create main toolbar"""
 +        toolbar = QToolBar()
 +        self.addToolBar(toolbar)
++
 +        # 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()
++
 +        # Refresh action
 +        refresh_action = QAction(
 +            qta.icon("fa5s.sync", color="#FF9800"), "Refresh", self
 +        )
 +        refresh_action.triggered.connect(self.refresh_views)
 +        toolbar.addAction(refresh_action)
++
 +        toolbar.addSeparator()
++
 +        # 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)
++
 +        # 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;")
 +        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)
 +        header_layout.addWidget(up_btn)
++
 +        home_btn = QPushButton()
 +        home_btn.setIcon(qta.icon("fa5s.home"))
 +        home_btn.setMaximumSize(30, 30)
 +        header_layout.addWidget(home_btn)
++
 +        layout.addWidget(header)
++
 +        # Path display
 +        path_edit = QLineEdit()
 +        path_edit.setReadOnly(True)
 +        layout.addWidget(path_edit)
++
 +        # File view
 +        if is_local:
 +            # Local file system model
 +            model = QFileSystemModel()
 +            model.setRootPath(QDir.homePath())
++
 +            view = QTreeView()
 +            view.setModel(model)
 +            view.setRootIndex(model.index(QDir.homePath()))
 +            view.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
++
 +            # 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))
++
          else:
 -            icon = qta.icon('fa6s.link-slash', color='#FF595B')
+-
 -        self.status_icon.setPixmap(icon.pixmap(24, 24))
+-
 -    def dragEnterEvent(self, event):
 -        """allow drag-and-drop upload if the event carries file URLs."""
 -        if event.mimeData().hasUrls():
 -            event.acceptProposedAction()
+-
 -    def dropEvent(self, event):
 -        """handle dropped files by uploading each to the remote server."""
 -        for url in event.mimeData().urls():
 -            local_path = url.toLocalFile()
 -            filename = os.path.basename(local_path)
 -            remote_file = os.path.join(self.remote_path, filename)
 -            # schedule upload in thread pool
 -            runnable = UploadRunnable(
 -                self.backend,
 -                local_path,
 -                remote_file,
 -                self.remote_refreshed,
 -                self.upload_error
 -            )
 -            self.threadpool.start(runnable)
 -        event.acceptProposedAction()
 +            # Remote file list with the new model
 +            view = QTreeView()
 +            view.setModel(self.remote_model)
 +            view.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
++
 +            # 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))
++
 +            # 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))
++
 +        # Context menu
 +        view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
 +        view.customContextMenuRequested.connect(
 +            lambda pos: self._show_context_menu(pos, is_local)
 +        )
 -    def browse_key(self):
 -        """open a file dialog to select the SSH private key path."""
 -        path, _ = QFileDialog.getOpenFileName(self, 'Select Private Key')
 -        if not path:
 -            return
 -        self.key_input.setText(path)
 +        layout.addWidget(view)
 +        return widget
 -    def show_error(self, msg):
 -        """show an error dialog with the given message."""
 -        QMessageBox.critical(self, 'Error', msg)
 +    def _on_host_changed(self, index):
 +        """Handle host selection change"""
 +        host = self.host_combo.currentData()
 +        is_custom = host is None
 -    def connect_sftp(self):
 -        """connect to the SFTP server using current form values and update UI."""
 -        host = self.host_input.text()
 -        port = int(self.port_input.text())
 -        user = self.user_input.text()
 -        key_path = self.key_input.text()
 -        passphrase = self.passphrase_input.text() or 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")
 +        else:
 +            icon = qta.icon("fa5s.unlink", color="#F44336")
 +            self.conn_status.setText("Disconnected")
 +            self.connect_btn.setText("Connect")
++
 +        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)
 +        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"""
          try:
 -            self.backend.connect(host, port, user, key_path, passphrase)
 -            self.sftp = self.backend.sftp
+-
 -            self.update_status_icon(True)
 -            self.browse_file_btn.setEnabled(True)
 -            self.remote_list.setEnabled(True)
 -            self.setAcceptDrops(True)
 -            self.refresh_remote()
 +            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)
++
          except Exception as e:
 -            self.show_error(str(e))
 +            QMessageBox.critical(self, "Connection Error", str(e))
 +            self._update_connection_status(False)
++
 +    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()
++
 +    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 _show_context_menu(self, pos, is_local: bool):
 +        """Show context menu for file operations"""
 +        menu = QMenu()
++
 +        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)
 +            else:
 +                download_action = menu.addAction(
 +                    qta.icon("fa5s.download", color="#2196F3"), "Download"
 +                )
 +                download_action.triggered.connect(self.download_selected)
++
 +        menu.addSeparator()
++
 +        refresh_action = menu.addAction(qta.icon("fa5s.sync"), "Refresh")
 +        refresh_action.triggered.connect(self.refresh_views)
++
 +        # Show menu at cursor position
 +        view = self.local_view if is_local else self.remote_view
 +        menu.exec(view.mapToGlobal(pos))
++
 +    def upload_selected(self):
 +        """Upload selected local files"""
 +        if not self.sftp:
 +            return
 -    def refresh_remote(self):
 -        """refresh the remote file list for the current remote directory."""
 -        if self.sftp is None:
 +        selection = self.local_view.selectedIndexes()
 +        if not selection:
              return
 -        try:
 -            self.remote_path = '.'
 -            self.remote_list.clear()
 -            for f in self.backend.listdir(self.remote_path):
 -                self.remote_list.addItem(f)
 -        except Exception as e:
 -            self.show_error(str(e))
 +        # Get unique file paths (avoiding duplicates from multiple columns)
 +        files = set()
 +        for index in selection:
 +            if index.column() == 0:  # Only process name column
 +                path = self.local_model.filePath(index)
 +                files.add(path)
++
 +        self._transfer_files(list(files), is_upload=True)
 -    def browse_and_upload(self):
 -        """open file dialog and upload the selected file to remote."""
 -        path, _ = QFileDialog.getOpenFileName(self, 'select file to upload')
 -        if not path:
 +    def download_selected(self):
 +        """Download selected remote files"""
 +        if not self.sftp:
              return
 -        filename = os.path.basename(path)
 -        remote_file = os.path.join(self.remote_path, filename)
+-
 -        # schedule file upload in thread pool
 -        runnable = UploadRunnable(
 -            self.backend,
 -            path,
 -            remote_file,
 -            self.remote_refreshed,
 -            self.upload_error
 -        )
 -        self.threadpool.start(runnable)
++
 +        selection = self.remote_view.selectedIndexes()
 +        if not selection:
 +            return
++
 +        # Get unique file paths (avoiding duplicates from multiple columns)
 +        files = []
 +        for index in selection:
 +            if index.column() == 0:  # Only process name column
 +                file_info = self.remote_model.fileInfo(index)
 +                if file_info and not file_info.is_dir:
 +                    files.append(file_info.full_path)
++
 +        if files:
 +            self._transfer_files(files, is_upload=False)
 +        else:
 +            QMessageBox.information(self, "Download", "Please select files to download (directories not supported yet)")
++
 +    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:
 +            self.remote_model.refresh()
 +        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)
  def main():
 -    """driver for wulftp."""
 +    """Application entry point"""
      app = QApplication(sys.argv)
 -    w = WulFTPClient()
 -    w.show()
 +    app.setApplicationName("wulFTP")
++
 +    # Set application style
 +    app.setStyle("Fusion")
++
 +    window = WulFTPClient()
 +    window.show()
++
      sys.exit(app.exec())
 -if __name__ == '__main__':
 -    main()
 +if __name__ == "__main__":
 +    main()