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 "base/utils/linear_map.h"
23 #include "core/components/common/layout/align_declaration.h"
24 #include "core/components/common/layout/constants.h"
25 #include "core/components/common/properties/text_style.h"
26 #include "core/components/text_overlay/text_overlay_manager.h"
27
28 namespace OHOS::Ace::V2 {
29
30 namespace {
31
32 const char* AXIS_TYPE[] = {
33 "Axis.VERTICAL",
34 "Axis.HORIZONTAL",
35 "Axis.FREE",
36 "Axis.NONE",
37 };
38 const FontWeight FONT_WEIGHT_CONVERT_MAP[] = {
39 FontWeight::W100,
40 FontWeight::W200,
41 FontWeight::W300,
42 FontWeight::W400,
43 FontWeight::W500,
44 FontWeight::W600,
45 FontWeight::W700,
46 FontWeight::W800,
47 FontWeight::W900,
48 FontWeight::W700, // FontWeight::BOLD
49 FontWeight::W400, // FontWeight::NORMAL
50 FontWeight::W900, // FontWeight::BOLDER,
51 FontWeight::W100, // FontWeight::LIGHTER
52 FontWeight::W500, // FontWeight::MEDIUM
53 FontWeight::W400, // FontWeight::REGULAR
54 };
55 } // namespace
56
ConvertStackFitToString(StackFit stackFit)57 inline std::string ConvertStackFitToString(StackFit stackFit)
58 {
59 std::string result = "";
60 switch (stackFit) {
61 case StackFit::STRETCH:
62 result = "StackFit.Stretch";
63 break;
64 case StackFit::INHERIT:
65 result = "StackFit.Inherit";
66 break;
67 case StackFit::FIRST_CHILD:
68 result = "StackFit.FirstChild";
69 break;
70 case StackFit::KEEP:
71 default:
72 result = "StackFit.Keep";
73 break;
74 }
75 return result;
76 }
77
ConvertOverflowToString(Overflow overflow)78 inline std::string ConvertOverflowToString(Overflow overflow)
79 {
80 std::string result = "";
81 switch (overflow) {
82 case Overflow::CLIP:
83 result = "Overflow.Clip";
84 break;
85 case Overflow::SCROLL:
86 result = "Overflow.Scroll";
87 break;
88 case Overflow::FORCE_CLIP:
89 result = "Overflow.ForceClip";
90 break;
91 case Overflow::OBSERVABLE:
92 default:
93 result = "Overflow.Observable";
94 break;
95 }
96 return result;
97 }
98
ConvertBoolToString(bool flag)99 inline std::string ConvertBoolToString(bool flag)
100 {
101 return flag ? "true" : "false";
102 }
103
ConvertStringToBool(const std::string & str)104 inline bool ConvertStringToBool(const std::string& str)
105 {
106 if (str == "true") {
107 return true;
108 } else {
109 return false;
110 }
111 }
112
ConvertTabBarModeToString(TabBarMode barMode)113 inline std::string ConvertTabBarModeToString(TabBarMode barMode)
114 {
115 std::string result = "";
116 switch (barMode) {
117 case TabBarMode::SCROLLABLE:
118 result = "BarMode.Scrollable";
119 break;
120 case TabBarMode::FIXED_START:
121 result = "BarMode.FixedStart";
122 break;
123 case TabBarMode::FIXED:
124 default:
125 result = "BarMode.Fixed";
126 break;
127 }
128 return result;
129 }
130
ConvertBarPositionToString(BarPosition barPosition)131 inline std::string ConvertBarPositionToString(BarPosition barPosition)
132 {
133 std::string result = "";
134 switch (barPosition) {
135 case BarPosition::END:
136 result = "BarPosition.End";
137 break;
138 case BarPosition::START:
139 default:
140 result = "BarPosition.Start";
141 break;
142 }
143 return result;
144 }
145
ConvertFlexDirectionToStirng(FlexDirection direction)146 inline std::string ConvertFlexDirectionToStirng(FlexDirection direction)
147 {
148 if (direction == FlexDirection::ROW) {
149 return "FlexDirection.Row";
150 } else if (direction == FlexDirection::ROW_REVERSE) {
151 return "FlexDirection.RowReverse";
152 } else if (direction == FlexDirection::COLUMN) {
153 return "FlexDirection.Column";
154 } else {
155 return "FlexDirection.ColumnReverse";
156 }
157 }
158
ConvertStringToFlexDirection(const std::string & str)159 inline FlexDirection ConvertStringToFlexDirection(const std::string& str)
160 {
161 static const std::unordered_map<std::string, FlexDirection> uMap {
162 { "FlexDirection.Row", FlexDirection::ROW },
163 { "FlexDirection.RowReverse", FlexDirection::ROW_REVERSE },
164 { "FlexDirection.Column", FlexDirection::COLUMN },
165 { "FlexDirection.ColumnReverse", FlexDirection::COLUMN_REVERSE },
166 };
167
168 auto iter = uMap.find(str);
169 if (iter != uMap.end()) {
170 return iter->second;
171 }
172 return FlexDirection::ROW;
173 }
174
ConvertWrapDirectionToStirng(WrapDirection direction)175 inline std::string ConvertWrapDirectionToStirng(WrapDirection direction)
176 {
177 if (direction == WrapDirection::HORIZONTAL) {
178 return "FlexDirection.Row";
179 } else if (direction == WrapDirection::HORIZONTAL_REVERSE) {
180 return "FlexDirection.RowReverse";
181 } else if (direction == WrapDirection::VERTICAL) {
182 return "FlexDirection.Column";
183 } else {
184 return "FlexDirection.ColumnReverse";
185 }
186 }
187
ConvertFlexAlignToStirng(FlexAlign align)188 inline std::string ConvertFlexAlignToStirng(FlexAlign align)
189 {
190 if (align == FlexAlign::FLEX_START) {
191 return "FlexAlign.Start";
192 } else if (align == FlexAlign::CENTER) {
193 return "FlexAlign.Center";
194 } else if (align == FlexAlign::FLEX_END) {
195 return "FlexAlign.End";
196 } else if (align == FlexAlign::SPACE_BETWEEN) {
197 return "FlexAlign.SpaceBetween";
198 } else if (align == FlexAlign::SPACE_AROUND) {
199 return "FlexAlign.SpaceAround";
200 } else if (align == FlexAlign::BASELINE) {
201 return "FlexAlign.Baseline";
202 } else if (align == FlexAlign::STRETCH) {
203 return "FlexAlign.Stretch";
204 } else {
205 return "FlexAlign.SpaceEvenly";
206 }
207 }
208
ConvertStringToFlexAlign(const std::string & str)209 inline FlexAlign ConvertStringToFlexAlign(const std::string& str)
210 {
211 static const std::unordered_map<std::string, FlexAlign> uMap {
212 { "FlexAlign.Start", FlexAlign::FLEX_START },
213 { "FlexAlign.Center", FlexAlign::CENTER },
214 { "FlexAlign.End", FlexAlign::FLEX_END },
215 { "FlexAlign.SpaceBetween", FlexAlign::SPACE_BETWEEN },
216 { "FlexAlign.SpaceAround", FlexAlign::SPACE_AROUND },
217 { "FlexAlign.Baseline", FlexAlign::BASELINE },
218 { "FlexAlign.Stretch", FlexAlign::STRETCH },
219 { "FlexAlign.SpaceEvenly", FlexAlign::SPACE_EVENLY },
220 };
221
222 auto iter = uMap.find(str);
223 if (iter != uMap.end()) {
224 return iter->second;
225 }
226 return FlexAlign::FLEX_START;
227 }
228
ConvertItemAlignToStirng(FlexAlign align)229 inline std::string ConvertItemAlignToStirng(FlexAlign align)
230 {
231 if (align == FlexAlign::FLEX_START) {
232 return "ItemAlign.Start";
233 }
234 if (align == FlexAlign::CENTER) {
235 return "ItemAlign.Center";
236 }
237 if (align == FlexAlign::FLEX_END) {
238 return "ItemAlign.End";
239 }
240 if (align == FlexAlign::BASELINE) {
241 return "ItemAlign.Baseline";
242 }
243 if (align == FlexAlign::STRETCH) {
244 return "ItemAlign.Stretch";
245 }
246 return "ItemAlign.Auto";
247 }
248
ConvertStringToItemAlign(const std::string & str)249 inline FlexAlign ConvertStringToItemAlign(const std::string& str)
250 {
251 static const std::unordered_map<std::string, FlexAlign> uMap {
252 { "ItemAlign.Start", FlexAlign::FLEX_START },
253 { "ItemAlign.Center", FlexAlign::CENTER },
254 { "ItemAlign.End", FlexAlign::FLEX_END },
255 { "ItemAlign.Baseline", FlexAlign::BASELINE },
256 { "ItemAlign.Stretch", FlexAlign::STRETCH },
257 };
258
259 auto iter = uMap.find(str);
260 if (iter != uMap.end()) {
261 return iter->second;
262 }
263 return FlexAlign::AUTO;
264 }
265
ConvertItemAlignToStirng(WrapAlignment align)266 inline std::string ConvertItemAlignToStirng(WrapAlignment align)
267 {
268 static const LinearEnumMapNode<WrapAlignment, std::string> itemAlignTable[] = {
269 { WrapAlignment::START, "ItemAlign.Start" },
270 { WrapAlignment::CENTER, "ItemAlign.Center" },
271 { WrapAlignment::END, "ItemAlign.End" },
272 { WrapAlignment::STRETCH, "ItemAlign.Stretch" },
273 { WrapAlignment::BASELINE, "ItemAlign.Baseline" },
274 };
275
276 auto index = BinarySearchFindIndex(itemAlignTable, ArraySize(itemAlignTable), align);
277 return index < 0 ? "ItemAlign.Auto" : itemAlignTable[index].value;
278 }
279
ConvertWrapAlignmentToStirng(WrapAlignment align)280 inline std::string ConvertWrapAlignmentToStirng(WrapAlignment align)
281 {
282 if (align == WrapAlignment::START) {
283 return "FlexAlign.Start";
284 } else if (align == WrapAlignment::CENTER) {
285 return "FlexAlign.Center";
286 } else if (align == WrapAlignment::END) {
287 return "FlexAlign.End";
288 } else if (align == WrapAlignment::SPACE_BETWEEN) {
289 return "FlexAlign.SpaceBetween";
290 } else if (align == WrapAlignment::SPACE_AROUND) {
291 return "FlexAlign.SpaceAround";
292 } else if (align == WrapAlignment::STRETCH) {
293 return "FlexAlign.Stretch";
294 } else if (align == WrapAlignment::BASELINE) {
295 return "FlexAlign.Baseline";
296 } else {
297 return "FlexAlign.SpaceEvenly";
298 }
299 }
300
ConvertWrapTextDecorationToStirng(TextDecoration decoration)301 inline std::string ConvertWrapTextDecorationToStirng(TextDecoration decoration)
302 {
303 static const LinearEnumMapNode<TextDecoration, std::string> decorationTable[] = {
304 { TextDecoration::NONE, "TextDecorationType.None" },
305 { TextDecoration::UNDERLINE, "TextDecorationType.Underline" },
306 { TextDecoration::OVERLINE, "TextDecorationType.Overline" },
307 { TextDecoration::LINE_THROUGH, "TextDecorationType.LineThrough" },
308 { TextDecoration::INHERIT, "TextDecorationType.Inherit" },
309 };
310
311 auto index = BinarySearchFindIndex(decorationTable, ArraySize(decorationTable), decoration);
312 return index < 0 ? "TextDecorationType.None" : decorationTable[index].value;
313 }
314
ConvertWrapTextDecorationToStirng(std::vector<TextDecoration> decorations)315 inline std::string ConvertWrapTextDecorationToStirng(std::vector<TextDecoration> decorations)
316 {
317 if (decorations.size() == 0) {
318 return ConvertWrapTextDecorationToStirng(TextDecoration::NONE);
319 }
320 std::string ret = "";
321 for (TextDecoration decoration: decorations) {
322 ret += ConvertWrapTextDecorationToStirng(decoration) + ",";
323 }
324 ret.pop_back();
325 return ret;
326 }
327
ConvertWrapTextDecorationStyleToString(TextDecorationStyle decorationStyle)328 inline std::string ConvertWrapTextDecorationStyleToString(TextDecorationStyle decorationStyle)
329 {
330 static const LinearEnumMapNode<TextDecorationStyle, std::string> decorationStyleTable[] = {
331 { TextDecorationStyle::SOLID, "TextDecorationStyle.SOLID" },
332 { TextDecorationStyle::DOUBLE, "TextDecorationStyle.DOUBLE" },
333 { TextDecorationStyle::DOTTED, "TextDecorationStyle.DOTTED" },
334 { TextDecorationStyle::DASHED, "TextDecorationStyle.DASHED" },
335 { TextDecorationStyle::WAVY, "TextDecorationStyle.WAVY" },
336 };
337
338 auto index = BinarySearchFindIndex(decorationStyleTable, ArraySize(decorationStyleTable), decorationStyle);
339 return index < 0 ? "TextDecorationStyle.SOLID" : decorationStyleTable[index].value;
340 }
341
ConvertWrapTextCaseToStirng(TextCase textCase)342 inline std::string ConvertWrapTextCaseToStirng(TextCase textCase)
343 {
344 static const LinearEnumMapNode<TextCase, std::string> textCaseTable[] = {
345 { TextCase::NORMAL, "TextCase.Normal" },
346 { TextCase::LOWERCASE, "TextCase.LowerCase" },
347 { TextCase::UPPERCASE, "TextCase.UpperCase" },
348 };
349
350 auto index = BinarySearchFindIndex(textCaseTable, ArraySize(textCaseTable), textCase);
351 return index < 0 ? "TextCase.Normal" : textCaseTable[index].value;
352 }
353
ConvertWrapImageFitToString(ImageFit imageFit)354 inline std::string ConvertWrapImageFitToString(ImageFit imageFit)
355 {
356 static const LinearEnumMapNode<ImageFit, std::string> imageFitTable[] = {
357 { ImageFit::COVER, "ImageFit.Cover" },
358 { ImageFit::FILL, "ImageFit.Fill" },
359 { ImageFit::CONTAIN, "ImageFit.Contain" },
360 { ImageFit::FITWIDTH, "ImageFit.FitWidth" },
361 { ImageFit::FITHEIGHT, "ImageFit.FitHeight" },
362 { ImageFit::NONE, "ImageFit.None" },
363 { ImageFit::SCALE_DOWN, "ImageFit.ScaleDown" },
364 };
365
366 auto index = BinarySearchFindIndex(imageFitTable, ArraySize(imageFitTable), imageFit);
367 return index < 0 ? "ImageFit.Cover" : imageFitTable[index].value;
368 }
369
ConvertWrapImageRepeatToString(ImageRepeat repeat)370 inline std::string ConvertWrapImageRepeatToString(ImageRepeat repeat)
371 {
372 static const LinearEnumMapNode<ImageRepeat, std::string> imageRepeatTable[] = {
373 { ImageRepeat::NO_REPEAT, "ImageRepeat.NoRepeat" },
374 { ImageRepeat::REPEAT, "ImageRepeat.XY" },
375 { ImageRepeat::REPEAT_X, "ImageRepeat.X" },
376 { ImageRepeat::REPEAT_Y, "ImageRepeat.Y" },
377 };
378
379 auto index = BinarySearchFindIndex(imageRepeatTable, ArraySize(imageRepeatTable), repeat);
380 return index < 0 ? "ImageRepeat.NoRepeat" : imageRepeatTable[index].value;
381 }
382
ConvertWrapImageInterpolationToString(ImageInterpolation imageInterpolation)383 inline std::string ConvertWrapImageInterpolationToString(ImageInterpolation imageInterpolation)
384 {
385 static const LinearEnumMapNode<ImageInterpolation, std::string> imageInterpolationTable[] = {
386 { ImageInterpolation::NONE, "ImageInterpolation.None" },
387 { ImageInterpolation::LOW, "ImageInterpolation.Low" },
388 { ImageInterpolation::MEDIUM, "ImageInterpolation.Medium" },
389 { ImageInterpolation::HIGH, "ImageInterpolation.High" },
390 };
391
392 auto index = BinarySearchFindIndex(imageInterpolationTable, ArraySize(imageInterpolationTable), imageInterpolation);
393 return index < 0 ? "ImageInterpolation.None" : imageInterpolationTable[index].value;
394 }
395
ConvertWrapImageRenderModeToString(ImageRenderMode imageRenderMode)396 inline std::string ConvertWrapImageRenderModeToString(ImageRenderMode imageRenderMode)
397 {
398 static const LinearEnumMapNode<ImageRenderMode, std::string> imageRenderModeTable[] = {
399 { ImageRenderMode::ORIGINAL, "ImageRenderMode.Original" },
400 { ImageRenderMode::TEMPLATE, "ImageRenderMode.Template" },
401 };
402
403 auto index = BinarySearchFindIndex(imageRenderModeTable, ArraySize(imageRenderModeTable), imageRenderMode);
404 return index < 0 ? "ImageRenderMode.Original" : imageRenderModeTable[index].value;
405 }
406
ConvertWrapTextAlignToString(TextAlign textAlign)407 inline std::string ConvertWrapTextAlignToString(TextAlign textAlign)
408 {
409 static const LinearEnumMapNode<TextAlign, std::string> textAlignTable[] = {
410 { TextAlign::START, "TextAlign.Start" },
411 { TextAlign::CENTER, "TextAlign.Center" },
412 { TextAlign::END, "TextAlign.End" },
413 { TextAlign::JUSTIFY, "TextAlign.Justify" },
414 { TextAlign::LEFT, "TextAlign.Left" },
415 { TextAlign::RIGHT, "TextAlign.Right" },
416 };
417
418 auto index = BinarySearchFindIndex(textAlignTable, ArraySize(textAlignTable), textAlign);
419 return index < 0 ? "TextAlign.Start" : textAlignTable[index].value;
420 }
421
ConvertWrapStringToTextAlign(const std::string & str)422 inline TextAlign ConvertWrapStringToTextAlign(const std::string& str)
423 {
424 static const std::unordered_map<std::string, TextAlign> uMap {
425 { "TextAlign.Left", TextAlign::LEFT },
426 { "TextAlign.Right", TextAlign::RIGHT },
427 { "TextAlign.Center", TextAlign::CENTER },
428 { "TextAlign.Justify", TextAlign::JUSTIFY },
429 { "TextAlign.Start", TextAlign::START },
430 { "TextAlign.End", TextAlign::END },
431 };
432
433 auto iter = uMap.find(str);
434 if (iter != uMap.end()) {
435 return iter->second;
436 }
437 return TextAlign::START;
438 }
439
ConvertWrapTextVerticalAlignToString(TextVerticalAlign textVerticalAlign)440 inline std::string ConvertWrapTextVerticalAlignToString(TextVerticalAlign textVerticalAlign)
441 {
442 static const LinearEnumMapNode<TextVerticalAlign, std::string> textVerticalAlignTable[] = {
443 { TextVerticalAlign::BASELINE, "TextVerticalAlign.BASELINE" },
444 { TextVerticalAlign::BOTTOM, "TextVerticalAlign.BOTTOM" },
445 { TextVerticalAlign::CENTER, "TextVerticalAlign.CENTER" },
446 { TextVerticalAlign::TOP, "TextVerticalAlign.TOP" },
447 };
448
449 auto index = BinarySearchFindIndex(
450 textVerticalAlignTable, ArraySize(textVerticalAlignTable), textVerticalAlign);
451 return index < 0 ? "TextVerticalAlign.BASELINE" : textVerticalAlignTable[index].value;
452 }
453
ConvertWrapStringToTextVerticalAlign(const std::string & str)454 inline TextVerticalAlign ConvertWrapStringToTextVerticalAlign(const std::string& str)
455 {
456 static const std::unordered_map<std::string, TextVerticalAlign> uMap {
457 { "TextVerticalAlign.BASELINE", TextVerticalAlign::BASELINE },
458 { "TextVerticalAlign.BOTTOM", TextVerticalAlign::BOTTOM },
459 { "TextVerticalAlign.CENTER", TextVerticalAlign::CENTER },
460 { "TextVerticalAlign.TOP", TextVerticalAlign::TOP },
461 };
462 auto iter = uMap.find(str);
463 return iter != uMap.end() ? iter->second : TextVerticalAlign::BASELINE;
464 }
465
ConvertWrapTextOverflowToString(TextOverflow textOverflow)466 inline std::string ConvertWrapTextOverflowToString(TextOverflow textOverflow)
467 {
468 static const LinearEnumMapNode<TextOverflow, std::string> textOverflowTable[] = {
469 { TextOverflow::NONE, "TextOverflow.None" },
470 { TextOverflow::CLIP, "TextOverflow.Clip" },
471 { TextOverflow::ELLIPSIS, "TextOverflow.Ellipsis" },
472 { TextOverflow::MARQUEE, "TextOverflow.Marquee" },
473 };
474
475 auto index = BinarySearchFindIndex(textOverflowTable, ArraySize(textOverflowTable), textOverflow);
476 return index < 0 ? "TextOverflow.Clip" : textOverflowTable[index].value;
477 }
478
ConvertWrapStringToTextOverflow(const std::string & str)479 inline TextOverflow ConvertWrapStringToTextOverflow(const std::string& str)
480 {
481 static const std::unordered_map<std::string, TextOverflow> uMap {
482 { "TextOverflow.Clip", TextOverflow::CLIP },
483 { "TextOverflow.Ellipsis", TextOverflow::ELLIPSIS },
484 { "TextOverflow.None", TextOverflow::NONE },
485 };
486
487 auto iter = uMap.find(str);
488 if (iter != uMap.end()) {
489 return iter->second;
490 }
491 return TextOverflow::CLIP;
492 }
493
ConvertWrapStringToMarqueeDirection(const std::string & str)494 inline MarqueeDirection ConvertWrapStringToMarqueeDirection(const std::string& str)
495 {
496 static const std::unordered_map<std::string, MarqueeDirection> uMap {
497 { "MarqueeDirection.LEFT", MarqueeDirection::LEFT },
498 { "MarqueeDirection.RIGHT", MarqueeDirection::RIGHT },
499 };
500
501 return uMap.count(str) ? uMap.at(str) : MarqueeDirection::LEFT;
502 }
503
ConvertWrapStringToMarqueeStartPolicy(const std::string & str)504 inline MarqueeStartPolicy ConvertWrapStringToMarqueeStartPolicy(const std::string& str)
505 {
506 static const std::unordered_map<std::string, MarqueeStartPolicy> uMap {
507 { "MarqueeStartPolicy.DEFAULT", MarqueeStartPolicy::DEFAULT },
508 { "MarqueeStartPolicy.ON_FOCUS", MarqueeStartPolicy::ON_FOCUS },
509 };
510
511 return uMap.count(str) ? uMap.at(str) : MarqueeStartPolicy::DEFAULT;
512 }
513
ConvertWrapFontStyleToStirng(FontStyle fontStyle)514 inline std::string ConvertWrapFontStyleToStirng(FontStyle fontStyle)
515 {
516 static const LinearEnumMapNode<FontStyle, std::string> fontStyleTable[] = {
517 { FontStyle::NORMAL, "FontStyle.Normal" },
518 { FontStyle::ITALIC, "FontStyle.Italic" },
519 };
520
521 auto index = BinarySearchFindIndex(fontStyleTable, ArraySize(fontStyleTable), fontStyle);
522 return index < 0 ? "FontStyle.Normal" : fontStyleTable[index].value;
523 }
524
ConvertFontWeight(FontWeight fontWeight)525 inline FontWeight ConvertFontWeight(FontWeight fontWeight)
526 {
527 return FONT_WEIGHT_CONVERT_MAP[static_cast<int>(fontWeight)];
528 }
529
ConvertWrapFontWeightToStirng(FontWeight fontWeight)530 inline std::string ConvertWrapFontWeightToStirng(FontWeight fontWeight)
531 {
532 static const LinearEnumMapNode<FontWeight, std::string> fontWeightTable[] = {
533 { FontWeight::W100, "100" },
534 { FontWeight::W200, "200" },
535 { FontWeight::W300, "300" },
536 { FontWeight::W400, "400" },
537 { FontWeight::W500, "500" },
538 { FontWeight::W600, "600" },
539 { FontWeight::W700, "700" },
540 { FontWeight::W800, "800" },
541 { FontWeight::W900, "900" },
542 { FontWeight::BOLD, "FontWeight.Bold" },
543 { FontWeight::NORMAL, "FontWeight.Normal" },
544 { FontWeight::BOLDER, "FontWeight.Bolder" },
545 { FontWeight::LIGHTER, "FontWeight.Lighter" },
546 { FontWeight::MEDIUM, "FontWeight.Medium" },
547 { FontWeight::REGULAR, "FontWeight.Regular" },
548 };
549
550 auto index = BinarySearchFindIndex(fontWeightTable, ArraySize(fontWeightTable), fontWeight);
551 return index < 0 ? "FontWeight.Normal" : fontWeightTable[index].value;
552 }
553
ConvertWrapStringToFontWeight(const std::string & str)554 inline FontWeight ConvertWrapStringToFontWeight(const std::string& str)
555 {
556 static const std::unordered_map<std::string, FontWeight> uMap {
557 { "FontWeight.100", FontWeight::W100 },
558 { "FontWeight.200", FontWeight::W200 },
559 { "FontWeight.300", FontWeight::W300 },
560 { "FontWeight.400", FontWeight::W400 },
561 { "FontWeight.500", FontWeight::W500 },
562 { "FontWeight.600", FontWeight::W600 },
563 { "FontWeight.700", FontWeight::W700 },
564 { "FontWeight.800", FontWeight::W800 },
565 { "FontWeight.900", FontWeight::W900 },
566 { "FontWeight.Bold", FontWeight::BOLD },
567 { "FontWeight.Normal", FontWeight::NORMAL },
568 { "FontWeight.Bolder", FontWeight::BOLDER },
569 { "FontWeight.Lighter", FontWeight::LIGHTER },
570 { "FontWeight.Medium", FontWeight::MEDIUM },
571 { "FontWeight.Regular", FontWeight::REGULAR },
572 };
573
574 auto iter = uMap.find(str);
575 if (iter != uMap.end()) {
576 return iter->second;
577 }
578 return FontWeight::NORMAL;
579 }
580
ConvertWrapCopyOptionToString(CopyOptions copyOptions)581 inline std::string ConvertWrapCopyOptionToString(CopyOptions copyOptions)
582 {
583 static const LinearEnumMapNode<CopyOptions, std::string> copyOptionsTable[] = {
584 { CopyOptions::None, "CopyOptions::None" },
585 { CopyOptions::InApp, "CopyOptions:InApp" },
586 { CopyOptions::Local, "CopyOptions:Local" },
587 { CopyOptions::Distributed, "CopyOptions:Distributed" },
588 };
589
590 auto index = BinarySearchFindIndex(copyOptionsTable, ArraySize(copyOptionsTable), copyOptions);
591 return index < 0 ? "CopyOptions::None" : copyOptionsTable[index].value;
592 }
593
ConvertEllipsisModeToString(EllipsisMode value)594 inline std::string ConvertEllipsisModeToString(EllipsisMode value)
595 {
596 static const LinearEnumMapNode<EllipsisMode, std::string> modalTable[] = {
597 { EllipsisMode::HEAD, "EllipsisMode.START" },
598 { EllipsisMode::MIDDLE, "EllipsisMode.CENTER" },
599 { EllipsisMode::TAIL, "EllipsisMode.END" },
600 };
601 auto index = BinarySearchFindIndex(modalTable, ArraySize(modalTable), value);
602 return index < 0 ? "EllipsisMode.END" : modalTable[index].value;
603 }
604
ConvertWrapWordBreakToString(WordBreak wordBreak)605 inline std::string ConvertWrapWordBreakToString(WordBreak wordBreak)
606 {
607 static const LinearEnumMapNode<WordBreak, std::string> wordBreakTable[] = {
608 { WordBreak::NORMAL, "normal" },
609 { WordBreak::BREAK_ALL, "break-all" },
610 { WordBreak::BREAK_WORD, "break-word" },
611 { WordBreak::HYPHENATION, "hyphenation" },
612 };
613
614 auto index = BinarySearchFindIndex(wordBreakTable, ArraySize(wordBreakTable), wordBreak);
615 return index < 0 ? "break-word" : wordBreakTable[index].value;
616 }
617
ConvertTextDirectionToString(TextDirection direction)618 inline std::string ConvertTextDirectionToString(TextDirection direction)
619 {
620 static const LinearEnumMapNode<TextDirection, std::string> textDirectionTable[] = {
621 { TextDirection::LTR, "LTR" },
622 { TextDirection::RTL, "RTL" },
623 { TextDirection::INHERIT, "INHERIT" },
624 { TextDirection::AUTO, "AUTO" },
625 };
626
627 auto index = BinarySearchFindIndex(textDirectionTable, ArraySize(textDirectionTable), direction);
628 return index < 0 ? "AUTO" : textDirectionTable[index].value;
629 }
630
ConvertWrapLineBreakStrategyToString(LineBreakStrategy lineBreakStrategy)631 inline std::string ConvertWrapLineBreakStrategyToString(LineBreakStrategy lineBreakStrategy)
632 {
633 static const LinearEnumMapNode<LineBreakStrategy, std::string> lineBreakStrategyTable[] = {
634 { LineBreakStrategy::GREEDY, "greedy" },
635 { LineBreakStrategy::HIGH_QUALITY, "high-quality" },
636 { LineBreakStrategy::BALANCED, "balanced" }
637 };
638
639 auto index = BinarySearchFindIndex(lineBreakStrategyTable, ArraySize(lineBreakStrategyTable), lineBreakStrategy);
640 return index < 0 ? "line-break-strategy" : lineBreakStrategyTable[index].value;
641 }
642
ConvertWrapTextSelectableToString(TextSelectableMode textSelectable)643 inline std::string ConvertWrapTextSelectableToString(TextSelectableMode textSelectable)
644 {
645 static const LinearEnumMapNode<TextSelectableMode, std::string> textSelectableTable[] = {
646 { TextSelectableMode::SELECTABLE_UNFOCUSABLE, "selectable-unfocusable" },
647 { TextSelectableMode::SELECTABLE_FOCUSABLE, "selectable-focusable" },
648 { TextSelectableMode::UNSELECTABLE, "unselectable" }
649 };
650
651 auto index = BinarySearchFindIndex(textSelectableTable, ArraySize(textSelectableTable), textSelectable);
652 return index < 0 ? "text-selectable" : textSelectableTable[index].value;
653 }
654
ConvertColorToString(Color color)655 inline std::string ConvertColorToString(Color color)
656 {
657 return color.ColorToString();
658 }
659
ConvertAxisToString(Axis axis)660 inline std::string ConvertAxisToString(Axis axis)
661 {
662 return AXIS_TYPE[static_cast<int32_t>(axis)];
663 }
664
ConvertSideToString(AlignDeclaration::Edge edge)665 inline std::string ConvertSideToString(AlignDeclaration::Edge edge)
666 {
667 if (edge == AlignDeclaration::Edge::TOP) {
668 return "Edge::Top";
669 } else if (edge == AlignDeclaration::Edge::CENTER) {
670 return "Edge::Center";
671 } else if (edge == AlignDeclaration::Edge::BOTTOM) {
672 return "Edge::Bottom";
673 } else if (edge == AlignDeclaration::Edge::BASELINE) {
674 return "Edge::Baseline";
675 } else if (edge == AlignDeclaration::Edge::START) {
676 return "Edge::Start";
677 } else if (edge == AlignDeclaration::Edge::MIDDLE) {
678 return "Edge::Middle";
679 } else if (edge == AlignDeclaration::Edge::END) {
680 return "Edge::End";
681 } else {
682 return "Edge::Center";
683 }
684 }
685
ConvertFontFamily(const std::vector<std::string> & fontFamily)686 inline std::string ConvertFontFamily(const std::vector<std::string>& fontFamily)
687 {
688 CHECK_NULL_RETURN(!fontFamily.empty(), "");
689 std::string result;
690 for (const auto& item : fontFamily) {
691 result += item;
692 result += ",";
693 }
694 result = result.substr(0, result.size() - 1);
695 return result;
696 }
697
698 std::string GetTextStyleInJson(const TextStyle& textStyle);
699
ConvertWrapTextHeightAdaptivePolicyToString(TextHeightAdaptivePolicy heightAdaptivePolicy)700 inline std::string ConvertWrapTextHeightAdaptivePolicyToString(TextHeightAdaptivePolicy heightAdaptivePolicy)
701 {
702 static const LinearEnumMapNode<TextHeightAdaptivePolicy, std::string> heightAdaptivePolicytTable[] = {
703 { TextHeightAdaptivePolicy::MAX_LINES_FIRST, "TextHeightAdaptivePolicy.MAX_LINES_FIRST" },
704 { TextHeightAdaptivePolicy::MIN_FONT_SIZE_FIRST, "TextHeightAdaptivePolicy.MIN_FONT_SIZE_FIRST" },
705 { TextHeightAdaptivePolicy::LAYOUT_CONSTRAINT_FIRST, "TextHeightAdaptivePolicy.LAYOUT_CONSTRAINT_FIRST" },
706 };
707
708 auto index =
709 BinarySearchFindIndex(heightAdaptivePolicytTable, ArraySize(heightAdaptivePolicytTable), heightAdaptivePolicy);
710 return index < 0 ? "TextHeightAdaptivePolicy.MAX_LINES_FIRST" : heightAdaptivePolicytTable[index].value;
711 }
712
ConvertWrapMarqueeUpdateStrategyToStirng(MarqueeUpdateStrategy marqueeUpdateStrategy)713 inline std::string ConvertWrapMarqueeUpdateStrategyToStirng(MarqueeUpdateStrategy marqueeUpdateStrategy)
714 {
715 static const LinearEnumMapNode<MarqueeUpdateStrategy, std::string> marqueeUpdateStrategyTable[] = {
716 { MarqueeUpdateStrategy::DEFAULT, "MarqueeUpdateStrategy.DEFAULT" },
717 { MarqueeUpdateStrategy::PRESERVE_POSITION, "MarqueeUpdateStrategy.PRESERVE_POSITION" },
718 };
719
720 auto index = BinarySearchFindIndex(
721 marqueeUpdateStrategyTable, ArraySize(marqueeUpdateStrategyTable), marqueeUpdateStrategy);
722 return index < 0 ? "MarqueeUpdateStrategy.DEFAULT" : marqueeUpdateStrategyTable[index].value;
723 }
724
ConvertSymbolColorToString(const std::vector<Color> & colors)725 inline std::string ConvertSymbolColorToString(const std::vector<Color>& colors)
726 {
727 if (colors.size() <= 0) {
728 return "";
729 }
730 auto colorStr = std::string("[");
731 for (auto color : colors) {
732 colorStr.append(color.ColorToString());
733 colorStr.append(",");
734 }
735 colorStr.append("]");
736 return colorStr;
737 }
738
IsValidTextDecorations(const std::vector<TextDecoration> & decorations)739 inline bool IsValidTextDecorations(const std::vector<TextDecoration>& decorations)
740 {
741 if (decorations.size() <= 0) {
742 return false;
743 }
744 for (TextDecoration decoration : decorations) {
745 if (decoration != TextDecoration::NONE) {
746 return true;
747 }
748 }
749 return false;
750 }
751
HasTextDecoration(const std::vector<TextDecoration> & decorations,TextDecoration value)752 inline bool HasTextDecoration(const std::vector<TextDecoration>& decorations, TextDecoration value)
753 {
754 auto iter = std::find(decorations.begin(), decorations.end(), value);
755 return iter != decorations.end();
756 }
757
IsEqualTextDecorations(const std::vector<TextDecoration> & left,const std::vector<TextDecoration> & right)758 inline bool IsEqualTextDecorations(
759 const std::vector<TextDecoration>& left, const std::vector<TextDecoration>& right)
760 {
761 if (left.size() != right.size()) {
762 return false;
763 }
764 for (int index = 0; index < static_cast<int>(left.size()); index++) {
765 if (!HasTextDecoration(right, left[index])) {
766 return false;
767 }
768 }
769 return true;
770 }
771 } // namespace OHOS::Ace::V2
772
773 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_V2_INSPECTOR_UTILS_H