`24cbe9c`

transfer dirs, fix remote->local drag and drop

Authored by

espadonne 10 months ago

SHA: 24cbe9cae52932d1cf75436abdff0360869f9d90
Parents: ff0e65e
Tree: 39f8fd6

2 changed files

Status	File	+	-
M	`src/wulftp/remote_model.py`	4	2
M	`src/wulftp/wulftp.py`	336	48

src/wulftp/remote_model.pymodified

                  item = self._get_item(index)
                  if item and item != self.root_item:
                      items.append(item)
 -                    paths.append(item.full_path)
 +                    # Include directory flag in the path data
 +                    path_info = f"{item.full_path}|{'D' if item.is_dir else 'F'}"
 +                    paths.append(path_info)
          if items:
 -            # Store remote paths as custom MIME type
 +            # Store remote paths with type info as custom MIME type
              mime_data.setData("application/x-wulftp-remote", "\n".join(paths).encode('utf-8'))
              # Also set text for debugging

src/wulftp/wulftp.pymodified

              self.signals.progress.emit(progress)
 +class DirectoryTransferWorker(QRunnable):
 +    """Worker for directory transfers"""
++
 +    def __init__(self, sftp, source_dir, dest_dir, is_upload=True):
 +        super().__init__()
 +        self.sftp = sftp
 +        self.source_dir = source_dir
 +        self.dest_dir = dest_dir
 +        self.is_upload = is_upload
 +        self.signals = WorkerSignals()
 +        self.total_files = 0
 +        self.processed_files = 0
++
 +    def run(self):
 +        try:
 +            if self.is_upload:
 +                self._upload_directory(self.source_dir, self.dest_dir)
 +            else:
 +                self._download_directory(self.source_dir, self.dest_dir)
 +            self.signals.finished.emit()
 +        except Exception as e:
 +            self.signals.error.emit(str(e))
++
 +    def _count_files(self, local_path):
 +        """Count total files in a local directory recursively"""
 +        count = 0
 +        for root, dirs, files in os.walk(local_path):
 +            count += len(files)
 +        return count
++
 +    def _count_remote_files(self, remote_path):
 +        """Count total files in a remote directory recursively"""
 +        count = 0
 +        try:
 +            for item in self.sftp.listdir_attr(remote_path):
 +                item_path = os.path.join(remote_path, item.filename)
 +                if stat.S_ISDIR(item.st_mode):
 +                    count += self._count_remote_files(item_path)
 +                else:
 +                    count += 1
 +        except:
 +            pass
 +        return count
++
 +    def _upload_directory(self, local_path, remote_path):
 +        """Recursively upload a directory"""
 +        # Count total files first
 +        if self.total_files == 0:
 +            self.total_files = self._count_files(local_path)
++
 +        # Create remote directory
 +        try:
 +            self.sftp.mkdir(remote_path)
 +        except:
 +            # Directory might already exist
 +            pass
++
 +        # Upload contents
 +        for item in os.listdir(local_path):
 +            local_item = os.path.join(local_path, item)
 +            remote_item = os.path.join(remote_path, item).replace('\\', '/')
++
 +            if os.path.isdir(local_item):
 +                self._upload_directory(local_item, remote_item)
 +            else:
 +                # Upload file
 +                self.sftp.put(local_item, remote_item)
 +                self.processed_files += 1
 +                if self.total_files > 0:
 +                    progress = int((self.processed_files / self.total_files) * 100)
 +                    self.signals.progress.emit(progress)
++
 +    def _download_directory(self, remote_path, local_path):
 +        """Recursively download a directory"""
 +        # Count total files first
 +        if self.total_files == 0:
 +            self.total_files = self._count_remote_files(remote_path)
++
 +        # Create local directory
 +        os.makedirs(local_path, exist_ok=True)
++
 +        # Download contents
 +        for item in self.sftp.listdir_attr(remote_path):
 +            remote_item = os.path.join(remote_path, item.filename).replace('\\', '/')
 +            local_item = os.path.join(local_path, item.filename)
++
 +            if stat.S_ISDIR(item.st_mode):
 +                self._download_directory(remote_item, local_item)
 +            else:
 +                # Download file
 +                self.sftp.get(remote_item, local_item)
 +                self.processed_files += 1
 +                if self.total_files > 0:
 +                    progress = int((self.processed_files / self.total_files) * 100)
 +                    self.signals.progress.emit(progress)
