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 return uMap.count(str) ? uMap.at(str) : FlexDirection::ROW;
144 }
145
ConvertWrapDirectionToStirng(WrapDirection direction)146 inline std::string ConvertWrapDirectionToStirng(WrapDirection direction)
147 {
148 if (direction == WrapDirection::HORIZONTAL) {
149 return "FlexDirection.Row";
150 } else if (direction == WrapDirection::HORIZONTAL_REVERSE) {
151 return "FlexDirection.RowReverse";
152 } else if (direction == WrapDirection::VERTICAL) {
153 return "FlexDirection.Column";
154 } else {
155 return "FlexDirection.ColumnReverse";
156 }
157 }
158
ConvertFlexAlignToStirng(FlexAlign align)159 inline std::string ConvertFlexAlignToStirng(FlexAlign align)
160 {
161 if (align == FlexAlign::FLEX_START) {
162 return "FlexAlign.Start";
163 } else if (align == FlexAlign::CENTER) {
164 return "FlexAlign.Center";
165 } else if (align == FlexAlign::FLEX_END) {
166 return "FlexAlign.End";
167 } else if (align == FlexAlign::SPACE_BETWEEN) {
168 return "FlexAlign.SpaceBetween";
169 } else if (align == FlexAlign::SPACE_AROUND) {
170 return "FlexAlign.SpaceAround";
171 } else if (align == FlexAlign::BASELINE) {
172 return "FlexAlign.Baseline";
173 } else if (align == FlexAlign::STRETCH) {
174 return "FlexAlign.Stretch";
175 } else {
176 return "FlexAlign.SpaceEvenly";
177 }
178 }
179
ConvertStringToFlexAlign(const std::string & str)180 inline FlexAlign ConvertStringToFlexAlign(const std::string& str)
181 {
182 static const std::unordered_map<std::string, FlexAlign> uMap {
183 { "FlexAlign.Start", FlexAlign::FLEX_START },
184 { "FlexAlign.Center", FlexAlign::CENTER },
185 { "FlexAlign.End", FlexAlign::FLEX_END },
186 { "FlexAlign.SpaceBetween", FlexAlign::SPACE_BETWEEN },
187 { "FlexAlign.SpaceAround", FlexAlign::SPACE_AROUND },
188 { "FlexAlign.Baseline", FlexAlign::BASELINE },
189 { "FlexAlign.Stretch", FlexAlign::STRETCH },
190 { "FlexAlign.SpaceEvenly", FlexAlign::SPACE_EVENLY },
191 };
192
193 return uMap.count(str) ? uMap.at(str) : FlexAlign::FLEX_START;
194 }
195
ConvertItemAlignToStirng(FlexAlign align)196 inline std::string ConvertItemAlignToStirng(FlexAlign align)
197 {
198 if (align == FlexAlign::FLEX_START) {
199 return "ItemAlign.Start";
200 }
201 if (align == FlexAlign::CENTER) {
202 return "ItemAlign.Center";
203 }
204 if (align == FlexAlign::FLEX_END) {
205 return "ItemAlign.End";
206 }
207 if (align == FlexAlign::BASELINE) {
208 return "ItemAlign.Baseline";
209 }
210 if (align == FlexAlign::STRETCH) {
211 return "ItemAlign.Stretch";
212 }
213 return "ItemAlign.Auto";
214 }
215
ConvertStringToItemAlign(const std::string & str)216 inline FlexAlign ConvertStringToItemAlign(const std::string& str)
217 {
218 static const std::unordered_map<std::string, FlexAlign> uMap {
219 { "ItemAlign.Start", FlexAlign::FLEX_START },
220 { "ItemAlign.Center", FlexAlign::CENTER },
221 { "ItemAlign.End", FlexAlign::FLEX_END },
222 { "ItemAlign.Baseline", FlexAlign::BASELINE },
223 { "ItemAlign.Stretch", FlexAlign::STRETCH },
224 };
225
226 return uMap.count(str) ? uMap.at(str) : FlexAlign::AUTO;
227 }
228
ConvertWrapAlignmentToStirng(WrapAlignment align)229 inline std::string ConvertWrapAlignmentToStirng(WrapAlignment align)
230 {
231 if (align == WrapAlignment::START) {
232 return "FlexAlign.Start";
233 } else if (align == WrapAlignment::CENTER) {
234 return "FlexAlign.Center";
235 } else if (align == WrapAlignment::END) {
236 return "FlexAlign.End";
237 } else if (align == WrapAlignment::SPACE_BETWEEN) {
238 return "FlexAlign.SpaceBetween";
239 } else if (align == WrapAlignment::SPACE_AROUND) {
240 return "FlexAlign.SpaceAround";
241 } else if (align == WrapAlignment::STRETCH) {
242 return "FlexAlign.Stretch";
243 } else if (align == WrapAlignment::BASELINE) {
244 return "FlexAlign.Baseline";
245 } else {
246 return "FlexAlign.SpaceEvenly";
247 }
248 }
249
ConvertWrapTextDecorationToStirng(TextDecoration decoration)250 inline std::string ConvertWrapTextDecorationToStirng(TextDecoration decoration)
251 {
252 static const LinearEnumMapNode<TextDecoration, std::string> decorationTable[] = {
253 { TextDecoration::NONE, "TextDecorationType.None" },
254 { TextDecoration::UNDERLINE, "TextDecorationType.Underline" },
255 { TextDecoration::OVERLINE, "TextDecorationType.Overline" },
256 { TextDecoration::LINE_THROUGH, "TextDecorationType.LineThrough" },
257 { TextDecoration::INHERIT, "TextDecorationType.Inherit" },
258 };
259
260 auto index = BinarySearchFindIndex(decorationTable, ArraySize(decorationTable), decoration);
261 return index < 0 ? "TextDecorationType.None" : decorationTable[index].value;
262 }
263
ConvertWrapTextDecorationStyleToString(TextDecorationStyle decorationStyle)264 inline std::string ConvertWrapTextDecorationStyleToString(TextDecorationStyle decorationStyle)
265 {
266 static const LinearEnumMapNode<TextDecorationStyle, std::string> decorationStyleTable[] = {
267 { TextDecorationStyle::SOLID, "TextDecorationStyle.SOLID" },
268 { TextDecorationStyle::DOUBLE, "TextDecorationStyle.DOUBLE" },
269 { TextDecorationStyle::DOTTED, "TextDecorationStyle.DOTTED" },
270 { TextDecorationStyle::DASHED, "TextDecorationStyle.DASHED" },
271 { TextDecorationStyle::WAVY, "TextDecorationStyle.WAVY" },
272 };
273
274 auto index = BinarySearchFindIndex(decorationStyleTable, ArraySize(decorationStyleTable), decorationStyle);
275 return index < 0 ? "TextDecorationStyle.SOLID" : decorationStyleTable[index].value;
276 }
277
ConvertWrapTextCaseToStirng(TextCase textCase)278 inline std::string ConvertWrapTextCaseToStirng(TextCase textCase)
279 {
280 static const LinearEnumMapNode<TextCase, std::string> textCaseTable[] = {
281 { TextCase::NORMAL, "TextCase.Normal" },
282 { TextCase::LOWERCASE, "TextCase.LowerCase" },
283 { TextCase::UPPERCASE, "TextCase.UpperCase" },
284 };
285
286 auto index = BinarySearchFindIndex(textCaseTable, ArraySize(textCaseTable), textCase);
287 return index < 0 ? "TextCase.Normal" : textCaseTable[index].value;
288 }
289
ConvertWrapImageFitToString(ImageFit imageFit)290 inline std::string ConvertWrapImageFitToString(ImageFit imageFit)
291 {
292 static const LinearEnumMapNode<ImageFit, std::string> imageFitTable[] = {
293 { ImageFit::COVER, "ImageFit.Cover" },
294 { ImageFit::FILL, "ImageFit.Fill" },
295 { ImageFit::CONTAIN, "ImageFit.Contain" },
296 { ImageFit::FITWIDTH, "ImageFit.FitWidth" },
297 { ImageFit::FITHEIGHT, "ImageFit.FitHeight" },
298 { ImageFit::NONE, "ImageFit.None" },
299 { ImageFit::SCALE_DOWN, "ImageFit.ScaleDown" },
300 };
301
302 auto index = BinarySearchFindIndex(imageFitTable, ArraySize(imageFitTable), imageFit);
303 return index < 0 ? "ImageFit.Cover" : imageFitTable[index].value;
304 }
305
ConvertWrapImageRepeatToString(ImageRepeat repeat)306 inline std::string ConvertWrapImageRepeatToString(ImageRepeat repeat)
307 {
308 static const LinearEnumMapNode<ImageRepeat, std::string> imageRepeatTable[] = {
309 { ImageRepeat::NO_REPEAT, "ImageRepeat.NoRepeat" },
310 { ImageRepeat::REPEAT, "ImageRepeat.XY" },
311 { ImageRepeat::REPEAT_X, "ImageRepeat.X" },
312 { ImageRepeat::REPEAT_Y, "ImageRepeat.Y" },
313 };
314
315 auto index = BinarySearchFindIndex(imageRepeatTable, ArraySize(imageRepeatTable), repeat);
316 return index < 0 ? "ImageRepeat.NoRepeat" : imageRepeatTable[index].value;
317 }
318
ConvertWrapImageInterpolationToString(ImageInterpolation imageInterpolation)319 inline std::string ConvertWrapImageInterpolationToString(ImageInterpolation imageInterpolation)
320 {
321 static const LinearEnumMapNode<ImageInterpolation, std::string> imageInterpolationTable[] = {
322 { ImageInterpolation::NONE, "ImageInterpolation.None" },
323 { ImageInterpolation::LOW, "ImageInterpolation.Low" },
324 { ImageInterpolation::MEDIUM, "ImageInterpolation.Medium" },
325 { ImageInterpolation::HIGH, "ImageInterpolation.High" },
326 };
327
328 auto index = BinarySearchFindIndex(imageInterpolationTable, ArraySize(imageInterpolationTable), imageInterpolation);
329 return index < 0 ? "ImageInterpolation.None" : imageInterpolationTable[index].value;
330 }
331
ConvertWrapImageRenderModeToString(ImageRenderMode imageRenderMode)332 inline std::string ConvertWrapImageRenderModeToString(ImageRenderMode imageRenderMode)
333 {
334 static const LinearEnumMapNode<ImageRenderMode, std::string> imageRenderModeTable[] = {
335 { ImageRenderMode::ORIGINAL, "ImageRenderMode.Original" },
336 { ImageRenderMode::TEMPLATE, "ImageRenderMode.Template" },
337 };
338
339 auto index = BinarySearchFindIndex(imageRenderModeTable, ArraySize(imageRenderModeTable), imageRenderMode);
340 return index < 0 ? "ImageRenderMode.Original" : imageRenderModeTable[index].value;
341 }
342
ConvertWrapTextAlignToString(TextAlign textAlign)343 inline std::string ConvertWrapTextAlignToString(TextAlign textAlign)
344 {
345 static const LinearEnumMapNode<TextAlign, std::string> textAlignTable[] = {
346 { TextAlign::START, "TextAlign.Start" },
347 { TextAlign::CENTER, "TextAlign.Center" },
348 { TextAlign::END, "TextAlign.End" },
349 { TextAlign::JUSTIFY, "TextAlign.Justify" },
350 { TextAlign::LEFT, "TextAlign.Left" },
351 { TextAlign::RIGHT, "TextAlign.Right" },
352 };
353
354 auto index = BinarySearchFindIndex(textAlignTable, ArraySize(textAlignTable), textAlign);
355 return index < 0 ? "TextAlign.Start" : textAlignTable[index].value;
356 }
357
ConvertWrapStringToTextAlign(const std::string & str)358 inline TextAlign ConvertWrapStringToTextAlign(const std::string& str)
359 {
360 static const std::unordered_map<std::string, TextAlign> uMap {
361 { "TextAlign.Left", TextAlign::LEFT },
362 { "TextAlign.Right", TextAlign::RIGHT },
363 { "TextAlign.Center", TextAlign::CENTER },
364 { "TextAlign.Justify", TextAlign::JUSTIFY },
365 { "TextAlign.Start", TextAlign::START },
366 { "TextAlign.End", TextAlign::END },
367 };
368
369 return uMap.count(str) ? uMap.at(str) : TextAlign::START;
370 }
371
ConvertWrapTextOverflowToString(TextOverflow textOverflow)372 inline std::string ConvertWrapTextOverflowToString(TextOverflow textOverflow)
373 {
374 static const LinearEnumMapNode<TextOverflow, std::string> textOverflowTable[] = {
375 { TextOverflow::NONE, "TextOverflow.None" },
376 { TextOverflow::CLIP, "TextOverflow.Clip" },
377 { TextOverflow::ELLIPSIS, "TextOverflow.Ellipsis" },
378 { TextOverflow::MARQUEE, "TextOverflow.Marquee" },
379 };
380
381 auto index = BinarySearchFindIndex(textOverflowTable, ArraySize(textOverflowTable), textOverflow);
382 return index < 0 ? "TextAlign.Start" : textOverflowTable[index].value;
383 }
384
ConvertWrapStringToTextOverflow(const std::string & str)385 inline TextOverflow ConvertWrapStringToTextOverflow(const std::string& str)
386 {
387 static const std::unordered_map<std::string, TextOverflow> uMap {
388 { "TextOverflow.Clip", TextOverflow::CLIP },
389 { "TextOverflow.Ellipsis", TextOverflow::ELLIPSIS },
390 { "TextOverflow.None", TextOverflow::NONE },
391 };
392
393 return uMap.count(str) ? uMap.at(str) : TextOverflow::CLIP;
394 }
395
ConvertWrapFontStyleToStirng(FontStyle fontStyle)396 inline std::string ConvertWrapFontStyleToStirng(FontStyle fontStyle)
397 {
398 static const LinearEnumMapNode<FontStyle, std::string> fontStyleTable[] = {
399 { FontStyle::NORMAL, "FontStyle.Normal" },
400 { FontStyle::ITALIC, "FontStyle.Italic" },
401 };
402
403 auto index = BinarySearchFindIndex(fontStyleTable, ArraySize(fontStyleTable), fontStyle);
404 return index < 0 ? "FontStyle.Normal" : fontStyleTable[index].value;
405 }
406
ConvertWrapFontWeightToStirng(FontWeight fontWeight)407 inline std::string ConvertWrapFontWeightToStirng(FontWeight fontWeight)
408 {
409 static const LinearEnumMapNode<FontWeight, std::string> fontWeightTable[] = {
410 { FontWeight::W100, "100" },
411 { FontWeight::W200, "200" },
412 { FontWeight::W300, "300" },
413 { FontWeight::W400, "400" },
414 { FontWeight::W500, "500" },
415 { FontWeight::W600, "600" },
416 { FontWeight::W700, "700" },
417 { FontWeight::W800, "800" },
418 { FontWeight::W900, "900" },
419 { FontWeight::BOLD, "FontWeight.Bold" },
420 { FontWeight::NORMAL, "FontWeight.Normal" },
421 { FontWeight::BOLDER, "FontWeight.Bolder" },
422 { FontWeight::LIGHTER, "FontWeight.Lighter" },
423 { FontWeight::MEDIUM, "FontWeight.Medium" },
424 { FontWeight::REGULAR, "FontWeight.Regular" },
425 };
426
427 auto index = BinarySearchFindIndex(fontWeightTable, ArraySize(fontWeightTable), fontWeight);
428 return index < 0 ? "FontWeight.Normal" : fontWeightTable[index].value;
429 }
430
ConvertWrapStringToFontWeight(const std::string & str)431 inline FontWeight ConvertWrapStringToFontWeight(const std::string& str)
432 {
433 static const std::unordered_map<std::string, FontWeight> uMap {
434 { "FontWeight.100", FontWeight::W100 },
435 { "FontWeight.200", FontWeight::W200 },
436 { "FontWeight.300", FontWeight::W300 },
437 { "FontWeight.400", FontWeight::W400 },
438 { "FontWeight.500", FontWeight::W500 },
439 { "FontWeight.600", FontWeight::W600 },
440 { "FontWeight.700", FontWeight::W700 },
441 { "FontWeight.800", FontWeight::W800 },
442 { "FontWeight.900", FontWeight::W900 },
443 { "FontWeight.Bold", FontWeight::BOLD },
444 { "FontWeight.Normal", FontWeight::NORMAL },
445 { "FontWeight.Bolder", FontWeight::BOLDER },
446 { "FontWeight.Lighter", FontWeight::LIGHTER },
447 { "FontWeight.Medium", FontWeight::MEDIUM },
448 { "FontWeight.Regular", FontWeight::REGULAR },
449 };
450
451 return uMap.count(str) ? uMap.at(str) : FontWeight::NORMAL;
452 }
453
ConvertWrapCopyOptionToString(CopyOptions copyOptions)454 inline std::string ConvertWrapCopyOptionToString(CopyOptions copyOptions)
455 {
456 static const LinearEnumMapNode<CopyOptions, std::string> copyOptionsTable[] = {
457 { CopyOptions::None, "CopyOptions::None" },
458 { CopyOptions::InApp, "CopyOptions:InApp" },
459 { CopyOptions::Local, "CopyOptions:Local" },
460 { CopyOptions::Distributed, "CopyOptions:Distributed" },
461 };
462
463 auto index = BinarySearchFindIndex(copyOptionsTable, ArraySize(copyOptionsTable), copyOptions);
464 return index < 0 ? "CopyOptions::None" : copyOptionsTable[index].value;
465 }
466
ConvertWrapWordBreakToString(WordBreak wordBreak)467 inline std::string ConvertWrapWordBreakToString(WordBreak wordBreak)
468 {
469 static const LinearEnumMapNode<WordBreak, std::string> wordBreakTable[] = {
470 { WordBreak::NORMAL, "normal" },
471 { WordBreak::BREAK_ALL, "break-all" },
472 { WordBreak::BREAK_WORD, "break-word" },
473 };
474
475 auto index = BinarySearchFindIndex(wordBreakTable, ArraySize(wordBreakTable), wordBreak);
476 return index < 0 ? "break-word" : wordBreakTable[index].value;
477 }
478
ConvertEllipsisModeToString(EllipsisMode value)479 inline std::string ConvertEllipsisModeToString(EllipsisMode value)
480 {
481 static const LinearEnumMapNode<EllipsisMode, std::string> modalTable[] = {
482 { EllipsisMode::HEAD, "head" },
483 { EllipsisMode::MIDDLE, "middle" },
484 { EllipsisMode::TAIL, "tail" },
485 };
486 auto index = BinarySearchFindIndex(modalTable, ArraySize(modalTable), value);
487 return index < 0 ? "tail" : modalTable[index].value;
488 }
489
ConvertColorToString(Color color)490 inline std::string ConvertColorToString(Color color)
491 {
492 return color.ColorToString();
493 }
494
ConvertAxisToString(Axis axis)495 inline std::string ConvertAxisToString(Axis axis)
496 {
497 return AXIS_TYPE[static_cast<int32_t>(axis)];
498 }
499
ConvertSideToString(AlignDeclaration::Edge edge)500 inline std::string ConvertSideToString(AlignDeclaration::Edge edge)
501 {
502 if (edge == AlignDeclaration::Edge::TOP) {
503 return "Edge::Top";
504 } else if (edge == AlignDeclaration::Edge::CENTER) {
505 return "Edge::Center";
506 } else if (edge == AlignDeclaration::Edge::BOTTOM) {
507 return "Edge::Bottom";
508 } else if (edge == AlignDeclaration::Edge::BASELINE) {
509 return "Edge::Baseline";
510 } else if (edge == AlignDeclaration::Edge::START) {
511 return "Edge::Start";
512 } else if (edge == AlignDeclaration::Edge::MIDDLE) {
513 return "Edge::Middle";
514 } else if (edge == AlignDeclaration::Edge::END) {
515 return "Edge::End";
516 } else {
517 return "Edge::Center";
518 }
519 }
520
ConvertFontFamily(const std::vector<std::string> & fontFamily)521 inline std::string ConvertFontFamily(const std::vector<std::string>& fontFamily)
522 {
523 CHECK_NULL_RETURN(!fontFamily.empty(), "");
524 std::string result;
525 for (const auto& item : fontFamily) {
526 result += item;
527 result += ",";
528 }
529 result = result.substr(0, result.size() - 1);
530 return result;
531 }
532
533 std::string GetTextStyleInJson(const TextStyle& textStyle);
534
ConvertWrapTextHeightAdaptivePolicyToString(TextHeightAdaptivePolicy heightAdaptivePolicy)535 inline std::string ConvertWrapTextHeightAdaptivePolicyToString(TextHeightAdaptivePolicy heightAdaptivePolicy)
536 {
537 static const LinearEnumMapNode<TextHeightAdaptivePolicy, std::string> heightAdaptivePolicytTable[] = {
538 { TextHeightAdaptivePolicy::MAX_LINES_FIRST, "TextHeightAdaptivePolicy.MAX_LINES_FIRST" },
539 { TextHeightAdaptivePolicy::MIN_FONT_SIZE_FIRST, "TextHeightAdaptivePolicy.MIN_FONT_SIZE_FIRST" },
540 { TextHeightAdaptivePolicy::LAYOUT_CONSTRAINT_FIRST, "TextHeightAdaptivePolicy.LAYOUT_CONSTRAINT_FIRST" },
541 };
542
543 auto index =
544 BinarySearchFindIndex(heightAdaptivePolicytTable, ArraySize(heightAdaptivePolicytTable), heightAdaptivePolicy);
545 return index < 0 ? "TextHeightAdaptivePolicy.MAX_LINES_FIRST" : heightAdaptivePolicytTable[index].value;
546 }
547
548 } // namespace OHOS::Ace::V2
549
550 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_V2_INSPECTOR_UTILS_H