openharmony/arkui_ace_engine
1
0
Fork 0
mirror of https://gitee.com/openharmony/arkui_ace_engine synced 2024-10-08 09:15:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

drawing area size

Browse Source 
Signed-off-by: huangdong57 <huangdong57@huawei.com>
This commit is contained in:
huangdong57 2023-07-12 18:00:39 +08:00
parent 7de7b7f7c6
commit dead3283b9
9 changed files with 462 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
frameworks/bridge/common/utils/componentInfo.h Normal file
View File

@ -0,0 +1,56 @@
/*
* Copyright (c) 2023 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.
*/
#ifndef FOUNDATION_ACE_FRAMEWORKS_BRIDGE_COMMON_UTILS_COMPONENTINFO_H
#define FOUNDATION_ACE_FRAMEWORKS_BRIDGE_COMMON_UTILS_COMPONENTINFO_H
#include "base/geometry/matrix4.h"
#include "base/geometry/ng/offset_t.h"
#include "base/geometry/ng/size_t.h"
#include "base/geometry/rect.h"
namespace OHOS::Ace::NG {
struct TranslateOption {
double x = 0.0;
double y = 0.0;
double z = 0.0;
};
struct ScaleOption {
double x = 0.0;
double y = 0.0;
double z = 0.0;
double centerX = 0.0;
double centerY = 0.0;
};
struct RotateOption {
double x = 0.0;
double y = 0.0;
double z = 0.0;
double angle = 0.0;
double centerX = 0.0;
double centerY = 0.0;
};
struct Rectangle {
SizeF size;
OffsetF localOffset;
OffsetF windowOffset;
Rect screenRect;
TranslateOption translate;
ScaleOption scale;
RotateOption rotate;
Matrix4 matrix4;
};
} // namespace OHOS::Ace::NG
#endif // FOUNDATION_ACE_FRAMEWORKS_BRIDGE_COMMON_UTILS_COMPONENTINFO_H

24
frameworks/bridge/declarative_frontend/engine/jsUIContext.js
View File

