ofdgo/ofdgo_editor_batch.go

// Copyright 2025-2026 肖其顿 (XIAO QI DUN)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package ofdgo

import (
	"cmp"
	"context"
	"fmt"
	"reflect"
	"slices"
	"strconv"
)

// editorObjectPosition 对象所属图层及层内索引
type editorObjectPosition struct {
	layer int
	index int
}

// ObjectPosition 对象在图层或页块直接成员中的位置，Index从0开始，Count不含嵌套页块的对象
type ObjectPosition struct {
	Layer     string
	Container string
	Index     int
	Count     int
}

// ObjectInfo 对象的编辑能力及直接容器位置
type ObjectInfo struct {
	Capabilities ObjectCapabilities
	Position     ObjectPosition
}

// Objects 按绘制顺序获取选区的独立快照，保留编辑中的段落信息
// 入参: page 页面索引, ids 对象标识，不得重复
// 返回: []GraphicObject 独立对象副本, error 错误信息
func (e *Editor) Objects(page int, ids []string) ([]GraphicObject, error) {
	_, indexes, err := e.selectedObjects(page, ids)
	if err != nil {
		return nil, err
	}
	slices.SortFunc(indexes, compareEditorPosition)
	objects := make([]GraphicObject, len(indexes))
	orderable := make(map[*editorXML]bool)
	for i, index := range indexes {
		object := e.pages[page].Content.Layer[index.layer].Objects[index.index]
		capability := e.objectCapabilities(object, orderable)
		if !capability.Copy {
			return nil, fmt.Errorf("object %q cannot be copied: %w", editorObjectID(object), capability.editError())
		}
		objects[i], err = cloneEditorObject(object)
		if err != nil {
			return nil, err
		}
		objects[i].origin = e.objectOrigin(editorObjectID(object))
	}
	return objects, nil
}

// CopyObjects 将对象快照按输入顺序复制到目标页并平移，分配新ID，提交一次撤销记录
// 对象引用当前Editor已注册的资源，保留段落信息，不修改输入快照
// 入参: page 目标页面索引, objects 对象快照, dx 横向位移，单位为毫米, dy 纵向位移，单位为毫米
// 返回: []string 按绘制顺序排列的新对象标识, error 错误信息
func (e *Editor) CopyObjects(page int, objects []GraphicObject, dx, dy float64) ([]string, error) {
	return e.CopyObjectsContext(context.Background(), page, objects, dx, dy)
}

// CopyObjectsContext 复制对象快照，准备期间取消不提交对象或撤销记录
// 入参: ctx 取消上下文, page 目标页, objects 对象快照, dx 横向位移，单位为毫米, dy 纵向位移，单位为毫米
// 返回: []string 新对象标识, error 校验或取消错误
func (e *Editor) CopyObjectsContext(ctx context.Context, page int, objects []GraphicObject, dx, dy float64) ([]string, error) {
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	if !finite(dx) || !finite(dy) {
		return nil, fmt.Errorf("copy requires finite offsets")
	}
	_, err := e.page(page)
	if err != nil {
		return nil, err
	}
	if len(objects) == 0 {
		return nil, nil
	}
	if err := e.prepareSourceIDs(); err != nil {
		return nil, err
	}
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	prepared := make([]GraphicObject, len(objects))
	origins := make([]*editorObjectOrigin, len(objects))
	result := make([]string, len(objects))
	maximum := e.maxID + len(objects)
	validation := &editorValidation{Editor: e}
	for i, object := range objects {
		if err := ctx.Err(); err != nil {
			return nil, err
		}
		result[i] = strconv.Itoa(e.maxID + i + 1)
		object, err := validation.prepareCopiedObject(result[i], object)
		if err != nil {
			return nil, err
		}
		if dx != 0 || dy != 0 {
			object, err = transformEditorObject(object, dx, dy, 1)
			if err != nil {
				return nil, err
			}
			if err = validateEditorGeometry(object); err != nil {
				return nil, err
			}
		}
		prepared[i], origins[i], err = e.copyObjectOrigin(objects[i], object, &maximum)
		if err != nil {
			return nil, err
		}
	}
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	e.maxID = maximum
	for i, origin := range origins {
		if origin != nil {
			e.setObjectOrigin(result[i], origin)
		}
	}
	layers := copyEditorPage(e.pages[page]).Content.Layer
	target := 0
	if e.originalPage(page) {
		target = len(e.source.pages[e.pages[page].ID].original.Content.Layer)
	}
	if target < len(layers) {
		target = len(layers) - 1
	}
	for i := 0; i < len(prepared); {
		style := e.copiedLayerStyle(objects[i])
		if target == len(layers) || layers[target].DrawParam != style {
			layers = append(layers, Layer{ID: e.nextID(), Type: "Body", DrawParam: style})
			target = len(layers) - 1
		}
		end := i + 1
		for end < len(prepared) && e.copiedLayerStyle(objects[end]) == style {
			end++
		}
		if len(layers[target].Objects) == 0 {
			layers[target].Objects = prepared[i:end:end]
		} else {
			layers[target].Objects = append(layers[target].Objects, prepared[i:end]...)
		}
		i = end
	}
	e.replacePreparedLayers(page, layers)
	return result, nil
}

