From e53a09651c2ac6683bda42e3ddad47d06b8a40ba Mon Sep 17 00:00:00 2001 From: wangweiyuan Date: Wed, 30 Jul 2025 15:55:06 +0800 Subject: [PATCH] Drawing_ArkTSGraphicsDraw Signed-off-by: wangweiyuan --- Drawing/ArkTSGraphicsDraw/.gitignore | 12 + Drawing/ArkTSGraphicsDraw/AppScope/app.json5 | 25 ++ .../resources/base/element/string.json | 8 + .../resources/base/media/app_icon.png | Bin 0 -> 2777 bytes Drawing/ArkTSGraphicsDraw/README.md | 94 +++++ Drawing/ArkTSGraphicsDraw/build-profile.json5 | 56 +++ Drawing/ArkTSGraphicsDraw/entry/.gitignore | 6 + .../entry/build-profile.json5 | 43 ++ Drawing/ArkTSGraphicsDraw/entry/hvigorfile.ts | 21 + .../entry/obfuscation-rules.txt | 23 + .../ArkTSGraphicsDraw/entry/oh-package.json5 | 25 ++ .../main/ets/drawing/pages/BasicEffect.ets | 188 +++++++++ .../ets/drawing/pages/CanvasGetResult.ets | 165 ++++++++ .../drawing/pages/CanvasOperationState.ets | 228 ++++++++++ .../main/ets/drawing/pages/ComplexEffect.ets | 394 ++++++++++++++++++ .../ets/drawing/pages/PixelMapDrawing.ets | 190 +++++++++ .../main/ets/drawing/pages/ShapeDrawing.ets | 348 ++++++++++++++++ .../ets/drawing/pages/TextBlockDrawing.ets | 180 ++++++++ .../main/ets/entryability/EntryAbility.ets | 57 +++ .../entrybackupability/EntryBackupAbility.ets | 27 ++ .../entry/src/main/ets/pages/Index.ets | 101 +++++ .../src/main/ets/utils/AdaptationUtil.ets | 42 ++ .../entry/src/main/module.json5 | 66 +++ .../main/resources/base/element/color.json | 8 + .../main/resources/base/element/string.json | 160 +++++++ .../main/resources/base/media/background.png | Bin 0 -> 57364 bytes .../main/resources/base/media/foreground.png | Bin 0 -> 12430 bytes .../resources/base/media/layered_image.json | 7 + .../src/main/resources/base/media/right.png | Bin 0 -> 4905 bytes .../main/resources/base/media/startIcon.png | Bin 0 -> 20093 bytes .../resources/base/profile/backup_config.json | 3 + .../resources/base/profile/main_pages.json | 12 + .../main/resources/dark/element/color.json | 8 + .../entry/src/mock/mock-config.json5 | 17 + .../src/ohosTest/ets/test/Ability.test.ets | 361 ++++++++++++++++ .../entry/src/ohosTest/ets/test/List.test.ets | 20 + .../entry/src/ohosTest/ets/utils/Logger.ets | 45 ++ .../entry/src/ohosTest/module.json5 | 27 ++ .../hvigor/hvigor-config.json5 | 37 ++ Drawing/ArkTSGraphicsDraw/hvigorfile.ts | 21 + Drawing/ArkTSGraphicsDraw/oh-package.json5 | 25 ++ Drawing/ArkTSGraphicsDraw/ohosTest.md | 14 + .../ArkTSGraphicsDraw/screenshot/canvas.jpeg | Bin 0 -> 30747 bytes .../ArkTSGraphicsDraw/screenshot/effect.jpeg | Bin 0 -> 47056 bytes .../ArkTSGraphicsDraw/screenshot/index.jpeg | Bin 0 -> 40004 bytes .../ArkTSGraphicsDraw/screenshot/shape.jpeg | Bin 0 -> 43622 bytes 46 files changed, 3064 insertions(+) create mode 100644 Drawing/ArkTSGraphicsDraw/.gitignore create mode 100644 Drawing/ArkTSGraphicsDraw/AppScope/app.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/AppScope/resources/base/element/string.json create mode 100644 Drawing/ArkTSGraphicsDraw/AppScope/resources/base/media/app_icon.png create mode 100644 Drawing/ArkTSGraphicsDraw/README.md create mode 100644 Drawing/ArkTSGraphicsDraw/build-profile.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/entry/.gitignore create mode 100644 Drawing/ArkTSGraphicsDraw/entry/build-profile.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/entry/hvigorfile.ts create mode 100644 Drawing/ArkTSGraphicsDraw/entry/obfuscation-rules.txt create mode 100644 Drawing/ArkTSGraphicsDraw/entry/oh-package.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/BasicEffect.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/CanvasGetResult.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/CanvasOperationState.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/ComplexEffect.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/PixelMapDrawing.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/ShapeDrawing.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/TextBlockDrawing.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/entryability/EntryAbility.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/entrybackupability/EntryBackupAbility.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/pages/Index.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/ets/utils/AdaptationUtil.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/module.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/element/color.json create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/element/string.json create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/background.png create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/foreground.png create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/layered_image.json create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/right.png create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/startIcon.png create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/profile/backup_config.json create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/profile/main_pages.json create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/main/resources/dark/element/color.json create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/mock/mock-config.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/test/Ability.test.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/test/List.test.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/utils/Logger.ets create mode 100644 Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/module.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/hvigor/hvigor-config.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/hvigorfile.ts create mode 100644 Drawing/ArkTSGraphicsDraw/oh-package.json5 create mode 100644 Drawing/ArkTSGraphicsDraw/ohosTest.md create mode 100644 Drawing/ArkTSGraphicsDraw/screenshot/canvas.jpeg create mode 100644 Drawing/ArkTSGraphicsDraw/screenshot/effect.jpeg create mode 100644 Drawing/ArkTSGraphicsDraw/screenshot/index.jpeg create mode 100644 Drawing/ArkTSGraphicsDraw/screenshot/shape.jpeg diff --git a/Drawing/ArkTSGraphicsDraw/.gitignore b/Drawing/ArkTSGraphicsDraw/.gitignore new file mode 100644 index 00000000..d2ff2014 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/.gitignore @@ -0,0 +1,12 @@ +/node_modules +/oh_modules +/local.properties +/.idea +**/build +/.hvigor +.cxx +/.clangd +/.clang-format +/.clang-tidy +**/.test +/.appanalyzer \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/AppScope/app.json5 b/Drawing/ArkTSGraphicsDraw/AppScope/app.json5 new file mode 100644 index 00000000..0f0064e2 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/AppScope/app.json5 @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ + "app": { + "bundleName": "com.samples.ArkTSGraphicsDraw", + "vendor": "example", + "versionCode": 1000000, + "versionName": "1.0.0", + "icon": "$media:app_icon", + "label": "$string:app_name" + } +} diff --git a/Drawing/ArkTSGraphicsDraw/AppScope/resources/base/element/string.json b/Drawing/ArkTSGraphicsDraw/AppScope/resources/base/element/string.json new file mode 100644 index 00000000..030035c3 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/AppScope/resources/base/element/string.json @@ -0,0 +1,8 @@ +{ + "string": [ + { + "name": "app_name", + "value": "ArkTSGraphicsDraw" + } + ] +} diff --git a/Drawing/ArkTSGraphicsDraw/AppScope/resources/base/media/app_icon.png b/Drawing/ArkTSGraphicsDraw/AppScope/resources/base/media/app_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..a39445dc87828b76fed6d2ec470dd455c45319e3 GIT binary patch literal 2777 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 literal 0 HcmV?d00001 diff --git a/Drawing/ArkTSGraphicsDraw/README.md b/Drawing/ArkTSGraphicsDraw/README.md new file mode 100644 index 00000000..c30357da --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/README.md @@ -0,0 +1,94 @@ +# ArkTSGraphicsDraw + +## 介绍 + +本示例基于开发>图形->ArkGraphics 2D（方舟2D图形服务）-> [图形绘制与显示](https://gitee.com/openharmony/docs/tree/OpenHarmony-5.0.1-Release/zh-cn/application-dev/graphics#/openharmony/docs/blob/OpenHarmony-5.0.1-Release/zh-cn/application-dev/graphics/textblock-drawing-arkts.md)中的ArkTS部分开发。 + +本示例主要功能如下： + +- 演示画布的获取与绘制结果的显示，画布的类型分为直接画布与离屏画布。 +- 演示画布操作及状态处理，通过对画布进行裁剪、平移等操作控制绘图结果 +- 演示绘制效果，绘制经过填充、描边、着色器、滤波器等效果处理过后的图形。 +- 演示图元绘制，绘制多种几何形状、绘制位图及绘制字块。 + +## 效果预览 + +| 主页 | 画布获取 | 绘制效果 | 图元绘制 | +| --------------------------------- | ----------------------------------- | ----------------------------------- | --------------------------------- | +| ![index](./screenshot/index.jpeg) | ![canvas](./screenshot/canvas.jpeg) | ![effect](./screenshot/effect.jpeg) | ![shape](./screenshot/shape.jpeg) | + + +使用说明： + +1. 点击主页的导航标签组件，进入对应的演示页面。演示页面包括： + - 画布的获取与绘制结果的显示 + - 画布操作及状态处理 + - 基础绘制效果 + - 复杂绘制效果 + - 几何图形绘制 + - 图片绘制 + - 字块绘制 +2. 在演示页面内点击绘制按钮，界面绘制出对应图案。 +3. 点击返回按钮，退出应用。 + +## 工程目录 + +``` +ArkTSGraphicsDraw +entry/src/main +├──ets +│ ├──drawing +| | └──pages +| | ├──BasicEffect.ets (基础渲染效果界面) +| | ├──CanvasGetResult.ets (画布的获取与绘制结果的显示界面) +| | ├──CanvasOperationState.ets (画布操作及状态处理界面) +| | ├──ComplexEffect.ets (复杂绘制效果界面) +| | ├──PixelMapDrawing.ets (图片绘制界面) +| | ├──ShapeDrawing.ets (几何形状绘制界面) +| | └──TextBlockDrawing.ets (字块绘制界面) +│ └──pages +│ └──Index.ets (UI主界面) +└──resources (资源文件) +entry/src/ohosTest/ets/ +├── test +| ├── Ability.test.ets (UI测试代码) +| └── List.test.ets (测试套件列表) +└── utils + └── Logger.ets (logger日志类) +``` + +## 具体实现 + +1. 自定义渲染节点 (`MyRenderNode`)：继承自 `RenderNode`，重写draw函数绘制图案。 +2. 自定义节点控制器 (`MyNodeController`)：继承自 `NodeController`，自定义`makeNode` 方法。创建了一个根节点 (`rootNode`)，并将 `myRenderNode` 添加为根节点的子节点。通过设置 `backgroundColor`、`frame`、`pivot`、`scale` 等属性，来控制渲染节点的显示效果。 +3. 绘制内容的切换：`MyRenderNode`中的`drawFunctions` 数组存储了多个绘制函数，`draw` 方法根据当前的绘制函数索引调用对应的绘制函数。当绘制索引更改时，调用 `invalidate()`触发重绘，切换绘制内容。 + +## 相关权限 + +不涉及 + +## 依赖 + +不涉及。 + +## 约束和限制 + +1. 本示例仅支持标准系统上运行，支持设备：华为手机。 + +2. HarmonyOS系统：HarmonyOS 5.0.4 Release及以上。 + +3. DevEco Studio版本：DevEco Studio 5.0.4 Release及以上。 + +4. HarmonyOS SDK版本：HarmonyOS 5.0.4 Release及以上。 + +## 下载 + +如需单独下载本工程，执行如下命令： + +``` +git init +git config core.sparsecheckout true +echo code/DocsSample/Drawing/ArkTSGraphicsDraw/ > .git/info/sparse-checkout +git remote add origin OpenHarmony/applications_app_samples +git pull origin master +``` \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/build-profile.json5 b/Drawing/ArkTSGraphicsDraw/build-profile.json5 new file mode 100644 index 00000000..2f3c8686 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/build-profile.json5 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ + "app": { + "products": [ + { + "name": "default", + "signingConfig": "default", + "compatibleSdkVersion": "5.0.4(16)", + "targetSdkVersion": "5.0.4(16)", + "runtimeOS": "HarmonyOS", + "buildOption": { + "strictMode": { + "caseSensitiveCheck": true, + "useNormalizedOHMUrl": true + } + } + } + ], + "buildModeSet": [ + { + "name": "debug" + }, + { + "name": "release" + } + ] + }, + "modules": [ + { + "name": "entry", + "srcPath": "./entry", + "targets": [ + { + "name": "default", + "applyToProducts": [ + "default" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/.gitignore b/Drawing/ArkTSGraphicsDraw/entry/.gitignore new file mode 100644 index 00000000..e2713a27 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/.gitignore @@ -0,0 +1,6 @@ +/node_modules +/oh_modules +/.preview +/build +/.cxx +/.test \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/build-profile.json5 b/Drawing/ArkTSGraphicsDraw/entry/build-profile.json5 new file mode 100644 index 00000000..e7569e30 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/build-profile.json5 @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ + "apiType": "stageMode", + "buildOption": { + }, + "buildOptionSet": [ + { + "name": "release", + "arkOptions": { + "obfuscation": { + "ruleOptions": { + "enable": false, + "files": [ + "./obfuscation-rules.txt" + ] + } + } + } + }, + ], + "targets": [ + { + "name": "default" + }, + { + "name": "ohosTest", + } + ] +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/hvigorfile.ts b/Drawing/ArkTSGraphicsDraw/entry/hvigorfile.ts new file mode 100644 index 00000000..e4f43d54 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/hvigorfile.ts @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { hapTasks } from '@ohos/hvigor-ohos-plugin'; + +export default { + system: hapTasks, /* Built-in plugin of Hvigor. It cannot be modified. */ + plugins:[] /* Custom plugin to extend the functionality of Hvigor. */ +} diff --git a/Drawing/ArkTSGraphicsDraw/entry/obfuscation-rules.txt b/Drawing/ArkTSGraphicsDraw/entry/obfuscation-rules.txt new file mode 100644 index 00000000..272efb6c --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/obfuscation-rules.txt @@ -0,0 +1,23 @@ +# Define project specific obfuscation rules here. +# You can include the obfuscation configuration files in the current module's build-profile.json5. +# +# For more details, see +# https://developer.huawei.com/consumer/cn/doc/harmonyos-guides-V5/source-obfuscation-V5 + +# Obfuscation options: +# -disable-obfuscation: disable all obfuscations +# -enable-property-obfuscation: obfuscate the property names +# -enable-toplevel-obfuscation: obfuscate the names in the global scope +# -compact: remove unnecessary blank spaces and all line feeds +# -remove-log: remove all console.* statements +# -print-namecache: print the name cache that contains the mapping from the old names to new names +# -apply-namecache: reuse the given cache file + +# Keep options: +# -keep-property-name: specifies property names that you want to keep +# -keep-global-name: specifies names that you want to keep in the global scope + +-enable-property-obfuscation +-enable-toplevel-obfuscation +-enable-filename-obfuscation +-enable-export-obfuscation \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/oh-package.json5 b/Drawing/ArkTSGraphicsDraw/entry/oh-package.json5 new file mode 100644 index 00000000..c9cb6c81 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/oh-package.json5 @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ + "name": "entry", + "version": "1.0.0", + "description": "Please describe the basic information.", + "main": "", + "author": "", + "license": "", + "dependencies": {} +} + diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/BasicEffect.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/BasicEffect.ets new file mode 100644 index 00000000..628b3fa4 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/BasicEffect.ets @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { UIContext, NodeController, FrameNode, RenderNode, DrawContext } from '@kit.ArkUI'; +import { drawing } from '@kit.ArkGraphics2D'; +import { VALUE_100, VALUE_400, VALUE_800 } from '../../pages/Index'; + +function drawFilling(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_create_brush] + // 设置画刷 + const brush = new drawing.Brush(); + // [End arkts_graphics_draw_create_brush] + // [Start arkts_graphics_draw_brush_set_color] + // 填充颜色设为红色 + brush.setColor(0xFF, 0xFF, 0x00, 0x00); + // [End arkts_graphics_draw_brush_set_color] + // [Start arkts_graphics_draw_brush_set_antialias] + // 开启抗锯齿效果 + brush.setAntiAlias(true); + // [End arkts_graphics_draw_brush_set_antialias] + // [Start arkts_graphics_draw_canvas_attach_brush] + // 为画布设置画刷 + canvas.attachBrush(brush); + // [End arkts_graphics_draw_canvas_attach_brush] + // 绘制一个圆心坐标（400，400）半径400的圆 + canvas.drawCircle(VALUE_400, VALUE_400, VALUE_400); + // [Start arkts_graphics_draw_canvas_detach_brush] + // 去除画刷 + canvas.detachBrush(); + // [End arkts_graphics_draw_canvas_detach_brush] +} + +function drawStroke(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_create_drawing_pen] + // 创建画笔 + let pen = new drawing.Pen(); + // [End arkts_graphics_draw_create_drawing_pen] + // [Start arkts_graphics_draw_pen_set_color] + // 设置颜色为红色 + pen.setColor(0xFF, 0xFF, 0x00, 0x00); + // [End arkts_graphics_draw_pen_set_color] + // [Start arkts_graphics_draw_pen_set_stroke_width] + // 设置线宽 + pen.setStrokeWidth(15); + // [End arkts_graphics_draw_pen_set_stroke_width] + // [Start arkts_graphics_draw_pen_set_antialias] + // 设置抗锯齿效果 + pen.setAntiAlias(true); + // [End arkts_graphics_draw_pen_set_antialias] + // [Start arkts_graphics_draw_pen_set_cap_style] + // 设置画笔线帽样式 + pen.setCapStyle(drawing.CapStyle.SQUARE_CAP); + // [End arkts_graphics_draw_pen_set_cap_style] + // [Start arkts_graphics_draw_pen_set_join_style] + // 设置画笔转角样式 + pen.setJoinStyle(drawing.JoinStyle.ROUND_JOIN); + // [End arkts_graphics_draw_pen_set_join_style] + // [Start arkts_graphics_draw_canvas_attach_pen] + // 为画布设置画笔 + canvas.attachPen(pen); + // [End arkts_graphics_draw_canvas_attach_pen] + // 创建U型路径 + let aX = VALUE_100; + let aY = VALUE_100; + let bX = VALUE_100; + let bY = VALUE_800; + let cX = VALUE_800; + let cY = VALUE_800; + let dX = VALUE_800; + let dY = VALUE_100; + let path = new drawing.Path(); + path.moveTo(aX, aY); + path.lineTo(bX, bY); + path.lineTo(cX, cY); + path.lineTo(dX, dY); + // 绘制U型路径 + canvas.drawPath(path); + // [Start arkts_graphics_draw_canvas_detach_pen] + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_canvas_detach_pen] +} + +// 自定义RenderNode +class MyRenderNode extends RenderNode { + private drawFunctions: ((canvas: drawing.Canvas) => void)[] = []; // 存储绘制函数的数组 + private currentDrawIndex: number = 0; // 当前绘制函数的下标 + + // 添加绘制函数的接口 + addDrawFunction(func: (canvas: drawing.Canvas) => void) { + this.drawFunctions.push(func); + } + + // 设置当前绘制函数的下标 + setDrawIndex(index: number) { + if (index >= 0 && index < this.drawFunctions.length) { + this.currentDrawIndex = index; + this.invalidate(); // 触发重绘 + } + } + + async draw(context: DrawContext) { + const canvas = context.canvas; + const drawFunction = this.drawFunctions[this.currentDrawIndex]; + if (drawFunction) { + drawFunction(canvas); + } + } +} + +// 自定义NodeController +class MyNodeController extends NodeController { + private rootNode: FrameNode | null = null; + private myRenderNode = new MyRenderNode(); + + constructor() { + super(); + // 添加绘制函数 + this.myRenderNode.addDrawFunction(drawFilling); + this.myRenderNode.addDrawFunction(drawStroke); + } + + makeNode(uiContext: UIContext): FrameNode { + this.rootNode = new FrameNode(uiContext); + if (this.rootNode === null) { + return this.rootNode; + } + + const renderNode = this.rootNode.getRenderNode(); + if (renderNode !== null) { + this.myRenderNode.backgroundColor = 0xffffffff; // 白色背景 + this.myRenderNode.frame = { x: 0, y: 0, width: 4800, height: 4800 }; + this.myRenderNode.pivot = { x: 0.2, y: 0.8 }; + this.myRenderNode.scale = { x: 1, y: 1 }; + renderNode.appendChild(this.myRenderNode); + renderNode.clipToFrame = true; + } + return this.rootNode; + } + + // 暴露设置绘制函数下标的方法 + setDrawIndex(index: number) { + this.myRenderNode.setDrawIndex(index); + } +} + +@Entry +@Component +struct BaseEffect { + private nodeController: MyNodeController = new MyNodeController(); + @State flag: boolean = false; + + build() { + Row() { + Column() { + // 将自定义NodeController进行显示 + NodeContainer(this.nodeController) + .width('100%') + .height('70%'); + Row() { + Button($r('app.string.Filling')) + .onClick(() => { + this.nodeController.setDrawIndex(0); // 点击绘制填充效果 + }); + Button($r('app.string.Stroke')) + .onClick(() => { + this.nodeController.setDrawIndex(1); // 点击绘制描边效果 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + } + } + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/CanvasGetResult.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/CanvasGetResult.ets new file mode 100644 index 00000000..4245fef6 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/CanvasGetResult.ets @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { UIContext, NodeController, FrameNode, RenderNode, DrawContext} from '@kit.ArkUI'; +import { image } from '@kit.ImageKit'; +import { taskpool } from '@kit.ArkTS'; +import { drawing } from '@kit.ArkGraphics2D'; + +// [Start arkts_graphics_draw_direct_canvas_api] +// 1. 自定义 RenderNode +class MyRenderNodeDirectDisplay extends RenderNode { + async draw(context: DrawContext) { + const canvas = context.canvas; + if (canvas === null) { + console.error('Canvas is null.'); + return; + } + // 3. 自定义的绘制相关操作 + const brush = new drawing.Brush(); + if (brush === null) { + console.error('Brush is null.'); + return; + } else { + brush.setColor({red: 255, blue: 0, green: 0, alpha: 255}); + canvas.attachBrush(brush); + canvas.drawRect({left: 0, right: 300, top: 0, bottom: 300}); + } + } +} + +// 2. 自定义 NodeController +class MyNodeControllerDirectDisplay extends NodeController { + private rootNode: FrameNode | null = null; + private myRenderNode = new MyRenderNodeDirectDisplay(); + + makeNode(uiContext: UIContext): FrameNode { + this.rootNode = new FrameNode(uiContext); + if (this.rootNode === null) { + return this.rootNode; + } + const renderNode = this.rootNode.getRenderNode(); + if (renderNode !== null) { + this.myRenderNode.backgroundColor = 0xffffffff; + this.myRenderNode.frame = { x: 0, y: 0, width: 4800, height: 4800 }; + this.myRenderNode.pivot = { x: 0.2, y: 0.8 }; + this.myRenderNode.scale = { x: 1, y: 1 }; + renderNode.appendChild(this.myRenderNode); + renderNode.clipToFrame = true; + } + return this.rootNode; + } +} +// [End arkts_graphics_draw_direct_canvas_api] + +// [Start arkts_graphics_draw_indirect_canvas_api] +// 1. 自定义RenderNode +export class MyRenderNodeIndirectDisplay extends RenderNode { + private pixelMap: image.PixelMap | null = null; + setPixelMap(pixelMap: image.PixelMap) { + this.pixelMap = pixelMap; + } + + async draw(context: DrawContext) { + const canvas = context.canvas; + if (this.pixelMap != null) { + // 4.1 利用3中创建的PixelMap构造离屏Canvas + const canvas_ = new drawing.Canvas(this.pixelMap); + + // 4.2 离屏绘制 + const brush = new drawing.Brush(); + brush.setColor({ alpha: 255, red: 0, green: 0, blue: 255 }); + canvas_.attachBrush(brush); + canvas_.drawRect({ left: 150, right: 575, top: 0, bottom: 600 }); + + // 4.3 将离屏Canvas的绘制结果交给RenderNode + canvas.drawImage(this.pixelMap, 0, 0); + } + } +} + +@Concurrent +async function createPixelMapAsync() { + const color : ArrayBuffer = new ArrayBuffer(4000000); // 40000为需要创建的像素buffer大小，取值为：height * width *4 + let opts : image.InitializationOptions = { editable: true, pixelFormat: 3, size: { height: 1000, width: 1000 } }; + const pixel = await image.createPixelMap(color, opts); + return pixel; +} + +// 2. 自定义NodeController +export class MyNodeControllerIndirectDisplay extends NodeController { + private rootNode: FrameNode | null = null; + private myRenderNode = new MyRenderNodeIndirectDisplay(); + + // 3. 在MyNodeController的aboutToAppear中创建PixeMap + aboutToAppear(): void { + let task = new taskpool.Task(createPixelMapAsync); + taskpool.execute(task).then((pixel:Object)=>{ + this.myRenderNode.setPixelMap(pixel as image.PixelMap); + this.myRenderNode.invalidate(); + }) + } + + makeNode(uiContext: UIContext): FrameNode { + this.rootNode = new FrameNode(uiContext); + if (this.rootNode === null) { + return this.rootNode; + } + + const renderNode = this.rootNode.getRenderNode(); + if (renderNode !== null) { + this.myRenderNode.backgroundColor = 0xffffffff; + this.myRenderNode.frame = { x: 0, y: 0, width: 4800, height: 4800 }; + this.myRenderNode.pivot = { x: 0.2, y: 0.8 }; + this.myRenderNode.scale = { x: 1, y: 1 }; + renderNode.appendChild(this.myRenderNode); + renderNode.clipToFrame = true; + } + return this.rootNode; + } +} +// [End arkts_graphics_draw_indirect_canvas_api] + +// [Start arkts_graphics_draw_direct_and_indirect_canvas] +@Entry +@Component +struct RenderTest { + @State message: string = 'hello'; + myNodeController_1 = new MyNodeControllerDirectDisplay(); + myNodeController_2 = new MyNodeControllerIndirectDisplay(); + + build() { + Row() { + Column() { + Column(){ + Text($r('app.string.DirectCanvas')) + // 直接画布 + NodeContainer(this.myNodeController_1) + .width('100%') + .height('40%') + } + Column(){ + Text($r('app.string.OffScreenCanvas')) + // 离屏画布 + NodeContainer(this.myNodeController_2) + .width('100%') + .height('40%') + .margin({ top: 20 }) + } + } + } + } +} +// [End arkts_graphics_draw_direct_and_indirect_canvas] \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/CanvasOperationState.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/CanvasOperationState.ets new file mode 100644 index 00000000..b15ceccc --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/CanvasOperationState.ets @@ -0,0 +1,228 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { UIContext, NodeController, FrameNode, RenderNode, DrawContext } from '@kit.ArkUI'; +import { common2D, drawing } from '@kit.ArkGraphics2D'; +import { VALUE_200, VALUE_300, VALUE_600 } from '../../pages/Index'; + + +function drawClipOperation(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_canvas_clip] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置颜色为蓝色 + brush.setColor(0xFF, 0x00, 0x00, 0xFF); + // 设置画刷填充效果 + canvas.attachBrush(brush); + // 创建矩形对象 + let rect: common2D.Rect = { left: VALUE_200, top: VALUE_200, right: VALUE_600, bottom: VALUE_600 }; + // 裁剪矩形区域 + canvas.clipRect(rect); + // 绘制圆形 + canvas.drawCircle(VALUE_300, VALUE_300, VALUE_300); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_canvas_clip] +} + +function drawTranslationOperation(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_canvas_translation] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置颜色为红色 + brush.setColor(0xFF, 0xFF, 0x00, 0x00); + // 设置画刷填充效果 + canvas.attachBrush(brush); + // 执行平移操作 + canvas.translate(VALUE_300, VALUE_300); + // 绘制矩形 + canvas.drawRect({ left: VALUE_200, top: VALUE_200, right: VALUE_600, bottom: VALUE_600 }); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_canvas_translation] +} + +function drawRotationOperation(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_canvas_rotation] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置颜色为红色 + brush.setColor(0xFF, 0xFF, 0x00, 0x00); + // 设置画刷填充效果 + canvas.attachBrush(brush); + // 顺时针旋转45度 + canvas.rotate(45, VALUE_200, VALUE_200); + // 绘制矩形 + canvas.drawRect({ left: VALUE_200, top: VALUE_200, right: VALUE_600, bottom: VALUE_600 }); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_canvas_rotation] +} + +function drawScaleOperation(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_canvas_scale] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置颜色为红色 + brush.setColor({ alpha: 0xFF, red: 0xFF, green: 0x00, blue: 0x00 }); + // 设置画刷填充效果 + canvas.attachBrush(brush); + // 执行放大操作 + canvas.scale(2, 2); + // 绘制矩形 + canvas.drawRect({ left: VALUE_200, top: VALUE_200, right: VALUE_600, bottom: VALUE_600 }); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_canvas_scale] +} + +function drawStateOperation(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_canvas_state_operation] + // 创建画笔 + let pen = new drawing.Pen(); + // 设置颜色为红色 + pen.setColor({ alpha: 0xFF, red: 0xFF, green: 0x00, blue: 0x00 }); + // 设置描边宽度为20px + pen.setStrokeWidth(20); + // 设置画笔描边效果 + canvas.attachPen(pen); + // 保存操作，当前是不存在放大等操作的，这个原始状态会被保存下来 + canvas.save(); + // x轴和y轴放行分别放大2倍 + canvas.scale(2, 2); + // 绘制圆形，因为执行过放大操作，所以此时绘制的是大圆 + canvas.drawCircle(VALUE_300, VALUE_300, VALUE_200); + // 恢复操作，恢复到没有放大的原始状态 + canvas.restore(); + // 绘制圆形，因为已经恢复到没有放大的原始状态，所以此时绘制的是小圆 + canvas.drawCircle(VALUE_300, VALUE_300, VALUE_200); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_canvas_state_operation] +} + + +// 自定义RenderNode +class MyRenderNode extends RenderNode { + private drawFunctions: ((canvas: drawing.Canvas) => void)[] = []; // 存储绘制函数的数组 + private currentDrawIndex: number = 0; // 当前绘制函数的下标 + + // 添加绘制函数的接口 + addDrawFunction(func: (canvas: drawing.Canvas) => void) { + this.drawFunctions.push(func); + } + + // 设置当前绘制函数的下标 + setDrawIndex(index: number) { + if (index >= 0 && index < this.drawFunctions.length) { + this.currentDrawIndex = index; + this.invalidate(); // 触发重绘 + } + } + + async draw(context: DrawContext) { + const canvas = context.canvas; + const drawFunction = this.drawFunctions[this.currentDrawIndex]; + if (drawFunction) { + drawFunction(canvas); + } + } +} + +// 自定义NodeController +class MyNodeController extends NodeController { + private rootNode: FrameNode | null = null; + private myRenderNode = new MyRenderNode(); + + constructor() { + super(); + // 添加绘制函数 + this.myRenderNode.addDrawFunction(drawClipOperation); + this.myRenderNode.addDrawFunction(drawTranslationOperation); + this.myRenderNode.addDrawFunction(drawRotationOperation); + this.myRenderNode.addDrawFunction(drawScaleOperation); + this.myRenderNode.addDrawFunction(drawStateOperation); + } + + makeNode(uiContext: UIContext): FrameNode { + this.rootNode = new FrameNode(uiContext); + if (this.rootNode === null) { + return this.rootNode; + } + + const renderNode = this.rootNode.getRenderNode(); + if (renderNode !== null) { + this.myRenderNode.backgroundColor = 0xffffffff; // 白色背景 + this.myRenderNode.frame = { x: 0, y: 0, width: 4800, height: 4800 }; + this.myRenderNode.pivot = { x: 0.2, y: 0.8 }; + this.myRenderNode.scale = { x: 1, y: 1 }; + renderNode.appendChild(this.myRenderNode); + renderNode.clipToFrame = true; + } + return this.rootNode; + } + + // 暴露设置绘制函数下标的方法 + setDrawIndex(index: number) { + this.myRenderNode.setDrawIndex(index); + } +} + +@Entry +@Component +struct CanvasOperationState { + private nodeController: MyNodeController = new MyNodeController(); + + build() { + Row() { + Column() { + // 将自定义NodeController进行显示 + NodeContainer(this.nodeController) + .width('100%') + .height('70%'); + Row() { + Button($r('app.string.ClipOperation')) + .onClick(() => { + this.nodeController.setDrawIndex(0); // 点击绘制裁剪操作 + }); + Button($r('app.string.TranslationOperation')) + .onClick(() => { + this.nodeController.setDrawIndex(1); // 点击绘制平移操作 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + Row() { + Button($r('app.string.RotationOperation')) + .onClick(() => { + this.nodeController.setDrawIndex(2); // 点击绘制旋转操作 + }); + Button($r('app.string.ScaleOperation')) + .onClick(() => { + this.nodeController.setDrawIndex(3); // 点击绘制缩放操作 + }); + Button($r('app.string.StateOperation')) + .onClick(() => { + this.nodeController.setDrawIndex(4); // 点击绘制画布状态操作 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + } + } + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/ComplexEffect.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/ComplexEffect.ets new file mode 100644 index 00000000..693fab14 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/ComplexEffect.ets @@ -0,0 +1,394 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { DrawContext, FrameNode, NodeController, RenderNode, UIContext } from '@kit.ArkUI'; +import { common2D, drawing } from '@kit.ArkGraphics2D'; +import { + VALUE_100, + VALUE_200, + VALUE_300, + VALUE_500, + VALUE_600, + VALUE_700, + VALUE_900, + VALUE_1000 +} from '../../pages/Index'; + +function drawMixedMode(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_mixed_mode] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置目标像素颜色，即矩形的颜色 + brush.setColor(0xFF, 0xFF, 0x00, 0x00); + // 将目标像素的画刷效果设置到Canvas中 + canvas.attachBrush(brush); + // 创建矩形对象 + let rect: common2D.Rect = { + left: VALUE_100, + top: VALUE_100, + right: VALUE_600, + bottom: VALUE_600 + }; + // 绘制矩形（目标像素） + canvas.drawRect(rect); + // 设置源像素颜色，即圆形的颜色 + brush.setColor(0xFF, 0x00, 0x00, 0xFF); + // 设置混合模式为叠加模式 + brush.setBlendMode(drawing.BlendMode.PLUS); + // 将源像素的画刷效果设置到Canvas中 + canvas.attachBrush(brush); + // 绘制圆（源像素） + canvas.drawCircle(VALUE_600, VALUE_600, VALUE_300); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_mixed_mode] +} + +function drawPathEffect(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_path_effect] + // 创建画笔 + let pen = new drawing.Pen(); + // 设置线宽 + pen.setStrokeWidth(10.0); + // 设置颜色 + pen.setColor(0xFF, 0xFF, 0x00, 0x00); + // 表示10px的实线，5px的间隔，2px的实线，5px的间隔，以此循环 + let intervals = [10, 5, 2, 5]; + // 设置虚线路径效果 + let effect = drawing.PathEffect.createDashPathEffect(intervals, 0); + pen.setPathEffect(effect); + // 设置画笔描边效果 + canvas.attachPen(pen); + // 创建矩形 + let rect: common2D.Rect = { + left: VALUE_200, + top: VALUE_200, + right: VALUE_1000, + bottom: VALUE_700 + }; + // 绘制矩形 + canvas.drawRect(rect); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_path_effect] +} + +function drawLinearGradient(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_linear_gradient] + let startPt: common2D.Point = { x: VALUE_100, y: VALUE_100 }; + let endPt: common2D.Point = { x: VALUE_900, y: VALUE_900 }; + let colors = [0xFFFFFF00, 0xFFFF0000, 0xFF0000FF]; + // 创建线性渐变着色器 + let shaderEffect = drawing.ShaderEffect.createLinearGradient(startPt, endPt, colors, drawing.TileMode.CLAMP); + // 创建画刷 + let brush = new drawing.Brush(); + // 设置线性着色器 + brush.setShaderEffect(shaderEffect); + // 设置画刷填充效果 + canvas.attachBrush(brush); + let rect: common2D.Rect = { + left: VALUE_100, + top: VALUE_100, + right: VALUE_900, + bottom: VALUE_900 + }; + // 绘制矩形 + canvas.drawRect(rect); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_linear_gradient] +} + +function drawPathGradient(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_path_gradient] + let centerPt: common2D.Point = { x: VALUE_500, y: VALUE_500 }; + let colors = [0xFFFF0000, 0xFF00FF00, 0xFF0000FF]; + // 创建径向渐变着色器 + let shaderEffect = drawing.ShaderEffect.createRadialGradient(centerPt, VALUE_600, colors, drawing.TileMode.CLAMP); + // 创建画刷 + let brush = new drawing.Brush(); + // 设置径向渐变着色器 + brush.setShaderEffect(shaderEffect); + // 设置画刷填充效果 + canvas.attachBrush(brush); + let rect: common2D.Rect = { + left: VALUE_100, + top: VALUE_100, + right: VALUE_900, + bottom: VALUE_900 + }; + // 绘制矩形 + canvas.drawRect(rect); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_path_gradient] +} + +function drawSectorGradient(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_sector_gradient] + let centerPt: common2D.Point = { x: VALUE_500, y: VALUE_500 }; + let colors = [0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00]; + // 创建扇形渐变着色器 + let shaderEffect = drawing.ShaderEffect.createSweepGradient(centerPt, colors, drawing.TileMode.CLAMP, 0, 360); + // 创建画刷 + let brush = new drawing.Brush(); + // 设置扇形渐变着色器 + brush.setShaderEffect(shaderEffect); + // 设置画刷填充效果 + canvas.attachBrush(brush); + let rect: common2D.Rect = { + left: VALUE_100, + top: VALUE_100, + right: VALUE_900, + bottom: VALUE_900 + }; + // 绘制矩形 + canvas.drawRect(rect); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_sector_gradient] +} + +function drawColorFilter(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_color_filter] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置颜色 + brush.setColor(0xFF, 0xFF, 0x00, 0x00); + // 设置颜色矩阵 + let matrix: number[] = [ + 1, 0, 0, 0, 0, + 0, 1, 0, 0, 0, + 0, 0, 0.5, 0.5, 0, + 0, 0, 0.5, 0.5, 0 + ]; + // 创建5x4颜色矩阵的颜色滤波器 + let filter = drawing.ColorFilter.createMatrixColorFilter(matrix); + // 设置颜色滤波器 + brush.setColorFilter(filter); + // 设置画刷填充效果 + canvas.attachBrush(brush); + let rect: common2D.Rect = { + left: VALUE_300, + top: VALUE_300, + right: VALUE_900, + bottom: VALUE_900 + }; + // 绘制矩形 + canvas.drawRect(rect); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_color_filter] +} + +function drawImageFilter(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_image_filter] + // 设置画笔 + let pen = new drawing.Pen(); + // 设置线宽 + pen.setStrokeWidth(10.0); + // 设置颜色 + pen.setColor(0xFF, 0xFF, 0x00, 0x00); + // 创建模糊效果图像滤波器 + let filter = drawing.ImageFilter.createBlurImageFilter(20, 20, drawing.TileMode.CLAMP); + // 设置图像滤波器 + pen.setImageFilter(filter); + // 设置画笔描边效果 + canvas.attachPen(pen); + let rect: common2D.Rect = { + left: VALUE_300, + top: VALUE_300, + right: VALUE_900, + bottom: VALUE_900 + }; + // 绘制矩形 + canvas.drawRect(rect); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_image_filter] +} + +function drawMaskFilter(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_mask_filter] + // 创建画笔 + let pen = new drawing.Pen(); + // 设置线宽 + pen.setStrokeWidth(10.0); + // 设置颜色 + pen.setColor(0xFF, 0xFF, 0x00, 0x00); + // 创建模糊效果的蒙版滤波器 + let filter = drawing.MaskFilter.createBlurMaskFilter(drawing.BlurType.NORMAL, 20); + // 设置模糊效果 + pen.setMaskFilter(filter); + // 设置画笔描边效果 + canvas.attachPen(pen); + let rect: common2D.Rect = { + left: VALUE_300, + top: VALUE_300, + right: VALUE_900, + bottom: VALUE_900 + }; + // 绘制矩形 + canvas.drawRect(rect); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_mask_filter] +} + +// 自定义RenderNode +class MyRenderNode extends RenderNode { + private drawFunctions: ((canvas: drawing.Canvas) => void)[] = []; // 存储绘制函数的数组 + private currentDrawIndex: number = 0; // 当前绘制函数的下标 + + // 添加绘制函数的接口 + addDrawFunction(func: (canvas: drawing.Canvas) => void) { + this.drawFunctions.push(func); + } + + // 设置当前绘制函数的下标 + setDrawIndex(index: number) { + if (index >= 0 && index < this.drawFunctions.length) { + this.currentDrawIndex = index; + this.invalidate(); // 触发重绘 + } + } + + async draw(context: DrawContext) { + const canvas = context.canvas; + const drawFunction = this.drawFunctions[this.currentDrawIndex]; + if (drawFunction) { + drawFunction(canvas); + } + } +} + +// 自定义NodeController +class MyNodeController extends NodeController { + private myRenderNode = new MyRenderNode(); + private rootNode: FrameNode | null = null; + + constructor() { + super(); + // 添加绘制函数 + this.myRenderNode.addDrawFunction(drawMixedMode); + this.myRenderNode.addDrawFunction(drawPathEffect); + this.myRenderNode.addDrawFunction(drawLinearGradient); + this.myRenderNode.addDrawFunction(drawPathGradient); + this.myRenderNode.addDrawFunction(drawSectorGradient); + this.myRenderNode.addDrawFunction(drawColorFilter); + this.myRenderNode.addDrawFunction(drawImageFilter); + this.myRenderNode.addDrawFunction(drawMaskFilter); + } + + makeNode(uiContext: UIContext): FrameNode { + this.rootNode = new FrameNode(uiContext); + if (this.rootNode === null) { + return this.rootNode; + } + + const renderNode = this.rootNode.getRenderNode(); + if (renderNode !== null) { + this.myRenderNode.backgroundColor = 0xff000000; // 黑色背景 + this.myRenderNode.frame = { + x: 0, + y: 0, + width: 4800, + height: 4800 + }; + this.myRenderNode.pivot = { x: 0.2, y: 0.8 }; + this.myRenderNode.scale = { x: 1, y: 1 }; + renderNode.appendChild(this.myRenderNode); + renderNode.clipToFrame = true; + } + return this.rootNode; + } + + // 暴露设置绘制函数下标的方法 + setDrawIndex(index: number) { + this.myRenderNode.setDrawIndex(index); + if (index === 0) { + this.myRenderNode.backgroundColor = 0xff000000; // 混合模式效果需要使用黑色背景展示 + } else { + this.myRenderNode.backgroundColor = 0xffffffff; // 其余模式使用白色背景 + } + + } +} + +@Entry +@Component +struct ComplexEffect { + private nodeController: MyNodeController = new MyNodeController(); + + build() { + Row() { + Column() { + // 将自定义NodeController进行显示 + NodeContainer(this.nodeController) + .width('100%') + .height('70%'); + Row() { + Button($r('app.string.MixedMode')) + .onClick(() => { + this.nodeController.setDrawIndex(0); // 点击绘制混合模式 + }); + Button($r('app.string.PathEffect')) + .onClick(() => { + this.nodeController.setDrawIndex(1); // 点击绘制路径效果 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + + Row() { + Button($r('app.string.LinearGradient')) + .onClick(() => { + this.nodeController.setDrawIndex(2); // 点击绘制线性渐变着色器效果 + }); + Button($r('app.string.PathGradient')) + .onClick(() => { + this.nodeController.setDrawIndex(3); // 点击绘制径向渐变着色器效果 + }); + Button($r('app.string.SectorGradient')) + .onClick(() => { + this.nodeController.setDrawIndex(4); // 点击绘制扇形渐变着色器效果 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + + Row() { + Button($r('app.string.ColorFilter')) + .onClick(() => { + this.nodeController.setDrawIndex(5); // 点击绘制颜色滤波器效果 + }); + Button($r('app.string.ImageFilter')) + .onClick(() => { + this.nodeController.setDrawIndex(6); // 点击绘制图像滤波器效果 + }); + Button($r('app.string.MaskFilter')) + .onClick(() => { + this.nodeController.setDrawIndex(7); // 点击绘制蒙版滤波器效果 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + } + } + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/PixelMapDrawing.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/PixelMapDrawing.ets new file mode 100644 index 00000000..e2bc466f --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/PixelMapDrawing.ets @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { DrawContext, FrameNode, NodeController, RenderNode, UIContext } from '@kit.ArkUI'; +import { drawing } from '@kit.ArkGraphics2D'; +import { image } from '@kit.ImageKit'; +import { VALUE_100, VALUE_200 } from '../../pages/Index'; + +let pixelMap: image.PixelMap; + +function drawImage(canvas: drawing.Canvas) { + // Start arkts_graphics_draw_image] + // 图片宽高 + let width = 600; + let height = 400; + // 字节长度，RGBA_8888每个像素占4字节 + let bytelength = width * height * 4; + const color: ArrayBuffer = new ArrayBuffer(bytelength); + let bufferArr = new Uint8Array(color); + for (let i = 0; i < bufferArr.length; i += 4) { + // 遍历并编辑每个像素，从而形成红绿蓝相间的条纹 + bufferArr[i] = 0x00; + bufferArr[i+1] = 0x00; + bufferArr[i+2] = 0x00; + bufferArr[i+3] = 0xFF; + let n = Math.floor(i / 80) % 3; + if (n == 0) { + bufferArr[i] = 0xFF; + } else if (n == 1) { + bufferArr[i+1] = 0xFF; + } else { + bufferArr[i+2] = 0xFF; + } + } + // 设置像素属性 + let opts: image.InitializationOptions = + { editable: true, pixelFormat: image.PixelMapFormat.RGBA_8888, size: { height: height, width: width } }; + // 创建PixelMap + pixelMap = image.createPixelMapSync(color, opts); + // 为了使图片完全显示，修改绘制起点参数为（0，0） + canvas.drawImage(pixelMap, 0, 0); + // End arkts_graphics_draw_image] +} + +function editPixel(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_edit_pixel] + // 设置编辑区域的宽高 + let innerWidth = 400; + let innerHeight = 200; + // 编辑区域的字节长度，RGBA_8888每个像素占4字节 + let innerByteLength = innerWidth * innerHeight * 4; + const innerColor: ArrayBuffer = new ArrayBuffer(innerByteLength); + let innerBufferArr = new Uint8Array(innerColor); + for (let i = 0; i < innerBufferArr.length; i += 4) { + // 编辑区域的像素都设置为黑白相间条纹 + let n = Math.floor(i / 80) % 2; + if (n == 0) { + innerBufferArr[i] = 0x00; + innerBufferArr[i+1] = 0x00; + innerBufferArr[i+2] = 0x00; + } else { + innerBufferArr[i] = 0xFF; + innerBufferArr[i+1] = 0xFF; + innerBufferArr[i+2] = 0xFF; + } + innerBufferArr[i+3] = 0xFF; + } + // 设置编辑区域的像素、宽高、偏移量等 + const area: image.PositionArea = { + pixels: innerColor, + offset: 0, + stride: innerWidth * 4, + region: { size: { height: innerHeight, width: innerWidth }, x: 100, y: 100 } + }; + // 编辑位图，形成中间的黑白相间条纹 + pixelMap.writePixelsSync(area); + // 为了使图片完全显示，修改绘制起点参数为（0，0） + canvas.drawImage(pixelMap, 0, 0); + // [End arkts_graphics_draw_edit_pixel] +} + +// 自定义RenderNode +class MyRenderNode extends RenderNode { + private drawFunctions: ((canvas: drawing.Canvas) => void)[] = []; // 存储绘制函数的数组 + private currentDrawIndex: number = 0; // 当前绘制函数的下标 + + // 添加绘制函数的接口 + addDrawFunction(func: (canvas: drawing.Canvas) => void) { + this.drawFunctions.push(func); + } + + // 设置当前绘制函数的下标 + setDrawIndex(index: number) { + if (index >= 0 && index < this.drawFunctions.length) { + this.currentDrawIndex = index; + this.invalidate(); // 触发重绘 + } + } + + async draw(context: DrawContext) { + const canvas = context.canvas; + const drawFunction = this.drawFunctions[this.currentDrawIndex]; + if (drawFunction) { + drawFunction(canvas); + } + } +} + +// 自定义NodeController +class MyNodeController extends NodeController { + private myRenderNode = new MyRenderNode(); + private rootNode: FrameNode | null = null; + + constructor() { + super(); + // 添加绘制函数 + this.myRenderNode.addDrawFunction(drawImage); + this.myRenderNode.addDrawFunction(editPixel); + } + + makeNode(uiContext: UIContext): FrameNode { + this.rootNode = new FrameNode(uiContext); + if (this.rootNode === null) { + return this.rootNode; + } + + const renderNode = this.rootNode.getRenderNode(); + if (renderNode !== null) { + this.myRenderNode.backgroundColor = 0xffffffff; // 白色背景 + this.myRenderNode.frame = { + x: 0, + y: 0, + width: 4800, + height: 4800 + }; + this.myRenderNode.pivot = { x: 0.2, y: 0.8 }; + this.myRenderNode.scale = { x: 1, y: 1 }; + renderNode.appendChild(this.myRenderNode); + renderNode.clipToFrame = true; + } + return this.rootNode; + } + + // 暴露设置绘制函数下标的方法 + setDrawIndex(index: number) { + this.myRenderNode.setDrawIndex(index); + } +} + +@Entry +@Component +struct ImageDrawing { + private nodeController: MyNodeController = new MyNodeController(); + + build() { + Row() { + Column() { + // 将自定义NodeController进行显示 + NodeContainer(this.nodeController) + .width('100%') + .height('70%'); + Row() { + Button($r('app.string.PixelMap')) + .onClick(() => { + this.nodeController.setDrawIndex(0); // 点击绘制位图 + }); + Button($r('app.string.EditMiddlePixel')) + .onClick(() => { + this.nodeController.setDrawIndex(1); // 点击编辑位图像素 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + } + } + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/ShapeDrawing.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/ShapeDrawing.ets new file mode 100644 index 00000000..5df7176e --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/ShapeDrawing.ets @@ -0,0 +1,348 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { DrawContext, FrameNode, NodeController, RenderNode, UIContext } from '@kit.ArkUI'; +import { common2D, drawing } from '@kit.ArkGraphics2D'; +import { + VALUE_100, + VALUE_200, + VALUE_300, + VALUE_400, + VALUE_500, + VALUE_600, + VALUE_630, + VALUE_700, + VALUE_800, + VALUE_900, + VALUE_1000, + VALUE_1800 +} from '../../pages/Index'; + +function drawPoint(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_point] + // 设置画笔 + let pen = new drawing.Pen(); + // 设置颜色 + pen.setColor(0xFF, 0xFF, 0x00, 0x00); + // 设置线宽 + pen.setStrokeWidth(40); + // 设置画笔描边效果 + canvas.attachPen(pen); + // 绘制5个点 + canvas.drawPoint(VALUE_200, VALUE_200); + canvas.drawPoint(VALUE_400, VALUE_400); + canvas.drawPoint(VALUE_600, VALUE_600); + canvas.drawPoint(VALUE_800, VALUE_800); + canvas.drawPoint(VALUE_1000, VALUE_1000); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_point] +} + +function drawArc(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_arc] + // 创建画笔 + let pen = new drawing.Pen(); + // 设置颜色 + pen.setColor({ + alpha: 0xFF, + red: 0xFF, + green: 0x00, + blue: 0x00 + }); + // 设置线宽 + pen.setStrokeWidth(20); + // 设置画笔描边效果 + canvas.attachPen(pen); + // 创建矩形对象 + const rect: common2D.Rect = { + left: VALUE_100, + top: VALUE_200, + right: VALUE_1000, + bottom: VALUE_600 + }; + // 绘制矩形 + canvas.drawArc(rect, 0, 180); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_arc] +} + +function drawCircle(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_circle] + // 创建画笔 + let pen = new drawing.Pen(); + // 设置颜色 + pen.setColor({ + alpha: 0xFF, + red: 0xFF, + green: 0x00, + blue: 0x00 + }); + // 设置线宽 + pen.setStrokeWidth(20); + // 设置画笔描边效果 + canvas.attachPen(pen); + // 绘制圆 + canvas.drawCircle(VALUE_630, VALUE_630, VALUE_500); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_circle] +} + +function drawPath(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_path] + let height_ = VALUE_1800; + let width_ = VALUE_1800; + let len = height_ / 4; + let aX = width_ / 3; + let aY = height_ / 6; + let dX = aX - len * Math.sin(18.0); + let dY = aY + len * Math.cos(18.0); + let cX = aX + len * Math.sin(18.0); + let cY = dY; + let bX = aX + (len / 2.0); + let bY = aY + Math.sqrt((cX - dX) * (cX - dX) + (len / 2.0) * (len / 2.0)); + let eX = aX - (len / 2.0); + let eY = bY; + + // 创建一个path对象，然后使用接口连接成一个五角星形状 + let path = new drawing.Path(); + // 指定path的起始位置 + path.moveTo(aX, aY); + // 用直线连接到目标点 + path.lineTo(bX, bY); + path.lineTo(cX, cY); + path.lineTo(dX, dY); + path.lineTo(eX, eY); + // 闭合形状，path绘制完毕 + path.close(); + + // 创建画笔对象 + let pen = new drawing.Pen(); + // 设置抗锯齿 + pen.setAntiAlias(true); + // 设置描边颜色 + pen.setColor(0xFF, 0xFF, 0x00, 0x00); + // 设置线宽 + pen.setStrokeWidth(10.0); + // 设置画笔描边效果 + canvas.attachPen(pen); + // 创建画刷 + let brush = new drawing.Brush(); + // 设置填充颜色 + brush.setColor(0xFF, 0x00, 0xFF, 0x00); + // 设置画刷填充效果 + canvas.attachBrush(brush); + // 绘制路径 + canvas.drawPath(path); + // 去除填充效果 + canvas.detachBrush(); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_path] +} + +function drawRegion(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_region] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置颜色 + brush.setColor(0xFF, 0xFF, 0x00, 0x00); + // 设置画刷填充效果 + canvas.attachBrush(brush); + // 创建左上角的region1 + let region1 = new drawing.Region(); + region1.setRect(VALUE_100, VALUE_100, VALUE_600, VALUE_600); + // 创建右下角的region2 + let region2 = new drawing.Region(); + region2.setRect(VALUE_300, VALUE_300, VALUE_900, VALUE_900); + // 将两个区域以XOR的方式组合 + region1.op(region2, drawing.RegionOp.XOR); + // 绘制区域 + canvas.drawRegion(region1); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_region] +} + +function drawRect(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_rect] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置颜色 + brush.setColor(0xFF, 0xFF, 0x00, 0x00); + // 设置画刷填充效果 + canvas.attachBrush(brush); + // 绘制矩形 + canvas.drawRect(VALUE_200, VALUE_200, VALUE_1000, VALUE_700); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_rect] +} + +function drawRoundRect(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_round_rect] + // 创建画刷 + let brush = new drawing.Brush(); + // 设置颜色 + brush.setColor(0xFF, 0xFF, 0x00, 0x00); + // 设置画刷填充效果 + canvas.attachBrush(brush); + // 创建矩形对象 + let rect: common2D.Rect = { + left: VALUE_200, + top: VALUE_200, + right: VALUE_1000, + bottom: VALUE_700 + }; + console.info('rect:', rect.right); + // 创建圆角矩形对象 + let rrect = new drawing.RoundRect(rect, 30, 30); + // 绘制圆角矩形 + canvas.drawRoundRect(rrect); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_round_rect] +} + +// 自定义RenderNode +class MyRenderNode extends RenderNode { + private drawFunctions: ((canvas: drawing.Canvas) => void)[] = []; // 存储绘制函数的数组 + private currentDrawIndex: number = 0; // 当前绘制函数的下标 + + // 添加绘制函数的接口 + addDrawFunction(func: (canvas: drawing.Canvas) => void) { + this.drawFunctions.push(func); + } + + // 设置当前绘制函数的下标 + setDrawIndex(index: number) { + if (index >= 0 && index < this.drawFunctions.length) { + this.currentDrawIndex = index; + this.invalidate(); // 触发重绘 + } + } + + async draw(context: DrawContext) { + const canvas = context.canvas; + const drawFunction = this.drawFunctions[this.currentDrawIndex]; + if (drawFunction) { + drawFunction(canvas); + } + } +} + +// 自定义NodeController +class MyNodeController extends NodeController { + private myRenderNode = new MyRenderNode(); + private rootNode: FrameNode | null = null; + + constructor() { + super(); + // 添加绘制函数 + this.myRenderNode.addDrawFunction(drawPoint); + this.myRenderNode.addDrawFunction(drawArc); + this.myRenderNode.addDrawFunction(drawCircle); + this.myRenderNode.addDrawFunction(drawPath); + this.myRenderNode.addDrawFunction(drawRegion); + this.myRenderNode.addDrawFunction(drawRect); + this.myRenderNode.addDrawFunction(drawRoundRect); + } + + makeNode(uiContext: UIContext): FrameNode { + this.rootNode = new FrameNode(uiContext); + if (this.rootNode === null) { + return this.rootNode; + } + + const renderNode = this.rootNode.getRenderNode(); + if (renderNode !== null) { + this.myRenderNode.backgroundColor = 0xffffffff; // 白色背景 + this.myRenderNode.frame = { + x: 0, + y: 0, + width: 4800, + height: 4800 + }; + this.myRenderNode.pivot = { x: 0.2, y: 0.8 }; + this.myRenderNode.scale = { x: 1, y: 1 }; + renderNode.appendChild(this.myRenderNode); + renderNode.clipToFrame = true; + } + return this.rootNode; + } + + // 暴露设置绘制函数下标的方法 + setDrawIndex(index: number) { + this.myRenderNode.setDrawIndex(index); + } +} + +@Entry +@Component +struct ShapeDrawing { + private nodeController: MyNodeController = new MyNodeController(); + + build() { + Row() { + Column() { + // 将自定义NodeController进行显示 + NodeContainer(this.nodeController) + .width('100%') + .height('70%'); + Row() { + Button($r('app.string.Point')) + .onClick(() => { + this.nodeController.setDrawIndex(0); // 点击绘制点 + }); + Button($r('app.string.Arc')) + .onClick(() => { + this.nodeController.setDrawIndex(1); // 点击绘制圆弧 + }); + Button($r('app.string.Circle')) + .onClick(() => { + this.nodeController.setDrawIndex(2); // 点击绘制圆 + }); + Button($r('app.string.Path')) + .onClick(() => { + this.nodeController.setDrawIndex(3); // 点击绘制路径 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + + Row() { + Button($r('app.string.Region')) + .onClick(() => { + this.nodeController.setDrawIndex(4); // 点击绘制区域 + }); + Button($r('app.string.Rect')) + .onClick(() => { + this.nodeController.setDrawIndex(5); // 点击绘制矩形 + }); + Button($r('app.string.RoundRect')) + .onClick(() => { + this.nodeController.setDrawIndex(6); // 点击绘制圆角矩形 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + } + } + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/TextBlockDrawing.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/TextBlockDrawing.ets new file mode 100644 index 00000000..9bc8d6f0 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/drawing/pages/TextBlockDrawing.ets @@ -0,0 +1,180 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { UIContext, NodeController, FrameNode, RenderNode, DrawContext } from '@kit.ArkUI'; +import { common2D, drawing } from '@kit.ArkGraphics2D'; +import { VALUE_100, VALUE_200, VALUE_300, VALUE_900 } from '../../pages/Index'; + +function drawBaseText(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_base_text] + // 创建字型对象 + const font = new drawing.Font(); + // 设置字体大小 + font.setSize(100); + // 创建字块对象 + const textBlob = drawing.TextBlob.makeFromString('Hello world', font, drawing.TextEncoding.TEXT_ENCODING_UTF8); + // 绘制字块 + canvas.drawTextBlob(textBlob, VALUE_200, VALUE_300); + // [End arkts_graphics_draw_base_text] +} + +function drawStrokeText(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_stroke_text] + // 创建画笔 + let pen = new drawing.Pen(); + // 设置抗锯齿 + pen.setAntiAlias(true); + // 设置描边线宽 + pen.setStrokeWidth(3.0); + // 设置描边颜色 + pen.setColor(0xFF, 0xFF, 0x00, 0x00); + // 创建字型对象 + const font = new drawing.Font(); + // 设置字体大小 + font.setSize(100); + // 添加画笔描边效果 + canvas.attachPen(pen); + // 创建字块对象 + const textBlob = drawing.TextBlob.makeFromString('Hello world', font, drawing.TextEncoding.TEXT_ENCODING_UTF8); + // 绘制字块 + canvas.drawTextBlob(textBlob, VALUE_200, VALUE_300); + // 去除描边效果 + canvas.detachPen(); + // [End arkts_graphics_draw_stroke_text] +} + +function drawGradientText(canvas: drawing.Canvas) { + // [Start arkts_graphics_draw_gradient_text] + let startPt: common2D.Point = { x: VALUE_100, y: VALUE_100 }; + let endPt: common2D.Point = { x: VALUE_900, y: VALUE_900 }; + let colors = [0xFFFFFF00, 0xFFFF0000, 0xFF0000FF]; + // 创建线性渐变着色器 + let shaderEffect = drawing.ShaderEffect.createLinearGradient(startPt, endPt, colors, drawing.TileMode.CLAMP); + // 创建画刷 + let brush = new drawing.Brush(); + // 设置着色器 + brush.setShaderEffect(shaderEffect); + // 添加画刷填充效果 + canvas.attachBrush(brush); + // 创建字型 + const font = new drawing.Font(); + // 设置字体大小 + font.setSize(VALUE_200); + // 创建字块 + const textBlob = drawing.TextBlob.makeFromString('Hello world', font, drawing.TextEncoding.TEXT_ENCODING_UTF8); + // 绘制字块 + canvas.drawTextBlob(textBlob, VALUE_100, VALUE_300); + // 去除填充效果 + canvas.detachBrush(); + // [End arkts_graphics_draw_gradient_text] +} + +// 自定义RenderNode +class MyRenderNode extends RenderNode { + private drawFunctions: ((canvas: drawing.Canvas) => void)[] = []; // 存储绘制函数的数组 + private currentDrawIndex: number = 0; // 当前绘制函数的下标 + + // 添加绘制函数的接口 + addDrawFunction(func: (canvas: drawing.Canvas) => void) { + this.drawFunctions.push(func); + } + + // 设置当前绘制函数的下标 + setDrawIndex(index: number) { + if (index >= 0 && index < this.drawFunctions.length) { + this.currentDrawIndex = index; + this.invalidate(); // 触发重绘 + } + } + + async draw(context: DrawContext) { + const canvas = context.canvas; + const drawFunction = this.drawFunctions[this.currentDrawIndex]; + if (drawFunction) { + drawFunction(canvas); + } + } +} + +// 自定义NodeController +class MyNodeController extends NodeController { + private rootNode: FrameNode | null = null; + private myRenderNode = new MyRenderNode(); + + constructor() { + super(); + // 添加绘制函数 + this.myRenderNode.addDrawFunction(drawBaseText); + this.myRenderNode.addDrawFunction(drawStrokeText); + this.myRenderNode.addDrawFunction(drawGradientText); + } + + makeNode(uiContext: UIContext): FrameNode { + this.rootNode = new FrameNode(uiContext); + if (this.rootNode === null) { + return this.rootNode; + } + + const renderNode = this.rootNode.getRenderNode(); + if (renderNode !== null) { + this.myRenderNode.backgroundColor = 0xffffffff; // 白色背景 + this.myRenderNode.frame = { x: 0, y: 0, width: 4800, height: 4800 }; + this.myRenderNode.pivot = { x: 0.2, y: 0.8 }; + this.myRenderNode.scale = { x: 1, y: 1 }; + renderNode.appendChild(this.myRenderNode); + renderNode.clipToFrame = true; + } + return this.rootNode; + } + + // 暴露设置绘制函数下标的方法 + setDrawIndex(index: number) { + this.myRenderNode.setDrawIndex(index); + } +} + +@Entry +@Component +struct TextBlobDrawing { + private nodeController: MyNodeController = new MyNodeController(); + + build() { + Row() { + Column() { + // 将自定义NodeController进行显示 + NodeContainer(this.nodeController) + .width('100%') + .height('70%'); + Row() { + Button($r('app.string.BaseText')) + .onClick(() => { + this.nodeController.setDrawIndex(0); // 点击绘制基本文字 + }); + Button($r('app.string.StrokeText')) + .onClick(() => { + this.nodeController.setDrawIndex(1); // 点击绘制描边文字 + }); + Button($r('app.string.GradientText')) + .onClick(() => { + this.nodeController.setDrawIndex(2); // 点击绘制渐变文字 + }); + } + .justifyContent(FlexAlign.SpaceEvenly) + .width('100%') + .height('8%') + } + } + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/entryability/EntryAbility.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/entryability/EntryAbility.ets new file mode 100644 index 00000000..edc2839f --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/entryability/EntryAbility.ets @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { AbilityConstant, ConfigurationConstant, UIAbility, Want } from '@kit.AbilityKit'; +import { hilog } from '@kit.PerformanceAnalysisKit'; +import { window } from '@kit.ArkUI'; + +export default class EntryAbility extends UIAbility { + onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void { + this.context.getApplicationContext().setColorMode(ConfigurationConstant.ColorMode.COLOR_MODE_NOT_SET); + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate'); + } + + onDestroy(): void { + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onDestroy'); + } + + onWindowStageCreate(windowStage: window.WindowStage): void { + // Main window is created, set main page for this ability + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageCreate'); + + windowStage.loadContent('pages/Index', (err) => { + if (err.code) { + hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? ''); + return; + } + hilog.info(0x0000, 'testTag', 'Succeeded in loading the content.'); + }); + } + + onWindowStageDestroy(): void { + // Main window is destroyed, release UI related resources + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageDestroy'); + } + + onForeground(): void { + // Ability has brought to foreground + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onForeground'); + } + + onBackground(): void { + // Ability has back to background + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onBackground'); + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/entrybackupability/EntryBackupAbility.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/entrybackupability/EntryBackupAbility.ets new file mode 100644 index 00000000..b1e21294 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/entrybackupability/EntryBackupAbility.ets @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { hilog } from '@kit.PerformanceAnalysisKit'; +import { BackupExtensionAbility, BundleVersion } from '@kit.CoreFileKit'; + +export default class EntryBackupAbility extends BackupExtensionAbility { + async onBackup() { + hilog.info(0x0000, 'testTag', 'onBackup ok'); + } + + async onRestore(bundleVersion: BundleVersion) { + hilog.info(0x0000, 'testTag', 'onRestore ok %{public}s', JSON.stringify(bundleVersion)); + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/pages/Index.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/pages/Index.ets new file mode 100644 index 00000000..2f592b9d --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/pages/Index.ets @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import router from '@ohos.router'; +import { AdaptationUtil } from '../utils/AdaptationUtil'; + +// 示例代码默认设备为真机，所以在开发板上某些绘制结果显示不全 +// 通过设备宽度等比例缩放参数，以此适配开发板显示 +let adaptationUtil = new AdaptationUtil(); +export const VALUE_100 = adaptationUtil.getWidth(100); +export const VALUE_200 = adaptationUtil.getWidth(200); +export const VALUE_300 = adaptationUtil.getWidth(300); +export const VALUE_400 = adaptationUtil.getWidth(400); +export const VALUE_500 = adaptationUtil.getWidth(500); +export const VALUE_600 = adaptationUtil.getWidth(600); +export const VALUE_630 = adaptationUtil.getWidth(630); +export const VALUE_700 = adaptationUtil.getWidth(700); +export const VALUE_800 = adaptationUtil.getWidth(800); +export const VALUE_900 = adaptationUtil.getWidth(900); +export const VALUE_1000 = adaptationUtil.getWidth(1000); +export const VALUE_1800 = adaptationUtil.getWidth(1800); + +interface Item { + text: string; +} + +const operationUrls: string[] = [ + 'drawing/pages/CanvasGetResult', + 'drawing/pages/CanvasOperationState', + 'drawing/pages/BasicEffect', + 'drawing/pages/ComplexEffect', + 'drawing/pages/ShapeDrawing', + 'drawing/pages/PixelMapDrawing', + 'drawing/pages/TextBlockDrawing' +]; + +@Entry +@Component +struct Index { + ResourceToString(resource: Resource): string { + return getContext(this).resourceManager.getStringSync(resource); + } + + @State listItem: Item[] = [ + { text: this.ResourceToString($r('app.string.CanvasGetResult')) }, + { text: this.ResourceToString($r('app.string.CanvasOperationState')) }, + { text: this.ResourceToString($r("app.string.BasicEffect")) }, + { text: this.ResourceToString($r('app.string.ComplexEffect')) }, + { text: this.ResourceToString($r('app.string.Shape_Drawing')) }, + { text: this.ResourceToString($r("app.string.PixelMap_Drawing")) }, + { text: this.ResourceToString($r("app.string.TextBlock_Drawing")) } + ] + + build() { + Column() { + List() { + ForEach(this.listItem, (item: Item, index) => { + ListItem() { + Row() { + Blank().width('4%') + Text(item.text) + .fontSize(16) + .fontColor('black') + .width('90%') + Image($r('app.media.right')) + .height(12) + .width(12) + } + .onClick(() => { + router.pushUrl({ + url: operationUrls[index] + }); + }) + .border({ radius: 20 }) + .width('90%') + .height('8%') + .backgroundColor(Color.White) + .margin({ top: 12, left: 15, right: 8 }) + } + }) + } + .height('90%') + .width('100%') + } + .width('100%') + .height('100%') + .backgroundColor('#F1F3F5') + } +} diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/utils/AdaptationUtil.ets b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/utils/AdaptationUtil.ets new file mode 100644 index 00000000..2495dcfb --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/ets/utils/AdaptationUtil.ets @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { display } from '@kit.ArkUI'; + +export class AdaptationUtil { + private screenWidth = 0; + private screenHeight = 0; + private static readonly STANDARD_WIDTH = 1260; + private static readonly STANDARD_HEIGHT = 2720; + + constructor() { + let screenWidth = display.getDefaultDisplaySync().width; + let screenHeight = display.getDefaultDisplaySync().height; + this.screenWidth = Math.min(screenWidth, screenHeight); + this.screenHeight = Math.max(screenWidth, screenHeight); + console.info('screenWidth ', this.screenWidth.toString(), 'screenHeight ', this.screenHeight.toString()); + } + + public getWidth(width: number): number { + let realWidth: number = Math.floor(width * this.screenWidth / AdaptationUtil.STANDARD_WIDTH); + return realWidth; + } + + public getHeight(height: number): number { + let realHeight: number = Math.floor(height * this.screenWidth / AdaptationUtil.STANDARD_HEIGHT); + return realHeight; + } +} + diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/module.json5 b/Drawing/ArkTSGraphicsDraw/entry/src/main/module.json5 new file mode 100644 index 00000000..4144486d --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/module.json5 @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ + "module": { + "name": "entry", + "type": "entry", + "description": "$string:module_desc", + "mainElement": "EntryAbility", + "deviceTypes": [ + "default", + "tablet" + ], + "deliveryWithInstall": true, + "installationFree": false, + "pages": "$profile:main_pages", + "abilities": [ + { + "name": "EntryAbility", + "srcEntry": "./ets/entryability/EntryAbility.ets", + "description": "$string:EntryAbility_desc", + "icon": "$media:layered_image", + "label": "$string:EntryAbility_label", + "startWindowIcon": "$media:startIcon", + "startWindowBackground": "$color:start_window_background", + "exported": true, + "skills": [ + { + "entities": [ + "entity.system.home" + ], + "actions": [ + "action.system.home" + ] + } + ] + } + ], + "extensionAbilities": [ + { + "name": "EntryBackupAbility", + "srcEntry": "./ets/entrybackupability/EntryBackupAbility.ets", + "type": "backup", + "exported": false, + "metadata": [ + { + "name": "ohos.extension.backup", + "resource": "$profile:backup_config" + } + ] + } + ] + } +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/element/color.json b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/element/color.json new file mode 100644 index 00000000..3c712962 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/element/color.json @@ -0,0 +1,8 @@ +{ + "color": [ + { + "name": "start_window_background", + "value": "#FFFFFF" + } + ] +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/element/string.json b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/element/string.json new file mode 100644 index 00000000..530d0021 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/element/string.json @@ -0,0 +1,160 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "module description" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "ArkTSGraphicsDraw" + }, + { + "name": "CanvasGetResult", + "value": "画布的获取与绘制结果的显示" + }, + { + "name": "CanvasOperationState", + "value": "画布操作及状态处理" + }, + { + "name": "BasicEffect", + "value": "基础绘制效果" + }, + { + "name": "ComplexEffect", + "value": "复杂绘制效果" + }, + { + "name": "Shape_Drawing", + "value": "几何图形绘制" + }, + { + "name": "PixelMap_Drawing", + "value": "图片绘制" + }, + { + "name": "TextBlock_Drawing", + "value": "字块绘制" + }, + { + "name": "DirectCanvas", + "value": "获取直接画布绘图结果" + }, + { + "name": "OffScreenCanvas", + "value": "获取离屏画布绘图结果" + }, + { + "name": "ClipOperation", + "value": "裁剪操作" + }, + { + "name": "TranslationOperation", + "value": "平移操作" + }, + { + "name": "RotationOperation", + "value": "旋转操作" + }, + { + "name": "ScaleOperation", + "value": "缩放操作" + }, + { + "name": "StateOperation", + "value": "画布状态操作" + }, + { + "name": "Filling", + "value": "填充效果" + }, + { + "name": "Stroke", + "value": "描边效果" + }, + { + "name": "MixedMode", + "value": "混合模式" + }, + { + "name": "PathEffect", + "value": "路径效果" + }, + { + "name": "LinearGradient", + "value": "线性渐变" + }, + { + "name": "PathGradient", + "value": "径向渐变" + }, + { + "name": "SectorGradient", + "value": "扇形渐变" + }, + { + "name": "ColorFilter", + "value": "颜色滤波器" + }, + { + "name": "ImageFilter", + "value": "图像滤波器" + }, + { + "name": "MaskFilter", + "value": "蒙版滤波器" + }, + { + "name": "Point", + "value": "点" + }, + { + "name": "Arc", + "value": "圆弧" + }, + { + "name": "Circle", + "value": "圆" + }, + { + "name": "Path", + "value": "路径" + }, + { + "name": "Region", + "value": "区域" + }, + { + "name": "Rect", + "value": "矩形" + }, + { + "name": "RoundRect", + "value": "圆角矩形" + }, + { + "name": "PixelMap", + "value": "绘制图片" + }, + { + "name": "EditMiddlePixel", + "value": "编辑中间像素" + }, + { + "name": "BaseText", + "value": "基本文字" + }, + { + "name": "StrokeText", + "value": "文字描边" + }, + { + "name": "GradientText", + "value": "文字渐变" + } + ] +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/background.png b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/background.png new file mode 100644 index 0000000000000000000000000000000000000000..f939c9fa8cc8914832e602198745f592a0dfa34d GIT binary patch literal 57364 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 A4*&oF literal 0 HcmV?d00001 diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/foreground.png b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/media/foreground.png new file mode 100644 index 0000000000000000000000000000000000000000..4483ddad1f079e1089d685bd204ee1cfe1d01902 GIT binary patch literal 12430 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