@ -112,6 +112,12 @@ class UIContext {
return this.UIInspector_;
}
getComponentUtils() {
if(this.componentUtils_ == null) {
this.componentUtils_ = new ComponentUtils(this.instanceId_);
}
return this.componentUtils_;
}
animateTo(value, event) {
__JSScopeUtil__.syncInstanceId(this.instanceId_);
Context.animateTo(value, event);
@ -156,6 +162,24 @@ class UIContext {
__JSScopeUtil__.restoreInstanceId();
}
}
class ComponentUtils {
/**
* Construct new instance of ComponentUtils.
* initialzie with instanceId.
* @param instanceId obtained on the c++ side.
* @since 10
*/
constructor(instanceId) {
this.instanceId_ = instanceId;
this.ohos_componentUtils = globalThis.requireNapi('componentUtils');
}
getRectangleById(id) {
__JSScopeUtil__.syncInstanceId(this.instanceId_);
let componentInformation = this.ohos_componentUtils.getRectangleById(id);
__JSScopeUtil__.restoreInstanceId();
return componentInformation;
}
}
class Router {
/**

17
frameworks/bridge/js_frontend/frontend_delegate.cpp
View File

@ -19,6 +19,7 @@
#include "core/common/ace_application_info.h"
#include "frameworks/bridge/common/utils/utils.h"
#include "frameworks/core/components_ng/base/inspector.h"
namespace OHOS::Ace::Framework {
namespace {
@ -114,6 +115,11 @@ bool FrontendDelegate::GetResourceData(const std::string& fileUri, T& content)
return true;
}
void FrontendDelegate::GetRectangleById(const std::string& key, NG::Rectangle& rectangle)
{
NG::Inspector::GetRectangleById(key, rectangle);
}
template<typename T>
bool FrontendDelegate::GetResourceData(const std::string& fileUri, T& content, std::string& ami)
{
@ -132,8 +138,7 @@ bool FrontendDelegate::GetResourceData(const std::string& fileUri, T& content, s
}
template<typename T>
bool FrontendDelegate::GetResourceData(const std::string& fileUri, const RefPtr<AssetManager>& assetManager,
T& content)
bool FrontendDelegate::GetResourceData(const std::string& fileUri, const RefPtr<AssetManager>& assetManager, T& content)
{
std::string targetFilePath;
if (!ParseFileUri(assetManager, fileUri, targetFilePath)) {
@ -150,9 +155,9 @@ bool FrontendDelegate::GetResourceData(const std::string& fileUri, const RefPtr<
template bool FrontendDelegate::GetResourceData(const std::string& fileUri, std::string& content);
template bool FrontendDelegate::GetResourceData(const std::string& fileUri, std::vector<uint8_t>& content);
template bool FrontendDelegate::GetResourceData(const std::string& fileUri, std::vector<uint8_t>& content,
std::string& ami);
template bool FrontendDelegate::GetResourceData(const std::string& fileUri, const RefPtr<AssetManager>& assetManager,
std::vector<uint8_t>& content);
template bool FrontendDelegate::GetResourceData(
const std::string& fileUri, std::vector<uint8_t>& content, std::string& ami);
template bool FrontendDelegate::GetResourceData(
const std::string& fileUri, const RefPtr<AssetManager>& assetManager, std::vector<uint8_t>& content);
} // namespace OHOS::Ace::Framework

2
frameworks/bridge/js_frontend/frontend_delegate.h
View File

@ -26,6 +26,7 @@
#include "core/event/ace_event_helper.h"
#include "core/pipeline/pipeline_base.h"
#include "frameworks/bridge/common/media_query/media_query_info.h"
#include "frameworks/bridge/common/utils/componentInfo.h"
#include "frameworks/bridge/js_frontend/engine/common/group_js_bridge.h"
#include "frameworks/bridge/js_frontend/engine/common/js_constants.h"
@ -92,6 +93,7 @@ public:
{
return "";
}
virtual void GetRectangleById(const std::string& key, NG::Rectangle& rectangle);
// distribute
virtual std::string RestoreRouterStack(const std::string& contentInfo)

61
frameworks/core/components_ng/base/inspector.cpp
View File

@ -321,6 +321,67 @@ std::string Inspector::GetInspectorNodeByKey(const std::string& key)
return jsonNode->ToString();
}
void Inspector::GetRectangleById(const std::string& key, Rectangle& rectangle)
{
auto frameNode = Inspector::GetFrameNodeByKey(key);
CHECK_NULL_VOID(frameNode);
rectangle.size = frameNode->GetGeometryNode()->GetFrameSize();
rectangle.localOffset = frameNode->GetGeometryNode()->GetFrameOffset();
rectangle.windowOffset = frameNode->GetOffsetRelativeToWindow();
auto pipeline = NG::PipelineContext::GetCurrentContext();
CHECK_NULL_VOID(pipeline);
rectangle.screenRect = pipeline->GetCurrentWindowRect();
auto renderContext = frameNode->GetRenderContext();
CHECK_NULL_VOID(renderContext);
Matrix4 defMatrix4 = Matrix4::CreateIdentity();
Matrix4 matrix4 = renderContext->GetTransformMatrixValue(defMatrix4);
rectangle.matrix4 = matrix4;
auto rect = renderContext->GetPaintRectWithoutTransform();
const double halfDimension = 50.0;
auto center = renderContext->GetTransformCenter().value_or(DimensionOffset(
Dimension(halfDimension, DimensionUnit::PERCENT), Dimension(halfDimension, DimensionUnit::PERCENT)));
double centerX = 0.0;
double centerY = 0.0;
if (center.GetX().Unit() == DimensionUnit::PERCENT || center.GetY().Unit() == DimensionUnit::PERCENT) {
if (rect.IsValid()) {
centerX = Dimension(center.GetX().ConvertToPxWithSize(rect.Width()), DimensionUnit::PX).ConvertToVp();
centerY = Dimension(center.GetY().ConvertToPxWithSize(rect.Height()), DimensionUnit::PX).ConvertToVp();
}
} else {
centerX = center.GetX().ConvertToVp();
centerY = center.GetY().ConvertToVp();
}
VectorF defScale = VectorF(1.0, 1.0);
VectorF scale = renderContext->GetTransformScaleValue(defScale);
rectangle.scale.x = scale.x;
rectangle.scale.y = scale.y;
rectangle.scale.z = 1.0;
rectangle.scale.centerX = centerX;
rectangle.scale.centerY = centerY;
Vector5F defRotate = Vector5F(0.0, 0.0, 0.0, 0.0, 0.0);
Vector5F rotate = renderContext->GetTransformRotateValue(defRotate);
rectangle.rotate.x = rotate.x;
rectangle.rotate.y = rotate.y;
rectangle.rotate.z = rotate.z;
rectangle.rotate.angle = rotate.w;
rectangle.rotate.centerX = centerX;
rectangle.rotate.centerY = centerY;
TranslateOptions defTranslate = TranslateOptions(0.0, 0.0, 0.0);
TranslateOptions translate = renderContext->GetTransformTranslateValue(defTranslate);
if ((translate.x.Unit() == DimensionUnit::PERCENT) && rect.IsValid()) {
rectangle.translate.x =
Dimension(translate.x.ConvertToPxWithSize(rect.Width()), DimensionUnit::PX).ConvertToVp();
} else {
rectangle.translate.x = translate.x.ConvertToVp();
}
if ((translate.y.Unit() == DimensionUnit::PERCENT) && rect.IsValid()) {
rectangle.translate.y =
Dimension(translate.y.ConvertToPxWithSize(rect.Height()), DimensionUnit::PX).ConvertToVp();
} else {
rectangle.translate.y = translate.y.ConvertToVp();
}
rectangle.translate.z = translate.z.ConvertToVp();
}
std::string Inspector::GetInspector(bool isLayoutInspector)
{
LOGI("GetInspector start");

2
frameworks/core/components_ng/base/inspector.h
View File

@ -19,6 +19,7 @@
#include <string>
#include "base/utils/macros.h"
#include "bridge/common/utils/componentInfo.h"
#include "core/components_ng/base/frame_node.h"
namespace OHOS::Ace::NG {
@ -27,6 +28,7 @@ public:
static RefPtr<FrameNode> GetFrameNodeByKey(const std::string& key);
static std::string GetInspectorNodeByKey(const std::string& key);
static bool SendEventByKey(const std::string& key, int action, const std::string& params);
static void GetRectangleById(const std::string& key, Rectangle& rectangle);
static std::string GetInspector(bool isLayoutInspector = false);
static void HideAllMenus();
};

77
interfaces/napi/kits/componentutils/BUILD.gn Normal file
View File

@ -0,0 +1,77 @@
# Copyright (c) 2023 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("//build/ohos.gni")
import("//foundation/arkui/ace_engine/ace_config.gni")
configs = [ "$ace_root:ace_config" ]
template("napi_componentutils_static") {
forward_variables_from(invoker, "*")
ohos_source_set(target_name) {
defines += invoker.defines
cflags_cc += invoker.cflags_cc
if (is_mac) {
cflags_cc += [ "-O0" ]
}
include_dirs = [
"$ace_root",
"$ace_root/frameworks",
"$root_out_dir/arkui/framework",
]
sources = [
"$ace_root/frameworks/base/geometry/matrix4.cpp",
"js_component_utils.cpp",
]
deps = []
if (platform != "" && is_cross_platform_build) {
deps += [ "${crossplatform_plugin_root}/libs/napi:napi_$platform" ]
} else {
external_deps = [ "napi:ace_napi" ]
}
if (defined(config.libace_target)) {
deps += [ config.libace_target ]
}
deps += [ "../utils:napi_utils_static_${platform}" ]
subsystem_name = ace_engine_subsystem
part_name = ace_engine_part
}
}
foreach(item, ace_platforms) {
napi_componentutils_static("componentutils_static_" + item.name) {
defines = []
cflags_cc = []
platform = item.name
config = {
}
if (defined(item.config)) {
config = item.config
}
if (defined(config.defines)) {
defines = config.defines
}
if (defined(config.cflags_cc)) {
cflags_cc = config.cflags_cc
}
}
}

228
interfaces/napi/kits/componentutils/js_component_utils.cpp Normal file
View File

@ -0,0 +1,228 @@
/*
* Copyright (c) 2023 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.
*/
#include <string>
#include "interfaces/napi/kits/utils/napi_utils.h"
#include "napi/native_api.h"
#include "napi/native_node_api.h"
#include "native_engine/native_value.h"
#include "frameworks/bridge/common/utils/componentInfo.h"
#include "frameworks/bridge/common/utils/engine_helper.h"
namespace OHOS::Ace::Napi {
namespace {
constexpr size_t STR_BUFFER_SIZE = 1024;
}
static napi_value JSGetRectangleById(napi_env env, napi_callback_info info)
{
size_t argc = 1;
napi_value argv = nullptr;
napi_value thisVar = nullptr;
void* data = nullptr;
napi_get_cb_info(env, info, &argc, &argv, &thisVar, &data);
NAPI_ASSERT(env, argc == 1, "requires 1 parameter");
napi_valuetype type = napi_undefined;
napi_typeof(env, argv, &type);
NAPI_ASSERT(env, type == napi_string, "the type of arg is not string");
char outBuffer[STR_BUFFER_SIZE] = { 0 };
size_t outSize = 0;
napi_get_value_string_utf8(env, argv, outBuffer, STR_BUFFER_SIZE, &outSize);
std::string key = std::string(outBuffer);
OHOS::Ace::NG::Rectangle rectangle;
auto delegate = EngineHelper::GetCurrentDelegate();
if (!delegate) {
NapiThrow(env, "UI execution context not found.", Framework::ERROR_CODE_INTERNAL_ERROR);
return nullptr;
}
delegate->GetRectangleById(key, rectangle);
napi_value obj = nullptr;
napi_value size = nullptr;
napi_value localOffset = nullptr;
napi_value windowOffset = nullptr;
napi_value screenOffset = nullptr;
napi_value translate = nullptr;
napi_value scale = nullptr;
napi_value rotate = nullptr;
napi_value transform = nullptr;
napi_value width = nullptr;
napi_value height = nullptr;
napi_value localOffsetX = nullptr;
napi_value localOffsetY = nullptr;
napi_value windowOffsetX = nullptr;
napi_value windowOffsetY = nullptr;
napi_value screenOffsetX = nullptr;
napi_value screenOffsetY = nullptr;
napi_value translateX = nullptr;
napi_value translateY = nullptr;
napi_value translateZ = nullptr;
napi_value scaleX = nullptr;
napi_value scaleY = nullptr;
napi_value scaleZ = nullptr;
napi_value scaleCenterX = nullptr;
napi_value scaleCenterY = nullptr;
napi_value rotateX = nullptr;
napi_value rotateY = nullptr;
napi_value rotateZ = nullptr;
napi_value rotateAngle = nullptr;
napi_value rotateCenterX = nullptr;
napi_value rotateCenterY = nullptr;
napi_value matrix4[16] = { nullptr };
const int m00 = 0;
const int m01 = 1;
const int m02 = 2;
const int m03 = 3;
const int m10 = 4;
const int m11 = 5;
const int m12 = 6;
const int m13 = 7;
const int m20 = 8;
const int m21 = 9;
const int m22 = 10;
const int m23 = 11;
const int m30 = 12;
const int m31 = 13;
const int m32 = 14;
const int m33 = 15;
napi_create_object(env, &obj);
napi_create_object(env, &size);
napi_create_object(env, &localOffset);
napi_create_object(env, &windowOffset);
napi_create_object(env, &screenOffset);
napi_create_object(env, &translate);
napi_create_object(env, &scale);
napi_create_object(env, &rotate);
napi_create_array(env, &transform);
napi_create_double(env, rectangle.size.Width(), &width);
napi_create_double(env, rectangle.size.Height(), &height);
napi_create_double(env, rectangle.localOffset.GetX(), &localOffsetX);
napi_create_double(env, rectangle.localOffset.GetY(), &localOffsetY);
napi_create_double(env, rectangle.windowOffset.GetX(), &windowOffsetX);
napi_create_double(env, rectangle.windowOffset.GetY(), &windowOffsetY);
napi_create_double(env, rectangle.windowOffset.GetX() + rectangle.screenRect.GetOffset().GetX(), &screenOffsetX);
napi_create_double(env, rectangle.windowOffset.GetY() + rectangle.screenRect.GetOffset().GetY(), &screenOffsetY);
napi_create_double(env, rectangle.translate.x, &translateX);
napi_create_double(env, rectangle.translate.y, &translateY);
napi_create_double(env, rectangle.translate.z, &translateZ);
napi_create_double(env, rectangle.scale.x, &scaleX);
napi_create_double(env, rectangle.scale.y, &scaleY);
napi_create_double(env, rectangle.scale.z, &scaleZ);
napi_create_double(env, rectangle.scale.centerX, &scaleCenterX);
napi_create_double(env, rectangle.scale.centerY, &scaleCenterY);
napi_create_double(env, rectangle.rotate.x, &rotateX);
napi_create_double(env, rectangle.rotate.y, &rotateY);
napi_create_double(env, rectangle.rotate.z, &rotateZ);
napi_create_double(env, rectangle.rotate.angle, &rotateAngle);
napi_create_double(env, rectangle.rotate.centerX, &rotateCenterX);
napi_create_double(env, rectangle.rotate.centerY, &rotateCenterY);
napi_create_double(env, rectangle.matrix4[m00], &matrix4[m00]);
napi_create_double(env, rectangle.matrix4[m01], &matrix4[m10]);
napi_create_double(env, rectangle.matrix4[m02], &matrix4[m20]);
napi_create_double(env, rectangle.matrix4[m03], &matrix4[m30]);
napi_create_double(env, rectangle.matrix4[m10], &matrix4[m01]);
napi_create_double(env, rectangle.matrix4[m11], &matrix4[m11]);
napi_create_double(env, rectangle.matrix4[m12], &matrix4[m21]);
napi_create_double(env, rectangle.matrix4[m13], &matrix4[m31]);
napi_create_double(env, rectangle.matrix4[m20], &matrix4[m02]);
napi_create_double(env, rectangle.matrix4[m21], &matrix4[m12]);
napi_create_double(env, rectangle.matrix4[m22], &matrix4[m22]);
napi_create_double(env, rectangle.matrix4[m23], &matrix4[m32]);
napi_create_double(env, rectangle.matrix4[m30], &matrix4[m03]);
napi_create_double(env, rectangle.matrix4[m31], &matrix4[m13]);
napi_create_double(env, rectangle.matrix4[m32], &matrix4[m23]);
napi_create_double(env, rectangle.matrix4[m33], &matrix4[m33]);
napi_set_element(env, transform, m00, matrix4[m00]);
napi_set_element(env, transform, m01, matrix4[m10]);
napi_set_element(env, transform, m02, matrix4[m20]);
napi_set_element(env, transform, m03, matrix4[m30]);
napi_set_element(env, transform, m10, matrix4[m01]);
napi_set_element(env, transform, m11, matrix4[m11]);
napi_set_element(env, transform, m12, matrix4[m21]);
napi_set_element(env, transform, m13, matrix4[m31]);
napi_set_element(env, transform, m20, matrix4[m02]);
napi_set_element(env, transform, m21, matrix4[m12]);
napi_set_element(env, transform, m22, matrix4[m22]);
napi_set_element(env, transform, m23, matrix4[m32]);
napi_set_element(env, transform, m30, matrix4[m03]);
napi_set_element(env, transform, m31, matrix4[m13]);
napi_set_element(env, transform, m32, matrix4[m23]);
napi_set_element(env, transform, m33, matrix4[m33]);
napi_set_named_property(env, obj, "size", size);
napi_set_named_property(env, size, "width", width);
napi_set_named_property(env, size, "height", height);
napi_set_named_property(env, obj, "localOffset", localOffset);
napi_set_named_property(env, localOffset, "x", localOffsetX);
napi_set_named_property(env, localOffset, "y", localOffsetY);
napi_set_named_property(env, obj, "windowOffset", windowOffset);
napi_set_named_property(env, windowOffset, "x", windowOffsetX);
napi_set_named_property(env, windowOffset, "y", windowOffsetY);
napi_set_named_property(env, obj, "screenOffset", screenOffset);
napi_set_named_property(env, screenOffset, "x", screenOffsetX);
napi_set_named_property(env, screenOffset, "y", screenOffsetY);
napi_set_named_property(env, obj, "translate", translate);
napi_set_named_property(env, translate, "x", translateX);
napi_set_named_property(env, translate, "y", translateY);
napi_set_named_property(env, translate, "z", translateZ);
napi_set_named_property(env, obj, "scale", scale);
napi_set_named_property(env, scale, "x", scaleX);
napi_set_named_property(env, scale, "y", scaleY);
napi_set_named_property(env, scale, "z", scaleZ);
napi_set_named_property(env, scale, "centerX", scaleCenterX);
napi_set_named_property(env, scale, "centerY", scaleCenterY);
napi_set_named_property(env, obj, "rotate", rotate);
napi_set_named_property(env, rotate, "x", rotateX);
napi_set_named_property(env, rotate, "y", rotateY);
napi_set_named_property(env, rotate, "z", rotateZ);
napi_set_named_property(env, rotate, "angle", rotateAngle);
napi_set_named_property(env, rotate, "centerX", rotateCenterX);
napi_set_named_property(env, rotate, "centerY", rotateCenterY);
napi_set_named_property(env, obj, "transform", transform);
return obj;
}
static napi_value registerFunc(napi_env env, napi_value exports)
{
napi_property_descriptor animatorDesc[] = {
DECLARE_NAPI_FUNCTION("getRectangleById", JSGetRectangleById),
};
NAPI_CALL(env, napi_define_properties(env, exports, sizeof(animatorDesc) / sizeof(animatorDesc[0]), animatorDesc));
return exports;
}
static napi_module componentUtilsModule = {
.nm_version = 1,
.nm_flags = 0,
.nm_filename = nullptr,
.nm_register_func = registerFunc,
.nm_modname = "componentUtils",
.nm_priv = ((void*)0),
.reserved = { 0 },
};
extern "C" __attribute__((constructor)) void ComponentUtilsRegister()
{
napi_module_register(&componentUtilsModule);
}
} // namespace OHOS::Ace::Napi

1
interfaces/napi/kits/napi_lib.gni
View File

@ -22,6 +22,7 @@ common_napi_libs = [
"device",
"font",
"grid",
"componentutils",
"measure",
"mediaquery",
"prompt",