// appendOwnedObjects 接收本库生成对象的所有权，全部校验后提交一次撤销记录
// 入参: ctx 取消上下文, page 目标页, objects 无原文和标识且调用方不再修改的对象
// 返回: error 校验或取消错误，失败时不提交页面内容
func (e *Editor) appendOwnedObjects(ctx context.Context, page int, objects []GraphicObject) error {
	return (&editorValidation{Editor: e}).appendOwnedObjects(ctx, page, objects)
}

// appendOwnedObjects 在资源不变的构建会话内复用校验结果，接收对象所有权
// 入参: ctx 取消上下文, page 目标页, objects 无原文和标识的独立对象
// 返回: error 校验或取消错误
func (v *editorValidation) appendOwnedObjects(ctx context.Context, page int, objects []GraphicObject) error {
	e := v.Editor
	if err := ctx.Err(); err != nil {
		return err
	}
	if _, err := e.page(page); err != nil {
		return err
	}
	if len(objects) == 0 {
		return nil
	}
	if err := e.prepareSourceIDs(); err != nil {
		return err
	}
	for i, object := range objects {
		if err := ctx.Err(); err != nil {
			return err
		}
		if object.origin != nil || editorObjectID(object) != "" {
			return fmt.Errorf("owned objects must not have identifiers or original content")
		}
		prepared, err := v.prepareObject("", object)
		if err != nil {
			return err
		}
		objects[i] = prepared
	}
	if err := ctx.Err(); err != nil {
		return err
	}
	for i := range objects {
		id := strconv.Itoa(e.maxID + i + 1)
		switch objects[i].Type {
		case "TextObject":
			objects[i].TextObject.ID = id
		case "PathObject":
			objects[i].PathObject.ID = id
		case "ImageObject":
			objects[i].ImageObject.ID = id
		case "CompositeObject":
			objects[i].CompositeGraphicUnit.ID = id
		}
	}
	layers := copyEditorPage(e.pages[page]).Content.Layer
	target := 0
	if e.originalPage(page) {
		target = len(e.source.pages[e.pages[page].ID].original.Content.Layer)
	}
	if target < len(layers) {
		target = len(layers) - 1
	}
	e.maxID += len(objects)
	if target == len(layers) || layers[target].DrawParam != "" {
		layers = append(layers, Layer{ID: e.nextID(), Type: "Body"})
		target = len(layers) - 1
	}
	if len(layers[target].Objects) == 0 {
		layers[target].Objects = objects[:len(objects):len(objects)]
	} else {
		layers[target].Objects = append(layers[target].Objects, objects...)
	}
	e.replacePreparedLayers(page, layers)
	return nil
}

