`ff0e65e`

trash, create dirs, remote view state

Authored by

espadonne 10 months ago

SHA: ff0e65ecb68f04f26653db5fea2053e243d669f8
Parents: cc8ff9f
Tree: 438c06c

2 changed files

Status	File	+	-
M	`src/wulftp/remote_model.py`	296	10
M	`src/wulftp/wulftp.py`	488	18

src/wulftp/remote_model.pymodified

      Qt,
      QVariant,
      pyqtSignal,
 +    QMimeData,
 +    QUrl,
+ )
  from PyQt6.QtGui import QIcon
      # Signals
      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)
      def __init__(self, sftp: Optional[SFTPClient] = None, parent: Optional[QObject] = None):
          super().__init__(parent)
          # Cache for performance (even though we're fetching fresh,
          # we cache during a single view session)
          self._path_cache: Dict[str, List[RemoteFileInfo]] = {}
++
 +        # Track which directories are expanded
 +        self._expanded_paths: set[str] = set()
      def set_sftp(self, sftp: SFTPClient):
          """Set or update the SFTP connection"""
          """Toggle showing hidden files"""
          if self.show_hidden != show:
              self.show_hidden = show
 -            self.refresh()
 +            self.refresh(preserve_state=True)
      def set_show_full_details(self, show: bool):
          """Toggle showing full file details (permissions)"""
              # Find the parent item for this path
              parent_item = self._find_item_by_path(path)
              if parent_item:
 -                # Update the parent's children
 +                # Get the parent index before we modify 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)
++
 +                # Only call beginInsertRows if we have items to insert
 +                if items:
 +                    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()
++
 +                if items:
 +                    self.endInsertRows()
 +                else:
 +                    # If no items, just set empty list
 +                    parent_item.children = []
              self.directoryLoaded.emit(path)
              return True
              self.errorOccurred.emit(str(e))
              return False
 +    def refresh(self, preserve_state: bool = True):
 +        """Refresh current view"""
 +        if self.root_item.children is not None:
 +            if preserve_state:
 +                # Smart refresh - only reload directories that are already loaded
 +                self._smart_refresh(self.root_item)
 +            else:
 +                # Full refresh - clear everything and start over
 +                self._path_cache.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()
++
 +                # 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:
 +            return
++
 +        try:
 +            # Fetch fresh listing
 +            path = item.full_path if item != self.root_item else "/"
 +            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("."):
 +                    continue
++
 +                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()
++
 +            # 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()
 +            else:
 +                # No children, just set empty list
 +                item.children = []
++
 +            # Update cache
 +            self._path_cache[path] = new_items
++
 +        except Exception as e:
 +            # Silently handle errors during refresh
 +            pass
++
 +    def mark_expanded(self, path: str):
 +        """Mark a directory as expanded"""
 +        self._expanded_paths.add(path)
++
 +    def mark_collapsed(self, path: str):
 +        """Mark a directory as collapsed"""
 +        self._expanded_paths.discard(path)
++
 +    def is_expanded(self, path: str) -> bool:
 +        """Check if a directory is marked as expanded"""
 +        return path in self._expanded_paths
++
      def _find_item_by_path(self, path: str) -> Optional[RemoteFileInfo]:
          """Find item by path traversing the tree"""
          if path == "/" or path == "":
      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
 +        # 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:
 +                # Load from cache instead of fetching
 +                cached_items = self._path_cache[item.full_path]
 +                parent_index = self._get_index_for_item(item)
 +                if cached_items:
 +                    self.beginInsertRows(parent_index, 0, len(cached_items) - 1)
 +                item.children = cached_items
 +                for child in cached_items:
 +                    child.parent = item
 +                if cached_items:
 +                    self.endInsertRows()
 +                else:
 +                    item.children = []
 +                return False
 +            return True
 +        return False
      def fetchMore(self, parent: QModelIndex):
          """Fetch children for a directory (lazy loading)"""
      def fileInfo(self, index: QModelIndex) -> Optional[RemoteFileInfo]:
          """Get RemoteFileInfo for an index"""
 -        return self._get_item(index)
 +        return self._get_item(index)
++
 +    # Drag and Drop support
 +    def supportedDropActions(self) -> Qt.DropAction:
 +        """Support copy and move operations"""
 +        return Qt.DropAction.CopyAction | Qt.DropAction.MoveAction
++
 +    def supportedDragActions(self) -> Qt.DropAction:
 +        """Support copy and move operations"""
 +        return Qt.DropAction.CopyAction | Qt.DropAction.MoveAction