++
++
  class LocalTreeView(QTreeView):
      """Custom tree view for local files that handles remote file drops"""
 -    remoteFilesDropped = pyqtSignal(list, str)  # remote_paths, local_directory
 +    remoteFilesDropped = pyqtSignal(list, str)  # remote_items (path, is_dir), local_directory
      def __init__(self, parent=None):
          super().__init__(parent)
                  if model and model.isDir(index):
                      event.acceptProposedAction()
                      return
 -            event.ignore()
 +            # Also accept drops on empty space (root directory)
 +            event.acceptProposedAction()
          else:
              super().dragMoveEvent(event)
                  # Dropped on empty space, use root
                  target_dir = model.rootPath() if model else ""
 -            # Get remote paths
 +            # Get remote paths with type info
              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()]
 +            remote_items = []
 +            for line in remote_data.split('\n'):
 +                if line.strip() and '|' in line:
 +                    path, type_flag = line.strip().rsplit('|', 1)
 +                    is_dir = type_flag == 'D'
 +                    remote_items.append((path, is_dir))
 +                elif line.strip():
 +                    # Fallback for old format
 +                    remote_items.append((line.strip(), False))
 -            if remote_paths and target_dir:
 -                self.remoteFilesDropped.emit(remote_paths, target_dir)
 +            if remote_items and target_dir:
 +                self.remoteFilesDropped.emit(remote_items, target_dir)
                  event.acceptProposedAction()
          else:
              # Let parent handle local file operations
          # Add splitter to main layout
          layout.addWidget(splitter)
++
 +        # Initial button state update
 +        self._update_button_states()
      def _create_toolbar(self):
          """Create main toolbar"""
              qta.icon("fa5s.trash", color="#F44336"), "Delete Selected", self
+         )
          delete_action.triggered.connect(self.delete_selected)
 -        delete_action.setEnabled(False)
 +        delete_action.setEnabled(True)  # Always enabled
          toolbar.addAction(delete_action)
          self.delete_action = delete_action
          # Path display
          path_edit = QLineEdit()
          path_edit.setReadOnly(True)
 -        path_edit.setStyleSheet("QLineEdit { background-color: #f0f0f0; }")
 +        path_edit.setStyleSheet("""
 +            QLineEdit {
 +                background-color: #2b2b2b;
 +                color: #ffffff;
 +                border: 1px solid #555555;
 +                padding: 4px;
 +                font-family: monospace;
 +            }
 +        """)
          layout.addWidget(path_edit)
          # File view
              up_btn.clicked.connect(lambda: self._navigate_up(True))
              home_btn.clicked.connect(lambda: self._navigate_home(True))
              view.doubleClicked.connect(lambda idx: self._on_local_double_click(idx))
++
 +            # Connect selection change to update button states
 +            view.selectionModel().selectionChanged.connect(self._update_button_states)
          else:
              # Remote file list with the new model
              # Track expansion state
              view.expanded.connect(self._on_remote_expanded)
              view.collapsed.connect(self._on_remote_collapsed)
++
 +            # Connect selection change to update button states
 +            view.selectionModel().selectionChanged.connect(self._update_button_states)
          # Context menu
          view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
              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)
 +        # Delete action is always enabled (not dependent on connection)
          if hasattr(self, 'remote_pane'):
              self.remote_pane.setEnabled(connected)
      def connect(self):
          """Establish SFTP connection"""
 +        # Store current focus widget
 +        focus_widget = QApplication.focusWidget()
++
          try:
              host_data = self.host_combo.currentData()
              self._update_connection_status(True)
              self.status_bar.showMessage(f"Connected to {hostname}", 3000)
++
 +            # Restore focus
 +            if focus_widget:
 +                focus_widget.setFocus()
          except Exception as e:
              QMessageBox.critical(
                  QMessageBox.StandardButton.Ok
+             )
              self._update_connection_status(False)
++
 +            # Restore focus even on error
 +            if focus_widget:
 +                focus_widget.setFocus()
      def disconnect(self):
          """Close SFTP connection"""
              self.local_view.setRootIndex(index)
              self.local_path.setText(self.local_model.filePath(index))
 +    def _update_button_states(self):
 +        """Update button states based on current selection"""
 +        # Check if anything is selected in either view
 +        local_has_selection = bool(self.local_view.selectedIndexes())
 +        remote_has_selection = bool(self.remote_view.selectedIndexes()) if self.sftp else False
++
 +        has_any_selection = local_has_selection or remote_has_selection
++
 +        # Update delete button - make it look disabled when nothing is selected
 +        if hasattr(self, 'delete_action'):
 +            if has_any_selection:
 +                self.delete_action.setIcon(qta.icon("fa5s.trash", color="#F44336"))
 +            else:
 +                self.delete_action.setIcon(qta.icon("fa5s.trash", color="#888888"))