// PageObjectInfo 批量获取页面对象能力与位置，不重复扫描同一容器
// 每次按当前页面计算，变更和撤销后无需失效旧缓存
// 入参: page 页面索引
// 返回: map[string]ObjectInfo 对象标识与信息, error 错误信息
func (e *Editor) PageObjectInfo(page int) (map[string]ObjectInfo, error) {
	content, err := e.page(page)
	if err != nil {
		return nil, err
	}
	result := make(map[string]ObjectInfo)
	orderable := make(map[*editorXML]bool)
	for i := range content.Content.Layer {
		layer := &content.Content.Layer[i]
		nodes := e.objectOrderNodes(page, layer)
		groups := make(map[*editorXML][]string)
		for _, object := range layer.Objects {
			id := editorObjectID(object)
			parent := e.objectOrderParent(nodes, id)
			groups[parent] = append(groups[parent], id)
			if id != "" {
				result[id] = ObjectInfo{Capabilities: e.objectCapabilities(object, orderable)}
			}
		}
		for parent, ids := range groups {
			container := layer.ID
			if parent != nil {
				container = parent.attr("ID")
			}
			for index, id := range ids {
				if id == "" {
					continue
				}
				info := result[id]
				info.Position = ObjectPosition{Layer: layer.ID, Container: container, Index: index, Count: len(ids)}
				result[id] = info
			}
		}
	}
	return result, nil
}

// ObjectPosition 获取对象的直接容器及排序位置
// 入参: page 页面索引, id 对象标识
// 返回: ObjectPosition 对象位置, error 错误信息
func (e *Editor) ObjectPosition(page int, id string) (ObjectPosition, error) {
	layer, _, err := e.findObject(page, id)
	if err != nil {
		return ObjectPosition{}, err
	}
	parent, indexes := e.objectOrderIndexes(page, layer, id)
	position := ObjectPosition{Layer: layer.ID, Container: layer.ID, Count: len(indexes)}
	if parent != nil {
		position.Container = parent.attr("ID")
	}
	for i, index := range indexes {
		if editorObjectID(layer.Objects[index]) == id {
			position.Index = i
			break
		}
	}
	return position, nil
}

// OrderObjects 调整同一图层或页块内选区的绘制顺序，保留各组选中及未选中对象的相对顺序
// 入参: page 页面索引, ids 对象标识, order 为up、down、top或bottom
// 返回: error 错误信息
func (e *Editor) OrderObjects(page int, ids []string, order string) error {
	if !slices.Contains([]string{"up", "down", "top", "bottom"}, order) {
		return fmt.Errorf("invalid object order %q", order)
	}
	selectedObjects, indexes, err := e.selectedObjects(page, ids)
	if err != nil || len(indexes) == 0 {
		return err
	}
	layer := &e.pages[page].Content.Layer[indexes[0].layer]
	_, siblings := e.objectOrderIndexes(page, layer, ids[0])
	positions := make(map[int]int, len(siblings))
	for i, index := range siblings {
		positions[index] = i
	}
	orderable := make(map[*editorXML]bool)
	for i, object := range selectedObjects {
		capability := e.objectCapabilities(object, orderable)
		_, exists := positions[indexes[i].index]
		if !capability.Order || indexes[i].layer != indexes[0].layer || !exists {
			return fmt.Errorf("ordering requires editable objects in the same container")
		}
	}
	layers := copyEditorPage(e.pages[page]).Content.Layer
	objects := make([]GraphicObject, len(siblings))
	for i, index := range siblings {
		objects[i] = layer.Objects[index]
	}
	selected := make([]bool, len(objects))
	for _, index := range indexes {
		selected[positions[index.index]] = true
	}
	orderEditorObjects(objects, selected, order)
	for i, index := range siblings {
		layers[indexes[0].layer].Objects[index] = objects[i]
	}
	e.replaceLayers(page, layers)
	return nil
}