++
 +    def flags(self, index: QModelIndex) -> Qt.ItemFlag:
 +        """Set item flags for drag and drop"""
 +        if not index.isValid():
 +            return Qt.ItemFlag.NoItemFlags
++
 +        default_flags = Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable
++
 +        item = self._get_item(index)
 +        if item:
 +            # All items can be dragged
 +            default_flags |= Qt.ItemFlag.ItemIsDragEnabled
++
 +            # Directories can accept drops
 +            if item.is_dir:
 +                default_flags |= Qt.ItemFlag.ItemIsDropEnabled
++
 +        return default_flags
++
 +    def mimeTypes(self) -> List[str]:
 +        """Return supported MIME types"""
 +        return ["text/uri-list", "application/x-qt-windows-mime;value=\"FileNameW\"", "application/x-wulftp-remote"]
++
 +    def mimeData(self, indexes: List[QModelIndex]) -> QMimeData:
 +        """Create MIME data for drag operation"""
 +        mime_data = QMimeData()
++
 +        # Get unique items (avoid duplicates from multiple columns)
 +        items = []
 +        paths = []
 +        for index in indexes:
 +            if index.column() == 0:  # Only process name column
 +                item = self._get_item(index)
 +                if item and item != self.root_item:
 +                    items.append(item)
 +                    paths.append(item.full_path)
++
 +        if items:
 +            # Store remote paths as custom MIME type
 +            mime_data.setData("application/x-wulftp-remote", "\n".join(paths).encode('utf-8'))
++
 +            # Also set text for debugging
 +            mime_data.setText("\n".join([item.name for item in items]))
++
 +        return mime_data
++
 +    def canDropMimeData(self, data: QMimeData, action: Qt.DropAction,
 +                        row: int, column: int, parent: QModelIndex) -> bool:
 +        """Check if we can accept the drop"""
 +        if not self.sftp:
 +            return False
++
 +        # Check if we have file URLs (from local file system)
 +        if data.hasUrls():
 +            # Can only drop onto directories or root
 +            if parent.isValid():
 +                item = self._get_item(parent)
 +                return item and item.is_dir
 +            return True  # Can drop to root
++
 +        return False
++
 +    def dropMimeData(self, data: QMimeData, action: Qt.DropAction,
 +                     row: int, column: int, parent: QModelIndex) -> bool:
 +        """Handle the drop - emit signal for main window to handle transfer"""
 +        if not self.canDropMimeData(data, action, row, column, parent):
 +            return False
++
 +        # Get the target directory
 +        if parent.isValid():
 +            target_item = self._get_item(parent)
 +            target_path = target_item.full_path if target_item else "/"
 +        else:
 +            target_path = "/"
++
 +        # Extract local file paths from URLs
 +        local_paths = []
 +        if data.hasUrls():
 +            for url in data.urls():
 +                if url.isLocalFile():
 +                    local_paths.append(url.toLocalFile())
++
 +        if local_paths:
 +            # Emit signal with files to upload and target directory
 +            self.filesDropped.emit(local_paths, target_path)
 +            return True
++
 +        return False

src/wulftp/wulftp.pymodified

  import os
  import stat
  import sys
 +import shutil
  from dataclasses import dataclass
  from pathlib import Path
  from typing import Dict, List, Optional
      QThreadPool,
      pyqtSignal,
      pyqtSlot,
 +    QMimeData,
+ )
 -from PyQt6.QtGui import QAction, QFileSystemModel, QIcon
 +from PyQt6.QtGui import QAction, QFileSystemModel, QIcon, QDragEnterEvent, QDropEvent
  from PyQt6.QtWidgets import (
      QAbstractItemView,
      QApplication,
      QTreeView,
      QVBoxLayout,
      QWidget,
 +    QSizePolicy,
 +    QInputDialog,
+ )
  # Load environment variables
              self.signals.progress.emit(progress)
 +class LocalTreeView(QTreeView):
 +    """Custom tree view for local files that handles remote file drops"""
++
 +    remoteFilesDropped = pyqtSignal(list, str)  # remote_paths, 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
 +            event.ignore()
 +        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
 +            remote_data = mime_data.data("application/x-wulftp-remote").data().decode('utf-8')
 +            remote_paths = [p.strip() for p in remote_data.split('\n') if p.strip()]
++
 +            if remote_paths and target_dir:
 +                self.remoteFilesDropped.emit(remote_paths, target_dir)
 +                event.acceptProposedAction()
 +        else:
 +            # Let parent handle local file operations
 +            super().dropEvent(event)
