use clipboard_rs::common::{RustImage, RustImageData};
use clipboard_rs::{Clipboard, ClipboardContext};
use eframe::egui;
use egui::collapsing_header::CollapsingState;
use egui::{Color32, Id, Rect, RichText, TextureHandle, Ui};
use font_kit::{family_name::FamilyName, handle::Handle, properties::Properties, source::SystemSource};
use image::DynamicImage;
use image::EncodableLayout;
use rodio::{DeviceSinkBuilder, MixerDeviceSink, Player, play};
use serde_json::{Map, Number, Value};
use std::collections::HashMap;
use std::collections::VecDeque;
use std::fs;
use std::io::Cursor;
use std::path::PathBuf;
use std::sync::mpsc::{Receiver, TryRecvError, channel};
use std::sync::Arc;
use std::thread;
use std::time::{Duration, Instant};
use wz_reader::property::{Vector2D, WzSubProperty, WzValue};
use wz_reader::util::node_util;
use wz_reader::util::resolve_base;
use wz_reader::{WzNodeArc, WzObjectType};
const MAX_JSON_NODES: usize = 4000;
const IMAGE_CACHE_CAP: usize = 48;
const MAX_VISIBLE_CHILDREN: usize = 500;
const TREE_WIDTH_DEFAULT: f32 = 320.0;
const TREE_WIDTH_MIN: f32 = 180.0;
const RIGHT_MIN_WIDTH: f32 = 320.0;
const SPLITTER_WIDTH: f32 = 6.0;
const TREE_WIDTH_FILE: &str = "wz_editor_tree_width.txt";
fn load_tree_width() -> f32 {
let path = std::env::temp_dir().join(TREE_WIDTH_FILE);
let Ok(text) = std::fs::read_to_string(path) else {
return TREE_WIDTH_DEFAULT;
};
text.trim().parse::<f32>().unwrap_or(TREE_WIDTH_DEFAULT)
}
fn save_tree_width(width: f32) {
let path = std::env::temp_dir().join(TREE_WIDTH_FILE);
let _ = std::fs::write(path, format!("{width:.0}"));
}
fn main() -> eframe::Result {
let options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default().with_inner_size([1280.0, 800.0]),
..Default::default()
};
eframe::run_native(
"WZ 浏览器 / wz_editor",
options,
Box::new(|cc| {
load_system_font(&cc.egui_ctx);
Ok(Box::<WzEditorApp>::default())
}),
)
}
fn load_system_font(ctx: &egui::Context) {
const FONT_NAME: &str = "SystemCJK";
let candidates = [
"Microsoft YaHei",
"PingFang SC",
"SimSun",
"Noto Sans CJK SC",
];
let mut font_bytes: Option<Vec<u8>> = None;
for family in candidates {
let Ok(handle) = SystemSource::new().select_best_match(
&[FamilyName::Title(family.to_string())],
&Properties::new(),
) else {
continue;
};
match handle {
Handle::Memory { bytes, .. } => font_bytes = Some(bytes.to_vec()),
Handle::Path { path, .. } => font_bytes = fs::read(path).ok(),
}
if font_bytes.is_some() {
break;
}
}
let Some(font_bytes) = font_bytes else {
return;
};
let mut fonts = egui::FontDefinitions::empty();
fonts
.font_data
.insert(FONT_NAME.to_owned(), Arc::new(egui::FontData::from_owned(font_bytes)));
for family in [egui::FontFamily::Proportional, egui::FontFamily::Monospace] {
fonts
.families
.entry(family)
.or_default()
.push(FONT_NAME.to_owned());
}
ctx.set_fonts(fonts);
}
fn wz_value_to_json(value: &WzValue) -> Value {
match value {
WzValue::Null => Value::Null,
WzValue::Short(value) => Value::from(*value),
WzValue::Int(value) => Value::from(*value),
WzValue::Long(value) => Value::from(*value),
WzValue::Float(value) => number_from_f64(*value as f64),
WzValue::Double(value) => number_from_f64(*value),
WzValue::Vector(Vector2D(x, y)) => {
let mut map = Map::new();
map.insert("x".to_string(), Value::from(*x));
map.insert("y".to_string(), Value::from(*y));
Value::Object(map)
}
WzValue::UOL(value) | WzValue::String(value) => {
Value::String(value.get_string().unwrap_or_default())
}
WzValue::ParsedString(value) => Value::String(value.clone()),
WzValue::RawData(_) => Value::String("<raw data>".to_string()),
WzValue::Video(_) => Value::String("<video>".to_string()),
WzValue::Lua(_) => Value::String("<lua>".to_string()),
}
}
fn number_from_f64(value: f64) -> Value {
match Number::from_f64(value) {
Some(number) => Value::Number(number),
None => Value::Null,
}
}
fn walk_node_to_json(node_arc: &WzNodeArc, json: &mut Map<String, Value>, budget: &mut usize) {
if *budget == 0 {
return;
}
*budget -= 1;
if node_util::parse_node(node_arc).is_err() {
let name = node_arc.read().unwrap().name.as_str().to_string();
json.insert(name, Value::String("<parse error>".to_string()));
return;
}
let (name, children, object_type) = {
let node = node_arc.read().unwrap();
(
node.name.as_str().to_string(),
node.children.values().cloned().collect::<Vec<WzNodeArc>>(),
node.object_type.clone(),
)
};
match object_type {
WzObjectType::Value(value) => {
json.insert(name, wz_value_to_json(&value));
}
WzObjectType::Property(WzSubProperty::PNG(png)) => {
json.insert(
name,
Value::String(format!(
"<png {}x{} {:?}>",
png.width,
png.height,
png.format()
)),
);
}
WzObjectType::Property(WzSubProperty::Sound(sound)) => {
json.insert(
name,
Value::String(format!("<sound {:?} {}ms>", sound.sound_type, sound.duration)),
);
}
WzObjectType::Property(WzSubProperty::Convex) => {
json.insert(name, Value::String("<convex>".to_string()));
}
_ => {
if children.is_empty() {
json.insert(name, Value::Null);
return;
}
let mut child_json = Map::new();
for child in &children {
walk_node_to_json(child, &mut child_json, budget);
}
json.insert(name, Value::Object(child_json));
}
}
}
fn node_to_json(node_arc: &WzNodeArc) -> String {
let mut json = Map::new();
let mut budget = MAX_JSON_NODES;
{
let children: Vec<WzNodeArc> = node_arc.read().unwrap().children.values().cloned().collect();
for child in &children {
walk_node_to_json(child, &mut json, &mut budget);
}
}
let mut text = serde_json::to_string_pretty(&Value::Object(json)).unwrap_or_default();
if budget == 0 {
text.push_str("\n…(节点过多,已截断)");
}
text
}
fn type_of<T>(_: &T) -> String {
std::any::type_name::<T>().to_string()
}
#[derive(Clone)]
struct PickerEntry {
path: PathBuf,
name: String,
is_dir: bool,
size: Option<u64>,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum PickerMode {
Wz,
Image,
}
impl PickerMode {
fn title(self) -> &'static str {
match self {
PickerMode::Wz => "打开 WZ 文件(请选择 Base.wz)",
PickerMode::Image => "选择替换用的图片",
}
}
fn matches_extension(self, extension: &str) -> bool {
let targets = match self {
PickerMode::Wz => ["wz"].as_slice(),
PickerMode::Image => ["png", "jpg", "jpeg", "bmp", "gif", "webp", "tga"].as_slice(),
};
targets
.iter()
.any(|target| extension.eq_ignore_ascii_case(target))
}
fn filter_label(self) -> &'static str {
match self {
PickerMode::Wz => "只看 .wz",
PickerMode::Image => "只看图片",
}
}
}
struct FilePicker {
open: bool,
mode: PickerMode,
current_dir: PathBuf,
path_input: String,
entries: Vec<PickerEntry>,
selected: Option<PathBuf>,
only_filtered: bool,
error: Option<String>,
need_refresh: bool,
last_opened: Option<PathBuf>,
}
impl FilePicker {
fn new() -> Self {
let start_dir = detect_start_dir();
let mut picker = Self {
open: false,
mode: PickerMode::Wz,
current_dir: start_dir.clone(),
path_input: start_dir.display().to_string(),
entries: Vec::new(),
selected: None,
only_filtered: true,
error: None,
need_refresh: true,
last_opened: None,
};
picker.refresh();
picker
}
fn show(&mut self, mode: PickerMode) {
self.mode = mode;
self.open = true;
self.need_refresh = true;
self.selected = None;
self.error = None;
}
fn enter_dir(&mut self, dir: PathBuf) {
self.current_dir = dir;
self.path_input = self.current_dir.display().to_string();
self.error = None;
self.refresh();
}
fn refresh(&mut self) {
self.entries.clear();
let Ok(read_dir) = fs::read_dir(&self.current_dir) else {
self.error = Some(format!("无法读取目录:{}", self.current_dir.display()));
return;
};
for entry in read_dir.flatten() {
let path = entry.path();
let Some(name) = path.file_name().map(|value| value.to_string_lossy().to_string()) else {
continue;
};
let is_dir = path.is_dir();
let wanted = path
.extension()
.map(|extension| self.mode.matches_extension(&extension.to_string_lossy()))
.unwrap_or(false);
if !is_dir && self.only_filtered && !wanted {
continue;
}
let size = entry.metadata().ok().map(|metadata| metadata.len());
self.entries.push(PickerEntry {
path,
name,
is_dir,
size,
});
}
self.entries.sort_by(|left, right| {
right
.is_dir
.cmp(&left.is_dir)
.then_with(|| left.name.to_lowercase().cmp(&right.name.to_lowercase()))
});
}
fn ui(&mut self, ctx: &egui::Context) -> Option<PathBuf> {
if !self.open {
return None;
}
if self.need_refresh {
self.refresh();
self.need_refresh = false;
}
let mut open = self.open;
let mut confirmed: Option<PathBuf> = None;
let mut close_requested = false;
let mode = self.mode;
egui::Window::new(mode.title())
.open(&mut open)
.collapsible(false)
.resizable(true)
.default_size([780.0, 540.0])
.show(ctx, |ui| {
ui.horizontal(|ui| {
if let Some(parent) = self.current_dir.parent().map(|value| value.to_path_buf()) {
if ui.button("上一级").clicked() {
self.enter_dir(parent);
}
}
if ui.button("刷新").clicked() {
self.refresh();
}
ui.label(mode.filter_label());
if ui.checkbox(&mut self.only_filtered, "").changed() {
self.refresh();
}
});
ui.horizontal(|ui| {
ui.label("路径");
let response = ui.add(
egui::TextEdit::singleline(&mut self.path_input).desired_width(f32::INFINITY),
);
let go = response.lost_focus() && ui.input(|state| state.key_pressed(egui::Key::Enter));
if go || ui.button("前往").clicked() {
let target = PathBuf::from(self.path_input.trim());
if target.is_dir() {
self.enter_dir(target);
} else {
self.error = Some(format!("目录不存在:{}", target.display()));
}
}
});
ui.horizontal_wrapped(|ui| {
ui.label("快捷");
for drive in list_drives() {
if ui.button(drive.display().to_string()).clicked() {
self.enter_dir(drive);
}
}
if let Some(work_dir) = std::env::current_dir().ok() {
if ui.button("工作目录").clicked() {
self.enter_dir(work_dir.clone());
}
let data_dir = work_dir.join(".data");
if data_dir.is_dir() && ui.button("项目 .data").clicked() {
self.enter_dir(data_dir);
}
}
if let Some(last) = self.last_opened.clone() {
if ui.button("上次打开").clicked() {
if let Some(parent) = last.parent() {
self.enter_dir(parent.to_path_buf());
self.selected = Some(last);
}
}
}
});
ui.separator();
egui::ScrollArea::vertical()
.id_salt("wz_picker_list")
.show(ui, |ui| {
let entries = self.entries.clone();
for entry in &entries {
let is_selected = self.selected.as_deref() == Some(entry.path.as_path());
let size_text = entry
.size
.map(format_size)
.unwrap_or_else(|| "-".to_string());
let label = if entry.is_dir {
format!("[目录] {}", entry.name)
} else if mode == PickerMode::Image {
match image::image_dimensions(&entry.path) {
Ok((width, height)) => {
format!("{} ({}x{}, {})", entry.name, width, height, size_text)
}
Err(_) => format!("{} ({})", entry.name, size_text),
}
} else {
format!("{} ({})", entry.name, size_text)
};
let mut rich = RichText::new(label);
if !entry.is_dir && entry.name == "Base.wz" {
rich = rich.color(Color32::from_rgb(0xc0, 0x30, 0x30)).strong();
}
let response = ui.selectable_label(is_selected, rich);
if response.clicked() {
if entry.is_dir {
self.enter_dir(entry.path.clone());
} else {
self.error = None;
self.selected = Some(entry.path.clone());
}
}
if response.double_clicked() && !entry.is_dir {
self.selected = Some(entry.path.clone());
if let Some(path) = self.take_confirmed() {
confirmed = Some(path);
close_requested = true;
}
}
}
});
ui.separator();
ui.horizontal(|ui| {
ui.label("文件");
let file_name = self
.selected
.as_ref()
.map(|path| path.display().to_string())
.unwrap_or_else(|| "(未选择)".to_string());
ui.add_enabled(
false,
egui::TextEdit::singleline(&mut file_name.clone()).desired_width(f32::INFINITY),
);
});
ui.horizontal(|ui| {
let enabled = self.selected.is_some();
let confirm_label = match mode {
PickerMode::Wz => "打开",
PickerMode::Image => "替换",
};
if ui.add_enabled(enabled, egui::Button::new(confirm_label)).clicked() {
if let Some(path) = self.take_confirmed() {
confirmed = Some(path);
close_requested = true;
}
}
if ui.button("取消").clicked() {
close_requested = true;
}
});
if let Some(error) = &self.error {
ui.colored_label(Color32::from_rgb(0xc0, 0x30, 0x30), error);
} else if mode == PickerMode::Wz {
ui.label(
RichText::new("提示:必须选择 Base.wz(其他 .wz 只是数据分片,不能作为根节点)。")
.weak(),
);
} else {
ui.label(
RichText::new("提示:替换只作用于当前会话的浏览/复制/导出,不会写回磁盘上的 WZ 文件。")
.weak(),
);
}
});
self.open = open && !close_requested;
confirmed
}
fn take_confirmed(&mut self) -> Option<PathBuf> {
let path = self.selected.clone()?;
if self.mode == PickerMode::Wz {
let is_base = path
.file_name()
.map(|name| name == "Base.wz")
.unwrap_or(false);
if !is_base {
self.error = Some(format!(
"必须选择 Base.wz,当前选的是:{}",
path.display()
));
return None;
}
self.error = None;
self.last_opened = Some(path.clone());
return Some(path);
}
match image::image_dimensions(&path) {
Ok((width, height)) => {
self.error = None;
self.selected = None;
let _ = (width, height);
Some(path)
}
Err(error) => {
self.error = Some(format!("不是可用的图片:{error}"));
None
}
}
}
}
fn detect_start_dir() -> PathBuf {
let work_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
let data_dir = work_dir.join(".data");
if data_dir.is_dir() {
data_dir
} else {
work_dir
}
}
#[cfg(windows)]
fn list_drives() -> Vec<PathBuf> {
('C'..='Z')
.map(|letter| PathBuf::from(format!("{letter}:\\")))
.filter(|path| path.exists())
.collect()
}
#[cfg(not(windows))]
fn list_drives() -> Vec<PathBuf> {
Vec::new()
}
fn format_size(size: u64) -> String {
const KB: u64 = 1024;
const MB: u64 = KB * 1024;
if size >= MB {
format!("{:.1} MB", size as f64 / MB as f64)
} else if size >= KB {
format!("{:.1} KB", size as f64 / KB as f64)
} else {
format!("{size} B")
}
}
struct Tree {
search: String,
goto_path: String,
selected: Option<WzNodeArc>,
selected_path: String,
error: Option<String>,
pending_action: Option<TreeAction>,
pending_copy_path: Option<String>,
marked: std::collections::HashSet<String>,
}
impl Default for Tree {
fn default() -> Self {
Self {
search: String::new(),
goto_path: String::new(),
selected: None,
selected_path: String::new(),
error: None,
pending_action: None,
pending_copy_path: None,
marked: std::collections::HashSet::new(),
}
}
}
impl Tree {
fn reset(&mut self) {
self.selected = None;
self.selected_path.clear();
self.search.clear();
self.error = None;
self.pending_action = None;
self.pending_copy_path = None;
self.marked.clear();
}
fn set_marked(&mut self, full_path: String, marked: bool) {
if marked {
self.marked.insert(full_path);
} else {
self.marked.remove(&full_path);
}
}
fn take_action(&mut self) -> Option<TreeAction> {
self.pending_action.take()
}
fn take_copy_path(&mut self) -> Option<String> {
self.pending_copy_path.take()
}
fn is_selected(&self, node: &WzNodeArc) -> bool {
self.selected
.as_ref()
.map(|selected| Arc::ptr_eq(selected, node))
.unwrap_or(false)
}
fn select(&mut self, node: WzNodeArc) {
let path = node.read().unwrap().get_path_from_root();
self.selected_path = path;
self.selected = Some(node);
}
fn try_parse(&mut self, node: &WzNodeArc) {
if let Err(error) = node_util::parse_node(node) {
self.error = Some(format!("解析节点失败:{error}"));
}
}
fn ui(&mut self, ui: &mut Ui, root: &WzNodeArc) -> bool {
ui.horizontal(|ui| {
ui.label("搜索");
ui.add(
egui::TextEdit::singleline(&mut self.search)
.hint_text("名称关键字(大小写不敏感)")
.desired_width(f32::INFINITY),
);
if ui.button("清空").clicked() {
self.search.clear();
}
});
ui.horizontal(|ui| {
ui.label("跳转");
let response = ui.add(
egui::TextEdit::singleline(&mut self.goto_path)
.hint_text("如 Skill/1111.img/skill/11111004")
.desired_width(f32::INFINITY),
);
let jump = response.lost_focus() && ui.input(|state| state.key_pressed(egui::Key::Enter));
if jump || ui.button("前往").clicked() {
self.goto(ui.ctx(), root);
}
});
if let Some(error) = self.error.take() {
ui.colored_label(Color32::from_rgb(0xc0, 0x30, 0x30), error);
}
ui.separator();
egui::ScrollArea::vertical()
.id_salt("wz_tree_scroll")
.show(ui, |ui| self.children_ui(ui, root, 0))
.inner
}
fn children_ui(&mut self, ui: &mut Ui, node: &WzNodeArc, depth: usize) -> bool {
let mut children: Vec<(String, WzNodeArc)> = {
let guard = node.read().unwrap();
guard
.children
.iter()
.map(|(name, child)| (name.as_str().to_string(), child.clone()))
.collect()
};
children.sort_by(|(left, _), (right, _)| natural_cmp(left, right));
let mut changed = false;
for (index, (name, child)) in children.iter().enumerate() {
if index >= MAX_VISIBLE_CHILDREN {
ui.label(
RichText::new(format!(
"… 还有 {} 项,请用上方搜索过滤",
children.len() - MAX_VISIBLE_CHILDREN
))
.weak(),
);
break;
}
changed |= self.node_ui(ui, name, child, depth);
}
changed
}
fn node_ui(&mut self, ui: &mut Ui, name: &str, node: &WzNodeArc, depth: usize) -> bool {
let search_active = !self.search.trim().is_empty();
if search_active && !subtree_matches(node, &self.search.trim().to_lowercase(), 0) {
return false; }
let full_path = node.read().unwrap().get_full_path();
let node_id = Id::new(full_path.clone());
let has_children = !node.read().unwrap().children.is_empty();
let is_image = name.ends_with(".img");
let mut changed = false;
let is_png = matches!(
&node.read().unwrap().object_type,
WzObjectType::Property(WzSubProperty::PNG(_))
);
let is_value = matches!(&node.read().unwrap().object_type, WzObjectType::Value(_));
let display_name = if self.marked.contains(&full_path) {
format!("{name} *")
} else {
name.to_string()
};
if has_children || is_image {
let mut state = CollapsingState::load_with_default_open(ui.ctx(), node_id, false);
if search_active {
state.set_open(true); }
let was_open = state.is_open();
let (_toggle, header, body) = state
.show_header(ui, |ui| {
let response =
ui.selectable_label(self.is_selected(node), node_label(&display_name, node));
self.context_menu(&response, node, is_png, is_value);
response.clicked()
})
.body(|ui| self.children_ui(ui, node, depth + 1));
if header.inner {
self.select(node.clone());
self.try_parse(node);
if let Some(mut stored) = CollapsingState::load(ui.ctx(), node_id) {
stored.set_open(!was_open);
stored.store(ui.ctx());
}
changed = true;
}
changed |= body.map(|inner| inner.inner).unwrap_or(false);
} else {
let response =
ui.selectable_label(self.is_selected(node), node_label(&display_name, node));
self.context_menu(&response, node, is_png, is_value);
if response.clicked() {
self.select(node.clone());
self.try_parse(node);
changed = true;
}
}
changed
}
fn context_menu(
&mut self,
response: &egui::Response,
node: &WzNodeArc,
is_png: bool,
is_value: bool,
) {
response.context_menu(|ui| {
let node_name = node.read().unwrap().name.as_str().to_string();
ui.label(RichText::new(node_name).strong());
ui.separator();
if is_value && ui.button("编辑值…").clicked() {
self.pending_action = Some(TreeAction::EditValue(node.clone()));
}
if is_png {
if ui.button("替换图片…").clicked() {
self.pending_action = Some(TreeAction::ReplaceImage(node.clone()));
}
if ui.button("还原原图").clicked() {
self.pending_action = Some(TreeAction::RevertImage(node.clone()));
}
}
if !is_value && !is_png {
ui.label(RichText::new("(该节点不可编辑)").weak());
}
ui.separator();
if ui.button("复制节点路径").clicked() {
self.pending_copy_path = Some(node.read().unwrap().get_path_from_root());
}
});
}
fn goto(&mut self, ctx: &egui::Context, root: &WzNodeArc) {
let path = self.goto_path.trim().trim_start_matches('/').to_string();
if path.is_empty() {
return;
}
let found = { root.read().unwrap().at_path_parsed(&path) };
match found {
Ok(node) => {
self.try_parse(&node);
let path_from_root = node.read().unwrap().get_path_from_root();
let root_name = root.read().unwrap().name.as_str().to_string();
let segments: Vec<&str> = path_from_root.split('/').collect();
for count in 1..segments.len() {
let prefix = segments[..count].join("/");
let id = Id::new(format!("{root_name}/{prefix}"));
if let Some(mut state) = CollapsingState::load(ctx, id) {
state.set_open(true);
state.store(ctx);
}
}
self.select(node);
}
Err(error) => self.error = Some(format!("跳转失败 {path}:{error}")),
}
}
}
fn node_label(name: &str, node: &WzNodeArc) -> RichText {
let color = match &node.read().unwrap().object_type {
WzObjectType::Property(WzSubProperty::PNG(_)) => Color32::from_rgb(0x1a, 0x8a, 0x3a),
WzObjectType::Property(WzSubProperty::Sound(_)) => Color32::from_rgb(0xb0, 0x70, 0x00),
WzObjectType::Value(_) => Color32::from_rgb(0x60, 0x60, 0x60),
WzObjectType::Image(_) => Color32::from_rgb(0x1a, 0x50, 0xa0),
_ => Color32::from_rgb(0x20, 0x20, 0x20),
};
RichText::new(name).color(color)
}
fn subtree_matches(node: &WzNodeArc, query: &str, depth: usize) -> bool {
if query.is_empty() {
return true;
}
let (name_matched, children) = {
let guard = node.read().unwrap();
(
guard.name.as_str().to_lowercase().contains(query),
guard.children.values().cloned().collect::<Vec<WzNodeArc>>(),
)
};
if name_matched {
return true;
}
if depth >= 8 || children.is_empty() {
return false;
}
children
.iter()
.any(|child| subtree_matches(child, query, depth + 1))
}
struct CachedImage {
image: DynamicImage,
texture: TextureHandle,
}
#[derive(Default)]
struct ImageCache {
entries: HashMap<String, CachedImage>,
order: VecDeque<String>,
}
impl ImageCache {
fn clear(&mut self) {
self.entries.clear();
self.order.clear();
}
fn ensure(&mut self, ctx: &egui::Context, key: &str, image: DynamicImage, nearest: bool) {
if self.entries.contains_key(key) {
return;
}
let color_image = match &image {
DynamicImage::ImageRgb8(buffer) => egui::ColorImage::from_rgb(
[buffer.width() as usize, buffer.height() as usize],
buffer.as_bytes(),
),
other => {
let rgba = other.to_rgba8();
egui::ColorImage::from_rgba_unmultiplied(
[rgba.width() as usize, rgba.height() as usize],
rgba.as_bytes(),
)
}
};
let options = if nearest {
egui::TextureOptions::NEAREST
} else {
egui::TextureOptions::LINEAR
};
let texture = ctx.load_texture(key, color_image, options);
self.entries.insert(key.to_string(), CachedImage { image, texture });
self.order.push_back(key.to_string());
while self.order.len() > IMAGE_CACHE_CAP {
if let Some(oldest) = self.order.pop_front() {
self.entries.remove(&oldest);
}
}
}
fn get(&self, key: &str) -> Option<&CachedImage> {
self.entries.get(key)
}
fn remove(&mut self, key: &str) {
self.entries.remove(key);
}
}
#[derive(Default)]
struct Overrides {
images: HashMap<String, DynamicImage>,
}
impl Overrides {
fn set_image(&mut self, path: String, image: DynamicImage) {
self.images.insert(path, image);
}
fn remove_image(&mut self, path: &str) -> bool {
self.images.remove(path).is_some()
}
fn image(&self, path: &str) -> Option<&DynamicImage> {
self.images.get(path)
}
}
#[derive(Default)]
struct ValueEditor {
open: bool,
node: Option<WzNodeArc>,
path: String,
kind: ValueKind,
buffer: String,
error: Option<String>,
}
#[derive(Default, Clone, Copy, PartialEq, Eq)]
enum ValueKind {
#[default]
Int,
Short,
Long,
Float,
Double,
Vector,
String,
}
impl ValueKind {
fn label(self) -> &'static str {
match self {
ValueKind::Int => "int",
ValueKind::Short => "short",
ValueKind::Long => "long",
ValueKind::Float => "float",
ValueKind::Double => "double",
ValueKind::Vector => "vector (x,y)",
ValueKind::String => "string",
}
}
fn parse(self, text: &str) -> Result<WzValue, String> {
let text = text.trim();
match self {
ValueKind::Int => text
.parse::<i32>()
.map(WzValue::Int)
.map_err(|_| "需要整数(如 115)".to_string()),
ValueKind::Short => text
.parse::<i16>()
.map(WzValue::Short)
.map_err(|_| "需要 short 整数(-32768~32767)".to_string()),
ValueKind::Long => text
.parse::<i64>()
.map(WzValue::Long)
.map_err(|_| "需要长整数".to_string()),
ValueKind::Float => text
.parse::<f32>()
.map(WzValue::Float)
.map_err(|_| "需要浮点数(如 1.5)".to_string()),
ValueKind::Double => text
.parse::<f64>()
.map(WzValue::Double)
.map_err(|_| "需要浮点数(如 1.5)".to_string()),
ValueKind::Vector => {
let (left, right) = text.split_once(',').ok_or("格式必须是 x,y(如 30,23)")?;
let x = left.trim().parse::<i32>().map_err(|_| "x 不是整数")?;
let y = right.trim().parse::<i32>().map_err(|_| "y 不是整数")?;
Ok(WzValue::Vector(Vector2D(x, y)))
}
ValueKind::String => Ok(WzValue::ParsedString(text.to_string())),
}
}
}
impl ValueEditor {
fn open_with(&mut self, node: &WzNodeArc) {
let (path, outcome) = {
let guard = node.read().unwrap();
let path = guard.get_path_from_root();
let outcome = match &guard.object_type {
WzObjectType::Value(value) => match value {
WzValue::Int(value) => Ok((ValueKind::Int, value.to_string())),
WzValue::Short(value) => Ok((ValueKind::Short, value.to_string())),
WzValue::Long(value) => Ok((ValueKind::Long, value.to_string())),
WzValue::Float(value) => Ok((ValueKind::Float, value.to_string())),
WzValue::Double(value) => Ok((ValueKind::Double, value.to_string())),
WzValue::Vector(Vector2D(x, y)) => {
Ok((ValueKind::Vector, format!("{x},{y}")))
}
WzValue::String(value) | WzValue::UOL(value) => Ok((
ValueKind::String,
value.get_string().unwrap_or_default(),
)),
WzValue::ParsedString(value) => Ok((ValueKind::String, value.clone())),
WzValue::Null => Ok((ValueKind::String, String::new())),
other => Err(format!("该类型不支持编辑:{other:?}")),
},
_ => Err("只有基本类型(叶子值)可以编辑".to_string()),
};
(path, outcome)
};
self.path = path;
match outcome {
Ok((kind, text)) => {
self.node = Some(node.clone());
self.kind = kind;
self.buffer = text;
self.error = None;
}
Err(message) => {
self.node = None;
self.buffer.clear();
self.error = Some(message);
}
}
self.open = true;
}
fn apply(&mut self) -> Result<String, String> {
let Some(node) = self.node.clone() else {
return Err("没有可编辑的节点".to_string());
};
let value = self.kind.parse(&self.buffer)?;
{
let mut guard = node.write().unwrap();
guard.object_type = WzObjectType::Value(value);
}
Ok(self.path.clone())
}
fn ui(&mut self, ctx: &egui::Context) -> bool {
if !self.open {
return false;
}
let mut open = self.open;
let mut applied = false;
egui::Window::new("编辑值")
.open(&mut open)
.collapsible(false)
.resizable(false)
.default_size([420.0, 220.0])
.show(ctx, |ui| {
ui.label(RichText::new(&self.path).weak());
ui.label(format!("类型:{}", self.kind.label()));
ui.add_space(4.0);
ui.add(
egui::TextEdit::singleline(&mut self.buffer).desired_width(f32::INFINITY),
);
if let Some(error) = &self.error {
ui.colored_label(Color32::from_rgb(0xc0, 0x30, 0x30), error);
}
ui.add_space(8.0);
ui.horizontal(|ui| {
if ui.button("确定").clicked() {
match self.apply() {
Ok(_) => {
self.error = None;
applied = true;
self.open = false;
}
Err(error) => self.error = Some(error),
}
}
if ui.button("取消").clicked() {
self.open = false;
}
});
ui.label(
RichText::new("提示:改的是内存里的 WZ 树,关掉程序就没了(WZ 是只读格式)。")
.weak(),
);
});
self.open = open;
applied
}
}
enum TreeAction {
EditValue(WzNodeArc),
ReplaceImage(WzNodeArc),
RevertImage(WzNodeArc),
}
enum LoadState {
Idle,
Loading {
started: Instant,
receiver: Receiver<Result<WzNodeArc, String>>,
},
}
impl Default for LoadState {
fn default() -> Self {
LoadState::Idle
}
}
struct AudioPlayer {
_device_sink: MixerDeviceSink,
player: Player,
}
struct Status {
text: String,
is_error: bool,
}
impl Default for Status {
fn default() -> Self {
Self {
text: "就绪:请点左上角「打开 Base.wz…」选择 WZ 文件".to_string(),
is_error: false,
}
}
}
struct WzEditorApp {
root: Option<WzNodeArc>,
root_path: Option<PathBuf>,
load_state: LoadState,
load_cost: Option<Duration>,
tree: Tree,
picker: FilePicker,
clipboard: Option<ClipboardContext>,
audio: Option<AudioPlayer>,
image_cache: ImageCache,
zoom: f32,
preview_text: String,
preview_path: String,
tree_width: f32,
tree_width_dirty: bool,
overrides: Overrides,
value_editor: ValueEditor,
replace_target: Option<WzNodeArc>,
status: Status,
}
impl Default for WzEditorApp {
fn default() -> Self {
Self {
root: None,
root_path: None,
load_state: LoadState::Idle,
load_cost: None,
tree: Tree::default(),
picker: FilePicker::new(),
clipboard: ClipboardContext::new().ok(),
audio: None,
image_cache: ImageCache::default(),
zoom: 1.0,
preview_text: String::new(),
preview_path: String::new(),
tree_width: load_tree_width(),
tree_width_dirty: false,
overrides: Overrides::default(),
value_editor: ValueEditor::default(),
replace_target: None,
status: Status::default(),
}
}
}
impl WzEditorApp {
fn nudge_tree_width(&mut self, delta: f32) {
self.tree_width = (self.tree_width + delta).max(TREE_WIDTH_MIN);
save_tree_width(self.tree_width);
self.set_status(format!("左栏宽度 {:.0}px", self.tree_width), false);
}
}
impl WzEditorApp {
fn set_status(&mut self, text: impl Into<String>, is_error: bool) {
self.status = Status {
text: text.into(),
is_error,
};
}
fn start_load(&mut self, path: PathBuf) {
let (sender, receiver) = channel();
let load_path = path.clone();
thread::spawn(move || {
let result = resolve_base(&load_path, None).map_err(|error| format!("{error}"));
let _ = sender.send(result);
});
self.load_state = LoadState::Loading {
started: Instant::now(),
receiver,
};
self.root = None;
self.root_path = Some(path.clone());
self.tree.reset();
self.image_cache.clear();
self.audio = None;
self.set_status(format!("正在加载:{}", path.display()), false);
}
fn poll_load(&mut self, ctx: &egui::Context) {
let received = match &self.load_state {
LoadState::Loading { receiver, .. } => Some(receiver.try_recv()),
LoadState::Idle => None,
};
match received {
Some(Ok(Ok(root))) => {
let cost = match &self.load_state {
LoadState::Loading { started, .. } => started.elapsed(),
LoadState::Idle => Duration::ZERO,
};
self.load_cost = Some(cost);
self.root = Some(root);
self.load_state = LoadState::Idle;
self.set_status(
format!("加载完成,耗时 {:.2}s", cost.as_secs_f32()),
false,
);
}
Some(Ok(Err(message))) => {
self.load_state = LoadState::Idle;
self.root = None;
self.set_status(format!("加载失败:{message}"), true);
}
Some(Err(TryRecvError::Empty)) => {
ctx.request_repaint();
}
Some(Err(TryRecvError::Disconnected)) => {
self.load_state = LoadState::Idle;
self.set_status("加载失败:后台线程异常退出".to_string(), true);
}
None => {}
}
}
fn close_wz(&mut self) {
self.root = None;
self.root_path = None;
self.load_state = LoadState::Idle;
self.load_cost = None;
self.tree.reset();
self.image_cache.clear();
self.audio = None;
self.set_status("已关闭,可重新打开 Base.wz".to_string(), false);
}
fn copy_text(&mut self, text: String) {
match &self.clipboard {
Some(clipboard) => match clipboard.set_text(text) {
Ok(()) => self.set_status("已复制到剪贴板".to_string(), false),
Err(error) => self.set_status(format!("复制失败:{error}"), true),
},
None => self.set_status("剪贴板不可用".to_string(), true),
}
}
fn copy_image(&mut self, image: DynamicImage) {
match &self.clipboard {
Some(clipboard) => match clipboard.set_image(RustImageData::from_dynamic_image(image)) {
Ok(()) => self.set_status("图片已复制到剪贴板".to_string(), false),
Err(error) => self.set_status(format!("复制图片失败:{error}"), true),
},
None => self.set_status("剪贴板不可用".to_string(), true),
}
}
fn top_bar(&mut self, ui: &mut Ui) {
egui::Panel::top("wz_top_bar").show(ui, |ui| {
ui.horizontal(|ui| {
if ui.button("打开 Base.wz…").clicked() {
self.picker.show(PickerMode::Wz);
}
if ui
.add_enabled(self.root.is_some(), egui::Button::new("关闭"))
.clicked()
{
self.close_wz();
}
if let Some(path) = self.root_path.clone() {
if ui.button("重新加载").clicked() {
self.start_load(path);
}
}
ui.separator();
match &self.root_path {
Some(path) => {
ui.label(RichText::new(path.display().to_string()).weak());
}
None => {
ui.label(RichText::new("未加载 WZ 文件").weak());
}
}
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
ui.label(RichText::new(format!("左栏 {:.0}px", self.tree_width)).weak());
if ui.button("加宽 →").clicked() {
self.nudge_tree_width(32.0);
}
if ui.button("← 收窄").clicked() {
self.nudge_tree_width(-32.0);
}
ui.label("左栏宽度");
});
});
});
}
fn status_bar(&mut self, ui: &mut Ui) {
egui::Panel::bottom("wz_status_bar").show(ui, |ui| {
ui.horizontal(|ui| {
let color = if self.status.is_error {
Color32::from_rgb(0xc0, 0x30, 0x30)
} else {
Color32::from_rgb(0x40, 0x40, 0x40)
};
ui.colored_label(color, &self.status.text);
ui.separator();
if let Some(cost) = self.load_cost {
ui.label(RichText::new(format!("加载耗时 {:.2}s", cost.as_secs_f32())).weak());
}
if !self.tree.selected_path.is_empty() {
ui.separator();
ui.label(RichText::new(format!("当前:{}", self.tree.selected_path)).weak());
}
});
});
}
fn body(&mut self, ui: &mut Ui) {
egui::CentralPanel::default().show(ui, |ui| {
let available = ui.available_rect_before_wrap();
let max_width = (available.width() - RIGHT_MIN_WIDTH).max(TREE_WIDTH_MIN);
self.tree_width = self.tree_width.clamp(TREE_WIDTH_MIN, max_width);
let left_rect = Rect::from_min_size(
available.min,
egui::Vec2::new(self.tree_width, available.height()),
);
let splitter_rect = Rect::from_min_size(
egui::Pos2::new(left_rect.max.x, available.min.y),
egui::Vec2::new(SPLITTER_WIDTH, available.height()),
);
let right_rect = Rect::from_min_size(
egui::Pos2::new(splitter_rect.max.x, available.min.y),
egui::Vec2::new(
(available.max.x - splitter_rect.max.x).max(0.0),
available.height(),
),
);
let mut left_ui = ui.new_child(
egui::UiBuilder::new()
.max_rect(left_rect)
.layout(egui::Layout::top_down(egui::Align::Min))
.id_salt("wz_tree_column"),
);
left_ui.set_clip_rect(left_rect);
let style = ui.style().clone();
egui::Frame::side_top_panel(&style).show(&mut left_ui, |ui| {
ui.expand_to_include_rect(ui.max_rect()); self.tree_column(ui);
});
let splitter = ui.interact(
splitter_rect,
Id::new("wz_tree_splitter"),
egui::Sense::click_and_drag(),
);
if splitter.dragged() {
if let Some(pointer) = splitter.interact_pointer_pos() {
self.tree_width = (pointer.x - available.min.x).clamp(TREE_WIDTH_MIN, max_width);
self.tree_width_dirty = true; }
}
if splitter.drag_stopped() && self.tree_width_dirty {
self.tree_width_dirty = false;
save_tree_width(self.tree_width);
}
if splitter.double_clicked() {
self.tree_width = TREE_WIDTH_DEFAULT.clamp(TREE_WIDTH_MIN, max_width);
save_tree_width(self.tree_width);
}
if splitter.hovered() || splitter.dragged() {
ui.set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
}
if splitter.dragged() {
self.set_status(
format!("左栏宽度 {:.0}px(松手生效,双击分隔条复位)", self.tree_width),
false,
);
}
let stroke = if splitter.dragged() {
ui.style().visuals.widgets.active.fg_stroke
} else if splitter.hovered() {
ui.style().visuals.widgets.hovered.fg_stroke
} else {
ui.style().visuals.widgets.noninteractive.bg_stroke
};
ui.painter()
.vline(splitter_rect.center().x, splitter_rect.y_range(), stroke);
let mut right_ui = ui.new_child(
egui::UiBuilder::new()
.max_rect(right_rect)
.layout(egui::Layout::top_down(egui::Align::Min))
.id_salt("wz_preview_column"),
);
right_ui.set_clip_rect(right_rect);
egui::Frame::central_panel(&style).show(&mut right_ui, |ui| {
ui.expand_to_include_rect(ui.max_rect());
self.preview_panel(ui);
});
ui.advance_cursor_after_rect(available);
});
}
fn tree_column(&mut self, ui: &mut Ui) {
let Some(root) = self.root.clone() else {
ui.label(RichText::new("(尚未加载 WZ)").weak());
return;
};
let selection_changed = self.tree.ui(ui, &root);
if selection_changed {
self.audio = None;
self.preview_path.clear();
}
if let Some(path) = self.tree.take_copy_path() {
self.copy_text(path);
}
match self.tree.take_action() {
Some(TreeAction::EditValue(node)) => {
self.value_editor.open_with(&node);
self.tree.select(node);
}
Some(TreeAction::ReplaceImage(node)) => {
let path = node.read().unwrap().get_path_from_root();
self.replace_target = Some(node.clone());
self.tree.select(node);
self.picker.show(PickerMode::Image);
self.set_status(format!("选择一张图片替换:{path}"), false);
}
Some(TreeAction::RevertImage(node)) => {
let path = node.read().unwrap().get_path_from_root();
if self.overrides.remove_image(&path) {
self.invalidate_image_cache(&path);
self.tree.set_marked(node.read().unwrap().get_full_path(), false);
self.set_status(format!("已还原原图:{path}"), false);
} else {
self.set_status("这个节点没有被替换过,无需还原".to_string(), false);
}
}
None => {}
}
}
fn invalidate_image_cache(&mut self, path: &str) {
self.image_cache.remove(&format!("{path}|nearest"));
self.image_cache.remove(&format!("{path}|linear"));
}
fn apply_image_replacement(&mut self, file: PathBuf) {
let Some(node) = self.replace_target.take() else {
self.set_status("没有待替换的节点".to_string(), true);
return;
};
let path = node.read().unwrap().get_path_from_root();
match image::open(&file) {
Ok(image) => {
let size = (image.width(), image.height());
self.invalidate_image_cache(&path); self.tree.set_marked(node.read().unwrap().get_full_path(), true);
self.overrides.set_image(path.clone(), image);
self.set_status(
format!(
"已替换 {}:来自 {}({}x{})—— 仅本会话生效,不写回 WZ",
path,
file.display(),
size.0,
size.1
),
false,
);
self.preview_path.clear();
}
Err(error) => self.set_status(format!("读取图片失败:{error}"), true),
}
}
fn preview_panel(&mut self, ui: &mut Ui) {
if self.root.is_none() {
ui.centered_and_justified(|ui| {
ui.vertical_centered(|ui| {
ui.label(RichText::new("尚未加载 WZ 文件").strong());
ui.add_space(8.0);
ui.label("点击左上角「打开 Base.wz…」,在弹出的窗口里选择 Base.wz");
ui.add_space(12.0);
if ui.button("打开 Base.wz…").clicked() {
self.picker.show(PickerMode::Wz);
}
});
});
return;
}
let Some(selected) = self.tree.selected.clone() else {
ui.centered_and_justified(|ui| {
ui.label(RichText::new("从左侧选择一个节点").weak());
});
return;
};
let path_from_root = self.tree.selected_path.clone();
let (child_count, object_type) = {
let node = selected.read().unwrap();
(node.children.len(), node.object_type.clone())
};
ui.horizontal(|ui| {
ui.label(RichText::new(&path_from_root).strong());
});
ui.horizontal(|ui| {
if ui.button("复制路径").clicked() {
let path = path_from_root.clone();
self.copy_text(path);
}
if ui.button("复制名称").clicked() {
let name = selected.read().unwrap().name.as_str().to_string();
self.copy_text(name);
}
ui.separator();
ui.label(RichText::new(format!("子节点 {child_count}")).weak());
ui.label(RichText::new(object_type_name(&object_type)).weak());
});
ui.separator();
match object_type {
WzObjectType::Property(WzSubProperty::PNG(png)) => {
if let Some(image) = self.overrides.image(&path_from_root).cloned() {
ui.horizontal(|ui| {
ui.colored_label(
Color32::from_rgb(0x1a, 0x8a, 0x3a),
format!(
"已替换(本会话):{} x {} —— 原图 {} x {} {:?}",
image.width(),
image.height(),
png.width,
png.height,
png.format()
),
);
});
self.show_image(ui, image, &path_from_root);
} else {
self.png_preview(ui, &selected, &png, &path_from_root);
}
}
WzObjectType::Property(WzSubProperty::Sound(sound)) => {
ui.label(format!(
"音效:{:?},时长 {:?}",
sound.sound_type,
Duration::from_millis(sound.duration as u64)
));
if ui.button("播放").clicked() {
let buffer = sound.get_buffer();
match DeviceSinkBuilder::open_default_sink() {
Ok(device_sink) => {
match play(device_sink.mixer(), Cursor::new(buffer)) {
Ok(player) => {
self.audio = Some(AudioPlayer {
_device_sink: device_sink,
player,
});
self.set_status("播放中".to_string(), false);
}
Err(error) => self.set_status(format!("播放失败:{error}"), true),
}
}
Err(error) => self.set_status(format!("音频设备不可用:{error}"), true),
}
}
if ui.button("停止").clicked() {
if let Some(audio) = &self.audio {
audio.player.stop();
}
self.audio = None;
}
}
WzObjectType::Property(WzSubProperty::Convex) => {
ui.label("Convex(凸多边形数据)");
}
WzObjectType::Property(WzSubProperty::Property) => {
self.json_preview(ui, &selected, &path_from_root);
}
WzObjectType::Value(value) => {
self.value_preview(ui, &value, &selected, &path_from_root);
}
WzObjectType::File(_) | WzObjectType::MsFile(_) => {
ui.label("WZ 文件根节点");
}
WzObjectType::Image(_) | WzObjectType::MsImage(_) => {
self.json_preview(ui, &selected, &path_from_root);
}
WzObjectType::Directory(_) => {
self.json_preview(ui, &selected, &path_from_root);
}
}
}
fn png_preview(
&mut self,
ui: &mut Ui,
node: &WzNodeArc,
png: &wz_reader::property::WzPng,
path: &str,
) {
let format = png.format();
ui.horizontal(|ui| {
ui.label(format!(
"图片 {} x {},格式 {:?}",
png.width, png.height, format
));
});
match png.extract_png() {
Ok(image) => self.show_image(ui, image, path),
Err(error) => {
ui.colored_label(
Color32::from_rgb(0xc0, 0x30, 0x30),
format!("图片解码失败:{error:?}"),
);
}
}
let _ = node;
}
fn show_image(&mut self, ui: &mut Ui, image: DynamicImage, path: &str) {
let nearest = self.zoom >= 1.0;
let cache_key = if nearest {
format!("{path}|nearest")
} else {
format!("{path}|linear")
};
ui.horizontal(|ui| {
ui.label("缩放");
ui.add(egui::Slider::new(&mut self.zoom, 0.25..=8.0).suffix("x"));
if ui.button("重置").clicked() {
self.zoom = 1.0;
}
});
self.image_cache
.ensure(ui.ctx(), &cache_key, image, nearest);
let Some((texture, cached_image)) = self
.image_cache
.get(&cache_key)
.map(|cached| (cached.texture.clone(), cached.image.clone()))
else {
return;
};
ui.add(
egui::Image::new(&texture)
.fit_to_original_size(self.zoom)
.bg_fill(Color32::from_gray(235)),
);
ui.horizontal(|ui| {
if ui.button("复制图片").clicked() {
let image = cached_image.clone();
self.copy_image(image);
}
if ui.button("导出 PNG").clicked() {
let file_name = std::env::temp_dir()
.join(format!("wz_editor_{}.png", path.replace('/', "_")));
match cached_image.clone().into_rgba8().save(&file_name) {
Ok(()) => self.set_status(format!("已导出:{}", file_name.display()), false),
Err(error) => self.set_status(format!("导出失败:{error}"), true),
}
}
});
}
fn json_preview(&mut self, ui: &mut Ui, node: &WzNodeArc, path: &str) {
if self.preview_path != path {
self.preview_text = node_to_json(node);
self.preview_path = path.to_string();
}
ui.horizontal(|ui| {
if ui.button("复制 JSON").clicked() {
let text = self.preview_text.clone();
self.copy_text(text);
}
ui.label(RichText::new(format!("{} 字节", self.preview_text.len())).weak());
});
egui::ScrollArea::both()
.id_salt("wz_json_preview")
.show(ui, |ui| {
ui.add(
egui::TextEdit::multiline(&mut self.preview_text)
.font(egui::TextStyle::Monospace)
.desired_width(f32::INFINITY),
);
});
}
fn value_preview(&mut self, ui: &mut Ui, value: &WzValue, node: &WzNodeArc, path: &str) {
match value {
WzValue::String(string) | WzValue::UOL(string) => {
let text = string.get_string().unwrap_or_default();
ui.label(format!("{text:?}"));
if matches!(value, WzValue::UOL(_)) {
ui.label(RichText::new("UOL:指向另一个节点的链接").weak());
if ui.button("跳转到目标").clicked() {
let target = node_util::get_resolved_uol_path(path, &text);
self.tree.goto_path = target;
if let Some(root) = self.root.clone() {
self.tree.goto(ui.ctx(), &root);
}
}
}
}
WzValue::Vector(vector) => {
ui.label(format!("{vector:?}"));
}
WzValue::Null => {
ui.label("null");
}
other => {
ui.label(format!("{other:?} ({})", type_of(other)));
}
}
let _ = node;
}
fn loading_overlay(&self, ctx: &egui::Context) {
if !matches!(self.load_state, LoadState::Loading { .. }) {
return;
}
egui::Window::new("加载中")
.collapsible(false)
.resizable(false)
.anchor(egui::Align2::CENTER_CENTER, egui::Vec2::ZERO)
.show(ctx, |ui| {
ui.horizontal(|ui| {
ui.spinner();
ui.label("正在解析 WZ,请稍候…");
});
});
}
}
fn object_type_name(object_type: &WzObjectType) -> String {
match object_type {
WzObjectType::File(_) => "文件",
WzObjectType::MsFile(_) => "MS 文件",
WzObjectType::Image(_) => "图片节点(.img)",
WzObjectType::MsImage(_) => "MS 图片节点",
WzObjectType::Directory(_) => "目录",
WzObjectType::Property(WzSubProperty::PNG(_)) => "PNG",
WzObjectType::Property(WzSubProperty::Sound(_)) => "音效",
WzObjectType::Property(WzSubProperty::Convex) => "Convex",
WzObjectType::Property(WzSubProperty::Property) => "属性",
WzObjectType::Value(_) => "值",
}
.to_string()
}
impl eframe::App for WzEditorApp {
fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
self.poll_load(ctx);
}
fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
let shortcut = ui
.ctx()
.input_mut(|state| state.consume_key(egui::Modifiers::COMMAND, egui::Key::O));
if shortcut {
self.picker.show(PickerMode::Wz);
}
self.top_bar(ui);
self.status_bar(ui);
self.body(ui);
let picker_mode = self.picker.mode;
if let Some(path) = self.picker.ui(ui.ctx()) {
match picker_mode {
PickerMode::Wz => self.start_load(path),
PickerMode::Image => self.apply_image_replacement(path),
}
}
if self.value_editor.ui(ui.ctx()) {
self.preview_path.clear(); self.set_status("已修改该节点的值(仅内存)".to_string(), false);
}
self.loading_overlay(ui.ctx());
}
}
fn natural_cmp(left: &str, right: &str) -> std::cmp::Ordering {
use std::cmp::Ordering;
let left_chars: Vec<char> = left.chars().collect();
let right_chars: Vec<char> = right.chars().collect();
let mut left_index = 0usize;
let mut right_index = 0usize;
while left_index < left_chars.len() && right_index < right_chars.len() {
let left_is_digit = left_chars[left_index].is_ascii_digit();
let right_is_digit = right_chars[right_index].is_ascii_digit();
if left_is_digit && right_is_digit {
let left_start = left_index;
let right_start = right_index;
while left_index < left_chars.len() && left_chars[left_index].is_ascii_digit() {
left_index += 1;
}
while right_index < right_chars.len() && right_chars[right_index].is_ascii_digit() {
right_index += 1;
}
let left_number: u128 = left[left_start..left_index].parse().unwrap_or(u128::MAX);
let right_number: u128 = right[right_start..right_index].parse().unwrap_or(u128::MAX);
match left_number.cmp(&right_number) {
Ordering::Equal => {}
ordering => return ordering,
}
} else {
let left_char = left_chars[left_index].to_ascii_lowercase();
let right_char = right_chars[right_index].to_ascii_lowercase();
match left_char.cmp(&right_char) {
Ordering::Equal => {
left_index += 1;
right_index += 1;
}
ordering => return ordering,
}
}
}
left_chars.len().cmp(&right_chars.len())
}