// DistributeObjects 按可见范围等距分布同页对象，固定两端对象，保留绘制顺序
// 不足三个对象时不修改；允许负间距，无法保持位置顺序的重叠布局返回错误
// 入参: page 页面索引, ids 对象标识, axis 为horizontal或vertical
// 返回: error 错误信息
func (e *Editor) DistributeObjects(page int, ids []string, axis string) error {
	if axis != "horizontal" && axis != "vertical" {
		return fmt.Errorf("invalid distribution axis %q", axis)
	}
	objects, indexes, err := e.selectedObjects(page, ids)
	if err != nil || len(objects) < 3 {
		return err
	}
	boxes, err := e.objectBounds(page, objects)
	if err != nil {
		return err
	}
	matrices, err := editorDistribution(boxes, indexes, axis)
	if err != nil {
		return err
	}
	var updates []GraphicObject
	for i, matrix := range matrices {
		if matrix == IdentityMatrix {
			continue
		}
		object, err := cloneEditorObject(objects[i])
		if err != nil {
			return err
		}
		object, err = e.transformObject(object, matrix.e, matrix.f, 1)
		if err != nil {
			return err
		}
		updates = append(updates, object)
	}
	return e.updateObjects(page, updates, true)
}

// UpdateObjects 原子替换同页对象，按各对象ID定位，全部校验通过后提交一次历史记录
// 入参: page 页面索引, objects 新对象内容，ID不得重复
// 返回: error 错误信息
func (e *Editor) UpdateObjects(page int, objects []GraphicObject) error {
	return e.updateObjects(page, objects, false)
}

// TransformObjects 同页对象以页面原点等比缩放后统一平移，保持相对位置，一次撤销恢复全部
// 入参: page 页面索引, ids 对象标识, dx 横向位移, dy 纵向位移, scale 正缩放比例
// 返回: error 错误信息
func (e *Editor) TransformObjects(page int, ids []string, dx, dy, scale float64) error {
	if !finite(dx) || !finite(dy) || !finite(scale) || scale <= 0 {
		return fmt.Errorf("transform requires finite offsets and a positive finite scale")
	}
	objects, _, err := e.selectedObjects(page, ids)
	if err != nil {
		return err
	}
	if dx == 0 && dy == 0 && scale == 1 {
		return nil
	}
	return e.transformObjects(page, objects, func(object GraphicObject) (GraphicObject, error) {
		if e.originalPage(page) {
			if err := validateEditorGeometry(object); err != nil {
				return GraphicObject{}, err
			}
		}
		return e.transformObject(object, dx, dy, scale)
	})
}

// AlignObjects 单对象对齐页面，多对象相互对齐至选区边界，文字采用实际字形范围
// 入参: page 页面索引, ids 对象标识, alignment 为left、center、right、top、middle或bottom
// 返回: error 错误信息
func (e *Editor) AlignObjects(page int, ids []string, alignment string) error {
	if !slices.Contains([]string{"left", "center", "right", "top", "middle", "bottom"}, alignment) {
		return fmt.Errorf("invalid alignment %q", alignment)
	}
	objects, _, err := e.selectedObjects(page, ids)
	if err != nil || len(objects) == 0 {
		return err
	}
	boxes, err := e.objectBounds(page, objects)
	if err != nil {
		return err
	}
	target, _ := ParseBox(e.pages[page].Area.PhysicalBox)
	if len(objects) > 1 {
		target = Box{}
		for _, box := range boxes {
			target = unionTextBox(target, box)
		}
	}
	for i, box := range boxes {
		matrix := editorAlignment(box, target, alignment)
		objects[i], err = cloneEditorObject(objects[i])
		if err != nil {
			return err
		}
		objects[i], err = e.transformObject(objects[i], matrix.e, matrix.f, 1)
		if err != nil {
			return err
		}
	}
	return e.updateObjects(page, objects, true)
}

// DeleteObjects 原子删除同页对象，保留其余对象顺序，一次撤销恢复全部
// 入参: page 页面索引, ids 对象标识
// 返回: error 错误信息
func (e *Editor) DeleteObjects(page int, ids []string) error {
	objects, indexes, err := e.selectedObjects(page, ids)
	if err != nil || len(indexes) == 0 {
		return err
	}
	orderable := make(map[*editorXML]bool)
	for _, object := range objects {
		capability := e.objectCapabilities(object, orderable)
		if !capability.Delete {
			return fmt.Errorf("object %q cannot be deleted: %w", editorObjectID(object), capability.editError())
		}
	}
	layers := copyEditorPage(e.pages[page]).Content.Layer
	slices.SortFunc(indexes, compareEditorPosition)
	for _, index := range slices.Backward(indexes) {
		layer := &layers[index.layer]
		layer.Objects = slices.Delete(layer.Objects, index.index, index.index+1)
	}
	e.replaceLayers(page, layers)
	return nil
}