c)ijgxDm}8EsRXFt3h@+Ufr7@DN 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 literal 0 HcmV?d00001 diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/profile/backup_config.json b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/profile/backup_config.json new file mode 100644 index 00000000..78f40ae7 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/profile/backup_config.json @@ -0,0 +1,3 @@ +{ + "allowToBackupRestore": true +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/profile/main_pages.json b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/profile/main_pages.json new file mode 100644 index 00000000..d703eb23 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/base/profile/main_pages.json @@ -0,0 +1,12 @@ +{ + "src": [ + "pages/Index", + "drawing/pages/CanvasGetResult", + "drawing/pages/CanvasOperationState", + "drawing/pages/BasicEffect", + "drawing/pages/ComplexEffect", + "drawing/pages/ShapeDrawing", + "drawing/pages/PixelMapDrawing", + "drawing/pages/TextBlockDrawing" + ] +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/dark/element/color.json b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/dark/element/color.json new file mode 100644 index 00000000..79b11c27 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/main/resources/dark/element/color.json @@ -0,0 +1,8 @@ +{ + "color": [ + { + "name": "start_window_background", + "value": "#000000" + } + ] +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/mock/mock-config.json5 b/Drawing/ArkTSGraphicsDraw/entry/src/mock/mock-config.json5 new file mode 100644 index 00000000..b9a78e20 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/mock/mock-config.json5 @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/test/Ability.test.ets b/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/test/Ability.test.ets new file mode 100644 index 00000000..1d8f5d71 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/test/Ability.test.ets @@ -0,0 +1,361 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { describe, it, expect } from '@ohos/hypium'; +import { Driver, ON } from '@ohos.UiTest'; +import Logger from '../utils/Logger'; +import { abilityDelegatorRegistry } from '@kit.TestKit'; +import { UIAbility, Want } from '@kit.AbilityKit'; + +const TAG = '[Sample_ArkTSGraphicsDraw]'; +const DELAY_SHORT = 400; +const DELAY_LONG = 1000; + +const delegator = abilityDelegatorRegistry.getAbilityDelegator(); +const bundleName = abilityDelegatorRegistry.getArguments().bundleName; + +function getString(resourceData: Resource): string { + let manage = delegator.getAppContext().resourceManager; + return manage.getStringSync(resourceData); +} + +export default function abilityTest() { + describe('ActsAbilityTest', () => { + /** + * @tc.number StartAbility_001 + * @tc.name StartAbility_001 + * @tc.desc 启动Ability + */ + it('ArkTSGraphicsDraw_StartAbility_001',0, async (done: Function) => { + console.info('StartAbility_001 begin'); + //start tested ability + const want: Want = { + bundleName: bundleName, + abilityName: 'EntryAbility' + }; + await delegator.startAbility(want); + let driver = Driver.create(); + await driver.delayMs(DELAY_LONG); + //check top display ability + const ability: UIAbility = await delegator.getCurrentTopAbility(); + console.info('get top ability'); + expect(ability.context.abilityInfo.name).assertEqual('EntryAbility'); + done(); + console.info('StartAbility_001 end'); + }) + + /** + * @tc.number:CanvasGetResult_001 + * @tc.name:CanvasGetResult_001 + * @tc.desc:直接画布与离屏画布的获取与绘制结果测试 + */ + it('ArkTSGraphicsDraw_CanvasGetResult_001', 0, async (done: Function) => { + Logger.info(TAG, 'CanvasGetResult_001 begin'); + let driver = Driver.create(); + let canvasGetResultStr = getString($r('app.string.CanvasGetResult')); + // 断言“画布的获取与绘制结果的显示”页面导航组件是否存在于主页上 + await driver.assertComponentExist(ON.text(canvasGetResultStr)); + // 获取该导航组件 + let canvasButton = await driver.findComponent(ON.text(canvasGetResultStr)); + // 点击导航组件，跳转至“画布的获取与绘制结果的显示”页面 + await canvasButton.click(); + await driver.delayMs(DELAY_LONG); + + await driver.assertComponentExist(ON.text(getString($r('app.string.DirectCanvas')))); + await driver.assertComponentExist(ON.text(getString($r('app.string.OffScreenCanvas')))); + + // 返回主页 + await driver.pressBack(); + done(); + Logger.info(TAG, 'CanvasGetResult_001 end'); + }); + + /** + * @tc.number:CanvasOperationState_001 + * @tc.name:CanvasOperationState_001 + * @tc.desc:画布操作与状态操作结果测试 + */ + it('ArkTSGraphicsDraw_CanvasOperationState_001', 0, async (done: Function) => { + Logger.info(TAG, 'CanvasOperationState_001 begin'); + let driver = Driver.create(); + let canvasOperationStr = getString($r('app.string.CanvasOperationState')); + await driver.assertComponentExist(ON.text(canvasOperationStr)); + let canvasOperationButton = await driver.findComponent(ON.text(canvasOperationStr)); + await canvasOperationButton.click(); + await driver.delayMs(DELAY_SHORT); + + let clipOperationStr = getString($r('app.string.ClipOperation')); + await driver.assertComponentExist(ON.text(clipOperationStr)); + let clipOperationButton = await driver.findComponent(ON.text(clipOperationStr)); + await clipOperationButton.click(); + await driver.delayMs(DELAY_SHORT); + + let translationOperationStr = getString($r('app.string.TranslationOperation')); + await driver.assertComponentExist(ON.text(translationOperationStr)); + let translationOperationButton = await driver.findComponent(ON.text(translationOperationStr)); + await translationOperationButton.click(); + await driver.delayMs(DELAY_SHORT); + + let rotationOperationStr = getString($r('app.string.RotationOperation')); + await driver.assertComponentExist(ON.text(rotationOperationStr)); + let rotationOperationButton = await driver.findComponent(ON.text(rotationOperationStr)); + await rotationOperationButton.click(); + await driver.delayMs(DELAY_SHORT); + + let scaleOperationStr = getString($r('app.string.ScaleOperation')); + await driver.assertComponentExist(ON.text(scaleOperationStr)); + let scaleOperationButton = await driver.findComponent(ON.text(scaleOperationStr)); + await scaleOperationButton.click(); + await driver.delayMs(DELAY_SHORT); + + let stateOperationStr = getString($r('app.string.StateOperation')); + await driver.assertComponentExist(ON.text(stateOperationStr)); + let stateOperationButton = await driver.findComponent(ON.text(stateOperationStr)); + await stateOperationButton.click(); + await driver.delayMs(DELAY_SHORT); + + await driver.pressBack(); + done(); + Logger.info(TAG, 'CanvasOperationState_001 end'); + }); + + /** + * @tc.number:BasicEffect_001 + * @tc.name:BasicEffect_001 + * @tc.desc:基础绘制效果结果测试 + */ + it('ArkTSGraphicsDraw_BasicEffect_001', 0, async (done: Function) => { + Logger.info(TAG, 'BasicEffect_001 begin'); + let driver = Driver.create(); + let basicEffectStr = getString($r('app.string.BasicEffect')); + await driver.assertComponentExist(ON.text(basicEffectStr)); + let basicEffectButton = await driver.findComponent(ON.text(basicEffectStr)); + await basicEffectButton.click(); + await driver.delayMs(DELAY_SHORT); + + let fillingStr = getString($r('app.string.Filling')); + await driver.assertComponentExist(ON.text(fillingStr)); + let fillingButton = await driver.findComponent(ON.text(fillingStr)); + await fillingButton.click(); + await driver.delayMs(DELAY_SHORT); + + let strokeStr = getString($r('app.string.Stroke')); + await driver.assertComponentExist(ON.text(strokeStr)); + let strokeButton = await driver.findComponent(ON.text(strokeStr)); + await strokeButton.click(); + await driver.delayMs(DELAY_SHORT); + + await driver.pressBack(); + done(); + Logger.info(TAG, 'BasicEffect_001 end'); + }); + + /** + * @tc.number:ComplexEffect_001 + * @tc.name:ComplexEffect_001 + * @tc.desc:复杂绘制效果结果测试 + */ + it('ArkTSGraphicsDraw_ComplexEffect_001', 0, async (done: Function) => { + Logger.info(TAG, 'ComplexEffect_001 begin'); + let driver = Driver.create(); + let complexEffectStr = getString($r('app.string.ComplexEffect')); + await driver.assertComponentExist(ON.text(complexEffectStr)); + let complexEffectButton = await driver.findComponent(ON.text(complexEffectStr)); + await complexEffectButton.click(); + await driver.delayMs(DELAY_SHORT); + + let mixedModeStr = getString($r('app.string.MixedMode')); + await driver.assertComponentExist(ON.text(mixedModeStr)); + let mixedModeButton = await driver.findComponent(ON.text(mixedModeStr)); + await mixedModeButton.click(); + await driver.delayMs(DELAY_SHORT); + + let pathEffectStr = getString($r('app.string.PathEffect')); + await driver.assertComponentExist(ON.text(pathEffectStr)); + let pathEffectButton = await driver.findComponent(ON.text(pathEffectStr)); + await pathEffectButton.click(); + await driver.delayMs(DELAY_SHORT); + + let linearGradientStr = getString($r('app.string.LinearGradient')); + await driver.assertComponentExist(ON.text(linearGradientStr)); + let linearGradientButton = await driver.findComponent(ON.text(linearGradientStr)); + await linearGradientButton.click(); + await driver.delayMs(DELAY_SHORT); + + let pathGradientStr = getString($r('app.string.PathGradient')); + await driver.assertComponentExist(ON.text(pathGradientStr)); + let pathGradientButton = await driver.findComponent(ON.text(pathGradientStr)); + await pathGradientButton.click(); + await driver.delayMs(DELAY_SHORT); + + let sectorGradientStr = getString($r('app.string.SectorGradient')); + await driver.assertComponentExist(ON.text(sectorGradientStr)); + let sectorGradientButton = await driver.findComponent(ON.text(sectorGradientStr)); + await sectorGradientButton.click(); + await driver.delayMs(DELAY_SHORT); + + let colorFilterStr = getString($r('app.string.ColorFilter')); + await driver.assertComponentExist(ON.text(colorFilterStr)); + let colorFilterButton = await driver.findComponent(ON.text(colorFilterStr)); + await colorFilterButton.click(); + await driver.delayMs(DELAY_SHORT); + + let imageFilterStr = getString($r('app.string.ImageFilter')); + await driver.assertComponentExist(ON.text(imageFilterStr)); + let imageFilterButton = await driver.findComponent(ON.text(imageFilterStr)); + await imageFilterButton.click(); + await driver.delayMs(DELAY_SHORT); + + let maskFilterStr = getString($r('app.string.MaskFilter')); + await driver.assertComponentExist(ON.text(maskFilterStr)); + let maskFilterButton = await driver.findComponent(ON.text(maskFilterStr)); + await maskFilterButton.click(); + await driver.delayMs(DELAY_SHORT); + + await driver.pressBack(); + done(); + Logger.info(TAG, 'ComplexEffect_001 end'); + }); + + /** + * @tc.number:ShapeDrawing_001 + * @tc.name:ShapeDrawing_001 + * @tc.desc:几何形状绘制结果测试 + */ + it('ArkTSGraphicsDraw_ShapeDrawing_001', 0, async (done: Function) => { + Logger.info(TAG, 'ShapeDrawing_001 begin'); + let driver = Driver.create(); + let shapeDrawingStr = getString($r('app.string.Shape_Drawing')); + await driver.assertComponentExist(ON.text(shapeDrawingStr)); + let shapeDrawingButton = await driver.findComponent(ON.text(shapeDrawingStr)); + await shapeDrawingButton.click(); + await driver.delayMs(DELAY_SHORT); + + let pointStr = getString($r('app.string.Point')); + await driver.assertComponentExist(ON.text(pointStr)); + let pointButton = await driver.findComponent(ON.text(pointStr)); + await pointButton.click(); + await driver.delayMs(DELAY_SHORT); + + let arcStr = getString($r('app.string.Arc')); + await driver.assertComponentExist(ON.text(arcStr)); + let arcButton = await driver.findComponent(ON.text(arcStr)); + await arcButton.click(); + await driver.delayMs(DELAY_SHORT); + + let circleStr = getString($r('app.string.Circle')); + await driver.assertComponentExist(ON.text(circleStr)); + let circleButton = await driver.findComponent(ON.text(circleStr)); + await circleButton.click(); + await driver.delayMs(DELAY_SHORT); + + let pathStr = getString($r('app.string.Path')); + await driver.assertComponentExist(ON.text(pathStr)); + let pathButton = await driver.findComponent(ON.text(pathStr)); + await pathButton.click(); + await driver.delayMs(DELAY_SHORT); + + let regionStr = getString($r('app.string.Region')); + await driver.assertComponentExist(ON.text(regionStr)); + let regionButton = await driver.findComponent(ON.text(regionStr)); + await regionButton.click(); + await driver.delayMs(DELAY_SHORT); + + let rectStr = getString($r('app.string.Rect')); + await driver.assertComponentExist(ON.text(rectStr)); + let rectButton = await driver.findComponent(ON.text(rectStr)); + await rectButton.click(); + await driver.delayMs(DELAY_SHORT); + + let roundRectStr = getString($r('app.string.RoundRect')); + await driver.assertComponentExist(ON.text(roundRectStr)); + let roundRectButton = await driver.findComponent(ON.text(roundRectStr)); + await roundRectButton.click(); + await driver.delayMs(DELAY_SHORT); + + await driver.pressBack(); + done(); + Logger.info(TAG, 'ShapeDrawing_001 end'); + }); + + /** + * @tc.number:PixelMapDrawing_001 + * @tc.name:PixelMapDrawing_001 + * @tc.desc:图片绘制结果测试 + */ + it('ArkTSGraphicsDraw_PixelMapDrawing_001', 0, async (done: Function) => { + Logger.info(TAG, 'PixelMapDrawing_001 begin'); + let driver = Driver.create(); + let pixelMapDrawingStr = getString($r('app.string.PixelMap_Drawing')); + await driver.assertComponentExist(ON.text(pixelMapDrawingStr)); + let pixelMapDrawingButton = await driver.findComponent(ON.text(pixelMapDrawingStr)); + await pixelMapDrawingButton.click(); + await driver.delayMs(DELAY_SHORT); + + let pixelMapStr = getString($r('app.string.PixelMap')); + await driver.assertComponentExist(ON.text(pixelMapStr)); + let pixelMapButton = await driver.findComponent(ON.text(pixelMapStr)); + await pixelMapButton.click(); + await driver.delayMs(DELAY_SHORT); + + let editMiddlePixelMapStr = getString($r('app.string.EditMiddlePixel')); + await driver.assertComponentExist(ON.text(editMiddlePixelMapStr)); + let editMiddlePixelMapButton = await driver.findComponent(ON.text(editMiddlePixelMapStr)); + await editMiddlePixelMapButton.click(); + await driver.delayMs(DELAY_SHORT); + + await driver.pressBack(); + done(); + Logger.info(TAG, 'PixelMapDrawing_001 end'); + }); + + /** + * @tc.number:TextBlockDrawing_001 + * @tc.name:TextBlockDrawing_001 + * @tc.desc:字块绘制结果测试 + */ + it('ArkTSGraphicsDraw_TextBlockDrawing_001', 0, async (done: Function) => { + Logger.info(TAG, 'TextBlockDrawing_001 begin'); + let driver = Driver.create(); + let textBlockDrawingStr = getString($r('app.string.TextBlock_Drawing')); + await driver.assertComponentExist(ON.text(textBlockDrawingStr)); + let textBlockDrawingButton = await driver.findComponent(ON.text(textBlockDrawingStr)); + await textBlockDrawingButton.click(); + await driver.delayMs(DELAY_SHORT); + + let baseTextStr = getString($r('app.string.BaseText')); + await driver.assertComponentExist(ON.text(baseTextStr)); + let baseTextButton = await driver.findComponent(ON.text(baseTextStr)); + await baseTextButton.click(); + await driver.delayMs(DELAY_SHORT); + + let strokeTextStr = getString($r('app.string.StrokeText')); + await driver.assertComponentExist(ON.text(strokeTextStr)); + let strokeTextButton = await driver.findComponent(ON.text(strokeTextStr)); + await strokeTextButton.click(); + await driver.delayMs(DELAY_SHORT); + + let gradientTextStr = getString($r('app.string.GradientText')); + await driver.assertComponentExist(ON.text(gradientTextStr)); + let gradientTextButton = await driver.findComponent(ON.text(gradientTextStr)); + await gradientTextButton.click(); + await driver.delayMs(DELAY_SHORT); + + await driver.pressBack(); + done(); + Logger.info(TAG, 'TextBlockDrawing_001 end'); + }); + }) +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/test/List.test.ets b/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/test/List.test.ets new file mode 100644 index 00000000..1eac52fc --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/test/List.test.ets @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import abilityTest from './Ability.test'; + +export default function testsuite() { + abilityTest(); +} \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/utils/Logger.ets b/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/utils/Logger.ets new file mode 100644 index 00000000..5320999d --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/ets/utils/Logger.ets @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import hilog from '@ohos.hilog'; + +class Logger { + private domain: number = 0xF811; + private prefix: string = ''; + private format: string = '%{public}s, %{public}s'; + + constructor(prefix: string) { + this.prefix = prefix; + this.domain = 0xF811; + } + + debug(...args: string[]): void { + hilog.debug(this.domain, this.prefix, this.format, args); + } + + info(...args: string[]): void { + hilog.info(this.domain, this.prefix, this.format, args); + } + + warn(...args: string[]): void { + hilog.warn(this.domain, this.prefix, this.format, args); + } + + error(...args: string[]): void { + hilog.error(this.domain, this.prefix, this.format, args); + } +} + +export default new Logger('[Sample_ArkTSGraphicsDraw]'); \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/module.json5 b/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/module.json5 new file mode 100644 index 00000000..c3fd9dda --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/entry/src/ohosTest/module.json5 @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ + "module": { + "name": "entry_test", + "type": "feature", + "deviceTypes": [ + "default", + "tablet" + ], + "deliveryWithInstall": true, + "installationFree": false + } +} diff --git a/Drawing/ArkTSGraphicsDraw/hvigor/hvigor-config.json5 b/Drawing/ArkTSGraphicsDraw/hvigor/hvigor-config.json5 new file mode 100644 index 00000000..d584c19c --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/hvigor/hvigor-config.json5 @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ + "modelVersion": "5.0.1", + "dependencies": { + }, + "execution": { + // "analyze": "normal", /* Define the build analyze mode. Value: [ "normal" | "advanced" | false ]. Default: "normal" */ + // "daemon": true, /* Enable daemon compilation. Value: [ true | false ]. Default: true */ + // "incremental": true, /* Enable incremental compilation. Value: [ true | false ]. Default: true */ + // "parallel": true, /* Enable parallel compilation. Value: [ true | false ]. Default: true */ + // "typeCheck": false, /* Enable typeCheck. Value: [ true | false ]. Default: false */ + }, + "logging": { + // "level": "info" /* Define the log level. Value: [ "debug" | "info" | "warn" | "error" ]. Default: "info" */ + }, + "debugging": { + // "stacktrace": false /* Disable stacktrace compilation. Value: [ true | false ]. Default: false */ + }, + "nodeOptions": { + // "maxOldSpaceSize": 8192 /* Enable nodeOptions maxOldSpaceSize compilation. Unit M. Used for the daemon process. Default: 8192*/ + // "exposeGC": true /* Enable to trigger garbage collection explicitly. Default: true*/ + } +} diff --git a/Drawing/ArkTSGraphicsDraw/hvigorfile.ts b/Drawing/ArkTSGraphicsDraw/hvigorfile.ts new file mode 100644 index 00000000..2a5e543f --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/hvigorfile.ts @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { appTasks } from '@ohos/hvigor-ohos-plugin'; + +export default { + system: appTasks, /* Built-in plugin of Hvigor. It cannot be modified. */ + plugins:[] /* Custom plugin to extend the functionality of Hvigor. */ +} diff --git a/Drawing/ArkTSGraphicsDraw/oh-package.json5 b/Drawing/ArkTSGraphicsDraw/oh-package.json5 new file mode 100644 index 00000000..e41bae02 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/oh-package.json5 @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +{ + "modelVersion": "5.0.1", + "description": "Please describe the basic information.", + "dependencies": { + }, + "devDependencies": { + "@ohos/hypium": "1.0.19", + "@ohos/hamock": "1.0.0" + } +} diff --git a/Drawing/ArkTSGraphicsDraw/ohosTest.md b/Drawing/ArkTSGraphicsDraw/ohosTest.md new file mode 100644 index 00000000..19d70b92 --- /dev/null +++ b/Drawing/ArkTSGraphicsDraw/ohosTest.md @@ -0,0 +1,14 @@ +# ArkTSGraphicDraw测试用例归档 + +## 用例表 + +| 测试功能 | 预置条件 | 输入 | 预期输出 | 是否自动 | 测试结果 | +| ---------------------- | ------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------ | -------- | -------- | +| 拉起应用 | 设备正常运行 | | 成功拉起应用 | 是 | Pass | +| 画布获取功能 | 进入“画布的获取与绘制结果的显示”页面 | | 页面显示“获取直接绘图结果”与“获取离屏画布绘图结果” | 是 | Pass | +| 画布操作及状态处理功能 | 进入“画布操作及状态处理”界面 | 依次点击裁剪操作、平移操作、旋转操作、缩放操作、画布状态操作五个按钮 | 在每个按钮点击后，绘制出对应的操作结果图案 | 是 | Pass | +| 基础绘制效果功能 | 进入“基础绘制效果”界面 | 依次点击填充效果、描边效果两个按钮 | 页面显示填充效果图案、描边效果图案 | 是 | Pass | +| 复杂绘制效果功能 | 进入“复杂绘制效果”界面 | 依次点击混合模式、路径效果、线性渐变、径向渐变、扇形渐变、颜色滤波器、图像滤波器、蒙版滤波器八个按钮 | 在每个按钮点击后，绘制出对应的绘制效果图案 | 是 | Pass | +| 几何图形绘制功能 | 进入“几何图形绘制”界面 | 依次点击点、圆弧、圆、路径、区域、矩形、圆角矩形七个按钮 | 在每个按钮点击后，绘制出对应的图案 | 是 | Pass | +| 图片绘制功能 | 进入“图片绘制”界面 | 依次点击绘制图片、编辑中间像素两个按钮 | 先绘制出一幅矩形像素图，而后像素图中间的像素变为黑白色 | 是 | Pass | +| 字块绘制功能 | 进入“字块绘制”界面 | 依次点击基本文字、文字描边、文字渐变三个按钮 | 依次绘制出基本文字图案、描边文字图案和渐变文字图案 | 是 | Pass | \ No newline at end of file diff --git a/Drawing/ArkTSGraphicsDraw/screenshot/canvas.jpeg b/Drawing/ArkTSGraphicsDraw/screenshot/canvas.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..e84db1b598db79ea066c5893351bbff812ca7e6d GIT binary patch literal 30747 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 MQt(&SgW-n$A5R$MX8-^I literal 0 HcmV?d00001 diff --git a/Drawing/ArkTSGraphicsDraw/screenshot/effect.jpeg b/Drawing/ArkTSGraphicsDraw/screenshot/effect.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..c9b0d49b5ded04df66b99cde18916224ee267b34 GIT binary patch literal 47056 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 b7wf>9|Cplair8Uc`E_5ZpbuyOTiU?(TG>jsH8d zyEDI;|J(O=-`h8D_U+vM)a|-m)%SDHxpk_Jd`~^jKCS{!Udk!T0dQ~t00;X3j|+ed zfQpQaf{cWUf`WpEhKi1fkA;bWfk}e*6bGMzl!}sql$@NJo`Z>+mW_^_oLS%*+jA~n zUS29DAu&O2Q4Stn?%y|oLqkKu#K0uR!XoCTA*bQ~PalsR04^#L06&TVM+?B?!Xej4LkfQW>Qf{KQY0qaov1b~M_K!8U?Kte)9g!T4?wF8K_NO&|{ zQpiu$-=feu;&XqD%|fMTnlaA9=8BO)RoqWq={4&EJB5O5KZXt>DJ-r65OxCmF6GyEwLT8n=LwW0Vmb)-x zGD9P)hcug!}8g*KJ>{KllG0Y39{zNi2c4v1oMAUS-mq^ zANE$QZcBYR;q%#m361?|^byciLh7+yG`|pa&BQ*92(*p0d&@A9(-2KZqdUVkOVU9x z>{yr12tn$PtSJ%siF$sEF_{pDB9c#|`9=2;z!BUyNCA$m$~AN*`Mf~{;EW~k@0fx(FRvl%yfUB8 z{0L;dn|TC~%^rcMvHPO+m>WVnfABjA=n{f3DJzrQwE5(_=9;D|Tag3lw)c!u)ZLgR ztk{{WmlRmGYH+gnGpNwao*^FD?zt^m-_lM7f(?|2QyO_bGG%R&-Ynt8iCih znX6ADUCNX-dURA>^K`8o7X}@RURWxYJ8$JmB7DbI6xx%dU?%`sH7y+`-6STL%EB+r zX1}zkU3{%Di-(Frj~ktlAn+PusP5r4p*~?Mz`c)GO6WL%Ztq5qHMa>D=#S$C?CzGE z{?wa(UwdoBWD-4)y6IMz4*Fm;#68eiz3|04i8LnSc&9a9=|@%I^t4V)*P<9I zu2jfgGiTAI_{5V0?K%x@a3ejfdQa;@28%x)n4KJFG8@fJxv@kTLVfE^rGBB8mv_@Ut4t1$}(-u z!AJ7$qC%mUvL-*y`VSZnyM%KAnp zjJL%0T`c-aNrczx3zjOe~$XXir9sT!U~?9=Rt|F_7QjkeFQGkoaePa zGS=rp18o^kFO=BdSs!kZKiNQW7~MGQb+20{zZHnA@R7PKTd}U!6^-E}bF5FB+c~~* zFYs{gUIE8Mz3?po-C8UxJ_02R)$ZU6p&N)KxuM%lSh&lQNzctviNSq_N(u(6HsX76 zy%k2Bq5-P=w?>u${+qJn5(hC4zicfvsvpM2E7*KMoJY?^MIdR-Un4i#^(!*1O=i6a z@{@Nw9|23{^moI}jZFC}!Z)KxcFx`WH|JwYd=EMAO6dNvuspJ^f$q5oGB`$y^h&(>Mvps9}l z{jJ7L?<0`&x@mp@A|Cz-pizY#yHwQpW`O2ymr^f}-Yjv8aZLyC(LMsNGmaxRYb&mw zwGlr8N-Llz2?TdChsBQNu~D%mb0%lPu(p2F8U22FCDUK@#S&0Qsm>gUxmS&G!}2aurN{Ddh)Q;EFNth zySnIzZ9#uN_|;I|A;b9iIp-%N>F(Z20*WQ@2oP!8I7&P*8f$r}o~(MObd5rFHr;Am zd2YnGJ+yxL2&gqiuRnkbzL_e=W@pl9Nzq@4#xK_~1I1o7s^U?;_>#$#%d%=>FTb#C z;luUp&8Xo7Wt;xoDo>)Nx(ZC7J6o^Hu1eC%=t_C|>XLhYPsz)EUGUq7r$1#DRw`cZ z<$^grvri2CbYfpN5jqS$WS=|x{&jB#T!v-VJxx0H@ffkv&>-$@L;aV2de4JUd^ix) zixVn;XH;VSdQogA)u#T)lXI9KZmtsK<4TMWq58yzfBv(Fl1`n|G-nYr_K;2@CLHzo zCh2aCKhErKsAc_GZo~H=zTTctMf(0%l_kQ7$<`%%r?V^44E0}}8vD3L1BG!V$**9; z%X=L*rX|1sybQOXc9T_6R$Lb|-rhd+aDMT|m1KekG-XFC22&tvm!z^A z%k)V)0`Jpx(~q55i~U`mj%rasCC_V{8X6-`G(!!NxL=yKx-9!bE;6x(S(WR@&P(jX zCvmZw5DhQHb8qA0p;JRe1=f(gL|Z%ZnWrpq?u#$Y{d_@u_WzBQf0*IIl7ZlIk@Skk{7VVmed&r|&V-MEfC#Mpo~SnDM=JW5Z|0hgyw^K zmPH_a1(~`ldzW>TR1HgPQ)D0$(W&8A${;&N_qsob?VkkkrW*MAtNieF?}Jx3%xbMRC^?*8 zmaTLLf~b+`;e&5n@!|ISbSGB_GH;%~tfIT0(Y_&{3HJcK03S+_D49U@Z}lQhCjiY^^Iv9Qi<(qe*%t5W@avy3>oQs~8CY<|Fo0E;@VNSm zqg9v@c5ecYFUPxZ`L=%Xj}f9%TElZ}bdZP*dnP928SbtSp0{#?dLF1J%aD`VFMfH2 zTqmP4{ft2XTpK-}j76{xOH|+K zJOZ*_{f__=|H_?_t%p;0k8P%x zM6uN^lVM#N$c79yPZB>tc?ASz32w&ms7{IMiW<3EtX1GH&+gU{F3?Xed%l3**An6f zhY2wg`wSm-?tQ_r2(>DI6YasE_%>FC{!?ed*Hcuw!rT;(vh_H`>$Nh62i(sFyS4r}%7UbJN0HeZhjujd2E#RRIW%>Zhd5aaK^q5CO%Tg) zSGWxd&X>28UvFFpbLBFp zMBU+yadsf+(LPlrReo+p{(hBbqZ~ye@+{(%Gi-kHbMEdBi5?^2Bf0N|Dct%!aam8m zsonNNW)nf zoYNzCCNo|dq<&*NvS@5frU}I7q_29eC5u2G=LN9#x0r1lAwAHrc}1<|x{BQEvjhpCF=cgu8U zgqb(#tf?Ny)UgbqS~%pNoJw=epLhqdygUT~{iQ$Ou7TTe-*edYma@6zRtEi=ee#rY z^|lIyq|c*x1^=+U#>aonKzl5En&7B>uqN^BaA+3Q$)rw9WE7=b-2|rLckvP3v3-2| z2%sW`t{ldQ+=|?K9D>qfM27oK*5+co4j+j0{4IT?AhN}~V^;fhb-DVoo|g$EOJ^uo z=b1Q~ZIkb7emXk(yCan{ba}=r;JQBz;P#GJEVR+qSI%mh1-P9$m`PXQhN^7uFZ6cdnCo2}A20u#4&-41g0e}Xy0OItg(?~9 zp{lDQD%+HFRIy$Zk=y8fJGKWXY(Mi0`(LgkZ+Wc1T-mc!7H2KZX^(*Q(iKnSwa1Rb z63FI~-Lk`ZUz{n`_y>eBE6)&QpLoh%MT1$aNaaDLANKIX$p0aNu<;S_%X$RXtq_vH zE>HEL)g2!UUqF;$Ze*QkS(YJpPDIMk!aFJOc10PqK)M0)YOF5Vu{-cPqP zR_pq3Z=A0k@cXE6RoL=O`QkNjTcjslD=2z*3gE;9BX{U+5|ictUREzL9Mr@n_l-_2r*3Vm?bZig*be`$O9j!Z*;NmicFIg>w){}_?c+eQgttRNW4$hPsaPs?AC99z0h4B2Lz!yb}C zU{D}G>(>X?M7;|ZY^ZQdA!Ii5GneVjcJCACeFT2}_{m$C^X79tSDgHGogblxTi=27 zcx~|1#f0}etk&VLGsk1H+*r|};sNdmKYHz~+HsJQKC!#9tE$^Vc}rYs$BtgwDQRk= z8%ExZle<0w2c{EHZd*<=&QC643bXw#D-gb_XHBf72w@0N6TuzG#Q+M^`cASR&kMUd zb(AnYQIVwP6v6KVxAKcUVF+T*Gh4;}*e5P_W>OGPm@AeW##}k)iDmjOwG=%PF6Nz2 zrX^F*`FisSREH8DE9c5K&S{psn|Z=1Sb`!+3PDt=+3GEwO-wt>YeAsopSR#)t~OZrHG zuJw`co9d`e2a^hj0m_wtejQ0ly8Gm{j2k-Pnfqaei1l-#{0_g(InAjrlt;=<%<=Q=w_XAKUzjfTx@;?kawWyz23B6T`&L=}h^aaY_>Z23~)JlRrPLydr0wE5C3($lMBc9&ZvoGq3EUe*m`)O+H z)woEj6OVbmn_p!jLtmftu&-m3;7{DqIZ))5Q0At1zpQ4|aRRF$bgrHsoanX*$7{7s z-D%|Qd0B?`)}|+1mV{TZlN9)KQMpZPM6EpQq$_i2au0B*sUR`%h~~swURo4=hjGyo zEviZ=u9ijcLFUcoPRzibO**bY(VeWX!w1>ziv0Uv`tNeVtRX@OVkYUW%m^SKGXAoH z7!2$A(6qG)+rr%nv6{=oQVvaeX1OaSvQLh2C``N_Qj{X?!G-%nUES(KKRT&sXROyM z018@PDz&yLj&g^ZBR;n5Fb{q(6+7-PGb>Xxm7Vr2?9?@X{3VZ{Dlv~n=uW7 zjYWIgaf2M=_1?TWbiboSP^}YnWGr%Xa#>=+;pCX1WlEH1?dLE{uVUzdTDwOC4T77b zA+~%)p2?UfQt_U|6Eg_X%qM$31B;22nfvE4e7X(x`~l4#H`^74J`#0PEwYRy>sWFJ zIv*L%*v_xPb<+nJOQNiHgH=n%40azO`m$4k(WBiE6v2-WN+^qz|5Af+t3*cXZA$HEf8I0k8W~ zDkn{3aL4Zv5L8V6wh+xyYJzikzJe=XvP*R3CEb#(^png9t9Ibz8wg#s@WE#kg_SDI za^``%fA#eWMa+4=Nm;4G>sLDK6yFk2@0m4L5gRM-Gc)pzYwKE1=VMjCwaf$)s=d+m zfaQy~pvk@DcO7?;iSRy-@XZ3ZRHvB8dVtX9<|t{{I*rn;=xWPlS@_xZ+TL!e8_^8C z0?{&}dczSGzC=q8BMLuHB|E`cMy?I?H2tZ+#D!=t)Heg*6qYnG1@Sf98K8XfQCw%f z5IVA3UY=%t--AJUD!|n#BuHGuXM*D~a;27{s7M>UP zVakN@u+sbFut9uMRQ}RI1jRjJ=Ws4VxkaZC%Et?BaW2z`nkoLM9xcr=@NWKO+HGhQ zlvXU&_XH28v6K_4Y0UJ{Ei7@zgzNid*|#C)Faea>?B?8_f9!ZKSYDw7K8ZZ6Sc}`} zo#xT^>{9wfJ2prQ|Ud_-4KKBW)%(>oEb>A=~B=pr6j?jM{Ms*FGQ!$p`_3T7Q z_dJOJHU6lEO)^&&RCCm`KB9*@KZ!vZGsNX7IA{jeP0`JzdsXe1(}lqpsX5!I3Wh9& zhXDbO4+tcbl;EUKIgn~-M$de0)Kr&lDltt}Kz4BwrXt9%J);(&B%GdW(JF%48vm%Q zpJpdt)K^5L!P}nANSF{3G7h%9COs~p(g2U7me_h}SAK|NKmK+&s`&JX{&}Z%zt-hL za8Tu6yOaLbz4RZsmUVSSN~lQ^;AZ>K$Ng)mSbu1$M)2bEXBlUn`xIoh>5bz7@2BTG zXGfAG;!hRx+S=OcLdsmiN8Z-kANBu2u@5UC-}tVhqflHJ@hMA74nP3V^?_$`uoxZh zjd}b2Frb|s@$Azd14B;af_yebQ-upoJMCUF6#sypu0JdA>c2jGyC`C5DQo;8j1ELc zFy~YM5%f?%hcARb&kR4_@HSSZ_{|q5ECt55Gss_l;%kcg-%6BG{yqW9vNAi5K=sYo zpU$I*lmBe|AIk)3OR>ZpYm%lEAWqRg#9uh{Z)D>ya`Kf`K++11x!_v$eq}o5*(1<= zGm7xf%YSm?-yaO$7X7h!^8VzB|5KpqU%m2ws%PST5FXe16mPS6!3)q!d5WgQMLfg& z%W(T^6wd#bzds|9!Iovmhci|fauOn-Fr=eHE^az}?{@S`#_A71q2G_FMfMH7{*R6g zB!Ye$N=ArlU4f&W#j1R3pa88;WjTMc#d!L2;hr8%d*koCk;93aVPA@`)I+#0?BB> z59)6P+<0~3q0SrcqC9SL=WBbuEZkQnsVbDdd-ogw-dP};e}^m(jPE@H1fmQ@`}~)L z^-0Q(ja`E3TBTTY2@+UB*?!0Uo&D}?dFa;DB@{uT&fYmv2% z+q_NfcidNu6DNKXWGD1yZes(z#*m5#OYkPCAt52eaNjHK+$|BTpn&-Ftg>Gaq5VB9 zaKT(5HvPc7*F@E04!%D+N-GN{d}rIZtgEQ&GIYQctwpidq#u&fgWA8u~Ua3;$2wjIXL=be6TFWA;ULpzlkWM1@Y)mu*Tx^;`8S)DbNmFa^%QU0zTZm$fTxg6?hM1CtsZ5Jstj$$hZ3RCqc)aI`p;=0u{K$!mNv}%kul8 zFhhS74fjx`f_mF%VsC{|ncZj`L%w_EM?QUlh48v+l4;_7ZXr_2(U2L%-E&WWL+M+^bAU;o~DYByAU?$c}*3hX3M){nBy_}zG4!FvWym1WGGVep| z`7tYFIM4v+@xp!or>+J{!;Wk|G<-{SpD{Izl^9N?$4Yt_wosX<&7Yv{Nm9nhe()lS zxlooj9_L+B?K;ZuFEJ1su6YC;6zgdV9hyq|F@-nE+`s)JGci5icDnw`^GuB2vljvW1`AG}(yOF} zj{~=1%+KJX2tf>#q9loly|7uwPRsFkc>f3lKh;0=Un9SjpSwzXus?x9`;)I6`*<=g zZJQx3)7p=~6H!IGlFnibEDgEPQB@18(=SeQoj~O3G|HXA!`x*%RME$I=RW38(FYYL0aw|c!0+E)L(8S7_IAhMThA8S6uKQyPl4cu+j zq=*4C!N}d~qwH`62YkncD5|{DVWWOPc^!wu>fsqUG}(GJ`H(trd7GIxcRJ^pM+xa^ zk56X7@^y8bictAUw;$isg({KK+LA-pj$D%gPW>~1J;z4Tj-X>qZ0D7F6`O*H#eRro z#|ZBCQqow|R)Z_0j;q2JA^xm&oQNb!T3-~+@k81%?GAsdE?W2ak(Ca_O|w?O>E<|R zO#~FBZ&8<)Ww3w6RSL1eHJGF6*_w3t@&owVjkmY~DfXf}@XBw_S1Q@7HUv4@t7Inm zkw){zytg+KcZ}I)2z0+J&(NQC@otZ(8#7p{TM~HL{xHfPv24-ya`P@nq$!=-Ibu~* zFKa&~BdAu)jY7VsZkaOp1$B_tBz>IHwsow`x4|yz5jjsLR+;aIW*>;& zkw<@MoAQ?#KW^b#zcu3NxdBBm#VJ)l6IU><&1;)UhWc5YYb!fZf&y)`A?|kxF=75E zHWD|msN!dcK#094`A^M2MO0oCy@PwzTq*amv4%FYVcQ-*rptwywtUa}pHWLXGb?HXN@C7cBncL&)k}tW!`sS+VUejh7|3||pP4wKVaP2}3o(UZ` z9cs%VNF=7Bju{~vYUEpPWJB8eeLk)A5ePePP2_i$dG~{LAk!Wd|9f#H=FayZU4Js( z+4B+#4TI>1Wuz&#*F)=LAdoZd%P6wUV=Z@hZ@3eK2MmZ?YF2s1>adP%Mt9TKH!=?P zL&ju5OF3W7`BfA_&XXy<(5zK&B?nY!Nl!}DVWuUMJvgYP-7aUxP$lB&9Z}Wt* zyo6UT63D(lz9U~fkj5M-Ls0q&`S}a`yC2BDsk#dh8+`61R+yQj8I*X)HdLeRPFj|_uH&>tS&@C5P`_X}gs=?)LK00=0g?nC328(@>0wAhH9*m-$ zFcNat5#de1rAalyN4>ztZJskiR7iCECv}9FjuNFs^A0rE7}NOr4#`=+_VB8myk@Z0 zmp2L>ficPIN%D z9>*vYq1HHf{#_#AhmFp3hA{_T>v+|;K9OC!Wp5#;kQX1nJRKDI)aP0D2q4}`gT40j zaYD;nCz~ee>OzOLMf3vPH8J`&iOFHn5i=-A4}xz(Ao^_6Lu==jEh+owy*R_I)$@QJ z%X{N7(C|#HQyX8+>BS1=^1d4-L%ny2f^uc0p7@Zi0nnvwlJJ$QlPS`^e5R)wTA~d( z{_LOa@p5ZpbgMaX*jMy}JXfsfkDr64EtY~i(Fs4H3%%L`O>*@lko!A#ZUZHi(@wz$&3LPCa#$ zK#}rnLu55g{9JioLPeq+b+pvviA|E5DF(YRa@@@cEr0(|fEk-#@{PNAFdVP4vFEYn zcrAg}WSN{%d_sapcZ^C-jDI1SYiyR4x)qp5LJVRnS+ACsl1h;BNyZ88O^Z?t|masS1h`LrN8!|F6DXDQ2E^_46zJ(IGb$SOO4 zCT@J*;G4a9efUoB^9XH8eX&J~fdM)v%Og0pejS$gNJ*C;yxI|x1!F2n0L zDC_T7e!n)=LQ8vin3jZvul`EvkKR5F876Q>S5|fahq@Yl&xger{jb9H($6qm|090O zzk44%6b<#7Az>#gxWi64WvzE?Jt^9zJB+D+P17Ig`)^ezpm#hG5<>#`)H4cH^}kBy z6fx$(GDah0NVb>?4&=XPEZtk5t09QyKAimX>VF<5FrV$k^yOG7+!pYO;lsU(BqwG0 z6&pr*p$n`1)s*~uddAK#D?US|!yMk%C~zM;NhtdBR3(uJD0+MN6UP@}Hm?jG34QDcd?5*a zhU7E$^0zIuq5JciiDgB>O5j z_Y63&3EM^=XvbM$mb#!)|^?H4T z;=2UeXg-ePLwuHKMf!8fb2tV9@~7Rd4g|d|mBWaIltOfGhW6#85I;zfZ^s_ntv5t0 zD{d&}W12;MNA_{;*mq2Kl*Aj;IzB05BV=r83SCrY>BddyI*D!2BH34ctJ>HYI5KaL zTC@?k%m4$R{m_!7P-F^VhSz@Qcz!o;BtTGZJ6FUqz2&*y9wG8#Tv zt`*~cds}_<@2$Z#CI?7*xzAzI5rhFhzFl?M?EbRyoT6|8^*ZF0TiKj?iYmBkGf_)7 zLD8ET30V5c&8PYYa+8O?vOBG&#C^r{T*#-^Z-!-EdtD9pbd#Qz2-wIFTM}xu#J*hr9RTHo7rXS;?vbhHz_VxL`&ydQ8l;zbm z)3l80qu8rBc9M|0mriEf7-46Sh1+lHB4=l`Utpmpb9^YR;1&-*XRxEozXTXg-{$te|~FMrEItJ zRgxo5Bi;ekIqqZFujNI`qIN9YqaPPi0%cD~E55bbHN zS;AXXQ)gy6YaBddwx-nnr2Z2}sfH>zs>Lm?)GN;Vh~-zZ(a%mv9F(AmidIwTzOweM z4n!p>Z!evUaN0{}zMQe8=3UxdkMDw>ihxf6Vss50RrisN?6`|A)jCI-TaJpRG6}n> zqS_}9<+XYXuD$rW_-^+Z{qz!W{^`xS(&yyTTEaLzGH0&YmUuNNzny_9CE-LZmPmL0 zjQW_dxAhUbu3@2qTGX+Mz>^JnY!xeTps2e)n)*~iNN7&N+dy&IOpIloG1nDbk8e<; zyLSZkQj^p*F$(hhm3^yO)(G&}9w=?7Cm_ysho}2j%kat^{!gQ{ef^HuI+Iihqf9FY z5SOi9ttMJ^QU-67x%zRZJOXPWTUU{G=AU1Oy^hUkR>~$cH8 zt){ZeujS`?Iu^0rgfSS%h)xIkkt%u>+&claT3DEu zcmFUw`isBIe6G^T!v|hYjwPvAg!71s3aUL-V^tgCZCho>&~nRN2Tz`K6r*xsxe5b7 zMVL+B8Tiu6J)G*=kqDfcE~Nnne_cSb1>E% z+y^1bwy$tI8Q>_{M*xFb*S`zyZT&6X$iv9PvIx(P*~ppW4AjkRxmhA)+GK9!iI2KX z6R*B-Sy>Tbtg&yNoV!ow{XOeY5S>T-t)d^rEQQ1^Gw4#4Ta~SQ$L>~J{6WNb@o0y5 zyET68A@A1=vR|J(KQ{d3NQfe}xpc%JP91m+&u`e>@6D#oMh4=%ZQ1fU8M zFih+wC00QQlnYKc>NX(?FWw?`4tVY`-eBRZ)#d3zFCv(Q zcq#`q>t(cu`u7|3^OwvBpZ*JgV-?acvg|}U1m<-j%Ua}#!X507DS41?mgOm#K2tHP zMKsX-aB}Y7bg5NEEt`CxZL4pfJ=2-+>%vo^lP2i;{xQ7*WSlTDCP}Un+5)(QpZiMR zYBn{tP1H*@B2gE68xC={QLeL=Too4n;>Z0Ls~we7&z1HOJj;CkjffJW?prZ|9`*ejr2FMB70hv`eTzYMP9obp zUGe)88GJMU2N_ZSZ<=)$HuL0Oy}enD$q&N_gtm@X=3?PD&exY^`pj?yTDa=?EQKAw z8#pBxY+8fi5zw~2An!+u(FZF27ErDAFW8k56**=nX80-msSn+>Y5%Z!TX0%icEcY> zHFA@nI%kE}e}%>QH>VC9^(N_;SKZ}U^0I*PAJ8h3ylRNce}=Ni{IgM_?0+y5`kd!% z_+wLx^8Y=-eO;U=h!1>)JWXFodlef@SumZUVBt^GD$Dt0IlCY`fclhdQhigPuxK|E zRW$Sh-xF(}#fupp2iAj9#w#K{0tgy#P?!H_=f5X6SihOfPM|03b7}8V;|59M?-rSV zc3>UP{%foo%(4SYxEQCd_~0=c2y8yW@<BQlj5}1?2%ce+xkL z`E9HIAx#yB2O7I^5XJv6)9pvmUKOSnn`j$eZW%3jv_`&KeV3IQfQ;6sB1AxS$F^kh z;Ohfh8$x(Z?qt=W6>AGdjI3A=Dign+^cV467CAaNkPk-%6SC6G&+Wo(&_m)!v|{Ej z$e112Yua&Jo^tHYLM>Ivk}5aP#R?HdMLE}79ePM(5^ww>-hc7C@y2>vb~~<=?A65?eTkR1nO0L1r$wViVyphC?FZu@lh&HOk%B7Cwn^;C%1Ep4nonfncQH zYY(d8$2ygBi=zTQsY+i3p#lqt*zSOr*=1R0+LDTv6jCeC9DNuMl z;A!V0fY+iU5S*&j4$jXhk_Peq^dzsO{S-vW)p`9v4yI6!xx^4y-y{a*>{lz)*_I#? zj=kDoJ48dpaSpH@R)wi`SW@NkYpL3CIOvanS&bw^aF^ECN;QDBnM`Oz_^Q|#TZvu9 z06ZP}@VsG??L0ZMjz448$so}}ZlO(k<6}k{;6)TJD(_D8`8*0kxlw_T&rV)D?JIY$ zRX|jMm_R+rK37V`x+*zZ4JW zse~q~;c0*Kwd=spx}vL_qUnBCIsk)fgg{Y5Ua;5NcyRRyqbDgzU!sRD+xS%$lU%Jq zAW?C4l1wGgfiBoV83a(Ae7sY4Ebey9v9+LuFn(LsI@Dd*j#*1aad{imFYT8Qw88ml zKJ@cCyTQwenuF#-w)4b9gU=#7JO)P38O3%)wBV!qsUHF1pQD!G#M<>{j8qUMe|=d$ zi*LwAfc^lmsL!n~cmDpAY$CdV_kq?(-rTUPuWx4zNiM*z3SFPF2 zZuz1c9Xxr#{1okO#TwiFMPjU9px!0j?iRV$5RcP`b*uAH0|j3J^EYg|%=FCMM3a<` z%ei2OJ0BnVN1y@=<~fkk2bLl2Jy_ZkzUdz`p^+BKH?c>3Q@ z_^3iu2f&mSMS9jvZSnp@Nk|o!X-Qv=_0T#coye@TnRdmj?fC`{9~g)I*Bcqfk7(*r zuxLrpa9@=Kv6XflEp}j)d|!2f>+>WLTb9$ax;%KLR{r(x1^?#YrFi)ZwQ#@hfubrjt)`p&Z0!@EbAKk2P= z)?D7Xh9bkrkHgq3UKrAYuN{Am%U7I?%vX5Y&=_K1No!oWzMhhm46d$tAA8>peguBrGR^xf zTqcV~o-Aw~uUx@4VWCWzgc9|66@2oMFSXXW5+>MmQ|qR87Z$1R+qyEhXLF9!fuW<{ zcf*WbvLlHFW0Zya_^s{`0?#JiS z-{bn0#1*<@eJp>PiDUSCO8$G5Vgb_Hvho6lw?ZD94X;hz4C%->?EPDh&M!z>wfNZi z7qqIp4RV*roKW`*Dp4vkFcWJ^|$eA4gmUYJX4;7cbzk=ui|l#M3`@j&JGYwS}TFNcj3Wu zJ{XhM$&7Sf$G(`bA$69kdOiYwG{h2F_uTt}uW?--!t{wxsf-)HdCW)bZ8#?%D(FUb z6~S!){uHIe^=Kc*R~GPm7gAyXt>2)Taw)99PP5BQ)#I?J_Xzkh+`zmDH-hbtVBkej z@mZ9!LMCTXwCN=57{in3wBc4c9Ztjov|{|6tYVk70rpJO51daHq3JgpFQDEzy{ z4|7wDGTTSjGDzy}#0ahL_Uq?+ucBSXN}&citutC*2i!U*8hA8poVzHBA%IB(n{=;ef{D6N1U3$9QiY5;2HG2)vG zigw{;iiUAM9C8l8E|)E;ASCa9Nd`7V$iIg;LLPJ z&ob>a$9Wo=OqgPA)Gy})7;>^2N0;t_ZntM+*LIXS6Niur^G>||DRO`vgRRV3H&-*$ z)r$44+Wl2>%tiXccQbMwjhvXLP-oqm@e3nDtan3-h#wBL)pMQX#4Ka#o1gVhrktby z{p9Yqe8U3jip33q-AdsJE+&1s?x;K~KZ<)` zdlA4;@qYsY_#Jbij7!)kEDA34-Z;=I%)~I5x$Qp7TW(*bO4G~^U_UWA!5N7=T zddUpGeDMIj+x=(b|3oH`Jn?^$&$|JY-%(SSL{~J6^UVDlRQbR8M3@V5WgB-{-r`}; z!8QW4VVUlI*u5)qIn6PB1YG1qKlhs))7nAIb~ zd55YB$&1mMV2Cw~QLk|~3(-nbWE#bsi7+&RvS9I_X_|yME9L9IgbccsQ2xp}WIC}d zv)^0B1}_!#BZkh%)rO+-GM~JS(g{vIBF2`O?;syV$=au618>K>O{YY+=Fcq_B6d5v zd|IUpL)m?5T@KOy6LgL>TW))s&PGq&x6MAEF@!auJgUK8L@|#BrUt(_0(XKeFRJ z@>XtXe4`M$yhkxWp#nFo+c4wuS!f<3O}h^*o-8MEjUbF<^J#iQM|sM;dyhYYZ~jk} z+DZD#Rsk8+u%DmWdiEAS#!nYPXH>xnGrbPze4E0rLfu+PKYq-Qa*dp!CRm^5n9zG)Dm_poAtliJMXBb(shl8GN34+H0hvp zkSe_+B29X)QBfcuB}xe$RFED)0YM1}LJ$bOhNg5uq=Y7+h9)2-fDo!TI5TI?nKk9E zd+&H=oy#9tJ8Q3R@3q&v-(>Ia{k_lgU5avksV+uXeXn zuBC5v+bOeTXXP*Ks(#G+@+P9tm2PmlFHHgk{%(eUQ-Rg@VD@#WOXK|k$>RBHU2x0U9z z)cx`okoUBbyo*{mO;pkE%(M#<#~o(=~V3zGwYe#*IjJA_QxJ^XRSRbO9Gy>87^fa zSLce=+@T9r$o;MrKLI8Ss8MB#pti2}v&%L1B|NhUvhfYeL1{M$O4W=}o&qkW?}QLQ z50|&3xvtzX4zO)`03 z@Io6OJyEc(&r)|akJnZo%jH%~$CS4Um|E?^gXp}|XLlF@8+h!AODLlx*jKEyGEmxr zfBYOFT-iy^Acth0W>K;XTUAAs2}cD|L3Jz7M5QguCC6$CbL7TrDkb%h)nxkf6!qab z@$8pn*WC&2yIWq~W@Nor+?C&u$vQ;eMCzzEMFe5Sn1E6jW3tudZ=Ok}^2sH+2NT85 z<*4LBd4vhv7NuR(Wuv{BNIQ>-loDfCd#|4{!A_44(nu2;52cGv4l6%S4Meimi zC}frIZ&7QIpr47>i=B{nh#lT{KGkGaS4jmr4?TXU!L=BT2%2-sQxZb~Sk>gzAoKpU}CX#nQRdE)9EjpWcTS>}Rntpx| ziZiW9+Z4m$4Z%spdPu}R4KngH7m}!CYlFF7Rcvpl&s*1`RWyodsyT&7z$;E{XK+SM zDM_s?B&a>cj;oTDNxP9d>^pBOGA`}z?-j$oG{F639%y52Qw!7(i$hmG@Y$`qtyoUW zyhjpV z3Wa}?y(8mQ%G zCEei9+RfoA0xZCs6r7E)5m?EX>`#h<#Yo1Iolkk$ugwK7-?ta6nxT%#jD8Y5bnPqP zv_FSpDLBs-#24TL7SLMu=Fm!i@`Bi|jKcS3Ue{Wa))O1#K*oS)ji&3_3!)a|J7-@x z0nCRSiP_u6KJXHzJ#zKe0b`cBgtl9HMirlZa?M9;m|Hr2yqh0WyI(ymy(qe1VJnf= z>|0QY8N(ay>A@F}fzg%ZcPipE=iM}=`0Sa&E>E*>7o@aJ)yHMwVmob6E9LZs*D0RJ zSGvhm$2=Mh5`huCon}5vNr8su7g|}u#Cpb^29<6m-bp05Tx57op%PzN_UV3Tk7Z36 zr$9Mii6%hEf`{u_$z>7pj~}-hs1j5cH!$$LFqo=gLR>Pz8Ql(WQoN`WI%U)%d=lam;rJJKpATrLic=I5s>PUKG>rlbXGtO?E*Ml5@dIW!L;o43H4 zv>Do`!TBm{^!u6d$}IpdkAGI-{>9&EjSTw{WqCYEWI%BtfFj=yAeT~UEL`TNaCLof zZh=wNr7DAZJs#ZejhCe^rJoKu{c)@_$frP$zC3o*Kk;=>tjPStL_G%5<*{j?{DTh>kbZOQ{U@adx_;~WK>Xo6G(A}94Tqad3sZx z!jUL118?BS>}2Mv6jF}3+6d%d8R?yg)OlG^#LRp~W#3s_ttxT#GHS)a1*PM{96L;O z(U{6z;S=E(+E(0?W^XX0L8GS({WQeRwBHl-QT3u}_=%BwC_gYPlOgwz6Z_`5HtOO& zkJ#vv?4;54YYu0x1a7Y6OXIuZWfY*|1Y-u)(ElR>3)t)sxWDEGog4Is5t8eowmoNP z{;Cw%bz>H-ff0QFwvGNKg^0*qzC=aon!)lyB28zukNKXRe(&HRMaz5ThG~)tns|MD z$S?mT-`SU&7Qg;ed3pcxXC7hZB(iI|oe%9^xO8vV)x$E`&*k7Bs{ArxMv4hsM-S^@ zfnPu06pv)_1CB=qpx^q_NTJRZ8GCJq!es%MjQcYa#3#2>{PP%|-g&wl_beLE`YE&S z8d&0;?NXGs3SuZ;B&q3zaW|~Hk`X~Ut!uBx)f91_eIqdfTr@P_*Tn`@^_HVIYfDO1 zxgP@{MTif}9mX4PS;Ics!yk&Zvo)7Y zQSDveZ@d;)-78@uv;29LsC@Gj{nMw{63Dt1Mz?7*{VQ2Ha9wcaiuLTYsTzl>M6=6z zoEt&|09cjnUAg(m~d&sE)iH)WAf`=JNA-h&eV(4qMBeG30 z4J6v`;&5drY5NZP>{ADPe`<_o0m!>(iB-P;Rpsr{svbJ&tZ9ml_!XjsxE;Kk-P*QU z*h;4c3WJ?JXzpD|uXw!c+WyA8NMA$$mT->zbe-np1P+JO#INSW2tB-C4xf@Ew=$_& zv*|}(E5dtFK6-d{IqNcy*xNG%G%RnTSu-o=t(qzsufCjyk}MoDMCm8#_8^3b*T<}C z1A)(SX{b8H@XjN{j{mOr%IvIcv{Qwiv&ZvHR}~iHE%q%5*J6Ja?p(|%av^Th>h}1h zGJa8*A2qBYNdX{$3o?GOc+Qe*G-J_ObbXBH{7^{PSAe4fTgZx-FMoIMrk@L4yA?XR zcuw=gZ1-z?uS3tDv~lC%_<)GJO5XJuLb*QrvY+2*|Bl-uU*dpo9549%ue-7M&0nF{ zVF|QH3yI|a0`WBLK4pKSc1gZp0gylsK$)T2KOkNYVXtOgP_2@zRN?lcdF4}T+`kY# zfFRBDBlwqjeB6IVT#T-TD}@^|g7-N#(n)I`GOP}p+|=ZRl~I|`z(D_ME%d5!Dg6TP)v)^p8@0cYMSPF?H@JB98-;XCCmwDXV@qHdO;S{k+9Sw#^M}72NCMC5qzks~Uz-ZHF8hH#@be22;^?z5 zX&xGaEH&DzOXfu-10DxrnCaVdFXv8~Z;5Wmmyhm;goJc+>i@7Ppkz9@c|b16rvI#2 zXeG1k(FrS$!fmsVR&YPo5^ptc>?!D=*T>o=TtKYj=U!1U4dT{hk~RqW?6aWP|3yxa zNvEpclj&h)S*6W-$4(=(=?UK7$-~4(&Y)~yb1C3*qbICyia1WIjzMo{!C-tz*7ZeS z*4SrJP1>37bZg8$YR>sRVHV=Z z(gO621Fs8HLrjBk+VZLe&W!dAIm3E_`Mw^E3ccfihY{xK;9v&j`ReTg{7+wZE#`hj zUJit(?eQs(xfLI+9p`Q=1B5y4L!Gt(zFRrzAQOC$jMwTU4f{9E1i+UST|b~JuxVL7 z%1{uX<3WKILj5xgsxQ4h}IByI|29DtZcFvxSa#9dww~Ipi|Im#w$hD!(1e4 zTo_oFh0Tm>IIGr!BNDVzJ1m~v@@5^7ir!a6v|x=I>w%#{vyyiw1ar=vg;qQ`L0q`) zF0+$|K#?{l^a~~#u~IQY+_~w}KpTYKA8VoyoS$Onqsz<#IU)LJYt5WaIMWQW5@q%w znE`Vm7jP&zYA0`(0)S(wn^G3^D91)2a09eYp=J0oD=*f5#r*!O08AsvFCg&2W_n>B*6(cS(Xk%YBaHw;X+yG#q9gFD?3!_Z_~d6d@*VP+<>&TRBpkP z0^7{T5s_+V^;&hd~ttxa^PlCka4<`{?Wi1a(@E`ZA9nDd@g^AMflx%;ce zYlwlyQuQs+`2Zn{lRSiKHa+q5*zKTAp`f;HOP%hBT7w**bIMrxdr9&e4kW2={O3(f zh2pED^8}P$60zubE3#B$CEB72#cL+csk-mly+oF}oWB9eyxmbExv@SUJ)P5*bsI7m zbaoLr5#`aTbXGAfdtp~>RH9@=jVHB^b2RIjE5oVi2jjt_hyN4M2w#gH=RjG#9l3MJ z?zb#u(gQOtm5k$wr=suRy)GpwHO;vZDKBN`neEg-cBc?AQ&}C>X<%_7&b`A+m{^~* z7+;Y73!UnI|JeP>{C<|sdJtl-;l0(I-y z2Fs;S>4e3eloW4;l5?yUD3B7fD;BGFrc}7s@4ko3!0^1&dT@Y-AYuwiwh%~-(t$l^ zN{p+0x5DMJ{^8&wy81vs975PQ)bb7^$i2RLEm3{K&*cs-Y@={O^^MFt$3%6PXPG|f zh5sdI5~#o{BA3|0cCRL3Rg;4 zovJ>0<_D1$CFVbnz16VZ8V@Y5Q3KqCv8<6mr?yLK3@+}bmPdO5oj`2##>QNB7fmh| zvGUi)OPH8jIq7S@JwN#VN(xMv-@KPJYT{&a6Mi9Bu=koK z5ma?S@0%+4yET^oR-N~^_nidX>LDfw=% zFdp4xWCU~J$%FwO-Q?t?pFDy(cyzqVqc)vMX z(A=e}8;@hA_|S*X4-n7_J9K5z!t8!3FOfjY?xSeD8!Y0TOpnWj>WVYNS5!x}SUoP= zgB#b{W~{%=LbWy*r|WsY0@_3GeFXr$f_6=4y~O`8?54nQiJVQA3)+LBD_j?gtJ7GE;MNVHMR*6tb3RJg<%68( zVAT6PaYcJ2*7}`-qmF^!|A@%Dd4q3E1~@JDIfP;4)E#G3!&GC_w+Lk zoS7K5{U=?1hqV(sW;)8ulWU$;OZiLlOS#&I5>{8kY%aB#?OFnX)|Nr`R-?o&40Kv|Oi8loA6s7i9H@C{9 zyRCA>8XrEYceacKY*3yvhcqftRzz@;+Loov4L1dyISD?a+1s8X+T;$OxAx0fvQ7IF z@M!8F0avv&)+gm-ixLtKZ)u1WN9Tc_%^IJov=0uA@BQU@BQn~?|G@C)LFm*156#c1_r|IeG&zw1ZmfDuo=Gi_eSPn@7TLH~PR$Bui@ z1|9Q>lh?&gT~yMcH+Qf>~9vw3P0yre{r@cA*4?7AF%%*D<rZ;(N~27*5- zQ@3W4lgo}3DtjS6h?Hy6HI>*p7S%7OddS|4zfldAQ?1q(IC>)0#c zw?og~*!SQ*lA+LDc3bw~kh0HLlCC9XeSYA?rmEbr`+3rJ<1SafvRCE7Hj)asKNAeu ziJ=16x63@;ZVMf^LqDFJdd1sy_N9qCYsxt+^u~PSg>?h(io{f#T>69el=+*8ZI$!} zxn!oLzU9=4xb|@^r1h2513$C&Wo;2P;e}BQyv&;cPOQ4!NpG#}d|O?&XU@d*@WoRle3$y1(v(TDi-)1pI|ZwRX*g zpVEjKM>|ut$0dHjh9d9Yfy8;2&S|PF7+@L@aQB~sD6SR3TM|*Sk5Bbpzjomaoq~XU zAU;s^eBqo^_E+VZiK{;)R;)G|UUl3~Ilmpcw5iu|k4Og>dE+1xDS7Y4Ol8Alm{m-`Rh5FuyUFUKPP}-4HD_%Jze^*Qp};=I+Uku(Eu)?$g+#b3-vv z^m19(pL{Z;0+?C@m(j#LOFSh|a(dKc+0#{a^@`79} z<`H!3va{V_&xreO+s|I<`P4Xavcz4^a-dn8h{gA}qE=6f-Z4olo2Di<&}X`gQ22)3 zuH76cyPaL``_;@I7qWQQsnKfSF0WI5M1t;l65<1XE|^J;h2?s5tPQ8qPGn{mY0_yXnQQ=@6>mgSSW4@WParsrjjK*Y%C z?waU$dJpOhK9><+zgTd^sq^eBcV5P^#bfW_Ox}Ri)uQL!Pe)#sADQyOB03Wn-7At& zuT6i7cQ%zye6o%6jtgChB|6Bqw@(iYkLfrD5aO5j;l)6hF27^dt9R z%->6bWM~$Tk|*K{CLDtfWf{72@Nh%Rq2|xmYeS3#T)J54z=P9oWErhm%%WRH68xh* z7@*oE;KVFe!CHT76AwPZ!G@XBT(6=ro12fE)0~&?H07bk#x+8RBO5D)3nGs$SS_(D zS<4ykxq>l!bv^2oP!)Xu9#`ae52KG9FVDr*3y#=|NU>SHUDS7366+*-%)hyfWXb&L z>8&T^e_nt3+gkiS1#{Gho{-v-T5h<3(eEXd*bd@eYgc?v|u2zF5d*>%fmN5D_81EIFg9`7q^tTd3aY6YUDo zD%wS|#Qkrx*uouVyo$oB?HQf&`b4c^;r7w(R5pSitJCMMoyifu%6E?2<#HM`%=UZh z_BNCkw@yE>VRhx>v^g#;LD9HbP6a%}QvnA_F5?DoZ&qgD-`U^X!)XXx*={azTv(uY z>|5Ax^Qf5SIFboN`YIh1&e&EO%14S`b*fAnTiGUhWP7@_%wQtJANb{?jw~l8set^6 zQV$I74srJ`hlx8eIK*`d)=HepHzp&r63&4QPP|lnI&+gLw-ZD*H?@8PUsN7|Y(!Fe z?5*`mDg6UTAzzf})-8Ft-K5$tVGE5$$P`=Hs5dYxe#MIlu+~hr>aDHj%hHl1_MLQa zX^|#k`!%E}=`Ww_rWk221t84M+yC-)nlqF%u4mrbcKdi3JBy4(U(HycKeTpaG;1+I zhm?JsQZ>eG^%f}2m)45^(l}QB`pyb+?k-0|a5~-*b`$J)VPn@6Ia8Lr|02(al;MK6 zs^=P+auAxWfO;5O7`AkdSph6~52aM7fR+TUOt=Hw&GM@0glrc_OHk)plx(Dh(HFoN zkD7(e;^WTQe7Z^YLhCHUwWaW+jK?hcDtkjB_rgRM1*fEyt-@oB?JwL_40;2enkoud7<5J}>fY1klVMysyl!_kH2uWld3E>+X%9QNzES~a z0ev6Iy6_r-p-|}*m{O?GUuouDy7LEDx}Z`=xzm-J_g}mN zjV295Zz3G850-(!ZlHRXq`ffguhU%=x2cVqm&Arhg+P{|o?p`PsWP01R(hTj5fVF3 z+_cZNxMi*#)c7tpn@WvnsOi%M3W~jBdaP;$NW8y$eBa5a|?c9Y3ab@5YhH zHV{0c3>Cm)VCMw6VA@}&t`o0K(jd@-_DAZ?im|3Qmw(P5PyvstBjzcX?61!?Kc}T! z*H_{_l#iaS;0NS+muV}8`(3^p&o!<5SV8@h;L_z|t!wDVOaW=nyO)aMxIu^SVtDrF zOVUc>^bySommVF6kFRNXznZ`O_4TFh`x7%r^|cI)$VcJ9&TePnY1p03z)j(?{cm5^ z(3nC-ij#w(5rArDpNrDQHLx$Geq>HOWM@Jt4j zQOqlZoU~=Qe29Vv9|u{5X~6_j*lYCUh^w7P$hBnMu%YA?B?-cJm~`W^jwyY_WgTU} zKgKXL6CZ{b``*Zz20MIuVDaH_dWN4=ifGQ#)zQ*UEo9d%)Rj!HOMrRJCW{WkE9#&* zGvHU@nF7pIfVsau`4pUeo5HX@VKw9$>{xfQ$70gAkP0ZF=r2jt&-Ox(uC|T4El7`& z`Z=;I+6iiqM=KcQ*>Hn=fd(odo>*l0Cj3#2p^b2QHo3NP(GRSA8QS2l{*SS8$^hUJ zgst4+yY2Wr86nM{fKlIk(!?Ip0QpVcCyxqv>4|!rWGwc8^1we)FG4Y!Z?{O^m0)XJ zjr}J4{$O-TXX_+9xtl~$VJs|*bMexNOtf|Ev`Q_CZmyV-Jbd6v9;X5%$l$9_DvoYu z%HK7=Z|NWW8K%JgQ{Pg%7>gIV7Q`ptx@1o=Z5Q@xEI%{@?1=<^uPbd85>LlQYmIq!+`!;oRNo zDukjJ;+^z|&=iO+e0O|LSaD*@1EUlcWL~>AM2T6jl7cGK@cIX|d<`GQ= zFhEIn#%vB|EC*8V-RhC49NIUe2v)RyGI=}n(s3D5=!!!W8vA9d$KUO~Hr=R01&s9i zma`Wc==s6*cF%L5vNb}kf7OS#CN5(WO9|kaMJr#$;l>hqTXP=i(QL=kF04O2MWKuW z#9I0$6zBv9Tz}iiQ;f`!SI847pW9%3aN!XqUr|m*1@!h*LyKr~1W4jQ@mBM=>n^w` zavz4Aw59FS8tC%hzpgwf4_B5ZyRpD|w1nDyCedx;VJEV7XKP&cFP<5K zz~R8*rcjt9q7D+NJqX-;`rc}G#$~9&H=uAo6;qfYsv#J=#G!hy!g&8uU9}#3J|c<~ zj|E=VfvNaj&{4h&_Rc7x=o=2&+DmGVh7)=2s3P>kl39qYH)CWS~xWA>nU`XR%U`^MEP< z*5lQp=O(=3cJ6RIsPogN0*s~5&~}Rzubcx#?Y2j#iDg%eleca}<9uvm96wE*oBd5J z@$V+K*dGNll)>si!LUK8_9n^L{SNs@1`kJNZ*3}dO05>9_J0o24?2B-l&gL-VXAS? zO$BUL1k+RH>e%+bY^9!cr2!^`X|P-q22G;p{gg9d9eHcgal00lt>9~1@oXJ)14U4T zFZZzj#GI`VXX%ZwjAN7*-xk~y0h)py(?!T%j__?^z*OaZ@qx5t&(bu^#_9dvaR>$6 zL2?gbj}p5gxZmB3p@fRtFXeaVIwGxWzb-#rwB;a1Im45D5N&?YBSyyJTJ|KAW7oPj)^niK~hy+y+0=dItZo-jA9m=!( zB@Ut$Ksp*Jm%cs1A0^59XS7V&=o`I6`?K{L>?sLN_)*t+CVou`lSB-v{_}G7%1nzVQ+SkqS&DvqGqKwyi5O zwR)5AgM%4@)JM=+DMuOr$WoYJ!QBwnwpHc(6MhfEewaYeZQnD6Jg%q@oHxAjRBt_7 z3MZU2f(5Q|K2pX<POvo%8_A__Aa?h@&e2P>(<0SD=HA~A0?^+byB0X*J&5CC^z7&6+9*6wW12z+n zgKz99c6=-b-<%84`B;|mg{7cDwB_q~S}1r0wLJS9i_Frz*n6&(3UC|BC9?Zn9xQ(R zE%nCjTB$twdBbtGWWJ-$Htiv39SJ-PFZ1Q(tgWyt`J8%ZqjE=d)d>#`_l%h69A^0V*dKx`ZURMl9JqR5aIIa{#C}wCuGn# zOxS;6l2-pdM4{e=@~0gCdmL3eAvMSY>vu(;jW13!zihnU4PQu!Y_DbCbqw=Hj!Shb z2wxSjXZbn{_oD)cKm6TLp@R{jAzyn(#|E2>qgB94nb6tUhAW|@qerps470Rzoipuvkh31oR#vplyPhXEm;# z3Lg^xzRh%PaN{%Ho)+iY;RX97tc*=2ASC*2Dqtbgz6ek zpznj@_6Y_!CCgXBFH_&ZkH7J!ML0&u4bo+V^*bQcq-s3ecDa1lV?fuPRz@FyyrUUT z1J%&KM0UVd`-2(l;mm91FUYebZ%TF1^mlnZhlUaGn>*nZ2%1`LM2^&8T$b|UTy}hK z_fRsE?|nnm>fdfOMb8)R%ZdhgBR}U)uW8K)w>~#)qU_=5)|n`BX1%amczb$dVu02?$XOY=cnqkACB^2idW?{8$Aj84DckE#xGmyvs6f_WjdTk-nX3$}=l;dWepoKO_hC~L zGM#iXAO6x)LOUr@yfyhja&2^ke>(jx5`oKiELks2VKtCLuhKwMb}T$VwqmTD^ZG>4 z@nx}XMFT2e3@%9AY{*+N&4^s9TWgW%T3fJnu<7-d$|Jd972HGlk*`VE|14toU;2Dj z*JYOn{pz8+Rf3%@*WYd`d&z_~0Au#0n9is2>?p)~fwn>9xIJt^-mlltuvZ?lw?=(6 zwXKbir47H(Fc~+CkyT`L64xE}JHXFFb1^}u6@wB@AmflJ5_}eBXLJG49i z02x9N;Z#5r4QcNfafNn$(IKakXF4bVcrF4<1yBJusDQ1=0@@7t(~ne-8Y4-x_w*oZ zQ~*VT3YY*r9bpQ?!8RRFugio^Snh>6aUD%8o$!-DG&k6#WjzgWvQ_)I&yQPNgXp@t`h3EXTUEtA~kDgY(_wOZhLJyoi)*gBl zZCM_q+nXLvV)MYgHbt<_ogIG=MmvxS_;8;J&_NJrD^aN+7`ku7Px(bTq;+GQfXrW@ z0*0(9G(p}%si)PAghEOi>+$d=CVU_S$3_Kwp#qLv26B*6X_0?E-F?b+Cb9~A2}1ev zWzvu2j%I>MwA1|IBC>FxvE{WIy42B`9=K8Ae^B`;U^0NLy4&uP59Pj!4VjE%NC@CKTg7-cBr_gN70b{ z$(@KJx)!z9&Mpow7WhWoOk#KAutCL(R8-En(_F;UUw`ov|J7$_MN!PDr1=lyt`qjT z$Mz=q=g8kYh&WKDr&VRjx*}Jjy@JYQ8=wBGyoF(HC)nd*MhoRZ+{CHUA%_v0NFI5h zVxABCLaRBC-gHD5Q9k{H{j)-KWWDyT8Dfb568*8;!EbARG22y0102Q!8YZ2p?!S_=Erztesq1Z@ZZfwtA zGa^9~&8u2nu=IFi5~Bk&Tvvas;i=3aBG9U8`sUAKCdRN<{jfN)d{V-85)L-9>`3Av z!bn7#(V+E=u>aM$M`D0nws#;yZ0*hg=-u_jP1gr2P1Hkut~qDX50OrxgF>fvOTH>o%+@#X6fb_ zaV7}p!r@ri{(R$?lR>ENmkeaByF-4aV|`)+XkfNpEweh(Ti|TE6UX5i-eBgh7S})A z;lNbz1P?=tkDs=be>Hgi=DOljIS^gzB=jq~H^2K_$TxvpDIi-HSXCnfVGLWgq5_&B znN$D@NqOM7n@(XSi&FgHdpz)PTb-vqc8DIzelr#DR02Ufmrn~{`6yQZpWAu)PlsUs z@s3z52kThp^a5D*Un2YVz>P%~Z3d%J=RPT7ew$+0&zkRUi|fu^(<@VWuhy!u<&AS; zNP+eYBa;E=ve-QItMQu+^Nqoqo5-+!la>bM7J*4sP9i9K#kdg@xdz|gpaMQ$CE3UI zi}?5EHMh>0Y&v#O0m#tpoObmLL0dlSWeBsFSCMhzbkNNV+o4cffiB*Wa9%{r|6#p> z-CKEZi6ay(nEwC&9{rW+7$#Ugw6NuU{UQBE$ShPi5C48!=DyVru$8?kuXUWwU4`N8A7^ka8_9FMIZXSLBaa-7814a&A!T`VgLeuzZZ(qiNq zCXWA7kokvZ*1w!bMc+;Ehxq4rr#rdpYTIFF7pnF}N%9{#>Pp8}&dzLebxdSufroMm z)(76}+wxS>eTDuQI{0E*TNF7&P_(hEh@VTA34J1G%K7>Uk=fV?`r$>z1ml?a{XU2R zY!|pi5yB|O&*x}#Hd;66eAxcvf;A`ICxv2=7d##HFvGhQL)XU7`&L80eDcnvB-uB& z&Au$W;Wl|>ErblgH0rmtOm7V{?h|4+erjYFp}JO0X_?m- z{HH%;U37?D&0pO%4sVwxT>R*%024|K%9hrLX5aXZ;dPG$b{(!>jx-^s8^qCrLE9a3 zXk4!;ro3V!zUbi`iyfI39OmPY&q38KFeCxd&ju%1_+H&gj(+V-iyE^rWVFVj+Y=pS z&z1eE|6Ss4;9u!*P$+0gClugK0g+#hygzaLmbd;rEpc7b^L34E@>fKX1(PvRQ3SbU zyE7-4n}DkZGRL>u*^X-7{V4&S`>RTPKi+7?FQZ~{|LQ9cEqFy!+}16gXRB$tlC>x6 zG@4p&b=g`;x-Hty9F|_VbB6XCE8#$aGd+PTG6H=BWgPN16eMRB-d&sUsceKU3(QfKnoVQ>kj?oV#^tI z7j&YgyIyuhwknTO!;7nh>A?-B(KGAq~nSyD4>A@=J_FW>EK9Ha*s7K zS%=c8P>-5RI3SCv7xx$FqO>a?Uelh_=~B$V@lB%p&0ouR!5$)VEhK!eXe&P}!Gk+A zgwr>sr~u8cW*0FciE}oAp(lT(v@khubROuCcyLlf{mMSK0-sesFH>Y;4#^M6Ss#g6 zY!2nmyY*Mu=YJ>LB{$bL)~M~{*vv!*2BL4?M+_J}3awPW8Es&xq8s=nZL@!tB93?P zq2&|ehuSk9SrKaOF9P9Z^g7!R4k***lKb3Um%g|yUhsyF0GAuY@urSBggD~G%=#Ij zgDIX*R6r?tkmx6ij{oq3oCkM0AV4oR7x*J1H!_J30a5hM_G@qG2i=92GA~p`?~;Ly zKSs8^riL@y!iQqfkLx7bU+>n;1{ir8Gzuq=zLF5)q(6*X+uDN3d}#8coo-KFf3D7s zFRUvrF<6yC(~F9&vCW9~(1Lrf-PQ)V%kP^KJot09P$mY;t&T z2;lw=ZN~ee!Q;NDewzl(%ENQCl60&;$A1*VJ0}ZNjClZma6GKl9)jZ{*YxEfE(d-_ zx3sS4EFn6wH$qqIlpGGiZ{9m)#IwxQf?P|O{~XV0s>PXBU96z<&wL`tph!C%-+!^ z$@$1`kD9A5JLvDhLmGeRpW9MdcpT^3yBAp#kTy&OocA==+f`WkY|gYjL^<%7+)ASL+G)SuRyoVdSJ(vYQJUUnEKHZgH;U-SC-=d{J* z1K_3^Bi@)XG7gT+({?$GLg%Sc4i6(MwF}+Mu3)U<=Zs$(^Ch{rTr_>CXmtRZ;%eFL zb=Aju`d$pK*E4Xp=Frq*_P(v{u0U+ugM9!1ey|=7GVPL=yE{GHa{30;#Fe($(%LK9IuJL+gvnhYA+U>fiEJ zelq{uu0+dn%DX=_w-@EB_>5`!!2m-ycJ#I;21yl)X2nAyk_3+*Bv4&;x*yHyxY_$D z-wJ+_;@cmMnp+p_2y0-SvgNX*L~yOQ`u4IsBHSZ>oECL0;8mWxe1HshD58gNE=b4v%UIHl2v7 zoKhBopWUy1VQcBdv6S=?lv~tuLX=OjW7X`kWitAzG3Sj87C~Gr72pgDDV_6i6eq9n ze29z8T_9N1tao9SDnDm}Kkut+AhMMxej7&L+q9GO_xcF0AMzNcZ}p3yq}@{2W&j+vwEnSC5m zDJ?DY_K-=5ssYng7`@(jUkqYp-8UbeJ+z3Ge>;v z%u)4{KVlB1UUX-^igMoN_(nk_ zIrp^=qBztJlio$P#~V#^gzyf>B)u8U{BmgsOQ|M-QDIlOqAPP*O)7%Vyr>FRs&?Mj z+Hv1XbH}Pv0Sf1T^8XuhJEUWFozy0v?(7_0O9PK|dH)h#|NCd~zej8fLnAx~jJWhbYji`v6(Fez8BMe(vr9fE#~&ss1=zm7~Q$||9H z%j)ZFkGWbsutfrB`;tWtju)#S=!&pPE>kRRREKaj!?OW-O&`x>&JoUlqyt?&S)t z%|bBv$u+iAN6#V8tR=IQ?iHj>Nia=MLPYr%Mt#msriJ3tfxs8OH|&PNnnO9;GX^x5 zt@As0_#f%<(05Q025DEZ^mp7y35z#S{ux8Z$6bKt+?CU(^kDRVf}b0=U)jLQS5jn8 zlk5c5?wxXbk@D)QfB=&dhL;cVAGdRKNgwC zW0*7Cl-aDV9osQ=*a^OtFm{49!u4_WCZ3ZDXm2no^whJ}$R&z+v{o_17P8-NAINp{ z+p@P8sX+JSXL?3%H~IPnHZD-422L@getE}qEdsaVab?ix(etFUw>N!;wYhsxFt>J?q8yoYnVo!%C!7(GbO*%vGfdb5euWC z#by?oauU0;Si!k<^%$F~pR$rz8=Bmz(7>}lp`gE!&_54gT%P@F+u8Q7Q42?JFpWl4 z_w;;=RozWv=Szj|wU}R9l9||dd{H;%zP)#j|50g`{-zwl+$1QsP&?-m`|@qMYx0Of z-J06u0}G+;r?uWp<_4})+zUFsIb)~gJ5@o!h2CGjV^XTu6||?EMJ{yTeja=fVJo?= zYTOv4sACGVwm*1?Dw>&tj$Un718&thckYT+TClqX$2e~$bhI%L`E(Scbg1OO=F@Fm#h94h7qes36L5k%RDwyhCN zJc73x`twy>XmACz*S~-(qP9A4R_&b~OwkWl#(HivJi-_K^R^ zO&(WM@-DQ*S2QTwPh9oE`&JJshRGuP(4gGaLw1)}JUxNfPfROoroB9ZH8GY98PDE{ zGiowC%2ixln2QkacpEq{U&J-`V(64GhJiCAse!igNkg*xa z#Y0aZqBR*L^BOvd6xP{EcOOO1B6YA=<4!lfQNXRLUp8(A?@{Nv|_JF8zYdmQh+(1UBHvfS-&neXMW0vL{ID0{itYvtGdo*H+DwHvue z#7H=;ft4sayxv)q!XjPrV~SIq4E{ByE@r?=i$k#q^HN8SrRxK;|B8n9oY>-{!!n)O zSA3-Ddm=eXU1QjWf<;gI#I=}0kMx=h%oD}Ot;T2-dWZ)VzzH^W^F%e(Lpz6eT(ccx zm&JshQ2}1wZ*jCtkrQc!ENMn1M_HF9&-oWd<^oGSUAw=6jsl8=G!PIX|ANdVqAr__*o_};vox5OERS;w56A7AahX4LsT|-ZpX2)?UYC$1jkMJy-bf=%XzP`hR9=aF`~&j#F2sxq zDAZO4?g>|Hqn2fH*=7a#PdvUPIu6&;!es%rla}iVyzFnpMR=+g!RUo74}`pUT(GuU)lxw^4+nD^95@)_3hvAdJVK_xN8A}l^UBe zQt~+y>dH`GuY?13+9mK3y~IUcR8sI9$dP(=!w*oCm@C=a)hsMa-!$(Z$w|J`zmbV( z5xw0ISyF!_?G_6?IK&V>DLNf~!NCfRkh1UQjh_a7uU6%3bE`3^2X1pCn6>-hZViYz zld3S@+@t{%A|NNbc{#>XLiz9 z%_V`#$4_#iT(&i7d$lY*Q46_*G%MoH$Qz0Nl9}&l&>YI2@dAj#XHEDOKmjgS9U#A} zYM??_pc!Rm%l(ql)X>7l1g_8q6_xgR`}K$=IX>}mTcsr%m?<`pTU!AJ}#BSF(I?X)vYPh0%iFID# zu=3|=qBZ3GqYPRxqi^KBfI&XH&a|dz9Y&kQu5rRlaL6&>RrnH^28#b?Isl}6nkz;_ zeWLDI6#EB6lOcjj8;yg)4PDtvXIP(AJLWE;JC=bkzC`QBc>~$o3=ypCuYRS|8pA6s z@=0FMo=RGUCk(FmuO-Xtv@V+yTqy(nclj*74g21{>UzLKpZl?x2!HP)R1l&6C7*mGUIT%d>J;kNgVOUR?Zo{tTOUBNVtw$CJjwj&qucd2M0dTs zgypAy$0PHQ+kcdU+nRP0n>7Wir+^VSA{V^99z-K6R5++Ubf0@u9p)1m(|7>;S z9R_<7gvbs3IyPG8*>ilYR-M%ZD1qn8!RU;@Z`w*jv?vmzy@*;1OT0v`Zn+RWVkZrs z4?=_^_Z4GkR(uT=^v6s8O<(UthK(0-50(YKGE9u8|4x8X0am2^;f-Y~fQ#0Y#3eq& zXV9b5_!*Qnv=Etlf+E!sfe;3JC`P~k-Y~(r#nlHTY&N16U#v;b*bU8o2rJs^#d4s1 zOi=F~N(QHx2M_H@C~Q$egAAvlUF@bWOUM{vq!f|gc2t%Y*GogFmG@}Vt&040?=OBV zUb4UGk_I?Xd0kU~$W6mfR=(5Yp=vklI{XKe6P{~gC%zs3J$*Z66`U7zMc>VvXA5uq zb~k=8#tu=NN>1q4gz{<*yrG)$C%q%w| zQ-Jw%GYoeAeDy~Pfe>!Q^dl0l1?{dATIJi*K#T#cMCbdX!EJ#-&2?c}vE?XzV!zk# z{3SX!n|zU#E%hvD%WcQJXS3C{ZjN;b++x%n&{^M`@8sZR_%N@MnmGrZPUe-`TkA7g z^!3gZF}#!C+`^5eh@*N*XG4a%`{WeaNGJS!{rbCOtn#5a%Xb-bKV#}pN$IUstIs)Y zyWdTJ-~d9`%VsleeivuhC>FJ%lPUcIdW!`~LIw8PFlYup#bo_r|c zzdw$R&_0CM_|^DEaW3=?x;=(RtnE7MCuw%Ug>D(cbczsthLT(AEJvfg7c z^A1mJlG%r(7~Wu-ee3>0`Z+@*{d6g8jQNY(O>0G4Wb*i;FS5O$JIen-zphPdc2v!t z@GGLQinZKA4d#-;?LC4;KCTbR=Yp>@Trt*TgFe{dqp%|JE+zei4c(b{1I@oWI_54T z`;~otGnV-HhA1{2&sW0Rp0p0(v-$Y;J!qPgv2>O{r$~gmJg{3LP-${dt@4GbtV_O> zR>CXo2eE~X+(u2bLfofUK|R6IsnL1J!J!eee58g?4Zp-?PNsZ6cynpNW|7;us;!r^ zUMrvGc$A{-2U})qhK?d>9l$M~x*BZXkW%MAk{q!U^#|NhstGDlsv?`thTo!1R|5Rm z&Fqs+4{{p@wIJd}V!SOAeLjemks8|Fkw~{H2I^|bHaB`#2~p>ZTm7hjI=Ir#NIiQ) zB-7g?eZ_?h3A3AFJUHJ|A-28!UdsNB9?nIG?5Ar6I%A^~8CQ101h0{`a}TBLLcxP- z!pytk(b0b{5$W-QlXkTOBvC-)=S%YW<*cFWV*8@S6b!A91x`!L(g};nD3eMx%RC#J zDPW|LyAKJG2j}9=_PZKBiiwej)_y)zh_u-BDmY?PSN8D7-wyPk9!E5C#>6XKApm{-@SDmxGF1WqTR7;8e1XM56Gvww3 zPDL1K1O)&3%y`K^Y7kRTQL%2> zf*$d-$6hRbE-Ur+16aiA(Z=s0dVl z@G_%cEKGqz(R!=S{C(NlJk%7l+z6{0q&c$zMgG5aHqW1yvmqO5%Pzc~f^Vx6zD8e7 z_ZI){tY${h&p?jFRL<$(0Fv4;yxiB`tGpCgBpgklJ8ayYAJ%9dnb@|f<_R>-$3ZB_ zk?$`)FUKr>{wP;$WigqYRcm@`Vsre_Q&wAuC!7nB1zs#Yiw^KZFPr{1 zGM6lWS{)Cek3Z$pDYYNKU+WD#XK3jvTMe5JQ#Nv>JX2ktGtGxhL^(18*9(qK_K-I>?(MLjE*UassJXz6!6f0YfQrefHnGvbg21Y#0 zDbLG;I9^{KPl%eyh>C=7M-CmiAsx@WEiKcZaXIXX4k{@Ers6`83Hj67@P|bRgoi^l zoWb+H-md0I_rn9@+}27F#RpWtrA>(Xp(6uc;}NDjJIJ9M93hc zpId@xfD#v^qv}AaS!YV=vrH6-6|wm5Sg_6mMFaq7}DI z-RgT}9)~=8z3LOXOwyU%qSdpFUq$zpTYM;b>>Ix6$5c$V=lV&UZ*~-?@5oCI#{u`h z7BEhfl!aBry?uRWNhYG(=smOu!BFo5fz-PxoC^Il==RZ1**&1dd_)``M++Y#Z>ygl zFhT?@?2)u!W`@2`IBwQJHuT2|kNLcb||Etl%P z{h7k2rx-xfvQ^aEziF8GJDb^W3}Z)*$;+Jj79L!mCT;_!XR5-sY!=K5JC}10|2a z*sJniD0!gn-;BJ4zhdO+{0k#5DsmdgI6Nu+I^OzqC`4jYFgCkTDLYpwgm3c=mWT#< zcqw4ppH3EU$}v3?yoFbLGGfH@YfkHU+X~}zF`4Z9jpK26sN;@;oJoD2eKahZ-AWF= z9nej4dwI6w4$Fl;oJsF%QLk45m52zXZF|S&y-}9-&6FJZ{ z_c*qyXu6$QvZKS1({4d)i7sK%+lHUru}Q11ab3`KZUZrWY&U2daP6;{JqNlo$nd7`%Z)+NKp3 z-UI4qc;9ii{Xip7L=Wbz(r&A@(v{bHHAq+g%OZ2rsTv1xt9eC}?_Grx^^s_j{SeL3 zO?S6)S#Bdr26g45!&Jqn0Gso{lm2&*%tP4PDK5h1&ersq!MyM53QF4wZJxJ#7|Rj{ z(-j+m?|*tC&u!+n4;sTIeFxVY>4!~r-kvyq`Wluywkk=~7@^HA-9y7lC;4KCP?){P z$xUuU4)H@AS9{%Ayw`yDrawz--Svo0JF~RqjDv)U{sVuQi>2rVW50B@Pj6#C5CSk8 zM60UNn^DuADSLqEnKioN04;+#ezxDHb6W8#H$E`&Bc=J~|ZT{sGaYKhDKA;Rw zop`}2BZBWtGa)Xc4DJF8!Ci@gbLD4@!`i~*E)=}+eqjv?R@d0W63N4W~uIr(Y>?JAkjRZr?W|G7C_MGdcf57znH$i#WS?AE>df-$k7T? zQyG%!n8JpPE!wuMuS;IHh`0Kj;j*qqyQSGS?1~iZyXW0;p6AAE5B!hldpfXmyGVLY zFC^csq~+96^0~m*bzi;aLF4XbA1O?W?q*zXjBSrYulqKeM7Pr`kxKEyoX}RUsgofG zv;Za;KVo{2FFY=E=BW0?F@sy)Z#OnH2V8x~&SatAJ>*u4Z~Ikq6#&Tdv6m8j_lFyT zL*icR3w|B1{^e#Zpw^{C5;MJ%+?#3X5Erkp{Q0OTsVL;K7z0zSiv3#Bsi9=xm1 z%3!?|(|Qjq&%4tO&mIcTKTHjCc%b}4XZ57oZz?+b#H&qOICA3uv^BtJB;N7Su5bvg zi;gjj;7rSwaC&4}gYwInz#CS!>IG|>T8X8mI{S!^@=Up&2G92ds=iwU)+jHmw&1nb z)=bESiwAmVo;epzx+}IfjI z3%i|43`N3O_#rWZJ-G+T)>NfCn*Mu*WK!2$n zslCkb$r?X${UYDRCc&SG$Ijq&W4Rn;K}v1lvcSUA3&eNgkR-n=FuA6dViVZ=#n$^5 zDxykpFbss-jz6uQZt-tdnijmX5-~pgbjhK(_5D;mfK8I|=G5nT5Q`M70-q;$`DKU2 z1zpI5<5xYN!I>UORgmt?iPnJ$0mQW~fe9V-ujsAEy5NVGB|G{-XpGOi&+1*}?A z0hS~(xOp*|JKqUnU>K&T{WcJ+5IbeO;TYfLsrthxGL-jer*zG0h*S%5`ao&&2n)*e z$qG)fo#y<0CBdyK91@Nay^gb(90_yE&?#_AOS^V9FCD;iS73O(ujO9Up#RE`L4W^8cgvZ_m(p3WKCaNViiHni?FB=)3u7JO%W|K%IHz zaslqDdyq~iO7Kq{30)exmufqG?K_P+F=ZLHSJ?lFn7e5o$s7=_?JX;@CLY0^A5bnh zjf1p#!{a7>>&*z5e0@qk#?^g$EcT~L;7ZX61b-hHp{5mavpsqu}~5b>&B5? z8Zl!Qj4jj-{2eH0Dkg6Q)(0d*!_w+WLn$9YQfY^E8@1Z9R-m2$qOzEa>pAdgrhOg3-)ZJSP$ zVy&ZmhB4jVH9dg<+HbUr&*Fl?kN(?(tpE47fqxVk{&oFd_V|T?Ul{m>fnON-g@Iof z_^-wQIB|zKY(M#20=0{i8)WI7JR5vQig@p^5YB`fC{J@O5_w`$a<-8{&_6#0FNZ7b ziaguU58_r;nq?FfAnRuBMr9xyQ?VeVeF z>~RJb!^`YEgzVmEJ3|73>Mf)9WPNTr|&RZc)H zU;cf83YW6mbPT^V`Rz|N|#(f3;N-FRXETOJ+898 zB}z}u&3oYZ+>LIu6)a(G<621euK*~dl^MlS z9h5s4vavZRpR9ZL7iAFpA>2K{w(3fDQp0ARaz%17w}N1^RiA!WZjI@hUDt zfZT;fGrX_*ti2865pj$o9J->nOT2-6iic|W_>dn&K^cFvdG~<)a0z-33vs3_nun|` zoQ@Agyf?W^%%MR%HrWPP4ON-Cqp9`gYePj{*~pAI!5T&i66ujm>B~FL zxZv)|X)0s6i(PNNM#AeLxj?P>ab4eC57;Ku4%9_Bx3zSfP<)oG!gic&3GBXTF~A<| zkCL>{>}J4&b&?;EiQbErW)bm_S?P-81xISWz!$Ccc{;<^Mro4oM^D>MD7O)}Qal}U zJXaz!;~v#a_bN&sU@bpAYT>ifRUp8(DOvctM~FApFnsM;7-eumCRR4AsJ`4MWLb{z zcE2!shphF&qV0oMWF9|=a0$zI5t#wT{(hy|4YmMwX4M#j5|N3go5z2CIJU3gLDH=L zZ=#lI+cH1of^b-HRC?a*%Ob<^HtgdYCfDbszAU+C zcJ%=^#pa4>kpMlT-M@Hk!)`f$UGffqGm7a#jWWd?1$13Vao=G)da~XFw-HXk>tPRa z+?6t7a$;j6JtOHs{O}fSM1nZ^gLZH?7v;#qeoUi+Jjg06K<2 zbh>!5%e+Zq4)S5ncgJi7>MND^a7TEE_(E|58!p(5ozs3Z(465mKvw7%O9!8<)2iNz zs^USrBk<>!FjgK3i22gp{ff{thO(XZqT*x zwTKw3_TsXRpL<@ohNwkHs(+t144xYWc1MBb4XC27Cfkl63$^~1x@YP zREy6*E_FbZB%pf$|L+(h^i7Ves3X-)OzPQkr+fsNAaif<~`UzVj~eNSI@R zs2T!9P;n?5n?W6CeWDyqLU=5#imQBtu~C;NjHerGqHl!!f>n`~r8;3&1hdQ~+E4qd zK#3<1x2vYBdLlL51VfVm3015zgw(@RC}=Bfc(FEN0^B%N8q=}D@WCs1rA7BpM^R*Y z)52EBCuWJ_!4^!*&hs9GEs zq$pDvK01L8+r%-7^QZTT}7so)=N=S3i7ojpwoK@eZ;#Sn|!evISDD>y^Y<8;$k2WTYl;XDF29I z|Iy(~p3cXWqb6Vtv1C_AIlQY0v#XFB_<{~h5ia`WkVo&lfJeaH1&|7|@z8d$U`rsM zEAIL&3}VLH%2Io{rSnYa)UTqP=kh@ZueQVIN@bfTgNh<<{=_M<(Z*`P47AV&6bO+; zpXjP`Is0?mt#`$D^KXZ)v+*>}UITO)cr1a=VA9b)hEn` zmU|rMrBnQB6BQli2lkOr-isM*=>mmbg)ieZ+n*Hzftr)N)xEw25Lq94Tj2AZHi2pG zY_iR|i=HflKo_|kOR3Ut{tih=URo0rpK_+#icHo;_NL^m%L`wMpxBav z$5ORaOxjwG?oBE?gjhP#gqzm!j}_NeCk*5ci|7~>B`)nD(e2AwfthPLQU|ZFvH0?_ zK49YVgkR89f#*UGBbz>FPIEqcz2APm=BQY@UQnOOek*u0aE8!Z6%E2(QwN9ELp_SIG z&llL(YNg`>v{Fcx!>Z(&12or3+H+9Ee!O%m-x8jOIzN_!eACM%Xg8WB>EvvzD={XT zIvu&@Y;u1083d|(bgbU|UJ>ymLCfzldt_xBU7W=#Q3r66Ff85Vw}hnNmrrCM-#&5@ zU|Dp&gPG>jSx28nQp<8U4^>h)i)^DX2K7DomStTwEkLO35cE19P&mzK;<~0D-i}jL z?5L3%(^cnqt1%dBDm;z{;(Sl}Nv} zWc69rhx=SFW2J1H5gr-okf>?0Mrc)4Yi8rQG!3L(01c5&pG9Mr)&VTHVTqj62q+fw_3f zJ;X!A4V?YUeq8SizefTm3*_g3F*xkRC9MZ%g}9v>q?*Qz!1#gj0t~*o=)r#+g7-o1 z6NaEB^fu2sGm`d$3 zEi5jl-D<@6iL&vnHwFewVZ2CR`#T9VO5X>mKYmD~sK016`e^nvuwul4{gxw)ZbEta zd(?$H_x2c4AL2%RnKi;VmFUOjKhtz(YE|BNx*gk-q~mNjV_+ImQ}?lAS7XMK)6*0C>N)<0ool|LKWO+bRO zhU|+h=rZ$`wmuN^pZ7DmmgI!T$ZKschn~bVSmj+wu86x+n;_38+%ne1uhs@KIw+o~ z&d$G^2en&8z$M%^?FsU1+yXD1olu7(6Ei0Dr#CHdo&`_nJCQ@rCj=&W1>fLE7YiDy zP<6u6u}*1v9k5JUFy;Q}xlqEO#RtkNkgBXxLTu0w?6N)icCQ7?(Fc)5GdV!<-M}2I z9g{^jxj#7JzTRL=(yEa~^IfaK3vDv}gQz=CV`8ey8b;Mkp`n)qDAmf!%DM|Bl!*;N zr$KU1IzQV9*&@6JnWXv7>Z^#ai`o+l(lk>-GuL)I=IH}NeZ(Bk5|HBfEowz|gt*=F z@gp(Y@FJR?gNH!&(fz;GU-+HE*QMPNpU&Qn_(*(piZyVp^9Rw!$oL44shWzRLT$;1 zIqT4DA4&@x1Knzqww7H}#<-AqQ1<#j47HZ`imWos9#BoK9Qv&I%sD*g3l){``vlun zoK=FG#eC4pC*~ls_6;g680$XOTBGf-#R#N?#hz=~@QNfqwD5?rGvmk%yMj5GuN$0L zwv+gX9S%k-OoGi+t|7Y>!*GuWRlTDJ)%6il9o-_x>(JHN6xUW9 zG3MifkG&z6D&uP9`YJrH=j-A7Q_{|`9w%+QBk!fZPvl;#R5WHAUu*tx+(`10O}F#S?@B4- zn>bxn_N4s5m*GE%wpG2Q6ozuMcp?-$I0lp1#T_yVO^VV=nY0VOU4JYl`9bl8d!DPk zhQ@U_IA3G}QiAKtID2gHY~aKosXJ1BeJTOKfp z&&(_IncU(QpWB6(yLby{2cwXUi>OJSnf85_h|J8ykjm5qUxY(pS(XW=GQJA>IWc(` zvUTCw)~c%Dw>C{-Of1u8uO6(8%oM@ljW4pbUvu zSWQQ))*98K5ccLI_hY|Wftu?3X2G@2PeWoVT$&JR*#AEOT6l~ufLr@warQmNc<+N zeVRCwP>Jvz4T0KH zU!PRCh`lE5<)N4t*fWXZ8GkMy;4RoIjt)R=iiU13o`3%=>e2pW6_87hc!7|{8KzfM zCOhSKX9{uiI%7*F&bK0YE6iOY;*?!z zq}PEXH=61Q^@w@);0Z*)gpF4Dq5X0$qte1MC?4YPk>%5%qOa8?CuQ+@m$rgK?K)aM zS66q|5S-Z6^VG1ZFIn7XSKPtepLQ+!?22=&RQ={idVA%lpiHTmSXd{v?a4xs`#fi7 z76%DZ#OY}gbXX&xU>lp)IP4in4sR=?y1^N$1H6$>%oi zwc1Rp&69y{*}2n+r1CT=I=5qao)kp(iof(M=9S1xuTw7n5H$FZt3jOqe&32Ne2y9Q zxJ)4-Ysy~m6YFl)UD^mu|F3;iLz*O0$LZ0vWsSy-?JGIKN(@Eyj3c#<1nYE+K~C`P zq4M}IgP(HZ(6D|(=2p{ik~Wai9vKds-uTg^X?v>7(PNtQs+ts~YK0@=y0JUqt#}~e zLL+X3Eb-G82NatV1x=*Sj10N=^=pUpuvtlI^R!TdA(p1@iQRhQF)$ZX@f4L;#j6`W z@L!5;Vh&#%eFX)Vg#noh8xV59S(6;Ua}sWDmrmj%bQvdW3<~WJx`r5%^y-i_Sq~pU zf;tK+j%RrDi%ej*ddjdbho`yjyepGn`dwp$bdiPQQZ><8 zFmX_`il`ba_2~!nllvsPFD$mVa0KnipQ<-RPx*;f!Oh)*)z!5g4)yS#Y~>>jO~euW zW15+nE5IE54OhvMK!Y`ly8J;>gHu+%DdKv9nu$ioFljsP`|wmxEsBF$+Ay{Vh`o|X+1ecIEe!qAO2O-jT=%L}4y z+fvyd=tIsA`&IyarN|B|_hYyIUMY)D4*aZ!aFe#~N>y=S_ehtM&~%OCT3&~` zu_zwA1@M)8KZw|YQoVVA<@?}uVC)q3npT?S`9;%^;z=pdV#46{frsRJRwdz!+ zZX>jkzctiWRYp`lX-D__R@~@*S)vQ0?m+MI(l9)kjsZ9Y(9P% zrB?Au&Ci>;fw4@K`k|qE^2FVT1S?>eZOE~fuLR`&um>UjTzTQLE`b} z+q(r?jZc-ll=mbr1#iJ9{k<|NRKiB;yM5j+ix4sn3Zu7=T8U<%X{RB8RdM+z3RYtJ z1^FS%o5v{^w#7b5h(UmYhsf@~Jf8el@PHZCPp_jUXow4=IRVDfHbsIo_AJwPU+LRC z2#2A?=CDY_{n$I#sB2Hb&|mluU}jtRgS)x7lBKDf5OoOeQ^d_FTVK zjJhe;^nvw2mf4?N0}%@gahAtXxFi+8@Uv&+v;Yi$&4B#BGyF``;4vueBTgNnJeu1; zt*qbo;U=w>@M&F_ct2K@>0zGgORxnrvzE~i$T$) zZ%+%INVCSc{PdEDfcn~E53+CeS?BWC)#ncavFVWAcBYlHj1!%W4LRq`@s`j9UG zRk=h9CakVPQtMq~_iEytHq+PC2c=BmIAY}M&ia^GCFH*GPr8ig5cv7uR?Yp}|CMXE zk4UPguWo1@5?DXL!ko8`$s=*73#m8DZ@%Cb9i-F_ayls~&iCM!)%JK;vFbA1+Mm67 zKeKltc&>5IcGYxm4RCVka=_WG0?w}BGrTW5;|G!N5YQI42vT+rzPI@aNK-b4Co}f^ zY^6TZ-?%aapr;WEplIL+5t*(GfC3eH!dVW`zeE1e3eaaQA@n!>AQG2I00%|P$N6mr z1f1MkAK-<^2{&fpGGtLSY_WK?J8Sfopj|PJ?ZS1lFE?XXF2#S&k~Ag_?@xF!3QQL< ztN+Nd{N;Bri`I@@NX8fCNnF%JlyFz$qJaE@-gR${e)WkB!HN&8LsZ@T*vxVs=Qd0a+y-{c2mm!0qM@5aXA%&zgmKuLz3pv_^;A)3X1%atbdOYHR;uke>fH7Pk8zdOM)h7OjqPxWM88Hc&Fg6Qd#1jCl=CggEr>zxFS5Bp)I5yuQSa5^x4y4mYY^4$UsD_Vb|epxI;Qm&@CNU zwBfm=oo&KonsX$N!51jc!{4XeV+wq+==hs*6s6;w={lf#MtTyO${q6aNi}pGNV^Ml zvvsd(xK(cL-voM^MX6~(@8(=^qt$vQO02t8VnN z3Ovg;bg+O&q#ufIYnI;_ONklF@XS(3m-A%w%g^m#-Ty5lt&Cpj@`bAkET5^QdiR~7t{V!zY3Hl`BBP%mxF=IwE!k&&kG5RUC|}9JV8>8LGWC>-HKpnDHr86MT1Gi@KI@9 zlToL??kgbn^k^_QJ^0w==NkGiPWTcsQ@uQjU+byeUg4Ok9 zS565-_Y+dUf{Gk@LNQuRsM!hnFBbx)P0eFCC+Ld>F{TO=hAE^f9|mM^lKdQGoDXmN zUB2MToV=vCMC&FRNAG}lN_}!Nboc!KzD<_*{=p`@|F77jz)>RCGC)qV-=9@?P$Y78 zyp)T}vD64~cy*0O-?Hm&$RSfW)Ym&@c`c{7+gI~$`x$;(@FST}d~TK-ETAZrn{v6x z+Jhr(K9&L{PjmY;m>1#j+1f60K=z5f!>s{_?(1Z3K7PhIP>1TiCqwo;-`Lx2elHeC z`|$7r&`VtPo&xjr7;{>-M+<)P>ZvBO0%2dbyxD;9)1+03Vufx}P+2*c@F9Rg8+-vO za!?PYFeboHUYK+HZGZ4_dOc(=@O{cd_CV*wjZ4bU)Ewtc*C9YCet|pqZHtCZCFVd1 zkKm6N_^ds13hCd^2YPrIo!n0U7eUK^`2YEpFyG?}zN@CwU-~`?+W#POW#C)AXf>3n zqeyGG_1nXfA-nxtSs5xqJNgn z98AbtNM~)IDwb9}9a71wP2(o&9hw?tlID*w%c&Bn+PBsr)dWcfw|bZeTuT7| zIz2Rwc2gI|=+LzCWQ4cSVT<>90{G>fQ;B0In$AV+s$hg|uY*J8XIhh8)aW3-z|i|> z14>0j(y3mNk+nIvh3Ima_sBl!*@R)lTrq=@MuBmf{P!~3Zu1jIrg-Tljb`Eqx87Kn zdE+Np4Z(_KoP6q?8Tt;J(lRee>l^qp$JH z68B-ycP_E#z7xslHc(Jzi@TUWO;Tr#4Yh`aFk>hQA!S4Li^%ea?n-i3?``#4uY-Gg zwCaPSR!=88e68IKMk}0rbnT9#Y@(<8W{<76r*0jRPrPZ-Y-iwlK}-M9+2yUiFLTX~ zxA@JT+`i|B8rNV>?0gs_S|T5iQGZ(t|MVR~7a_aD zn_)jIrL=H#exvAO{TKdFCeOa3a4FmGjq|KF<#zTag6yg8Ic-u+4}uv}bBPWw7X0LG*lW6FN7k_*-b?Cx)Gx z2$$mp;SOE9Lb7SQ2llF)>4W9DM8?wXeAiRW(V=+skZ`MRfnODia>l_aS{IF#oH9Nh z!ZsH0hE&b`E3B;lJ60tB3$XIyfGp7-+$0i|r)Xj49DR9FPJ33An41K2=Cxp=P zS4rNcReqb&=wgq{No9t6E{=4k7(27rTHvYPj_duJhR_PL1MU-~Zn{CM-J}$k;nzs@i>I)mu$y|9Cx|L~MRb|Md3v><@ zOi5y4(E4ou9BG<06VZqFA7UMTzHOXIU{E%^J*u(HImNFv_3}LbatU73X}-FgxwahT zXek*&yZhUXYVYO`knw_1D74Un_q(y9x-n1BV&-P0)y2|>#u-`9Fq*5VnJaGryo?7%(<8OzDWe8zRR49K8A{!VX6`BN(&B5qUFtQBye`a@Tv%M6 zaohx4C9LPw&7>1~SoW5W>Z=yf_=)T=^218dv+aYr2JJcvkf0g9twzf8TI$0B4rX*)VJCT{fv*mEIz z)EfV?wfvuy2mkz>B-wX5JE#d~!|UQ}ivn%fqIP_#{G1+alL@ko#3VRRPq1S!PhVyf z22K0cw=G~yc!3oUzx-3XErD($Co$KPBGAFIx0QK-D_D47y%BM{I74YiJ2u6iBHkxG zWH{JD05b8!!(tzVs__Ds7SZS!mEkAw;Rf2)iZh@Ld@q7rs@ip-HbtGv59+}xwDENPzwW3)sS^=(i^7>*}3UAEcLrYox=oCoa+#hVV-VRRFg zuq>6}rEm9nn5fghLkzkPEq5r+*kiZ)jpP7oC1djY1t*pjzpvyaAX7pWy{!00B`T_{ zn_M0V!_y1wZqzfPbm4D>L~nVHkd#gA*7prFA*wh;r(^Zc~x|41bfa+7dmE&3ofLRE_>oGuATK&Am2D zPG-aHlG01UNkfh26ZY--Y7a#`YD;xuQ}b2M4r?ml#qyBALZMg6E*JQtxfd&+l%|OK z+#`4tU7NS(QY=4q*w03ah+KB0Q^095r`E|k^(igg&G#@+F&r(x)PQfOOPsiFe#t7t z#7`WoOz=JLy~GkGcm3XKdYMgn?H6v`n(?H!fSbIw7xW@lbAGtoI>chFVOX1&FFp#uhC9N1Q^r znrIK;>`g#|5>;oFMk}Mjyk+x9Dc$B$y*6{Uik5g~3DG3WEB=#F-7YC_w~IA``_^4+ zVk&C)9QQ2GY_pPF%XUrEMGklz=u;`yYGt#K&5V_6?A+sfY*K`eeJkO^s})E`oIH)DG(Q3LeD`RetLhO zC1GVXi-D0w;yb1oi-v97f0o~2paW-vH;jr@_&7^!f>nThTTgva`t?pjCr`DRXYf8v zgNXSeo&(m#LSvYE|}?hv{B{O$ic|j>=)r1jXAPI&kl?uzBJ9t1;>~&j3_%C*{`squ>dO}i& z@OI?CDG)tRd97RSalUEm^IDI)TcTs}>&}!fIhH3!kie{$Rvy)JC7TCce3%oa=wa<2Xrkpql#Y;7^p7VIs}p3UUF zKm94p>n5f-D!o?PeR!WoP5wjHSxm|6mkgnwPxxn1FdzO-TBQ;|;BVxz5F?Y-G;j2? z&2?0}+AhL3{_5IkyWL{n^=x@Wjg(|xaxUU?;~YbO<0@GWe3lFD584j5G2Op7)VNIr zX{rF!a-nb*K|*sLe)V`c_=KKtt%r>8y4IcWTMiB&TuGJzlJbEuASiQA6Av)?KR->m zA)eYBkzyzRq`yMy*@L)S8r_$_z2twp-uA|1hv{ub(`5SK3-x-P@pA-iA1yBbr$mfI zh50)asmOqa7lSGCh(;;NaBvfxa&uq*`jPtcntF!xH@lC0XSa^gVeT@b7MuvaS3G1S-%P}aZ1azpc)v{(4X;p)>I8HSjVpYhZ; zCBLWb{d)cHQOy5k_g{AZg@Iof_=SOA82E*O{~QK%bZX|M1e^Q6AMK@zSX7eP#B>O4 zo((_j0`U8ic(ZQgFv;hz?yJc`}F{va9y*;n^X{2-d+ zoFpWk6-889OjgCOE#Z^zo(H#{1cri|H;X#%_uDhqR9+o>{Afyv$yLV6scE}y(db|) zLTP_}p#j*|wEMgKATo7>pJ-FL2@(CXN2g=@UO0E3ky#n#k7eWjVmSG^Sq+?=`*vMn zrKDriAhz2hi4vz!$87b3D8eaEF=>BKx<{m&aKEkL?r(R!Iba2k%WyfGwKd5E3u|j9 zw)%3&#_M;23#YxRKEz7w+gYf{8)|d*O6xPO$NtHiE%CR8;H8hEI#Rdp(CkZr3)5c< z3SF_1dLHqUYsorbzkg`}+@ zOby4yf3H9II}yn*>FDlcKI>z1YtwD0As;6-4g>-QzHYomEqI{WHmInCQh667HgxJD4;2K0)!f0AD1Ne8?}7DpXRv5 z60SuEY_Ky3CfcK<*7InBP*w)95}TAKERQwAuU>Y#syNV|aIg7g&Wh2iT#QNTzv#ZC z<4}{)S`5|D?_g;6}bZ%!%IW0WK9{qsZ;8YZ!_>c(x63MiDU$B8GS&?&9! zUfaX1C(`_tj6z`^XF@fNxP;Z*GzuGB@42BzJC{$OK%-WF?S3rBh__R&ZHCG)4-cfw dtWu}Gia*YYweSHkg8cqbal`)~Y7{@l{|8uSf`R}5 literal 0 HcmV?d00001 -- Gitee