This commit is contained in:
LZX committed 2026-09-11 16:03:47 +08:00
1 parent 8531403c33
commit b03ece33a2
37 files changed
+6388 -908

No files matched your search

+89 -243
View File
@@ -1,265 +1,111 @@
import 'package:code_editor/models/editor_tab_item.dart';
import 'package:code_editor/models/editor_theme.dart';
import 'package:code_editor/models/file_directory_history.dart';
import 'package:code_editor/models/file_item.dart';
import 'package:code_editor/services/file_directory_history_service.dart';
import 'package:code_editor/services/file_service.dart';
import 'package:file_picker/file_picker.dart';
import 'package:flutter/foundation.dart';
import 'package:path/path.dart' as p;
import 'package:code_editor/providers/project_provider.dart';
import 'package:code_editor/providers/settings_provider.dart';
import 'package:code_editor/providers/tab_provider.dart';
import 'package:flutter/material.dart';
/// 组合门面 Provider,委托给 SettingsProvider, ProjectProvider, TabProvider,
/// 保持向下兼容性与测试透明度。
class EditorProvider extends ChangeNotifier {
FileDirectoryHistory _history = const FileDirectoryHistory(
rootPath: null,
lastOpenedFilePath: "未命名",
);
List<FileItem> _items = [];
bool _isLoading = false;
FileItem? _cutItem;
FileItem? _copiedItem;
final SettingsProvider settingsProvider;
final ProjectProvider projectProvider;
final TabProvider tabProvider;
FileDirectoryHistory get history => _history;
String? get rootPath => _history.rootPath;
String? get currentFilePath => _history.lastOpenedFilePath;
List<String> get openDirectoryPaths => _history.openDirectoryPaths;
List<FileItem> get items => _items;
bool get isLoading => _isLoading;
FileItem? get cutItem => _cutItem;
FileItem? get copiedItem => _copiedItem;
bool get canPaste => _cutItem != null || _copiedItem != null;
bool isFileSelected(String path) {
if (currentFilePath == null) return false;
return currentFilePath == path || currentFilePath!.trim() == path.trim();
EditorProvider({
SettingsProvider? settings,
ProjectProvider? project,
TabProvider? tab,
}) : settingsProvider = settings ?? SettingsProvider(),
projectProvider = project ?? ProjectProvider(),
tabProvider = tab ?? TabProvider() {
tabProvider.bindProjectProvider(projectProvider);
settingsProvider.addListener(notifyListeners);
projectProvider.addListener(notifyListeners);
tabProvider.addListener(notifyListeners);
}
bool isItemCut(String path) {
if (_cutItem == null) return false;
return _cutItem!.path == path || _cutItem!.path.trim() == path.trim();
@override
void dispose() {
settingsProvider.removeListener(notifyListeners);
projectProvider.removeListener(notifyListeners);
tabProvider.removeListener(notifyListeners);
super.dispose();
}
Future<void> init() async {
await _loadProjectFromHistory();
await settingsProvider.init();
await projectProvider.init();
await tabProvider.init();
}
Future<void> _loadProjectFromHistory() async {
_isLoading = true;
notifyListeners();
// =================== Settings Provider Getters & Methods ===================
EditorTheme get editorTheme => settingsProvider.editorTheme;
ThemeMode get appThemeMode => settingsProvider.appThemeMode;
double get fontSize => settingsProvider.fontSize;
bool get wordWrap => settingsProvider.wordWrap;
Locale? get locale => settingsProvider.locale;
try {
final lastHistory = await FileDirectoryHistoryService.instance.getLastHistory();
if (lastHistory == null) {
_isLoading = false;
notifyListeners();
return;
}
Future<void> setEditorTheme(EditorTheme theme) => settingsProvider.setEditorTheme(theme);
Future<void> setAppThemeMode(ThemeMode mode) => settingsProvider.setAppThemeMode(mode);
Future<void> setFontSize(double size) => settingsProvider.setFontSize(size);
Future<void> setWordWrap(bool wrap) => settingsProvider.setWordWrap(wrap);
Future<void> setLocale(Locale? newLocale) => settingsProvider.setLocale(newLocale);
final path = lastHistory.rootPath;
final cleanPath = (path != null && path.trim().isNotEmpty) ? p.normalize(path.trim()) : null;
final validOpenPaths = cleanPath == null
? <String>[]
: lastHistory.openDirectoryPaths
.map((e) => p.normalize(e.trim()))
.where((e) => e != cleanPath && p.isWithin(cleanPath, e))
.toList();
// =================== Project Provider Getters & Methods ===================
FileDirectoryHistory get history => projectProvider.history;
String? get rootPath => projectProvider.rootPath;
List<String> get openDirectoryPaths => projectProvider.openDirectoryPaths;
List<FileItem> get items => projectProvider.items;
bool get isLoading => projectProvider.isLoading;
FileItem? get cutItem => projectProvider.cutItem;
FileItem? get copiedItem => projectProvider.copiedItem;
bool get canPaste => projectProvider.canPaste;
List<FileItem> items = cleanPath != null
? await FileService.instance.buildTree(
cleanPath,
openDirectoryPaths: validOpenPaths,
)
: [];
bool isItemCut(String path) => projectProvider.isItemCut(path);
Future<void> openDirectory() => projectProvider.openDirectory();
Future<void> switchProject(FileDirectoryHistory selectedHistory) => projectProvider.switchProject(selectedHistory);
Future<void> toggleDirectory(FileItem item, bool expanded) => projectProvider.toggleDirectory(item, expanded);
Future<void> refreshTree() => projectProvider.refreshTree();
void cut(FileItem item) => projectProvider.cut(item);
void copy(FileItem item) => projectProvider.copy(item);
Future<void> paste(FileItem targetDir) => projectProvider.paste(targetDir);
Future<void> createFile(String parentDir, String name) => projectProvider.createFile(parentDir, name);
Future<void> createDirectory(String parentDir, String name) => projectProvider.createDirectory(parentDir, name);
Future<void> rename(FileItem item, String newName) => projectProvider.rename(item, newName);
Future<void> delete(FileItem item) => projectProvider.delete(item);
_items = items;
_history = FileDirectoryHistory(
rootPath: cleanPath,
lastOpenedFilePath: lastHistory.lastOpenedFilePath,
openDirectoryPaths: validOpenPaths,
);
} catch (e) {
debugPrint('加载项目历史失败: $e');
} finally {
_isLoading = false;
notifyListeners();
}
@visibleForTesting
void setHistoryForTesting(FileDirectoryHistory history) {
// ignore: invalid_use_of_visible_for_testing_member
projectProvider.setHistoryForTesting(history);
}
Future<void> openDirectory() async {
try {
final String? selectedPath = await FilePicker.platform.getDirectoryPath();
if (selectedPath == null || selectedPath.trim().isEmpty) {
return;
}
// =================== Tab Provider Getters & Methods ===================
List<EditorTabItem> get openTabs => tabProvider.openTabs;
EditorTabItem? get activeTab => tabProvider.activeTab;
String? get currentFilePath => tabProvider.currentFilePath;
bool get isModified => tabProvider.isModified;
final cleanPath = p.normalize(selectedPath.trim());
final currentRoot = _history.rootPath != null ? p.normalize(_history.rootPath!) : null;
final isSameRoot = currentRoot != null && cleanPath == currentRoot;
bool isFileSelected(String path) => tabProvider.isFileSelected(path);
Future<void> selectFile(FileItem item) => tabProvider.selectFile(item);
Future<void> openFile(String path, {String? content}) => tabProvider.openFile(path, content: content);
Future<bool> closeTab(BuildContext context, int index) => tabProvider.closeTab(context, index);
Future<void> reorderTabs(int oldIndex, int newIndex) => tabProvider.reorderTabs(oldIndex, newIndex);
Future<bool> saveTab(EditorTabItem tab) => tabProvider.saveTab(tab);
Future<bool> saveCurrentFile() => tabProvider.saveCurrentFile();
Future<bool> saveAllFiles() => tabProvider.saveAllFiles();
Future<bool> checkUnsavedChanges(BuildContext context) => tabProvider.checkUnsavedChanges(context);
void registerSaveHandler(Future<bool> Function()? handler) => tabProvider.registerSaveHandler(handler);
void setModified(bool modified) => tabProvider.setModified(modified);
void updateActiveTabContent(String content, {bool? isModified}) =>
tabProvider.updateActiveTabContent(content, isModified: isModified);
await FileDirectoryHistoryService.instance.recordHistory(
rootPath: cleanPath,
lastOpenedFilePath: isSameRoot ? _history.lastOpenedFilePath : null,
openDirectoryPaths: isSameRoot ? _history.openDirectoryPaths : const [],
);
_cutItem = null;
_copiedItem = null;
await _loadProjectFromHistory();
} catch (e) {
debugPrint('打开文件夹失败: $e');
}
}
Future<void> switchProject(FileDirectoryHistory selectedHistory) async {
final selectedRoot = selectedHistory.rootPath;
if (selectedRoot == null || selectedRoot.trim().isEmpty) return;
await FileDirectoryHistoryService.instance.recordHistory(
rootPath: selectedRoot,
lastOpenedFilePath: selectedHistory.lastOpenedFilePath,
openDirectoryPaths: selectedHistory.openDirectoryPaths,
);
_cutItem = null;
_copiedItem = null;
await _loadProjectFromHistory();
}
Future<void> selectFile(FileItem item) async {
if (item.isDirectory) return;
final cleanPath = _history.rootPath;
if (cleanPath != null) {
await FileDirectoryHistoryService.instance.recordHistory(
rootPath: cleanPath,
lastOpenedFilePath: item.path,
openDirectoryPaths: _history.openDirectoryPaths,
);
_history = FileDirectoryHistory(
rootPath: cleanPath,
lastOpenedFilePath: item.path,
openDirectoryPaths: _history.openDirectoryPaths,
);
notifyListeners();
}
}
Future<void> toggleDirectory(FileItem item, bool expanded) async {
final cleanPath = _history.rootPath;
if (cleanPath == null) return;
final updatedOpenPaths = List<String>.from(_history.openDirectoryPaths);
if (expanded) {
if (!updatedOpenPaths.contains(item.path)) {
updatedOpenPaths.add(item.path);
}
if (item.children.isEmpty) {
final children = await FileService.instance.buildTree(
item.path,
depth: item.depth + 1,
openDirectoryPaths: updatedOpenPaths,
);
item.children.clear();
item.children.addAll(children);
}
} else {
updatedOpenPaths.remove(item.path);
}
await FileDirectoryHistoryService.instance.recordHistory(
rootPath: cleanPath,
lastOpenedFilePath: _history.lastOpenedFilePath,
openDirectoryPaths: updatedOpenPaths,
);
_history = FileDirectoryHistory(
rootPath: cleanPath,
lastOpenedFilePath: _history.lastOpenedFilePath,
openDirectoryPaths: updatedOpenPaths,
);
notifyListeners();
}
Future<void> refreshTree() async {
final currentRoot = _history.rootPath;
if (currentRoot == null || currentRoot.trim().isEmpty) return;
try {
final items = await FileService.instance.buildTree(
currentRoot,
openDirectoryPaths: _history.openDirectoryPaths,
);
String? currentFile = _history.lastOpenedFilePath;
if (currentFile != null) {
final exists = await FileService.instance.entityExists(currentFile);
if (!exists) {
currentFile = null;
await FileDirectoryHistoryService.instance.recordHistory(
rootPath: currentRoot,
lastOpenedFilePath: null,
openDirectoryPaths: _history.openDirectoryPaths,
);
}
}
_items = items;
if (currentFile != _history.lastOpenedFilePath) {
_history = FileDirectoryHistory(
rootPath: currentRoot,
lastOpenedFilePath: currentFile,
openDirectoryPaths: _history.openDirectoryPaths,
);
}
notifyListeners();
} catch (e) {
debugPrint('刷新目录树失败: $e');
}
}
void cut(FileItem item) {
_cutItem = item;
_copiedItem = null;
notifyListeners();
}
void copy(FileItem item) {
_copiedItem = item;
_cutItem = null;
notifyListeners();
}
Future<void> paste(FileItem targetDir) async {
if (!targetDir.isDirectory) return;
if (_cutItem != null) {
final source = _cutItem!;
await FileService.instance.moveEntity(source.path, targetDir.path);
_cutItem = null;
await refreshTree();
} else if (_copiedItem != null) {
final source = _copiedItem!;
await FileService.instance.copyEntity(source.path, targetDir.path);
await refreshTree();
}
}
Future<void> createFile(String parentDir, String name) async {
final targetPath = p.join(parentDir, name.trim());
await FileService.instance.createFile(targetPath);
await refreshTree();
}
Future<void> createDirectory(String parentDir, String name) async {
final targetPath = p.join(parentDir, name.trim());
await FileService.instance.createDirectory(targetPath);
await refreshTree();
}
Future<void> rename(FileItem item, String newName) async {
await FileService.instance.renameEntity(item.path, newName.trim());
await refreshTree();
}
Future<void> delete(FileItem item) async {
await FileService.instance.deleteEntity(item.path);
await refreshTree();
@visibleForTesting
void setOpenTabsForTesting(List<EditorTabItem> tabs, {String? activePath}) {
// ignore: invalid_use_of_visible_for_testing_member
tabProvider.setOpenTabsForTesting(tabs, activePath: activePath);
}
}