// compareEditorPosition 比较对象在页面结构中的先后顺序
// 入参: a 第一个对象的位置, b 第二个对象的位置
// 返回: int 比较结果
func compareEditorPosition(a, b editorObjectPosition) int {
	if value := cmp.Compare(a.layer, b.layer); value != 0 {
		return value
	}
	return cmp.Compare(a.index, b.index)
}

// objectOrderIndexes 获取同一直接容器的对象索引，不跨越图层或页块
// 入参: page 页面索引, layer 图层, id 对象标识
// 返回: *editorXML 原始容器, []int 对象索引
func (e *Editor) objectOrderIndexes(page int, layer *Layer, id string) (*editorXML, []int) {
	nodes := e.objectOrderNodes(page, layer)
	parent := e.objectOrderParent(nodes, id)
	var indexes []int
	for i, object := range layer.Objects {
		if e.objectOrderParent(nodes, editorObjectID(object)) == parent {
			indexes = append(indexes, i)
		}
	}
	return parent, indexes
}

// objectOrderNodes 获取原图层中的对象节点
// 入参: page 页面索引, layer 当前图层
// 返回: map[string]*editorXML 原节点映射
func (e *Editor) objectOrderNodes(page int, layer *Layer) map[string]*editorXML {
	if e.originalPage(page) {
		source := e.source.pages[e.pages[page].ID]
		if slices.ContainsFunc(source.original.Content.Layer, func(original Layer) bool { return original.ID == layer.ID }) {
			return source.nodes
		}
	}
	return nil
}

// objectOrderParent 获取对象的原始直接容器，新对象沿用所在图层
// 入参: nodes 原节点映射, id 对象标识
// 返回: *editorXML 原始容器
func (e *Editor) objectOrderParent(nodes map[string]*editorXML, id string) *editorXML {
	if nodes != nil {
		if node := nodes[id]; node != nil {
			return node.parent
		} else if origin := e.objectOrigin(id); origin != nil {
			return origin.node.parent
		}
	}
	return nil
}

// orderEditorObjects 调整选区层级，保持选中及未选中对象各自的相对顺序
// 入参: objects 同容器对象, selected 选中状态, order 排序方向
func orderEditorObjects[T any](objects []T, selected []bool, order string) {
	switch order {
	case "up":
		for i := len(objects) - 2; i >= 0; i-- {
			if selected[i] && !selected[i+1] {
				objects[i], objects[i+1] = objects[i+1], objects[i]
				selected[i], selected[i+1] = false, true
			}
		}
	case "down":
		for i := 1; i < len(objects); i++ {
			if selected[i] && !selected[i-1] {
				objects[i], objects[i-1] = objects[i-1], objects[i]
				selected[i], selected[i-1] = false, true
			}
		}
	default:
		ordered := make([]T, 0, len(objects))
		for _, takeSelected := range []bool{order == "bottom", order != "bottom"} {
			for i, object := range objects {
				if selected[i] == takeSelected {
					ordered = append(ordered, object)
				}
			}
		}
		copy(objects, ordered)
	}
}

