fix(client): compare pinned originals and close generation on dispatch

This commit is contained in:
WuYongJie 2026-11-16 18:24:36 +08:00
parent 9796529020
commit fbb88e99fa
6 changed files with 357 additions and 459 deletions

View File

@ -329,7 +329,7 @@ Agent 导入的完全透明页面背景以原生“无填充”表达,保留
- 切文档先保存旧文档的输入及选区,再切换上下文;小型本机草稿同步原子写入,不能把排入异步整文档保存队列当作已落盘。保存失败保留原作用域的内存文本并重试;账户切换须先处理未保存草稿。首次加载完成前,输入、建议项、提示词插入与发送遵守同一门禁,迟到回执不能覆盖新输入。
- 回复使用同一稳定宽度预算;标题分别为18/16/15pt,围栏代码使用深色圆角表面、等宽文字、语言标记与复制代码入口。未闭合围栏继续作为代码块,复制保留原代码内容;代码块到达不重排已经显示的前文。单份原生排版同时承担选择、逐字入场和Caret定位。
- 候选贴图最多64项,按真实读取更新LRU;所有表面完成当前帧可见性收集后再淘汰,不逐出可见贴图。已完成候选才能重取预览;全部被可见内容占用时等待释放空间,不随机丢弃旧卡片。解码等待队列也须有总容量上限。
- 已选候选在图位提供“按住对比”浮标及画布焦点下的反斜线快捷键,松开即显示当前原图。候选以真实字节在文档副本上执行相同裁剪、替换、遮罩及叠层合成;比较仅绘制临时覆盖,不产生采纳、文档修订、撤销或导出副作用。来源、账号、项目、文档版本、模板、花色、图位、候选或请求改变即拒绝旧回执。没有可靠原生映射、Linked或无法准确覆盖的透明合成结果明确不提供对比,不用候选缩略图冒充槽位结果。
- 已采纳图片的图位直接显示“按住对比”。按住时在文档副本显示工程固定模板同一图位的原图,松开恢复当前采纳图。在画布选中该图位后,也可按住反斜线比较。对比仅绘制临时预览,原工程、撤销记录和导出内容不受影响。项目、文档修订、模板、花色、图位或采纳结果变化时丢弃旧预览。固定模板缺少可用原图时提示具体原因。
本批自动化与GPU证据记录于 `output/native-productivity-20261102/`;当前运行窗口保持原包,源码验证不等同于活体窗口更新验收。

View File

