From 037474cf5b8eb0db738e930e9d2e364cabf27f5c Mon Sep 17 00:00:00 2001 From: Pjandro Date: Fri, 23 Oct 2026 21:25:15 +0000 Subject: [PATCH] =?UTF-8?q?SmartArt:=20ECMA-376=20=D0=BF=D1=80=D0=B5=D1=81?= =?UTF-8?q?=D0=B5=D1=82-=D0=B3=D0=B5=D0=BE=D0=BC=D0=B5=D1=82=D1=80=D0=B8?= =?UTF-8?q?=D1=8F=20=D0=B2=D0=BC=D0=B5=D1=81=D1=82=D0=BE=20=D0=BA=D0=B0?= =?UTF-8?q?=D0=BB=D0=B8=D0=B1=D1=80=D0=BE=D0=B2=D0=B0=D0=BD=D0=BD=D1=8B?= =?UTF-8?q?=D1=85=20=D0=BA=D0=BE=D1=8D=D1=84=D1=84=D0=B8=D1=86=D0=B8=D0=B5?= =?UTF-8?q?=D0=BD=D1=82=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PresetGeometry: avLst/gdLst/pathLst семи пресетов (rect, roundRect, ellipse, gear6, gear9, circularArrow, leftCircularArrow) дословно из presetShapeDefinitions.xml + вычислитель префиксных формул ST_GeomGuideFormula. Кольцевые стрелки: оператор ?: = «if x > 0 then y else z» (ISO/IEC 29500-1), углы Arc2D со знаком минус (математическая конвенция). PrstGeomShapes удалён. PresetGeometryTest#tableMatchesEcmaXml пинит синхрон таблицы с копией стандарта (test-ресурс geom/presetShapeDefinitions.xml). --- AGENTS.md | 13 +- .../internal/chart/PresetGeometry.java | 1280 + .../internal/chart/PrstGeomShapes.java | 183 - .../internal/chart/SmartArtRenderer.java | 160 +- .../internal/chart/PresetGeometryTest.java | 275 + .../resources/geom/presetShapeDefinitions.xml | 19898 ++++++++++++++++ 6 files changed, 21562 insertions(+), 247 deletions(-) create mode 100644 wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/PresetGeometry.java delete mode 100644 wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/PrstGeomShapes.java create mode 100644 wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/PresetGeometryTest.java create mode 100644 wordpdf-core/src/test/resources/geom/presetShapeDefinitions.xml diff --git a/AGENTS.md b/AGENTS.md index b77cbbb..d6a11a1 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -28,7 +28,7 @@ ### Chart-движок (`internal/chart`, package-private кроме `DrawingPreRenderer.run`) -Java2D → PNG 300 dpi (`ChartRenderer.DPI = 300`, `PADDING = 4.0`, растр × `DPI/72`, размеры — в пунктах, EMU→pt `cx/12700.0`). `ChartSpec.parse` (`enum Type`: PIE/PIE3D/DOUGHNUT/BAR/BAR_HORIZONTAL/LINE/AREA/SURFACE3D/UNSUPPORTED; пустой `c:title` + `autoTitleDeleted="0"` → у **круговых** имя первого ряда, у прочих — `AUTO_TITLE = "Название диаграммы"` (русская замена англ. плейсхолдеру Word); палитра `accent1..6` темы, легенда по умолчанию снизу, позиция `t` поддержана, `overlay` → место не резервируется) → `ChartRenderer` (осевые «круглые» шаги `niceUnit` 1/2/5·10ⁿ как Word) → пейнтеры `CartesianPainter`/`PiePainter` (`DEPTH_RATIO=0.22`, `TILT_CORRECTION=0.95`, `FIT_MARGIN=0.865`)/`Surface3dPainter` (калибровка по эталону Word 300 dpi: `CAMERA_DISTANCE=2.36`, `DEPTH_RATIO=0.705`, `HEIGHT_RATIO=0.664`, `GUTTER_LEFT/RIGHT=0.1485`, `GUTTER_TOP=0.116`, `GUTTER_BOTTOM=0.146`, свет `LIGHT_X/Y/Z=0.83/0.48/0.28`); `SmartArtRenderer` рисует кэш разложенной схемы (relationship `…/office/2007/relationships/diagramDrawing`, фактически `word/diagrams/drawing1.xml`; fit-scale ×0.80); палитра темы — `DrawMlColor` (instance; без ThemePart — дефолтная Office-палитра `accent1=4472C4`…); текст — `DrawMlText`; утилиты `RgbHsl`, `PrstGeomShapes`. Калибровочные константы менять только вместе с `Surface3dPainterTest`/`PiePainterTest`. Обход `pkg.getParts()` — только по **снимку** списка (`createImagePart` мутирует реестр → CME); rels частей — `part.getRelationshipsPart()`, НЕ `getOwningRelationshipPart()` (это rels ссылающегося); обход XML обязан раскрывать `JAXBElement`. +Java2D → PNG 300 dpi (`ChartRenderer.DPI = 300`, `PADDING = 4.0`, растр × `DPI/72`, размеры — в пунктах, EMU→pt `cx/12700.0`). `ChartSpec.parse` (`enum Type`: PIE/PIE3D/DOUGHNUT/BAR/BAR_HORIZONTAL/LINE/AREA/SURFACE3D/UNSUPPORTED; пустой `c:title` + `autoTitleDeleted="0"` → у **круговых** имя первого ряда, у прочих — `AUTO_TITLE = "Название диаграммы"` (русская замена англ. плейсхолдеру Word); палитра `accent1..6` темы, легенда по умолчанию снизу, позиция `t` поддержана, `overlay` → место не резервируется) → `ChartRenderer` (осевые «круглые» шаги `niceUnit` 1/2/5·10ⁿ как Word) → пейнтеры `CartesianPainter`/`PiePainter` (`DEPTH_RATIO=0.22`, `TILT_CORRECTION=0.95`, `FIT_MARGIN=0.865`)/`Surface3dPainter` (калибровка по эталону Word 300 dpi: `CAMERA_DISTANCE=2.36`, `DEPTH_RATIO=0.705`, `HEIGHT_RATIO=0.664`, `GUTTER_LEFT/RIGHT=0.1485`, `GUTTER_TOP=0.116`, `GUTTER_BOTTOM=0.146`, свет `LIGHT_X/Y/Z=0.83/0.48/0.28`); `SmartArtRenderer` рисует кэш разложенной схемы (relationship `…/office/2007/relationships/diagramDrawing`, фактически `word/diagrams/drawing1.xml`; fit-scale ×0.80), формы строит `PresetGeometry` — ECMA-пресет-геометрия `a:prstGeom`: avLst/gdLst/pathLst семи пресетов (rect, roundRect, ellipse, gear6, gear9, circularArrow, leftCircularArrow) дословно из `presetShapeDefinitions.xml`, вычислитель префиксных формул; оператор `?:` = «if x > 0 then y else z» (ISO/IEC 29500-1, НЕ x != 0), углы в Arc2D передавать со знаком минус (математическая конвенция y вверх), неизвестный пресет → прямоугольник ячейки (синхрон таблицы со стандартом пинит `PresetGeometryTest#tableMatchesEcmaXml`); палитра темы — `DrawMlColor` (instance; без ThemePart — дефолтная Office-палитра `accent1=4472C4`…); текст — `DrawMlText`; утилиты `RgbHsl`. Калибровочные константы менять только вместе с `Surface3dPainterTest`/`PiePainterTest`. Обход `pkg.getParts()` — только по **снимку** списка (`createImagePart` мутирует реестр → CME); rels частей — `part.getRelationshipsPart()`, НЕ `getOwningRelationshipPart()` (это rels ссылающегося); обход XML обязан раскрывать `JAXBElement`. ### Критические инварианты (нарушение = битый вывод) @@ -37,7 +37,7 @@ Java2D → PNG 300 dpi (`ChartRenderer.DPI = 300`, `PADDING = 4.0`, растр - FOP — форк `org.docx4j:docx4j-fo-renderer*` 2.11-docx4j.6 (транзитив от `docx4j-export-fo` 17.3.2, в pom не пинится; пакеты `org.apache.fop.*`). `Fop.Renderers.getRenderer()` возвращает **список** (рендер выбирается по mime `application/pdf`). `docx2fo.xslt` в репозитории нет — он в jar `docx4j-export-fo`. - Страницы в валидаторе = `max(кэш docProps/app.xml, явные разрывы, lastRenderedPageBreak+1)`; explicit = межсекционные `sectPr` в body + `w:br type="page"` + `pageBreakBefore` (включая таблицы и `w:sdt`). Единственный путь — lightweight (StAX по zip, secure-ридер без DTD/external entities; JAXB-обход удалён — `WordPdfValidator` не зависит от docx4j): атрибуты — по локальному имени (`attrLocal`, не по transitional-URI: иначе в strict-документе `w:br type="page"` не засчитываются); `sectPr` внутри `pPr` не считает, последнюю body-direct секцию не считает, `continuous`-секции не считает, в колонтитулах — только `w:br type="page"`, `pageBreakBefore` — только внутри `pPr` вне `sectPr` (truthy-значения `val`: `null|true|1|on`); на не-zip молчит — подпись проверяет вызывающий. Все отказы — `ValidationException`. - Известный остаток эталона: U+2188/U+218A — глифов нет в OFL-шрифтах бандла, остаются `.notdef` (GNU FreeSerif GPL — не добавляем намеренно). -- Внимательно: комментарии в `WordPdfConverter`/`DocxOnOffNormalizer` говорят «docx4j 11.x» — устаревшее число, фактически 17.3.2 (описанное поведение верно); javadoc `PrstGeomShapes` gear «×0.92» vs код `×0.82`. +- Внимательно: комментарии в `WordPdfConverter`/`DocxOnOffNormalizer` говорят «docx4j 11.x» — устаревшее число, фактически 17.3.2 (описанное поведение верно). ### Шрифты (30 TTF + 3 лицензии, SIL OFL, `wordpdf-core/src/main/resources/fonts/`) @@ -52,7 +52,8 @@ Java2D → PNG 300 dpi (`ChartRenderer.DPI = 300`, `PADDING = 4.0`, растр |`…/wordpdf/internal/`|6 байтовых нормализатора + `FopFallbackFonts` (классы `public` — вызываются из родительского пакета; публичные члены только `normalize`/`declare`; `OleObjectNormalizer` — многочастный, публичный `normalize(byte[], boolean)`, бросает `DrawingFoundException(OLE)`)| |`…/wordpdf/internal/chart/`|11 классов Java2D-рендера диаграмм/SmartArt в PNG (public только `DrawingPreRenderer`)| |`wordpdf-core/src/main/resources/fonts/`|30 TTF + 3 лицензии — бинарные фикстуры, часть jar| -|`wordpdf-core/src/test/resources/samples/`|12 закоммиченных `.docx`-фикстур (единственные фикстуры)| +|`wordpdf-core/src/test/resources/samples/`|12 закоммиченных `.docx`-фикстур (единственные .docx-фикстуры)| +|`wordpdf-core/src/test/resources/geom/`|`presetShapeDefinitions.xml` — копия приложения ECMA-376, синхрон таблицы `PresetGeometry` (только в тестах, в jar не попадает)| |`wordpdf-app/src/main/java/ru/pjandro/wordpdf/app/`|REST API (10 классов): `WordPdfApplication` (единственный public), `ConvertController`, `ConversionService` (очередь), `ApiExceptionHandler`, `ApiKeyFilter`, `OpenApiConfig` (`@SecurityScheme` X-API-Key для springdoc) + 5 класса исключений| |`wordpdf-web/src/`|SPA (React 19 + TS + Vite + Tailwind): `api.ts` (вся сеть), `components/` (App, ApiKeyGate, PdfPreview, StatusMessage, DropZone, Logo)| |корневые `Containerfile`, `compose.yml`, `compose.dev.yml`, `gateway/nginx.conf`|образ бэкенда (multi-stage maven:3.9-temurin-21 → temurin-**21-jre-alpine** (musl) — chart-движку нужен только модуль java.desktop (Graphics2D, он внутри JRE); fontconfig и системные шрифты рантайму не нужны — текст рисуется глифами fontbox, см. `fonts/GlyphFont` (проверено на musl-стенде без libfontconfig/`/etc/fonts`); HEALTHCHECK busybox `wget` (curl/apt не ставим), non-root uid 10001); compose app+web+gateway: web-образ со своим HEALTHCHECK (`wget /`), в обоих compose `depends_on web: condition: service_healthy`; прод-compose не в репо — его рендерит job `deploy` (лимиты запекаются из Variables); podman-специфика обоих compose: `x-podman.name_separator_compat` (docker-style имена), явные `healthcheck` app/web (дубли Containerfile-HEALTHCHECK — OCI-выгрузка его теряет; app-хелсчеки — `wget`, как в Containerfile), зафиксированная подсеть `10.113.0.0/24` gw `10.113.0.1` под резолвер aardvark-dns; два repo-стенда одновременно не поднять (общая подсеть)| @@ -153,13 +154,13 @@ SSH-пользователи/логины, ни хосты, ни директо ## Testing & QA -- Гейт `maven-pmd-plugin` 3.28.0 (PMD 7.17) на `verify` для обоих модулей, ruleset `pmd-ruleset.xml` (codestyle без opinionated-правил + unused-правила + XPath `LiteralFirstInEquals` — строковый литерал слева в `equals`/`equalsIgnoreCase`; `junit5TestPattern` разрешает underscore-имена регрессий; `includeTests=true` — тесты сканируются; `failurePriority` не задан — дефолт 2, т.е. нарушения priority ≤ 2 валят build, priority 3 — только WARNING в отчёт). Литералы в условиях `if` — только именованными константами (`AvoidLiteralsInIfCondition`), `null` вместо пустой коллекции запрещён (`ReturnEmptyCollectionRatherThanNull` — `GlyphCoverageNormalizer.split` возвращает пустой список). -- 17 тестовых классов / 162 `@Test` (core 14/132, app 3/30). JUnit 6 (`org.junit.jupiter:junit-jupiter`), surefire 3.6.0 с `-Djava.awt.headless=true` в argLine; только `Assertions` (Mockito/AssertJ не использовать, несмотря на test-classpath Boot; в app-тестах допустим inline-Hamcrest `org.hamcrest.Matchers.containsString` в `andExpect`); тестовые классы package-private, зеркалят main-пакеты; только `@Test` (+ единственный `@BeforeAll` — warm-up шрифтов в `GlyphCoverageNormalizerTest`). +- Гейт `maven-pmd-plugin` 3.28.0 (PMD 7.17) на `verify` для обоих модулей, ruleset `pmd-ruleset.xml` (codestyle без opinionated-правил + unused-правила + XPath `LiteralFirstInEquals` — строковый литерал слева в `equals`/`equalsIgnoreCase`; `junit5TestPattern` разрешает underscore-имена регрессий; `includeTests=true` — тесты сканируются; `failurePriority` не задан — на практике `verify` валят нарушения любой приоритетности, проверено на priority 3–4: строки `[WARNING] PMD Failure` = BUILD FAILURE). Литералы в условиях `if` — только именованными константами (`AvoidLiteralsInIfCondition`; `else if`-ветки правило не проверяет, обычный вложенный `if` — проверяет; пустые `while` тоже валятся — `EmptyControlStatement`), `null` вместо пустой коллекции запрещён (`ReturnEmptyCollectionRatherThanNull` — `GlyphCoverageNormalizer.split` возвращает пустой список). +- 18 тестовых классов / 173 `@Test` (core 15/143, app 3/30). JUnit 6 (`org.junit.jupiter:junit-jupiter`), surefire 3.6.0 с `-Djava.awt.headless=true` в argLine; только `Assertions` (Mockito/AssertJ не использовать, несмотря на test-classpath Boot; в app-тестах допустим inline-Hamcrest `org.hamcrest.Matchers.containsString` в `andExpect`); тестовые классы package-private, зеркалят main-пакеты; только `@Test` (+ единственный `@BeforeAll` — warm-up шрифтов в `GlyphCoverageNormalizerTest`). - **PDF сравнивается текстом, не растеризацией**: PDFBox 3 (`Loader.loadPDF`) — `PDFTextStripper` для текста (пер-странично `setStartPage/setEndPage`), override `processTextPosition` для шрифта конкретного символа (`fontNameOf`), обход ресурсов страниц для встроенных шрифтов (`EAAAAA+Carlito-Bold`) и счётчика картинок (`imageCount`). Негативные маркеры — регрессии: `assertFalse(text.contains("#"))` (.notdef), `assertFalse(font.startsWith("Helvetica"))`. Текст нормализуется по пробелам (`norm`); в `tableImage_tableAndImage` — полное удаление пробелов (docx4j переносит слова в auto-fit таблицах). - Пиксели (BufferedImage) — только в unit-тестах chart-пейнтеров: безразмерные отношения к эталону Word, допуски `assertRatio` <0.06 (`PiePainterTest` аспект h/w=0.585) / <0.10 (`Surface3dPainterTest`, + `assertRange` ±6 pt для центров силуэта); пороги залитых px и перцентильные коридоры яркости. Эталонные замеры — по Word-экспорту 300 dpi (`develop/`, вне git). - `GlyphFont` (fontbox): метрики пиксельно-метрически эквивалентны AWT (ascent/descent/leading/advance совпадают до 4-го знака, кернинг-дрейф 0.0000 — DejaVu Sans, Carlito). Приёмочный стенд без-fontconfig: контейнер без `libfontconfig.so.1*` и `/etc/fonts`, `mvn verify` + `java -jar` (до перехода на GlyphFont там падали `GlyphCoverageNormalizerTest` 12 / `CartesianPainterTest` 3 / `PiePainterTest` 2 / chart-тесты `WordPdfConverterTest` 4, chart-рендер молча деградировал). `GlyphFontTest` написан без единого `java.awt.Font` — обязан проходить на хосте без fontconfig. - Фикстуры — закоммиченные `samples/*.docx` (12; в тестах не генерировать): core грузит classpath-ресурсом → `byte[]`, PDF для PDFBox — временный файл; app читает `/samples/…` из **test-jar core** (classifier `tests`) → `mvn -pl wordpdf-app` без `-am` не соберётся. In-memory docx — `ZipOutputStream` из литеральных XML или POI в `byte[]`. Ключевые: `too-many-pages` (150 явных разрывов → 151), `stale-cache` (кэш `1` + 110 `lastRenderedPageBreak`), `charts-smartart` (4 растра; SmartArt-одиночка = ровно 2 Image XObject), `ole-embedded` (осиротевший bin с ложным `Default bin→footer+xml` + настоящий `w:object` с честным `Override → oleObject`; ручная, генератором не перезаписывать). - Юниты нормализаторов работают строками (`rewrite`) + zip'ами из `ZipOutputStream`; обязательные контракты: «нечего менять → тот же массив» (`assertSame` покрыт тестами только у zip-нормализаторов `DocxOnOff`/`SymbolFont`/`StrictOoxml` и у `OleObject` — `printerSettings`-bin/нет `.bin`; у `Field`/`GlyphCoverage` — `rewrite`→`null`) и неприкосновенность частей вне `word/*.xml` (`[Content_Types].xml`). Тесты бьют и в package-private API (`GlyphCoverageNormalizer.split(text, family)`, `ChartSpec.readTitle`). Исключение — `OleObjectNormalizerTest`: многочастный нормализатор без `rewrite`-хука, тесты только через `normalize` на in-memory zip. - App-тесты: `@SpringBootTest` + `@AutoConfigureMockMvc` (Boot 4: `org.springframework.boot.webmvc.test.autoconfigure`); три контекста — `ConvertControllerTest` (пустой ключ), `ApiKeyFilterTest` (`properties = "wordpdf.api-key=…"`), `ConvertLimitsTest` (`@TestPropertySource` с лимитами — отдельный класс, не `@Nested`). -- Регрессивные пары (фикс = нормализатор/pre-renderer + юнит + конвертер-тест с фикстурой): `StrictOoxmlNormalizerTest`↔`strictOoxml_convertsNotRejected` (+`pageCount_strictBreaksCountedLightweight` — lightweight против strict), `DocxOnOffNormalizerTest`↔`ruPlain_regularRunsUseRegularFont`, `SymbolFontNormalizerTest`↔`symbolFonts_bulletsAreNotHash`, `FieldNormalizerTest`↔`pageNumbers_recomputedNotCached`, `GlyphCoverageNormalizerTest`↔`exoticGlyphs_drawnNotHash`, `OleObjectNormalizerTest`↔`oleObjects_removedAndConverted`/`drawingErrors_errorFlagRejectsOle` (+app `errorFlagOle_rejected`/`oleObjects_removedByDefault`), `WordPdfValidatorTest`↔`staleCachePageCountRejectedBeforeRender` (+`checkPageCount_limitBoundary` 99/100/101, `pageCount_breaksInsideTablesAreCounted`, `pageCount_continuousSectionsNotCountedLightweight`, `validate_notAZip`↔`inputNotAZip_rejectedBeforeRender`, `validate_plainZipRejected`/`validate_xlsxRenamedRejected`/`validate_zipBombRejected`/`validate_tooManyEntriesRejected`↔`plainZipNotDocx_rejected`/`inputNotDocx_rejectedBeforeRender` — контейнер и zip-бомба), `BundledFontsTest`↔`ruPlain_emDashEmbeddedNotHelvetica`, `ChartSpecTest`↔автозаголовки, chart-пейнтеры↔`chartsSmartArt_drawingsBecomeImages` (+`drawingErrors_*`↔app `errorFlagCharts_rejected`/`errorFlagSmartArt_rejected`); `noLoggingWarningInPdf` — регрессия `slf4j-simple`, `pdfTitle_comesFromParameter` — регрессия PDF-title (юнит-партнёра нет). App-регрессии: `requestLimitParams_areIgnored`, `nonPositiveLimits_failStartup`, `unknownPath_notFound`, `concurrentRequests_bothSucceed` (гонка реестра `PhysicalFonts`), `corruptNotAZip_rejected`, `plainZipNotDocx_rejected` (голый zip без манифеста → 400), `junkInsideValidZip_conversionError` (500 на валидном .docx-контейнере с мусором), `nonDocxFilename_rejected`, `oversizedOverCoreLimit_rejected`, `drawingsAlwaysRendered`, `cyrillicAndPathInFilename_sanitizedResponseName` (RFC 5987 + path-traversal), `docsOpenWithoutKey`/`forwardedPrefix_healthStaysOpen`/`forwardedPrefix_docsOpenWithoutKey` (открытая документация + матч фильтра без forwarded-contextPath). +- Регрессивные пары (фикс = нормализатор/pre-renderer + юнит + конвертер-тест с фикстурой): `StrictOoxmlNormalizerTest`↔`strictOoxml_convertsNotRejected` (+`pageCount_strictBreaksCountedLightweight` — lightweight против strict), `DocxOnOffNormalizerTest`↔`ruPlain_regularRunsUseRegularFont`, `SymbolFontNormalizerTest`↔`symbolFonts_bulletsAreNotHash`, `FieldNormalizerTest`↔`pageNumbers_recomputedNotCached`, `GlyphCoverageNormalizerTest`↔`exoticGlyphs_drawnNotHash`, `OleObjectNormalizerTest`↔`oleObjects_removedAndConverted`/`drawingErrors_errorFlagRejectsOle` (+app `errorFlagOle_rejected`/`oleObjects_removedByDefault`), `WordPdfValidatorTest`↔`staleCachePageCountRejectedBeforeRender` (+`checkPageCount_limitBoundary` 99/100/101, `pageCount_breaksInsideTablesAreCounted`, `pageCount_continuousSectionsNotCountedLightweight`, `validate_notAZip`↔`inputNotAZip_rejectedBeforeRender`, `validate_plainZipRejected`/`validate_xlsxRenamedRejected`/`validate_zipBombRejected`/`validate_tooManyEntriesRejected`↔`plainZipNotDocx_rejected`/`inputNotDocx_rejectedBeforeRender` — контейнер и zip-бомба), `BundledFontsTest`↔`ruPlain_emDashEmbeddedNotHelvetica`, `ChartSpecTest`↔автозаголовки, `PresetGeometryTest`↔`chartsSmartArt_drawingsBecomeImages` (`tableMatchesEcmaXml` — синхрон таблицы пресетов с ECMA XML; кольцевые стрелки — семантика `?:` и знаки дуг Arc2D), chart-пейнтеры↔`chartsSmartArt_drawingsBecomeImages` (+`drawingErrors_*`↔app `errorFlagCharts_rejected`/`errorFlagSmartArt_rejected`); `noLoggingWarningInPdf` — регрессия `slf4j-simple`, `pdfTitle_comesFromParameter` — регрессия PDF-title (юнит-партнёра нет). App-регрессии: `requestLimitParams_areIgnored`, `nonPositiveLimits_failStartup`, `unknownPath_notFound`, `concurrentRequests_bothSucceed` (гонка реестра `PhysicalFonts`), `corruptNotAZip_rejected`, `plainZipNotDocx_rejected` (голый zip без манифеста → 400), `junkInsideValidZip_conversionError` (500 на валидном .docx-контейнере с мусором), `nonDocxFilename_rejected`, `oversizedOverCoreLimit_rejected`, `drawingsAlwaysRendered`, `cyrillicAndPathInFilename_sanitizedResponseName` (RFC 5987 + path-traversal), `docsOpenWithoutKey`/`forwardedPrefix_healthStaysOpen`/`forwardedPrefix_docsOpenWithoutKey` (открытая документация + матч фильтра без forwarded-contextPath). - UI-тестов нет; гейт SPA — `npm run build` (tsc -b) + `npm run lint` (oxlint, `.oxlintrc.json`: rules-of-hooks error, only-export-components warn). Прод-автотесты (pytest 9 + requests, 21 проверка, env-конфиг, `mise exec -- python -m pytest -q .` из `prod-autotests/`) гоняются CI после deploy против живого прода; `WORDPDF_API_KEY` пуст → честный SKIP `@needs_key`-проверок. diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/PresetGeometry.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/PresetGeometry.java new file mode 100644 index 0000000..5e65138 --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/PresetGeometry.java @@ -0,0 +1,1280 @@ +package ru.pjandro.wordpdf.internal.chart; + +import org.docx4j.dml.CTGeomGuide; +import org.docx4j.dml.CTGeomGuideList; +import org.docx4j.dml.CTPresetGeometry2D; + +import java.awt.geom.AffineTransform; +import java.awt.geom.Area; +import java.awt.geom.Arc2D; +import java.awt.geom.Path2D; +import java.awt.geom.Rectangle2D; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Пресет-геометрия DrawingML ({@code a:prstGeom}) по ECMA-376 Part 1: + * avLst/gdLst/pathLst пресетов скопированы дословно из блоков + * {@code presetShapeDefinitions.xml} (приложение к стандарту; байтовая + * копия — в репо LibreOffice core, oox/source/drawingml/). Формулы + * гайдов — префиксные строки {@code ST_GeomGuideFormula} (оператор, + * затем арность аргументов), путь собирается из команд + * moveTo/lnTo/arcTo/close со ссылками на вычисленные гайды. + * + * Поддержаны пресеты, которые встречаются в SmartArt-кэшах: rect, + * roundRect, ellipse, gear6, gear9, circularArrow, leftCircularArrow. + * Неизвестный пресет -> прямоугольник ячейки: для подписанной схемы + * это заметнее, чем пустое место. + * + * Регрессии — PresetGeometryTest. + */ +final class PresetGeometry { + + /** Полный угол, единицы 1/60000 градуса. */ + private static final double FULL_ANGLE = 21_600_000.0; + /** Делитель перевода 1/60000 градуса в радианы. */ + private static final double DEG_UNITS = 60_000.0; + + private PresetGeometry() { + } + + /** Один пресет: пары имя/формула avLst и gdLst + команды пути. */ + record Preset(String[] avLst, String[] gdLst, String[] pathLst) { + } + + private static final Map PRESETS = presets(); + + /** Таблица для синхронизационного теста с XML стандарта. */ + static Preset preset(String prst) { + return PRESETS.get(prst); + } + + private static Map presets() { + Map m = new HashMap<>(); + // Блок : avLst/gdLst в ECMA пустые, путь — контур ячейки. + m.put("rect", new Preset( + new String[0], + new String[0], + new String[] { + "moveTo l t", + "lnTo r t", + "lnTo r b", + "lnTo l b", + "close", + })); + // Блок дословно. + m.put("roundRect", new Preset( + new String[] { + "adj val 16667", + }, + new String[] { + "a pin 0 adj 50000", + "x1 */ ss a 100000", + "x2 +- r 0 x1", + "y2 +- b 0 x1", + "il */ x1 29289 100000", + "ir +- r 0 il", + "ib +- b 0 il", + }, + new String[] { + "moveTo l x1", + "arcTo x1 x1 cd2 cd4", + "lnTo x2 t", + "arcTo x1 x1 3cd4 cd4", + "lnTo r y2", + "arcTo x1 x1 0 cd4", + "lnTo x1 b", + "arcTo x1 x1 cd4 cd4", + "close", + })); + // Блок дословно. + m.put("ellipse", new Preset( + new String[0], + new String[] { + "idx cos wd2 2700000", + "idy sin hd2 2700000", + "il +- hc 0 idx", + "ir +- hc idx 0", + "it +- vc 0 idy", + "ib +- vc idy 0", + }, + new String[] { + "moveTo l vc", + "arcTo wd2 hd2 cd2 cd4", + "arcTo wd2 hd2 3cd4 cd4", + "arcTo wd2 hd2 0 cd4", + "arcTo wd2 hd2 cd4 cd4", + "close", + })); + // Блок дословно. + m.put("gear6", new Preset( + new String[] { + "adj1 val 15000", + "adj2 val 3526", + }, + new String[] { + "a1 pin 0 adj1 20000", + "a2 pin 0 adj2 5358", + "th */ ss a1 100000", + "lFD */ ss a2 100000", + "th2 */ th 1 2", + "l2 */ lFD 1 2", + "l3 +- th2 l2 0", + "rh +- hd2 0 th", + "rw +- wd2 0 th", + "dr +- rw 0 rh", + "maxr ?: dr rh rw", + "ha at2 maxr l3", + "aA1 +- 19800000 0 ha", + "aD1 +- 19800000 ha 0", + "ta11 cos rw aA1", + "ta12 sin rh aA1", + "bA1 at2 ta11 ta12", + "cta1 cos rh bA1", + "sta1 sin rw bA1", + "ma1 mod cta1 sta1 0", + "na1 */ rw rh ma1", + "dxa1 cos na1 bA1", + "dya1 sin na1 bA1", + "xA1 +- hc dxa1 0", + "yA1 +- vc dya1 0", + "td11 cos rw aD1", + "td12 sin rh aD1", + "bD1 at2 td11 td12", + "ctd1 cos rh bD1", + "std1 sin rw bD1", + "md1 mod ctd1 std1 0", + "nd1 */ rw rh md1", + "dxd1 cos nd1 bD1", + "dyd1 sin nd1 bD1", + "xD1 +- hc dxd1 0", + "yD1 +- vc dyd1 0", + "xAD1 +- xA1 0 xD1", + "yAD1 +- yA1 0 yD1", + "lAD1 mod xAD1 yAD1 0", + "a1 at2 yAD1 xAD1", + "dxF1 sin lFD a1", + "dyF1 cos lFD a1", + "xF1 +- xD1 dxF1 0", + "yF1 +- yD1 dyF1 0", + "xE1 +- xA1 0 dxF1", + "yE1 +- yA1 0 dyF1", + "yC1t sin th a1", + "xC1t cos th a1", + "yC1 +- yF1 yC1t 0", + "xC1 +- xF1 0 xC1t", + "yB1 +- yE1 yC1t 0", + "xB1 +- xE1 0 xC1t", + "aD6 +- 3cd4 ha 0", + "td61 cos rw aD6", + "td62 sin rh aD6", + "bD6 at2 td61 td62", + "ctd6 cos rh bD6", + "std6 sin rw bD6", + "md6 mod ctd6 std6 0", + "nd6 */ rw rh md6", + "dxd6 cos nd6 bD6", + "dyd6 sin nd6 bD6", + "xD6 +- hc dxd6 0", + "yD6 +- vc dyd6 0", + "xA6 +- hc 0 dxd6", + "xF6 +- xD6 0 lFD", + "xE6 +- xA6 lFD 0", + "yC6 +- yD6 0 th", + "swAng1 +- bA1 0 bD6", + "aA2 +- 1800000 0 ha", + "aD2 +- 1800000 ha 0", + "ta21 cos rw aA2", + "ta22 sin rh aA2", + "bA2 at2 ta21 ta22", + "yA2 +- h 0 yD1", + "td21 cos rw aD2", + "td22 sin rh aD2", + "bD2 at2 td21 td22", + "yD2 +- h 0 yA1", + "yC2 +- h 0 yB1", + "yB2 +- h 0 yC1", + "xB2 val xC1", + "swAng2 +- bA2 0 bD1", + "aD3 +- cd4 ha 0", + "td31 cos rw aD3", + "td32 sin rh aD3", + "bD3 at2 td31 td32", + "yD3 +- h 0 yD6", + "yB3 +- h 0 yC6", + "aD4 +- 9000000 ha 0", + "td41 cos rw aD4", + "td42 sin rh aD4", + "bD4 at2 td41 td42", + "xD4 +- w 0 xD1", + "xC4 +- w 0 xC1", + "xB4 +- w 0 xB1", + "aD5 +- 12600000 ha 0", + "td51 cos rw aD5", + "td52 sin rh aD5", + "bD5 at2 td51 td52", + "xD5 +- w 0 xA1", + "xC5 +- w 0 xB1", + "xB5 +- w 0 xC1", + "xCxn1 +/ xB1 xC1 2", + "yCxn1 +/ yB1 yC1 2", + "yCxn2 +- b 0 yCxn1", + "xCxn4 +/ r 0 xCxn1", + }, + new String[] { + "moveTo xA1 yA1", + "lnTo xB1 yB1", + "lnTo xC1 yC1", + "lnTo xD1 yD1", + "arcTo rw rh bD1 swAng2", + "lnTo xC1 yB2", + "lnTo xB1 yC2", + "lnTo xA1 yD2", + "arcTo rw rh bD2 swAng1", + "lnTo xF6 yB3", + "lnTo xE6 yB3", + "lnTo xA6 yD3", + "arcTo rw rh bD3 swAng1", + "lnTo xB4 yC2", + "lnTo xC4 yB2", + "lnTo xD4 yA2", + "arcTo rw rh bD4 swAng2", + "lnTo xB5 yC1", + "lnTo xC5 yB1", + "lnTo xD5 yA1", + "arcTo rw rh bD5 swAng1", + "lnTo xE6 yC6", + "lnTo xF6 yC6", + "lnTo xD6 yD6", + "arcTo rw rh bD6 swAng1", + "close", + })); + // Блок дословно. + m.put("gear9", new Preset( + new String[] { + "adj1 val 10000", + "adj2 val 1763", + }, + new String[] { + "a1 pin 0 adj1 20000", + "a2 pin 0 adj2 2679", + "th */ ss a1 100000", + "lFD */ ss a2 100000", + "th2 */ th 1 2", + "l2 */ lFD 1 2", + "l3 +- th2 l2 0", + "rh +- hd2 0 th", + "rw +- wd2 0 th", + "dr +- rw 0 rh", + "maxr ?: dr rh rw", + "ha at2 maxr l3", + "aA1 +- 18600000 0 ha", + "aD1 +- 18600000 ha 0", + "ta11 cos rw aA1", + "ta12 sin rh aA1", + "bA1 at2 ta11 ta12", + "cta1 cos rh bA1", + "sta1 sin rw bA1", + "ma1 mod cta1 sta1 0", + "na1 */ rw rh ma1", + "dxa1 cos na1 bA1", + "dya1 sin na1 bA1", + "xA1 +- hc dxa1 0", + "yA1 +- vc dya1 0", + "td11 cos rw aD1", + "td12 sin rh aD1", + "bD1 at2 td11 td12", + "ctd1 cos rh bD1", + "std1 sin rw bD1", + "md1 mod ctd1 std1 0", + "nd1 */ rw rh md1", + "dxd1 cos nd1 bD1", + "dyd1 sin nd1 bD1", + "xD1 +- hc dxd1 0", + "yD1 +- vc dyd1 0", + "xAD1 +- xA1 0 xD1", + "yAD1 +- yA1 0 yD1", + "lAD1 mod xAD1 yAD1 0", + "a1 at2 yAD1 xAD1", + "dxF1 sin lFD a1", + "dyF1 cos lFD a1", + "xF1 +- xD1 dxF1 0", + "yF1 +- yD1 dyF1 0", + "xE1 +- xA1 0 dxF1", + "yE1 +- yA1 0 dyF1", + "yC1t sin th a1", + "xC1t cos th a1", + "yC1 +- yF1 yC1t 0", + "xC1 +- xF1 0 xC1t", + "yB1 +- yE1 yC1t 0", + "xB1 +- xE1 0 xC1t", + "aA2 +- 21000000 0 ha", + "aD2 +- 21000000 ha 0", + "ta21 cos rw aA2", + "ta22 sin rh aA2", + "bA2 at2 ta21 ta22", + "cta2 cos rh bA2", + "sta2 sin rw bA2", + "ma2 mod cta2 sta2 0", + "na2 */ rw rh ma2", + "dxa2 cos na2 bA2", + "dya2 sin na2 bA2", + "xA2 +- hc dxa2 0", + "yA2 +- vc dya2 0", + "td21 cos rw aD2", + "td22 sin rh aD2", + "bD2 at2 td21 td22", + "ctd2 cos rh bD2", + "std2 sin rw bD2", + "md2 mod ctd2 std2 0", + "nd2 */ rw rh md2", + "dxd2 cos nd2 bD2", + "dyd2 sin nd2 bD2", + "xD2 +- hc dxd2 0", + "yD2 +- vc dyd2 0", + "xAD2 +- xA2 0 xD2", + "yAD2 +- yA2 0 yD2", + "lAD2 mod xAD2 yAD2 0", + "a2 at2 yAD2 xAD2", + "dxF2 sin lFD a2", + "dyF2 cos lFD a2", + "xF2 +- xD2 dxF2 0", + "yF2 +- yD2 dyF2 0", + "xE2 +- xA2 0 dxF2", + "yE2 +- yA2 0 dyF2", + "yC2t sin th a2", + "xC2t cos th a2", + "yC2 +- yF2 yC2t 0", + "xC2 +- xF2 0 xC2t", + "yB2 +- yE2 yC2t 0", + "xB2 +- xE2 0 xC2t", + "swAng1 +- bA2 0 bD1", + "aA3 +- 1800000 0 ha", + "aD3 +- 1800000 ha 0", + "ta31 cos rw aA3", + "ta32 sin rh aA3", + "bA3 at2 ta31 ta32", + "cta3 cos rh bA3", + "sta3 sin rw bA3", + "ma3 mod cta3 sta3 0", + "na3 */ rw rh ma3", + "dxa3 cos na3 bA3", + "dya3 sin na3 bA3", + "xA3 +- hc dxa3 0", + "yA3 +- vc dya3 0", + "td31 cos rw aD3", + "td32 sin rh aD3", + "bD3 at2 td31 td32", + "ctd3 cos rh bD3", + "std3 sin rw bD3", + "md3 mod ctd3 std3 0", + "nd3 */ rw rh md3", + "dxd3 cos nd3 bD3", + "dyd3 sin nd3 bD3", + "xD3 +- hc dxd3 0", + "yD3 +- vc dyd3 0", + "xAD3 +- xA3 0 xD3", + "yAD3 +- yA3 0 yD3", + "lAD3 mod xAD3 yAD3 0", + "a3 at2 yAD3 xAD3", + "dxF3 sin lFD a3", + "dyF3 cos lFD a3", + "xF3 +- xD3 dxF3 0", + "yF3 +- yD3 dyF3 0", + "xE3 +- xA3 0 dxF3", + "yE3 +- yA3 0 dyF3", + "yC3t sin th a3", + "xC3t cos th a3", + "yC3 +- yF3 yC3t 0", + "xC3 +- xF3 0 xC3t", + "yB3 +- yE3 yC3t 0", + "xB3 +- xE3 0 xC3t", + "swAng2 +- bA3 0 bD2", + "aA4 +- 4200000 0 ha", + "aD4 +- 4200000 ha 0", + "ta41 cos rw aA4", + "ta42 sin rh aA4", + "bA4 at2 ta41 ta42", + "cta4 cos rh bA4", + "sta4 sin rw bA4", + "ma4 mod cta4 sta4 0", + "na4 */ rw rh ma4", + "dxa4 cos na4 bA4", + "dya4 sin na4 bA4", + "xA4 +- hc dxa4 0", + "yA4 +- vc dya4 0", + "td41 cos rw aD4", + "td42 sin rh aD4", + "bD4 at2 td41 td42", + "ctd4 cos rh bD4", + "std4 sin rw bD4", + "md4 mod ctd4 std4 0", + "nd4 */ rw rh md4", + "dxd4 cos nd4 bD4", + "dyd4 sin nd4 bD4", + "xD4 +- hc dxd4 0", + "yD4 +- vc dyd4 0", + "xAD4 +- xA4 0 xD4", + "yAD4 +- yA4 0 yD4", + "lAD4 mod xAD4 yAD4 0", + "a4 at2 yAD4 xAD4", + "dxF4 sin lFD a4", + "dyF4 cos lFD a4", + "xF4 +- xD4 dxF4 0", + "yF4 +- yD4 dyF4 0", + "xE4 +- xA4 0 dxF4", + "yE4 +- yA4 0 dyF4", + "yC4t sin th a4", + "xC4t cos th a4", + "yC4 +- yF4 yC4t 0", + "xC4 +- xF4 0 xC4t", + "yB4 +- yE4 yC4t 0", + "xB4 +- xE4 0 xC4t", + "swAng3 +- bA4 0 bD3", + "aA5 +- 6600000 0 ha", + "aD5 +- 6600000 ha 0", + "ta51 cos rw aA5", + "ta52 sin rh aA5", + "bA5 at2 ta51 ta52", + "td51 cos rw aD5", + "td52 sin rh aD5", + "bD5 at2 td51 td52", + "xD5 +- w 0 xA4", + "xC5 +- w 0 xB4", + "xB5 +- w 0 xC4", + "swAng4 +- bA5 0 bD4", + "aD6 +- 9000000 ha 0", + "td61 cos rw aD6", + "td62 sin rh aD6", + "bD6 at2 td61 td62", + "xD6 +- w 0 xA3", + "xC6 +- w 0 xB3", + "xB6 +- w 0 xC3", + "aD7 +- 11400000 ha 0", + "td71 cos rw aD7", + "td72 sin rh aD7", + "bD7 at2 td71 td72", + "xD7 +- w 0 xA2", + "xC7 +- w 0 xB2", + "xB7 +- w 0 xC2", + "aD8 +- 13800000 ha 0", + "td81 cos rw aD8", + "td82 sin rh aD8", + "bD8 at2 td81 td82", + "xA8 +- w 0 xD1", + "xD8 +- w 0 xA1", + "xC8 +- w 0 xB1", + "xB8 +- w 0 xC1", + "aA9 +- 3cd4 0 ha", + "aD9 +- 3cd4 ha 0", + "td91 cos rw aD9", + "td92 sin rh aD9", + "bD9 at2 td91 td92", + "ctd9 cos rh bD9", + "std9 sin rw bD9", + "md9 mod ctd9 std9 0", + "nd9 */ rw rh md9", + "dxd9 cos nd9 bD9", + "dyd9 sin nd9 bD9", + "xD9 +- hc dxd9 0", + "yD9 +- vc dyd9 0", + "ta91 cos rw aA9", + "ta92 sin rh aA9", + "bA9 at2 ta91 ta92", + "xA9 +- hc 0 dxd9", + "xF9 +- xD9 0 lFD", + "xE9 +- xA9 lFD 0", + "yC9 +- yD9 0 th", + "swAng5 +- bA9 0 bD8", + "xCxn1 +/ xB1 xC1 2", + "yCxn1 +/ yB1 yC1 2", + "xCxn2 +/ xB2 xC2 2", + "yCxn2 +/ yB2 yC2 2", + "xCxn3 +/ xB3 xC3 2", + "yCxn3 +/ yB3 yC3 2", + "xCxn4 +/ xB4 xC4 2", + "yCxn4 +/ yB4 yC4 2", + "xCxn5 +/ r 0 xCxn4", + "xCxn6 +/ r 0 xCxn3", + "xCxn7 +/ r 0 xCxn2", + "xCxn8 +/ r 0 xCxn1", + }, + new String[] { + "moveTo xA1 yA1", + "lnTo xB1 yB1", + "lnTo xC1 yC1", + "lnTo xD1 yD1", + "arcTo rw rh bD1 swAng1", + "lnTo xB2 yB2", + "lnTo xC2 yC2", + "lnTo xD2 yD2", + "arcTo rw rh bD2 swAng2", + "lnTo xB3 yB3", + "lnTo xC3 yC3", + "lnTo xD3 yD3", + "arcTo rw rh bD3 swAng3", + "lnTo xB4 yB4", + "lnTo xC4 yC4", + "lnTo xD4 yD4", + "arcTo rw rh bD4 swAng4", + "lnTo xB5 yC4", + "lnTo xC5 yB4", + "lnTo xD5 yA4", + "arcTo rw rh bD5 swAng3", + "lnTo xB6 yC3", + "lnTo xC6 yB3", + "lnTo xD6 yA3", + "arcTo rw rh bD6 swAng2", + "lnTo xB7 yC2", + "lnTo xC7 yB2", + "lnTo xD7 yA2", + "arcTo rw rh bD7 swAng1", + "lnTo xB8 yC1", + "lnTo xC8 yB1", + "lnTo xD8 yA1", + "arcTo rw rh bD8 swAng5", + "lnTo xE9 yC9", + "lnTo xF9 yC9", + "lnTo xD9 yD9", + "arcTo rw rh bD9 swAng5", + "close", + })); + // Блок дословно. + m.put("circularArrow", new Preset( + new String[] { + "adj1 val 12500", + "adj2 val 1142319", + "adj3 val 20457681", + "adj4 val 10800000", + "adj5 val 12500", + }, + new String[] { + "a5 pin 0 adj5 25000", + "maxAdj1 */ a5 2 1", + "a1 pin 0 adj1 maxAdj1", + "enAng pin 1 adj3 21599999", + "stAng pin 0 adj4 21599999", + "th */ ss a1 100000", + "thh */ ss a5 100000", + "th2 */ th 1 2", + "rw1 +- wd2 th2 thh", + "rh1 +- hd2 th2 thh", + "rw2 +- rw1 0 th", + "rh2 +- rh1 0 th", + "rw3 +- rw2 th2 0", + "rh3 +- rh2 th2 0", + "wtH sin rw3 enAng", + "htH cos rh3 enAng", + "dxH cat2 rw3 htH wtH", + "dyH sat2 rh3 htH wtH", + "xH +- hc dxH 0", + "yH +- vc dyH 0", + "rI min rw2 rh2", + "u1 */ dxH dxH 1", + "u2 */ dyH dyH 1", + "u3 */ rI rI 1", + "u4 +- u1 0 u3", + "u5 +- u2 0 u3", + "u6 */ u4 u5 u1", + "u7 */ u6 1 u2", + "u8 +- 1 0 u7", + "u9 sqrt u8", + "u10 */ u4 1 dxH", + "u11 */ u10 1 dyH", + "u12 +/ 1 u9 u11", + "u13 at2 1 u12", + "u14 +- u13 21600000 0", + "u15 ?: u13 u13 u14", + "u16 +- u15 0 enAng", + "u17 +- u16 21600000 0", + "u18 ?: u16 u16 u17", + "u19 +- u18 0 cd2", + "u20 +- u18 0 21600000", + "u21 ?: u19 u20 u18", + "maxAng abs u21", + "aAng pin 0 adj2 maxAng", + "ptAng +- enAng aAng 0", + "wtA sin rw3 ptAng", + "htA cos rh3 ptAng", + "dxA cat2 rw3 htA wtA", + "dyA sat2 rh3 htA wtA", + "xA +- hc dxA 0", + "yA +- vc dyA 0", + "wtE sin rw1 stAng", + "htE cos rh1 stAng", + "dxE cat2 rw1 htE wtE", + "dyE sat2 rh1 htE wtE", + "xE +- hc dxE 0", + "yE +- vc dyE 0", + "dxG cos thh ptAng", + "dyG sin thh ptAng", + "xG +- xH dxG 0", + "yG +- yH dyG 0", + "dxB cos thh ptAng", + "dyB sin thh ptAng", + "xB +- xH 0 dxB 0", + "yB +- yH 0 dyB 0", + "sx1 +- xB 0 hc", + "sy1 +- yB 0 vc", + "sx2 +- xG 0 hc", + "sy2 +- yG 0 vc", + "rO min rw1 rh1", + "x1O */ sx1 rO rw1", + "y1O */ sy1 rO rh1", + "x2O */ sx2 rO rw1", + "y2O */ sy2 rO rh1", + "dxO +- x2O 0 x1O", + "dyO +- y2O 0 y1O", + "dO mod dxO dyO 0", + "q1 */ x1O y2O 1", + "q2 */ x2O y1O 1", + "DO +- q1 0 q2", + "q3 */ rO rO 1", + "q4 */ dO dO 1", + "q5 */ q3 q4 1", + "q6 */ DO DO 1", + "q7 +- q5 0 q6", + "q8 max q7 0", + "sdelO sqrt q8", + "ndyO */ dyO -1 1", + "sdyO ?: ndyO -1 1", + "q9 */ sdyO dxO 1", + "q10 */ q9 sdelO 1", + "q11 */ DO dyO 1", + "dxF1 +/ q11 q10 q4", + "q12 +- q11 0 q10", + "dxF2 */ q12 1 q4", + "adyO abs dyO", + "q13 */ adyO sdelO 1", + "q14 */ DO dxO -1", + "dyF1 +/ q14 q13 q4", + "q15 +- q14 0 q13", + "dyF2 */ q15 1 q4", + "q16 +- x2O 0 dxF1", + "q17 +- x2O 0 dxF2", + "q18 +- y2O 0 dyF1", + "q19 +- y2O 0 dyF2", + "q20 mod q16 q18 0", + "q21 mod q17 q19 0", + "q22 +- q21 0 q20", + "dxF ?: q22 dxF1 dxF2", + "dyF ?: q22 dyF1 dyF2", + "sdxF */ dxF rw1 rO", + "sdyF */ dyF rh1 rO", + "xF +- hc sdxF 0", + "yF +- vc sdyF 0", + "x1I */ sx1 rI rw2", + "y1I */ sy1 rI rh2", + "x2I */ sx2 rI rw2", + "y2I */ sy2 rI rh2", + "dxI +- x2I 0 x1I", + "dyI +- y2I 0 y1I", + "dI mod dxI dyI 0", + "v1 */ x1I y2I 1", + "v2 */ x2I y1I 1", + "DI +- v1 0 v2", + "v3 */ rI rI 1", + "v4 */ dI dI 1", + "v5 */ v3 v4 1", + "v6 */ DI DI 1", + "v7 +- v5 0 v6", + "v8 max v7 0", + "sdelI sqrt v8", + "v9 */ sdyO dxI 1", + "v10 */ v9 sdelI 1", + "v11 */ DI dyI 1", + "dxC1 +/ v11 v10 v4", + "v12 +- v11 0 v10", + "dxC2 */ v12 1 v4", + "adyI abs dyI", + "v13 */ adyI sdelI 1", + "v14 */ DI dxI -1", + "dyC1 +/ v14 v13 v4", + "v15 +- v14 0 v13", + "dyC2 */ v15 1 v4", + "v16 +- x1I 0 dxC1", + "v17 +- x1I 0 dxC2", + "v18 +- y1I 0 dyC1", + "v19 +- y1I 0 dyC2", + "v20 mod v16 v18 0", + "v21 mod v17 v19 0", + "v22 +- v21 0 v20", + "dxC ?: v22 dxC1 dxC2", + "dyC ?: v22 dyC1 dyC2", + "sdxC */ dxC rw2 rI", + "sdyC */ dyC rh2 rI", + "xC +- hc sdxC 0", + "yC +- vc sdyC 0", + "ist0 at2 sdxC sdyC", + "ist1 +- ist0 21600000 0", + "istAng ?: ist0 ist0 ist1", + "isw1 +- stAng 0 istAng", + "isw2 +- isw1 0 21600000", + "iswAng ?: isw1 isw2 isw1", + "p1 +- xF 0 xC", + "p2 +- yF 0 yC", + "p3 mod p1 p2 0", + "p4 */ p3 1 2", + "p5 +- p4 0 thh", + "xGp ?: p5 xF xG", + "yGp ?: p5 yF yG", + "xBp ?: p5 xC xB", + "yBp ?: p5 yC yB", + "en0 at2 sdxF sdyF", + "en1 +- en0 21600000 0", + "en2 ?: en0 en0 en1", + "sw0 +- en2 0 stAng", + "sw1 +- sw0 21600000 0", + "swAng ?: sw0 sw0 sw1", + "wtI sin rw3 stAng", + "htI cos rh3 stAng", + "dxI cat2 rw3 htI wtI", + "dyI sat2 rh3 htI wtI", + "xI +- hc dxI 0", + "yI +- vc dyI 0", + "aI +- stAng 0 cd4", + "aA +- ptAng cd4 0", + "aB +- ptAng cd2 0", + "idx cos rw1 2700000", + "idy sin rh1 2700000", + "il +- hc 0 idx", + "ir +- hc idx 0", + "it +- vc 0 idy", + "ib +- vc idy 0", + }, + new String[] { + "moveTo xE yE", + "arcTo rw1 rh1 stAng swAng", + "lnTo xGp yGp", + "lnTo xA yA", + "lnTo xBp yBp", + "lnTo xC yC", + "arcTo rw2 rh2 istAng iswAng", + "close", + })); + // Блок дословно. + m.put("leftCircularArrow", new Preset( + new String[] { + "adj1 val 12500", + "adj2 val -1142319", + "adj3 val 1142319", + "adj4 val 10800000", + "adj5 val 12500", + }, + new String[] { + "a5 pin 0 adj5 25000", + "maxAdj1 */ a5 2 1", + "a1 pin 0 adj1 maxAdj1", + "enAng pin 1 adj3 21599999", + "stAng pin 0 adj4 21599999", + "th */ ss a1 100000", + "thh */ ss a5 100000", + "th2 */ th 1 2", + "rw1 +- wd2 th2 thh", + "rh1 +- hd2 th2 thh", + "rw2 +- rw1 0 th", + "rh2 +- rh1 0 th", + "rw3 +- rw2 th2 0", + "rh3 +- rh2 th2 0", + "wtH sin rw3 enAng", + "htH cos rh3 enAng", + "dxH cat2 rw3 htH wtH", + "dyH sat2 rh3 htH wtH", + "xH +- hc dxH 0", + "yH +- vc dyH 0", + "rI min rw2 rh2", + "u1 */ dxH dxH 1", + "u2 */ dyH dyH 1", + "u3 */ rI rI 1", + "u4 +- u1 0 u3", + "u5 +- u2 0 u3", + "u6 */ u4 u5 u1", + "u7 */ u6 1 u2", + "u8 +- 1 0 u7", + "u9 sqrt u8", + "u10 */ u4 1 dxH", + "u11 */ u10 1 dyH", + "u12 +/ 1 u9 u11", + "u13 at2 1 u12", + "u14 +- u13 21600000 0", + "u15 ?: u13 u13 u14", + "u16 +- u15 0 enAng", + "u17 +- u16 21600000 0", + "u18 ?: u16 u16 u17", + "u19 +- u18 0 cd2", + "u20 +- u18 0 21600000", + "u21 ?: u19 u20 u18", + "u22 abs u21", + "minAng */ u22 -1 1", + "u23 abs adj2", + "a2 */ u23 -1 1", + "aAng pin minAng a2 0", + "ptAng +- enAng aAng 0", + "wtA sin rw3 ptAng", + "htA cos rh3 ptAng", + "dxA cat2 rw3 htA wtA", + "dyA sat2 rh3 htA wtA", + "xA +- hc dxA 0", + "yA +- vc dyA 0", + "wtE sin rw1 stAng", + "htE cos rh1 stAng", + "dxE cat2 rw1 htE wtE", + "dyE sat2 rh1 htE wtE", + "xE +- hc dxE 0", + "yE +- vc dyE 0", + "wtD sin rw2 stAng", + "htD cos rh2 stAng", + "dxD cat2 rw2 htD wtD", + "dyD sat2 rh2 htD wtD", + "xD +- hc dxD 0", + "yD +- vc dyD 0", + "dxG cos thh ptAng", + "dyG sin thh ptAng", + "xG +- xH dxG 0", + "yG +- yH dyG 0", + "dxB cos thh ptAng", + "dyB sin thh ptAng", + "xB +- xH 0 dxB 0", + "yB +- yH 0 dyB 0", + "sx1 +- xB 0 hc", + "sy1 +- yB 0 vc", + "sx2 +- xG 0 hc", + "sy2 +- yG 0 vc", + "rO min rw1 rh1", + "x1O */ sx1 rO rw1", + "y1O */ sy1 rO rh1", + "x2O */ sx2 rO rw1", + "y2O */ sy2 rO rh1", + "dxO +- x2O 0 x1O", + "dyO +- y2O 0 y1O", + "dO mod dxO dyO 0", + "q1 */ x1O y2O 1", + "q2 */ x2O y1O 1", + "DO +- q1 0 q2", + "q3 */ rO rO 1", + "q4 */ dO dO 1", + "q5 */ q3 q4 1", + "q6 */ DO DO 1", + "q7 +- q5 0 q6", + "q8 max q7 0", + "sdelO sqrt q8", + "ndyO */ dyO -1 1", + "sdyO ?: ndyO -1 1", + "q9 */ sdyO dxO 1", + "q10 */ q9 sdelO 1", + "q11 */ DO dyO 1", + "dxF1 +/ q11 q10 q4", + "q12 +- q11 0 q10", + "dxF2 */ q12 1 q4", + "adyO abs dyO", + "q13 */ adyO sdelO 1", + "q14 */ DO dxO -1", + "dyF1 +/ q14 q13 q4", + "q15 +- q14 0 q13", + "dyF2 */ q15 1 q4", + "q16 +- x2O 0 dxF1", + "q17 +- x2O 0 dxF2", + "q18 +- y2O 0 dyF1", + "q19 +- y2O 0 dyF2", + "q20 mod q16 q18 0", + "q21 mod q17 q19 0", + "q22 +- q21 0 q20", + "dxF ?: q22 dxF1 dxF2", + "dyF ?: q22 dyF1 dyF2", + "sdxF */ dxF rw1 rO", + "sdyF */ dyF rh1 rO", + "xF +- hc sdxF 0", + "yF +- vc sdyF 0", + "x1I */ sx1 rI rw2", + "y1I */ sy1 rI rh2", + "x2I */ sx2 rI rw2", + "y2I */ sy2 rI rh2", + "dxI +- x2I 0 x1I", + "dyI +- y2I 0 y1I", + "dI mod dxI dyI 0", + "v1 */ x1I y2I 1", + "v2 */ x2I y1I 1", + "DI +- v1 0 v2", + "v3 */ rI rI 1", + "v4 */ dI dI 1", + "v5 */ v3 v4 1", + "v6 */ DI DI 1", + "v7 +- v5 0 v6", + "v8 max v7 0", + "sdelI sqrt v8", + "v9 */ sdyO dxI 1", + "v10 */ v9 sdelI 1", + "v11 */ DI dyI 1", + "dxC1 +/ v11 v10 v4", + "v12 +- v11 0 v10", + "dxC2 */ v12 1 v4", + "adyI abs dyI", + "v13 */ adyI sdelI 1", + "v14 */ DI dxI -1", + "dyC1 +/ v14 v13 v4", + "v15 +- v14 0 v13", + "dyC2 */ v15 1 v4", + "v16 +- x1I 0 dxC1", + "v17 +- x1I 0 dxC2", + "v18 +- y1I 0 dyC1", + "v19 +- y1I 0 dyC2", + "v20 mod v16 v18 0", + "v21 mod v17 v19 0", + "v22 +- v21 0 v20", + "dxC ?: v22 dxC1 dxC2", + "dyC ?: v22 dyC1 dyC2", + "sdxC */ dxC rw2 rI", + "sdyC */ dyC rh2 rI", + "xC +- hc sdxC 0", + "yC +- vc sdyC 0", + "ist0 at2 sdxC sdyC", + "ist1 +- ist0 21600000 0", + "istAng0 ?: ist0 ist0 ist1", + "isw1 +- stAng 0 istAng0", + "isw2 +- isw1 21600000 0", + "iswAng0 ?: isw1 isw1 isw2", + "istAng +- istAng0 iswAng0 0", + "iswAng +- 0 0 iswAng0", + "p1 +- xF 0 xC", + "p2 +- yF 0 yC", + "p3 mod p1 p2 0", + "p4 */ p3 1 2", + "p5 +- p4 0 thh", + "xGp ?: p5 xF xG", + "yGp ?: p5 yF yG", + "xBp ?: p5 xC xB", + "yBp ?: p5 yC yB", + "en0 at2 sdxF sdyF", + "en1 +- en0 21600000 0", + "en2 ?: en0 en0 en1", + "sw0 +- en2 0 stAng", + "sw1 +- sw0 0 21600000", + "swAng ?: sw0 sw1 sw0", + "stAng0 +- stAng swAng 0", + "swAng0 +- 0 0 swAng", + "wtI sin rw3 stAng", + "htI cos rh3 stAng", + "dxI cat2 rw3 htI wtI", + "dyI sat2 rh3 htI wtI", + "xI +- hc dxI 0", + "yI +- vc dyI 0", + "aI +- stAng cd4 0", + "aA +- ptAng 0 cd4", + "aB +- ptAng cd2 0", + "idx cos rw1 2700000", + "idy sin rh1 2700000", + "il +- hc 0 idx", + "ir +- hc idx 0", + "it +- vc 0 idy", + "ib +- vc idy 0", + }, + new String[] { + "moveTo xE yE", + "lnTo xD yD", + "arcTo rw2 rh2 istAng iswAng", + "lnTo xBp yBp", + "lnTo xA yA", + "lnTo xGp yGp", + "lnTo xF yF", + "arcTo rw1 rh1 stAng0 swAng0", + "close", + })); + return Map.copyOf(m); + } + + /** + * Пресет-геометрия в координатах прямоугольника ячейки + * {@code [x, y, w, h]} (pt). {@code adj} — значения avLst по позиции + * (см. {@link #adjustValues}); отсутствующие позиции берутся из + * формул-дефолтов пресета. {@code prst == null} или пресет вне + * таблицы -> прямоугольник ячейки. + */ + static java.awt.Shape build(String prst, int[] adj, double x, double y, double w, double h) { + Preset preset = prst == null ? null : PRESETS.get(prst); + if (preset == null) { + return new Rectangle2D.Double(x, y, w, h); + } + Map env = new HashMap<>(); + env.put("w", w); + env.put("h", h); + env.put("ss", Math.min(w, h)); + env.put("wd2", w / 2.0); + env.put("hd2", h / 2.0); + env.put("hc", w / 2.0); + env.put("vc", h / 2.0); + env.put("l", 0.0); + env.put("t", 0.0); + env.put("r", w); + env.put("b", h); + env.put("cd2", FULL_ANGLE / 2.0); + env.put("cd4", FULL_ANGLE / 4.0); + env.put("3cd4", FULL_ANGLE * 3.0 / 4.0); + for (int i = 0; i < preset.avLst().length; i++) { + String[] e = preset.avLst()[i].split(" ", 2); + if (adj != null && adj.length > i) { + env.put(e[0], (double) adj[i]); + } else { + env.put(e[0], eval(e[1], env)); + } + } + for (String gd : preset.gdLst()) { + String[] e = gd.split(" ", 2); + env.put(e[0], eval(e[1], env)); + } + Path2D path = new Path2D.Double(); + double[] cur = new double[2]; + for (String cmd : preset.pathLst()) { + exec(cmd, env, path, cur); + } + // ECMA-гайды заданы в локальных координатах ячейки (0,0,w,h); + // смещение фигуры (a:xfrm/@off) накладывает вызывающий. + Area area = new Area(path); + area.transform(AffineTransform.getTranslateInstance(x, y)); + return area; + } + + /** + * avLst пресета в int-массив по позициям записей XML + * (a:gd name="adjN" fmla="val K" -> [.., K, ..]); неизменяемый. + */ + static int[] adjustValues(CTPresetGeometry2D prstGeom) { + CTGeomGuideList av = prstGeom == null ? null : prstGeom.getAvLst(); + if (av == null || av.getGd().isEmpty()) { + return new int[0]; + } + List gd = av.getGd(); + int[] out = new int[gd.size()]; + for (int i = 0; i < gd.size(); i++) { + out[i] = (int) evalGuide(gd.get(i).getFmla()); + } + return out; + } + + /** Значение a:gd/@fmla в пустом окружении; null/нечисловое -> 0. */ + private static double evalGuide(String fmla) { + if (fmla == null || fmla.isBlank()) { + return 0; + } + try { + return eval(fmla, Map.of()); + } catch (IllegalArgumentException e) { + return 0; + } + } + + + /** + * Вычислитель {@code ST_GeomGuideFormula} (ECMA-376 Part 1): + * префиксная запись — оператор, затем ровно арность аргументов + * ("pin 0 adj1 20000" = clamp(adj1, 0, 20000)). + */ + private static double eval(String fmla, Map env) { + int[] pos = {0}; + String[] tok = fmla.trim().split("\\s+"); + // Хвост после полного выражения игнорируется: в самом ECMA-файле + // у circularArrow/leftCircularArrow гайд xB = "+- xH 0 dxB 0" с + // лишним нулевым аргументом (значение от него не меняется). + return expr(tok, env, pos); + } + + private static double expr(String[] tok, Map env, int[] pos) { + if (pos[0] >= tok.length) { + throw new IllegalArgumentException("формула кончилась раньше времени"); + } + String t = tok[pos[0]]; + switch (t) { + case "val": { + pos[0]++; + return operand(tok, env, pos); + } + case "+": { + pos[0]++; + return operand(tok, env, pos) + operand(tok, env, pos); + } + case "-": { + pos[0]++; + double a = operand(tok, env, pos); + return a - operand(tok, env, pos); + } + case "*": { + pos[0]++; + double a = operand(tok, env, pos); + double b = operand(tok, env, pos); + return a * b / operand(tok, env, pos); + } + case "/": { + pos[0]++; + double a = operand(tok, env, pos); + double b = operand(tok, env, pos); + return (a + b) / operand(tok, env, pos); + } + case "+-": { + pos[0]++; + double a = operand(tok, env, pos); + double b = operand(tok, env, pos); + return a + b - operand(tok, env, pos); + } + case "*/": { + pos[0]++; + double a = operand(tok, env, pos); + double b = operand(tok, env, pos); + return a * b / operand(tok, env, pos); + } + case "+/": { + pos[0]++; + double a = operand(tok, env, pos); + double b = operand(tok, env, pos); + return (a + b) / operand(tok, env, pos); + } + case "?:": { + pos[0]++; + double a = operand(tok, env, pos); + double b = operand(tok, env, pos); + double c = operand(tok, env, pos); + return a > 0 ? b : c; + } + case "pin": { + pos[0]++; + double min = operand(tok, env, pos); + double val = operand(tok, env, pos); + double max = operand(tok, env, pos); + return Math.min(Math.max(val, min), max); + } + case "abs": { + pos[0]++; + return Math.abs(operand(tok, env, pos)); + } + case "sqrt": { + pos[0]++; + return Math.sqrt(operand(tok, env, pos)); + } + case "min": { + pos[0]++; + double a = operand(tok, env, pos); + return Math.min(a, operand(tok, env, pos)); + } + case "max": { + pos[0]++; + double a = operand(tok, env, pos); + return Math.max(a, operand(tok, env, pos)); + } + case "mod": { + pos[0]++; + double a = operand(tok, env, pos); + double b = operand(tok, env, pos); + double c = operand(tok, env, pos); + return Math.sqrt(a * a + b * b + c * c); + } + case "sin": { + pos[0]++; + double r = operand(tok, env, pos); + double ang = operand(tok, env, pos); + return r * Math.sin(Math.toRadians(ang / DEG_UNITS)); + } + case "cos": { + pos[0]++; + double r = operand(tok, env, pos); + double ang = operand(tok, env, pos); + return r * Math.cos(Math.toRadians(ang / DEG_UNITS)); + } + case "at2": { + pos[0]++; + double x = operand(tok, env, pos); + double y = operand(tok, env, pos); + return Math.toDegrees(Math.atan2(y, x)) * DEG_UNITS; + } + case "cat2": { + pos[0]++; + double r = operand(tok, env, pos); + double y = operand(tok, env, pos); + double z = operand(tok, env, pos); + return r * Math.cos(Math.atan2(z, y)); + } + case "sat2": { + pos[0]++; + double r = operand(tok, env, pos); + double y = operand(tok, env, pos); + double z = operand(tok, env, pos); + return r * Math.sin(Math.atan2(z, y)); + } + default: + return operand(tok, env, pos); + } + } + + /** Аргумент: ссылка на гайд или числовой литерал. */ + private static double operand(String[] tok, Map env, int[] pos) { + if (pos[0] >= tok.length) { + throw new IllegalArgumentException("формула кончилась раньше времени"); + } + String t = tok[pos[0]]; + pos[0]++; + Double e = env.get(t); + return e != null ? e : parseNumber(t, String.join(" ", tok)); + } + + private static double parseNumber(String tok, String fmla) { + try { + return Double.parseDouble(tok); + } catch (NumberFormatException e) { + throw new IllegalArgumentException("неизвестный токен \"" + tok + "\" в формуле " + fmla); + } + } + + /** + * Команда pathLst: {@code moveTo x y}, {@code lnTo x y}, + * {@code arcTo wR hR stAng swAng}, {@code close}. Аргументы — имена + * гайдов или числовые литералы (в roundRect/ellipse угол дуги задан + * и литералом {@code 0}). Углы ECMA: 0 = на 3 часа, рост по часовой + * (y вниз); центр дуги восстанавливается из текущей точки, стоящей + * на стартовом угле. + */ + private static void exec(String cmd, Map env, Path2D path, double[] cur) { + String[] tok = cmd.split("\\s+"); + switch (tok[0]) { + case "moveTo": { + cur[0] = num(env, tok[1]); + cur[1] = num(env, tok[2]); + path.moveTo(cur[0], cur[1]); + break; + } + case "lnTo": { + cur[0] = num(env, tok[1]); + cur[1] = num(env, tok[2]); + path.lineTo(cur[0], cur[1]); + break; + } + case "arcTo": { + double wR = num(env, tok[1]); + double hR = num(env, tok[2]); + double stAng = num(env, tok[3]); + double swAng = num(env, tok[4]); + double stDeg = stAng / DEG_UNITS; + double swDeg = swAng / DEG_UNITS; + double th = Math.toRadians(stDeg); + double cx = cur[0] - wR * Math.cos(th); + double cy = cur[1] - hR * Math.sin(th); + // Arc2D отсчитывает углы в математической конвенции (y вверх): + // точка дуги под φ = (cx + r·cos φ, cy − r·sin φ), поэтому + // ECMA-угол θ (y вниз) передаётся как −θ. + path.append(new Arc2D.Double(cx - wR, cy - hR, 2 * wR, 2 * hR, + -stDeg, -swDeg, Arc2D.OPEN), true); + double te = Math.toRadians(stDeg + swDeg); + cur[0] = cx + wR * Math.cos(te); + cur[1] = cy + hR * Math.sin(te); + break; + } + case "close": + path.closePath(); + break; + default: + throw new IllegalArgumentException("неизвестная команда пути: " + cmd); + } + } + + private static double num(Map env, String tok) { + Double v = env.get(tok); + return v != null ? v : parseNumber(tok, tok); + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/PrstGeomShapes.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/PrstGeomShapes.java deleted file mode 100644 index 92e84a4..0000000 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/PrstGeomShapes.java +++ /dev/null @@ -1,183 +0,0 @@ -package ru.pjandro.wordpdf.internal.chart; - -import java.awt.geom.Area; -import java.awt.geom.Ellipse2D; -import java.awt.geom.Path2D; -import java.awt.geom.Rectangle2D; -import java.awt.geom.RoundRectangle2D; - -/** - * Пресеты геометрии DrawingML (a:prstGeom) в объёме, который нужен - * SmartArt-схемам: прямоугольники, эллипсы, шестерни и круговые стрелки. - * - * Неизвестный пресет -> прямоугольник (вызывающий логирует подмену): - * для подписанной схемы это заметнее, чем пустое место. - */ -final class PrstGeomShapes { - - /** Минимальный заметный дуге размах, градусы. */ - private static final double MIN_ARC_SPAN_DEG = 1; - - private PrstGeomShapes() { - } - - /** Форма с необязательным отверстием (у шестерней — центральная втулка). */ - record Shape(Area area, Area hole) { - Area filled() { - if (hole == null) { - return area; - } - Area a = new Area(area); - a.subtract(hole); - return a; - } - } - - /** - * @param prst имя пресета из a:prstGeom/@prst - * @param adj целочисленные adjs из a:avLst (в стотысячных долях/градусах*60000) - */ - static Shape build(String prst, int[] adj, double x, double y, double w, double h) { - String p = prst == null ? "rect" : prst; - switch (p) { - case "rect" -> { - return new Shape(new Area(new Rectangle2D.Double(x, y, w, h)), null); - } - case "roundRect" -> { - double arc = Math.min(w, h) * 0.12; - return new Shape(new Area(new RoundRectangle2D.Double(x, y, w, h, arc, arc)), null); - } - case "ellipse", "oval" -> { - return new Shape(new Area(new Ellipse2D.Double(x, y, w, h)), null); - } - case "gear6", "gear9" -> { - int teeth = "gear6".equals(p) ? 6 : 9; - return gear(x, y, w, h, teeth); - } - case "circularArrow", "leftCircularArrow", "rightCircularArrow", - "curvedRightArrow", "curvedLeftArrow" -> { - return circularArrow(x, y, w, h, adj, - "leftCircularArrow".equals(p) || "curvedLeftArrow".equals(p)); - } - default -> { - return new Shape(new Area(new Rectangle2D.Double(x, y, w, h)), null); - } - } - } - - /** - * Шестерня: зубчатый венец + (опционально) центральное отверстие. - * Внешний радиус немного меньше w/2 (× 0.92), чтобы соседние - * шестерни в drawing1.xml не слипались там, где их ext-ы близко - * (Word использует тот же приём — эффективный радиус ≈ 0.97·ext/2). - * Зуб узкий и короткий, впадины — глубокие. - */ - private static Shape gear(double x, double y, double w, double h, int teeth) { - double cx = x + w / 2.0; - double cy = y + h / 2.0; - double r = Math.min(w, h) / 2.0 * 0.82; - double toothH = r * 0.18; - double body = r - toothH; - Path2D path = new Path2D.Double(); - double step = 2 * Math.PI / teeth; - // зуб: основание -> подъём -> вершина (плоская) -> спуск - double toothWidth = step * 0.30; - for (int i = 0; i < teeth; i++) { - double a = i * step; - double a0 = a - toothWidth; - double a1 = a + toothWidth; - double gap1 = a + step - toothWidth; - if (i == 0) { - path.moveTo(cx + body * Math.cos(a0), cy + body * Math.sin(a0)); - } else { - path.lineTo(cx + body * Math.cos(a0), cy + body * Math.sin(a0)); - } - path.lineTo(cx + r * Math.cos(a0 + toothWidth * 0.5), - cy + r * Math.sin(a0 + toothWidth * 0.5)); - path.lineTo(cx + r * Math.cos(a1 - toothWidth * 0.5), - cy + r * Math.sin(a1 - toothWidth * 0.5)); - path.lineTo(cx + body * Math.cos(a1), cy + body * Math.sin(a1)); - // впадина: плоская дуга по body между зубьями - path.lineTo(cx + body * Math.cos(gap1), cy + body * Math.sin(gap1)); - } - path.closePath(); - return new Shape(new Area(path), null); - } - - /** - * Круговая стрелка: сектор кольца + треугольный наконечник. - * adj2/adj3 — углы начала/конца в 1/60000 градуса (0 = на 3 часа, - * по часовой, т.к. y на экране растёт вниз). - */ - private static Shape circularArrow(double x, double y, double w, double h, - int[] adj, boolean arrowAtStart) { - double cx = x + w / 2.0; - double cy = y + h / 2.0; - double rOuter = Math.min(w, h) / 2.0 * 0.92; - // adj1 у реальных схем даёт невидимую полоску — держим минимум. - double thickness = Math.max(rOuter * pct(adj, 0, 40000), rOuter * 0.07); - double rInner = Math.max(1, rOuter - thickness); - double startDeg = deg(adj, 1, 2700000); - double endDeg = deg(adj, 2, 3600000); - if (Math.abs(endDeg - startDeg) < MIN_ARC_SPAN_DEG) { - endDeg = startDeg + 270; - } - - double a0 = Math.toRadians(startDeg); - double a1 = Math.toRadians(endDeg); - if (a1 < a0) { - a1 += 2 * Math.PI; - } - Path2D path = new Path2D.Double(); - arcSegment(path, cx, cy, rOuter, a0, a1); - arcSegment(path, cx, cy, rInner, a1, a0); - path.closePath(); - Area area = new Area(path); - - // Наконечник: размеры берём от толщины кольца — adjs у реальных - // схем (adj4/adj5) дают либо абсурдный угол, либо невидимый «усик». - // headOut ограничен, чтобы он не вылезал сильно за rOuter (иначе - // кольцо цепляется с шестерёнкой, центр которой совпадает со стрелкой). - double rMid = (rOuter + rInner) / 2.0; - double headOut = Math.min(thickness * 1.15, thickness * 2.0); - double tipAngle = arrowAtStart ? a0 - thickness * 1.7 / rMid : a1 + thickness * 1.7 / rMid; - double baseAngle = thickness * 0.9 / rMid; - double base = arrowAtStart ? a0 : a1; - Path2D head = new Path2D.Double(); - head.moveTo(cx + (rOuter + headOut * 0.2) * Math.cos(base - Math.copySign(baseAngle, base - tipAngle)), - cy + (rOuter + headOut * 0.2) * Math.sin(base - Math.copySign(baseAngle, base - tipAngle))); - head.lineTo(cx + rMid * Math.cos(tipAngle), cy + rMid * Math.sin(tipAngle)); - head.lineTo(cx + Math.max(1, rInner - headOut) * Math.cos(base - Math.copySign(baseAngle, base - tipAngle)), - cy + Math.max(1, rInner - headOut) * Math.sin(base - Math.copySign(baseAngle, base - tipAngle))); - head.closePath(); - area.add(new Area(head)); - return new Shape(area, null); - } - - private static void arcSegment(Path2D path, double cx, double cy, double r, - double a0, double a1) { - int steps = Math.max(2, (int) (Math.abs(a1 - a0) / Math.toRadians(4))); - for (int i = 0; i <= steps; i++) { - double t = a0 + (a1 - a0) * i / steps; - double px = cx + r * Math.cos(t); - double py = cy + r * Math.sin(t); - if (i == 0 && (path.getCurrentPoint() == null - || Math.abs(path.getCurrentPoint().getX() - px) > 1e-9 - || Math.abs(path.getCurrentPoint().getY() - py) > 1e-9)) { - path.moveTo(px, py); - } else { - path.lineTo(px, py); - } - } - } - - private static double pct(int[] adj, int idx, int def) { - int v = adj != null && idx < adj.length ? adj[idx] : def; - return v / 100000.0; - } - - private static double deg(int[] adj, int idx, int def) { - int v = adj != null && idx < adj.length ? adj[idx] : def; - return v / 60000.0; - } -} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/SmartArtRenderer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/SmartArtRenderer.java index 961b2d9..30e71b7 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/SmartArtRenderer.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/SmartArtRenderer.java @@ -1,6 +1,5 @@ package ru.pjandro.wordpdf.internal.chart; -import org.docx4j.dml.CTGeomGuide; import org.docx4j.dml.CTGradientFillProperties; import org.docx4j.dml.CTGradientStop; import org.docx4j.dml.CTPoint2D; @@ -8,8 +7,11 @@ import org.docx4j.dml.CTPositiveSize2D; import org.docx4j.dml.CTPresetGeometry2D; import org.docx4j.dml.CTShapeProperties; import org.docx4j.dml.CTShapeStyle; +import org.docx4j.dml.CTTextBodyProperties; +import org.docx4j.dml.CTTextNormalAutofit; import org.docx4j.dml.CTTransform2D; import org.docx4j.dml.diagram.CTCxn; +import org.docx4j.dml.STTextAnchoringType; import org.docx4j.dml.diagram.CTDataModel; import org.docx4j.dml.diagram.STCxnType; import org.docx4j.dml.diagram.CTPt; @@ -21,7 +23,6 @@ import java.awt.Color; import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.geom.AffineTransform; -import java.awt.geom.Area; import java.awt.geom.Rectangle2D; import java.awt.image.BufferedImage; import java.util.ArrayList; @@ -45,6 +46,26 @@ final class SmartArtRenderer { /** Порог «фигура повёрнута», градусы: меньше — поворот незначим. */ private static final double ROTATION_EPSILON_DEG = 0.01; + /** Дефолтные insets bodyPr (ECMA-376 CT_TextBodyProperties), pt. */ + private static final double DEFAULT_LR_INS_PT = 7.2; + private static final double DEFAULT_TB_INS_PT = 3.6; + /** EMU в пунктах (insets заданы в EMU). */ + private static final double EMU_PER_PT = 12700.0; + /** fontScale/lnSpcReduction: 100000 = «атрибут не задан / 100%». */ + private static final int NORM_AUTOFIT_FULL = 100000; + + /** Значения выравнивания bodyPr/@anchor, отличные от дефолта. */ + private static final String VALIGN_CTR = "ctr"; + private static final String VALIGN_BOTTOM = "b"; + private static final String ALIGN_LEFT = "l"; + private static final String VALIGN_TOP = "t"; + + /** Минимальный ещё печатаемый размер текстового прямоугольника/кегля, pt. */ + private static final double MIN_TEXT_BOX_PT = 0.5; + private static final double MIN_FONT_PT = 4.0; + /** Попыток подбора кегля в autosize. */ + private static final int SHRINK_ATTEMPTS = 4; + private SmartArtRenderer() { } @@ -99,10 +120,12 @@ final class SmartArtRenderer { } double mw = Math.max(1e-6, maxX - minX); double mh = Math.max(1e-6, maxY - minY); - // 0.80: drawing1.xml хранит ext-ы вплотную (gear6+gear6, - // gear6+circularArrow с почти одним центром), при scale=0.96 - // они слипаются. 0.80 даёт зазор ~10% от ext — как в эталоне. - double scale = Math.min(widthPt / mw, heightPt / mh) * 0.80; + // dsp-кэш: координаты EMU в проектном пространстве схемы; фрейм + // wp:extent — EMU. По MS-ODRAWXML «Diagram Layout» трансформа в + // схеме нет; когда кэш свежий, он совпадает с фреймом 1:1. Для + // устаревшего кэша (фрейм ресайзили после раскладки) — равномерный + // fit с центрированием, без коэффициентов. + double scale = Math.min(widthPt / mw, heightPt / mh); double offX = (widthPt - mw * scale) / 2.0 - minX * scale; double offY = (heightPt - mh * scale) / 2.0 - minY * scale; @@ -180,16 +203,9 @@ final class SmartArtRenderer { if (spPr != null && spPr.getPrstGeom() != null) { CTPresetGeometry2D pg = spPr.getPrstGeom(); prst = pg.getPrst() == null ? null : pg.getPrst().value(); - if (pg.getAvLst() != null) { - List gd = pg.getAvLst().getGd(); - adj = new int[gd.size()]; - for (int i = 0; i < gd.size(); i++) { - adj[i] = parseGuide(gd.get(i).getFmla()); - } - } + adj = PresetGeometry.adjustValues(pg); } - PrstGeomShapes.Shape shape = PrstGeomShapes.build(prst, adj, x, y, sw, sh); - Area area = shape.filled(); + java.awt.Shape area = PresetGeometry.build(prst, adj, x, y, sw, sh); Color fill = resolveFill(spPr, colors); if (fill != null) { @@ -233,6 +249,20 @@ final class SmartArtRenderer { tw = txXfrm.getExt().getCx() / 12700.0 * scale; th = txXfrm.getExt().getCy() / 12700.0 * scale; } + CTTextBodyProperties bodyPr = sp.getTxBody() == null ? null : sp.getTxBody().getBodyPr(); + if (bodyPr != null) { + double insL = inset(bodyPr.getLIns(), DEFAULT_LR_INS_PT) * scale; + double insR = inset(bodyPr.getRIns(), DEFAULT_LR_INS_PT) * scale; + double insT = inset(bodyPr.getTIns(), DEFAULT_TB_INS_PT) * scale; + double insB = inset(bodyPr.getBIns(), DEFAULT_TB_INS_PT) * scale; + tx += insL; + ty += insT; + tw -= insL + insR; + th -= insT + insB; + if (tw <= MIN_TEXT_BOX_PT || th <= MIN_TEXT_BOX_PT) { + return; + } + } Color textColor = textColor(sp, colors); List paragraphs = new ArrayList<>(); @@ -251,38 +281,68 @@ final class SmartArtRenderer { if (paragraphs.isEmpty()) { return; } - // Шрифт из XML (sz=2600 → 26pt) слишком крупный для маленьких - // шестерёнок SmartArt: "123" лезет поверх зубьев. Ограничиваем - // начальный кегль ~25% меньшей стороны текстового прямоугольника. - double capPt = Math.max(4.0, Math.min(tw, th) * 0.25); - if (p0(paragraphs) > capPt) { - List shrunk = new ArrayList<>(); - for (DrawMlText.Paragraph p : paragraphs) { - shrunk.add(new DrawMlText.Paragraph(p.text(), - p.style().derive(capPt, null, null, null, null), p.align())); + // autofit по CT_TextBodyProperties: noAutofit — текст по заявленным + // размерам (переполнение не ужимается, как в Word); normAutofit — + // fontScale/lnSpcReduction из XML, затем подбор кегля под прямоугольник. + double lineFactor = 1.0; + boolean noAutofit = bodyPr != null && bodyPr.getNoAutofit() != null; + CTTextNormalAutofit na = bodyPr == null ? null : bodyPr.getNormAutofit(); + if (na != null) { + if (na.getFontScale() > 0 && na.getFontScale() != NORM_AUTOFIT_FULL) { + double k = na.getFontScale() / (double) NORM_AUTOFIT_FULL; + List scaled = new ArrayList<>(); + for (DrawMlText.Paragraph p : paragraphs) { + scaled.add(new DrawMlText.Paragraph(p.text(), + p.style().derive(p.style().sizePt() * k, + null, null, null, null), p.align())); + } + paragraphs = scaled; + } + if (na.getLnSpcReduction() > 0) { + lineFactor = 1.0 - na.getLnSpcReduction() / (double) NORM_AUTOFIT_FULL; } - paragraphs = shrunk; } - // autosize: уменьшаем кегль, пока текст не влезет в прямоугольник - for (int attempt = 0; attempt < 4; attempt++) { - double needed = 0; - for (DrawMlText.Paragraph p : paragraphs) { - needed += DrawMlText.textHeight(p.style()); + if (!noAutofit) { + // autosize: уменьшаем кегль, пока текст не влезет в прямоугольник + for (int attempt = 0; attempt < SHRINK_ATTEMPTS; attempt++) { + double needed = 0; + for (DrawMlText.Paragraph p : paragraphs) { + needed += DrawMlText.textHeight(p.style()); + } + if (needed <= th || p0(paragraphs) <= MIN_FONT_PT) { + break; + } + double factor = th / needed; + List shrunk = new ArrayList<>(); + for (DrawMlText.Paragraph p : paragraphs) { + shrunk.add(new DrawMlText.Paragraph(p.text(), + p.style().derive(p.style().sizePt() * factor, + null, null, null, null), p.align())); + } + paragraphs = shrunk; } - if (needed <= th || p0(paragraphs) <= 4) { - break; - } - double factor = th / needed; - List shrunk = new ArrayList<>(); - for (DrawMlText.Paragraph p : paragraphs) { - shrunk.add(new DrawMlText.Paragraph(p.text(), - p.style().derive(p.style().sizePt() * factor, - null, null, null, null), p.align())); - } - paragraphs = shrunk; } DrawMlText.paint(g, paragraphs, new Rectangle2D.Double(tx, ty, tw, th), - "ctr", "ctr", 1.0); + ALIGN_LEFT, vAlignOf(bodyPr), lineFactor); + } + + /** Insets bodyPr: значение из XML (EMU) или дефолт ECMA (pt) -> pt. */ + private static double inset(Integer emu, double defaultPt) { + return emu == null ? defaultPt : emu / EMU_PER_PT; + } + + /** bodyPr/@anchor -> vAlign DrawMlText; дефолт ECMA — верх. */ + private static String vAlignOf(CTTextBodyProperties bodyPr) { + if (bodyPr == null || bodyPr.getAnchor() == null) { + return VALIGN_TOP; + } + if (bodyPr.getAnchor() == STTextAnchoringType.CTR) { + return VALIGN_CTR; + } + if (bodyPr.getAnchor() == STTextAnchoringType.B) { + return VALIGN_BOTTOM; + } + return VALIGN_TOP; } private static double p0(List ps) { @@ -318,20 +378,4 @@ final class SmartArtRenderer { } return new Color(0x59, 0x59, 0x59); } - - /** a:gd/@fmla = "val 4687" -> 4687. */ - private static int parseGuide(String fmla) { - if (fmla == null) { - return 0; - } - String s = fmla.trim(); - if (s.startsWith("val")) { - s = s.substring(3).trim(); - } - try { - return Integer.parseInt(s); - } catch (NumberFormatException e) { - return 0; - } - } } diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/PresetGeometryTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/PresetGeometryTest.java new file mode 100644 index 0000000..9fffbfc --- /dev/null +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/PresetGeometryTest.java @@ -0,0 +1,275 @@ +package ru.pjandro.wordpdf.internal.chart; + +import org.docx4j.dml.CTGeomGuide; +import org.docx4j.dml.CTGeomGuideList; +import org.docx4j.dml.CTPresetGeometry2D; +import org.junit.jupiter.api.Test; + +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamReader; +import java.awt.Shape; +import java.awt.geom.PathIterator; +import java.awt.geom.Rectangle2D; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Таблица пресетов {@link PresetGeometry} обязана быть дословной копией + * блоков ECMA {@code presetShapeDefinitions.xml} (копия стандарта — + * тестовый ресурс {@code geom/presetShapeDefinitions.xml}); синхрон + * проверяет {@link #tableMatchesEcmaXml()}. + * + * Геометрические зонды — регрессии разборов, на которых движок уже + * спотыкался: оператор {@code ?:} («if x > 0, then y else z», а не + * «x != 0») и знаковая конвенция дуг Arc2D. Ошибка в любом из них + * превращает кольцевую стрелку в залитый «пакман» без отверстия. + */ +class PresetGeometryTest { + + private static final double EPS = 1e-6; + + private static final String[] SUPPORTED = { + "rect", "roundRect", "ellipse", "gear6", "gear9", + "circularArrow", "leftCircularArrow", + }; + + /** Глубина блока пресета и его секций в дереве StAX (корень — 1). */ + private static final int DEPTH_BLOCK = 2; + private static final int DEPTH_SECTION = 3; + + @Test + void tableMatchesEcmaXml() throws Exception { + Map fromXml = parseEcmaXml(); + for (String name : SUPPORTED) { + PresetGeometry.Preset expected = fromXml.get(name); + PresetGeometry.Preset actual = PresetGeometry.preset(name); + assertTrue(expected != null && actual != null, name + " отсутствует"); + assertArrayEquals(expected.avLst(), actual.avLst(), name + ": avLst"); + assertArrayEquals(expected.gdLst(), actual.gdLst(), name + ": gdLst"); + assertArrayEquals(expected.pathLst(), actual.pathLst(), name + ": pathLst"); + } + } + + /** circularArrow: кольцевая полоса сверху (180°→343,76°), отверстие пусто, низ — пасть. */ + @Test + void circularArrowIsRingBandNotDisc() { + Shape s = PresetGeometry.build("circularArrow", new int[0], 0, 0, 100, 100); + for (double deg : new double[] {200, 270, 340}) { + assertTrue(onRing(s, deg, 37.5), "полоса на " + deg + "°"); + assertFalse(onRing(s, deg, 20), "отверстие на " + deg + "°"); + } + assertFalse(onRing(s, 90, 37.5), "низ — пасть, не полоса"); + } + + /** leftCircularArrow — зеркало: полоса снизу, пасть сверху. */ + @Test + void leftCircularArrowMirrorsBand() { + Shape s = PresetGeometry.build("leftCircularArrow", new int[0], 0, 0, 100, 100); + for (double deg : new double[] {20, 90, 160}) { + assertTrue(onRing(s, deg, 37.5), "полоса на " + deg + "°"); + assertFalse(onRing(s, deg, 20), "отверстие на " + deg + "°"); + } + assertFalse(onRing(s, 270, 37.5), "верх — пасть, не полоса"); + } + + @Test + void gearsCoverCenterAndFillCell() { + for (String gear : new String[] {"gear6", "gear9"}) { + Shape s = PresetGeometry.build(gear, new int[0], 0, 0, 100, 100); + assertTrue(s.contains(50, 50), gear + ": центр залит"); + Rectangle2D b = s.getBounds2D(); + assertTrue(b.getWidth() > 85 && b.getHeight() > 90, gear + ": " + b); + } + } + + /** avLst-override доходит до движка: толстая шестерня (adj1=20000) отличается от дефолта. */ + @Test + void adjustOverrideChangesGear() { + Shape def = PresetGeometry.build("gear6", new int[0], 0, 0, 100, 100); + Shape thick = PresetGeometry.build("gear6", new int[] {20000, 3526}, 0, 0, 100, 100); + assertNotEquals(def.getBounds2D(), thick.getBounds2D()); + assertTrue(thick.contains(50, 50)); + } + + @Test + void roundRectRoundsCorners() { + Shape s = PresetGeometry.build("roundRect", new int[0], 0, 0, 100, 100); + assertFalse(s.contains(1, 1), "угол срезан"); + assertTrue(s.contains(1, 50), "середина стороны на месте"); + } + + @Test + void ellipseFitsCell() { + Shape s = PresetGeometry.build("ellipse", new int[0], 0, 0, 100, 100); + assertTrue(s.contains(50, 50)); + assertFalse(s.contains(1, 1), "угол вне эллипса"); + } + + /** Смещение ячейки (a:xfrm/@off) транслирует построенную форму. */ + @Test + void offsetTranslatesBuiltShape() { + Shape s = PresetGeometry.build("ellipse", new int[0], 10, 20, 100, 100); + Rectangle2D b = s.getBounds2D(); + assertEquals(10, b.getMinX(), 1e-3); + assertEquals(20, b.getMinY(), 1e-3); + assertEquals(100, b.getWidth(), 1e-3); + assertEquals(100, b.getHeight(), 1e-3); + } + + @Test + void unknownPresetFallsBackToCellRect() { + Shape s = PresetGeometry.build("bogusShape", new int[0], 5, 6, 70, 80); + Rectangle2D b = s.getBounds2D(); + assertEquals(5, b.getX(), EPS); + assertEquals(6, b.getY(), EPS); + assertEquals(70, b.getWidth(), EPS); + assertEquals(80, b.getHeight(), EPS); + assertTrue(s.contains(5, 6)); + } + + @Test + void adjustValuesReadsValGuidesByPosition() { + CTPresetGeometry2D pg = new CTPresetGeometry2D(); + CTGeomGuideList av = new CTGeomGuideList(); + av.getGd().add(guide("adj1", "val 15000")); + av.getGd().add(guide("adj2", "ss 5")); + pg.setAvLst(av); + assertArrayEquals(new int[] {15000, 0}, PresetGeometry.adjustValues(pg)); + assertEquals(0, PresetGeometry.adjustValues(new CTPresetGeometry2D()).length); + } + + private static CTGeomGuide guide(String name, String fmla) { + CTGeomGuide g = new CTGeomGuide(); + g.setName(name); + g.setFmla(fmla); + return g; + } + + /** Точка на эллипсе (50±r) под углом deg (единичная конвенция ECMA: y вниз). */ + private static boolean onRing(Shape s, double deg, double r) { + double t = Math.toRadians(deg); + return s.contains(50 + r * Math.cos(t), 50 + r * Math.sin(t)); + } + + /** + * Разбор блоков стандарта: для каждого поддерживаемого пресета — + * строки avLst/gdLst («name fmla») и команды pathLst в формате + * движка («moveTo x y», «arcTo wR hR stAng swAng», «close»). + */ + private static Map parseEcmaXml() throws Exception { + XMLInputFactory f = XMLInputFactory.newFactory(); + f.setProperty(XMLInputFactory.SUPPORT_DTD, false); + f.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false); + Map out = new LinkedHashMap<>(); + try (InputStream in = PresetGeometryTest.class.getResourceAsStream( + "/geom/presetShapeDefinitions.xml")) { + assertTrue(in != null, "ресурс geom/presetShapeDefinitions.xml не найден"); + XMLStreamReader r = f.createXMLStreamReader(in); + int depth = 0; + String block = null; + String section = null; + List av = new ArrayList<>(); + List gd = new ArrayList<>(); + List path = new ArrayList<>(); + while (r.hasNext()) { + int ev = r.next(); + if (ev == XMLStreamConstants.START_ELEMENT) { + depth++; + String ln = r.getLocalName(); + if (depth == DEPTH_BLOCK && List.of(SUPPORTED).contains(ln)) { + block = ln; + av = new ArrayList<>(); + gd = new ArrayList<>(); + path = new ArrayList<>(); + } else if (block != null && depth == DEPTH_SECTION) { + section = switch (ln) { + case "avLst", "gdLst", "pathLst" -> ln; + default -> null; + }; + } else if (block != null && "gd".equals(ln) && section != null) { + String entry = r.getAttributeValue(null, "name") + " " + + r.getAttributeValue(null, "fmla"); + switch (section) { + case "avLst" -> av.add(entry); + default -> gd.add(entry); + } + } else if (block != null && "pathLst".equals(section)) { + switch (ln) { + case "moveTo", "lnTo" -> { + String[] pt = readPt(r); + path.add(ln + " " + pt[0] + " " + pt[1]); + } + case "arcTo" -> path.add("arcTo " + r.getAttributeValue(null, "wR") + + " " + r.getAttributeValue(null, "hR") + + " " + r.getAttributeValue(null, "stAng") + + " " + r.getAttributeValue(null, "swAng")); + case "close" -> path.add("close"); + default -> { + } + } + } + } else if (ev == XMLStreamConstants.END_ELEMENT) { + String ln = r.getLocalName(); + if (depth == DEPTH_SECTION) { + section = null; + } + if (depth == DEPTH_BLOCK && ln.equals(block)) { + out.put(block, new PresetGeometry.Preset( + av.toArray(String[]::new), + gd.toArray(String[]::new), + path.toArray(String[]::new))); + block = null; + } + depth--; + } + } + } + return out; + } + + /** Атрибуты x/y единственного внутри moveTo/lnTo; закрывается здесь. */ + private static String[] readPt(XMLStreamReader r) throws Exception { + while (r.hasNext()) { + if (r.next() == XMLStreamConstants.START_ELEMENT + && "pt".equals(r.getLocalName())) { + String[] attrs = { + r.getAttributeValue(null, "x"), + r.getAttributeValue(null, "y"), + }; + boolean closed = false; + while (!closed) { + closed = r.next() == XMLStreamConstants.END_ELEMENT + && "pt".equals(r.getLocalName()); + } + return attrs; + } + } + throw new IllegalStateException("у команды нет "); + } + + /** Формат движка: путь rect'а — ровно контур ячейки. */ + @Test + void rectPathIsCellContour() { + PathIterator pi = PresetGeometry.build("rect", new int[0], 0, 0, 100, 100) + .getPathIterator(null); + double[] p = new double[6]; + int segments = 0; + while (!pi.isDone()) { + if (pi.currentSegment(p) != PathIterator.SEG_CLOSE) { + segments++; + } + pi.next(); + } + assertEquals(4, segments); + } +} diff --git a/wordpdf-core/src/test/resources/geom/presetShapeDefinitions.xml b/wordpdf-core/src/test/resources/geom/presetShapeDefinitions.xml new file mode 100644 index 0000000..f3c3f2c --- /dev/null +++ b/wordpdf-core/src/test/resources/geom/presetShapeDefinitions.xml @@ -0,0 +1,19898 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- 2.56.1