// editorDistribution 计算等间距平移，位置相同时按原绘制顺序排序
// 入参: boxes 可见范围, indexes 绘制位置, axis 分布方向
// 返回: []Matrix 页面平移, error 错误信息
func editorDistribution(boxes []Box, indexes []editorObjectPosition, axis string) ([]Matrix, error) {
	matrices := make([]Matrix, len(boxes))
	for i := range matrices {
		matrices[i] = IdentityMatrix
	}
	if len(boxes) < 3 {
		return matrices, nil
	}
	positions, sizes := make([]float64, len(boxes)), make([]float64, len(boxes))
	order := make([]int, len(boxes))
	total := 0.0
	for i, box := range boxes {
		positions[i], sizes[i] = box.X, box.W
		if axis == "vertical" {
			positions[i], sizes[i] = box.Y, box.H
		}
		order[i] = i
		total += sizes[i]
	}
	slices.SortFunc(order, func(i, j int) int {
		if c := cmp.Compare(positions[i], positions[j]); c != 0 {
			return c
		}
		return compareEditorPosition(indexes[i], indexes[j])
	})
	first, last := order[0], order[len(order)-1]
	gap := (positions[last] + sizes[last] - positions[first] - total) / float64(len(order)-1)
	for i, index := range order[:len(order)-1] {
		step := sizes[index] + gap
		if geometryEqual(step, 0) {
			step = 0
		}
		if step < 0 || step == 0 && compareEditorPosition(indexes[index], indexes[order[i+1]]) > 0 {
			return nil, fmt.Errorf("overlap prevents ordered equal-gap distribution")
		}
	}
	next := positions[first] + sizes[first] + gap
	for _, index := range order[1 : len(order)-1] {
		position := next
		next += sizes[index] + gap
		if geometryEqual(position, positions[index]) {
			continue
		}
		dx, dy := position-positions[index], 0.0
		if axis == "vertical" {
			dx, dy = 0, dx
		}
		matrices[index] = TranslationMatrix(dx, dy)
	}
	return matrices, nil
}

// replaceLayers 替换图层容器，隔离历史快照与后续的增删、排序操作
// 入参: page 页面索引, layers 新图层列表
func (e *Editor) replaceLayers(page int, layers []Layer) {
	before := e.pages[page].Content.Layer
	if reflect.DeepEqual(before, layers) {
		return
	}
	after := copyEditorPage(PageContent{Content: Content{Layer: layers}}).Content.Layer
	e.replacePreparedLayers(page, after)
}

// replacePreparedLayers 提交已隔离的图层容器，历史启用时仍保留独立快照
// 图层回放同步补回文档或版本快照中尚未加载的页面原文、属性和对象来源
// 入参: page 页面索引, after 已准备且不再由调用方修改的图层列表
func (e *Editor) replacePreparedLayers(page int, after []Layer) {
	if e.historyLimit == 0 {
		e.pages[page].Content.Layer = after
		e.recordChange()
		return
	}
	before := copyEditorPage(e.pages[page])
	var reader *Reader
	var source *editorSourcePage
	var origins map[string]*editorObjectOrigin
	if e.source != nil {
		reader, source = e.source.reader, e.source.pages[before.ID]
		if source != nil && source.original != nil {
			origins = make(map[string]*editorObjectOrigin, len(source.nodes))
			for id := range source.nodes {
				origins[id] = e.source.origins[id]
			}
		}
	}
	apply := func(e *Editor, layers []Layer) {
		if source != nil && source.original != nil && e.source != nil && e.source.reader == reader && e.pages[page].ID == before.ID {
			if current := e.source.pages[before.ID]; current != nil && current.original == nil {
				e.source.pages[before.ID] = source
				for id, origin := range origins {
					e.source.origins[id] = origin
				}
				e.pages[page] = copyEditorPage(before)
			}
		}
		e.pages[page].Content.Layer = copyEditorPage(PageContent{Content: Content{Layer: layers}}).Content.Layer
	}
	apply(e, after)
	if change := e.recordChange(); change != nil {
		change.undo = func(e *Editor) { apply(e, before.Content.Layer) }
		change.redo = func(e *Editor) { apply(e, after) }
	}
}

// updateObjects 校验内容更新或几何与外观变换，原子提交跨图层选区
// 入参: page 页面索引, objects 新对象, preserveContent 是否保留原内容
// 返回: error 错误信息
func (e *Editor) updateObjects(page int, objects []GraphicObject, preserveContent bool) error {
	return e.updateObjectOrigins(page, objects, preserveContent, nil)
}