@ -625,10 +625,14 @@ impl Backend {
}
fn image_contract(&self, key: &str, choice: &str) -> R<(String, Value)> {
let id = self.image_model_id(choice)?;
if !self.key_catalog(key)?.contains(&id) {
return Err("个人Key未开放此模型".into());
let permitted = self.key_catalog(key)
.map_err(|error| format!("本次生图未提交。模型权限检查失败:{error}"))?;
if !permitted.contains(&id) {
return Err("个人Key未开放此模型,本次生图未提交".into());
}
let contract = crate::jiansun_image_protocol::select(&self.public_image_catalog()?, &id)?;
let catalog = self.public_image_catalog()
.map_err(|error| format!("本次生图未提交。{error}"))?;
let contract = crate::jiansun_image_protocol::select(&catalog, &id)?;
Ok((id, contract))
}
fn refresh_image_models(&mut self, saved: &Value, available: Option<&[String]>) {
@ -1428,7 +1432,7 @@ pub fn start(root: PathBuf, ctx: egui::Context) -> Workspace {
ctx.request_repaint();
return true;
}
let handled_read = if matches!(method.as_str(), "prompt-library-list" | "prompt-library-edit" | "prompt-library-sync" | "project-list" | "candidate-preview-prep") {
let handled_read = if matches!(method.as_str(), "prompt-library-list" | "prompt-library-edit" | "prompt-library-sync" | "project-list" | "template-compare-prep") {
let method = method.clone();
let input = input.clone();
(|| {
@ -1468,18 +1472,18 @@ pub fn start(root: PathBuf, ctx: egui::Context) -> Workspace {
}
return true;
}
if method == "candidate-preview-prep" {
let mut reader = backend.clone();
if method == "template-compare-prep" {
let reader = backend.clone();
let task_events = events.clone();
let task_ctx = ctx.clone();
let task_input = input.clone();
if image_reads.submit(move || {
if let Err(error) = reader.canvas_workspace_action("candidate-preview-prep", &task_input, &task_events, &task_ctx) {
let _ = task_events.send(Event::CandidatePreviewFailed { request: task_input.clone(), error });
if let Err(error) = reader.prepare_template_comparison(&task_input, &task_events) {
let _ = task_events.send(Event::TemplateCompareFailed { request: task_input.clone(), error });
}
task_ctx.request_repaint();
}).is_err() {
let _ = events.send(Event::CandidatePreviewFailed { request: input.clone(), error: "候选预览繁忙,请稍后重试".into() });
let _ = events.send(Event::TemplateCompareFailed { request: input.clone(), error: "模板原图读取繁忙,请稍后再试".into() });
ctx.request_repaint();
}
return true;

View File

@ -630,6 +630,55 @@ fn merge_missing_ending(doc: &mut Document, mut original: Document, meta: &Value
}
impl Backend {
pub(super) fn prepare_template_comparison(&self, input: &Value, events: &mpsc::Sender<Event>) -> R<()> {
use photocraft_doc::{LayerContent, LayerId, SmartSource};
let doc = input["doc"].as_u64().ok_or("请先打开项目")?;
self.ensure_owner(doc)?;
let dir = self.project_dir(doc)?;
let state = load(&dir)?;
let account = &self.auth["account"]["id"];
let local = self.locations.get(&doc).ok_or("原项目不可用")?;
let project = format!("{}|{}|{}", self.origin, account.as_str().unwrap_or("guest"), local);
if !preview_scope_matches(input, &state, account, &self.origin, &project) {
return Err("对比所属项目或固定模板已变化".into());
}
let variant = uuid(&input["variantId"], "花色")?;
let slot = input["slotId"].as_str().ok_or("对比图位缺失")?;
let (output, field) = definition(&state, slot, &variant)?;
let component = output["component"].as_str().ok_or("固定模板组件缺失")?;
if input["outputId"] != component || state["activeOutput"] != component || state["activeVariantId"] != variant
|| input["documentId"] != output["id"] || input["fieldId"] != field["fieldId"]
|| mapped_slot(&state, slot, &variant).is_none_or(|row| row["nativeLayerId"] != input["nativeLayerId"])
{
return Err("对比图位或花色已变化".into());
}
let document = output["id"].as_str().filter(|id| state["activeMapping"] == mapping_key(&variant,component,Some(id)));
let pack = &state["template"];
let original = if pack["enterprise"].is_object() {
self.enterprise_template_canvas(pack, component, document, &variant, |_| {})?
} else {
slot_canvas::skeleton(pack, component, document, &variant)?
};
let original_mapping = mapping(&original).ok_or("固定模板缺少图位映射")?;
let original_field = page_fields(&original_mapping).find(|(id, _)| **id == output["id"])
.and_then(|(_, fields)| fields.iter().find(|f| f["slotId"] == slot && f["fieldId"] == field["fieldId"] && f["kind"] == "image"))
.ok_or("固定模板找不到同一图位的原图")?;
let original_id = original_field["nativeLayerId"].as_u64().ok_or("固定模板原图图层缺失")?;
let layer = original.layer(LayerId(original_id)).ok_or("固定模板原图图层缺失")?;
let has_image = match &layer.content {
LayerContent::Raster(_) => true,
LayerContent::Smart(smart) => match &smart.source {
SmartSource::Embedded { file_name, bytes } => file_name != "template-empty.png" && !bytes.is_empty(),
SmartSource::Linked { .. } => smart.cache.is_some(),
},
_ => false,
};
if !has_image { return Err("该图位在固定模板中没有可用原图".into()); }
events.send(Event::TemplateCompare { layer: Box::new(layer.clone()), request: input.clone() })
.map_err(|_| "工作台已关闭,原图对比未显示".into())
}
pub(super) fn read_pinned_template_image(&self, dir: &Path, target: &Value) -> R<Value> {
let state = load(dir)?;
let pack = &state["template"];
@ -1031,7 +1080,7 @@ impl Backend {
let call = self.image_job(Some(Arc::new(references)), &json!({"doc":doc,"revision":input["baseRevision"],"model":model,"mode":if parent.is_some(){"refine"}else{"generate"},"text":prompt,"screen":output["name"],"references":layers,"slotBinding":binding,"slotFrame":field["frame"],"brand":if knowledge.is_null(){brand}else{json!({"name":creation["brief"]["brandName"],"knowledge":knowledge})},"facts":creation["facts"]}), false, events, ctx);
let file = dir.join("image-jobs").join(&candidate).join("task.json");
let mut journal =
if file.is_file() { read_json(&file)? } else { json!({"id":candidate,"slotBinding":binding,"phase":"prepared","notDispatched":true}) };
if file.is_file() { read_json(&file)? } else { json!({"id":candidate,"slotBinding":binding,"phase":"prepared","notDispatched":true,"message":call.as_ref().err()}) };
let mut call = call;
// Keep the same worker and original candidate until read-only recovery settles.
if matches!(journal["phase"].as_str(), Some("dispatched" | "running" | "unknown")) {
@ -1066,19 +1115,10 @@ impl Backend {
candidate_result = Some(candidate_receipt(&reconcile_candidate(&dir, &journal)?));
}
}
} else if matches!(method, "slot-adopt-prep" | "slot-edit-prep" | "candidate-preview-prep") {
let preview = method == "candidate-preview-prep";
let project = self.locations.get(&doc).map(|local| format!("{}|{}|{}", self.origin, self.auth["account"]["id"].as_str().unwrap_or("guest"), local));
if preview && project.as_deref().is_none_or(|project| !preview_scope_matches(input, &state, &self.auth["account"]["id"], &self.origin, project)) {
return Err("预览所属账号、项目或模板已变化,未读取候选".into());
}
} else if matches!(method, "slot-adopt-prep" | "slot-edit-prep") {
let variant_id = uuid(&input["variantId"], "花色")?;
let id = input["slotId"].as_str().ok_or("请选择图片目标")?;
let (output, field) = definition(&state, id, &variant_id)?;
if preview && (input["outputId"] != output["component"] || state["activeOutput"] != output["component"]
|| state["activeVariantId"] != variant_id) {
return Err("预览目标输出或花色已变化,未读取候选".into());
}
let candidate = uuid(&input["candidateId"], "候选")?;
let record = read_candidate(&dir, &candidate)?;
if record["phase"] != "complete"
@ -1105,19 +1145,13 @@ impl Backend {
if artifact["sha256"] != format!("{:x}", Sha256::digest(&bytes)) {
return Err("候选像素已变化,未采纳".into());
}
let adoption = (!preview).then(|| Uuid::new_v4().to_string());
let meta = json!({"canvasFirst":true,"doc":doc,"accountId":self.auth["account"]["id"],"origin":self.origin,"baseRevision":input["baseRevision"],"workspaceRevision":state["revision"],"workspaceId":state["id"],"templateHash":state["template"]["contentHash"],"structureHash":state["structureHash"],"outputId":output["component"],"documentId":output["id"],"slotId":id,"variantId":variant_id,"candidateId":candidate,"taskId":candidate,"nativeLayerId":layer,"sha256":artifact["sha256"],"fit":field["crop"],"frame":frame});
let mut meta = meta;
if preview {
meta["project"] = json!(project);
meta["previewRequestId"] = input["previewRequestId"].clone();
meta["slotRevision"] = json!(revision(&state));
events.send(Event::CandidatePreview { bytes, meta }).map_err(|_| "工作台已关闭,候选预览未显示")?;
} else if method == "slot-edit-prep" {
if method == "slot-edit-prep" {
meta["purpose"] = json!("professional-edit");
events.send(Event::SlotAdopt { bytes, meta }).map_err(|_| "工作台已关闭,原候选和采用准备保留")?;
} else {
let adoption = adoption.ok_or("采纳身份缺失")?;
let adoption = Uuid::new_v4().to_string();
meta["adoptionId"] = json!(adoption);
write_json(&dir.join("template-outputs").join(format!("canvas-adoption-{adoption}.json")), &json!({"phase":"prepared","meta":meta}))?;
events.send(Event::SlotAdopt { bytes, meta }).map_err(|_| "工作台已关闭,原候选和采用准备保留")?;

View File

@ -615,9 +615,10 @@ impl Backend {
}
let taskdir = dir.join("image-jobs").join(t["id"].as_str().filter(|s| Uuid::parse_str(s).is_ok()).ok_or("任务记录无效")?);
let identity = json!({"doc":id,"accountId":self.auth["account"]["id"],"origin":self.origin,"taskId":t["id"],"slotId":t["slotBinding"]["slotId"],"variantId":t["slotBinding"]["variantId"]});
let progress = |text: &str| {
let progress = |text: &str, dispatched: bool| {
let mut v = identity.clone();
v["text"] = json!(text);
v["dispatched"] = json!(dispatched);
let _ = tx.send(Event::Json("image-progress".into(), Ok(v)));
ctx.request_repaint();
};
@ -638,7 +639,7 @@ impl Backend {
match original_response(
&mut t,
|path, idempotency| {
progress(if idempotency.is_some() { "正在定位原请求…" } else { "正在核查原请求…" });
progress(if idempotency.is_some() { "正在定位原请求…" } else { "正在核查原请求…" }, false);
let diagnostic_file = taskdir.join("recovery-http.json");
let mut diagnostic = if diagnostic_file.exists() { read_json(&diagnostic_file)? } else { json!({"attempts":[]}) };
let kind = if idempotency.is_some() { "lookup" } else { "result" };
@ -696,15 +697,6 @@ impl Backend {
if p["multipart"] != true && !protocol::accepts(&payload, &p["schema"], 0) {
return Err("当前参数不满足98k公开契约,未提交".into());
}
self.image_validate(deadline)?; // Live permission immediately before a paid dispatch.
t["phase"] = json!("dispatched");
job_save(&dir, &t)?;
if t["creationBinding"].is_object() {
// Both journals know the immutable original task before the paid POST.
super::creation::bind_image_dispatch(&dir, &mut t)?;
job_save(&dir, &t)?;
}
progress("98k 正在生成图片…");
let mut req = self
.http
.post(format!("{UPSTREAM}{}", p["path"].as_str().ok_or("模型路径无效")?))
@ -732,7 +724,20 @@ impl Backend {
} else {
req = req.json(&payload);
}
let response = slot_post(&dir, &t, || req.send().map_err(|_| "生成连接中断,结果待核查;不会重发".into()))?;
let (client, request) = req.build_split();
let request = request.map_err(|_| "生图请求准备失败,未提交")?;
self.image_validate(deadline)?; // Live permission immediately before a paid dispatch.
t["phase"] = json!("dispatched");
job_save(&dir, &t)?;
if t["creationBinding"].is_object() {
// Both journals know the immutable original task before the paid POST.
super::creation::bind_image_dispatch(&dir, &mut t)?;
job_save(&dir, &t)?;
}
let response = slot_post(&dir, &t, || {
progress("98k 正在生成图片…", true);
client.execute(request).map_err(|_| "生成连接中断,结果待核查;不会重发".into())
})?;
if let Some(rid) = response.headers().get("x-request-id").and_then(|v| v.to_str().ok()).filter(|s| Uuid::parse_str(s).is_ok()) {
t["requestId"] = json!(rid);
job_save(&dir, &t)?;
@ -751,7 +756,7 @@ impl Backend {
job_save(&dir, &t)?;
}
let uid = t["upstreamTaskId"].as_str().filter(|s| protocol::token(s)).ok_or("任务号无效")?;
progress("正在等待原任务结果…");
progress("正在等待原任务结果…", false);
let (code, v) = body(
self.http
.get(format!("{UPSTREAM}/extensions/v1/tasks/{uid}/result"))
@ -785,7 +790,7 @@ impl Backend {
job_bytes(&dir, &raw_file, &serde_json::to_vec(&raw).map_err(|_| "原响应保存失败")?).map_err(|_| "原结果保存失败,请保留原请求号")?;
let outputs = raw["data"].as_array().filter(|a| a.len() == 1).ok_or("98k图片结果结构无法确认;不会重发")?;
let out = &outputs[0];
progress("正在下载并检查图片…");
progress("正在下载并检查图片…", false);
let bytes = if let Some(b) = out["b64_json"].as_str() {
if b.len() > 28 * 1024 * 1024 {
return Err("图片超过20MiB限制".into());

View File

@ -62,8 +62,8 @@ pub enum Event {
CreationCanvas(Box<Document>, Value),
SlotCanvas(Box<Document>, Value),
SlotAdopt { bytes: Vec<u8>, meta: Value },
CandidatePreview { bytes: Vec<u8>, meta: Value },
CandidatePreviewFailed { request: Value, error: String },
TemplateCompare { layer: Box<photocraft_doc::Layer>, request: Value },
TemplateCompareFailed { request: Value, error: String },
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
@ -2412,7 +2412,7 @@ impl Workspace {
fn receive_json_error(&mut self, method: &str, e: String) {
if method == "slot-append" {
self.canvas_workspace.generation_submission_failed();
self.canvas_workspace.generation_submission_failed(&e);
}
if method == "slot-adopt-prep" {
self.canvas_workspace.pending_adoption = None;
@ -2554,6 +2554,9 @@ impl Workspace {
&& v["origin"] == self.origin
&& v["doc"].as_u64() == app.session.active().map(|s| s.doc.id.0)
{
if v["dispatched"] == true {
self.canvas_workspace.image_dispatched(&v);
}
self.image_progress = v["text"].as_str().unwrap_or("").into();
if let Some(id) = v["taskId"].as_str() {
let text = v["text"].as_str().unwrap_or("").trim_start_matches("98k ");
@ -2966,11 +2969,11 @@ impl Workspace {
self.slot_apply_saved(app, id, rev);
self.project_open_saved(app, id, rev);
}
Event::CandidatePreview { bytes, meta } => {
self.canvas_compare_received(app, ui.ctx(), bytes, meta);
Event::TemplateCompare { layer, request } => {
self.canvas_compare_received(app, *layer, request);
ui.ctx().request_repaint();
}
Event::CandidatePreviewFailed { request, error } => {
Event::TemplateCompareFailed { request, error } => {
self.canvas_compare_failed(&request, error);
ui.ctx().request_repaint();
}

View File

@ -35,8 +35,7 @@ struct CandidateDrawResult {
struct SlotDrawInput<'a> {
row: &'a Row<'a>,
mapping_layer: Option<u64>,
compare_lease: &'a Option<Value>,
hold_requested: bool,
workflow: &'a Value,
blocked_by_overlay: bool,
comparison_owns_primary: bool,
xf: ViewXform,
@ -82,6 +81,7 @@ pub(super) struct State {
regen: Option<Value>,
regen_drafts: BTreeMap<String, String>,
prompt: String,
regen_error: String,
regen_session: u64,
regen_edit_version: u64,
submitted_regen: Option<SubmittedRegen>,
@ -206,32 +206,16 @@ enum AdoptionProgress {
Done(Result<Box<(Document, Option<AdoptionSnapshot>)>, String>),
}
static COMPARE_WORKER_BUSY: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
static COMPARE_REQUEST_ID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
#[derive(Default)]
struct CompareState {
lease: Option<Value>,
requested: bool,
request: Option<Value>,
worker: Option<CompareWorker>,
preview_doc: Option<std::sync::Arc<Document>>,
source_ticket: Option<photocraft_engine::smart_cmds::SourceTicket>,
source_digest: Option<[u8; 32]>,
source_recheck: Option<std::sync::mpsc::Receiver<Result<[u8; 32], String>>>,
source_checked_at: Option<std::time::Instant>,
error: Option<String>,
canvas_armed: bool,
}
struct CompareWorker {
source_ticket: photocraft_engine::smart_cmds::SourceTicket,
approve_recheck: std::sync::mpsc::SyncSender<bool>,
result: std::sync::mpsc::Receiver<CompareProgress>,
}
enum CompareProgress { Prepared, Done(Result<(std::sync::Arc<Document>, [u8; 32]), String>) }
struct AdoptionSnapshot {
before_doc: std::sync::Arc<Document>,
source_digest: [u8; 32],
@ -719,9 +703,49 @@ impl State {
self.regen_edit_version = self.regen_edit_version.wrapping_add(1);
}
pub(super) fn generation_submission_failed(&mut self) {
pub(super) fn generation_submission_failed(&mut self, error: &str) {
self.submitted_composer = None;
self.submitted_regen = None;
if let Some(submitted) = self.submitted_regen.take()
&& self.is_current_regen(&submitted)
{
self.regen_error = error.into();
}
}
fn is_current_regen(&self, submitted: &SubmittedRegen) -> bool {
self.regen_session == submitted.session
&& self.regen_edit_version == submitted.edit_version
&& self.prompt == submitted.text
&& self.regen.as_ref().is_some_and(|current| same_generation_target(&submitted.target, current))
}
fn close_dispatched_regen(&mut self, candidate: &Value) {
if let Some(submitted) = self.submitted_regen.as_ref()
&& submitted.identity.matches(candidate, &submitted.target)
&& self.is_current_regen(submitted)
{
self.regen_drafts.remove(&self.draft_key(&submitted.target));
self.regen = None;
self.prompt.clear();
self.regen_error.clear();
}
}
fn finish_regen_submission(&mut self, candidate: &Value, complete: bool, error: Option<&str>) {
if complete {
self.close_dispatched_regen(candidate);
}
if let Some(submitted) = self.submitted_regen.take_if(|submitted| submitted.identity.matches(candidate, &submitted.target))
&& self.is_current_regen(&submitted)
&& let Some(error) = error
{
self.regen_error = error.into();
}
}
pub(super) fn image_dispatched(&mut self, progress: &Value) {
let candidate = json!({"id":progress["taskId"],"slotId":progress["slotId"],"variantId":progress["variantId"]});
self.close_dispatched_regen(&candidate);
}
pub(super) fn expect_fresh_preview(&mut self, id: &str) {
@ -778,6 +802,7 @@ impl State {
self.regen_drafts.insert(self.draft_key(&target), self.prompt.clone());
}
self.prompt.clear();
self.regen_error.clear();
}
fn open_regen(&mut self, target: Value, workflow: &Value) {
self.invalidate_regen();
@ -1101,18 +1126,7 @@ impl Workspace {
}
if method == "slot-append" {
let complete = value["error"].is_null() && candidate["status"] == "complete";
if let Some(submitted) = self.canvas_workspace.submitted_regen.take_if(|submitted| submitted.identity.matches(candidate, &submitted.target))
&& complete
&& self.canvas_workspace.regen_session == submitted.session
&& self.canvas_workspace.regen_edit_version == submitted.edit_version
&& self.canvas_workspace.prompt == submitted.text
&& self.canvas_workspace.regen.as_ref().is_some_and(|current| same_generation_target(&submitted.target, current))
{
let draft = self.canvas_workspace.draft_key(&submitted.target);
self.canvas_workspace.regen_drafts.remove(&draft);
self.canvas_workspace.regen = None;
self.canvas_workspace.prompt.clear();
}
self.canvas_workspace.finish_regen_submission(candidate, complete, value["error"].as_str());
if let Some(submitted) = self.canvas_workspace.submitted_composer.take_if(|submitted| submitted.identity.matches(candidate, &submitted.target))
&& complete
&& self.canvas_workspace.composer_edit_version == submitted.edit_version
@ -1396,89 +1410,46 @@ impl Workspace {
} else { self.note("已采纳图片,可撤销"); }
Some((meta, true))
}
fn compare_lease(&self, app: &PhotocraftApp) -> Option<Value> {
fn compare_lease(&self, app: &PhotocraftApp, workflow: &Value, slot: &str) -> Option<Value> {
let state = app.session.active()?;
let target = self.canvas_workspace.context.as_ref()?;
if self.canvas_workspace.selection != state.selected_layers().iter().map(|id| id.0).collect::<Vec<_>>() { return None; }
if target["kind"] != "candidate" || target["status"] != "complete" || self.template_workflow["canvasFirst"] != true { return None; }
let project = bound_project(self, state.doc.id.0)?;
let slot = target["slotId"].as_str()?;
let candidate = target["candidateId"].as_str()?;
let layer = target["nativeLayerId"].as_u64()?;
if !state.doc.layer(photocraft_doc::LayerId(layer)).is_some_and(|layer| matches!(&layer.content, LayerContent::Smart(_))) { return None; }
if native_layer(&state.doc, slot) != Some(layer) || target["outputId"] != self.canvas_workspace.output
|| target["productVariantId"] != self.canvas_workspace.variant { return None; }
let row = rows(&self.template_workflow, &self.canvas_workspace.output, &self.canvas_workspace.variant).into_iter()
.find(|row| row.slot["id"] == slot && candidates(row.slot).iter().any(|item| item["id"] == candidate && item["status"] == "complete"))?;
let f = frame(&row)?;
let crop = photocraft_geom::Rect::new(f[0].floor() as i32, f[1].floor() as i32, (f[0]+f[2]).ceil() as i32, (f[1]+f[3]).ceil() as i32).intersect(&state.doc.bounds());
if crop.is_empty() || crop.width() > 8192 || crop.height() > 8192 || u64::from(crop.width()) * u64::from(crop.height()) > 16_777_216 { return None; }
let workspace = self.template_workflow["workspaceId"].as_str().filter(|value| !value.is_empty())?;
let template = self.template_workflow["templateHash"].as_str().filter(|value| !value.is_empty())?;
let structure = self.template_workflow["structureHash"].as_str().filter(|value| !value.is_empty())?;
let workspace_revision = self.template_workflow["revision"].as_u64()?;
Some(json!({"accountId":self.account["id"],"origin":self.origin,"project":project,"doc":state.doc.id.0,"baseRevision":state.revision,
"workspaceId":workspace,"templateHash":template,"structureHash":structure,"workspaceRevision":workspace_revision,"slotRevision":workspace_revision,
"outputId":self.canvas_workspace.output,"variantId":self.canvas_workspace.variant,"slotId":slot,"candidateId":candidate,"taskId":target["taskId"],"nativeLayerId":layer,
"fit":row.slot["crop"],"frame":row.slot["frame"],"crop":[crop.x0,crop.y0,crop.width(),crop.height()]}))
let variant = &self.canvas_workspace.variant;
let output = &self.canvas_workspace.output;
let candidate = adopted(&state.doc, slot, variant)?;
let layer = native_layer(&state.doc, slot)?;
if !matches!(&state.doc.layer(photocraft_doc::LayerId(layer))?.content, LayerContent::Smart(_)) {
return None;
}
let field = workflow["slots"].as_array()?.iter().find(|row|
row["id"] == slot && row["outputId"] == *output && row["variantId"] == *variant && row["kind"] == "image")?;
Some(json!({
"accountId":self.account["id"],"origin":self.origin,"project":project,"doc":state.doc.id.0,"baseRevision":state.revision,
"workspaceId":workflow["workspaceId"],"templateHash":workflow["templateHash"],"structureHash":workflow["structureHash"],
"workspaceRevision":workflow["revision"],"outputId":output,"variantId":variant,"slotId":slot,
"fieldId":field["fieldId"],"documentId":field["documentId"],"candidateId":candidate,"nativeLayerId":layer
}))
}
pub(super) fn canvas_compare_received(&mut self, app: &PhotocraftApp, ctx: &egui::Context, bytes: Vec<u8>, meta: Value) {
use std::sync::atomic::Ordering;
let Some(lease) = self.compare_lease(app) else { self.canvas_workspace.compare = CompareState::default(); return };
let Some(request) = self.canvas_workspace.compare.request.as_ref() else { return };
if !self.canvas_workspace.compare.requested || self.canvas_workspace.compare.lease.as_ref() != Some(&lease) || self.canvas_workspace.compare.worker.is_some()
|| ["accountId","origin","project","doc","baseRevision","workspaceId","templateHash","structureHash","workspaceRevision","slotRevision","outputId","variantId","slotId","candidateId","taskId","nativeLayerId","fit","frame","previewRequestId"]
.iter().any(|key| meta[*key] != request[*key]) || meta["sha256"].as_str().is_none_or(|hash| hash.len() != 64) { return; }
if bytes.len() > 32 * 1024 * 1024 {
self.canvas_workspace.compare.error = Some("候选图片过大,无法生成对比".into());
fn compare_request_matches(&self, app: &PhotocraftApp, workflow: &Value, request: &Value) -> bool {
request["slotId"].as_str().and_then(|slot| self.compare_lease(app, workflow, slot))
.is_some_and(|mut lease| {
lease["previewRequestId"] = request["previewRequestId"].clone();
&lease == request
})
}
pub(super) fn canvas_compare_received(&mut self, app: &PhotocraftApp, mut original: photocraft_doc::Layer, request: Value) {
if self.canvas_workspace.compare.request.as_ref() != Some(&request)
|| !self.compare_request_matches(app, &self.template_workflow, &request) {
return;
}
if COMPARE_WORKER_BUSY.compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire).is_err() {
self.canvas_workspace.compare.requested = false;
return;
}
let Some(state) = app.session.active() else { COMPARE_WORKER_BUSY.store(false, Ordering::Release); return };
let Some(layer) = lease["nativeLayerId"].as_u64() else { COMPARE_WORKER_BUSY.store(false, Ordering::Release); return };
let Some(LayerContent::Smart(smart)) = state.doc.layer(photocraft_doc::LayerId(layer)).map(|layer| &layer.content) else { COMPARE_WORKER_BUSY.store(false, Ordering::Release); return };
let source_ticket = match photocraft_engine::smart_cmds::freeze_source(&app.session, state.doc.id, state.revision, photocraft_doc::LayerId(layer), smart.contents_id) {
Ok(ticket) => ticket,
Err(error) => { COMPARE_WORKER_BUSY.store(false, Ordering::Release); self.canvas_workspace.compare.error = Some(error.to_string()); return; }
};
let worker_ticket = source_ticket.clone();
let doc = state.doc.clone();
let (tx, rx) = std::sync::mpsc::sync_channel(1);
let (approve_recheck, approval) = std::sync::mpsc::sync_channel(1);
let wake_ctx = ctx.clone();
let spawned = std::thread::Builder::new().name("agent-compare-preview".into()).spawn(move || {
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<(std::sync::Arc<Document>, [u8; 32]), String> {
use sha2::Digest;
let actual_hash = format!("{:x}", sha2::Sha256::digest(&bytes));
if meta["sha256"].as_str() != Some(actual_hash.as_str()) { return Err("候选图片校验失败,未显示对比".into()); }
let layer = meta["nativeLayerId"].as_u64().ok_or("图位无效")?;
let source = worker_ticket.read().map_err(|error|error.to_string())?;
let original = original_for_replacement(&doc,photocraft_doc::LayerId(layer),&source)?;
let candidate_source = photocraft_engine::smart_cmds::prepare_bounded_source("candidate.png", std::sync::Arc::new(bytes)).map_err(|error| error.to_string())?;
let mut shadow = photocraft_engine::Session::new();
shadow.add_document(doc.as_ref().clone(), None);
photocraft_engine::smart_cmds::replace_instance_bounded_fit(&mut shadow, photocraft_doc::LayerId(layer), original.as_ref(), &candidate_source, meta["fit"] == "contain").map_err(|e|e.to_string())?;
let prepared = shadow.active().ok_or("预览不可用")?.doc.clone();
tx.send(CompareProgress::Prepared).map_err(|_| "对比准备已取消")?;
wake_ctx.request_repaint();
if !approval.recv_timeout(std::time::Duration::from_secs(30)).unwrap_or(false) { return Err("对比准备已取消".into()); }
let again = worker_ticket.read().map_err(|error|error.to_string())?;
if again.digest != source.digest { return Err("原智能对象源文件已变化,未显示对比".into()); }
Ok((prepared, source.digest))
})).unwrap_or_else(|_| Err("对比预览生成失败".into()));
let _ = tx.send(CompareProgress::Done(result));
COMPARE_WORKER_BUSY.store(false, Ordering::Release);
wake_ctx.request_repaint();
});
if spawned.is_ok() { self.canvas_workspace.compare.worker = Some(CompareWorker { source_ticket, approve_recheck, result:rx }); }
else {
COMPARE_WORKER_BUSY.store(false, Ordering::Release);
self.canvas_workspace.compare.error = Some("对比准备服务无法启动".into());
}
let Some(state) = app.session.active() else { return };
let Some(id) = request["nativeLayerId"].as_u64().map(photocraft_doc::LayerId) else { return };
let mut shadow = state.doc.as_ref().clone();
let Some(target) = shadow.layer_mut(id) else { return };
original.id = id;
*target = original;
self.canvas_workspace.compare.preview_doc = Some(std::sync::Arc::new(shadow));
}
pub(crate) fn canvas_adoption_valid(&self, app: &PhotocraftApp, lease: &Value, started: std::time::Instant) -> bool {
@ -1498,16 +1469,15 @@ impl Workspace {
})
}
pub(crate) fn canvas_compare_valid(&self, app: &PhotocraftApp, lease: &Value, preview_request_id: u64) -> bool {
pub(crate) fn canvas_compare_valid(&self, app: &PhotocraftApp, request: &Value, preview_request_id: u64) -> bool {
let compare = &self.canvas_workspace.compare;
compare.requested && compare.preview_doc.is_some()
&& compare.lease.as_ref() == Some(lease) && self.compare_lease(app).as_ref() == Some(lease)
&& compare.request.as_ref().and_then(|request|request["previewRequestId"].as_u64()) == Some(preview_request_id)
&& compare.source_ticket.as_ref().is_some_and(|ticket|ticket.validate(&app.session).is_ok())
compare.preview_doc.is_some() && compare.request.as_ref() == Some(request)
&& request["previewRequestId"].as_u64() == Some(preview_request_id)
&& self.compare_request_matches(app, &self.template_workflow, request)
}
pub(super) fn canvas_compare_failed(&mut self, request: &Value, message: String) {
if self.canvas_workspace.compare.requested && self.canvas_workspace.compare.request.as_ref() == Some(request) {
if self.canvas_workspace.compare.request.as_ref() == Some(request) {
self.canvas_workspace.compare.error = Some(message);
}
}
@ -1723,139 +1693,76 @@ impl Workspace {
camera
}
fn update_compare_source(&mut self, app: &mut PhotocraftApp, ui: &mut Ui, hold_requested: bool) {
// Verify external source bytes only during a deliberate hold. Each new hold
// starts without a freshness grant, and release discards any pending result.
use std::sync::atomic::Ordering;
let compare = &mut self.canvas_workspace.compare;
if !hold_requested {
compare.source_recheck = None;
compare.source_checked_at = None;
}
if let Some(receiver) = compare.source_recheck.as_ref() {
match receiver.try_recv() {
Ok(result) => {
let valid = compare.source_ticket.as_ref().is_some_and(|ticket| ticket.validate(&app.session).is_ok());
if !valid || result.ok() != compare.source_digest {
compare.preview_doc = None;
compare.source_ticket = None;
compare.error = Some("原智能对象源文件或授权已变化,对比已取消".into());
}
compare.source_recheck = None;
compare.source_checked_at = Some(std::time::Instant::now());
}
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
compare.preview_doc = None;
compare.source_ticket = None;
compare.source_recheck = None;
compare.error = Some("原智能对象源文件校验失败,对比已取消".into());
}
Err(std::sync::mpsc::TryRecvError::Empty) => ui.ctx().request_repaint_after(std::time::Duration::from_millis(100)),
}
}
if hold_requested && compare.preview_doc.is_some() && compare.source_recheck.is_none() {
let interval = std::time::Duration::from_millis(500);
let due = compare.source_checked_at.is_none_or(|at| at.elapsed() >= interval);
if due && COMPARE_WORKER_BUSY.compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire).is_ok() {
if let Some(ticket) = compare.source_ticket.clone().filter(|ticket| ticket.validate(&app.session).is_ok()) {
let (sender, receiver) = std::sync::mpsc::sync_channel(1);
let wake = ui.ctx().clone();
if std::thread::Builder::new().name("agent-compare-source-recheck".into()).spawn(move || {
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| ticket.read().map(|source| source.digest).map_err(|error| error.to_string())))
.unwrap_or_else(|_| Err("原智能对象源文件校验失败".into()));
let _ = sender.send(result);
COMPARE_WORKER_BUSY.store(false, Ordering::Release);
wake.request_repaint();
}).is_ok() {
compare.source_recheck = Some(receiver);
} else {
COMPARE_WORKER_BUSY.store(false, Ordering::Release);
compare.preview_doc = None;
compare.source_ticket = None;
compare.error = Some("原智能对象源文件校验无法启动".into());
}
} else {
COMPARE_WORKER_BUSY.store(false, Ordering::Release);
compare.preview_doc = None;
compare.source_ticket = None;
compare.error = Some("原智能对象授权已变化,对比已取消".into());
}
} else {
ui.ctx().request_repaint_after(interval);
}
}
}
fn prepare_workspace_compare(&mut self, app: &mut PhotocraftApp, ui: &mut Ui, xf: ViewXform) -> (Option<Value>, bool, bool) {
fn prepare_workspace_compare(&mut self, app: &PhotocraftApp, ui: &Ui, xf: ViewXform) -> bool {
#[cfg(not(target_arch = "wasm32"))]
crate::canvas::set_agent_compare(ui.ctx(), None);
let compare_lease = self.compare_lease(app);
let hold_requested = ui.input(|input| {
let pointer = input.pointer.primary_down() && input.pointer.press_origin().is_some_and(|point| {
self.canvas_workspace.geometry.get("compare-hold").is_some_and(|bounds| {
Rect::from_min_size(pos2(bounds[0], bounds[1]), vec2(bounds[2], bounds[3])).contains(point)
})
});
let keyboard = self.canvas_workspace.compare.canvas_armed && input.modifiers == egui::Modifiers::NONE && input.key_down(egui::Key::Backslash);
input.raw.focused && (pointer || keyboard)
}) && !ui.ctx().text_edit_focused() && !egui::Popup::is_any_open(ui.ctx())
&& ui.ctx().memory(|memory| memory.top_modal_layer().is_none()) && app.ui.dialogs.is_empty()
&& self.canvas_workspace.regen.is_none();
if self.canvas_workspace.compare.lease != compare_lease {
let canvas_armed = self.canvas_workspace.compare.lease.is_none() && compare_lease.is_some()
&& self.canvas_workspace.compare.canvas_armed;
self.canvas_workspace.compare = CompareState { lease:compare_lease.clone(), canvas_armed, ..CompareState::default() };
}
if let Some(lease) = compare_lease.as_ref() {
if let Some(task) = lease["taskId"].as_str().filter(|task| !task.is_empty()) { self.agent_images.mark_visible(task); }
if !self.canvas_workspace.compare.requested {
if COMPARE_WORKER_BUSY.load(std::sync::atomic::Ordering::Acquire) {
ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));
} else {
let mut request = lease.clone();
request["previewRequestId"] = json!(COMPARE_REQUEST_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed) % 9_007_199_254_740_991 + 1);
if self.tx.send(Request::Action("candidate-preview-prep".into(), request.clone())).is_ok() {
self.canvas_workspace.compare.requested = true;
self.canvas_workspace.compare.request = Some(request);
}
}
}
if let Some(worker) = self.canvas_workspace.compare.worker.as_ref() {
match worker.result.try_recv() {
Ok(CompareProgress::Prepared) => {
let valid = worker.source_ticket.validate(&app.session).is_ok() && self.compare_lease(app).as_ref() == Some(lease);
let _ = worker.approve_recheck.send(valid);
ui.ctx().request_repaint_after(std::time::Duration::from_millis(32));
}
Ok(CompareProgress::Done(result)) => {
let valid = worker.source_ticket.validate(&app.session).is_ok() && self.compare_lease(app).as_ref() == Some(lease);
match result {
Ok((doc, digest)) if valid => {
self.canvas_workspace.compare.source_digest = Some(digest);
self.canvas_workspace.compare.source_checked_at = None;
self.canvas_workspace.compare.preview_doc = Some(doc);
self.canvas_workspace.compare.source_ticket = Some(worker.source_ticket.clone());
}
Ok(_) => self.canvas_workspace.compare.error = Some("原项目或权限已变化,对比已取消".into()),
Err(error) => self.canvas_workspace.compare.error = Some(error),
}
self.canvas_workspace.compare.worker = None;
}
Err(std::sync::mpsc::TryRecvError::Disconnected) => { self.canvas_workspace.compare.error = Some("对比准备服务已停止".into()); self.canvas_workspace.compare.worker = None; }
Err(std::sync::mpsc::TryRecvError::Empty) => ui.ctx().request_repaint_after(std::time::Duration::from_millis(32)),
}
}
self.update_compare_source(app, ui, hold_requested);
}
let blocked_by_overlay = ui.ctx().memory(|memory| memory.top_modal_layer().is_some()) || egui::Popup::is_any_open(ui.ctx())
let blocked = ui.ctx().memory(|memory| memory.top_modal_layer().is_some()) || egui::Popup::is_any_open(ui.ctx())
|| !app.ui.dialogs.is_empty() || self.canvas_workspace.regen.is_some()
|| !ui.input(|input| input.raw.focused);
if blocked_by_overlay || ui.ctx().text_edit_focused() || ui.input(|input| input.key_pressed(egui::Key::Escape)) {
if self.canvas_workspace.compare.request.as_ref().is_some_and(|request|
!self.compare_request_matches(app, &self.template_workflow, request))
{
self.canvas_workspace.compare = CompareState::default();
}
if blocked || ui.ctx().text_edit_focused() || ui.input(|input| input.key_pressed(egui::Key::Escape)) {
self.canvas_workspace.compare.canvas_armed = false;
} else if ui.input(|input| input.pointer.any_pressed()) {
self.canvas_workspace.compare.canvas_armed = ui.input(|input| input.pointer.interact_pos().is_some_and(|point| xf.rect.contains(point)));
}
(compare_lease, hold_requested, blocked_by_overlay)
blocked
}
fn draw_compare_button(&mut self, app: &PhotocraftApp, ui: &mut Ui, workflow: &Value, slot: &str, rect: Rect, blocked: bool) -> bool {
let Some(mut lease) = self.compare_lease(app, workflow, slot) else { return false };
let compare = &mut self.canvas_workspace.compare;
let nonce = compare.request.as_ref().map_or(Value::Null, |request| request["previewRequestId"].clone());
lease["previewRequestId"] = nonce;
let same = compare.request.as_ref() == Some(&lease);
let error = compare.error.as_deref().filter(|_| same);
let label = if error.is_some() { "原图不可用" } else if same && compare.preview_doc.is_none() { "读取原图" } else { "按住对比" };
let hint = error.unwrap_or("按住查看固定模板原图,松开回到已采纳图片。画布聚焦时也可按住反斜杠。");
let enabled = !blocked && !ui.ctx().text_edit_focused() && !ui.input(|input| input.pointer.middle_down());
let button_rect = Rect::from_min_size(rect.right_top() + vec2(-87.0, 7.0), vec2(81.0, 32.0));
let mut controls = ui.new_child(egui::UiBuilder::new().id_salt(("compare-hold",slot)).max_rect(button_rect)
.layout(egui::Layout::top_down_justified(egui::Align::Center)));
controls.set_clip_rect(rect.intersect(ui.clip_rect()));
let hold = kit::action_button(&mut controls, label, kit::ButtonRole::Secondary, enabled);
if !ui.input(|input| input.pointer.primary_down() || input.key_down(egui::Key::Backslash)) {
hold.clone().on_hover_text(hint);
}
let bounds = [hold.rect.min.x,hold.rect.min.y,hold.rect.width(),hold.rect.height()];
self.canvas_workspace.geometry.insert(format!("compare-hold:{slot}"), bounds);
self.canvas_workspace.geometry.entry("compare-hold".into()).or_insert(bounds);
let keyboard_target = self.canvas_workspace.context.as_ref().and_then(|target| target["slotId"].as_str())
.or_else(|| compare.request.as_ref().and_then(|request| request["slotId"].as_str()));
let (pointer_held, key_held, pressed, released) = ui.input(|input| {
let over_button = input.pointer.press_origin().is_some_and(|point| hold.rect.intersect(rect).contains(point));
let keyboard = compare.canvas_armed && keyboard_target == Some(slot) && input.modifiers == egui::Modifiers::NONE;
(over_button && input.pointer.primary_down(), keyboard && input.key_down(egui::Key::Backslash),
(over_button && input.pointer.primary_pressed()) || (keyboard && input.key_pressed(egui::Key::Backslash)),
input.pointer.primary_released() && hold.hovered())
});
let held = pointer_held || key_held;
// Prepare the first visible adopted slot while the user approaches it.
// Subsequent slots prepare on hover once the previous read has settled.
let prewarm = compare.request.is_none() || (hold.hovered() && compare.preview_doc.is_some());
if enabled && (held || prewarm) {
if !same || (error.is_some() && pressed) {
lease["previewRequestId"] = json!(COMPARE_REQUEST_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed) % 9_007_199_254_740_991 + 1);
if self.tx.send(Request::Action("template-compare-prep".into(), lease.clone())).is_ok() {
compare.request = Some(lease);
compare.preview_doc = None;
compare.error = None;
}
} else if held && let (Some(doc), Some(request_id)) = (&compare.preview_doc, lease["previewRequestId"].as_u64()) {
#[cfg(not(target_arch = "wasm32"))]
crate::canvas::set_agent_compare(ui.ctx(), Some(crate::canvas::AgentComparePreview {
doc:doc.clone(), lease, preview_request_id:request_id, hold_rect:hold.rect, keyboard_armed:key_held,
}));
self.canvas_workspace.geometry.insert("compare-active".into(), [rect.min.x,rect.min.y,rect.width(),rect.height()]);
}
}
enabled && (pointer_held || released)
}
fn candidate_context_menu(&mut self, ui: &mut Ui, input: CandidateMenuInput<'_>) -> CandidateMenuResult {
@ -1957,7 +1864,7 @@ impl Workspace {
}
fn draw_workspace_slot(&mut self, app: &mut PhotocraftApp, ui: &mut Ui, input: SlotDrawInput<'_>) -> (bool, bool, bool) {
let SlotDrawInput { row, mapping_layer, compare_lease, hold_requested, blocked_by_overlay, mut comparison_owns_primary, xf, doc_id, variant, variant_label, world_pointer, now, painter } = input;
let SlotDrawInput { row, mapping_layer, workflow, blocked_by_overlay, mut comparison_owns_primary, xf, doc_id, variant, variant_label, world_pointer, now, painter } = input;
let slot_id = row.slot["id"].as_str().unwrap_or("");
let mut blocked = false;
let mut pointer_on_image = false;
@ -1969,41 +1876,12 @@ impl Workspace {
if rect.intersects(xf.rect) {
self.canvas_workspace.geometry.insert(format!("slot:{slot_id}"), [rect.min.x, rect.min.y, rect.width(), rect.height()]);
}
if let Some(lease) = compare_lease.as_ref().filter(|lease| lease["slotId"] == slot_id)
&& rect.intersects(xf.rect)
let visible = rect.intersect(xf.rect);
if visible.width() >= 107.0 && visible.height() >= 44.0
&& self.draw_compare_button(app, ui, workflow, slot_id, visible, blocked_by_overlay)
{
let button_rect = Rect::from_min_size(pos2(rect.right()-126.0, rect.top()+8.0), vec2(118.0, 30.0));
let mut controls = ui.new_child(egui::UiBuilder::new().id_salt(("compare-hold",slot_id)).max_rect(button_rect));
let ready = self.canvas_workspace.compare.preview_doc.is_some();
let label = if self.canvas_workspace.compare.error.is_some() { "对比不可用" } else if ready { "按住对比" } else { "准备对比…" };
let hint = self.canvas_workspace.compare.error.as_deref().map(|raw| {
let message=super::operation_error::message(raw);
format!("{}\n{}",message.title,message.reason.unwrap_or(""))
}).unwrap_or_else(||"按住显示候选,松开恢复;画布聚焦时可按住反斜杠".into());
let middle_pan = ui.input(|input| input.pointer.button_down(egui::PointerButton::Middle));
let hold = super::stitch_ui::action_button(&mut controls, label, super::stitch_ui::ButtonRole::Secondary, ready && !blocked_by_overlay && !middle_pan)
.on_hover_text(hint);
self.canvas_workspace.geometry.insert("compare-hold".into(), [hold.rect.min.x,hold.rect.min.y,hold.rect.width(),hold.rect.height()]);
let owns_primary = (hold.is_pointer_button_down_on() && ui.input(|input| input.pointer.primary_down()))
|| (hold.hovered() && ui.input(|input| input.pointer.primary_released()));
if owns_primary { blocked = true; comparison_owns_primary = true; }
let key_held = self.canvas_workspace.compare.canvas_armed && !blocked_by_overlay
&& ui.input(|input| input.modifiers == egui::Modifiers::NONE && input.key_down(egui::Key::Backslash));
let pointer_held = !blocked_by_overlay && hold.is_pointer_button_down_on() && ui.input(|input| input.pointer.primary_down());
let fresh = self.canvas_workspace.compare.source_recheck.is_none()
&& self.canvas_workspace.compare.source_checked_at.is_some_and(|at| at.elapsed() < std::time::Duration::from_millis(500));
if hold_requested && fresh && let (Some(doc), Some(request_id)) = (self.canvas_workspace.compare.preview_doc.as_ref(),
self.canvas_workspace.compare.request.as_ref().and_then(|request|request["previewRequestId"].as_u64())) {
#[cfg(not(target_arch = "wasm32"))]
crate::canvas::set_agent_compare(ui.ctx(), Some(crate::canvas::AgentComparePreview {
doc:doc.clone(), lease:lease.clone(), preview_request_id:request_id,
hold_rect:hold.rect, keyboard_armed:self.canvas_workspace.compare.canvas_armed,
}));
if key_held || pointer_held {
self.canvas_workspace.geometry.insert("compare-active".into(), [rect.min.x,rect.min.y,rect.width(),rect.height()]);
}
}
blocked = true;
comparison_owns_primary = true;
}
let empty=mapping_layer.and_then(|id|app.session.active()?.doc.layer(photocraft_doc::LayerId(id)))
.is_some_and(|layer|matches!(&layer.content,LayerContent::Smart(smart)if matches!(&smart.source,photocraft_doc::SmartSource::Embedded{file_name,..}if file_name=="template-empty.png")));
@ -2682,7 +2560,7 @@ impl Workspace {
return (false, self.plain_workspace_camera(app, ui, xf, doc_id, width));
}
super::glow_pill::bind(ui, app.gpu_render_state.as_ref());
let (compare_lease, hold_requested, blocked_by_overlay) = self.prepare_workspace_compare(app, ui, xf);
let blocked_by_overlay = self.prepare_workspace_compare(app, ui, xf);
let workflow = std::mem::take(&mut self.template_workflow);
let mut clear_references = false;
let output = self.canvas_workspace.output.clone();
@ -2738,7 +2616,7 @@ impl Workspace {
let slot_id = row.slot["id"].as_str().unwrap_or("");
let mapping_layer = row.slot["nativeLayerId"].as_u64().or_else(|| layer_map.get(slot_id).copied());
let slot = self.draw_workspace_slot(app, ui, SlotDrawInput {
row, mapping_layer, compare_lease: &compare_lease, hold_requested, blocked_by_overlay, comparison_owns_primary, xf, doc_id,
row, mapping_layer, workflow: &workflow, blocked_by_overlay, comparison_owns_primary, xf, doc_id,
variant: &variant, variant_label: &variant_label, world_pointer, now, painter: &painter,
});
blocked |= slot.0;
@ -2827,7 +2705,7 @@ impl Workspace {
action = None;
}
if (!over_reference && !blocked) || self.canvas_workspace.direct_image_drag.is_some() {
blocked |= self.edit_canvas_image(app, ui, xf, &rows, &layer_map, editing_enabled && !hold_requested);
blocked |= self.edit_canvas_image(app, ui, xf, &rows, &layer_map, editing_enabled && !self.canvas_workspace.geometry.contains_key("compare-active"));
}
if pointer.is_some() && !pointer_on_image && !blocked && !egui::Popup::is_any_open(ui.ctx())
&& ui.input(|input| input.pointer.primary_clicked()) {
@ -2979,8 +2857,8 @@ impl Workspace {
closed = kit::icon_button(ui, "x", 28.0, false, "关闭").clicked();
});
});
if !self.error.is_empty() {
kit::status_chip(ui, &self.error, kit::StatusTone::Error);
if !self.canvas_workspace.regen_error.is_empty() {
kit::status_chip(ui, &self.canvas_workspace.regen_error, kit::StatusTone::Error);
}
ui.add_space(5.0);
let using_template = regeneration_template_prompt(&self.template_workflow, &target) == Some(prompt.as_str());
@ -3057,10 +2935,11 @@ impl Workspace {
if open && (closed || cancel || response.is_some_and(|r| r.should_close()) || ui.input_mut(|input| input.consume_key(egui::Modifiers::NONE, egui::Key::Escape))) {
self.canvas_workspace.invalidate_regen();
}
if submit
&& let Err(error) = self.submit_regeneration(app)
{
self.error = error;
if submit {
self.canvas_workspace.regen_error.clear();
if let Err(error) = self.submit_regeneration(app) {
self.canvas_workspace.regen_error = error;
}
}
}
}
@ -3493,117 +3372,83 @@ mod tests {
assert_eq!(location(doc, &rows, &target, 1440.0, &images), Some(fit_candidate(bounds, vec2(16.0, 8.0))));
}
#[test]
fn comparison_hold_uses_real_candidate_composite_and_releases_without_editing() {
let (mut w, mut app, requests, layer, bytes) = native_fixture();
fn comparison_fixture() -> (Workspace, PhotocraftApp, mpsc::Receiver<Request>, u64, photocraft_doc::Layer) {
let (mut workspace, mut app, requests, layer, bytes) = native_fixture();
warm_fixture_target(&mut app, layer);
w.library = false;
w.canvas_workspace.initial_focus = false;
let state = app.session.active().unwrap();
let state = app.session.active_mut().unwrap();
Arc::make_mut(&mut state.doc).metadata.text.push(("jiansun.adopted.wood.image-slot".into(), "already-adopted".into()));
let doc = state.doc.id.0;
let revision = state.revision;
let original = state.doc.as_ref().clone();
let history = state.history.entries();
w.open_projects.insert(doc, w.local_identity("comparison-fixture"));
w.template_workflow["structureHash"] = json!("real-test-structure");
w.template_workflow["slots"][0]["frame"] = json!({"x":30,"y":40,"width":100,"height":50});
w.template_workflow["slots"][0]["crop"] = json!("contain");
w.template_workflow["slots"][0]["nativeLayerId"] = json!(layer);
w.template_workflow["slots"][0]["candidates"] = json!([{"id":"candidate-real-png","taskId":"candidate-real-png","status":"complete"}]);
let target = scope(&w.template_workflow["slots"][0], Some(&w.template_workflow["slots"][0]["candidates"][0]), "wood", "木色");
w.canvas_workspace.context = Some(target);
w.canvas_workspace.selection = app.session.active().unwrap().selected_layers().iter().map(|id|id.0).collect();
let lease = w.compare_lease(&app).expect("real matching candidate and slot");
w.canvas_workspace.compare.lease = Some(lease.clone());
w.canvas_workspace.compare.requested = true;
let mut request = lease.clone();
request["previewRequestId"] = json!(1);
w.canvas_workspace.compare.request = Some(request.clone());
let mut meta = request;
use sha2::Digest;
meta["sha256"] = json!(format!("{:x}", sha2::Sha256::digest(&bytes)));
let id = photocraft_doc::LayerId(layer);
let mut template = photocraft_engine::Session::new();
template.add_document(state.doc.as_ref().clone(), None);
let source = photocraft_engine::smart_cmds::prepare_bounded_source("pinned.png", Arc::new(bytes)).unwrap();
let base = photocraft_engine::smart_cmds::prepare_bounded_source(
"base.png", photocraft_engine::smart_cmds::contents_of(&state.doc, id).unwrap().1
).unwrap();
photocraft_engine::smart_cmds::replace_instance_bounded_fit(&mut template, id, Some(&base), &source, true).unwrap();
let pinned = template.active().unwrap().doc.layer(id).unwrap().clone();
workspace.library = false;
workspace.canvas_workspace.initial_focus = false;
workspace.open_projects.insert(doc, workspace.local_identity("comparison-fixture"));
workspace.template_workflow["structureHash"] = json!("real-test-structure");
workspace.template_workflow["slots"][0]["fieldId"] = json!("S01-I01");
workspace.template_workflow["slots"][0]["frame"] = json!({"x":30,"y":40,"width":240,"height":90});
workspace.template_workflow["slots"][0]["nativeLayerId"] = json!(layer);
(workspace, app, requests, layer, pinned)
}
#[test]
fn comparison_shows_pinned_original_without_selecting_a_candidate_or_editing() {
let (mut w, mut app, requests, layer, pinned) = comparison_fixture();
let doc = app.session.active().unwrap().doc.clone();
let revision = app.session.active().unwrap().revision;
let history = app.session.active().unwrap().history.entries();
let ctx = egui::Context::default();
let wakes = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let wake_count = wakes.clone();
ctx.set_request_repaint_callback(move |_| { wake_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed); });
let mut stale = meta.clone();
stale["previewRequestId"] = json!(2);
w.canvas_compare_received(&app, &ctx, bytes.clone(), stale.clone());
workspace_frame_at(&mut w, &mut app, &ctx, vec![], None);
assert_ne!(w.canvas_workspace.context.as_ref().map(|target| &target["kind"]), Some(&json!("candidate")));
let bounds = w.canvas_workspace.geometry["compare-hold:image-slot"];
let point = pos2(bounds[0] + bounds[2] * 0.5, bounds[1] + bounds[3] * 0.5);
let button = |pressed| egui::Event::PointerButton {
pos:point,button:egui::PointerButton::Primary,pressed,modifiers:egui::Modifiers::NONE
};
workspace_frame_at(&mut w, &mut app, &ctx, vec![egui::Event::PointerMoved(point),button(true)], None);
let request = requests.try_iter().find_map(|request| match request {
Request::Action(method, input) if method == "template-compare-prep" => Some(input), _ => None,
}).expect("adopted canvas slot requests the template original");
assert_eq!(request["candidateId"], "already-adopted");
assert_eq!(request["fieldId"], "S01-I01");
let mut stale = request.clone();
stale["previewRequestId"] = json!(0);
w.canvas_compare_received(&app, pinned.clone(), stale.clone());
w.canvas_compare_failed(&stale, "old failure".into());
assert!(w.canvas_workspace.compare.worker.is_none() && w.canvas_workspace.compare.error.is_none(), "old success and failure cannot claim the new request");
w.canvas_compare_received(&app, &ctx, bytes, meta);
assert!(w.canvas_workspace.compare.worker.is_some(), "real candidate bytes must enter worker");
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(15);
while wakes.load(std::sync::atomic::Ordering::Relaxed) == 0 {
assert!(std::time::Instant::now() < deadline, "background completion must wake the UI without another frame");
std::thread::yield_now();
}
while w.canvas_workspace.compare.worker.is_some() {
workspace_frame_at(&mut w, &mut app, &ctx, vec![], None);
assert!(std::time::Instant::now() < deadline);
std::thread::yield_now();
}
assert!(wakes.load(std::sync::atomic::Ordering::Relaxed) > 0, "background completion must wake the UI");
assert!(w.canvas_workspace.compare.preview_doc.is_some(), "real replacement document must be prepared");
let rect = w.canvas_workspace.geometry["compare-hold"];
let point = pos2(rect[0] + rect[2]/2.0, rect[1] + rect[3]/2.0);
workspace_frame_at(&mut w, &mut app, &ctx, vec![egui::Event::PointerMoved(point),egui::Event::PointerButton {pos:point,button:egui::PointerButton::Primary,pressed:true,modifiers:egui::Modifiers::NONE}], None);
assert!(!w.canvas_workspace.geometry.contains_key("compare-active"), "a new hold waits for source verification");
while !w.canvas_workspace.geometry.contains_key("compare-active") {
workspace_frame_at(&mut w, &mut app, &ctx, vec![], None);
assert!(std::time::Instant::now() < deadline, "held source verification must complete");
std::thread::yield_now();
}
workspace_frame_at(&mut w, &mut app, &ctx, vec![egui::Event::PointerButton {pos:point,button:egui::PointerButton::Primary,pressed:false,modifiers:egui::Modifiers::NONE}], None);
assert!(!w.canvas_workspace.geometry.contains_key("compare-active"), "release restores current canvas");
let key = |pressed| egui::Event::Key { key:egui::Key::Backslash, physical_key:Some(egui::Key::Backslash), pressed, repeat:false, modifiers:egui::Modifiers::NONE };
workspace_frame_at(&mut w, &mut app, &ctx, vec![key(true)], None);
assert!(!w.canvas_workspace.geometry.contains_key("compare-active"), "a new keyboard hold must reverify the source");
while !w.canvas_workspace.geometry.contains_key("compare-active") {
workspace_frame_at(&mut w, &mut app, &ctx, vec![], None);
assert!(std::time::Instant::now() < deadline, "keyboard hold source verification must complete");
std::thread::yield_now();
}
workspace_frame_at(&mut w, &mut app, &ctx, vec![key(false)], None);
assert!(!w.canvas_workspace.geometry.contains_key("compare-active"), "shortcut release restores canvas");
let middle = egui::Event::PointerButton {pos:point,button:egui::PointerButton::Middle,pressed:true,modifiers:egui::Modifiers::NONE};
assert!(!workspace_frame_at(&mut w, &mut app, &ctx, vec![egui::Event::PointerMoved(point), middle], None).0, "comparison must not consume middle-button pan");
workspace_frame_at(&mut w, &mut app, &ctx, vec![egui::Event::PointerButton {pos:point,button:egui::PointerButton::Middle,pressed:false,modifiers:egui::Modifiers::NONE}], None);
assert_eq!(app.session.active().unwrap().doc.as_ref(), &original);
assert!(w.canvas_workspace.compare.preview_doc.is_none() && w.canvas_workspace.compare.error.is_none());
w.canvas_compare_received(&app, pinned.clone(), request);
let shadow = w.canvas_workspace.compare.preview_doc.as_ref().unwrap();
assert_eq!(shadow.layer(photocraft_doc::LayerId(layer)), Some(&pinned));
assert_eq!(shadow.layers.last(), doc.layers.last());
workspace_frame_at(&mut w, &mut app, &ctx, vec![], None);
assert!(w.canvas_workspace.geometry.contains_key("compare-active"));
workspace_frame_at(&mut w, &mut app, &ctx, vec![button(false)], None);
assert!(!w.canvas_workspace.geometry.contains_key("compare-active"));
assert_eq!(app.session.active().unwrap().doc, doc);
assert_eq!(app.session.active().unwrap().revision, revision);
assert_eq!(app.session.active().unwrap().history.entries(), history);
assert!(requests.try_iter().all(|event| !matches!(event, Request::Action(method, _) if method == "slot-adopt-prep" || method == "slot-adopted")));
w.account["id"] = json!("another-account");
workspace_frame_at(&mut w, &mut app, &ctx, vec![], None);
assert!(w.canvas_workspace.compare.preview_doc.is_none(), "scope change drops comparison pixels");
assert!(w.canvas_workspace.compare.preview_doc.is_none());
}
#[test]
#[ignore = "native GPU comparison evidence; requires PHOTOCRAFT_AGENT_QA_OUT"]
fn comparison_visual_acceptance() {
use sha2::Digest;
let directory = std::env::var("PHOTOCRAFT_AGENT_QA_OUT").expect("explicit evidence directory");
let (mut w, mut app, requests, layer, bytes) = native_fixture();
warm_fixture_target(&mut app, layer);
w.library = false;
w.material = false;
w.creation_open = false;
w.canvas_workspace.initial_focus = false;
let state = app.session.active().unwrap();
let doc = state.doc.id.0;
let original = state.doc.as_ref().clone();
let revision = state.revision;
let crop = photocraft_compose::layer_bounds(state.doc.layer(photocraft_doc::LayerId(layer)).unwrap(), state.doc.bounds()).intersect(&state.doc.bounds());
w.open_projects.insert(doc, w.local_identity("comparison-visual-fixture"));
w.template_workflow["structureHash"] = json!("fixture-structure");
w.template_workflow["slots"][0]["frame"] = json!({"x":crop.x0,"y":crop.y0,"width":crop.width(),"height":crop.height()});
w.template_workflow["slots"][0]["crop"] = json!("contain");
w.template_workflow["slots"][0]["nativeLayerId"] = json!(layer);
w.template_workflow["slots"][0]["candidates"] = json!([{"id":"comparison-visual-candidate","taskId":"comparison-visual-candidate","status":"complete"}]);
w.canvas_workspace.context = Some(scope(&w.template_workflow["slots"][0], Some(&w.template_workflow["slots"][0]["candidates"][0]), "wood", "木色"));
w.canvas_workspace.selection = app.session.active().unwrap().selected_layers().iter().map(|id|id.0).collect();
let (w, mut app, requests, _, pinned) = comparison_fixture();
let original = app.session.active().unwrap().doc.clone();
let revision = app.session.active().unwrap().revision;
let view = &mut app.ui.views[0];
view.center = [(crop.x0 as f32 + crop.x1 as f32)/2.0,(crop.y0 as f32 + crop.y1 as f32)/2.0];
view.center = [150.0, 85.0];
view.zoom = 2.0;
view.fit_pending = false;
view.fill_pending = false;
@ -3612,40 +3457,33 @@ mod tests {
let mut h = egui_kittest::Harness::builder().with_size(vec2(800.0,600.0)).wgpu().build_ui_state(
|ui,app:&mut PhotocraftApp| {
let view = app.ui.views[0].clone();
let rect = ui.max_rect();
let view = crate::canvas::canvas_view(app,ui,0,rect,view,true);
app.ui.views[0] = view;
app.ui.views[0] = crate::canvas::canvas_view(app,ui,0,ui.max_rect(),view,true);
}, app);
crate::PhotocraftApp::setup_context(&h.ctx,crate::theme::ThemeKind::ProMedium);
h.run_steps(4);
let request = requests.try_iter().find_map(|request| match request {
Request::Action(method, input) if method == "candidate-preview-prep" => Some(input), _ => None,
}).expect("actual selected candidate requests read-only preview");
let mut meta = request.clone();
meta["sha256"] = json!(format!("{:x}",sha2::Sha256::digest(&bytes)));
let ctx = h.ctx.clone();
{
let app = h.state_mut();
let mut w = app.jiansun.take().unwrap();
w.canvas_compare_received(app,&ctx,bytes,meta);
app.jiansun = Some(w);
}
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(15);
while h.state().jiansun.as_ref().unwrap().canvas_workspace.compare.preview_doc.is_none() {
h.run_steps(1);
assert!(std::time::Instant::now() < deadline, "real worker preview timed out: {:?}",h.state().jiansun.as_ref().unwrap().canvas_workspace.compare.error);
std::thread::yield_now();
}
h.run_steps(2);
let before = h.render().expect("native before GPU presentation");
before.save(std::path::Path::new(&directory).join("comparison-before.png")).unwrap();
let w = h.state().jiansun.as_ref().unwrap();
let hold = w.canvas_workspace.geometry["compare-hold"];
let hold = w.canvas_workspace.geometry["compare-hold:image-slot"];
let slot = w.canvas_workspace.geometry["slot:image-slot"];
let sample = ((slot[0]+slot[2]*0.5) as u32,(slot[1]+slot[3]-5.0) as u32);
let sample = ((slot[0]+60.0) as u32,(slot[1]+56.0) as u32);
let point = pos2(hold[0]+hold[2]/2.0,hold[1]+hold[3]/2.0);
h.event(egui::Event::PointerMoved(point));
h.event(egui::Event::PointerButton {pos:point,button:egui::PointerButton::Primary,pressed:true,modifiers:egui::Modifiers::NONE});
let button = |pressed| egui::Event::PointerButton {
pos:point,button:egui::PointerButton::Primary,pressed,modifiers:egui::Modifiers::NONE
};
h.event(button(true));
h.run_steps(2);
let request = requests.try_iter().find_map(|request| match request {
Request::Action(method, input) if method == "template-compare-prep" => Some(input), _ => None,
}).expect("native button requests the fixed original");
{
let app = h.state_mut();
let mut w = app.jiansun.take().unwrap();
w.canvas_compare_received(app, pinned, request);
app.jiansun = Some(w);
}
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(15);
let held = loop {
h.run_steps(1);
let image = h.render().expect("native held comparison GPU presentation");
@ -3654,12 +3492,12 @@ mod tests {
std::thread::yield_now();
};
held.save(std::path::Path::new(&directory).join("comparison-held.png")).unwrap();
h.event(egui::Event::PointerButton {pos:point,button:egui::PointerButton::Primary,pressed:false,modifiers:egui::Modifiers::NONE});
h.event(button(false));
h.run_steps(2);
let released = h.render().expect("native released GPU presentation");
released.save(std::path::Path::new(&directory).join("comparison-released.png")).unwrap();
assert_eq!(before.get_pixel(sample.0,sample.1),released.get_pixel(sample.0,sample.1),"release restores native pixel");
assert_eq!(h.state().session.active().unwrap().doc.as_ref(), &original);
assert_eq!(before.get_pixel(sample.0,sample.1),released.get_pixel(sample.0,sample.1));
assert_eq!(h.state().session.active().unwrap().doc, original);
assert_eq!(h.state().session.active().unwrap().revision, revision);
}
@ -4255,7 +4093,7 @@ mod tests {
#[test]
fn regeneration_ack_preserves_reopened_changed_and_other_target_drafts() {
for scenario in ["untouched", "other-slot", "edited-back", "cancel-reopen", "unknown", "failed", "error"] {
for scenario in ["untouched", "dispatched", "other-slot", "edited-back", "cancel-reopen", "unknown", "failed", "error"] {
let (mut w, app, requests, layer, _) = native_fixture();
w.busy = None;
let target = json!({"kind":"slot","slotId":"image-slot","productVariantId":"wood","outputId":"detail","nativeLayerId":layer});
@ -4265,6 +4103,9 @@ mod tests {
w.submit_regeneration(&app).unwrap();
assert!(matches!(requests.try_recv().unwrap(), Request::Action(method,_) if method == "slot-append"));
w.canvas_receipt("slot-progress", &prepared_for("image-slot", "wood", &["finished-candidate"]));
assert!(w.canvas_workspace.regen.is_some(), "reserving a candidate does not confirm dispatch");
w.canvas_workspace.image_dispatched(&json!({"taskId":"another-candidate","slotId":"image-slot","variantId":"wood"}));
assert!(w.canvas_workspace.regen.is_some(), "a different candidate cannot dismiss the dialog");
let mut receipt = receipt_for("image-slot", "wood", "complete");
match scenario {
"other-slot" => {
@ -4284,11 +4125,22 @@ mod tests {
}
"unknown" => receipt["candidateResult"]["status"] = json!("unknown"),
"failed" => receipt["candidateResult"]["status"] = json!("failed"),
"error" => receipt["error"] = json!("请求未完成"),
"error" => {
receipt["candidateResult"]["status"] = json!("failed");
receipt["error"] = json!("本次生图未提交。模型权限检查超时");
}
_ => {}
}
if matches!(scenario, "dispatched" | "other-slot" | "edited-back" | "cancel-reopen") {
w.canvas_workspace.image_dispatched(&json!({"taskId":"finished-candidate","slotId":"image-slot","variantId":"wood"}));
assert_eq!(w.canvas_workspace.regen.is_none(), scenario == "dispatched", "only the untouched submitted dialog closes before completion");
assert!(w.canvas_workspace.submitted_regen.is_some(), "the pending card keeps the submitted target until the terminal receipt");
}
w.canvas_receipt("slot-append", &receipt);
if scenario == "untouched" {
if scenario == "error" {
assert_eq!(w.canvas_workspace.regen_error, "本次生图未提交。模型权限检查超时");
}
if matches!(scenario, "untouched" | "dispatched") {
assert!(w.canvas_workspace.regen.is_none() && w.canvas_workspace.prompt.is_empty());
} else {
assert!(w.canvas_workspace.regen.is_some(), "{scenario}: the current dialog must remain open");