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