// updateObjectOrigins 原子提交对象及原文来源，撤销时一并恢复
// 入参: page 页面索引, objects 新对象, preserveContent 是否保留原内容, origins 新原文来源
// 返回: error 错误信息
func (e *Editor) updateObjectOrigins(page int, objects []GraphicObject, preserveContent bool, origins map[string]*editorObjectOrigin) error {
	ids := make([]string, len(objects))
	for i, object := range objects {
		ids[i] = editorObjectID(object)
	}
	before, indexes, err := e.selectedObjects(page, ids)
	if err != nil {
		return err
	}
	after := make([]GraphicObject, len(objects))
	var beforeOrigins, afterOrigins map[string]*editorObjectOrigin
	orderable := make(map[*editorXML]bool)
	for i, object := range objects {
		object.origin = nil
		preserved := preserveContent
		origin := e.objectOrigin(ids[i])
		if origin != nil {
			capability := e.objectCapabilities(before[i], orderable)
			if !capability.Transform {
				beforeBox, beforeCTM := editorGeometry(before[i])
				afterBox, afterCTM := editorGeometry(object)
				if !capability.Update && !(preserved && capability.Delete) || before[i].Type != object.Type || beforeBox != afterBox || beforeCTM != afterCTM {
					return fmt.Errorf("object %q is read-only for this operation: %w", ids[i], capability.editError())
				}
			}
			if !preserved && !capability.Update && editorPreservedObject(before[i], object) && capability.Paint {
				if err := e.validatePreservedAppearance(before[i], object); err != nil {
					return err
				}
				preserved = true
			}
			if !preserved && !editorXMLSupported(origin.node) {
				return capability.editError()
			}
		}
		if preserved && origin != nil {
			if err := validateEditorGeometry(object); err != nil {
				return err
			}
			after[i] = cloneEditorData(object)
			if before[i].Type != object.Type {
				data, err := editorObjectXML(object)
				if err != nil {
					return err
				}
				root, err := parseEditorXML(data)
				if err != nil {
					return err
				}
				root.parent = origin.node.parent
				if beforeOrigins == nil {
					beforeOrigins = make(map[string]*editorObjectOrigin)
					afterOrigins = make(map[string]*editorObjectOrigin)
				}
				beforeOrigins[ids[i]] = origin
				afterOrigins[ids[i]] = &editorObjectOrigin{page: origin.page, data: data, node: root, object: object}
			}
		} else {
			after[i], err = e.prepareObject(ids[i], object)
			if err != nil {
				return err
			}
			if e.originalPage(page) {
				after[i], err = e.resolveEditorStyle(after[i], e.pages[page].Content.Layer[indexes[i].layer].DrawParam)
				if err != nil {
					return err
				}
			}
		}
		if next := origins[ids[i]]; next != nil {
			if beforeOrigins == nil {
				beforeOrigins = make(map[string]*editorObjectOrigin)
				afterOrigins = make(map[string]*editorObjectOrigin)
			}
			beforeOrigins[ids[i]], afterOrigins[ids[i]] = origin, next
		}
	}
	if reflect.DeepEqual(before, after) && len(afterOrigins) == 0 {
		return nil
	}
	apply := func(e *Editor, objects []GraphicObject, origins map[string]*editorObjectOrigin) {
		for i, index := range indexes {
			e.pages[page].Content.Layer[index.layer].Objects[index.index] = objects[i]
		}
		for id, origin := range origins {
			e.setObjectOrigin(id, origin)
		}
	}
	apply(e, after, afterOrigins)
	if change := e.recordChange(); change != nil {
		change.undo = func(e *Editor) { apply(e, before, beforeOrigins) }
		change.redo = func(e *Editor) { apply(e, after, afterOrigins) }
	}
	return nil
}

// editorAlignment 计算对象范围到目标边缘或中心的平移
// 入参: box 对象范围, target 目标范围, alignment 对齐方式
// 返回: Matrix 页面平移
func editorAlignment(box, target Box, alignment string) Matrix {
	matrix := IdentityMatrix
	switch alignment {
	case "left":
		matrix.e = target.X - box.X
	case "center":
		matrix.e = target.X + (target.W-box.W)/2 - box.X
	case "right":
		matrix.e = target.X + target.W - box.W - box.X
	case "top":
		matrix.f = target.Y - box.Y
	case "middle":
		matrix.f = target.Y + (target.H-box.H)/2 - box.Y
	case "bottom":
		matrix.f = target.Y + target.H - box.H - box.Y
	}
	if geometryEqual(matrix.e, 0) {
		matrix.e = 0
	}
	if geometryEqual(matrix.f, 0) {
		matrix.f = 0
	}
	return matrix
}