++
      def _on_remote_expanded(self, index: QModelIndex):
          """Track when a directory is expanded"""
          path = self.remote_model.filePath(index)
          menu.exec(view.mapToGlobal(pos))
      def upload_selected(self):
 -        """Upload selected local files"""
 +        """Upload selected local files and directories"""
          if not self.sftp:
              return
          if not selection:
              return
 -        # Get unique file paths (avoiding duplicates from multiple columns)
 -        files = set()
 +        # Get unique file/directory paths (avoiding duplicates from multiple columns)
 +        items = []
          for index in selection:
              if index.column() == 0:  # Only process name column
                  path = self.local_model.filePath(index)
 -                files.add(path)
 +                is_dir = self.local_model.isDir(index)
 +                items.append((path, is_dir))
 -        self._transfer_files(list(files), is_upload=True)
 +        # Separate files and directories
 +        files = [path for path, is_dir in items if not is_dir]
 +        directories = [path for path, is_dir in items if is_dir]
++
 +        # Handle directories first
 +        if directories:
 +            reply = QMessageBox.question(
 +                self,
 +                "Upload Directories",
 +                f"Upload {len(directories)} director{'y' if len(directories) == 1 else 'ies'}?\n\n" +
 +                "This will recursively upload all contents.",
 +                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +                QMessageBox.StandardButton.Yes
 +            )
++
 +            if reply == QMessageBox.StandardButton.Yes:
 +                for dir_path in directories:
 +                    dirname = os.path.basename(dir_path)
 +                    remote_base = self.remote_path.text() or "/"
 +                    remote_path = os.path.join(remote_base, dirname).replace('\\', '/')
++
 +                    worker = DirectoryTransferWorker(self.sftp, dir_path, remote_path, is_upload=True)
++
 +                    # Connect signals
 +                    worker.signals.progress.connect(self._update_progress)
 +                    worker.signals.finished.connect(self._transfer_complete)
 +                    worker.signals.error.connect(self._transfer_error)
++
 +                    # Show progress bar
 +                    self.progress_bar.setVisible(True)
 +                    self.progress_bar.setValue(0)
++
 +                    # Start transfer
 +                    self.threadpool.start(worker)
++
 +                    self.status_bar.showMessage(f"Uploading directory: {dirname}", 3000)
++
 +        # Handle files
 +        if files:
 +            self._transfer_files(files, is_upload=True)
      def download_selected(self):
 -        """Download selected remote files"""
 +        """Download selected remote files and directories"""
          if not self.sftp:
              return
          if not selection:
              return
 -        # Get unique file paths (avoiding duplicates from multiple columns)
 -        files = []
 +        # Get unique file/directory paths (avoiding duplicates from multiple columns)
 +        items = []
          for index in selection:
              if index.column() == 0:  # Only process name column
                  file_info = self.remote_model.fileInfo(index)
 -                if file_info and not file_info.is_dir:
 -                    files.append(file_info.full_path)
 +                if file_info:
 +                    items.append((file_info.full_path, file_info.is_dir, file_info.name))
 +        # Separate files and directories
 +        files = [path for path, is_dir, name in items if not is_dir]
 +        directories = [(path, name) for path, is_dir, name in items if is_dir]
++
 +        # Handle directories first
 +        if directories:
 +            reply = QMessageBox.question(
 +                self,
 +                "Download Directories",
 +                f"Download {len(directories)} director{'y' if len(directories) == 1 else 'ies'}?\n\n" +
 +                "This will recursively download all contents.",
 +                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +                QMessageBox.StandardButton.Yes
 +            )
++
 +            if reply == QMessageBox.StandardButton.Yes:
 +                for dir_path, dirname in directories:
 +                    local_base = self.local_model.filePath(self.local_view.rootIndex())
 +                    local_path = os.path.join(local_base, dirname)
++
 +                    worker = DirectoryTransferWorker(self.sftp, dir_path, local_path, is_upload=False)
++
 +                    # Connect signals
 +                    worker.signals.progress.connect(self._update_progress)
 +                    worker.signals.finished.connect(self._transfer_complete_download)
 +                    worker.signals.error.connect(self._transfer_error)
++
 +                    # Show progress bar
 +                    self.progress_bar.setVisible(True)
 +                    self.progress_bar.setValue(0)
++
 +                    # Start transfer
 +                    self.threadpool.start(worker)
++
 +                    self.status_bar.showMessage(f"Downloading directory: {dirname}", 3000)
