diff --git a/apps/detail-photocraft/DESIGN.md b/apps/detail-photocraft/DESIGN.md index 21350031..1b829bc5 100644 --- a/apps/detail-photocraft/DESIGN.md +++ b/apps/detail-photocraft/DESIGN.md @@ -191,7 +191,7 @@ Agent 导入的完全透明页面背景以原生“无填充”表达,保留 - 处理中的激活流光归属于当前任务卡片。输入浮层不会继承任务的 Running 状态;任务运行时使用 `Inactive`,即使保留输入焦点或鼠标悬停也不增加内晕染。停止后任务卡收敛到 `Inactive`,Orb 静止;完成后任务卡退场,输入框仍为未激活细边。空闲时真实聚焦按 `Active`、悬停按 `Inactive`,组件不自行发明第三种材质。 - 小壹头像与任务标识参考 SmoothUI Siri Orb 的柔和粉、青、紫内部色场、圆形遮罩与球面高光;禁止以描边圆圈、轨道或点阵代替球体。历史消息静止,处理中只加快内部运动,不暗示语音输入。2026-10-29 修订:输入框内的实时小壹入口(包括空白 mini)默认缓慢流动并轻缓呼吸,输入时增强;回到空闲时平滑减速,不重置相位。此为待命身份动效,不代表模型已经调用;处理中输入框仍不继承任务卡的激活流光。减少动态效果冻结色场与呼吸,隐藏、裁掉或最小化时不因 Orb 安排重绘。 - 2026-10-29 精简:对话内容区去掉重复的 Orb+“小壹”标题行,直接展示回复、处理对象与候选结果;身份入口保留在首位“小壹”标签和输入框内,任务卡继续展示真实任务状态。 -- 对话中候选缩略图应以独立两行展示真实页号及所属图位中的候选序号,完整图位和花色可查看;身份缺失或不唯一时不得猜测编号。产品资料的参考图读取与同步使用真实任务状态展示不确定进度,不推测百分比。 +- 对话中的候选卡片按图片比例显示,页号和候选序号叠在图内底部,悬停可查看完整图位和花色。同一轮的后续选项放在图片下方。身份缺失或不唯一时使用通用候选名称。产品资料的参考图读取与同步使用真实任务状态展示不确定进度,不推测百分比。 - 提示库遇到云端版本冲突后,只有成功读取最新云端快照才能继续“保留本机”;刷新失败时保留草稿、提示先同步。线上个人提示库尚未随本地改动部署。 - 同帧毛玻璃试验按尺寸复用临时纹理,隐藏后释放;无效参数和预算超限使用不透明回退。设备丢失、显存不足及真实窗口性能未完整验证,试验开关仍默认关闭。 - 模板列表展示经模板身份和版本校验的首屏结构示意,明确“不含图片”,不可称为真实封面或完整 Cutout Card。 @@ -398,3 +398,9 @@ Agent 导入的完全透明页面背景以原生“无填充”表达,保留 小壹跟随当前工作区:进入“我的项目”显示项目搜索、新建和已有项目入口;进入素材库显示素材搜索;进入资料页不发送旧画布引用。返回画布恢复该项目对话、草稿和选择。页面切换只改变当前交互作用域,后台请求保持发送时的身份与归属。 本批验证证据单独记录于 `output/client-glow-workspace-20261105/`。原生离屏 GPU 连续帧验证与实际窗口验收分别记录,不把离屏状态注入记作真实生图请求。 + +产品资料中的产品图在模板画布前景按原比例展示,与画布共用坐标;左键拖动、滚轮缩放,不写入成品图层。详情页图位可直接选中、拖动,选中后用滚轮缩放,修改可撤销。中键始终平移画布。 + +引用胶囊只展示主动添加的对象,点击画布或发送后的选区保留都不会自动添加引用。胶囊平时使用中性黑玻璃,悬停或键盘聚焦才出现细光涌。 + +生图等待状态与目标图片同宽高比,在图位内叠放小壹标识和状态文字,降低光涌速度;采纳时先显示正在采纳,图层更新后才显示已采纳。 diff --git a/apps/detail-photocraft/crates/ui-egui/src/jiansun/agent_motion.rs b/apps/detail-photocraft/crates/ui-egui/src/jiansun/agent_motion.rs index e2ed1359..4e6f5a15 100644 --- a/apps/detail-photocraft/crates/ui-egui/src/jiansun/agent_motion.rs +++ b/apps/detail-photocraft/crates/ui-egui/src/jiansun/agent_motion.rs @@ -3,17 +3,10 @@ use crate::theme::Tokens; use egui::{Color32, Id, Mesh, Pos2, Rect, Shape, Stroke, Ui, layers::ShapeIdx, pos2, vec2}; use std::{collections::VecDeque, sync::Arc, time::Duration}; +#[cfg(test)] #[path = "blob_warp.rs"] mod blob_warp; -/// A local, decorative image-waiting mark. This is separate from the live -/// composer identity (Siri Orb) and carries no progress or audio semantics. -/// Paint the bounded warp mark only for an actual image wait or its fading -/// remnant. The caller supplies a stable, frozen request/target identity. -pub(super) fn paint_waiting_blob(ui: &Ui, surface: Surface, reduced: bool, running: bool) -> Option<()> { - blob_warp::paint(ui, surface, reduced, running) -} - const RIM_SECONDS: f64 = 9.0; const FIELD_SECONDS: f64 = 6.0; const SETTLE_SECONDS: f64 = 0.16; diff --git a/apps/detail-photocraft/crates/ui-egui/src/jiansun/agent_panel.rs b/apps/detail-photocraft/crates/ui-egui/src/jiansun/agent_panel.rs index 5fe20427..b0beacd1 100644 --- a/apps/detail-photocraft/crates/ui-egui/src/jiansun/agent_panel.rs +++ b/apps/detail-photocraft/crates/ui-egui/src/jiansun/agent_panel.rs @@ -1,6 +1,6 @@ //! Native collaboration dock. Model execution and credential storage remain outside the UI. use super::{json, Ui, Tokens, agent_motion, Value, RichText, Workspace, PhotocraftApp, Request, workflow_bridge, CenterView, LayerContent, Arc, Instant, Duration}; -use crate::{icons, widgets}; +use crate::icons; use egui::{Align, Color32, FontId, Frame, Id, Layout, Rect, Response, Sense, Stroke, Vec2, vec2}; pub(super) fn paint_tag(ui: &Ui, rect: Rect, response: &Response, selected: bool) { @@ -531,6 +531,16 @@ fn artifact_preview_contents(ui: &mut Ui, texture: &egui::TextureHandle, view: & pub(super) fn rect_value(r: Rect) -> Value { json!([r.left(), r.top(), r.width(), r.height()]) } +fn frame_image_ratio(frame: &Value) -> Option { + let width = frame["width"].as_f64()?; + let height = frame["height"].as_f64()?; + (width > 0.0 && height > 0.0).then_some((width / height) as f32).filter(|ratio| ratio.is_finite() && *ratio > 0.0) +} + +fn image_card_size(width: f32, ratio: f32) -> egui::Vec2 { + let width = width.min(340.0 * ratio); + vec2(width, width / ratio) +} fn image_location(value: &Value, id: &str) -> Value { let mut target = json!({"kind":"candidate","taskId":id,"candidateId":id}); for key in ["slotId", "productVariantId", "outputId"] { @@ -1060,6 +1070,14 @@ impl Workspace { // from the actual dock/clip rather than compounding those margins. let dock_width = self.panel_geometry["panel"][2].as_f64().map(|width| width as f32).unwrap_or(ui.clip_rect().width()); let desired_card_width = (dock_width - 32.0).max(0.0).min((ui.clip_rect().right() - ui.cursor().left()).max(0.0)); + let ratio = (waiting_visibility > 0.0).then(|| { + let slot = target.as_ref()?; + self.template_workflow["slots"].as_array()?.iter() + .find(|value| value["id"] == slot["slotId"] + && (slot["productVariantId"].is_null() || slot["productVariantId"] == value["variantId"])) + .and_then(|value| frame_image_ratio(&value["frame"])) + }).flatten().unwrap_or(16.0 / 9.0); + let image_size = image_card_size(desired_card_width, ratio); let elapsed_ms = if active { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).ok() .and_then(|now| u64::try_from(now.as_millis()).ok()) @@ -1068,7 +1086,8 @@ impl Workspace { ui.add_space(10.0); let card = super::stitch_ui::surface(ui, super::stitch_ui::SurfaceRole::Task, |ui| { let waiting_background = agent_motion::reserve_background(ui); - ui.set_min_width(ui.available_width().max((desired_card_width - 26.0).max(0.0))); + ui.set_width(((if waiting_visibility > 0.0 { image_size.x } else { desired_card_width }) - 26.0).max(0.0)); + let top = ui.cursor().top(); ui.horizontal(|ui| { if waiting_visibility > 0.0 { let (rect, _) = ui.allocate_exact_size(vec2(26.0, 26.0), egui::Sense::hover()); @@ -1102,7 +1121,7 @@ impl Workspace { ui.add(egui::Label::new(RichText::new(label).size(12.0).color(t.text_dim)).wrap()); } if waiting_visibility > 0.0 { - ui.allocate_space(vec2(ui.available_width(), 56.0 * waiting_visibility)); + ui.set_min_height((image_size.y - 26.0).max(ui.cursor().top() - top)); } waiting_background }); @@ -1114,7 +1133,7 @@ impl Workspace { let elapsed=ui.data_mut(|data|{ let id=Id::unique("glow-pill-image-clock"); let mut clock=data.get_temp::<(Id,f64,f64)>(id).filter(|clock|clock.0==waiting_id).unwrap_or((waiting_id,now,0.0)); - if active && !self.reduce_motion {clock.2=now-clock.1;} + if active && !self.reduce_motion {clock.2=(now-clock.1)*0.55;} data.insert_temp(id,clock);clock.2 }); let activity=ui.ctx().animate_bool_with_time(processing_id.with("working"),active,if self.reduce_motion {0.0} else {0.16}); @@ -1362,7 +1381,6 @@ impl Workspace { if stream.is_some() && self.unknown { ui.label(RichText::new("输出未完成").small().color(t.warning)); } - for &index in &turn.choice_indices {let action=if self.messages.get(index).is_some_and(|message|message["kind"]=="pi-ui-request"){self.pi_ui_render(ui,index)}else if self.messages.get(index).is_some_and(|message|message["kind"]=="copywriting-fields"){self.copy_fields_ui(ui,index)}else{self.copy_options_ui(ui,index)};if let Some(action)=action{locate=Some(action);}ui.add_space(8.0);} if !turn.images.is_empty() { ui.add_space(6.0); ui.horizontal(|ui| { @@ -1372,8 +1390,8 @@ impl Workspace { }); ui.add_space(4.0); let available = ui.available_width().max(1.0); - let columns = if available >= 280.0 { 3 } else if available >= 180.0 { 2 } else { 1 }; - let cell_width = ((available - 8.0 * (columns - 1) as f32) / columns as f32).clamp(1.0, 120.0); + let columns = if turn.images.len() > 1 && available >= 300.0 { 2 } else { 1 }; + let cell_width = ((available - 8.0 * (columns - 1) as f32) / columns as f32).clamp(1.0, 420.0); egui::Grid::new(ui.scope_id().with("result-grid")) .num_columns(columns) .min_col_width(cell_width) @@ -1390,6 +1408,7 @@ impl Workspace { } }); } + for &index in &turn.choice_indices {let action=if self.messages.get(index).is_some_and(|message|message["kind"]=="pi-ui-request"){self.pi_ui_render(ui,index)}else if self.messages.get(index).is_some_and(|message|message["kind"]=="copywriting-fields"){self.copy_fields_ui(ui,index)}else{self.copy_options_ui(ui,index)};if let Some(action)=action{locate=Some(action);}ui.add_space(8.0);} } locate } @@ -1402,13 +1421,20 @@ impl Workspace { let mut locate = None; let target = image_location(value, id); let (page_label, short_label, label) = image_result_labels(&target, &self.template_workflow, &self.creation_brief); - ui.push_id(id, |ui| ui.vertical(|ui| { - ui.set_width(cell_width); - ui.allocate_ui_with_layout(vec2(cell_width, 112.0), Layout::centered_and_justified(egui::Direction::TopDown), |ui| { + let ratio_id = ui.scope_id().with(("result-image-ratio", id)); + let ratio = ui.data_mut(|data| { if let Some(texture) = self.agent_images.peek(id) { let size = texture.size_vec2(); - let factor = (cell_width / size.x.max(1.0)).min(112.0 / size.y.max(1.0)).min(1.0); - let (rect, response) = ui.allocate_exact_size(size * factor, Sense::click()); + data.insert_temp(ratio_id, size.x / size.y.max(1.0)); + } + data.get_temp::(ratio_id).or_else(|| frame_image_ratio(value)).unwrap_or(1.0) + }); + let size = image_card_size(cell_width, ratio); + ui.push_id(id, |ui| ui.vertical(|ui| { + ui.set_width(cell_width); + ui.allocate_ui_with_layout(vec2(cell_width, size.y), Layout::centered_and_justified(egui::Direction::TopDown), |ui| { + if let Some(texture) = self.agent_images.peek(id) { + let (rect, response) = ui.allocate_exact_size(size, Sense::click()); // Blur and fade in place: geometry, the rounded mask, the hit // target and selection outline all remain at the final crop. // The parent UI clip still bounds the image when scrolling. @@ -1428,6 +1454,17 @@ impl Workspace { } else if response.hovered() { ui.painter().rect_stroke(rect.expand(1.0), t.radius_sm, Stroke::new(1.0, t.text_dim), egui::StrokeKind::Outside); } + if rect.width() >= 64.0 && rect.height() >= 34.0 { + let caption = if page_label.is_empty() { short_label.clone() } else { format!("{page_label} · {short_label}") }; + let mut job = egui::text::LayoutJob::simple_singleline(caption, FontId::proportional(12.0), Color32::WHITE); + job.wrap.max_width = rect.width() - 22.0; + job.wrap.max_rows = 1; + let text = ui.fonts_mut(|fonts| fonts.layout_job(job)); + let pos = rect.left_bottom() + vec2(10.0, -8.0 - text.size().y); + let painter = ui.painter_at(rect); + painter.rect_filled(Rect::from_min_size(pos, text.size()).expand2(vec2(5.0, 3.0)), 6.0, Color32::from_black_alpha(188)); + painter.galley(pos, text, Color32::WHITE); + } let response = response.on_hover_text(format!("定位 {label} · 右键查看原图")); response.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, format!("定位 {label}"))); if response.clicked() { @@ -1449,7 +1486,18 @@ impl Workspace { }); }); } else { - let response = super::stitch_ui::icon_action_button(ui, "image", "查看候选", false, 28.0, true); + let label = "定位候选"; + let (rect, response) = ui.allocate_exact_size(size, Sense::click()); + let response = response.on_hover_cursor(egui::CursorIcon::PointingHand); + response.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, label)); + if ui.is_rect_visible(rect) { + ui.painter().rect_filled(rect, t.radius_sm, if response.hovered() { t.hover } else { t.field }); + let icon_size = rect.width().min(rect.height()).min(16.0); + crate::icons::paint(ui, Rect::from_center_size(rect.center(), vec2(icon_size, icon_size)), "image", icon_size, t.text_dim); + if response.has_focus() { + ui.painter().rect_stroke(rect, t.radius_sm, Stroke::new(1.0, t.text_dim), egui::StrokeKind::Inside); + } + } if ui.is_rect_visible(response.rect) && matches!(value["status"].as_str(), None | Some("complete")) { self.agent_images.mark_visible(id); } @@ -1458,12 +1506,6 @@ impl Workspace { } } }); - ui.with_layout(Layout::top_down(Align::Center), |ui| { - if !page_label.is_empty() { - widgets::elided_label(ui, &page_label, cell_width).on_hover_text(&label); - } - widgets::elided_label(ui, &short_label, cell_width).on_hover_text(&label); - }); })); locate } @@ -2132,13 +2174,14 @@ impl Workspace { "layers" }; let short = subject_short_label(&subject, &self.template_workflow); + let preview = subject["taskId"].as_str().and_then(|id| self.agent_images.peek(id)).cloned(); ui.spacing_mut().button_padding = vec2(6.0, 2.0); ui.spacing_mut().interact_size.y = 23.0; let mut locate = false; let mut detach = None; let response = ui.horizontal(|ui| { ui.spacing_mut().item_spacing.x = 4.0; - let (response, remove) = super::stitch_ui::reference_chip(ui, glyph, &short, &label, pulse, chip_width); + let (response, remove) = super::stitch_ui::reference_chip_with_preview(ui, glyph, &short, &label, pulse, chip_width, preview.as_ref()); self.panel_geometry["referenceRemove"] = rect_value(remove.rect); if remove.clicked() || (remove.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter) || i.key_pressed(egui::Key::Space))) { detach = Some(0); } locate = response.clicked() || (response.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter) || i.key_pressed(egui::Key::Space))); @@ -2788,6 +2831,7 @@ mod tests { json!({"role":"user","text":"这一屏的光线柔和一点,保留产品原有结构。"}), json!({"role":"assistant","kind":"reply","text":"可以。先保留当前版本,我会针对选中的图位提供候选;采纳后再替换画布中的图片。"}), ]; + w.composer_reference_add(&app).unwrap(); app.jiansun = Some(w); (app, requests) } @@ -3203,10 +3247,12 @@ mod tests { crate::panels::request_dock_width(&ctx, dock_width); let mut output = None; for _ in 0..4 { - output = Some(ctx.run_ui( - egui::RawInput { screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(1280.0, 1050.0))), ..Default::default() }, + let mut frame = ctx.run_ui( + egui::RawInput { screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(1280.0, 1550.0))), ..Default::default() }, |ui| crate::panels::right_dock(&mut app, ui), - )); + ); + frame.textures_delta.clear(); + output = Some(frame); } let output = output.unwrap(); let clip = geometry(app.jiansun.as_ref().unwrap(), "conversationClip"); @@ -3219,27 +3265,20 @@ mod tests { assert!(reply_shape.2 > 1, "long Chinese reply wraps at dock width {dock_width}"); assert!(reply_shape.1.left() >= clip.left() && reply_shape.1.right() <= clip.right() + 1.0, "reply must fit its visible viewport at {dock_width}: {:?} in {clip:?}", reply_shape.1); let mut image_rects = Vec::new(); - let mut label_rects = Vec::new(); for (index, id) in ids.iter().enumerate() { let image = images.iter().find(|(texture, _)| texture == id).expect("each result has one real image").1; let (page, number) = if index == 2 { ("P2", "候选 1") } else if index == 1 { ("P1", "候选 2") } else { ("P1", "候选 1") }; - let belongs_to_image = |rect: &Rect| rect.left() >= image.left() - 1.0 && rect.left() < image.right() && rect.top() >= image.bottom(); - let page_rect = texts.iter().find(|(text, rect, _)| text == page && belongs_to_image(rect) && rect.top() < image.bottom() + 25.0) - .unwrap_or_else(|| panic!("page {page} must be painted under its own thumbnail at width {dock_width}")).1; - let label = texts.iter().find(|(text, rect, _)| text == number && belongs_to_image(rect) - && rect.top() >= page_rect.bottom() - 1.0 && rect.top() < page_rect.bottom() + 25.0) - .unwrap_or_else(|| panic!("the full {number} must be painted under page {page} at width {dock_width}")).1; + let caption = format!("{page} · {number}"); + assert!(texts.iter().any(|(text, rect, _)| text == &caption && image.contains_rect(*rect)), + "{caption} must be painted inside its own image at width {dock_width}"); assert!(image.left() >= clip.left() && image.right() <= clip.right() + 1.0, "image exceeds the conversation at {dock_width}: {image:?}"); - assert!(page_rect.left() >= clip.left() && page_rect.right() <= clip.right() + 1.0, "page exceeds the conversation at {dock_width}: {page_rect:?}"); - assert!(label.left() >= clip.left() && label.right() <= clip.right() + 1.0, "label exceeds the conversation at {dock_width}: {label:?}"); - assert!(label.top() >= image.bottom(), "each label is below its own thumbnail at {dock_width}"); image_rects.push(image); - label_rects.push(label); } - assert!(image_rects[0].right() <= image_rects[1].left(), "first and second images stay in separate columns"); - assert!(label_rects[0].right() <= image_rects[1].left(), "first label never spills into the next result column"); if dock_width >= 400.0 { - assert!(image_rects[1].right() <= image_rects[2].left() && label_rects[1].right() <= image_rects[2].left(), "all three wide-dock columns remain separate"); + assert!(image_rects[0].right() <= image_rects[1].left()); + assert!(image_rects[0].bottom() <= image_rects[2].top()); + } else if dock_width == 288.0 { + assert!(image_rects.windows(2).all(|pair| pair[0].bottom() <= pair[1].top())); } assert!(requests.try_recv().is_err(), "drawing result history must not issue a model request"); } @@ -4123,27 +4162,84 @@ mod tests { } #[test] - fn conversation_preview_cold_hot_and_reloaded_keep_the_same_layout() { + fn conversation_places_choices_below_the_image_in_the_same_turn() { + fn label_top(shape: &egui::Shape, wanted: &str) -> Option { + match shape { + egui::Shape::Vec(shapes) => shapes.iter().find_map(|shape| label_top(shape, wanted)), + egui::Shape::Text(text) if text.galley.text() == wanted => Some(text.pos.y), + _ => None, + } + } + let (mut app, _) = dock_fixture(); + let ctx = egui::Context::default(); + PhotocraftApp::setup_context(&ctx, crate::theme::ThemeKind::ProMedium); + let w = app.jiansun.as_mut().unwrap(); + w.reduce_motion = true; + w.messages = vec![ + json!({"role":"user","text":"生成首图"}), + json!({"role":"assistant","kind":"pi-ui-request","request":{"id":"choose","title":"首屏主图怎么处理"}}), + json!({"role":"assistant","kind":"image","taskId":"layout-image"}), + ]; + let mut output = ctx.run_ui(egui::RawInput { + screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(500.0, 800.0))), + ..Default::default() + }, |ui| { + let turn = turns(&w.messages).into_iter().next().unwrap(); + w.turn_ui(ui, turn, Id::unique("layout"), 1, true); + }); + output.textures_delta.clear(); + let top = |wanted| output.shapes.iter().find_map(|shape| label_top(&shape.shape, wanted)).unwrap(); + assert!(top("生成图片") < top("首屏主图怎么处理")); + } + + #[test] + fn conversation_preview_eviction_retains_measured_layout() { let (mut app, _) = dock_fixture(); let ctx = egui::Context::default(); PhotocraftApp::setup_context(&ctx, crate::theme::ThemeKind::ProMedium); let frame = |app: &PhotocraftApp| { let mut bounds = Rect::NOTHING; - let _ = ctx.run_ui(egui::RawInput::default(), |ui| { + let mut output = ctx.run_ui(egui::RawInput::default(), |ui| { let start = ui.cursor().min; app.jiansun.as_ref().unwrap().image_result(ui, &json!({"taskId":"layout-image"}), 112.0); bounds = Rect::from_min_max(start, ui.cursor().min); }); + output.textures_delta.clear(); bounds }; - let cold = frame(&app); for size in [[100, 20], [20, 100]] { let texture = ctx.load_texture("layout-image", egui::ColorImage::filled(size, Color32::WHITE), egui::TextureOptions::LINEAR); app.jiansun.as_mut().unwrap().agent_images.insert("layout-image".into(), texture); let hot = frame(&app); - assert_eq!(cold, hot, "preview aspect ratio and texture reload cannot shift following messages"); app.jiansun.as_mut().unwrap().agent_images.remove("layout-image"); - assert_eq!(cold, frame(&app), "eviction must retain the same slot"); + assert_eq!(hot, frame(&app), "eviction must retain the measured image layout"); + } + } + + #[test] + fn conversation_result_preserves_image_ratio_and_overlays_the_caption() { + let (mut app, _) = dock_fixture(); + let ctx = egui::Context::default(); + PhotocraftApp::setup_context(&ctx, crate::theme::ThemeKind::ProMedium); + for dimensions in [[200, 100], [100, 200]] { + let texture = ctx.load_texture("result", egui::ColorImage::filled(dimensions, Color32::WHITE), egui::TextureOptions::LINEAR); + let texture_id = texture.id(); + let w = app.jiansun.as_mut().unwrap(); + w.agent_images.insert("result".into(), texture); + let mut output = ctx.run_ui(egui::RawInput::default(), |ui| { + w.image_result(ui, &json!({"taskId":"result"}), 200.0); + }); + output.textures_delta.clear(); + let image = output.shapes.iter().find_map(|shape| match &shape.shape { + egui::Shape::Rect(rect) if rect.fill_texture_id() == texture_id => Some(rect.rect), + _ => None, + }).expect("preview texture"); + let caption = output.shapes.iter().find_map(|shape| match &shape.shape { + egui::Shape::Text(text) if text.galley.text() == "候选图片" => Some(Rect::from_min_size(text.pos, text.galley.size())), + _ => None, + }).expect("image caption"); + assert!((image.width() / image.height() - dimensions[0] as f32 / dimensions[1] as f32).abs() < 0.01); + assert!(image.contains_rect(caption)); } } @@ -4156,15 +4252,15 @@ mod tests { let texture = ctx.load_texture(id, egui::ColorImage::filled([8, 8], Color32::WHITE), egui::TextureOptions::LINEAR); app.jiansun.as_mut().unwrap().agent_images.insert(id.into(), texture); } - let _ = ctx.run_ui(egui::RawInput::default(), |ui| { + ctx.run_ui(egui::RawInput::default(), |ui| { ui.set_clip_rect(Rect::from_min_size(pos2(5000.0, 5000.0), vec2(20.0, 20.0))); app.jiansun.as_ref().unwrap().image_result(ui, &json!({"taskId":"hidden"}), 112.0); - }); + }).textures_delta.clear(); let cache = &app.jiansun.as_ref().unwrap().agent_images; assert_eq!(cache.iter().next().map(|(key, _)| key.as_str()), Some("hidden")); - let _ = ctx.run_ui(egui::RawInput::default(), |ui| { + ctx.run_ui(egui::RawInput::default(), |ui| { app.jiansun.as_ref().unwrap().image_result(ui, &json!({"taskId":"hidden"}), 112.0); - }); + }).textures_delta.clear(); assert_eq!(cache.iter().next_back().map(|(key, _)| key.as_str()), Some("hidden")); } @@ -4192,9 +4288,11 @@ mod tests { let run = |ctx: &egui::Context, app: &PhotocraftApp, events| { let current = time.get(); time.set(current + 0.25); - ctx.run_ui(egui::RawInput { screen_rect: Some(Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0))), time: Some(current), events, ..Default::default() }, |ui| { + let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0))), time: Some(current), events, ..Default::default() }, |ui| { app.jiansun.as_ref().unwrap().image_result(ui, &value, 112.0); - }) + }); + output.textures_delta.clear(); + output }; let first = run(&ctx, &app, vec![]); let mut image = None; @@ -4853,10 +4951,12 @@ mod tests { w.reduce_motion = true; let mut output = None; for _ in 0..3 { - output = Some(ctx.run_ui( + let mut frame = ctx.run_ui( egui::RawInput { screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, vec2(1280.0, 800.0))), ..Default::default() }, |ui| crate::panels::right_dock(&mut app, ui), - )); + ); + frame.textures_delta.clear(); + output = Some(frame); } let mut texts = Vec::new(); for shape in &output.unwrap().shapes { diff --git a/apps/detail-photocraft/crates/ui-egui/src/jiansun/canvas_workspace.rs b/apps/detail-photocraft/crates/ui-egui/src/jiansun/canvas_workspace.rs index 4ae32509..5e8c8e91 100644 --- a/apps/detail-photocraft/crates/ui-egui/src/jiansun/canvas_workspace.rs +++ b/apps/detail-photocraft/crates/ui-egui/src/jiansun/canvas_workspace.rs @@ -93,7 +93,9 @@ pub(super) struct State { professional_controls: BTreeMap, pending_entry: HashSet, appeared: HashMap, - waiting_surfaces: HashMap, + reference_cards: HashMap<(usize, String), [f32; 4]>, + reference_drag: Option<(egui::Id, [f64; 2])>, + direct_image_drag: Option, pub(super) progress: HashMap, selection: Vec, initial_focus: bool, @@ -107,6 +109,48 @@ pub(super) struct State { candidate_menu: Option, } +#[derive(Clone, Copy)] +struct DirectImageDrag { + layer: u64, + revision: u64, + start: [f64; 2], + bounds: [f32; 4], +} + +fn image_affine(scale: f64, pivot: [f64; 2], delta: [f64; 2]) -> [f64; 6] { + [scale, 0.0, 0.0, scale, pivot[0] * (1.0 - scale) + delta[0], pivot[1] * (1.0 - scale) + delta[1]] +} + +fn take_image_wheel(ui: &Ui) -> f32 { + ui.input_mut(|input| { + let mut scroll = 0.0; + input.events.retain(|event| { + if let egui::Event::MouseWheel { unit, delta, modifiers, .. } = event + && *modifiers == egui::Modifiers::NONE && delta.y != 0.0 && delta.y.abs() >= delta.x.abs() + { + scroll += delta.y * if *unit == egui::MouseWheelUnit::Line { 40.0 } else { 1.0 }; + return false; + } + true + }); + // The input state can continue emitting the tail of a notch on frames + // with no new event. It belongs to the image while the pointer is over it. + if input.modifiers == egui::Modifiers::NONE && input.smooth_scroll_delta.y.abs() >= input.smooth_scroll_delta.x.abs() { + input.smooth_scroll_delta.y = 0.0; + } + scroll + }) +} + +fn reference_scale(card: &mut [f32; 4], anchor: [f64; 2], factor: f32) { + let side = card[2].max(card[3]); + let scale = (side * factor).clamp(120.0, 3200.0) / side; + for i in 0..2 { + card[i] = anchor[i] as f32 + (card[i] - anchor[i] as f32) * scale; + card[i + 2] *= scale; + } +} + #[derive(Clone)] struct CandidateMenu { popup: egui::Id, @@ -1066,7 +1110,8 @@ impl Workspace { let active_layer = state.active_layer; let selected_layers = state.selected_layers(); let project = bound_project(self, state.doc.id.0).map(str::to_owned); - let reduced = self.reduce_motion; + let animate_original = !self.reduce_motion && matches!(&smart.source, photocraft_doc::SmartSource::Linked { .. }); + let recheck_source = matches!(&smart.source, photocraft_doc::SmartSource::Linked { .. }); let worker_meta = meta.clone(); let (sender, result) = std::sync::mpsc::sync_channel(1); let (approve_recheck, approval) = std::sync::mpsc::sync_channel(1); @@ -1087,7 +1132,7 @@ impl Workspace { photocraft_engine::smart_cmds::refresh_layer_with_bounded_source(&before, &mut target, original).map_err(|error|error.to_string())?; } *before.layer_mut(photocraft_doc::LayerId(layer)).ok_or("原图位不存在")? = target; - let snapshot = if !reduced { + let snapshot = if animate_original { Some(AdoptionSnapshot { before_doc:std::sync::Arc::new(before.clone()), source_digest:source.digest }) } else { None }; let mut prepared = photocraft_engine::Session::new(); @@ -1097,10 +1142,12 @@ impl Workspace { let key = format!("jiansun.adopted.{variant}.{slot}"); updated.metadata.text.retain(|(k, _)| *k != key); updated.metadata.text.push((key, candidate.into())); - sender.send(AdoptionProgress::Prepared).map_err(|_| "采纳准备已取消")?; - 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()); } + if recheck_source { + sender.send(AdoptionProgress::Prepared).map_err(|_| "采纳准备已取消")?; + 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((updated, snapshot)) })).unwrap_or_else(|_| Err("图片准备失败,原画布已保留".into())); let _ = sender.send(AdoptionProgress::Done(prepared.map(Box::new))); @@ -1744,9 +1791,9 @@ impl Workspace { 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()) - || ui.ctx().text_edit_focused() || !app.ui.dialogs.is_empty() || self.canvas_workspace.regen.is_some() + || !app.ui.dialogs.is_empty() || self.canvas_workspace.regen.is_some() || !ui.input(|input| input.raw.focused); - if blocked_by_overlay || ui.input(|input| input.key_pressed(egui::Key::Escape)) { + if blocked_by_overlay || 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))); @@ -1957,9 +2004,10 @@ impl Workspace { fn paint_candidate_task_badge(&self,ui:&Ui,id:egui::Id,rect:Rect,candidate:&Value,processing:bool,adopted:bool) { use super::stitch_ui::{self as kit,BadgeKind}; - if adopted || rect.width()<=112.0 || rect.height()<=50.0 {return;} + if processing || adopted || rect.width()<=112.0 || rect.height()<=50.0 {return;} let status=candidate["status"].as_str().unwrap_or(""); - let (kind,label)=if processing {(BadgeKind::Running,"生成中")} + let pending = self.canvas_workspace.pending_adoption.as_ref().is_some_and(|pending| pending["candidateId"] == candidate["id"]); + let (kind,label)=if pending {(BadgeKind::Running,"正在采纳")} else if matches!(status,"unknown"|"failed") {(BadgeKind::Warning,"需检查")} else if self.agent_effects_paused && matches!(status,"prepared"|"dispatched"|"running") {(BadgeKind::Neutral,"已停止")} else {return;}; @@ -1974,7 +2022,7 @@ impl Workspace { } } - fn draw_workspace_candidate(&mut self, app: &mut PhotocraftApp, ui: &mut Ui, input: CandidateDrawInput<'_>, seen_waiting: &mut HashSet) -> CandidateDrawResult { + fn draw_workspace_candidate(&mut self, app: &mut PhotocraftApp, ui: &mut Ui, input: CandidateDrawInput<'_>) -> CandidateDrawResult { let CandidateDrawInput { row, width, index, xf, pointer, doc_id, variant, variant_label, mapping_layer, painter, t, workflow, output, now } = input; let slot_id = row.slot["id"].as_str().unwrap_or(""); let all = candidates(row.slot); @@ -2002,7 +2050,7 @@ impl Workspace { response.widget_info(|| { egui::WidgetInfo::labeled(egui::Role::Button, true, format!("{},候选 {}", row.slot["label"].as_str().unwrap_or("图片"), index + 1)) }); - if response.hovered() { + if result.pointer_on_image { result.blocked = true; } let selected = includes_target(self.canvas_workspace.context.as_ref(), slot_id, Some(id)); @@ -2011,7 +2059,6 @@ impl Workspace { if !self.agent_images.contains_key(task_id) { painter.rect_filled(image_rect, 5.0, t.field); } - let processing_light = super::agent_motion::reserve_background(ui); let mut has_image = false; if let Some(c) = candidate { if let Some(texture) = self.agent_images.get(task_id) { @@ -2026,25 +2073,31 @@ impl Workspace { } else if c["status"] == "complete" && !task_id.is_empty() && self.agent_images.can_insert(task_id) && self.requested_previews.insert(task_id.to_owned()) { let _ = self.tx.send(Request::Action("agent-image-preview".into(), json!({"doc":doc_id,"taskId":task_id}))); } - let processing = !has_image - && matches!(c["status"].as_str(), Some("prepared" | "dispatched" | "running")) - && matches!(self.busy.as_deref(), Some("slot-generate" | "slot-append")) - && self.canvas_workspace.progress.contains_key(task_id) - && !self.agent_effects_paused; + let processing = !has_image && matches!(c["status"].as_str(), Some("prepared" | "dispatched" | "running")) + && candidate_is_running(self, doc_id, slot_id, c); let waiting_id = ui.scope_id().with(("candidate-processing", doc_id, &variant, slot_id, id, task_id)); - seen_waiting.insert(waiting_id); - let surface = - super::agent_motion::Surface::new(waiting_id, image_rect, 5.0) - .behind(processing_light) - .clipped_to(xf.rect); - // External generation has no observable drawing action. Show - // a flowing waiting field without inventing an Agent cursor. - if super::agent_motion::paint_waiting_blob(ui, surface, self.reduce_motion, processing).is_some() { - self.canvas_workspace.waiting_surfaces.insert(waiting_id, surface); + if processing { + ui.scope(|ui| { + ui.set_clip_rect(visible); + let background = super::agent_motion::reserve_background(ui); + super::stitch_ui::material(ui, waiting_id, image_rect, 8.0, 0.0, background); + let start = ui.data_mut(|data| *data.get_temp_mut_or_insert_with(waiting_id, || now)); + let elapsed = (now - start) * 0.55; + let pulse = if self.reduce_motion { super::glow_pill::Pulse::default() } else { super::glow_pill::waiting(elapsed) }; + super::glow_pill::paint(ui, super::glow_pill::Surface { id: waiting_id, rect: image_rect, radius: 8.0, + time: if self.reduce_motion { 2.4 } else { elapsed }, pulse, opacity: 1.0, background: Some(background), text_range: None, flanks: 0.0 }); + if image_rect.width() >= 92.0 && image_rect.height() >= 48.0 { + let orb = Rect::from_min_size(image_rect.min + vec2(10.0, 10.0), vec2(20.0, 20.0)); + super::siri_orb::paint(ui, waiting_id.with("orb"), orb, super::siri_orb::Motion::Thinking, self.reduce_motion); + ui.painter().text(orb.right_center() + vec2(7.0, 0.0), Align2::LEFT_CENTER, "正在生成", FontId::proportional(12.0), t.text); + } + if !self.reduce_motion { ui.ctx().request_repaint_after(std::time::Duration::from_millis(32)); } + }); + self.canvas_workspace.geometry.insert(format!("generating:{key}"), [rect.min.x, rect.min.y, rect.width(), rect.height()]); } else { - self.canvas_workspace.waiting_surfaces.remove(&waiting_id); + ui.data_mut(|data| data.remove::(waiting_id)); } - if !has_image { + if !has_image && !processing { let text = if self.agent_effects_paused && matches!(c["status"].as_str(), Some("prepared" | "dispatched" | "running")) { "已停止修改 · 原请求保留" } else if c["status"] == "complete" { @@ -2070,18 +2123,37 @@ impl Workspace { if response.clicked() { result.trace_target = Some(target.clone()); } self.canvas_workspace.context = Some(target); } - if footer_height > 0.0 && (response.hovered() || selected) { + if !processing && footer_height > 0.0 && (result.pointer_on_image || selected) { let button_rect = Rect::from_min_size(rect.right_bottom() + vec2(-72.0, -40.0), vec2(64.0, 34.0)); if c["status"] == "complete" && !adopted { let mut controls = ui.new_child(egui::UiBuilder::new() .id_salt(("candidate-adopt", &key)).max_rect(button_rect) .layout(egui::Layout::top_down(egui::Align::Min))); - let response = super::stitch_ui::action_button(&mut controls, "采纳", super::stitch_ui::ButtonRole::Primary, - self.canvas_workspace.pending_adoption.is_none() && self.saving.is_none()); + let pending = self.canvas_workspace.pending_adoption.as_ref().is_some_and(|pending| pending["candidateId"] == id); + let enabled = self.canvas_workspace.pending_adoption.is_none() && self.saving.is_none() + && app.ui.dialogs.is_empty() && !egui::Popup::is_any_open(ui.ctx()) + && ui.memory(|memory| memory.top_modal_layer().is_none()); + let response = super::stitch_ui::action_button(&mut controls, if pending { "采纳中…" } else { "采纳" }, super::stitch_ui::ButtonRole::Primary, enabled); self.canvas_workspace .geometry .insert(format!("adopt:{key}"), [response.rect.min.x, response.rect.min.y, response.rect.width(), response.rect.height()]); - if response.clicked() { + // The canvas is also an interactive widget. Keep the exact + // button press across frames even when it takes canvas focus. + let press = response.id.with("adopt-press"); + let (start, finish, down) = ui.input(|input| { + let start = input.events.iter().any(|event| matches!(event, + egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: true, .. } + if response.rect.contains(*pos) && xf.rect.contains(*pos))); + let finish = input.pointer.primary_clicked() && input.pointer.interact_pos().is_some_and(|pos| response.rect.contains(pos)); + (start, finish, input.pointer.primary_down()) + }); + let clicked = ui.data_mut(|data| { + if enabled && start { data.insert_temp(press, true); } + let clicked = enabled && finish && data.get_temp::(press) == Some(true); + if !down || !enabled { data.remove::(press); } + clicked + }); + if response.clicked() || clicked { result.action = Some(("slot-adopt-prep", json!({"slotId":slot_id,"candidateId":id,"variantId":variant,"nativeLayerId":mapping_layer}))); } @@ -2201,14 +2273,178 @@ impl Workspace { } } + fn paint_product_references(&mut self, app: &PhotocraftApp, ui: &mut Ui, xf: ViewXform, doc_id: u64, width: f32, enabled: bool) -> bool { + if self.creation_doc != Some(doc_id) { return false; } + let images: Vec<_> = super::creation::image_rows(&self.creation["brief"]).into_iter() + .filter_map(|(image, _)| { + if image["purpose"] == "scene" { return None; } + Some((image["source"].as_str()?.to_owned(), image["name"].as_str().unwrap_or("产品参考图").to_owned())) + }).collect(); + let mut owns_primary = false; + // Paint after the template and candidates, using the same document transform. + let painter = ui.painter_at(xf.rect); + let mut cards = Vec::new(); + for (index, (source, name)) in images.into_iter().enumerate() { + let key = super::creation_reads::reference_key(&source); + self.queue_creation_reference(app, &source); + let Some(texture) = self.creation_thumbs.get(&key).cloned() else { continue }; + let reference_id = ui.scope_id().with(("canvas-product-reference", doc_id, index)); + let card = self.canvas_workspace.reference_cards.entry((index, source.clone())).or_insert_with(|| { + let size = texture.size_vec2(); + let size = size * (720.0 / size.x.max(size.y)); + let right = xf.to_doc(pos2(xf.rect.right() - 24.0, xf.rect.top() + 54.0)); + let x = (width + GAP + CARD_WIDTH + CARD_GAP).min(right[0] as f32 - size.x); + [x, right[1] as f32 + index as f32 * 758.0, size.x, size.y] + }); + let screen = world_rect(xf, *card); + cards.push((index, reference_id, source, name, texture, *card, screen)); + } + let middle = ui.input(|input| input.pointer.middle_down()); + let pointer = ui.input(|input| input.pointer.interact_pos()); + let hovered = pointer.and_then(|point| cards.iter().rev().find(|(_, _, _, _, _, _, rect)| rect.intersect(xf.rect).contains(point)).map(|card| card.0)); + owns_primary |= enabled && middle && hovered.is_some(); + let (pressed, down, released) = ui.input(|input| (input.pointer.primary_pressed(), input.pointer.primary_down(), input.pointer.primary_released())); + if !enabled || middle { + self.canvas_workspace.reference_drag = None; + } + for (index, reference_id, source, name, texture, mut world, screen) in cards { + let visible = screen.intersect(xf.rect).intersect(ui.clip_rect()); + let can_interact = enabled && !middle && hovered == Some(index); + if can_interact && pressed && let Some(point) = pointer { + let [x, y] = xf.to_doc(point); + self.canvas_workspace.reference_drag = Some((reference_id, [x - f64::from(world[0]), y - f64::from(world[1])])); + } + let drag = self.canvas_workspace.reference_drag.filter(|(id, _)| *id == reference_id); + let before = world; + if let Some((_, offset)) = drag && (down || released) && let Some(point) = pointer { + let [x, y] = xf.to_doc(point); + world[0] = (x - offset[0]) as f32; + world[1] = (y - offset[1]) as f32; + } + if can_interact && !down { + let scroll = take_image_wheel(ui); + if scroll != 0.0 { + reference_scale(&mut world, xf.to_doc(pointer.unwrap_or(screen.center())), (scroll * 0.006).exp()); + } + } + if world != before { + self.canvas_workspace.reference_cards.insert((index, source), world); + ui.ctx().request_repaint(); + } + if can_interact || drag.is_some() { + owns_primary = true; + ui.ctx().set_cursor_icon(if down && drag.is_some() { egui::CursorIcon::Grabbing } else { egui::CursorIcon::Grab }); + } + let rect = world_rect(xf, world); + if !rect.intersects(xf.rect) { continue; } + painter.add(candidate_image_shape(ui.ctx(), texture.id(), world, xf, 1.0)); + self.canvas_workspace.geometry.insert(format!("product-reference:{index}"), [rect.min.x, rect.min.y, rect.width(), rect.height()]); + if visible.is_positive() { + let response = ui.interact(visible, reference_id, Sense::hover()); + if can_interact && drag.is_none() { response.on_hover_text(format!("{name} · 拖动摆放,滚轮缩放")); } + } + } + if !down { self.canvas_workspace.reference_drag = None; } + owns_primary + } + + fn edit_canvas_image(&mut self, app: &mut PhotocraftApp, ui: &mut Ui, xf: ViewXform, rows: &[Row<'_>], layers: &BTreeMap, enabled: bool) -> bool { + if !enabled || ui.input(|input| input.pointer.middle_down() || input.key_down(egui::Key::Space) || input.key_pressed(egui::Key::Escape)) { + if self.canvas_workspace.direct_image_drag.take().is_some() { app.drag = None; } + return false; + } + let Some(state) = app.session.active() else { return false }; + let revision = state.revision; + let pointer = ui.input(|input| input.pointer.interact_pos()).filter(|point| xf.rect.contains(*point)); + let target = pointer.and_then(|point| { + let doc_point = xf.to_doc(point); + rows.iter().rev().filter_map(|row| { + let id = row.slot["nativeLayerId"].as_u64().or_else(|| layers.get(row.slot["id"].as_str()?).copied())?; + let layer = state.doc.layer(photocraft_doc::LayerId(id))?; + let locks = state.doc.effective_locks(layer.id); + if !layer.visible || locks.position || locks.all || !matches!(layer.content, LayerContent::Smart(_)) { return None; } + let bounds = photocraft_engine::transform_cmds::transform_frame(&state.doc, layer); + if bounds.is_empty() || doc_point[0] < f64::from(bounds.x0) || doc_point[0] >= f64::from(bounds.x1) + || doc_point[1] < f64::from(bounds.y0) || doc_point[1] >= f64::from(bounds.y1) { return None; } + Some((id, [bounds.x0 as f32, bounds.y0 as f32, bounds.width() as f32, bounds.height() as f32])) + }).next() + }); + if self.canvas_workspace.direct_image_drag.is_some_and(|drag| drag.revision != revision) { + self.canvas_workspace.direct_image_drag = None; + app.drag = None; + return true; + } + if let Some(drag) = self.canvas_workspace.direct_image_drag { + let (down, released, position) = ui.input(|input| (input.pointer.primary_down(), input.pointer.primary_released(), input.pointer.interact_pos())); + if let Some(position) = position { + let current = xf.to_doc(position); + let delta = [current[0] - drag.start[0], current[1] - drag.start[1]]; + if released && xf.map_vec(vec2(delta[0] as f32, delta[1] as f32)).length() >= 3.0 { + self.commit_canvas_image_transform(app, drag.layer, image_affine(1.0, drag.start, delta)); + } else if down { + if let Some(preview) = app.drag.as_mut() { + preview.points.truncate(1); + preview.points.push([current[0], current[1], 1.0]); + } + ui.ctx().request_repaint(); + let mut bounds = drag.bounds; + bounds[0] += delta[0] as f32; + bounds[1] += delta[1] as f32; + ui.painter_at(xf.rect).rect_stroke(world_rect(xf, bounds), 4.0, Stroke::new(1.5, Tokens::get(ui.ctx()).agent().accent), egui::StrokeKind::Inside); + ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing); + } + } + if !down { self.canvas_workspace.direct_image_drag = None; app.drag = None; } + return true; + } + let (Some(position), Some((layer, bounds))) = (pointer, target) else { return false }; + let modifiers = ui.input(|input| input.modifiers); + if modifiers != egui::Modifiers::NONE { return false; } + // Preserve ordinary canvas navigation and let a plain click select the image. + if ui.input(|input| input.pointer.primary_pressed()) { + if state.active_layer != Some(photocraft_doc::LayerId(layer)) || state.selected_layers().len() != 1 { + if let Err(error) = app.session.select_layer(photocraft_doc::LayerId(layer)) { self.error = error.to_string(); return true; } + app.sync_mask_targets(); + } + let revision = app.session.active().map_or(revision, |state| state.revision); + let start = xf.to_doc(position); + self.canvas_workspace.direct_image_drag = Some(DirectImageDrag { layer, revision, start, bounds }); + if !app.layer_mask_targeted() { + app.drag = Some(crate::canvas::Drag::new(crate::state::Tool::Move, start, vec![[start[0], start[1], 1.0]], egui::Modifiers::NONE, false)); + } + return true; + } + if state.active_layer == Some(photocraft_doc::LayerId(layer)) { + let scroll = take_image_wheel(ui); + if scroll.abs() > 0.01 { + let factor = f64::from((scroll * 0.003).exp().clamp(0.75, 1.33)); + self.commit_canvas_image_transform(app, layer, image_affine(factor, xf.to_doc(position), [0.0; 2])); + return true; + } + } + ui.ctx().set_cursor_icon(egui::CursorIcon::Grab); + false + } + + fn commit_canvas_image_transform(&mut self, app: &mut PhotocraftApp, layer: u64, matrix: [f64; 6]) { + if let Err(error) = app.run("edit.transform", json!({"layer":layer,"matrix":matrix})) { + self.error = error; + } else { + self.draft_changed = true; + self.sync_dirty = true; + } + } + fn workspace_canvas(&mut self, app: &mut PhotocraftApp, ui: &mut Ui, xf: ViewXform, doc_id: u64, width: f32) -> (bool, Option) { self.expire_workspace_adoption(app, ui, doc_id); if !self.workspace_canvas_allowed(app, ui, doc_id) { + if self.canvas_workspace.direct_image_drag.take().is_some() { app.drag = None; } return (false, None); } if self.template_workflow["canvasFirst"] != true { 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 workflow = std::mem::take(&mut self.template_workflow); let mut clear_references = false; @@ -2252,7 +2488,6 @@ impl Workspace { let mut pointer_on_image = false; let mut comparison_owns_primary = false; let mut trace_target = None; - let mut seen_waiting = HashSet::new(); for row in &rows { 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()); @@ -2267,8 +2502,10 @@ impl Workspace { let count = all.len().max(1); let group = world_rect(xf, candidate_group(row, width, count)); if group.intersects(xf.rect) { - painter.rect_filled(group, 12.0, t.card); - painter.rect_stroke(group, 12.0, Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside); + if !all.iter().any(|candidate| candidate_is_running(self, doc_id, slot_id, candidate)) { + painter.rect_filled(group, 12.0, t.card); + painter.rect_stroke(group, 12.0, Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside); + } self.canvas_workspace.geometry.insert( format!("candidate-group:{slot_id}"), [group.min.x, group.min.y, group.width(), group.height()], @@ -2293,7 +2530,7 @@ impl Workspace { let result = self.draw_workspace_candidate(app, ui, CandidateDrawInput { row, width, index, xf, pointer, doc_id, variant: &variant, variant_label: &variant_label, mapping_layer, painter: &painter, t, workflow: &workflow, output: &output, now, - }, &mut seen_waiting); + }); blocked |= result.blocked; pointer_on_image |= result.pointer_on_image; menu_shown |= result.menu_shown; @@ -2302,6 +2539,16 @@ impl Workspace { if result.professional_request.is_some() { professional_request = result.professional_request; } } } + let editing_enabled = !blocked_by_overlay && app.ui.dialogs.is_empty() && app.ui.transform.is_none() + && !ui.memory(|memory| memory.top_modal_layer().is_some()) && !egui::Popup::is_any_open(ui.ctx()); + let over_reference = self.paint_product_references(app, ui, xf, doc_id, width, editing_enabled); + blocked |= over_reference; + if over_reference && action.as_ref().is_some_and(|(method, _)| *method == "slot-adopt-prep") { + 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); + } if pointer.is_some() && !pointer_on_image && !blocked && !egui::Popup::is_any_open(ui.ctx()) && ui.input(|input| input.pointer.primary_clicked()) { let modifiers = ui.input(|input| input.events.iter().rev().find_map(|event| match event { @@ -2340,9 +2587,6 @@ impl Workspace { self.canvas_workspace.locate_motion = None; } self.finish_candidate_menu(ui, &workflow, doc_id, menu_shown); - self.canvas_workspace.waiting_surfaces.retain(|id, surface| { - seen_waiting.contains(id) || super::agent_motion::paint_waiting_blob(ui, *surface, self.reduce_motion, false).is_some() - }); let manual_pointer = ui.input(|input| input.pointer.any_pressed() && input.pointer.interact_pos().is_some_and(|point| xf.rect.contains(point))); if let Some((layer, bounds)) = queued_edit_target(self, app, manual_pointer) { let rect = world_rect(xf, bounds); @@ -2642,6 +2886,51 @@ mod tests { use super::super::{Edit, Event}; use std::sync::{Arc, mpsc}; + #[test] + fn reference_cards_keep_document_coordinates_and_zoom_about_the_pointer() { + let mut card = [200.0, 100.0, 600.0, 300.0]; + let anchor = [350.0, 175.0]; + reference_scale(&mut card, anchor, 3.0); + assert_eq!(card, [-100.0, -50.0, 1800.0, 900.0]); + reference_scale(&mut card, anchor, 10.0); + assert_eq!(card[2..], [3200.0, 1600.0]); + let xf = ViewXform { rect: Rect::from_min_size(pos2(0.0, 0.0), vec2(1200.0, 800.0)), zoom: 0.5, + center: [600.0, 400.0], flip: false, rotation: 0.0, aspect: 1.0 }; + let pan = ViewXform { center: [560.0, 360.0], ..xf }; + assert_eq!(world_rect(pan, card).min - world_rect(xf, card).min, vec2(20.0, 20.0)); + } + + #[test] + fn direct_image_drag_and_scale_edit_only_the_selected_picture_and_are_undoable() { + let (mut w, mut app, _, layer, _) = native_fixture(); + warm_fixture_target(&mut app, layer); + w.canvas_workspace.initial_focus = false; + w.template_workflow["slots"][0]["frame"] = json!({"x":30,"y":40,"width":100,"height":50}); + let ctx = egui::Context::default(); + let before = app.session.active().unwrap().doc.clone(); + let start = pos2(65.0, 60.0); + let end = pos2(110.0, 92.0); + let button = |pos, pressed| egui::Event::PointerButton { pos, pressed, button: egui::PointerButton::Primary, modifiers: egui::Modifiers::NONE }; + workspace_frame(&mut w, &mut app, &ctx, vec![]); + assert!(workspace_frame(&mut w, &mut app, &ctx, vec![egui::Event::PointerMoved(start), button(start, true)]).0); + workspace_frame(&mut w, &mut app, &ctx, vec![egui::Event::PointerMoved(end)]); + assert_eq!(app.session.active().unwrap().doc, before, "drag preview does not commit a history entry"); + workspace_frame(&mut w, &mut app, &ctx, vec![button(end, false)]); + let moved = app.session.active().unwrap().doc.clone(); + let placement = |doc: &Document| { + let LayerContent::Smart(image) = &doc.layer(photocraft_doc::LayerId(layer)).unwrap().content else { panic!("image layer") }; + image.transform.m + }; + assert_eq!(placement(&moved)[4..], [75.0, 72.0]); + assert_eq!(moved.layers.last(), before.layers.last()); + w.commit_canvas_image_transform(&mut app, layer, image_affine(1.25, [110.0, 92.0], [0.0; 2])); + assert_eq!(placement(&app.session.active().unwrap().doc)[0], 1.25); + app.session.execute("edit.undo", json!({})).unwrap(); + assert_eq!(app.session.active().unwrap().doc.layers, moved.layers); + app.session.execute("edit.undo", json!({})).unwrap(); + assert_eq!(app.session.active().unwrap().doc.layers, before.layers); + } + #[test] fn processing_target_stays_bound_to_the_submitted_scope_not_the_new_selection() { let target = json!({"kind":"slot","slotId":"original","productVariantId":"wood","outputId":"detail"}); @@ -3735,7 +4024,7 @@ mod tests { w.template_workflow["slots"][0]["frame"]=json!({"x":30,"y":40,"width":600,"height":600}); w.template_workflow["slots"][0]["candidates"]=json!([{"id":"new-candidate","status":"complete"}]); w.canvas_workspace.context=Some(json!({"kind":"candidate","slotId":"image-slot","candidateId":"new-candidate","productVariantId":"wood"})); - let mut h=egui_kittest::Harness::builder().with_size(vec2(width,height)).with_pixels_per_point(scale).with_max_steps(64).wgpu().build_ui_state( + let mut h=egui_kittest::Harness::builder().with_context_setup(crate::cjk_fonts::install_system_provider_for_tests).with_size(vec2(width,height)).with_pixels_per_point(scale).with_max_steps(64).wgpu().build_ui_state( |ui,state:&mut (Workspace,PhotocraftApp)| { let doc=state.1.session.active().unwrap().doc.id.0; let xf=ViewXform {rect:ui.max_rect(),zoom:0.4,center:[2000.0,400.0],flip:false,rotation:0.0,aspect:1.0}; @@ -3747,6 +4036,21 @@ mod tests { h.run_steps(4); h.render().unwrap().save(std::path::Path::new(&directory).join(format!("candidate-primary-{width}.png"))).unwrap(); assert!(h.state().0.canvas_workspace.geometry.contains_key("adopt:image-slot/new-candidate")); + let target=json!({"kind":"slot","slotId":"image-slot","productVariantId":"wood","outputId":"detail","nativeLayerId":layer}); + let workspace=&mut h.state_mut().0; + workspace.template_workflow["slots"][0]["candidates"]=json!([{"id":"in-flight","status":"running"}]); + workspace.busy=Some("slot-append".into()); + workspace.canvas_workspace.submitted_composer=Some(SubmittedComposer { + edit_version: 0, target, text: String::new(), + identity: GenerationIdentity { existing: HashSet::new(), candidate_id: Some("in-flight".into()), ambiguous: false }, + }); + h.run_steps(4); + let generating=h.state().0.canvas_workspace.geometry["generating:image-slot/in-flight"]; + assert!((generating[2]-generating[3]).abs() < 0.01, "a square target must have a square waiting card"); + h.render().unwrap().save(std::path::Path::new(&directory).join(format!("candidate-generating-{width}.png"))).unwrap(); + h.state_mut().0.busy=None; + h.run_steps(4); + assert!(!h.state().0.canvas_workspace.geometry.contains_key("generating:image-slot/in-flight")); h.state_mut().0.canvas_workspace.open_regen(json!({"kind":"slot","slotId":"image-slot","productVariantId":"wood","outputId":"detail","nativeLayerId":layer})); h.state_mut().0.canvas_workspace.prompt="保留产品结构,只调整自然光。".into(); h.run_steps(4); @@ -3873,7 +4177,7 @@ mod tests { } #[test] - fn adoption_with_motion_requires_real_prewarm_renderer() { + fn embedded_adoption_with_motion_does_not_wait_for_the_comparison_renderer() { let (mut w, mut app, _requests, layer, bytes) = native_fixture(); w.reduce_motion = false; let state = app.session.active().unwrap(); @@ -3883,10 +4187,11 @@ mod tests { "templateHash":"fixed","nativeLayerId":layer,"slotId":"image-slot","variantId":"wood","candidateId":"no-renderer","fit":"contain"}); w.canvas_workspace.pending_adoption = Some(meta.clone()); adopt_and_wait(&mut w, &mut app, bytes, meta); - assert_eq!(app.session.active().unwrap().revision, revision); - assert_eq!(app.session.active().unwrap().doc.as_ref(), original.as_ref()); - assert!(w.canvas_workspace.adoption_effect.is_none(), "unavailable renderer must not fake a ready transition"); - assert!(!w.error.is_empty()); + assert_ne!(app.session.active().unwrap().revision, revision); + assert_ne!(app.session.active().unwrap().doc.as_ref(), original.as_ref()); + assert_eq!(adopted(&app.session.active().unwrap().doc, "image-slot", "wood"), Some("no-renderer")); + assert!(w.canvas_workspace.adoption_snapshot.is_none()); + assert!(w.error.is_empty()); } #[test] diff --git a/apps/detail-photocraft/crates/ui-egui/src/jiansun/composer_references.rs b/apps/detail-photocraft/crates/ui-egui/src/jiansun/composer_references.rs index 7c6cd788..ba99f799 100644 --- a/apps/detail-photocraft/crates/ui-egui/src/jiansun/composer_references.rs +++ b/apps/detail-photocraft/crates/ui-egui/src/jiansun/composer_references.rs @@ -28,7 +28,6 @@ struct Draft { pinned: Vec, selected: Vec, overflow: bool, - manual: bool, } impl Draft { @@ -47,31 +46,10 @@ impl Draft { self.pinned.push(item.clone()); } } - self.manual = true; Ok(()) } - fn visible(&self) -> Vec { - let mut result = self.pinned.clone(); - if self.manual { - return result; - } - for item in &self.selected { - if !result.iter().any(|old| old.identity == item.identity) && result.len() < MAX_REFERENCES { - result.push(item.clone()); - } - } - result - } - fn remove(&mut self, index: usize) { - let mut visible = self.visible(); - if index < visible.len() { - visible.remove(index); - self.pinned = visible; - self.manual = true; - } - } } /// Drafts are scoped to account, origin, document and local/cloud project. @@ -105,7 +83,7 @@ impl State { self.scope .as_ref() .and_then(|scope| self.drafts.get(scope)) - .map(|draft| draft.visible().into_iter().map(|item| item.value).collect()) + .map(|draft| draft.pinned.iter().map(|item| item.value.clone()).collect()) .unwrap_or_default() } } @@ -297,13 +275,11 @@ impl Workspace { } /// A successfully dispatched intent owns a frozen snapshot. Clear only the - /// current composer's explicit references; the current native selection is - /// still the live context for any later intent. + /// current composer's explicit references, leaving the canvas selection intact. pub(super) fn composer_reference_clear(&mut self, app: &PhotocraftApp) { self.composer_reference_sync(app); if let Some(draft) = self.composer_references.draft_mut() { draft.pinned.clear(); - draft.manual = false; } } @@ -338,17 +314,16 @@ impl Workspace { } draft.pinned.push(reference.clone()); } - draft.manual = true; Ok(()) } pub(super) fn composer_reference_remove(&mut self, app: &PhotocraftApp, index: usize) -> Result<(), String> { self.composer_reference_sync(app); let draft = self.composer_references.draft_mut().ok_or("请先打开项目")?; - if index >= draft.visible().len() { + if index >= draft.pinned.len() { return Err("引用已发生变化,请重试".into()); } - draft.remove(index); + draft.pinned.remove(index); Ok(()) } @@ -361,10 +336,8 @@ impl Workspace { if self.editing_product_brief() {return Ok(Vec::new());} let st = app.session.active().ok_or("请先打开项目")?; let current = self.composer_reference_state(app); - let draft = current.scope.as_ref().and_then(|scope| current.drafts.get(scope)).ok_or("请先打开项目")?; - let additional = draft.selected.iter().filter(|item| !draft.manual && !draft.pinned.iter().any(|old| old.identity == item.identity)).count(); - if (!draft.manual && draft.overflow) || draft.pinned.len() + additional > MAX_REFERENCES { - return Err("最多添加 32 个引用,请减少选中对象".into()); + if current.scope.is_none() { + return Err("请先打开项目".into()); } let mut references = current.list(); for item in &mut references { @@ -408,20 +381,21 @@ mod tests { } #[test] - fn removal_enters_manual_mode_and_explicit_add_restores_it() { + fn removing_a_pin_never_readds_it_when_canvas_selection_changes() { let mut draft = Draft::default(); draft.sync(vec![reference(1, "layer")]); - draft.remove(0); + draft.add_selection().unwrap(); + draft.pinned.remove(0); draft.sync(vec![reference(1, "layer")]); - assert!(draft.visible().is_empty()); + assert!(draft.pinned.is_empty()); draft.add_selection().expect("add"); - assert_eq!(draft.visible().len(), 1); - draft.remove(0); + assert_eq!(draft.pinned.len(), 1); + draft.pinned.remove(0); draft.sync(vec![reference(2, "layer")]); draft.sync(vec![reference(1, "layer")]); - assert!(draft.visible().is_empty()); + assert!(draft.pinned.is_empty()); draft.add_selection().expect("add again"); - assert_eq!(draft.visible().len(), 1); + assert_eq!(draft.pinned.len(), 1); } #[test] @@ -432,9 +406,9 @@ mod tests { draft.add_selection().expect("add"); draft.sync(vec![reference(1, "pixelMask"), reference(1, "vectorMask")]); draft.add_selection().expect("add"); - assert_eq!(draft.visible().len(), 4); - draft.remove(0); - assert_eq!(draft.visible().len(), 3); + assert_eq!(draft.pinned.len(), 4); + draft.pinned.remove(0); + assert_eq!(draft.pinned.len(), 3); } #[test] @@ -452,6 +426,8 @@ mod tests { fn native_mask_reference_remove_and_snapshot_are_independent_of_selection() { let (mut w, mut app, id) = fixture(); app.ui.mask_target = true; + assert!(w.composer_reference_list(&app).is_empty()); + w.composer_reference_add(&app).expect("explicitly add mask"); let before = w.composer_reference_snapshot(&app).expect("snapshot"); assert_eq!(before[0]["nativeLayerId"], id); assert_eq!(before[0]["component"], "pixelMask"); @@ -490,7 +466,7 @@ mod tests { } #[test] - fn clearing_explicit_references_preserves_frozen_request_and_tracks_only_live_selection() { + fn clearing_explicit_references_preserves_frozen_request_without_readding_selection() { let (mut w, mut app, selected) = fixture(); let pinned = app.session.execute("layer.new.layer", json!({"name":"Pinned"})).expect("layer")["layer"].as_u64().expect("id"); app.session.execute("layer.select", json!({"layer":selected})).expect("select"); @@ -501,8 +477,10 @@ mod tests { w.composer_reference_clear(&app); let live = w.composer_reference_snapshot(&app).expect("next intent"); - assert_eq!(live.len(), 1); - assert_eq!(live[0]["nativeLayerId"], selected, "the actual current selection remains the live context"); + assert!(live.is_empty(), "selecting a layer does not attach it to the next message"); + w.composer_reference_add(&app).expect("attach the current selection deliberately"); + assert_eq!(w.composer_reference_snapshot(&app).unwrap()[0]["nativeLayerId"], selected); + w.composer_reference_clear(&app); assert_eq!(frozen[0]["nativeLayerId"], pinned, "clearing the composer cannot mutate an already frozen request"); app.session.execute("select.deselectLayers", json!({})).expect("clear native selection"); @@ -519,12 +497,12 @@ mod tests { w.composer_reference_add_target(&app, &json!({"documentId":doc,"nativeLayerId":selected,"component":"layer"})).expect("other reference"); w.composer_reference_clear(&app); let cleared = w.composer_references.draft_mut().expect("current scope"); - assert!(cleared.pinned.is_empty() && !cleared.manual); + assert!(cleared.pinned.is_empty()); w.account = json!({"id":"owner"}); w.composer_reference_sync(&app); let original = w.composer_references.draft_mut().expect("original scope"); assert_eq!(original.pinned.len(), 1); - assert!(original.manual, "another account's clear must not erase this draft"); + assert!(!original.pinned.is_empty(), "another account's clear must not erase this draft"); } #[test] @@ -586,7 +564,6 @@ mod tests { w.creation_open = false; w.professional_mode = false; w.open_projects.insert(document_id, w.local_identity("white-project")); - w.composer_reference_add_target(&app, &json!({"documentId":document_id,"nativeLayerId":selected,"component":"layer"})).expect("pin"); app.ui.dock_tabs.color = 4; app.ui.dock.agent_available = true; app.ui.dock.set_collapsed(crate::dock::Group::Color, false); @@ -617,14 +594,15 @@ mod tests { let doc = std::sync::Arc::make_mut(&mut app.session.active_mut().expect("document").doc); doc.layer_mut(photocraft_doc::LayerId(selected)).expect("foreground").locks.position = true; ordinary_canvas_gesture(&mut app, [10.0,10.0], [10.0,10.0], egui::Modifiers::NONE); - assert!(!app.jiansun.as_ref().expect("workspace").composer_reference_list(&app).is_empty(), "a locked ordinary layer is still a real target"); + assert_eq!(app.session.active().unwrap().selected_layers(), vec![photocraft_doc::LayerId(selected)]); + assert!(app.jiansun.as_ref().unwrap().composer_reference_list(&app).is_empty()); let (mut app, _, background) = white_canvas_reference_fixture(); let doc = std::sync::Arc::make_mut(&mut app.session.active_mut().expect("document").doc); doc.layer_mut(photocraft_doc::LayerId(background)).expect("background").locks.position = false; assert!(!doc.is_background(photocraft_doc::LayerId(background)), "editable raster is no longer a structural Background"); ordinary_canvas_gesture(&mut app, [100.0,75.0], [100.0,75.0], egui::Modifiers::NONE); - assert!(!app.jiansun.as_ref().expect("workspace").composer_reference_list(&app).is_empty(), "an editable background follows native layer picking"); + assert!(app.jiansun.as_ref().unwrap().composer_reference_list(&app).is_empty()); assert_eq!(app.session.active().expect("document").selected_layers(), vec![photocraft_doc::LayerId(background)]); } @@ -633,7 +611,7 @@ mod tests { let (mut app, _, background) = white_canvas_reference_fixture(); app.ui.dock_tabs.color = 0; ordinary_canvas_gesture(&mut app, [100.0,75.0], [100.0,75.0], egui::Modifiers::NONE); - assert!(!app.jiansun.as_ref().expect("workspace").composer_reference_list(&app).is_empty()); + assert!(app.jiansun.as_ref().unwrap().composer_reference_list(&app).is_empty()); assert_eq!(app.session.active().expect("document").selected_layers(), vec![photocraft_doc::LayerId(background)]); } @@ -650,7 +628,7 @@ mod tests { let w=app.jiansun.as_ref().unwrap(); let refs=&w.composer_references; let draft=refs.drafts.get(refs.scope.as_ref().unwrap()).unwrap(); - assert!(draft.pinned.is_empty()); assert!(!draft.manual); + assert!(draft.pinned.is_empty()); assert!(w.composer_reference_list(&app).is_empty()); assert_eq!(w.pi_request_scope,frozen); assert_eq!(app.session.active().unwrap().revision,revision); @@ -770,13 +748,14 @@ mod tests { let mut draft = String::new(); let hand = std::cell::Cell::new(None); let mut frame = |app: &mut PhotocraftApp, events: Vec| { - let _ = ctx.run_ui(egui::RawInput { screen_rect:Some(screen), events, ..Default::default() }, |ui| { + let mut output = ctx.run_ui(egui::RawInput { screen_rect:Some(screen), events, ..Default::default() }, |ui| { ui.put(input_rect, egui::TextEdit::singleline(&mut draft).id(super::super::composer_input_id())); let view = app.ui.views[0].clone(); let _ = crate::canvas::canvas_view(app, ui, 0, canvas_rect, view, true); hand.set(crate::hold_keys::held_tool(app, ui.ctx())); crate::shortcuts::handle(app, ui.ctx()); }); + output.textures_delta.clear(); }; frame(&mut app, vec![]); ctx.memory_mut(|memory| memory.request_focus(super::super::composer_input_id())); @@ -897,13 +876,14 @@ mod tests { let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(700.0, 500.0)); let canvas = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(400.0, 300.0)); let frame = |app: &mut PhotocraftApp, events: Vec| { - let _ = ctx.run_ui(egui::RawInput { screen_rect:Some(screen), events, ..Default::default() }, |ui| { + let mut output = ctx.run_ui(egui::RawInput { screen_rect:Some(screen), events, ..Default::default() }, |ui| { let view = app.ui.views[0].clone(); let _ = crate::canvas::canvas_view(app, ui, 0, canvas, view, true); if modal { egui::Modal::new(egui::Id::unique("focus-protection-modal")).show(ui.ctx(), |ui| { ui.label("Modal"); }); } }); + output.textures_delta.clear(); }; frame(&mut app, vec![]); if !modal { egui::Popup::open_id(&ctx, egui::Id::unique("focus-protection-popup")); } @@ -936,7 +916,7 @@ mod tests { assert_eq!(method, "agent"); assert_eq!(first["context"]["requestScope"]["references"][0]["nativeLayerId"], pinned); - app.session.execute("select.deselectLayers", json!({})).expect("clear native selection"); + assert_eq!(app.session.active().unwrap().selected_layers(), vec![photocraft_doc::LayerId(selected)]); w.busy = None; w.submit(&app, "second intent".into()); let super::super::Request::Action(method, second) = requests.try_recv().expect("second request") else { panic!("expected agent request") }; @@ -958,7 +938,7 @@ mod tests { w.submit(&app, "intent".into()); assert!(w.busy.is_none()); let draft = w.composer_references.draft_mut().expect("current scope"); - assert!(draft.manual && draft.pinned.len() == 1, "a failed dispatch keeps the explicit reference for retry"); + assert!(draft.pinned.len() == 1, "a failed dispatch keeps the explicit reference for retry"); } fn reviewed_intent_fixture(intent: &str) -> (Workspace, PhotocraftApp, std::sync::mpsc::Receiver, Value, u64) { @@ -1004,7 +984,7 @@ mod tests { assert!(w.error.contains("本机服务已停止"), "{intent}: the real channel dispatch must have failed: {}", w.error); assert!(w.workflow.proposal().is_none(), "{intent}: the reviewed action reached dispatch"); let draft = w.composer_references.draft_mut().expect("current scope"); - assert!(draft.manual && draft.pinned.len() == 1, "{intent}: failed dispatch retains explicit references"); + assert!(draft.pinned.len() == 1, "{intent}: failed dispatch retains explicit references"); assert_eq!(draft.pinned[0].value["nativeLayerId"], selected); assert_eq!(w.pi_request_scope, frozen, "{intent}: the prior request remains frozen"); } @@ -1033,7 +1013,7 @@ mod tests { let draft = state.draft_mut().expect("scope"); draft.sync((0..=MAX_REFERENCES as u64).map(|id| reference(id, "layer")).collect()); assert!(draft.add_selection().is_err()); - assert_eq!(draft.visible().len(), MAX_REFERENCES); + assert!(draft.pinned.is_empty(), "over-limit selection does not partially attach"); } #[test] @@ -1042,10 +1022,11 @@ mod tests { w.template_workflow = json!({"canvasFirst":true,"slots":[{"id":"slot","outputId":"detail","label":"Main","candidates":[{"id":"candidate","status":"complete"}]}]}); w.canvas_workspace.context = Some(json!({"kind":"candidate","slotId":"slot","candidateId":"candidate","outputId":"detail","productVariantId":"wood"})); + assert!(w.composer_reference_list(&app).is_empty()); + w.composer_reference_add(&app).expect("pin candidate"); let refs = w.composer_reference_snapshot(&app).expect("candidate"); assert_eq!(refs.len(), 1); assert_eq!(refs[0]["candidateId"], "candidate"); - w.composer_reference_add(&app).expect("pin candidate"); w.template_workflow["slots"][0]["candidates"] = json!([]); assert!(w.composer_reference_snapshot(&app).is_err()); } @@ -1055,6 +1036,7 @@ mod tests { let (mut w, app, selected) = fixture(); w.template_workflow = json!({"canvasFirst":true,"slots":[]}); w.canvas_workspace.context = Some(json!({"kind":"slot","slotId":"stale","nativeLayerId":selected+100,"outputId":"detail"})); + w.composer_reference_add(&app).expect("attach selected layer"); let refs = w.composer_reference_snapshot(&app).expect("selected layer"); assert_eq!(refs.len(), 1); assert_eq!(refs[0]["nativeLayerId"], selected); diff --git a/apps/detail-photocraft/crates/ui-egui/src/jiansun/creation.rs b/apps/detail-photocraft/crates/ui-egui/src/jiansun/creation.rs index 9fa11651..425dbcd2 100644 --- a/apps/detail-photocraft/crates/ui-egui/src/jiansun/creation.rs +++ b/apps/detail-photocraft/crates/ui-egui/src/jiansun/creation.rs @@ -345,7 +345,7 @@ fn selected_template(brief: &Value, workflow: &Value, canonical_brief: &Value) - if template_identity(&installed) { installed } else { Value::Null } } -fn image_rows(brief: &Value) -> Vec<(Value, String)> { +pub(super) fn image_rows(brief: &Value) -> Vec<(Value, String)> { let mut rows = brief["images"].as_array().into_iter().flatten().cloned().map(|image| (image, String::new())).collect::>(); for variant in brief_variants(brief) { let owner = variant["id"].as_str().unwrap_or("").to_owned(); diff --git a/apps/detail-photocraft/crates/ui-egui/src/jiansun/stitch_ui.rs b/apps/detail-photocraft/crates/ui-egui/src/jiansun/stitch_ui.rs index a887f768..c8a1615a 100644 --- a/apps/detail-photocraft/crates/ui-egui/src/jiansun/stitch_ui.rs +++ b/apps/detail-photocraft/crates/ui-egui/src/jiansun/stitch_ui.rs @@ -1061,17 +1061,23 @@ pub(super) fn reference_chip_width(ui: &Ui, label: &str, max_width: f32) -> f32 (text_width + 48.0).clamp(48.0_f32.min(max_width), max_width) } +#[cfg(test)] pub(super) fn reference_chip(ui: &mut Ui, icon: &str, label: &str, accessible_name: &str, pulse: f32, width: f32) -> (Response, Response) { - reference_chip_core(ui, icon, label, Some(accessible_name), &format!("移除引用:{accessible_name}"), "移除引用", pulse, width) + reference_chip_with_preview(ui, icon, label, accessible_name, pulse, width, None) +} + +#[allow(clippy::too_many_arguments)] +pub(super) fn reference_chip_with_preview(ui: &mut Ui, icon: &str, label: &str, accessible_name: &str, pulse: f32, width: f32, preview: Option<&egui::TextureHandle>) -> (Response, Response) { + reference_chip_core(ui, icon, label, Some(accessible_name), &format!("移除引用:{accessible_name}"), "移除引用", pulse, width, preview) } pub(super) fn attachment_reference_chip(ui: &mut Ui, name: &str) -> Response { let width = reference_chip_width(ui, name, ui.available_width().max(48.0)); - reference_chip_core(ui, "image", name, None, &format!("移除参考图:{name}"), "从草稿移除参考图", 0.0, width).1 + reference_chip_core(ui, "image", name, None, &format!("移除参考图:{name}"), "从草稿移除参考图", 0.0, width, None).1 } #[allow(clippy::too_many_arguments)] -fn reference_chip_core(ui: &mut Ui, icon: &str, label: &str, locate_name: Option<&str>, remove_name: &str, remove_hint: &str, pulse: f32, width: f32) -> (Response, Response) { +fn reference_chip_core(ui: &mut Ui, icon: &str, label: &str, locate_name: Option<&str>, remove_name: &str, remove_hint: &str, pulse: f32, width: f32, preview: Option<&egui::TextureHandle>) -> (Response, Response) { let t = Tokens::get(ui.ctx()).agent(); let (rect, _) = ui.allocate_exact_size(vec2(width, 24.0), egui::Sense::hover()); let remove_rect = egui::Rect::from_min_max(egui::pos2(rect.right() - rect.width().min(24.0), rect.top()), rect.max); @@ -1080,10 +1086,25 @@ fn reference_chip_core(ui: &mut Ui, icon: &str, label: &str, locate_name: Option let locate = if locate_name.is_some() { locate.on_hover_cursor(egui::CursorIcon::PointingHand) } else { locate.on_hover_text(label) }; let remove = ui.interact(remove_rect, ui.scope_id().with("detach"), egui::Sense::click()).on_hover_cursor(egui::CursorIcon::PointingHand); let hovered = locate.hovered() || remove.hovered(); - let border = if locate.has_focus() || remove.has_focus() { t.text_dim } else { t.field_border }; - ui.painter().rect_filled(rect, 12.0, if hovered { t.hover } else { t.field.lerp_to_gamma(t.hover, pulse * 0.5) }); - ui.painter().rect_stroke(rect, 12.0, Stroke::new(1.0, border), egui::StrokeKind::Inside); - crate::icons::paint(ui, egui::Rect::from_center_size(egui::pos2(rect.left() + 12.0, rect.center().y), vec2(13.0, 13.0)), icon, 13.0, t.icon); + let focused = locate.has_focus() || remove.has_focus(); + let slot = super::agent_motion::reserve_background(ui); + let gain = ui.ctx().animate_bool_with_time(locate.id.with("reference-light"), ui.is_enabled() && (hovered || focused), + if ui.style().animation_time == 0.0 { 0.0 } else { 0.18 }); + material(ui, locate.id, rect, 12.0, (gain * 0.40).max(pulse * 0.20), slot); + if focused { + ui.painter().rect_stroke(rect, 12.0, Stroke::new(1.0, t.text_dim), egui::StrokeKind::Inside); + } + let swatch = egui::Rect::from_center_size(egui::pos2(rect.left() + 12.0, rect.center().y), vec2(16.0, 14.0)); + if let Some(preview) = preview { + let source = preview.size_vec2(); + let size = source * (swatch.width() / source.x).min(swatch.height() / source.y); + ui.painter().add(super::agent_motion::rounded_image_entry_blur(preview.id(), + egui::Rect::from_center_size(swatch.center(), size), 1.0, 2.0)); + } else { + let tile = super::agent_motion::reserve_background(ui); + material(ui, locate.id.with("reference-swatch"), swatch, 4.0, gain * 0.48, tile); + crate::icons::paint(ui, swatch, icon, 10.0, t.icon); + } let text_clip = egui::Rect::from_min_max(egui::pos2(rect.left() + 22.0, rect.top()), egui::pos2(remove_rect.left().max(rect.left() + 22.0), rect.bottom())); ui.painter_at(text_clip).text(egui::pos2(rect.left() + 22.0, rect.center().y), egui::Align2::LEFT_CENTER, label, egui::FontId::proportional(11.0), t.text); crate::icons::paint(ui, remove_rect.shrink(5.0), "x", 12.0, if remove.hovered() { t.text } else { t.icon }); @@ -1096,7 +1117,7 @@ fn reference_chip_core(ui: &mut Ui, icon: &str, label: &str, locate_name: Option #[test] fn reference_chip_measures_content_and_respects_available_width() { let ctx = egui::Context::default(); - let _ = ctx.run_ui(egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(320.0, 100.0))), ..Default::default() }, |ui| { + let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(320.0, 100.0))), ..Default::default() }, |ui| { let short = reference_chip_width(ui, "a", 144.0); let longer = reference_chip_width(ui, "longer label", 144.0); let capped = reference_chip_width(ui, &"long label ".repeat(50), 144.0); @@ -1109,6 +1130,7 @@ fn reference_chip_measures_content_and_respects_available_width() { assert_eq!(remove.rect.width(), 24.0); assert!(locate.rect.right() <= remove.rect.left()); }); + output.textures_delta.clear(); } #[cfg(test)]