++
++
  class WulFTPClient(QMainWindow):
      def __init__(self):
          super().__init__()
          central = QWidget()
          self.setCentralWidget(central)
 -        # Main layout
 +        # 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.conn_status = QLabel("Disconnected")
          self.status_bar.addPermanentWidget(self.conn_status)
 -        # Create toolbar
 +        # Create toolbar with connection controls
          self._create_toolbar()
 -        # Connection bar
 -        conn_widget = self._create_connection_bar()
 -        layout.addWidget(conn_widget)
+-
 -        # Create splitter for two-pane view
 +        # 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)
          # Set initial splitter sizes
          splitter.setSizes([600, 600])
++
 +        # Add splitter to main layout
          layout.addWidget(splitter)
      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
          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(False)
 +        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)
 -        toolbar.addSeparator()
 +        # 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)
          """Create a file browser pane"""
          widget = QWidget()
          layout = QVBoxLayout(widget)
 +        layout.setContentsMargins(5, 5, 5, 5)
 +        layout.setSpacing(5)
          # Header with navigation
          header = QWidget()
          # Title
          title_label = QLabel(title)
 -        title_label.setStyleSheet("font-weight: bold;")
 +        title_label.setStyleSheet("font-weight: bold; font-size: 14px;")
          header_layout.addWidget(title_label)
          header_layout.addStretch()
          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: #f0f0f0; }")
          layout.addWidget(path_edit)
          # File view
              model = QFileSystemModel()
              model.setRootPath(QDir.homePath())
 -            view = QTreeView()
 +            # 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.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
              # 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))
              # 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)
          # Context menu
          view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
              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))
              self.upload_action.setEnabled(connected)
          if hasattr(self, 'download_action'):
              self.download_action.setEnabled(connected)
 +        if hasattr(self, 'delete_action'):
 +            self.delete_action.setEnabled(connected)
          if hasattr(self, 'remote_pane'):
              self.remote_pane.setEnabled(connected)
              self.status_bar.showMessage(f"Connected to {hostname}", 3000)
          except Exception as e:
 -            QMessageBox.critical(self, "Connection Error", str(e))
 +            QMessageBox.critical(
 +                self,
 +                "Connection Error",
 +                str(e),
 +                QMessageBox.StandardButton.Ok,
 +                QMessageBox.StandardButton.Ok
 +            )
              self._update_connection_status(False)
      def disconnect(self):
          """Refresh both file views"""
          # Local is automatically updated by QFileSystemModel
          if self.sftp and self.remote_model:
 -            self.remote_model.refresh()
 +            self.remote_model.refresh(preserve_state=True)
      def _toggle_hidden_files(self, checked: bool):
          """Toggle showing hidden files in remote view"""
              self.local_view.setRootIndex(index)
              self.local_path.setText(self.local_model.filePath(index))
 +    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:
                      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
 -        view = self.local_view if is_local else self.remote_view
          menu.exec(view.mapToGlobal(pos))
      def upload_selected(self):
          if files:
              self._transfer_files(files, is_upload=False)
          else:
 -            QMessageBox.information(self, "Download", "Please select files to download (directories not supported yet)")
 +            QMessageBox.information(
 +                self,
 +                "Download",
 +                "Please select files to download (directories not supported yet)",
 +                QMessageBox.StandardButton.Ok,
 +                QMessageBox.StandardButton.Ok
 +            )
      def _transfer_files(self, files: List[str], is_upload: bool):
          """Transfer files with progress tracking"""
      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()
 +        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.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 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)
++
 +        # Upload each file to the target directory
 +        for local_path in local_paths:
 +            filename = os.path.basename(local_path)
 +            remote_path = os.path.join(target_directory, filename)
++
 +            # Skip directories for now
 +            if os.path.isdir(local_path):
 +                QMessageBox.information(
 +                    self,
 +                    "Upload",
 +                    f"Directory upload not yet supported: {filename}",
 +                    QMessageBox.StandardButton.Ok,
 +                    QMessageBox.StandardButton.Ok
 +                )
 +                continue
++
 +            # 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)
++
 +        self.status_bar.showMessage(f"Uploading {len(local_paths)} file(s) to {target_directory}", 3000)
++
 +    def _handle_remote_files_dropped(self, remote_paths: List[str], local_directory: str):
 +        """Handle remote files dropped onto local view"""
 +        if not self.sftp:
 +            return
++
 +        # Download each file to the target directory
 +        for remote_path in remote_paths:
 +            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)
++
 +        self.status_bar.showMessage(f"Downloading {len(remote_paths)} file(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():