++
 +        # Handle files
          if files:
              self._transfer_files(files, is_upload=False)
 -        else:
 -            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 _handle_files_dropped(self, local_paths: List[str], target_directory: str):
 -        """Handle files dropped onto remote view"""
 +        """Handle files and directories dropped onto remote view"""
          if not self.sftp:
              return
          # Update remote path to show where files are being uploaded
          self.remote_path.setText(target_directory)
 -        # Upload each file to the target directory
 +        # Separate files and directories
 +        files = []
 +        directories = []
++
          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
 +                directories.append(local_path)
 +            else:
 +                files.append(local_path)
++
 +        # Handle directories
 +        if directories:
 +            reply = QMessageBox.question(
 +                self,
 +                "Upload Directories",
 +                f"Upload {len(directories)} director{'y' if len(directories) == 1 else 'ies'}?\n\n" +
 +                "This will recursively upload all contents.",
 +                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +                QMessageBox.StandardButton.Yes
 +            )
++
 +            if reply == QMessageBox.StandardButton.Yes:
 +                for dir_path in directories:
 +                    dirname = os.path.basename(dir_path)
 +                    remote_path = os.path.join(target_directory, dirname).replace('\\', '/')
++
 +                    worker = DirectoryTransferWorker(self.sftp, dir_path, remote_path, is_upload=True)
++
 +                    # Connect signals
 +                    worker.signals.progress.connect(self._update_progress)
 +                    worker.signals.finished.connect(self._transfer_complete)
 +                    worker.signals.error.connect(self._transfer_error)
++
 +                    # Show progress bar
 +                    self.progress_bar.setVisible(True)
 +                    self.progress_bar.setValue(0)
++
 +                    # Start transfer
 +                    self.threadpool.start(worker)
++
 +        # Handle files
 +        for local_path in files:
 +            filename = os.path.basename(local_path)
 +            remote_path = os.path.join(target_directory, filename).replace('\\', '/')
              # Create transfer worker
              worker = TransferWorker(self.sftp, local_path, remote_path, True)
              # Start transfer
              self.threadpool.start(worker)
 -        self.status_bar.showMessage(f"Uploading {len(local_paths)} file(s) to {target_directory}", 3000)
 +        total_items = len(files) + len(directories)
 +        self.status_bar.showMessage(f"Uploading {total_items} item(s) to {target_directory}", 3000)
 -    def _handle_remote_files_dropped(self, remote_paths: List[str], local_directory: str):
 -        """Handle remote files dropped onto local view"""
 +    def _handle_remote_files_dropped(self, remote_items: List[tuple], local_directory: str):
 +        """Handle remote files and directories dropped onto local view"""
          if not self.sftp:
              return
++
 +        # Separate files and directories
 +        files = []
 +        directories = []
++
 +        for remote_path, is_dir in remote_items:
 +            if is_dir:
 +                dirname = os.path.basename(remote_path)
 +                directories.append((remote_path, dirname))
 +            else:
 +                files.append(remote_path)
++
 +        # Handle directories
 +        if directories:
 +            reply = QMessageBox.question(
 +                self,
 +                "Download Directories",
 +                f"Download {len(directories)} director{'y' if len(directories) == 1 else 'ies'}?\n\n" +
 +                "This will recursively download all contents.",
 +                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
 +                QMessageBox.StandardButton.Yes
 +            )
 -        # Download each file to the target directory
 -        for remote_path in remote_paths:
 +            if reply == QMessageBox.StandardButton.Yes:
 +                for remote_path, dirname in directories:
 +                    local_path = os.path.join(local_directory, dirname)
++
 +                    worker = DirectoryTransferWorker(self.sftp, remote_path, local_path, is_upload=False)
++
 +                    # Connect signals
 +                    worker.signals.progress.connect(self._update_progress)
 +                    worker.signals.finished.connect(self._transfer_complete_download)
 +                    worker.signals.error.connect(self._transfer_error)
++
 +                    # Show progress bar
 +                    self.progress_bar.setVisible(True)
 +                    self.progress_bar.setValue(0)
++
 +                    # Start transfer
 +                    self.threadpool.start(worker)
++
 +        # Handle files
 +        for remote_path in files:
              filename = os.path.basename(remote_path)
              local_path = os.path.join(local_directory, filename)
              # Start transfer
              self.threadpool.start(worker)
 -        self.status_bar.showMessage(f"Downloading {len(remote_paths)} file(s) to {local_directory}", 3000)
 +        total_items = len(files) + len(directories)
 +        self.status_bar.showMessage(f"Downloading {total_items} item(s) to {local_directory}", 3000)
      @pyqtSlot()
      def _transfer_complete_download(self):