"""主窗口 应用的主界面,包含 URL 输入、视频信息展示、格式选择、 下载选项、进度列表、播放列表管理等所有核心 UI 交互。 """ import logging import os import re import threading from pathlib import Path from typing import List, Optional, Dict, Any from PySide6.QtWidgets import ( QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QPushButton, QComboBox, QCheckBox, QTableWidget, QTableWidgetItem, QHeaderView, QProgressBar, QFrame, QStackedWidget, QScrollArea, QGroupBox, QFormLayout, QStatusBar, QMenuBar, QMenu, QMessageBox, QSplitter, QAbstractItemView, QStyle, QApplication, QSizePolicy, QGridLayout, ) from PySide6.QtCore import ( Qt, Signal, Slot, QThread, QUrl, QTimer, QSize, ) from PySide6.QtGui import ( QAction, QFont, QIcon, QPixmap, QDesktopServices, QPalette, QColor, ) from ..models.task import ( DownloadTask, VideoInfo, VideoFormat, DownloadProgress, TaskStatus, DownloadType, ) from ..models.settings import Settings, ThemeMode from ..config.settings_manager import get_settings_manager, get_settings from ..downloader.format_parser import FormatParser from ..downloader.video_downloader import VideoDownloader from ..downloader.playlist_downloader import PlaylistDownloader from ..downloader.subtitle_downloader import SubtitleDownloader from ..downloader.thumbnail_downloader import ThumbnailDownloader from ..downloader.ffmpeg_merger import FFmpegMerger from ..downloader.ffmpeg_installer import FFmpegInstaller from ..downloader.download_queue import DownloadQueue from ..utils.validators import validate_youtube_url, sanitize_filename, clean_video_url from ..utils.logger import get_logger from .settings_window import SettingsWindow from .about_window import AboutWindow from .theme import get_theme_stylesheet logger = get_logger(__name__) class FetchInfoWorker(QThread): """获取视频信息的后台线程 在后台获取视频信息和格式列表,避免阻塞 UI。 """ # 信号:成功获取 (video_info, formats, subtitles) info_ready = Signal(object, list, list) # 信号:获取失败 (error_message) info_error = Signal(str) # 信号:播放列表信息 (playlist_title, videos) playlist_ready = Signal(str, list) def __init__(self, url: str, cookies: str = "", cookies_file: str = "", parent=None) -> None: """初始化信息获取线程 Args: url: YouTube URL cookies: 浏览器名称用于 Cookie 读取 cookies_file: Cookie 文件路径(Netscape 格式) parent: 父对象 """ super().__init__(parent) self._url = url self._cookies = cookies self._cookies_file = cookies_file self._is_playlist = False @property def is_playlist(self) -> bool: """是否为播放列表""" return self._is_playlist def run(self) -> None: """执行线程逻辑""" try: valid, vid, is_playlist = validate_youtube_url(self._url) if not valid: self.info_error.emit("无效的 YouTube URL,请检查链接格式。") return self._is_playlist = is_playlist parser = FormatParser(self._cookies, self._cookies_file) if is_playlist: # 播放列表 playlist_dl = PlaylistDownloader(self._cookies, self._cookies_file) videos = playlist_dl.fetch_playlist_info(self._url) title = playlist_dl.fetch_playlist_title(self._url) self.playlist_ready.emit(title, videos) else: # 单个视频 — 清理 URL(移除 ?list= / &t= 等参数) clean_url = clean_video_url(self._url) info = parser.fetch_video_info(clean_url) if info is None: err = parser.last_error or "无法获取视频信息,请检查链接或网络连接。" self.info_error.emit(err) return formats = parser.fetch_formats(clean_url) subtitles = parser.fetch_subtitles(clean_url) self.info_ready.emit(info, formats, subtitles) except Exception as e: logger.error(f"获取信息失败: {e}") self.info_error.emit(f"获取信息时发生错误: {str(e)}") class MainWindow(QMainWindow): """主窗口 YouTube Downloader Pro 的主界面, 提供视频下载、播放列表管理和设置入口。 """ # 应用信息 APP_TITLE = "YouTube Downloader Pro" APP_VERSION = "v1.0.0" def __init__(self) -> None: """初始化主窗口""" super().__init__() # 设置管理器 self._settings_manager = get_settings_manager() self._settings = self._settings_manager.settings # 下载器组件 cookies = self._settings.cookies_from_browser cookies_file = self._settings.cookies_file self._format_parser = FormatParser(cookies, cookies_file) self._video_downloader = VideoDownloader(self._settings.ffmpeg_path) self._playlist_downloader = PlaylistDownloader(cookies, cookies_file) self._subtitle_downloader = SubtitleDownloader() self._thumbnail_downloader = ThumbnailDownloader() self._ffmpeg_merger = FFmpegMerger(self._settings.ffmpeg_path) # 下载队列 self._download_queue = DownloadQueue(self._settings.max_workers) self._active_downloaders: dict = {} # task_id -> VideoDownloader self._downloaders_lock = threading.Lock() # 保护 _active_downloaders # 当前获取的视频信息 self._current_info: Optional[VideoInfo] = None self._current_formats: List[VideoFormat] = [] self._current_subtitles = [] self._playlist_videos: List[VideoInfo] = [] # 后台线程 self._fetch_worker: Optional[FetchInfoWorker] = None # 进度定时器(延迟到 showEvent 启动,避免初始化竞态崩溃) self._progress_timer = QTimer() self._progress_timer.setInterval(500) self._progress_timer.timeout.connect(self._refresh_progress_display) # 构建 UI self._setup_ui() self._setup_menu_bar() self._setup_status_bar() self._setup_connections() # 主题在 main.py 中通过 app.setStyleSheet() 预加载,此处不重复应用 # 恢复窗口位置 self._restore_window_geometry() logger.info("主窗口初始化完成") # ========== UI 构建 ========== def _setup_ui(self) -> None: """构建主界面布局""" self.setWindowTitle(f"{self.APP_TITLE} {self.APP_VERSION}") self.setMinimumSize(1000, 700) # 中央组件 central = QWidget() self.setCentralWidget(central) main_layout = QVBoxLayout(central) main_layout.setContentsMargins(16, 12, 16, 12) main_layout.setSpacing(10) # ---------- 顶部:URL 输入区 ---------- self._create_url_bar(main_layout) # ---------- 中间:内容区 (堆叠) ---------- self._content_stack = QStackedWidget() # 页面 0: 空状态 self._empty_page = self._create_empty_page() self._content_stack.addWidget(self._empty_page) # 页面 1: 视频信息 + 格式选择 + 选项 self._video_page = self._create_video_page() self._content_stack.addWidget(self._video_page) # 页面 2: 播放列表 self._playlist_page = self._create_playlist_page() self._content_stack.addWidget(self._playlist_page) main_layout.addWidget(self._content_stack, stretch=1) # ---------- 下载设置面板(始终可见,对所有下载模式生效)---------- self._download_settings = self._create_download_settings() main_layout.addWidget(self._download_settings) # ---------- 底部:下载进度列表 ---------- self._create_progress_table(main_layout) # 默认显示空状态 self._content_stack.setCurrentIndex(0) def _create_url_bar(self, parent_layout: QVBoxLayout) -> None: """创建顶部 URL 输入栏 Args: parent_layout: 父布局 """ url_frame = QFrame() url_frame.setObjectName("urlBar") url_frame.setFixedHeight(56) url_layout = QHBoxLayout(url_frame) url_layout.setContentsMargins(8, 8, 8, 8) # URL 图标 url_icon = QLabel("🔗") url_icon.setFixedWidth(30) url_layout.addWidget(url_icon) # URL 输入框 self._url_input = QLineEdit() self._url_input.setPlaceholderText( "粘贴 YouTube 视频或播放列表链接... 例如: https://www.youtube.com/watch?v=..." ) self._url_input.setClearButtonEnabled(True) self._url_input.returnPressed.connect(self._on_fetch_info) url_layout.addWidget(self._url_input) # 获取信息按钮 self._fetch_btn = QPushButton("🔍 获取信息") self._fetch_btn.setFixedWidth(110) self._fetch_btn.setToolTip("获取视频信息和可用格式") self._fetch_btn.clicked.connect(self._on_fetch_info) url_layout.addWidget(self._fetch_btn) # 下载按钮 self._download_btn = QPushButton("⬇ 下载") self._download_btn.setFixedWidth(90) self._download_btn.setEnabled(False) self._download_btn.setToolTip("开始下载当前视频") self._download_btn.clicked.connect(self._on_start_download) url_layout.addWidget(self._download_btn) # 批量下载按钮 self._batch_btn = QPushButton("📦 批量下载") self._batch_btn.setFixedWidth(100) self._batch_btn.setToolTip("批量添加多个视频链接同时下载") self._batch_btn.clicked.connect(self._on_batch_download) url_layout.addWidget(self._batch_btn) parent_layout.addWidget(url_frame) def _create_empty_page(self) -> QWidget: """创建空状态引导页 Returns: 空状态页面组件 """ page = QWidget() layout = QVBoxLayout(page) layout.setAlignment(Qt.AlignmentFlag.AlignCenter) layout.addStretch() icon_label = QLabel("📥") icon_label.setAlignment(Qt.AlignmentFlag.AlignCenter) icon_label.setStyleSheet("font-size: 64px;") layout.addWidget(icon_label) title = QLabel("YouTube Downloader Pro") title.setAlignment(Qt.AlignmentFlag.AlignCenter) title_font = QFont() title_font.setPointSize(22) title_font.setBold(True) title.setFont(title_font) layout.addWidget(title) hint = QLabel('在上方粘贴 YouTube 链接,然后点击"获取信息"开始') hint.setAlignment(Qt.AlignmentFlag.AlignCenter) hint.setStyleSheet("color: #888; font-size: 13px;") layout.addWidget(hint) layout.addStretch() return page def _create_video_page(self) -> QWidget: """创建视频信息页面 Returns: 视频信息页面组件 """ page = QWidget() layout = QVBoxLayout(page) layout.setSpacing(10) # ===== 视频信息卡片 ===== info_frame = QFrame() info_frame.setObjectName("videoInfoCard") info_layout = QHBoxLayout(info_frame) info_layout.setContentsMargins(16, 12, 16, 12) # 封面图 self._thumbnail_label = QLabel() self._thumbnail_label.setFixedSize(160, 90) self._thumbnail_label.setAlignment(Qt.AlignmentFlag.AlignCenter) self._thumbnail_label.setStyleSheet( "background-color: #333; border-radius: 6px; color: #888; font-size: 12px;" ) self._thumbnail_label.setText("封面图") info_layout.addWidget(self._thumbnail_label) # 视频元数据 meta_layout = QVBoxLayout() meta_layout.setSpacing(4) self._title_label = QLabel("视频标题") title_font = QFont() title_font.setPointSize(14) title_font.setBold(True) self._title_label.setFont(title_font) self._title_label.setWordWrap(True) meta_layout.addWidget(self._title_label) meta_grid = QGridLayout() meta_grid.setSpacing(4) meta_grid.addWidget(QLabel("👤 作者:"), 0, 0) self._author_label = QLabel("-") meta_grid.addWidget(self._author_label, 0, 1) meta_grid.addWidget(QLabel("⏱ 时长:"), 0, 2) self._duration_label = QLabel("-") meta_grid.addWidget(self._duration_label, 0, 3) meta_grid.addWidget(QLabel("📅 上传:"), 1, 0) self._upload_date_label = QLabel("-") meta_grid.addWidget(self._upload_date_label, 1, 1) meta_layout.addLayout(meta_grid) info_layout.addLayout(meta_layout, stretch=1) layout.addWidget(info_frame) return page def _create_download_settings(self) -> QWidget: """创建下载设置面板(始终可见) 包含格式选择和下载选项,对所有下载模式(单视频/播放列表/批量)生效。 """ container = QWidget() layout = QVBoxLayout(container) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(8) # ===== 格式选择区 ===== format_group = QGroupBox("格式选择") format_flayout = QFormLayout(format_group) # 视频格式 video_fmt_layout = QHBoxLayout() self._video_format_combo = QComboBox() self._video_format_combo.setMinimumWidth(400) self._video_format_combo.setToolTip("选择视频清晰度和编码格式") video_fmt_layout.addWidget(self._video_format_combo) video_fmt_layout.addStretch() format_flayout.addRow("🎬 视频格式:", video_fmt_layout) # 音频格式 audio_fmt_layout = QHBoxLayout() self._audio_format_combo = QComboBox() self._audio_format_combo.setMinimumWidth(200) self._audio_format_combo.setToolTip("选择纯音频格式(仅下载音频时选择此项)") audio_fmt_layout.addWidget(self._audio_format_combo) audio_fmt_layout.addStretch() format_flayout.addRow("🎵 音频格式:", audio_fmt_layout) layout.addWidget(format_group) # ===== 下载选项 ===== options_frame = QFrame() options_hlayout = QHBoxLayout(options_frame) options_hlayout.setContentsMargins(0, 0, 0, 0) self._subtitle_cb = QCheckBox("📝 下载字幕") self._subtitle_cb.setChecked(self._settings.auto_subtitle) options_hlayout.addWidget(self._subtitle_cb) self._sub_lang_combo = QComboBox() self._sub_lang_combo.addItems(["中文", "English", "日本語", "한국어"]) self._sub_lang_combo.setFixedWidth(80) options_hlayout.addWidget(self._sub_lang_combo) options_hlayout.addSpacing(16) self._thumbnail_cb = QCheckBox("🖼 下载封面") options_hlayout.addWidget(self._thumbnail_cb) options_hlayout.addSpacing(16) self._auto_merge_cb = QCheckBox("🔗 自动合并音视频") self._auto_merge_cb.setChecked(self._settings.auto_merge) self._auto_merge_cb.setToolTip("高清视频自动下载音视频流并使用 FFmpeg 合并") options_hlayout.addWidget(self._auto_merge_cb) options_hlayout.addStretch() layout.addWidget(options_frame) return container def _create_playlist_page(self) -> QWidget: """创建播放列表信息页面 Returns: 播放列表页面组件 """ page = QWidget() layout = QVBoxLayout(page) layout.setSpacing(8) # 播放列表标题 self._playlist_title_label = QLabel("播放列表") pl_font = QFont() pl_font.setPointSize(14) pl_font.setBold(True) self._playlist_title_label.setFont(pl_font) layout.addWidget(self._playlist_title_label) # 操作按钮 btn_layout = QHBoxLayout() self._select_all_btn = QPushButton("全选") self._select_all_btn.setFixedWidth(70) self._select_all_btn.clicked.connect(self._on_select_all) btn_layout.addWidget(self._select_all_btn) self._deselect_all_btn = QPushButton("取消全选") self._deselect_all_btn.setFixedWidth(80) self._deselect_all_btn.clicked.connect(self._on_deselect_all) btn_layout.addWidget(self._deselect_all_btn) btn_layout.addStretch() count_label = QLabel("共 ") btn_layout.addWidget(count_label) self._playlist_count_label = QLabel("0") self._playlist_count_label.setStyleSheet("font-weight: bold;") btn_layout.addWidget(self._playlist_count_label) btn_layout.addWidget(QLabel(" 个视频")) btn_layout.addStretch() self._playlist_download_btn = QPushButton("⬇ 下载选中") self._playlist_download_btn.setFixedWidth(110) self._playlist_download_btn.clicked.connect(self._on_download_selected) btn_layout.addWidget(self._playlist_download_btn) layout.addLayout(btn_layout) # 视频列表表格 self._playlist_table = QTableWidget() self._playlist_table.setColumnCount(5) self._playlist_table.setHorizontalHeaderLabels([ "", "序号", "标题", "作者", "时长", ]) self._playlist_table.setSelectionBehavior( QAbstractItemView.SelectionBehavior.SelectRows ) self._playlist_table.setEditTriggers( QAbstractItemView.EditTrigger.NoEditTriggers ) self._playlist_table.horizontalHeader().setSectionResizeMode( 2, QHeaderView.ResizeMode.Stretch ) self._playlist_table.setColumnWidth(0, 40) # 复选框 self._playlist_table.setColumnWidth(1, 50) # 序号 self._playlist_table.setColumnWidth(3, 120) # 作者 self._playlist_table.setColumnWidth(4, 80) # 时长 self._playlist_table.setAlternatingRowColors(True) layout.addWidget(self._playlist_table) return page def _create_progress_table(self, parent_layout: QVBoxLayout) -> None: """创建下载进度列表 Args: parent_layout: 父布局 """ progress_group = QGroupBox("下载队列") progress_layout = QVBoxLayout(progress_group) # 工具栏 toolbar = QHBoxLayout() self._pause_all_btn = QPushButton("⏸ 全部暂停") self._pause_all_btn.setFixedWidth(90) self._pause_all_btn.clicked.connect(self._on_pause_all) toolbar.addWidget(self._pause_all_btn) self._resume_all_btn = QPushButton("▶ 全部恢复") self._resume_all_btn.setFixedWidth(90) self._resume_all_btn.clicked.connect(self._on_resume_all) toolbar.addWidget(self._resume_all_btn) self._cancel_all_btn = QPushButton("⏹ 全部取消") self._cancel_all_btn.setFixedWidth(90) self._cancel_all_btn.clicked.connect(self._on_cancel_all) toolbar.addWidget(self._cancel_all_btn) toolbar.addStretch() self._clear_completed_btn = QPushButton("清空已完成") self._clear_completed_btn.setFixedWidth(90) self._clear_completed_btn.clicked.connect(self._on_clear_completed) toolbar.addWidget(self._clear_completed_btn) self._retry_failed_btn = QPushButton("重试失败") self._retry_failed_btn.setFixedWidth(80) self._retry_failed_btn.clicked.connect(self._on_retry_failed) toolbar.addWidget(self._retry_failed_btn) progress_layout.addLayout(toolbar) # 进度表格 self._progress_table = QTableWidget() self._progress_table.setColumnCount(6) self._progress_table.setHorizontalHeaderLabels([ "任务", "状态", "速度", "已下载/总大小", "进度", "操作", ]) self._progress_table.setSelectionBehavior( QAbstractItemView.SelectionBehavior.SelectRows ) self._progress_table.setEditTriggers( QAbstractItemView.EditTrigger.NoEditTriggers ) self._progress_table.horizontalHeader().setSectionResizeMode( 0, QHeaderView.ResizeMode.Stretch ) self._progress_table.setColumnWidth(1, 80) self._progress_table.setColumnWidth(2, 100) self._progress_table.setColumnWidth(3, 150) self._progress_table.setColumnWidth(4, 160) self._progress_table.setColumnWidth(5, 90) self._progress_table.setAlternatingRowColors(True) progress_layout.addWidget(self._progress_table) parent_layout.addWidget(progress_group) def _setup_menu_bar(self) -> None: """设置菜单栏""" menu_bar = self.menuBar() # 文件菜单 file_menu = menu_bar.addMenu("文件(&F)") add_url_action = QAction("添加下载链接...", self) add_url_action.triggered.connect( lambda: self._url_input.setFocus() ) file_menu.addAction(add_url_action) file_menu.addSeparator() exit_action = QAction("退出(&X)", self) exit_action.setShortcut("Ctrl+Q") exit_action.triggered.connect(self.close) file_menu.addAction(exit_action) # 工具菜单 tools_menu = menu_bar.addMenu("工具(&T)") settings_action = QAction("设置(&S)...", self) settings_action.setShortcut("Ctrl+,") settings_action.triggered.connect(self._open_settings) tools_menu.addAction(settings_action) tools_menu.addSeparator() open_dir_action = QAction("打开下载目录...", self) open_dir_action.triggered.connect(self._open_download_dir) tools_menu.addAction(open_dir_action) # 帮助菜单 help_menu = menu_bar.addMenu("帮助(&H)") about_action = QAction("关于(&A)...", self) about_action.triggered.connect(self._open_about) help_menu.addAction(about_action) help_menu.addSeparator() ffmpeg_action = QAction("检查 FFmpeg 状态...", self) ffmpeg_action.triggered.connect(self._check_ffmpeg_status) help_menu.addAction(ffmpeg_action) def _setup_status_bar(self) -> None: """设置状态栏""" self._status_bar = QStatusBar() self.setStatusBar(self._status_bar) # 线程数标签 self._thread_label = QLabel( f"线程: {self._settings.max_workers}" ) self._status_bar.addPermanentWidget(self._thread_label) # FFmpeg 状态(标签创建,内容在 showEvent 中更新) self._ffmpeg_status_label = QLabel() self._status_bar.addPermanentWidget(self._ffmpeg_status_label) self._status_bar.showMessage("就绪") def _setup_connections(self) -> None: """设置下载队列的回调连接(所有回调通过 QTimer 调度到主线程)""" self._download_queue.set_callbacks( on_started=lambda t: QTimer.singleShot(0, lambda: self._on_task_started(t)), on_completed=lambda t: QTimer.singleShot(0, lambda: self._on_task_completed(t)), on_failed=lambda t: QTimer.singleShot(0, lambda: self._on_task_failed(t)), on_all_completed=lambda: QTimer.singleShot(0, self._on_all_completed), ) # ========== 主题 ========== def _apply_theme(self) -> None: """应用当前主题设置""" theme = self._settings.theme if theme == ThemeMode.SYSTEM: is_dark = True # 默认深色 try: import darkdetect is_dark = darkdetect.isDark() except Exception: pass else: is_dark = (theme == ThemeMode.DARK) if is_dark: self._apply_dark_theme() else: self._apply_light_theme() def _apply_dark_theme(self) -> None: """应用深色主题""" QApplication.instance().setStyleSheet(get_theme_stylesheet(True)) def _apply_light_theme(self) -> None: """应用浅色主题""" QApplication.instance().setStyleSheet(get_theme_stylesheet(False)) # ========== 窗口状态管理 ========== def _restore_window_geometry(self) -> None: """恢复上次的窗口位置和大小""" s = self._settings if s.window_width > 0 and s.window_height > 0: self.resize(s.window_width, s.window_height) if s.window_x >= 0 and s.window_y >= 0: self.move(s.window_x, s.window_y) def _save_window_geometry(self) -> None: """保存当前窗口位置和大小""" s = self._settings s.window_width = self.width() s.window_height = self.height() s.window_x = self.x() s.window_y = self.y() self._settings_manager.save(s) # ========== 事件处理 ========== def closeEvent(self, event) -> None: """窗口关闭事件 Args: event: 关闭事件 """ # 停止进度刷新定时器 self._progress_timer.stop() # 保存窗口状态 self._save_window_geometry() # 停止下载队列 if self._download_queue.is_running: reply = QMessageBox.question( self, "确认退出", "下载任务正在进行中,确定要退出吗?", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, ) if reply == QMessageBox.StandardButton.No: self._progress_timer.start() # 恢复定时器 event.ignore() return self._download_queue.stop() event.accept() def showEvent(self, event) -> None: """窗口显示后延迟启动定时器,避免与渲染管道竞争""" super().showEvent(event) if not self._progress_timer.isActive(): # 延迟启动避免与 Qt 渲染竞态 (Python 3.14 兼容) QTimer.singleShot(500, self._update_ffmpeg_status_label) QTimer.singleShot(1000, self._progress_timer.start) # ========== 核心操作 ========== def _on_fetch_info(self) -> None: """获取视频/播放列表信息""" url = self._url_input.text().strip() if not url: QMessageBox.warning(self, "提示", "请先输入 YouTube 链接。") return valid, _, _ = validate_youtube_url(url) if not valid: QMessageBox.warning( self, "无效链接", "请检查 YouTube 链接格式是否正确。\n\n" "支持的格式:\n" " • https://www.youtube.com/watch?v=...\n" " • https://youtu.be/...\n" " • https://www.youtube.com/playlist?list=..." ) return # 禁用按钮,防止重复点击 self._fetch_btn.setEnabled(False) self._download_btn.setEnabled(False) self._status_bar.showMessage("正在获取信息...") # 启动后台线程获取信息 self._fetch_worker = FetchInfoWorker( url, cookies=self._settings.cookies_from_browser, cookies_file=self._settings.cookies_file, ) self._fetch_worker.info_ready.connect(self._on_info_ready) self._fetch_worker.info_error.connect(self._on_info_error) self._fetch_worker.playlist_ready.connect(self._on_playlist_ready) self._fetch_worker.start() @Slot(object, list, list) def _on_info_ready( self, info: VideoInfo, formats: list, subtitles: list, ) -> None: """视频信息获取成功 Args: info: 视频信息 formats: 可用格式列表 subtitles: 字幕列表 """ self._current_info = info self._current_formats = formats self._current_subtitles = subtitles # 更新 UI self._display_video_info(info) self._populate_format_combos(formats) # 切换到视频页面 self._content_stack.setCurrentIndex(1) self._download_btn.setEnabled(True) self._fetch_btn.setEnabled(True) self._status_bar.showMessage(f"已获取: {info.title[:50]}...", 5000) logger.info(f"视频信息获取成功: {info.title}") @Slot(str) def _on_info_error(self, error_msg: str) -> None: """视频信息获取失败 Args: error_msg: 错误消息 """ self._fetch_btn.setEnabled(True) self._status_bar.showMessage("获取失败", 3000) QMessageBox.critical(self, "获取失败", error_msg) logger.error(f"获取信息失败: {error_msg}") @Slot(str, list) def _on_playlist_ready(self, title: str, videos: list) -> None: """播放列表信息获取成功 Args: title: 播放列表标题 videos: 视频信息列表 """ self._playlist_videos = videos # 更新播放列表 UI self._playlist_title_label.setText(f"📋 {title}") self._playlist_count_label.setText(str(len(videos))) # 填充播放列表表格 self._populate_playlist_table(videos) # 切换到播放列表页面 self._content_stack.setCurrentIndex(2) self._download_btn.setEnabled(True) self._fetch_btn.setEnabled(True) # 后台获取第一个视频的可用格式,填充格式选择下拉框 if videos and videos[0].webpage_url: self._fetch_formats_for_playlist(videos[0].webpage_url) self._status_bar.showMessage( f"播放列表: {title} ({len(videos)} 个视频)", 5000 ) logger.info(f"播放列表解析成功: {title} ({len(videos)} 个视频)") def _fetch_formats_for_playlist(self, sample_url: str) -> None: """后台获取播放列表的可用格式(使用第一个视频采样) Args: sample_url: 采样视频的 URL """ class FormatFetchThread(QThread): formats_ready = Signal(list) def __init__(self, url: str, cookies: str = "", cookies_file: str = ""): super().__init__() self._url = url self._cookies = cookies self._cookies_file = cookies_file def run(self) -> None: try: parser = FormatParser(self._cookies, self._cookies_file) formats = parser.fetch_formats(self._url) self.formats_ready.emit(formats) except Exception: self.formats_ready.emit([]) self._format_thread = FormatFetchThread( sample_url, cookies=self._settings.cookies_from_browser, cookies_file=self._settings.cookies_file, ) self._format_thread.formats_ready.connect(self._populate_format_combos) self._format_thread.start() def _on_start_download(self) -> None: """开始下载""" current_page = self._content_stack.currentIndex() if current_page == 1: # 单视频下载 self._start_single_download() elif current_page == 2: # 播放列表下载 self._start_playlist_download() else: QMessageBox.warning(self, "提示", "请先获取视频信息。") def _start_single_download(self) -> None: """启动单个视频下载""" if not self._current_info: return # 创建下载任务 task = DownloadTask( url=self._url_input.text().strip(), video_info=self._current_info, ) # 获取选择的格式(从 combo 的用户数据中获取) selected_fmt = self._video_format_combo.currentData() if selected_fmt and isinstance(selected_fmt, VideoFormat): task.selected_format = selected_fmt # 检查 FFmpeg 是否就绪(纯视频格式需要合并) if ( task.selected_format and task.selected_format.has_video and not task.selected_format.has_audio and not self._ffmpeg_merger.is_available ): reply = QMessageBox.warning( self, "FFmpeg 不可用", "您选择的视频格式只有视频流,没有音频。\n" "合并音频需要 FFmpeg,但当前未安装。\n\n" "建议:\n" " 1. 选择含音频的合并格式(下拉列表前半部分)\n" " 2. 安装 FFmpeg 并在设置中配置\n\n" "是否仍要继续?(可能下载失败)", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, QMessageBox.StandardButton.No, ) if reply == QMessageBox.StandardButton.No: return # 下载选项 task.download_subtitle = self._subtitle_cb.isChecked() task.download_thumbnail = self._thumbnail_cb.isChecked() if self._subtitle_cb.isChecked(): lang_map = {0: "zh", 1: "en", 2: "ja", 3: "ko"} task.subtitle_language = lang_map.get( self._sub_lang_combo.currentIndex(), "zh" ) # 输出目录 task.output_dir = ( self._settings.download_dir or str(Path.home() / "Downloads" / "YouTube") ) # 代理和限速 if self._settings.proxy: task.extra_data["proxy"] = self._settings.proxy if self._settings.rate_limit: task.extra_data["rate_limit"] = self._settings.rate_limit if self._settings.cookies_file: task.extra_data["cookies_file"] = self._settings.cookies_file elif self._settings.cookies_from_browser: task.extra_data["cookies_from_browser"] = self._settings.cookies_from_browser # 添加到下载队列 self._download_queue.add_task(task) # 刷新进度表 self._refresh_progress_table() # 启动队列(如果尚未运行) self._ensure_queue_running() self._status_bar.showMessage( f"已添加下载: {task.video_info.title[:40]}..." ) def _start_playlist_download(self) -> None: """启动播放列表批量下载 使用主窗口当前设置(画质/格式/字幕/封面/音频)应用到所有选中视频。 """ selected_videos = self._get_selected_playlist_videos() if not selected_videos: QMessageBox.warning(self, "提示", "请至少选择一个视频。") return # 读取主窗口的当前设置 selected_fmt = self._video_format_combo.currentData() is_audio_only = False if (selected_fmt and isinstance(selected_fmt, VideoFormat) and selected_fmt.is_audio_only): is_audio_only = True output_dir = ( self._settings.download_dir or str(Path.home() / "Downloads" / "YouTube") ) tasks = [] for i, video_info in enumerate(selected_videos): task = DownloadTask( url=video_info.webpage_url, video_info=video_info, is_playlist=True, ) # 应用主窗口的画质/格式选择 if selected_fmt and isinstance(selected_fmt, VideoFormat): task.selected_format = selected_fmt # 应用主窗口的下载选项 task.download_video = not is_audio_only task.download_audio = is_audio_only task.download_subtitle = self._subtitle_cb.isChecked() task.download_thumbnail = self._thumbnail_cb.isChecked() task.subtitle_auto = self._settings.auto_subtitle task.subtitle_language = self._settings.default_subtitle_lang task.subtitle_format = self._settings.default_subtitle_format task.output_dir = output_dir if self._settings.proxy: task.extra_data["proxy"] = self._settings.proxy if self._settings.rate_limit: task.extra_data["rate_limit"] = self._settings.rate_limit if self._settings.cookies_file: task.extra_data["cookies_file"] = self._settings.cookies_file elif self._settings.cookies_from_browser: task.extra_data["cookies_from_browser"] = self._settings.cookies_from_browser tasks.append(task) # 批量添加 self._download_queue.add_tasks(tasks) # 刷新进度表 self._refresh_progress_table() # 启动队列 self._ensure_queue_running() self._status_bar.showMessage( f"已添加 {len(tasks)} 个下载任务" ) def _on_batch_download(self) -> None: """批量下载对话框 支持两种模式: 1. 粘贴多个视频 URL(每行一个) 2. 粘贴播放列表链接,自动解析全部视频 解析后展示视频列表,支持勾选、配置参数,一键批量下载。 """ from PySide6.QtWidgets import ( QDialog, QTextEdit, QDialogButtonBox, QSpinBox, ) from PySide6.QtCore import QThread, Signal # ===== 后台解析线程 ===== class ParseThread(QThread): """后台解析播放列表的线程""" result_signal = Signal(list) # [(url, title, author, duration_str), ...] error_signal = Signal(str) def __init__(self, raw_text: str, cookies: str = "", cookies_file: str = ""): super().__init__() self._raw_text = raw_text self._cookies = cookies self._cookies_file = cookies_file def run(self) -> None: results = [] lines = [l.strip() for l in self._raw_text.split("\n") if l.strip()] for line in lines: valid, vid, is_playlist = validate_youtube_url(line) if not valid: continue if is_playlist: # 播放列表:解析所有视频 try: pl = PlaylistDownloader(self._cookies, self._cookies_file) videos = pl.fetch_playlist_info(line) for v in videos: results.append(( v.webpage_url or f"https://youtu.be/{v.title}", v.title, v.author, v.duration_str, )) except Exception as e: self.error_signal.emit(f"播放列表解析失败: {e}") else: # 单个视频:先获取基本信息 try: parser = FormatParser(self._cookies, self._cookies_file) info = parser.fetch_video_info(line) if info: results.append(( line, info.title, info.author, info.duration_str, )) else: results.append((line, "(获取中...)", "", "")) except Exception: results.append((line, "(获取失败)", "", "")) self.result_signal.emit(results) # ===== 构建对话框 ===== dialog = QDialog(self) dialog.setWindowTitle("批量下载") dialog.setMinimumSize(750, 600) layout = QVBoxLayout(dialog) layout.setSpacing(8) # ---- 输入区 ---- input_label = QLabel( "粘贴视频链接(每行一个)或播放列表链接,然后点击「解析链接」:" ) layout.addWidget(input_label) text_edit = QTextEdit() text_edit.setPlaceholderText( "https://www.youtube.com/watch?v=xxxxx\n" "https://youtu.be/yyyyy\n" "https://www.youtube.com/playlist?list=zzzzz\n" "..." ) text_edit.setMaximumHeight(120) layout.addWidget(text_edit) # ---- 解析按钮 ---- parse_btn = QPushButton("🔍 解析链接") parse_btn.setFixedHeight(34) layout.addWidget(parse_btn) # ---- 结果表格 ---- result_table = QTableWidget() result_table.setColumnCount(4) result_table.setHorizontalHeaderLabels(["", "标题", "作者", "时长"]) result_table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows) result_table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers) result_table.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch) result_table.setColumnWidth(0, 40) result_table.setColumnWidth(2, 120) result_table.setColumnWidth(3, 70) result_table.setAlternatingRowColors(True) layout.addWidget(result_table) # ---- 表格工具栏 ---- table_toolbar = QHBoxLayout() select_all_btn = QPushButton("全选") select_all_btn.setFixedWidth(60) deselect_all_btn = QPushButton("取消全选") deselect_all_btn.setFixedWidth(80) count_label = QLabel("共 0 个视频") table_toolbar.addWidget(select_all_btn) table_toolbar.addWidget(deselect_all_btn) table_toolbar.addStretch() table_toolbar.addWidget(count_label) layout.addLayout(table_toolbar) # ---- 下载选项提示(使用主窗口设置) ---- options_label = QLabel( "下载参数使用主窗口设置:画质/格式/字幕/封面/音频等。\n" "请先在主窗口选择好格式和选项,再使用批量下载。" ) options_label.setStyleSheet("color: #2196F3; font-size: 12px; padding: 4px;") layout.addWidget(options_label) thread_layout = QHBoxLayout() thread_layout.addWidget(QLabel("批量线程数:")) thread_spin = QSpinBox() thread_spin.setRange(1, 32) thread_spin.setValue(self._settings.max_workers) thread_spin.setFixedWidth(60) thread_layout.addWidget(thread_spin) thread_layout.addStretch() layout.addLayout(thread_layout) # ---- 底部按钮 ---- btn_layout = QHBoxLayout() download_btn = QPushButton("⬇ 开始批量下载") download_btn.setEnabled(False) download_btn.setFixedHeight(36) close_btn = QPushButton("关闭") close_btn.setFixedHeight(36) btn_layout.addStretch() btn_layout.addWidget(close_btn) btn_layout.addWidget(download_btn) layout.addLayout(btn_layout) # ---- 存储解析结果 ---- parsed_urls: list = [] # [(url, title, author, duration_str), ...] # ---- 信号连接 ---- def on_parse(): raw_text = text_edit.toPlainText().strip() if not raw_text: QMessageBox.warning(dialog, "提示", "请输入至少一个链接。") return parse_btn.setEnabled(False) parse_btn.setText("⏳ 正在解析...") result_table.setRowCount(0) parsed_urls.clear() self._parse_thread = ParseThread( raw_text, cookies=self._settings.cookies_from_browser, cookies_file=self._settings.cookies_file, ) def on_result(results): nonlocal parsed_urls parsed_urls = results result_table.setRowCount(len(results)) for i, (url, title, author, duration) in enumerate(results): cb = QTableWidgetItem() cb.setFlags(Qt.ItemFlag.ItemIsUserCheckable | Qt.ItemFlag.ItemIsEnabled) cb.setCheckState(Qt.CheckState.Checked) result_table.setItem(i, 0, cb) result_table.setItem(i, 1, QTableWidgetItem(title)) result_table.setItem(i, 2, QTableWidgetItem(author)) result_table.setItem(i, 3, QTableWidgetItem(duration)) count_label.setText(f"共 {len(results)} 个视频") download_btn.setEnabled(len(results) > 0) parse_btn.setEnabled(True) parse_btn.setText("🔍 解析链接") def on_error(msg): parse_btn.setEnabled(True) parse_btn.setText("🔍 解析链接") QMessageBox.warning(dialog, "解析错误", msg) self._parse_thread.result_signal.connect(on_result) self._parse_thread.error_signal.connect(on_error) self._parse_thread.start() parse_btn.clicked.connect(on_parse) select_all_btn.clicked.connect(lambda: [ result_table.item(i, 0).setCheckState(Qt.CheckState.Checked) for i in range(result_table.rowCount()) if result_table.item(i, 0) ]) deselect_all_btn.clicked.connect(lambda: [ result_table.item(i, 0).setCheckState(Qt.CheckState.Unchecked) for i in range(result_table.rowCount()) if result_table.item(i, 0) ]) close_btn.clicked.connect(dialog.reject) def on_download(): selected = [] for i in range(result_table.rowCount()): cb = result_table.item(i, 0) if cb and cb.checkState() == Qt.CheckState.Checked and i < len(parsed_urls): selected.append(parsed_urls[i]) if not selected: QMessageBox.warning(dialog, "提示", "请至少勾选一个视频。") return # 读取主窗口当前设置 selected_fmt = self._video_format_combo.currentData() is_audio_only = False if (selected_fmt and isinstance(selected_fmt, VideoFormat) and selected_fmt.is_audio_only): is_audio_only = True output_dir = ( self._settings.download_dir or str(Path.home() / "Downloads" / "YouTube") ) tasks = [] for url, title, author, duration in selected: task = DownloadTask(url=url) task.video_info = VideoInfo( title=title, author=author, webpage_url=url, ) # 应用主窗口的画质/格式选择 if selected_fmt and isinstance(selected_fmt, VideoFormat): task.selected_format = selected_fmt # 应用主窗口的下载选项 task.download_video = not is_audio_only task.download_audio = is_audio_only task.download_subtitle = self._subtitle_cb.isChecked() task.download_thumbnail = self._thumbnail_cb.isChecked() task.subtitle_auto = self._settings.auto_subtitle task.subtitle_language = self._settings.default_subtitle_lang task.subtitle_format = self._settings.default_subtitle_format task.output_dir = output_dir if self._settings.proxy: task.extra_data["proxy"] = self._settings.proxy if self._settings.rate_limit: task.extra_data["rate_limit"] = self._settings.rate_limit if self._settings.cookies_file: task.extra_data["cookies_file"] = self._settings.cookies_file elif self._settings.cookies_from_browser: task.extra_data["cookies_from_browser"] = self._settings.cookies_from_browser tasks.append(task) # 应用线程数 self._download_queue.max_workers = thread_spin.value() self._download_queue.add_tasks(tasks) self._refresh_progress_table() self._ensure_queue_running() self._status_bar.showMessage(f"已添加 {len(tasks)} 个批量下载任务") QMessageBox.information( dialog, "批量下载", f"已添加 {len(tasks)} 个下载任务到队列!\n\n" "可在主窗口下方下载队列中查看进度。" ) download_btn.clicked.connect(on_download) dialog.exec() def _ensure_queue_running(self) -> None: """确保下载队列正在运行""" if not self._download_queue.is_running: self._download_queue.max_workers = self._settings.max_workers self._download_queue.start(self._execute_download) def _execute_download(self, task: DownloadTask) -> bool: """执行单个下载任务(由队列线程调用) 每个任务创建独立的 VideoDownloader 实例,避免多线程竞态。 Args: task: 下载任务 Returns: 下载是否成功 """ # 每个任务使用独立的下载器,避免多线程共享导致竞态 downloader = VideoDownloader(self._settings.ffmpeg_path) # 设置进度回调,让 task.progress 随下载实时更新(UI 定时器读取) def update_progress(progress: DownloadProgress, message: str) -> None: task.progress = progress downloader.set_progress_hook(update_progress) with self._downloaders_lock: self._active_downloaders[task.task_id] = downloader try: # 执行下载 success = downloader.download_video(task) finally: # 清理 with self._downloaders_lock: self._active_downloaders.pop(task.task_id, None) # 下载字幕(字幕下载器是线程安全的,仅做 HTTP 请求) if task.download_subtitle and task.video_info: output_dir = task.output_dir or str( Path.home() / "Downloads" / "YouTube" ) try: self._subtitle_downloader.download_subtitle( task.url, output_dir, language=task.subtitle_language, subtitle_format=task.subtitle_format, auto_subtitle=task.subtitle_auto, output_filename=sanitize_filename(task.video_info.title), ) except Exception as e: logger.warning(f"字幕下载失败: {e}") # 下载封面 if task.download_thumbnail and task.video_info: output_dir = task.output_dir or str( Path.home() / "Downloads" / "YouTube" ) try: self._thumbnail_downloader.download_thumbnail( task.url, output_dir, output_format=task.thumbnail_format, output_filename=sanitize_filename(task.video_info.title), ) except Exception as e: logger.warning(f"封面下载失败: {e}") return success def _on_download_progress( self, task: DownloadTask, progress: DownloadProgress, message: str, ) -> None: """下载进度回调(在下载线程中调用) Args: task: 下载任务 progress: 进度信息 message: 状态消息 """ # 使用信号安全地更新 UI (通过定时器轮询) pass # UI 由 _progress_timer 定期刷新 # ========== 播放列表操作 ========== def _populate_playlist_table(self, videos: List[VideoInfo]) -> None: """填充播放列表表格 Args: videos: 视频信息列表 """ table = self._playlist_table table.setRowCount(len(videos)) for i, video in enumerate(videos): # 复选框 cb_item = QTableWidgetItem() cb_item.setFlags( Qt.ItemFlag.ItemIsUserCheckable | Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable ) cb_item.setCheckState(Qt.CheckState.Checked) table.setItem(i, 0, cb_item) # 序号 table.setItem(i, 1, QTableWidgetItem(str(i + 1))) # 标题 table.setItem(i, 2, QTableWidgetItem(video.title)) # 作者 table.setItem(i, 3, QTableWidgetItem(video.author)) # 时长 table.setItem(i, 4, QTableWidgetItem(video.duration_str)) def _get_selected_playlist_videos(self) -> List[VideoInfo]: """获取播放列表中被勾选的视频 Returns: 被选中的视频信息列表 """ selected = [] for i in range(self._playlist_table.rowCount()): cb_item = self._playlist_table.item(i, 0) if cb_item and cb_item.checkState() == Qt.CheckState.Checked: if i < len(self._playlist_videos): selected.append(self._playlist_videos[i]) return selected def _on_select_all(self) -> None: """全选播放列表""" for i in range(self._playlist_table.rowCount()): item = self._playlist_table.item(i, 0) if item: item.setCheckState(Qt.CheckState.Checked) def _on_deselect_all(self) -> None: """取消全选播放列表""" for i in range(self._playlist_table.rowCount()): item = self._playlist_table.item(i, 0) if item: item.setCheckState(Qt.CheckState.Unchecked) def _on_download_selected(self) -> None: """下载选中的播放列表视频""" self._start_playlist_download() # ========== 进度表操作 ========== def _refresh_progress_table(self) -> None: """刷新进度列表显示""" tasks = self._download_queue.get_all_tasks() table = self._progress_table table.setRowCount(len(tasks)) for i, task in enumerate(tasks): # 任务名称 title = task.video_info.title if task.video_info else task.url[:50] table.setItem(i, 0, QTableWidgetItem(title)) # 状态 status_item = QTableWidgetItem(task.status.value) if task.status == TaskStatus.COMPLETED: status_item.setForeground(QColor("#4CAF50")) elif task.status == TaskStatus.FAILED: status_item.setForeground(QColor("#F44336")) elif task.status in (TaskStatus.DOWNLOADING, TaskStatus.MERGING): status_item.setForeground(QColor("#2196F3")) elif task.status == TaskStatus.CANCELLED: status_item.setForeground(QColor("#FF9800")) table.setItem(i, 1, status_item) # 速度 table.setItem(i, 2, QTableWidgetItem(task.progress.speed_str)) # 已下载/总大小 size_text = f"{task.progress.downloaded_str} / {task.progress.total_str}" table.setItem(i, 3, QTableWidgetItem(size_text)) # 进度条 progress_widget = QProgressBar() progress_widget.setRange(0, 100) progress_widget.setValue(int(task.progress.percent)) progress_widget.setTextVisible(True) progress_widget.setFormat(f"{task.progress.percent:.1f}%") table.setCellWidget(i, 4, progress_widget) # 操作按钮 if task.status in (TaskStatus.DOWNLOADING, TaskStatus.MERGING): cancel_btn = QPushButton("取消") cancel_btn.setFixedSize(60, 24) cancel_btn.clicked.connect( lambda checked, tid=task.task_id: self._cancel_single_task(tid) ) table.setCellWidget(i, 5, cancel_btn) elif task.status == TaskStatus.FAILED: retry_btn = QPushButton("重试") retry_btn.setFixedSize(60, 24) retry_btn.clicked.connect( lambda checked, tid=task.task_id: self._retry_single_task(tid) ) table.setCellWidget(i, 5, retry_btn) elif task.status == TaskStatus.COMPLETED: table.setItem(i, 5, QTableWidgetItem("✅")) else: table.setItem(i, 5, QTableWidgetItem("-")) @Slot() def _refresh_progress_display(self) -> None: """定时刷新进度显示(由 QTimer 触发)""" try: if self._download_queue.task_count > 0: self._refresh_progress_table() except Exception: pass # 防止定时器回调异常导致崩溃 def _cancel_single_task(self, task_id: str) -> None: """取消单个任务 Args: task_id: 任务 ID """ # 取消对应的下载器 downloader = self._active_downloaders.get(task_id) if downloader: downloader.cancel() self._download_queue.cancel_task(task_id) self._status_bar.showMessage(f"已取消任务: {task_id}") def _retry_single_task(self, task_id: str) -> None: """重试单个任务 Args: task_id: 任务 ID """ task = self._download_queue.get_task(task_id) if task: task.reset_progress() self._download_queue.add_task(task) self._ensure_queue_running() self._status_bar.showMessage(f"正在重试: {task_id}") def _on_pause_all(self) -> None: """全部暂停""" with self._downloaders_lock: downloaders = list(self._active_downloaders.values()) for downloader in downloaders: downloader.pause() self._status_bar.showMessage("已暂停所有下载") def _on_resume_all(self) -> None: """全部恢复""" with self._downloaders_lock: downloaders = list(self._active_downloaders.values()) for downloader in downloaders: downloader.resume() self._status_bar.showMessage("已恢复下载") def _on_cancel_all(self) -> None: """全部取消""" reply = QMessageBox.question( self, "确认取消", "确定要取消所有下载任务吗?", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, ) if reply == QMessageBox.StandardButton.Yes: with self._downloaders_lock: downloaders = list(self._active_downloaders.values()) for downloader in downloaders: downloader.cancel() self._download_queue.stop() self._refresh_progress_table() self._status_bar.showMessage("已取消所有任务") def _on_clear_completed(self) -> None: """清空已完成的任务""" count = self._download_queue.clear_completed() self._refresh_progress_table() self._status_bar.showMessage(f"已清除 {count} 个已完成任务") def _on_retry_failed(self) -> None: """重试所有失败的任务""" count = self._download_queue.retry_failed(self._execute_download) if count > 0: self._ensure_queue_running() self._status_bar.showMessage(f"正在重试 {count} 个失败任务") else: self._status_bar.showMessage("没有失败的任务需要重试") # ========== 回调 ========== def _on_task_started(self, task: DownloadTask) -> None: """任务开始回调""" pass # UI 由定时器刷新 def _on_task_completed(self, task: DownloadTask) -> None: """任务完成回调""" self._status_bar.showMessage( f"✅ 下载完成: {task.video_info.title[:40] if task.video_info else task.task_id}", 5000, ) def _on_task_failed(self, task: DownloadTask) -> None: """任务失败回调""" self._status_bar.showMessage( f"❌ 下载失败: {task.video_info.title[:40] if task.video_info else task.task_id}", 8000, ) def _on_all_completed(self) -> None: """全部任务完成回调""" QMessageBox.information( self, "下载完成", "所有下载任务已完成!" ) self._status_bar.showMessage("全部下载任务已完成!") # ========== UI 更新辅助方法 ========== def _display_video_info(self, info: VideoInfo) -> None: """在视频页面显示视频信息 Args: info: 视频信息对象 """ self._title_label.setText(info.title) self._author_label.setText(info.author) self._duration_label.setText(info.duration_str) self._upload_date_label.setText(info.upload_date_str) def _populate_format_combos(self, formats: List[VideoFormat]) -> None: """填充格式下拉框 FFmpeg 可用时:所有格式可选,视频优先 FFmpeg 不可用时:优先显示含音频的合并格式,标记纯视频格式 Args: formats: 可用格式列表 """ ffmpeg_ok = self._ffmpeg_merger.is_available # ===== 视频格式 ===== self._video_format_combo.clear() # 分类 combined = [f for f in formats if f.has_video and f.has_audio] video_only = [f for f in formats if f.has_video and not f.has_audio] if ffmpeg_ok: # FFmpeg 可用:所有格式自由选择(按分辨率排序) all_video = sorted( combined + video_only, key=lambda f: (f.resolution_int, f.has_audio) ) for fmt in all_video: self._video_format_combo.addItem(fmt.display_name, fmt) else: # FFmpeg 不可用:合并格式优先,纯视频格式标为不可用 for fmt in combined: self._video_format_combo.addItem(fmt.display_name, fmt) if video_only: # 添加分隔线和标记 self._video_format_combo.insertSeparator( self._video_format_combo.count() ) for fmt in video_only: label = f"{fmt.display_name} ⚠ (需要 FFmpeg 合并)" self._video_format_combo.addItem(label, fmt) # 如果没有任何格式 if self._video_format_combo.count() == 0: for fmt in formats: if fmt.has_video: self._video_format_combo.addItem(fmt.display_name, fmt) # ===== 音频格式 ===== self._audio_format_combo.clear() audio_formats = [f for f in formats if f.is_audio_only] if audio_formats: # 按比特率降序排列 audio_formats.sort(key=lambda f: f.abr, reverse=True) for fmt in audio_formats: self._audio_format_combo.addItem(fmt.display_name, fmt) else: self._audio_format_combo.addItem("默认最佳音频") # ========== 菜单操作 ========== def _open_settings(self) -> None: """打开设置窗口""" dialog = SettingsWindow(self) if dialog.exec(): # 设置已保存,重新加载 self._settings = self._settings_manager.settings # 更新下载队列配置 self._download_queue.max_workers = self._settings.max_workers # 更新 FFmpeg self._video_downloader = VideoDownloader( self._settings.ffmpeg_path ) self._ffmpeg_merger.ffmpeg_path = self._settings.ffmpeg_path # 重新应用主题 self._apply_theme() # 更新状态栏 self._thread_label.setText( f"线程: {self._settings.max_workers}" ) self._update_ffmpeg_status_label() self._status_bar.showMessage("设置已更新", 3000) def _open_about(self) -> None: """打开关于窗口""" dialog = AboutWindow(self) dialog.exec() def _open_download_dir(self) -> None: """打开下载目录""" download_dir = ( self._settings.download_dir or str(Path.home() / "Downloads" / "YouTube") ) # 确保目录存在 Path(download_dir).mkdir(parents=True, exist_ok=True) QDesktopServices.openUrl(QUrl.fromLocalFile(download_dir)) def _check_ffmpeg_status(self) -> None: """检查并显示 FFmpeg 状态,缺失时提供自动安装选项""" if self._ffmpeg_merger.is_available: QMessageBox.information( self, "FFmpeg 状态", f"FFmpeg 已就绪\n\n路径: {self._ffmpeg_merger.ffmpeg_path}\n\n" "高清视频音视频合并功能可用。" ) else: reply = QMessageBox.question( self, "FFmpeg 未检测到", "FFmpeg 未检测到\n\n" "高清视频 (1080p+) 需要 FFmpeg 合并音视频。\n\n" "是否自动下载安装 FFmpeg?\n" "(约 30MB,需要网络连接)\n\n" "选'否'将手动指定路径。", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, QMessageBox.StandardButton.Yes, ) if reply == QMessageBox.StandardButton.Yes: self._auto_install_ffmpeg() def _auto_install_ffmpeg(self) -> None: """自动下载并安装 FFmpeg 在后台线程中执行下载安装,通过进度对话框显示状态。 安装成功后自动更新设置和状态。 """ from PySide6.QtWidgets import QProgressDialog from PySide6.QtCore import QThread, Signal from pathlib import Path class InstallThread(QThread): progress_signal = Signal(str, float) finished_signal = Signal(bool, str) def __init__(self): super().__init__() self._installer = None def run(self) -> None: try: install_dir = Path.home() / ".youtube_downloader_pro" / "ffmpeg" self._installer = FFmpegInstaller(install_dir) self._installer.set_progress_callback( lambda msg, pct: self.progress_signal.emit(msg, pct) ) success = self._installer.install() if success: self.finished_signal.emit( True, str(self._installer.ffmpeg_exe_path) ) else: self.finished_signal.emit( False, "安装失败,请检查网络连接后重试" ) except Exception as e: self.finished_signal.emit(False, str(e)) def cancel(self) -> None: if self._installer: self._installer.cancel() progress_dialog = QProgressDialog( "准备安装 FFmpeg...", "取消", 0, 100, self, ) progress_dialog.setWindowTitle("安装 FFmpeg") progress_dialog.setMinimumDuration(0) progress_dialog.setAutoClose(False) progress_dialog.setWindowModality(Qt.WindowModality.WindowModal) install_thread = InstallThread() install_thread.progress_signal.connect( lambda msg, pct: ( progress_dialog.setLabelText(msg), progress_dialog.setValue(int(pct)), ) ) def on_finished(success: bool, result: str) -> None: progress_dialog.close() if success: self._settings.ffmpeg_path = result self._settings_manager.save(self._settings) self._ffmpeg_merger.ffmpeg_path = result self._video_downloader = VideoDownloader(result) self._update_ffmpeg_status_label() self._status_bar.showMessage( f"FFmpeg 安装成功!路径: {result}", 8000 ) QMessageBox.information( self, "安装成功", f"FFmpeg 已成功安装!\n\n路径: {result}\n\n" "现在可以下载高清视频并进行音视频合并了。" ) else: self._status_bar.showMessage( f"FFmpeg 安装失败: {result}", 8000 ) QMessageBox.warning( self, "安装失败", f"FFmpeg 自动安装失败:\n\n{result}\n\n" "请手动安装 FFmpeg:\n" "https://ffmpeg.org/download.html\n\n" "或在设置中手动指定 FFmpeg 路径。" ) install_thread.finished_signal.connect(on_finished) progress_dialog.canceled.connect(install_thread.cancel) install_thread.start() def _update_ffmpeg_status_label(self) -> None: """更新状态栏 FFmpeg 图标和提示""" if self._ffmpeg_merger.is_available: self._ffmpeg_status_label.setText("FFmpeg ✅") self._ffmpeg_status_label.setStyleSheet("color: #4CAF50;") self._auto_merge_cb.setEnabled(True) else: self._ffmpeg_status_label.setText("FFmpeg ❌ (点击安装)") self._ffmpeg_status_label.setStyleSheet( "color: #F44336; font-weight: bold;" ) self._auto_merge_cb.setChecked(False) self._auto_merge_cb.setEnabled(False) # 启动时在状态栏提示 self._status_bar.showMessage( "⚠ FFmpeg 未安装 — 高清视频(1080p+)下载受限。点击菜单 帮助→检查 FFmpeg 状态 可自动安装", 10000, )