mirror of
https://github.com/xiaoqidun/ofdgo.git
synced 2026-10-29 17:27:08 +08:00
475 lines
14 KiB
Go
475 lines
14 KiB
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 (
|
|
"encoding/xml"
|
|
"net/url"
|
|
"strconv"
|
|
|
|
"github.com/tdewolff/canvas"
|
|
)
|
|
|
|
// Action 动作
|
|
type Action struct {
|
|
Event string `xml:"Event,attr"`
|
|
Region *Region `xml:"Region"`
|
|
Goto *Goto `xml:"Goto"`
|
|
URI *URI `xml:"URI"`
|
|
GotoA *GotoA `xml:"GotoA"`
|
|
Sound *Sound `xml:"Sound"`
|
|
Movie *Movie `xml:"Movie"`
|
|
}
|
|
|
|
// Goto 文档内跳转动作
|
|
type Goto struct {
|
|
Dest *Dest `xml:"Dest"`
|
|
Bookmark *GotoBookmark `xml:"Bookmark"`
|
|
}
|
|
|
|
// Dest 文档内跳转目标
|
|
type Dest struct {
|
|
Type string `xml:"Type,attr"`
|
|
PageID string `xml:"PageID,attr"`
|
|
Left float64 `xml:"Left"`
|
|
Right float64 `xml:"Right"`
|
|
Top float64 `xml:"Top"`
|
|
Bottom float64 `xml:"Bottom"`
|
|
Zoom float64 `xml:"Zoom"`
|
|
}
|
|
|
|
// GotoBookmark 书签跳转目标
|
|
type GotoBookmark struct {
|
|
Name string `xml:"Name,attr"`
|
|
}
|
|
|
|
// URI URI动作
|
|
type URI struct {
|
|
URI string `xml:"URI,attr"`
|
|
Base string `xml:"Base,attr"`
|
|
}
|
|
|
|
// PageLink 页面链接，URI、Dest和Attachment分别表示外链、文档内跳转和附件
|
|
// Box使用页面毫米坐标，Path为可选的页面坐标SVG路径，存在时作为精确点击区域
|
|
// 同一来源的多个动作共享非零Group，组内按返回顺序执行
|
|
type PageLink struct {
|
|
URI string
|
|
Box Box
|
|
Dest *Dest
|
|
Attachment string
|
|
Path string
|
|
Group int
|
|
}
|
|
|
|
// GotoA 附件动作
|
|
type GotoA struct {
|
|
AttachID string `xml:"AttachID,attr"`
|
|
NewWindow *bool `xml:"NewWindow,attr"`
|
|
}
|
|
|
|
// Sound 音频动作
|
|
type Sound struct {
|
|
ResourceID string `xml:"ResourceID,attr"`
|
|
Volume *int `xml:"Volume,attr"`
|
|
Repeat bool `xml:"Repeat,attr"`
|
|
Synchronous bool `xml:"Synchronous,attr"`
|
|
}
|
|
|
|
// Movie 视频动作
|
|
type Movie struct {
|
|
ResourceID string `xml:"ResourceID,attr"`
|
|
Operator string `xml:"Operator,attr"`
|
|
}
|
|
|
|
// Region 动作区域
|
|
type Region struct {
|
|
Area []RegionArea `xml:"Area"`
|
|
}
|
|
|
|
// RegionArea 动作区域分路径
|
|
type RegionArea struct {
|
|
Start string `xml:"Start,attr"`
|
|
Command []RegionCommand `xml:"-"`
|
|
}
|
|
|
|
// RegionCommand 动作区域绘制指令
|
|
type RegionCommand struct {
|
|
Type string
|
|
Point1 string
|
|
Point2 string
|
|
Point3 string
|
|
EllipseSize string
|
|
RotationAngle string
|
|
LargeArc string
|
|
SweepDirection string
|
|
EndPoint string
|
|
}
|
|
|
|
// actionSource 动作来源
|
|
type actionSource struct {
|
|
Box Box
|
|
Actions []Action
|
|
Matrix Matrix
|
|
Path string
|
|
}
|
|
|
|
// gotoDest 获取文档内跳转目标
|
|
// 入参: action 跳转动作, bookmarks 书签
|
|
// 返回: *Dest 跳转目标
|
|
func gotoDest(action *Goto, bookmarks map[string]Dest) *Dest {
|
|
if action.Dest != nil {
|
|
return action.Dest
|
|
}
|
|
if action.Bookmark != nil {
|
|
if dest, ok := bookmarks[action.Bookmark.Name]; ok {
|
|
return &dest
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// UnmarshalXML 解析跳转目标
|
|
// 入参: d XML解码器, start 起始节点
|
|
// 返回: error 错误信息
|
|
func (dest *Dest) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
|
var value struct {
|
|
Left *float64 `xml:"Left"`
|
|
Right *float64 `xml:"Right"`
|
|
Top *float64 `xml:"Top"`
|
|
Bottom *float64 `xml:"Bottom"`
|
|
Zoom *float64 `xml:"Zoom"`
|
|
}
|
|
dest.Type = attrValue(start, "Type")
|
|
dest.PageID = attrValue(start, "PageID")
|
|
dest.Left = actionFloatAttr(start, "Left")
|
|
dest.Right = actionFloatAttr(start, "Right")
|
|
dest.Top = actionFloatAttr(start, "Top")
|
|
dest.Bottom = actionFloatAttr(start, "Bottom")
|
|
dest.Zoom = actionFloatAttr(start, "Zoom")
|
|
if err := d.DecodeElement(&value, &start); err != nil {
|
|
return err
|
|
}
|
|
if value.Left != nil {
|
|
dest.Left = *value.Left
|
|
}
|
|
if value.Right != nil {
|
|
dest.Right = *value.Right
|
|
}
|
|
if value.Top != nil {
|
|
dest.Top = *value.Top
|
|
}
|
|
if value.Bottom != nil {
|
|
dest.Bottom = *value.Bottom
|
|
}
|
|
if value.Zoom != nil {
|
|
dest.Zoom = *value.Zoom
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// UnmarshalXML 解析视频动作并应用默认值
|
|
// 入参: d XML解码器, start 起始节点
|
|
// 返回: error 错误信息
|
|
func (m *Movie) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
|
type movie Movie
|
|
value := movie{Operator: "Play"}
|
|
if err := d.DecodeElement(&value, &start); err != nil {
|
|
return err
|
|
}
|
|
*m = Movie(value)
|
|
return nil
|
|
}
|
|
|
|
// UnmarshalXML 解析动作区域分路径并保留指令顺序
|
|
// 入参: d XML解码器, start 起始节点
|
|
// 返回: error 错误信息
|
|
func (a *RegionArea) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
|
*a = RegionArea{Start: attrValue(start, "Start")}
|
|
for {
|
|
tok, err := d.Token()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch node := tok.(type) {
|
|
case xml.StartElement:
|
|
command := RegionCommand{
|
|
Type: node.Name.Local,
|
|
Point1: attrValue(node, "Point1"),
|
|
Point2: attrValue(node, "Point2"),
|
|
Point3: attrValue(node, "Point3"),
|
|
EllipseSize: attrValue(node, "EllipseSize"),
|
|
RotationAngle: attrValue(node, "RotationAngle"),
|
|
LargeArc: attrValue(node, "LargeArc"),
|
|
SweepDirection: attrValue(node, "SweepDirection"),
|
|
EndPoint: attrValue(node, "EndPoint"),
|
|
}
|
|
a.Command = append(a.Command, command)
|
|
if err := d.Skip(); err != nil {
|
|
return err
|
|
}
|
|
case xml.EndElement:
|
|
if node.Name.Local == start.Name.Local {
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// actionFloatAttr 获取动作浮点属性
|
|
// 入参: start 起始节点, name 属性名
|
|
// 返回: float64 属性值
|
|
func actionFloatAttr(start xml.StartElement, name string) float64 {
|
|
value, _ := strconv.ParseFloat(attrValue(start, name), 64)
|
|
return value
|
|
}
|
|
|
|
// pageActionSources 获取页面动作来源
|
|
// 入参: page 页面内容, box 页面区域
|
|
// 返回: []actionSource 动作来源
|
|
func (r *Renderer) pageActionSources(page *PageContent, box Box) []actionSource {
|
|
sources := make([]actionSource, 0)
|
|
if len(page.Actions) > 0 {
|
|
sources = append(sources, actionSource{
|
|
Box: Box{W: box.W, H: box.H},
|
|
Actions: page.Actions,
|
|
Matrix: IdentityMatrix,
|
|
})
|
|
}
|
|
for order := range 3 {
|
|
if r.Reader.doc != nil {
|
|
for _, ref := range page.Template {
|
|
kind := ref.ZOrder
|
|
if kind == "" {
|
|
kind = "Background"
|
|
}
|
|
if layerOrder(kind) != order {
|
|
continue
|
|
}
|
|
if template := r.loadTemplate(ref.TemplateID); template != nil {
|
|
sources = append(sources, actionSource{Box: Box{W: box.W, H: box.H}, Actions: template.Actions, Matrix: IdentityMatrix})
|
|
for templateOrder := range 3 {
|
|
sources = r.appendLayerActionSources(sources, template.Content.Layer, templateOrder)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
sources = r.appendLayerActionSources(sources, page.Content.Layer, order)
|
|
}
|
|
return sources
|
|
}
|
|
|
|
// appendLayerActionSources 按绘制顺序添加图层动作来源
|
|
// 入参: sources 动作来源, layers 页面图层, order 图层顺序
|
|
// 返回: []actionSource 动作来源
|
|
func (r *Renderer) appendLayerActionSources(sources []actionSource, layers []Layer, order int) []actionSource {
|
|
for _, layer := range layers {
|
|
if layerOrder(layer.Type) != order {
|
|
continue
|
|
}
|
|
for _, object := range layer.Objects {
|
|
sources = r.appendGraphicActionSources(sources, object, IdentityMatrix, false, nil)
|
|
}
|
|
}
|
|
return sources
|
|
}
|
|
|
|
// annotationActionSources 获取注释动作来源
|
|
// 入参: annotations 页面注释
|
|
// 返回: []actionSource 动作来源
|
|
func (r *Renderer) annotationActionSources(annotations []Annotation) []actionSource {
|
|
sources := make([]actionSource, 0)
|
|
for _, annotation := range annotations {
|
|
if annotation.Visible != nil && !*annotation.Visible {
|
|
continue
|
|
}
|
|
box, err := ParseBox(annotation.Appearance.Boundary)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
for _, object := range annotation.Appearance.Objects {
|
|
sources = r.appendGraphicActionSources(sources, object, TranslationMatrix(box.X, box.Y), false, nil)
|
|
}
|
|
}
|
|
return sources
|
|
}
|
|
|
|
// appendGraphicActionSources 添加图形对象动作来源
|
|
// 入参: sources 动作来源, object 图形对象, parent 父级变换, boundaryInCTM 边界是否参与父级变换, seen 当前资源引用链
|
|
// 返回: []actionSource 动作来源
|
|
func (r *Renderer) appendGraphicActionSources(sources []actionSource, object GraphicObject, parent Matrix, boundaryInCTM bool, seen map[string]bool) []actionSource {
|
|
var boundary, ctm, resource string
|
|
var actions []Action
|
|
var children []GraphicObject
|
|
composite := false
|
|
switch object.Type {
|
|
case "TextObject":
|
|
boundary = object.TextObject.Boundary
|
|
ctm = object.TextObject.CTM
|
|
actions = object.TextObject.Actions
|
|
case "PathObject":
|
|
boundary = object.PathObject.Boundary
|
|
ctm = object.PathObject.CTM
|
|
actions = object.PathObject.Actions
|
|
case "ImageObject":
|
|
boundary = object.ImageObject.Boundary
|
|
ctm = object.ImageObject.CTM
|
|
actions = object.ImageObject.Actions
|
|
case "CompositeGraphicUnit", "CompositeObject":
|
|
boundary = object.CompositeGraphicUnit.Boundary
|
|
ctm = object.CompositeGraphicUnit.CTM
|
|
resource = object.CompositeGraphicUnit.ResourceID
|
|
actions = object.CompositeGraphicUnit.Actions
|
|
children = object.CompositeGraphicUnit.Objects
|
|
composite = true
|
|
}
|
|
box, _ := ParseBox(boundary)
|
|
placement := TranslationMatrix(box.X, box.Y).Multiply(parent)
|
|
if boundaryInCTM || composite {
|
|
placement = parent.Multiply(TranslationMatrix(box.X, box.Y))
|
|
}
|
|
matrix := placement.Multiply(NewMatrix(ctm))
|
|
if len(actions) > 0 {
|
|
source := actionSource{Box: placement.TransformBox(Box{W: box.W, H: box.H}), Actions: actions, Matrix: matrix}
|
|
if placement.a == 1 && placement.b == 0 && placement.c == 0 && placement.d == 1 {
|
|
source.Box.W, source.Box.H = box.W, box.H
|
|
}
|
|
if box.W > 0 && box.H > 0 && !axisAlignedMatrix(placement) {
|
|
source.Path = canvas.Rectangle(box.W, box.H).Transform(actionCanvasMatrix(placement)).ToSVG()
|
|
}
|
|
sources = append(sources, source)
|
|
}
|
|
if resource != "" && !seen[resource] {
|
|
if unit := r.CompositeGraphicUnits[resource]; unit != nil {
|
|
if seen == nil {
|
|
seen = make(map[string]bool)
|
|
}
|
|
seen[resource] = true
|
|
sources = r.appendGraphicActionSources(sources, GraphicObject{Type: "CompositeGraphicUnit", CompositeGraphicUnit: *unit}, matrix, true, seen)
|
|
delete(seen, resource)
|
|
}
|
|
}
|
|
for _, child := range children {
|
|
sources = r.appendGraphicActionSources(sources, child, matrix, boundaryInCTM, seen)
|
|
}
|
|
return sources
|
|
}
|
|
|
|
// actionCanvasMatrix 转换页面坐标矩阵，不翻转Y轴
|
|
// 入参: matrix 页面变换
|
|
// 返回: canvas.Matrix 路径变换
|
|
func actionCanvasMatrix(matrix Matrix) canvas.Matrix {
|
|
return canvas.Matrix{{matrix.a, matrix.c, matrix.e}, {matrix.b, matrix.d, matrix.f}}
|
|
}
|
|
|
|
// actionRegionPath 解析复杂点击区域并转换为页面坐标
|
|
// 入参: region 动作区域, matrix 坐标变换
|
|
// 返回: *canvas.Path 点击路径
|
|
func actionRegionPath(region *Region, matrix Matrix) *canvas.Path {
|
|
path := &canvas.Path{}
|
|
for _, area := range region.Area {
|
|
start := parseFloats(area.Start)
|
|
if len(start) != 2 {
|
|
continue
|
|
}
|
|
part := &canvas.Path{}
|
|
part.MoveTo(start[0], start[1])
|
|
for _, command := range area.Command {
|
|
p1, p2, p3 := parseFloats(command.Point1), parseFloats(command.Point2), parseFloats(command.Point3)
|
|
switch command.Type {
|
|
case "Move":
|
|
if len(p1) == 2 {
|
|
part.Close()
|
|
part.MoveTo(p1[0], p1[1])
|
|
}
|
|
case "Line":
|
|
if len(p1) == 2 {
|
|
part.LineTo(p1[0], p1[1])
|
|
}
|
|
case "QuadraticBezier":
|
|
if len(p1) == 2 && len(p2) == 2 {
|
|
part.QuadTo(p1[0], p1[1], p2[0], p2[1])
|
|
}
|
|
case "CubicBezier":
|
|
if len(p3) == 2 {
|
|
first, second := part.Pos(), canvas.Point{X: p3[0], Y: p3[1]}
|
|
if len(p1) == 2 {
|
|
first = canvas.Point{X: p1[0], Y: p1[1]}
|
|
}
|
|
if len(p2) == 2 {
|
|
second = canvas.Point{X: p2[0], Y: p2[1]}
|
|
}
|
|
part.CubeTo(first.X, first.Y, second.X, second.Y, p3[0], p3[1])
|
|
}
|
|
case "Arc":
|
|
size, end := parseFloats(command.EllipseSize), parseFloats(command.EndPoint)
|
|
angle, err := strconv.ParseFloat(command.RotationAngle, 64)
|
|
large, largeErr := strconv.ParseBool(command.LargeArc)
|
|
sweep, sweepErr := strconv.ParseBool(command.SweepDirection)
|
|
if len(end) == 2 && err == nil && largeErr == nil && sweepErr == nil {
|
|
rx, ry := 0.0, 0.0
|
|
if len(size) > 0 {
|
|
rx, ry = size[0], size[0]
|
|
}
|
|
if len(size) > 1 {
|
|
ry = size[1]
|
|
}
|
|
part.ArcTo(rx, ry, angle, large, sweep, end[0], end[1])
|
|
}
|
|
case "Close":
|
|
part.Close()
|
|
}
|
|
}
|
|
part.Close()
|
|
path = path.Append(part)
|
|
}
|
|
if canvas.Equal(matrix.a*matrix.d-matrix.b*matrix.c, 0) {
|
|
path = path.ReplaceArcs()
|
|
}
|
|
return path.Transform(actionCanvasMatrix(matrix))
|
|
}
|
|
|
|
// actionLinkRegion 获取动作点击区域
|
|
// 入参: source 动作来源, action 动作
|
|
// 返回: Box 外接矩形, string 精确路径
|
|
func actionLinkRegion(source actionSource, action Action) (Box, string) {
|
|
if action.Region == nil {
|
|
return source.Box, source.Path
|
|
}
|
|
path := actionRegionPath(action.Region, source.Matrix)
|
|
if path.Empty() {
|
|
return Box{}, ""
|
|
}
|
|
box := path.Bounds()
|
|
return Box{X: box.X0, Y: box.Y0, W: box.W(), H: box.H()}, path.ToSVG()
|
|
}
|
|
|
|
// resolveActionURI 解析URI动作地址
|
|
// 入参: action URI动作
|
|
// 返回: string URI地址
|
|
func resolveActionURI(action URI) string {
|
|
if action.Base == "" {
|
|
return action.URI
|
|
}
|
|
base, err := url.Parse(action.Base)
|
|
if err != nil {
|
|
return action.URI
|
|
}
|
|
target, err := url.Parse(action.URI)
|
|
if err != nil {
|
|
return action.URI
|
|
}
|
|
return base.ResolveReference(target).String()
|
|
}
|