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