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