// selectedObjects 校验同页选择，返回内部只读对象与对应索引
// 入参: page 页面索引, ids 对象标识，不得重复
// 返回: []GraphicObject 所选对象, []editorObjectPosition 图层和对象索引, error 错误信息
func (e *Editor) selectedObjects(page int, ids []string) ([]GraphicObject, []editorObjectPosition, error) {
	content, err := e.page(page)
	if err != nil {
		return nil, nil, err
	}
	objects := make([]GraphicObject, len(ids))
	indexes := make([]editorObjectPosition, len(ids))
	if len(ids) == 0 {
		return objects, indexes, nil
	}
	selected := make(map[string]int, len(ids))
	for i, id := range ids {
		if _, exists := selected[id]; exists {
			return nil, nil, fmt.Errorf("duplicate object %q", id)
		}
		selected[id] = i
	}
	for i, layer := range content.Content.Layer {
		for j, object := range layer.Objects {
			id := editorObjectID(object)
			if index, ok := selected[id]; ok && id != "" {
				objects[index] = object
				indexes[index] = editorObjectPosition{i, j}
				delete(selected, id)
				if len(selected) == 0 {
					return objects, indexes, nil
				}
			}
		}
	}
	for _, id := range ids {
		if _, missing := selected[id]; missing {
			return nil, nil, fmt.Errorf("object %q not found on page %d", id, page)
		}
	}
	return objects, indexes, nil
}

// editorObjectID 获取可创作对象的标准标识
// 入参: object 图形对象
// 返回: string 对象标识，不支持的类型返回空字符串
func editorObjectID(object GraphicObject) string {
	switch object.Type {
	case "TextObject":
		return object.TextObject.ID
	case "PathObject":
		return object.PathObject.ID
	case "ImageObject":
		return object.ImageObject.ID
	case "CompositeObject", "CompositeGraphicUnit":
		return object.CompositeGraphicUnit.ID
	}
	return ""
}

// objectBounds 批量获取对齐范围，复用同一渲染器的资源和字形缓存
// 入参: page 页面索引, objects 待度量的对象
// 返回: []Box 对象范围, error 错误信息
func (e *Editor) objectBounds(page int, objects []GraphicObject) ([]Box, error) {
	orderable := make(map[*editorXML]bool)
	for _, object := range objects {
		capability := e.objectCapabilities(object, orderable)
		if !capability.Arrange {
			return nil, fmt.Errorf("object %q cannot be arranged: %w", editorObjectID(object), capability.editError())
		}
	}
	reader, err := e.Reader()
	if err != nil {
		return nil, err
	}
	defer reader.Close()
	if _, err := reader.PageContentByIndex(page); err != nil {
		return nil, err
	}
	renderer := e.newRenderer(reader)
	objectLayers := make(map[string]int, len(objects))
	for _, object := range objects {
		objectLayers[editorObjectID(object)] = -1
	}
	for i, layer := range e.pages[page].Content.Layer {
		for _, object := range layer.Objects {
			id := editorObjectID(object)
			if index, wanted := objectLayers[id]; wanted && index < 0 {
				objectLayers[id] = i
			}
		}
	}
	boxes := make([]Box, len(objects))
	for i, object := range objects {
		layer := objectLayers[editorObjectID(object)]
		if layer < 0 {
			return nil, fmt.Errorf("object %q not found on page %d", editorObjectID(object), page)
		}
		boxes[i], err = renderer.ObjectBounds(object, e.pages[page].Content.Layer[layer].DrawParam)
		if err != nil {
			return nil, err
		}
		if boxes[i].W <= 0 || boxes[i].H <= 0 {
			return nil, fmt.Errorf("object %q has no visible bounds", editorObjectID(object))
		}
	}
	return boxes, nil
}