1 /*
2 * Copyright (c) 2023 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 #include "core/interfaces/native/node/rich_editor_modifier.h"
16
17 #include "core/components_ng/pattern/rich_editor/rich_editor_model_ng.h"
18 #include "core/components_ng/pattern/rich_editor/rich_editor_theme.h"
19
20 namespace OHOS::Ace::NG {
21 namespace {
22 constexpr uint32_t NORMAL_VALUE_ARRAY_STEP = 2;
23 constexpr DisplayMode DEFAULT_BAR_STATE_VALUE = DisplayMode::AUTO;
24 }
25
26 constexpr bool DEFAULT_ENABLE_TEXT_DETECTOR = false;
27
SetRichEditorDetectEnable(ArkUINodeHandle node,ArkUI_Uint32 value)28 void SetRichEditorDetectEnable(ArkUINodeHandle node, ArkUI_Uint32 value)
29 {
30 auto* frameNode = reinterpret_cast<FrameNode*>(node);
31 CHECK_NULL_VOID(frameNode);
32 RichEditorModelNG::SetTextDetectEnable(frameNode, static_cast<bool>(value));
33 }
34
ResetRichEditorDetectEnable(ArkUINodeHandle node)35 void ResetRichEditorDetectEnable(ArkUINodeHandle node)
36 {
37 auto* frameNode = reinterpret_cast<FrameNode*>(node);
38 CHECK_NULL_VOID(frameNode);
39 RichEditorModelNG::SetTextDetectEnable(frameNode, DEFAULT_ENABLE_TEXT_DETECTOR);
40 }
41
SetRichEditorDataDetectorConfigWithEvent(ArkUINodeHandle node,const struct ArkUITextDetectConfigStruct * arkUITextDetectConfig)42 void SetRichEditorDataDetectorConfigWithEvent(
43 ArkUINodeHandle node, const struct ArkUITextDetectConfigStruct* arkUITextDetectConfig)
44 {
45 auto* frameNode = reinterpret_cast<FrameNode*>(node);
46 CHECK_NULL_VOID(frameNode);
47 TextDetectConfig textDetectConfig;
48 textDetectConfig.types = arkUITextDetectConfig->types;
49 if (arkUITextDetectConfig->onResult) {
50 textDetectConfig.onResult =
51 std::move(*(reinterpret_cast<std::function<void(const std::string&)>*>(arkUITextDetectConfig->onResult)));
52 }
53 textDetectConfig.entityColor = Color(arkUITextDetectConfig->entityColor);
54 textDetectConfig.entityDecorationType = TextDecoration(arkUITextDetectConfig->entityDecorationType);
55 textDetectConfig.entityDecorationColor = Color(arkUITextDetectConfig->entityDecorationColor);
56 textDetectConfig.entityDecorationStyle = TextDecorationStyle(arkUITextDetectConfig->entityDecorationStyle);
57 RichEditorModelNG::SetTextDetectConfig(frameNode, textDetectConfig);
58 }
59
ResetRichEditorDataDetectorConfigWithEvent(ArkUINodeHandle node)60 void ResetRichEditorDataDetectorConfigWithEvent(ArkUINodeHandle node)
61 {
62 auto* frameNode = reinterpret_cast<FrameNode*>(node);
63 CHECK_NULL_VOID(frameNode);
64 TextDetectConfig textDetectConfig;
65 RichEditorModelNG::SetTextDetectConfig(frameNode, textDetectConfig);
66 }
67
SetRichEditorOnIMEInputComplete(ArkUINodeHandle node,void * callback)68 void SetRichEditorOnIMEInputComplete(ArkUINodeHandle node, void* callback)
69 {
70 auto* frameNode = reinterpret_cast<FrameNode*>(node);
71 CHECK_NULL_VOID(frameNode);
72 if (callback) {
73 auto onIMEInputComplete = reinterpret_cast<std::function<void(RichEditorAbstractSpanResult)>*>(callback);
74 RichEditorModelNG::SetOnIMEInputComplete(frameNode, std::move(*onIMEInputComplete));
75 } else {
76 RichEditorModelNG::SetOnIMEInputComplete(frameNode, nullptr);
77 }
78 }
79
ResetRichEditorOnIMEInputComplete(ArkUINodeHandle node)80 void ResetRichEditorOnIMEInputComplete(ArkUINodeHandle node)
81 {
82 auto* frameNode = reinterpret_cast<FrameNode*>(node);
83 CHECK_NULL_VOID(frameNode);
84 RichEditorModelNG::SetOnIMEInputComplete(frameNode, nullptr);
85 }
86
SetRichEditorCopyOptions(ArkUINodeHandle node,ArkUI_Int32 copyOptionsValue)87 void SetRichEditorCopyOptions(ArkUINodeHandle node, ArkUI_Int32 copyOptionsValue)
88 {
89 auto* frameNode = reinterpret_cast<FrameNode*>(node);
90 CopyOptions copyOptions = static_cast<CopyOptions>(copyOptionsValue);
91 CHECK_NULL_VOID(frameNode);
92 RichEditorModelNG::SetCopyOption(frameNode, copyOptions);
93 }
94
ResetRichEditorCopyOptions(ArkUINodeHandle node)95 void ResetRichEditorCopyOptions(ArkUINodeHandle node)
96 {
97 auto* frameNode = reinterpret_cast<FrameNode*>(node);
98 CHECK_NULL_VOID(frameNode);
99 CopyOptions defaultCopyOptions = CopyOptions::Distributed;
100 RichEditorModelNG::SetCopyOption(frameNode, defaultCopyOptions);
101 }
102
SetRichEditorOnSelectionChange(ArkUINodeHandle node,void * callback)103 void SetRichEditorOnSelectionChange(ArkUINodeHandle node, void* callback)
104 {
105 auto* frameNode = reinterpret_cast<FrameNode*>(node);
106 CHECK_NULL_VOID(frameNode);
107 if (callback) {
108 auto onSelectionChange = reinterpret_cast<std::function<void(const BaseEventInfo*)>*>(callback);
109 RichEditorModelNG::SetOnSelectionChange(frameNode, std::move(*onSelectionChange));
110 } else {
111 RichEditorModelNG::SetOnSelectionChange(frameNode, nullptr);
112 }
113 }
114
ResetRichEditorOnSelectionChange(ArkUINodeHandle node)115 void ResetRichEditorOnSelectionChange(ArkUINodeHandle node)
116 {
117 auto* frameNode = reinterpret_cast<FrameNode*>(node);
118 CHECK_NULL_VOID(frameNode);
119 RichEditorModelNG::SetOnSelectionChange(frameNode, nullptr);
120 }
121
SetRichEditorCaretColor(ArkUINodeHandle node,ArkUI_Uint32 color)122 void SetRichEditorCaretColor(ArkUINodeHandle node, ArkUI_Uint32 color)
123 {
124 auto* frameNode = reinterpret_cast<FrameNode*>(node);
125 CHECK_NULL_VOID(frameNode);
126 RichEditorModelNG::SetCaretColor(frameNode, Color(color));
127 }
128
ResetRichEditorCaretColor(ArkUINodeHandle node)129 void ResetRichEditorCaretColor(ArkUINodeHandle node)
130 {
131 auto pipeline = PipelineContext::GetCurrentContext();
132 CHECK_NULL_VOID(pipeline);
133 auto richEditorTheme = pipeline->GetTheme<RichEditorTheme>();
134 CHECK_NULL_VOID(richEditorTheme);
135 auto caretColor = richEditorTheme->GetCaretColor();
136 auto* frameNode = reinterpret_cast<FrameNode*>(node);
137 CHECK_NULL_VOID(frameNode);
138 RichEditorModelNG::SetCaretColor(frameNode, caretColor);
139 }
140
SetRichEditorOnSelect(ArkUINodeHandle node,void * callback)141 void SetRichEditorOnSelect(ArkUINodeHandle node, void* callback)
142 {
143 auto* frameNode = reinterpret_cast<FrameNode*>(node);
144 CHECK_NULL_VOID(frameNode);
145 if (callback) {
146 auto onSelect = reinterpret_cast<std::function<void(const BaseEventInfo*)>*>(callback);
147 RichEditorModelNG::SetOnSelect(frameNode, std::move(*onSelect));
148 } else {
149 RichEditorModelNG::SetOnSelect(frameNode, nullptr);
150 }
151 }
152
ResetRichEditorOnSelect(ArkUINodeHandle node)153 void ResetRichEditorOnSelect(ArkUINodeHandle node)
154 {
155 auto* frameNode = reinterpret_cast<FrameNode*>(node);
156 CHECK_NULL_VOID(frameNode);
157 RichEditorModelNG::SetOnSelect(frameNode, nullptr);
158 }
159
SetRichEditorOnSubmit(ArkUINodeHandle node,void * callback)160 void SetRichEditorOnSubmit(ArkUINodeHandle node, void* callback)
161 {
162 auto* frameNode = reinterpret_cast<FrameNode*>(node);
163 CHECK_NULL_VOID(frameNode);
164 if (callback) {
165 auto onSubmit = reinterpret_cast<std::function<void(int32_t, NG::TextFieldCommonEvent&)>*>(callback);
166 RichEditorModelNG::SetOnSubmit(frameNode, std::move(*onSubmit));
167 } else {
168 RichEditorModelNG::SetOnSubmit(frameNode, nullptr);
169 }
170 }
171
ResetRichEditorOnSubmit(ArkUINodeHandle node)172 void ResetRichEditorOnSubmit(ArkUINodeHandle node)
173 {
174 auto* frameNode = reinterpret_cast<FrameNode*>(node);
175 CHECK_NULL_VOID(frameNode);
176 RichEditorModelNG::SetOnSubmit(frameNode, nullptr);
177 }
178
SetRichEditorAboutToIMEInput(ArkUINodeHandle node,void * callback)179 void SetRichEditorAboutToIMEInput(ArkUINodeHandle node, void* callback)
180 {
181 auto* frameNode = reinterpret_cast<FrameNode*>(node);
182 CHECK_NULL_VOID(frameNode);
183 if (callback) {
184 auto aboutToIMEInput = reinterpret_cast<std::function<bool(const RichEditorInsertValue&)>*>(callback);
185 RichEditorModelNG::SetAboutToIMEInput(frameNode, std::move(*aboutToIMEInput));
186 } else {
187 RichEditorModelNG::SetAboutToIMEInput(frameNode, nullptr);
188 }
189 }
190
ResetRichEditorAboutToIMEInput(ArkUINodeHandle node)191 void ResetRichEditorAboutToIMEInput(ArkUINodeHandle node)
192 {
193 auto* frameNode = reinterpret_cast<FrameNode*>(node);
194 CHECK_NULL_VOID(frameNode);
195 RichEditorModelNG::SetAboutToIMEInput(frameNode, nullptr);
196 }
197
SetRichEditorOnReady(ArkUINodeHandle node,void * callback)198 void SetRichEditorOnReady(ArkUINodeHandle node, void* callback)
199 {
200 auto* frameNode = reinterpret_cast<FrameNode*>(node);
201 CHECK_NULL_VOID(frameNode);
202 if (callback) {
203 auto onReady = reinterpret_cast<std::function<void(void)>*>(callback);
204 RichEditorModelNG::SetOnReady(frameNode, std::move(*onReady));
205 } else {
206 RichEditorModelNG::SetOnReady(frameNode, nullptr);
207 }
208 }
209
ResetRichEditorOnReady(ArkUINodeHandle node)210 void ResetRichEditorOnReady(ArkUINodeHandle node)
211 {
212 auto* frameNode = reinterpret_cast<FrameNode*>(node);
213 CHECK_NULL_VOID(frameNode);
214 RichEditorModelNG::SetOnReady(frameNode, nullptr);
215 }
216
SetRichEditorOnDeleteComplete(ArkUINodeHandle node,void * callback)217 void SetRichEditorOnDeleteComplete(ArkUINodeHandle node, void* callback)
218 {
219 auto* frameNode = reinterpret_cast<FrameNode*>(node);
220 CHECK_NULL_VOID(frameNode);
221 if (callback) {
222 auto onDeleteComplete = reinterpret_cast<std::function<void(void)>*>(callback);
223 RichEditorModelNG::SetOnDeleteComplete(frameNode, std::move(*onDeleteComplete));
224 } else {
225 RichEditorModelNG::SetOnDeleteComplete(frameNode, nullptr);
226 }
227 }
228
ResetRichEditorOnDeleteComplete(ArkUINodeHandle node)229 void ResetRichEditorOnDeleteComplete(ArkUINodeHandle node)
230 {
231 auto* frameNode = reinterpret_cast<FrameNode*>(node);
232 CHECK_NULL_VOID(frameNode);
233 RichEditorModelNG::SetOnDeleteComplete(frameNode, nullptr);
234 }
235
SetRichEditorOnEditingChange(ArkUINodeHandle node,void * callback)236 void SetRichEditorOnEditingChange(ArkUINodeHandle node, void* callback)
237 {
238 auto* frameNode = reinterpret_cast<FrameNode*>(node);
239 CHECK_NULL_VOID(frameNode);
240 if (callback) {
241 auto onEditingChange = reinterpret_cast<std::function<void(bool)>*>(callback);
242 RichEditorModelNG::SetOnEditingChange(frameNode, std::move(*onEditingChange));
243 } else {
244 RichEditorModelNG::SetOnEditingChange(frameNode, nullptr);
245 }
246 }
247
ResetRichEditorOnEditingChange(ArkUINodeHandle node)248 void ResetRichEditorOnEditingChange(ArkUINodeHandle node)
249 {
250 auto* frameNode = reinterpret_cast<FrameNode*>(node);
251 CHECK_NULL_VOID(frameNode);
252 RichEditorModelNG::SetOnEditingChange(frameNode, nullptr);
253 }
254
SetRichEditorSelectedBackgroundColor(ArkUINodeHandle node,ArkUI_Uint32 color)255 void SetRichEditorSelectedBackgroundColor(ArkUINodeHandle node, ArkUI_Uint32 color)
256 {
257 auto* frameNode = reinterpret_cast<FrameNode*>(node);
258 CHECK_NULL_VOID(frameNode);
259 RichEditorModelNG::SetSelectedBackgroundColor(frameNode, Color(color));
260 }
261
ResetRichEditorSelectedBackgroundColor(ArkUINodeHandle node)262 void ResetRichEditorSelectedBackgroundColor(ArkUINodeHandle node)
263 {
264 auto pipeline = PipelineContext::GetCurrentContext();
265 CHECK_NULL_VOID(pipeline);
266 auto richEditorTheme = pipeline->GetTheme<RichEditorTheme>();
267 CHECK_NULL_VOID(richEditorTheme);
268 auto selectedBackgroundColor = richEditorTheme->GetSelectedBackgroundColor();
269 auto* frameNode = reinterpret_cast<FrameNode*>(node);
270 CHECK_NULL_VOID(frameNode);
271 RichEditorModelNG::SetSelectedBackgroundColor(frameNode, selectedBackgroundColor);
272 }
273
SetRichEditorOnPaste(ArkUINodeHandle node,void * callback)274 void SetRichEditorOnPaste(ArkUINodeHandle node, void* callback)
275 {
276 auto* frameNode = reinterpret_cast<FrameNode*>(node);
277 CHECK_NULL_VOID(frameNode);
278 if (callback) {
279 auto onPaste = reinterpret_cast<std::function<void(NG::TextCommonEvent&)>*>(callback);
280 RichEditorModelNG::SetOnPaste(frameNode, std::move(*onPaste));
281 } else {
282 RichEditorModelNG::SetOnPaste(frameNode, nullptr);
283 }
284 }
285
ResetRichEditorOnPaste(ArkUINodeHandle node)286 void ResetRichEditorOnPaste(ArkUINodeHandle node)
287 {
288 auto* frameNode = reinterpret_cast<FrameNode*>(node);
289 CHECK_NULL_VOID(frameNode);
290 RichEditorModelNG::SetOnPaste(frameNode, nullptr);
291 }
292
SetRichEditorOnCut(ArkUINodeHandle node,void * callback)293 void SetRichEditorOnCut(ArkUINodeHandle node, void* callback)
294 {
295 auto* frameNode = reinterpret_cast<FrameNode*>(node);
296 CHECK_NULL_VOID(frameNode);
297 if (callback) {
298 auto onCut = reinterpret_cast<std::function<void(NG::TextCommonEvent&)>*>(callback);
299 RichEditorModelNG::SetOnCut(frameNode, std::move(*onCut));
300 } else {
301 RichEditorModelNG::SetOnCut(frameNode, nullptr);
302 }
303 }
304
ResetRichEditorOnCut(ArkUINodeHandle node)305 void ResetRichEditorOnCut(ArkUINodeHandle node)
306 {
307 auto* frameNode = reinterpret_cast<FrameNode*>(node);
308 CHECK_NULL_VOID(frameNode);
309 RichEditorModelNG::SetOnCut(frameNode, nullptr);
310 }
311
SetRichEditorOnCopy(ArkUINodeHandle node,void * callback)312 void SetRichEditorOnCopy(ArkUINodeHandle node, void* callback)
313 {
314 auto* frameNode = reinterpret_cast<FrameNode*>(node);
315 CHECK_NULL_VOID(frameNode);
316 if (callback) {
317 auto onCopy = reinterpret_cast<std::function<void(NG::TextCommonEvent&)>*>(callback);
318 RichEditorModelNG::SetOnCopy(frameNode, std::move(*onCopy));
319 } else {
320 RichEditorModelNG::SetOnCopy(frameNode, nullptr);
321 }
322 }
323
ResetRichEditorOnCopy(ArkUINodeHandle node)324 void ResetRichEditorOnCopy(ArkUINodeHandle node)
325 {
326 auto* frameNode = reinterpret_cast<FrameNode*>(node);
327 CHECK_NULL_VOID(frameNode);
328 RichEditorModelNG::SetOnCopy(frameNode, nullptr);
329 }
330
SetRichEditorEnterKeyType(ArkUINodeHandle node,ArkUI_Uint32 enterKeyType)331 void SetRichEditorEnterKeyType(ArkUINodeHandle node, ArkUI_Uint32 enterKeyType)
332 {
333 auto* frameNode = reinterpret_cast<FrameNode*>(node);
334 CHECK_NULL_VOID(frameNode);
335 RichEditorModelNG::SetEnterKeyType(frameNode, TextInputAction(enterKeyType));
336 }
337
ResetRichEditorEnterKeyType(ArkUINodeHandle node)338 void ResetRichEditorEnterKeyType(ArkUINodeHandle node)
339 {
340 auto* frameNode = reinterpret_cast<FrameNode*>(node);
341 CHECK_NULL_VOID(frameNode);
342 auto defaultEnterKeyType = TextInputAction::NEW_LINE;
343 RichEditorModelNG::SetEnterKeyType(frameNode, defaultEnterKeyType);
344 }
345
SetRichEditorEnableKeyboardOnFocus(ArkUINodeHandle node,ArkUI_Bool value)346 void SetRichEditorEnableKeyboardOnFocus(ArkUINodeHandle node, ArkUI_Bool value)
347 {
348 auto* frameNode = reinterpret_cast<FrameNode*>(node);
349 CHECK_NULL_VOID(frameNode);
350 RichEditorModelNG::SetRequestKeyboardOnFocus(frameNode, value);
351 }
352
ResetRichEditorEnableKeyboardOnFocus(ArkUINodeHandle node)353 void ResetRichEditorEnableKeyboardOnFocus(ArkUINodeHandle node)
354 {
355 auto* frameNode = reinterpret_cast<FrameNode*>(node);
356 CHECK_NULL_VOID(frameNode);
357 RichEditorModelNG::SetRequestKeyboardOnFocus(frameNode, true);
358 }
359
SetRichEditorEnablePreviewText(ArkUINodeHandle node,ArkUI_Bool value)360 void SetRichEditorEnablePreviewText(ArkUINodeHandle node, ArkUI_Bool value)
361 {
362 auto* frameNode = reinterpret_cast<FrameNode*>(node);
363 CHECK_NULL_VOID(frameNode);
364 RichEditorModelNG::SetSupportPreviewText(frameNode, value);
365 }
366
ResetRichEditorEnablePreviewText(ArkUINodeHandle node)367 void ResetRichEditorEnablePreviewText(ArkUINodeHandle node)
368 {
369 auto* frameNode = reinterpret_cast<FrameNode*>(node);
370 CHECK_NULL_VOID(frameNode);
371 RichEditorModelNG::SetSupportPreviewText(frameNode, true);
372 }
373
374
SetRichEditorEditMenuOptions(ArkUINodeHandle node,void * onCreateMenuCallback,void * onMenuItemClickCallback,void * onPrepareMenuCallback)375 void SetRichEditorEditMenuOptions(ArkUINodeHandle node, void* onCreateMenuCallback, void* onMenuItemClickCallback,
376 void* onPrepareMenuCallback)
377 {
378 auto* frameNode = reinterpret_cast<FrameNode*>(node);
379 CHECK_NULL_VOID(frameNode);
380 CHECK_NULL_VOID(onCreateMenuCallback && onMenuItemClickCallback && onPrepareMenuCallback);
381 NG::OnCreateMenuCallback* onCreateMenu = reinterpret_cast<NG::OnCreateMenuCallback*>(onCreateMenuCallback);
382 NG::OnMenuItemClickCallback* onMenuItemClick
383 = reinterpret_cast<NG::OnMenuItemClickCallback*>(onMenuItemClickCallback);
384 NG::OnPrepareMenuCallback* onPrepareMenu = reinterpret_cast<NG::OnPrepareMenuCallback*>(onPrepareMenuCallback);
385 RichEditorModelNG::SetSelectionMenuOptions(frameNode, std::move(*onCreateMenu),
386 std::move(*onMenuItemClick), std::move(*onPrepareMenu));
387 }
388
ResetRichEditorEditMenuOptions(ArkUINodeHandle node)389 void ResetRichEditorEditMenuOptions(ArkUINodeHandle node)
390 {
391 auto* frameNode = reinterpret_cast<FrameNode*>(node);
392 CHECK_NULL_VOID(frameNode);
393 NG::OnCreateMenuCallback onCreateMenuCallback;
394 NG::OnMenuItemClickCallback onMenuItemClick;
395 NG::OnPrepareMenuCallback onPrepareMenuCallback;
396 RichEditorModelNG::SetSelectionMenuOptions(frameNode, std::move(onCreateMenuCallback), std::move(onMenuItemClick),
397 std::move(onPrepareMenuCallback));
398 }
399
SetRichEditorOnWillChange(ArkUINodeHandle node,void * callback)400 void SetRichEditorOnWillChange(ArkUINodeHandle node, void* callback)
401 {
402 auto* frameNode = reinterpret_cast<FrameNode*>(node);
403 CHECK_NULL_VOID(frameNode);
404 auto onWillChange = reinterpret_cast<std::function<bool(const RichEditorChangeValue&)>*>(callback);
405 RichEditorModelNG::SetOnWillChange(frameNode, std::move(*onWillChange));
406 }
407
ResetRichEditorOnWillChange(ArkUINodeHandle node)408 void ResetRichEditorOnWillChange(ArkUINodeHandle node)
409 {
410 auto* frameNode = reinterpret_cast<FrameNode*>(node);
411 CHECK_NULL_VOID(frameNode);
412 RichEditorModelNG::SetOnWillChange(frameNode, nullptr);
413 }
414
SetRichEditorOnDidChange(ArkUINodeHandle node,void * callback)415 void SetRichEditorOnDidChange(ArkUINodeHandle node, void* callback)
416 {
417 auto* frameNode = reinterpret_cast<FrameNode*>(node);
418 CHECK_NULL_VOID(frameNode);
419 auto onDidChange = reinterpret_cast<std::function<bool(const RichEditorChangeValue&)>*>(callback);
420 RichEditorModelNG::SetOnDidChange(frameNode, std::move(*onDidChange));
421 }
422
ResetRichEditorOnDidChange(ArkUINodeHandle node)423 void ResetRichEditorOnDidChange(ArkUINodeHandle node)
424 {
425 auto* frameNode = reinterpret_cast<FrameNode*>(node);
426 CHECK_NULL_VOID(frameNode);
427 RichEditorModelNG::SetOnDidChange(frameNode, nullptr);
428 }
429
SetRichEditorPlaceholderValue(const ArkUI_Float64 * valueArray,ArkUI_Uint32 index,const ArkUI_Uint32 arraySize,ArkUI_Float64 & result)430 bool SetRichEditorPlaceholderValue(
431 const ArkUI_Float64* valueArray, ArkUI_Uint32 index, const ArkUI_Uint32 arraySize, ArkUI_Float64& result)
432 {
433 CHECK_NULL_RETURN(valueArray, false);
434 ArkUI_Uint32 step = NORMAL_VALUE_ARRAY_STEP;
435 auto hasValueIndex = index * step;
436 auto valueIndex = hasValueIndex + 1;
437 if (valueIndex >= arraySize) {
438 return false;
439 }
440 if (static_cast<bool>(valueArray[hasValueIndex])) {
441 result = valueArray[valueIndex];
442 return true;
443 }
444 return false;
445 }
446
SetRichEditorPlaceholderDimension(const ArkUI_Float64 * dimensionArray,ArkUI_Uint32 offset,const ArkUI_Uint32 arraySize,std::optional<Dimension> & optDimension)447 bool SetRichEditorPlaceholderDimension(const ArkUI_Float64* dimensionArray, ArkUI_Uint32 offset,
448 const ArkUI_Uint32 arraySize, std::optional<Dimension>& optDimension)
449 {
450 CHECK_NULL_RETURN(dimensionArray, false);
451 auto hasValue = dimensionArray[offset];
452 if (!static_cast<bool>(hasValue)) {
453 return false;
454 }
455 auto valueIndex = offset + 1;
456 auto unitIndex = offset + 2;
457 if (unitIndex >= arraySize) {
458 return false;
459 }
460 auto value = dimensionArray[valueIndex];
461 auto unit = dimensionArray[unitIndex];
462 DimensionUnit unitValue = static_cast<DimensionUnit>(unit);
463 optDimension = Dimension(value, unitValue);
464 return true;
465 }
466
SetRichEditorPlaceholder(ArkUINodeHandle node,ArkUI_CharPtr * stringParameters,const ArkUI_Uint32 stringParametersCount,const ArkUI_Float64 * valuesArray,const ArkUI_Uint32 valuesCount)467 void SetRichEditorPlaceholder(ArkUINodeHandle node, ArkUI_CharPtr* stringParameters,
468 const ArkUI_Uint32 stringParametersCount, const ArkUI_Float64* valuesArray, const ArkUI_Uint32 valuesCount)
469 {
470 auto* frameNode = reinterpret_cast<FrameNode*>(node);
471 CHECK_NULL_VOID(frameNode);
472 double result = 0;
473 PlaceholderOptions options;
474 CHECK_NULL_VOID(stringParameters);
475 if (0 < stringParametersCount && stringParameters[0] != nullptr) { // 0: value
476 std::string value = stringParameters[0];
477 options.value = UtfUtils::Str8ToStr16(value);
478 }
479 for (ArkUI_Uint32 index = 1; index < stringParametersCount; index++) { // 1: value
480 options.fontFamilies.push_back(stringParameters[index]);
481 }
482 if (SetRichEditorPlaceholderValue(valuesArray, 0, valuesCount, result) && // 0: fontWeight
483 GreatOrEqual(result, 0.0) && result <= static_cast<double>(OHOS::Ace::FontWeight::REGULAR)) {
484 options.fontWeight = static_cast<OHOS::Ace::FontWeight>(result);
485 }
486 if (SetRichEditorPlaceholderValue(valuesArray, 1, valuesCount, result) && // 1: fontStyle
487 GreatOrEqual(result, 0.0) && result < static_cast<double>(OHOS::Ace::FontStyle::NONE)) {
488 options.fontStyle = static_cast<OHOS::Ace::FontStyle>(result);
489 }
490 if (SetRichEditorPlaceholderValue(valuesArray, 2, valuesCount, result)) { // 2: fontColor
491 double colorResourceId = -1.0;
492 Color fontColor;
493 if (SetRichEditorPlaceholderValue(valuesArray, 3, valuesCount, colorResourceId) && // 3: colorResourceId
494 GreatOrEqual(colorResourceId, 0.0)) {
495 fontColor.SetValue(static_cast<ArkUI_Uint32>(result));
496 options.fontColor = fontColor;
497 } else {
498 fontColor.SetValue(static_cast<ArkUI_Uint32>(result));
499 options.fontColor = fontColor;
500 }
501 }
502 std::optional<Dimension> fontSizeOptional = std::nullopt;
503 ArkUI_Uint32 step = NORMAL_VALUE_ARRAY_STEP;
504 ArkUI_Uint32 offset = 4 * step; // 4: fontSize
505 if (SetRichEditorPlaceholderDimension(valuesArray, offset, valuesCount, fontSizeOptional)) {
506 options.fontSize = fontSizeOptional;
507 }
508
509 RichEditorModelNG::SetPlaceholder(frameNode, options);
510 }
511
ResetRichEditorPlaceholder(ArkUINodeHandle node)512 void ResetRichEditorPlaceholder(ArkUINodeHandle node)
513 {
514 auto* frameNode = reinterpret_cast<FrameNode*>(node);
515 CHECK_NULL_VOID(frameNode);
516 PlaceholderOptions options;
517 auto pipeline = frameNode->GetContextWithCheck();
518 CHECK_NULL_VOID(pipeline);
519 auto textTheme = pipeline->GetTheme<TextTheme>();
520 CHECK_NULL_VOID(textTheme);
521 TextStyle textStyle = textTheme ? textTheme->GetTextStyle() : TextStyle();
522 options.value = u"";
523 options.fontSize = textStyle.GetFontSize();
524 options.fontFamilies = textStyle.GetFontFamilies();
525 options.fontWeight = textStyle.GetFontWeight();
526 options.fontStyle = textStyle.GetFontStyle();
527 Color fontColor;
528 auto richEditorTheme = pipeline->GetTheme<NG::RichEditorTheme>();
529 options.fontColor = richEditorTheme ? richEditorTheme->GetPlaceholderColor() : fontColor;
530 RichEditorModelNG::SetPlaceholder(frameNode, options);
531 }
532
SetRichEditorAboutToDelete(ArkUINodeHandle node,void * callback)533 void SetRichEditorAboutToDelete(ArkUINodeHandle node, void* callback)
534 {
535 auto* frameNode = reinterpret_cast<FrameNode*>(node);
536 CHECK_NULL_VOID(frameNode);
537 auto aboutToDelete = reinterpret_cast<std::function<bool(const RichEditorDeleteValue&)>*>(callback);
538 RichEditorModelNG::SetAboutToDelete(frameNode, std::move(*aboutToDelete));
539 }
540
ResetRichEditorAboutToDelete(ArkUINodeHandle node)541 void ResetRichEditorAboutToDelete(ArkUINodeHandle node)
542 {
543 auto* frameNode = reinterpret_cast<FrameNode*>(node);
544 CHECK_NULL_VOID(frameNode);
545 RichEditorModelNG::SetAboutToDelete(frameNode, nullptr);
546 }
547
SetRichEditorBarState(ArkUINodeHandle node,ArkUI_Uint32 barStateValue)548 void SetRichEditorBarState(ArkUINodeHandle node, ArkUI_Uint32 barStateValue)
549 {
550 auto *frameNode = reinterpret_cast<FrameNode*>(node);
551 CHECK_NULL_VOID(frameNode);
552 DisplayMode displayMode = static_cast<DisplayMode>(barStateValue);
553 RichEditorModelNG::SetBarState(frameNode, displayMode);
554 }
555
ResetRichEditorBarState(ArkUINodeHandle node)556 void ResetRichEditorBarState(ArkUINodeHandle node)
557 {
558 auto *frameNode = reinterpret_cast<FrameNode *>(node);
559 CHECK_NULL_VOID(frameNode);
560 RichEditorModelNG::SetBarState(frameNode, DEFAULT_BAR_STATE_VALUE);
561 }
562
SetRichEditorMaxLength(ArkUINodeHandle node,ArkUI_Uint32 value)563 void SetRichEditorMaxLength(ArkUINodeHandle node, ArkUI_Uint32 value)
564 {
565 auto *frameNode = reinterpret_cast<FrameNode*>(node);
566 CHECK_NULL_VOID(frameNode);
567 RichEditorModelNG::SetMaxLength(frameNode, value);
568 }
569
ResetRichEditorMaxLength(ArkUINodeHandle node)570 void ResetRichEditorMaxLength(ArkUINodeHandle node)
571 {
572 auto *frameNode = reinterpret_cast<FrameNode *>(node);
573 CHECK_NULL_VOID(frameNode);
574 RichEditorModelNG::SetMaxLength(frameNode, INT_MAX);
575 }
576
SetRichEditorMaxLines(ArkUINodeHandle node,ArkUI_Uint32 maxLine)577 void SetRichEditorMaxLines(ArkUINodeHandle node, ArkUI_Uint32 maxLine)
578 {
579 auto *frameNode = reinterpret_cast<FrameNode *>(node);
580 CHECK_NULL_VOID(frameNode);
581 if (maxLine <= 0) {
582 RichEditorModelNG::SetMaxLines(frameNode, INT_MAX);
583 return;
584 }
585 RichEditorModelNG::SetMaxLines(frameNode, maxLine);
586 }
587
ResetRichEditorMaxLines(ArkUINodeHandle node)588 void ResetRichEditorMaxLines(ArkUINodeHandle node)
589 {
590 auto *frameNode = reinterpret_cast<FrameNode *>(node);
591 CHECK_NULL_VOID(frameNode);
592 RichEditorModelNG::SetMaxLines(frameNode, INT_MAX);
593 }
594
SetRichEditorStopBackPress(ArkUINodeHandle node,ArkUI_Uint32 value)595 void SetRichEditorStopBackPress(ArkUINodeHandle node, ArkUI_Uint32 value)
596 {
597 auto* frameNode = reinterpret_cast<FrameNode*>(node);
598 CHECK_NULL_VOID(frameNode);
599 RichEditorModelNG::SetStopBackPress(frameNode, static_cast<bool>(value));
600 }
601
ResetRichEditorStopBackPress(ArkUINodeHandle node)602 void ResetRichEditorStopBackPress(ArkUINodeHandle node)
603 {
604 auto* frameNode = reinterpret_cast<FrameNode*>(node);
605 CHECK_NULL_VOID(frameNode);
606 RichEditorModelNG::SetStopBackPress(frameNode, true);
607 }
608
SetRichEditorKeyboardAppearance(ArkUINodeHandle node,ArkUI_Uint32 keyboardAppearance)609 void SetRichEditorKeyboardAppearance(ArkUINodeHandle node, ArkUI_Uint32 keyboardAppearance)
610 {
611 auto* frameNode = reinterpret_cast<FrameNode*>(node);
612 CHECK_NULL_VOID(frameNode);
613 auto value = static_cast<KeyboardAppearance>(keyboardAppearance);
614 if (value < KeyboardAppearance::NONE_IMMERSIVE || value > KeyboardAppearance::DARK_IMMERSIVE) {
615 RichEditorModelNG::SetKeyboardAppearance(frameNode, KeyboardAppearance::NONE_IMMERSIVE);
616 return;
617 }
618 RichEditorModelNG::SetKeyboardAppearance(frameNode, value);
619 }
620
ResetRichEditorKeyboardAppearance(ArkUINodeHandle node)621 void ResetRichEditorKeyboardAppearance(ArkUINodeHandle node)
622 {
623 auto* frameNode = reinterpret_cast<FrameNode*>(node);
624 CHECK_NULL_VOID(frameNode);
625 auto value = KeyboardAppearance::NONE_IMMERSIVE;
626 RichEditorModelNG::SetKeyboardAppearance(frameNode, value);
627 }
628
SetRichEditorOnDidIMEInput(ArkUINodeHandle node,void * callback)629 void SetRichEditorOnDidIMEInput(ArkUINodeHandle node, void* callback)
630 {
631 auto* frameNode = reinterpret_cast<FrameNode*>(node);
632 CHECK_NULL_VOID(frameNode);
633 if (callback) {
634 auto OnDidIMEInput = reinterpret_cast<std::function<void(TextRange)>*>(callback);
635 RichEditorModelNG::SetOnDidIMEInput(frameNode, std::move(*OnDidIMEInput));
636 } else {
637 RichEditorModelNG::SetOnDidIMEInput(frameNode, nullptr);
638 }
639 }
640
ResetRichEditorOnDidIMEInput(ArkUINodeHandle node)641 void ResetRichEditorOnDidIMEInput(ArkUINodeHandle node)
642 {
643 auto* frameNode = reinterpret_cast<FrameNode*>(node);
644 CHECK_NULL_VOID(frameNode);
645 RichEditorModelNG::SetOnDidIMEInput(frameNode, nullptr);
646 }
647
SetRichEditorEnableHapticFeedback(ArkUINodeHandle node,ArkUI_Uint32 value)648 void SetRichEditorEnableHapticFeedback(ArkUINodeHandle node, ArkUI_Uint32 value)
649 {
650 auto* frameNode = reinterpret_cast<FrameNode*>(node);
651 CHECK_NULL_VOID(frameNode);
652 RichEditorModelNG::SetEnableHapticFeedback(frameNode, static_cast<bool>(value));
653 }
654
ResetRichEditorEnableHapticFeedback(ArkUINodeHandle node)655 void ResetRichEditorEnableHapticFeedback(ArkUINodeHandle node)
656 {
657 auto* frameNode = reinterpret_cast<FrameNode*>(node);
658 CHECK_NULL_VOID(frameNode);
659 RichEditorModelNG::SetEnableHapticFeedback(frameNode, true);
660 }
661
SetRichEditorEnableAutoSpacing(ArkUINodeHandle node,ArkUI_Bool value)662 void SetRichEditorEnableAutoSpacing(ArkUINodeHandle node, ArkUI_Bool value)
663 {
664 auto *frameNode = reinterpret_cast<FrameNode*>(node);
665 CHECK_NULL_VOID(frameNode);
666 RichEditorModelNG::SetEnableAutoSpacing(frameNode, value);
667 }
668
ResetRichEditorEnableAutoSpacing(ArkUINodeHandle node)669 void ResetRichEditorEnableAutoSpacing(ArkUINodeHandle node)
670 {
671 auto *frameNode = reinterpret_cast<FrameNode *>(node);
672 CHECK_NULL_VOID(frameNode);
673 RichEditorModelNG::SetEnableAutoSpacing(frameNode, false);
674 }
675
SetRichEditorUndoStyle(ArkUINodeHandle node,ArkUI_Int32 undoStyleValue)676 void SetRichEditorUndoStyle(ArkUINodeHandle node, ArkUI_Int32 undoStyleValue)
677 {
678 auto *frameNode = reinterpret_cast<FrameNode *>(node);
679 CHECK_NULL_VOID(frameNode);
680 bool enable = (undoStyleValue == static_cast<int32_t>(UndoStyle::KEEP_STYLE));
681 RichEditorModelNG::SetSupportStyledUndo(frameNode, enable);
682 }
683
ResetRichEditorUndoStyle(ArkUINodeHandle node)684 void ResetRichEditorUndoStyle(ArkUINodeHandle node)
685 {
686 auto *frameNode = reinterpret_cast<FrameNode *>(node);
687 CHECK_NULL_VOID(frameNode);
688 RichEditorModelNG::SetSupportStyledUndo(frameNode, false);
689 }
690 namespace NodeModifier {
GetRichEditorModifier()691 const ArkUIRichEditorModifier* GetRichEditorModifier()
692 {
693 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
694 static const ArkUIRichEditorModifier modifier = {
695 .setRichEditorEnableDataDetector = SetRichEditorDetectEnable,
696 .resetRichEditorEnableDataDetector = ResetRichEditorDetectEnable,
697 .setRichEditorDataDetectorConfigWithEvent = SetRichEditorDataDetectorConfigWithEvent,
698 .resetRichEditorDataDetectorConfigWithEvent = ResetRichEditorDataDetectorConfigWithEvent,
699 .setRichEditorOnIMEInputComplete = SetRichEditorOnIMEInputComplete,
700 .resetRichEditorOnIMEInputComplete = ResetRichEditorOnIMEInputComplete,
701 .setRichEditorCopyOptions = SetRichEditorCopyOptions,
702 .resetRichEditorCopyOptions = ResetRichEditorCopyOptions,
703 .setRichEditorOnSelectionChange = SetRichEditorOnSelectionChange,
704 .resetRichEditorOnSelectionChange = ResetRichEditorOnSelectionChange,
705 .setRichEditorCaretColor = SetRichEditorCaretColor,
706 .resetRichEditorCaretColor = ResetRichEditorCaretColor,
707 .setRichEditorOnSelect = SetRichEditorOnSelect,
708 .resetRichEditorOnSelect = ResetRichEditorOnSelect,
709 .setRichEditorOnSubmit = SetRichEditorOnSubmit,
710 .resetRichEditorOnSubmit = ResetRichEditorOnSubmit,
711 .setRichEditorAboutToIMEInput = SetRichEditorAboutToIMEInput,
712 .resetRichEditorAboutToIMEInput = ResetRichEditorAboutToIMEInput,
713 .setOnReady = SetRichEditorOnReady,
714 .resetOnReady = ResetRichEditorOnReady,
715 .setOnDeleteComplete = SetRichEditorOnDeleteComplete,
716 .resetOnDeleteComplete = ResetRichEditorOnDeleteComplete,
717 .setOnEditingChange = SetRichEditorOnEditingChange,
718 .resetOnEditingChange = ResetRichEditorOnEditingChange,
719 .setRichEditorSelectedBackgroundColor = SetRichEditorSelectedBackgroundColor,
720 .resetRichEditorSelectedBackgroundColor = ResetRichEditorSelectedBackgroundColor,
721 .setRichEditorOnPaste = SetRichEditorOnPaste,
722 .resetRichEditorOnPaste = ResetRichEditorOnPaste,
723 .setRichEditorOnCut = SetRichEditorOnCut,
724 .resetRichEditorOnCut = ResetRichEditorOnCut,
725 .setRichEditorOnCopy = SetRichEditorOnCopy,
726 .resetRichEditorOnCopy = ResetRichEditorOnCopy,
727 .setRichEditorEnterKeyType = SetRichEditorEnterKeyType,
728 .resetRichEditorEnterKeyType = ResetRichEditorEnterKeyType,
729 .setRichEditorEnableKeyboardOnFocus = SetRichEditorEnableKeyboardOnFocus,
730 .resetRichEditorEnableKeyboardOnFocus = ResetRichEditorEnableKeyboardOnFocus,
731 .setRichEditorEnablePreviewText = SetRichEditorEnablePreviewText,
732 .resetRichEditorEnablePreviewText = ResetRichEditorEnablePreviewText,
733 .setRichEditorEditMenuOptions = SetRichEditorEditMenuOptions,
734 .resetRichEditorEditMenuOptions = ResetRichEditorEditMenuOptions,
735 .setRichEditorOnWillChange = SetRichEditorOnWillChange,
736 .resetRichEditorOnWillChange = ResetRichEditorOnWillChange,
737 .setRichEditorOnDidChange = SetRichEditorOnDidChange,
738 .resetRichEditorOnDidChange = ResetRichEditorOnDidChange,
739 .setRichEditorPlaceholder = SetRichEditorPlaceholder,
740 .resetRichEditorPlaceholder = ResetRichEditorPlaceholder,
741 .setRichEditorAboutToDelete = SetRichEditorAboutToDelete,
742 .resetRichEditorAboutToDelete = ResetRichEditorAboutToDelete,
743 .setRichEditorBarState = SetRichEditorBarState,
744 .resetRichEditorBarState = ResetRichEditorBarState,
745 .setRichEditorMaxLength = SetRichEditorMaxLength,
746 .resetRichEditorMaxLength = ResetRichEditorMaxLength,
747 .setRichEditorMaxLines = SetRichEditorMaxLines,
748 .resetRichEditorMaxLines = ResetRichEditorMaxLines,
749 .setRichEditorStopBackPress = SetRichEditorStopBackPress,
750 .resetRichEditorStopBackPress = ResetRichEditorStopBackPress,
751 .setRichEditorKeyboardAppearance = SetRichEditorKeyboardAppearance,
752 .resetRichEditorKeyboardAppearance = ResetRichEditorKeyboardAppearance,
753 .setRichEditorOnDidIMEInput = SetRichEditorOnDidIMEInput,
754 .resetRichEditorOnDidIMEInput = ResetRichEditorOnDidIMEInput,
755 .setRichEditorEnableHapticFeedback = SetRichEditorEnableHapticFeedback,
756 .resetRichEditorEnableHapticFeedback = ResetRichEditorEnableHapticFeedback,
757 .setRichEditorEnableAutoSpacing = SetRichEditorEnableAutoSpacing,
758 .resetRichEditorEnableAutoSpacing = ResetRichEditorEnableAutoSpacing,
759 .setRichEditorUndoStyle = SetRichEditorUndoStyle,
760 .resetRichEditorUndoStyle = ResetRichEditorUndoStyle
761 };
762 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
763 return &modifier;
764 }
765
GetCJUIRichEditorModifier()766 const CJUIRichEditorModifier* GetCJUIRichEditorModifier()
767 {
768 CHECK_INITIALIZED_FIELDS_BEGIN(); // don't move this line
769 static const CJUIRichEditorModifier modifier = {
770 .setRichEditorEnableDataDetector = SetRichEditorDetectEnable,
771 .resetRichEditorEnableDataDetector = ResetRichEditorDetectEnable,
772 .setRichEditorCopyOptions = SetRichEditorCopyOptions,
773 .resetRichEditorCopyOptions = ResetRichEditorCopyOptions,
774 .setRichEditorCaretColor = SetRichEditorCaretColor,
775 .resetRichEditorCaretColor = ResetRichEditorCaretColor,
776 .setOnReady = SetRichEditorOnReady,
777 .resetOnReady = ResetRichEditorOnReady,
778 .setOnDeleteComplete = SetRichEditorOnDeleteComplete,
779 .resetOnDeleteComplete = ResetRichEditorOnDeleteComplete,
780 .setOnEditingChange = SetRichEditorOnEditingChange,
781 .resetOnEditingChange = ResetRichEditorOnEditingChange,
782 .setRichEditorSelectedBackgroundColor = SetRichEditorSelectedBackgroundColor,
783 .resetRichEditorSelectedBackgroundColor = ResetRichEditorSelectedBackgroundColor,
784 .setRichEditorEnterKeyType = SetRichEditorEnterKeyType,
785 .resetRichEditorEnterKeyType = ResetRichEditorEnterKeyType,
786 .setRichEditorBarState = SetRichEditorBarState,
787 .resetRichEditorBarState = ResetRichEditorBarState,
788 };
789 CHECK_INITIALIZED_FIELDS_END(modifier, 0, 0, 0); // don't move this line
790 return &modifier;
791 }
792 }
793 }
794