1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_V2_INSPECTOR_UTILS_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_V2_INSPECTOR_UTILS_H
18
19 #include <string>
20 #include <vector>
21
22 #include "core/components/common/layout/constants.h"
23 #include "core/components/common/layout/align_declaration.h"
24 #include "core/components/common/properties/text_style.h"
25 #include "core/components/text_overlay/text_overlay_manager.h"
26
27 namespace OHOS::Ace::V2 {
28
29 namespace {
30
31 const char* AXIS_TYPE[] = {
32 "Axis.VERTICAL",
33 "Axis.HORIZONTAL",
34 "Axis.FREE",
35 "Axis.NONE",
36 };
37
38 } // namespace
39
ConvertStackFitToString(StackFit stackFit)40 inline std::string ConvertStackFitToString(StackFit stackFit)
41 {
42 std::string result = "";
43 switch (stackFit) {
44 case StackFit::STRETCH:
45 result = "StackFit.Stretch";
46 break;
47 case StackFit::INHERIT:
48 result = "StackFit.Inherit";
49 break;
50 case StackFit::FIRST_CHILD:
51 result = "StackFit.FirstChild";
52 break;
53 case StackFit::KEEP:
54 default:
55 result = "StackFit.Keep";
56 break;
57 }
58 return result;
59 }
60
ConvertOverflowToString(Overflow overflow)61 inline std::string ConvertOverflowToString(Overflow overflow)
62 {
63 std::string result = "";
64 switch (overflow) {
65 case Overflow::CLIP:
66 result = "Overflow.Clip";
67 break;
68 case Overflow::SCROLL:
69 result = "Overflow.Scroll";
70 break;
71 case Overflow::FORCE_CLIP:
72 result = "Overflow.ForceClip";
73 break;
74 case Overflow::OBSERVABLE:
75 default:
76 result = "Overflow.Observable";
77 break;
78 }
79 return result;
80 }
81
ConvertBoolToString(bool flag)82 inline std::string ConvertBoolToString(bool flag)
83 {
84 return flag ? "true" : "false";
85 }
86
ConvertTabBarModeToString(TabBarMode barMode)87 inline std::string ConvertTabBarModeToString(TabBarMode barMode)
88 {
89 std::string result = "";
90 switch (barMode) {
91 case TabBarMode::SCROLLABLE:
92 result = "BarMode.Scrollable";
93 break;
94 case TabBarMode::FIXED_START:
95 result = "BarMode.FixedStart";
96 break;
97 case TabBarMode::FIXED:
98 default:
99 result = "BarMode.Fixed";
100 break;
101 }
102 return result;
103 }
104
ConvertBarPositionToString(BarPosition barPosition)105 inline std::string ConvertBarPositionToString(BarPosition barPosition)
106 {
107 std::string result = "";
108 switch (barPosition) {
109 case BarPosition::END:
110 result = "BarPosition.End";
111 break;
112 case BarPosition::START:
113 default:
114 result = "BarPosition.Start";
115 break;
116 }
117 return result;
118 }
119
ConvertFlexDirectionToStirng(FlexDirection direction)120 inline std::string ConvertFlexDirectionToStirng(FlexDirection direction)
121 {
122 if (direction == FlexDirection::ROW) {
123 return "FlexDirection.Row";
124 } else if (direction == FlexDirection::ROW_REVERSE) {
125 return "FlexDirection.RowReverse";
126 } else if (direction == FlexDirection::COLUMN) {
127 return "FlexDirection.Column";
128 } else {
129 return "FlexDirection.ColumnReverse";
130 }
131 }
132
ConvertStringToFlexDirection(const std::string & str)133 inline FlexDirection ConvertStringToFlexDirection(const std::string& str)
134 {
135 static const std::unordered_map<std::string, FlexDirection> uMap {
136 { "FlexDirection.Row", FlexDirection::ROW },
137 { "FlexDirection.RowReverse", FlexDirection::ROW_REVERSE },
138 { "FlexDirection.Column", FlexDirection::COLUMN },
139 { "FlexDirection.ColumnReverse", FlexDirection::COLUMN_REVERSE },
140 };
141
142 return uMap.count(str) ? uMap.at(str) : FlexDirection::ROW;
143 }
144
ConvertWrapDirectionToStirng(WrapDirection direction)145 inline std::string ConvertWrapDirectionToStirng(WrapDirection direction)
146 {
147 if (direction == WrapDirection::HORIZONTAL) {
148 return "FlexDirection.Row";
149 } else if (direction == WrapDirection::HORIZONTAL_REVERSE) {
150 return "FlexDirection.RowReverse";
151 } else if (direction == WrapDirection::VERTICAL) {
152 return "FlexDirection.Column";
153 } else {
154 return "FlexDirection.ColumnReverse";
155 }
156 }
157
ConvertFlexAlignToStirng(FlexAlign align)158 inline std::string ConvertFlexAlignToStirng(FlexAlign align)
159 {
160 if (align == FlexAlign::FLEX_START) {
161 return "FlexAlign.Start";
162 } else if (align == FlexAlign::CENTER) {
163 return "FlexAlign.Center";
164 } else if (align == FlexAlign::FLEX_END) {
165 return "FlexAlign.End";
166 } else if (align == FlexAlign::SPACE_BETWEEN) {
167 return "FlexAlign.SpaceBetween";
168 } else if (align == FlexAlign::SPACE_AROUND) {
169 return "FlexAlign.SpaceAround";
170 } else if (align == FlexAlign::BASELINE) {
171 return "FlexAlign.Baseline";
172 } else if (align == FlexAlign::STRETCH) {
173 return "FlexAlign.Stretch";
174 } else {
175 return "FlexAlign.SpaceEvenly";
176 }
177 }
178
ConvertStringToFlexAlign(const std::string & str)179 inline FlexAlign ConvertStringToFlexAlign(const std::string& str)
180 {
181 static const std::unordered_map<std::string, FlexAlign> uMap {
182 { "FlexAlign.Start", FlexAlign::FLEX_START },
183 { "FlexAlign.Center", FlexAlign::CENTER },
184 { "FlexAlign.End", FlexAlign::FLEX_END },
185 { "FlexAlign.SpaceBetween", FlexAlign::SPACE_BETWEEN },
186 { "FlexAlign.SpaceAround", FlexAlign::SPACE_AROUND },
187 { "FlexAlign.Baseline", FlexAlign::BASELINE },
188 { "FlexAlign.Stretch", FlexAlign::STRETCH },
189 { "FlexAlign.SpaceEvenly", FlexAlign::SPACE_EVENLY },
190 };
191
192 return uMap.count(str) ? uMap.at(str) : FlexAlign::FLEX_START;
193 }
194
ConvertItemAlignToStirng(FlexAlign align)195 inline std::string ConvertItemAlignToStirng(FlexAlign align)
196 {
197 if (align == FlexAlign::FLEX_START) {
198 return "ItemAlign.Start";
199 }
200 if (align == FlexAlign::CENTER) {
201 return "ItemAlign.Center";
202 }
203 if (align == FlexAlign::FLEX_END) {
204 return "ItemAlign.End";
205 }
206 if (align == FlexAlign::BASELINE) {
207 return "ItemAlign.Baseline";
208 }
209 if (align == FlexAlign::STRETCH) {
210 return "ItemAlign.Stretch";
211 }
212 return "ItemAlign.Auto";
213 }
214
ConvertStringToItemAlign(const std::string & str)215 inline FlexAlign ConvertStringToItemAlign(const std::string& str)
216 {
217 static const std::unordered_map<std::string, FlexAlign> uMap {
218 { "ItemAlign.Start", FlexAlign::FLEX_START },
219 { "ItemAlign.Center", FlexAlign::CENTER },
220 { "ItemAlign.End", FlexAlign::FLEX_END },
221 { "ItemAlign.Baseline", FlexAlign::BASELINE },
222 { "ItemAlign.Stretch", FlexAlign::STRETCH },
223 };
224
225 return uMap.count(str) ? uMap.at(str) : FlexAlign::AUTO;
226 }
227
ConvertWrapAlignmentToStirng(WrapAlignment align)228 inline std::string ConvertWrapAlignmentToStirng(WrapAlignment align)
229 {
230 if (align == WrapAlignment::START) {
231 return "FlexAlign.Start";
232 } else if (align == WrapAlignment::CENTER) {
233 return "FlexAlign.Center";
234 } else if (align == WrapAlignment::END) {
235 return "FlexAlign.End";
236 } else if (align == WrapAlignment::SPACE_BETWEEN) {
237 return "FlexAlign.SpaceBetween";
238 } else if (align == WrapAlignment::SPACE_AROUND) {
239 return "FlexAlign.SpaceAround";
240 } else if (align == WrapAlignment::STRETCH) {
241 return "FlexAlign.Stretch";
242 } else if (align == WrapAlignment::BASELINE) {
243 return "FlexAlign.Baseline";
244 } else {
245 return "FlexAlign.SpaceEvenly";
246 }
247 }
248
ConvertWrapTextDecorationToStirng(TextDecoration decoration)249 inline std::string ConvertWrapTextDecorationToStirng(TextDecoration decoration)
250 {
251 static const LinearEnumMapNode<TextDecoration, std::string> decorationTable[] = {
252 { TextDecoration::NONE, "TextDecorationType.None" },
253 { TextDecoration::UNDERLINE, "TextDecorationType.Underline" },
254 { TextDecoration::OVERLINE, "TextDecorationType.Overline" },
255 { TextDecoration::LINE_THROUGH, "TextDecorationType.LineThrough" },
256 { TextDecoration::INHERIT, "TextDecorationType.Inherit" },
257 };
258
259 auto index = BinarySearchFindIndex(decorationTable, ArraySize(decorationTable), decoration);
260 return index < 0 ? "TextDecorationType.None" : decorationTable[index].value;
261 }
262
ConvertWrapTextCaseToStirng(TextCase textCase)263 inline std::string ConvertWrapTextCaseToStirng(TextCase textCase)
264 {
265 static const LinearEnumMapNode<TextCase, std::string> textCaseTable[] = {
266 { TextCase::NORMAL, "TextCase.Normal" },
267 { TextCase::LOWERCASE, "TextCase.LowerCase" },
268 { TextCase::UPPERCASE, "TextCase.UpperCase" },
269 };
270
271 auto index = BinarySearchFindIndex(textCaseTable, ArraySize(textCaseTable), textCase);
272 return index < 0 ? "TextCase.Normal" : textCaseTable[index].value;
273 }
274
ConvertWrapImageFitToString(ImageFit imageFit)275 inline std::string ConvertWrapImageFitToString(ImageFit imageFit)
276 {
277 static const LinearEnumMapNode<ImageFit, std::string> imageFitTable[] = {
278 { ImageFit::COVER, "ImageFit.Cover" },
279 { ImageFit::FILL, "ImageFit.Fill" },
280 { ImageFit::CONTAIN, "ImageFit.Contain" },
281 { ImageFit::FITWIDTH, "ImageFit.FitWidth" },
282 { ImageFit::FITHEIGHT, "ImageFit.FitHeight" },
283 { ImageFit::NONE, "ImageFit.None" },
284 { ImageFit::SCALE_DOWN, "ImageFit.ScaleDown" },
285 };
286
287 auto index = BinarySearchFindIndex(imageFitTable, ArraySize(imageFitTable), imageFit);
288 return index < 0 ? "ImageFit.Cover" : imageFitTable[index].value;
289 }
290
ConvertWrapImageRepeatToString(ImageRepeat repeat)291 inline std::string ConvertWrapImageRepeatToString(ImageRepeat repeat)
292 {
293 static const LinearEnumMapNode<ImageRepeat, std::string> imageRepeatTable[] = {
294 { ImageRepeat::NO_REPEAT, "ImageRepeat.NoRepeat" },
295 { ImageRepeat::REPEAT, "ImageRepeat.XY" },
296 { ImageRepeat::REPEAT_X, "ImageRepeat.X" },
297 { ImageRepeat::REPEAT_Y, "ImageRepeat.Y" },
298 };
299
300 auto index = BinarySearchFindIndex(imageRepeatTable, ArraySize(imageRepeatTable), repeat);
301 return index < 0 ? "ImageRepeat.NoRepeat" : imageRepeatTable[index].value;
302 }
303
ConvertWrapImageInterpolationToString(ImageInterpolation imageInterpolation)304 inline std::string ConvertWrapImageInterpolationToString(ImageInterpolation imageInterpolation)
305 {
306 static const LinearEnumMapNode<ImageInterpolation, std::string> imageInterpolationTable[] = {
307 { ImageInterpolation::NONE, "ImageInterpolation.None" },
308 { ImageInterpolation::LOW, "ImageInterpolation.Low" },
309 { ImageInterpolation::MEDIUM, "ImageInterpolation.Medium" },
310 { ImageInterpolation::HIGH, "ImageInterpolation.High" },
311 };
312
313 auto index =
314 BinarySearchFindIndex(imageInterpolationTable, ArraySize(imageInterpolationTable), imageInterpolation);
315 return index < 0 ? "ImageInterpolation.None" : imageInterpolationTable[index].value;
316 }
317
ConvertWrapImageRenderModeToString(ImageRenderMode imageRenderMode)318 inline std::string ConvertWrapImageRenderModeToString(ImageRenderMode imageRenderMode)
319 {
320 static const LinearEnumMapNode<ImageRenderMode, std::string> imageRenderModeTable[] = {
321 { ImageRenderMode::ORIGINAL, "ImageRenderMode.Original" },
322 { ImageRenderMode::TEMPLATE, "ImageRenderMode.Template" },
323 };
324
325 auto index = BinarySearchFindIndex(imageRenderModeTable, ArraySize(imageRenderModeTable), imageRenderMode);
326 return index < 0 ? "ImageRenderMode.Original" : imageRenderModeTable[index].value;
327 }
328
ConvertWrapTextAlignToString(TextAlign textAlign)329 inline std::string ConvertWrapTextAlignToString(TextAlign textAlign)
330 {
331 static const LinearEnumMapNode<TextAlign, std::string> textAlignTable[] = {
332 { TextAlign::LEFT, "TextAlign.Left" },
333 { TextAlign::RIGHT, "TextAlign.Right" },
334 { TextAlign::CENTER, "TextAlign.Center" },
335 { TextAlign::JUSTIFY, "TextAlign.Justify" },
336 { TextAlign::START, "TextAlign.Start" },
337 { TextAlign::END, "TextAlign.End" },
338 };
339
340 auto index = BinarySearchFindIndex(textAlignTable, ArraySize(textAlignTable), textAlign);
341 return index < 0 ? "TextAlign.Start" : textAlignTable[index].value;
342 }
343
ConvertWrapStringToTextAlign(const std::string & str)344 inline TextAlign ConvertWrapStringToTextAlign(const std::string& str)
345 {
346 static const std::unordered_map<std::string, TextAlign> uMap {
347 { "TextAlign.Left", TextAlign::LEFT },
348 { "TextAlign.Right", TextAlign::RIGHT },
349 { "TextAlign.Center", TextAlign::CENTER },
350 { "TextAlign.Justify", TextAlign::JUSTIFY },
351 { "TextAlign.Start", TextAlign::START },
352 { "TextAlign.End", TextAlign::END },
353 };
354
355 return uMap.count(str) ? uMap.at(str) : TextAlign::START;
356 }
357
ConvertWrapTextOverflowToString(TextOverflow textOverflow)358 inline std::string ConvertWrapTextOverflowToString(TextOverflow textOverflow)
359 {
360 static const LinearEnumMapNode<TextOverflow, std::string> textOverflowTable[] = {
361 { TextOverflow::NONE, "TextOverflow.None" },
362 { TextOverflow::CLIP, "TextOverflow.Clip" },
363 { TextOverflow::ELLIPSIS, "TextOverflow.Ellipsis" },
364 { TextOverflow::MARQUEE, "TextOverflow.Marquee" },
365 };
366
367 auto index = BinarySearchFindIndex(textOverflowTable, ArraySize(textOverflowTable), textOverflow);
368 return index < 0 ? "TextAlign.Start" : textOverflowTable[index].value;
369 }
370
ConvertWrapStringToTextOverflow(const std::string & str)371 inline TextOverflow ConvertWrapStringToTextOverflow(const std::string& str)
372 {
373 static const std::unordered_map<std::string, TextOverflow> uMap {
374 { "TextOverflow.Clip", TextOverflow::CLIP },
375 { "TextOverflow.Ellipsis", TextOverflow::ELLIPSIS },
376 { "TextOverflow.None", TextOverflow::NONE },
377 };
378
379 return uMap.count(str) ? uMap.at(str) : TextOverflow::CLIP;
380 }
381
ConvertWrapFontStyleToStirng(FontStyle fontStyle)382 inline std::string ConvertWrapFontStyleToStirng(FontStyle fontStyle)
383 {
384 static const LinearEnumMapNode<FontStyle, std::string> fontStyleTable[] = {
385 { FontStyle::NORMAL, "FontStyle.Normal" },
386 { FontStyle::ITALIC, "FontStyle.Italic" },
387 };
388
389 auto index = BinarySearchFindIndex(fontStyleTable, ArraySize(fontStyleTable), fontStyle);
390 return index < 0 ? "FontStyle.Normal" : fontStyleTable[index].value;
391 }
392
ConvertWrapFontWeightToStirng(FontWeight fontWeight)393 inline std::string ConvertWrapFontWeightToStirng(FontWeight fontWeight)
394 {
395 static const LinearEnumMapNode<FontWeight, std::string> fontWeightTable[] = {
396 { FontWeight::W100, "100" },
397 { FontWeight::W200, "200" },
398 { FontWeight::W300, "300" },
399 { FontWeight::W400, "400" },
400 { FontWeight::W500, "500" },
401 { FontWeight::W600, "600" },
402 { FontWeight::W700, "700" },
403 { FontWeight::W800, "800" },
404 { FontWeight::W900, "900" },
405 { FontWeight::BOLD, "FontWeight.Bold" },
406 { FontWeight::NORMAL, "FontWeight.Normal" },
407 { FontWeight::BOLDER, "FontWeight.Bolder" },
408 { FontWeight::LIGHTER, "FontWeight.Lighter" },
409 { FontWeight::MEDIUM, "FontWeight.Medium" },
410 { FontWeight::REGULAR, "FontWeight.Regular" },
411 };
412
413 auto index = BinarySearchFindIndex(fontWeightTable, ArraySize(fontWeightTable), fontWeight);
414 return index < 0 ? "FontWeight.Normal" : fontWeightTable[index].value;
415 }
416
ConvertWrapStringToFontWeight(const std::string & str)417 inline FontWeight ConvertWrapStringToFontWeight(const std::string& str)
418 {
419 static const std::unordered_map<std::string, FontWeight> uMap {
420 { "FontWeight.100", FontWeight::W100 },
421 { "FontWeight.200", FontWeight::W200 },
422 { "FontWeight.300", FontWeight::W300 },
423 { "FontWeight.400", FontWeight::W400 },
424 { "FontWeight.500", FontWeight::W500 },
425 { "FontWeight.600", FontWeight::W600 },
426 { "FontWeight.700", FontWeight::W700 },
427 { "FontWeight.800", FontWeight::W800 },
428 { "FontWeight.900", FontWeight::W900 },
429 { "FontWeight.Bold", FontWeight::BOLD },
430 { "FontWeight.Normal", FontWeight::NORMAL },
431 { "FontWeight.Bolder", FontWeight::BOLDER },
432 { "FontWeight.Lighter", FontWeight::LIGHTER },
433 { "FontWeight.Medium", FontWeight::MEDIUM },
434 { "FontWeight.Regular", FontWeight::REGULAR },
435 };
436
437 return uMap.count(str) ? uMap.at(str) : FontWeight::NORMAL;
438 }
439
ConvertWrapCopyOptionToString(CopyOptions copyOptions)440 inline std::string ConvertWrapCopyOptionToString(CopyOptions copyOptions)
441 {
442 static const LinearEnumMapNode<CopyOptions, std::string> copyOptionsTable[] = {
443 { CopyOptions::None, "CopyOptions::None" },
444 { CopyOptions::InApp, "CopyOptions:InApp" },
445 { CopyOptions::Local, "CopyOptions:Local" },
446 { CopyOptions::Distributed, "CopyOptions:Distributed" },
447 };
448
449 auto index = BinarySearchFindIndex(copyOptionsTable, ArraySize(copyOptionsTable), copyOptions);
450 return index < 0 ? "CopyOptions::None" : copyOptionsTable[index].value;
451 }
452
ConvertColorToString(Color color)453 inline std::string ConvertColorToString(Color color)
454 {
455 return color.ColorToString();
456 }
457
ConvertAxisToString(Axis axis)458 inline std::string ConvertAxisToString(Axis axis)
459 {
460 return AXIS_TYPE[static_cast<int32_t>(axis)];
461 }
462
ConvertSideToString(AlignDeclaration::Edge edge)463 inline std::string ConvertSideToString(AlignDeclaration::Edge edge)
464 {
465 if (edge == AlignDeclaration::Edge::TOP) {
466 return "Edge::Top";
467 } else if (edge == AlignDeclaration::Edge::CENTER) {
468 return "Edge::Center";
469 } else if (edge == AlignDeclaration::Edge::BOTTOM) {
470 return "Edge::Bottom";
471 } else if (edge == AlignDeclaration::Edge::BASELINE) {
472 return "Edge::Baseline";
473 } else if (edge == AlignDeclaration::Edge::START) {
474 return "Edge::Start";
475 } else if (edge == AlignDeclaration::Edge::MIDDLE) {
476 return "Edge::Middle";
477 } else if (edge == AlignDeclaration::Edge::END) {
478 return "Edge::End";
479 } else {
480 return "Edge::Center";
481 }
482 }
483
ConvertFontFamily(const std::vector<std::string> & fontFamily)484 inline std::string ConvertFontFamily(const std::vector<std::string>& fontFamily)
485 {
486 std::string result;
487 for (const auto& item : fontFamily) {
488 result += item;
489 result += ",";
490 }
491 result = result.substr(0, result.size() - 1);
492 return result;
493 }
494
495 std::string GetTextStyleInJson(const TextStyle& textStyle);
496
ConvertWrapTextHeightAdaptivePolicyToString(TextHeightAdaptivePolicy heightAdaptivePolicy)497 inline std::string ConvertWrapTextHeightAdaptivePolicyToString(TextHeightAdaptivePolicy heightAdaptivePolicy)
498 {
499 static const LinearEnumMapNode<TextHeightAdaptivePolicy, std::string> heightAdaptivePolicytTable[] = {
500 { TextHeightAdaptivePolicy::MAX_LINES_FIRST, "TextHeightAdaptivePolicy.MAX_LINES_FIRST" },
501 { TextHeightAdaptivePolicy::MIN_FONT_SIZE_FIRST, "TextHeightAdaptivePolicy.MIN_FONT_SIZE_FIRST" },
502 { TextHeightAdaptivePolicy::LAYOUT_CONSTRAINT_FIRST, "TextHeightAdaptivePolicy.LAYOUT_CONSTRAINT_FIRST" },
503 };
504
505 auto index = BinarySearchFindIndex(
506 heightAdaptivePolicytTable, ArraySize(heightAdaptivePolicytTable), heightAdaptivePolicy);
507 return index < 0 ? "TextHeightAdaptivePolicy.MAX_LINES_FIRST" : heightAdaptivePolicytTable[index].value;
508 }
509
510 } // namespace OHOS::Ace::V2
511
512 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_V2_INSPECTOR_UTILS_H