diff --git a/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/@ohos.arkui.UIContext.ts b/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/@ohos.arkui.UIContext.ts index 9e70117701d647261b9bb0caaa55571d659a1145..80177957a96ba00b5534ea1dd868b8e075a2e39f 100644 --- a/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/@ohos.arkui.UIContext.ts +++ b/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/@ohos.arkui.UIContext.ts @@ -37,6 +37,9 @@ import { mediaquery } from '@ohos/mediaquery' import { AlertDialog, AlertDialogParamWithConfirm, AlertDialogParamWithButtons, AlertDialogParamWithOptions }from "arkui/component/alertDialog" import { ActionSheet, ActionSheetOptions} from "arkui/component/actionSheet" +import {TimePickerDialog, TimePickerDialogOptions} from "arkui/component/timePicker" +import {DatePickerDialog, DatePickerDialogOptions} from "arkui/component/datePicker" +import {TextPickerDialog, TextPickerDialogOptions} from "arkui/component/textPicker" import inspector from "@ohos/arkui/inspector" import router from '@ohos/router' import { ComponentContent } from 'arkui/ComponentContent' @@ -564,6 +567,18 @@ export class UIContext { public showActionSheet(options: ActionSheetOptions): void { throw Error("showActionSheet not implemented in UIContext!") } + + public showTimePickerDialog(options: TimePickerDialogOptions): void { + throw Error("showTimePickerDialog not implemented in UIContext!") + } + + public showDatePickerDialog(options: DatePickerDialogOptions): void { + throw Error("showDatePickerDialog not implemented in UIContext!") + } + + public showTextPickerDialog(options: TextPickerDialogOptions): void { + throw Error("showTextPickerDialog not implemented in UIContext!") + } // @ts-ignore public freezeUINode(id: number, isFrozen: boolean): void { throw Error("freezeUINode not implemented in UIContext!") diff --git a/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/component/textPicker.ts b/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/component/textPicker.ts index e8596d816c1f23f9fed8c9fa969d1219fb28aba5..29a3e99a77299746698a47d08c7a28dfc2c92211 100644 --- a/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/component/textPicker.ts +++ b/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/component/textPicker.ts @@ -45,7 +45,7 @@ export class TextPickerDialog { thisSerializer.writeInt8(options_type as int32) if ((RuntimeType.UNDEFINED) != (options_type)) { const options_value = options! - thisSerializer.writeTextPickerDialogOptions(options_value) + HookWriteTextPickerDialogOptions(thisSerializer, options_value) } const retval = ArkUIGeneratedNativeModule._TextPickerDialog_show(thisSerializer.asBuffer(), thisSerializer.length()) thisSerializer.release() diff --git a/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/handwritten/UIContextImpl.ts b/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/handwritten/UIContextImpl.ts index ed55af6a91d5fc6e5d8e0ab5479935bd65595a47..c65df22c875a7496825e8caad4fe89eaa3c1b9fc 100644 --- a/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/handwritten/UIContextImpl.ts +++ b/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/handwritten/UIContextImpl.ts @@ -34,6 +34,9 @@ import router from '@ohos/router' import { AlertDialog, AlertDialogParamWithConfirm, AlertDialogParamWithButtons, AlertDialogParamWithOptions }from "arkui/component/alertDialog" import { ActionSheet, ActionSheetOptions } from "arkui/component/actionSheet" +import {TimePickerDialog, TimePickerDialogOptions} from "arkui/component/timePicker" +import {DatePickerDialog, DatePickerDialogOptions} from "arkui/component/datePicker" +import {TextPickerDialog, TextPickerDialogOptions} from "arkui/component/textPicker" import inspector from "@ohos/arkui/inspector" import { ComponentContent } from 'arkui/ComponentContent' import overlayManager from '@ohos/overlayManager' @@ -1643,6 +1646,24 @@ export class UIContextImpl extends UIContext { ArkUIAniModule._Common_Restore_InstanceId(); } + public showTimePickerDialog(options: TimePickerDialogOptions): void { + ArkUIAniModule._Common_Sync_InstanceId(this.instanceId_); + TimePickerDialog.show(options); + ArkUIAniModule._Common_Restore_InstanceId(); + } + + public showDatePickerDialog(options: DatePickerDialogOptions): void { + ArkUIAniModule._Common_Sync_InstanceId(this.instanceId_); + DatePickerDialog.show(options); + ArkUIAniModule._Common_Restore_InstanceId(); + } + + public showTextPickerDialog(options: TextPickerDialogOptions): void { + ArkUIAniModule._Common_Sync_InstanceId(this.instanceId_); + TextPickerDialog.show(options); + ArkUIAniModule._Common_Restore_InstanceId(); + } + // @ts-ignore public freezeUINode(id: number, isFrozen: boolean): void { ArkUIAniModule._Common_Sync_InstanceId(this.instanceId_) diff --git a/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/handwritten/component/textPicker.ts b/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/handwritten/component/textPicker.ts index e8076614b0a0a44611d21af2fe595efe6881c4af..d0bd9b90022066427a1851d9e3cae10ee5941d07 100644 --- a/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/handwritten/component/textPicker.ts +++ b/frameworks/bridge/arkts_frontend/koala_projects/arkoala-arkts/arkui-ohos/src/handwritten/component/textPicker.ts @@ -21,6 +21,7 @@ import { Resource } from "global.resource" import { LengthMetrics } from "../Graphics" import { TextPickerSelectedOps } from "./textpickerselectedops" import { TextPickerValueOps } from "./textpickervalueops" +import { Color } from "./enums" class CheckTextPickerOptions { static isArray_String(value: Object | string | number | undefined): boolean { @@ -200,6 +201,395 @@ function hookSetTextPickerOptions(peer: ArkTextPickerPeer, options?: TextPickerO TextPickerOpsHandWritten.hookTextPickerValueImpl(peer, (options!.value as Bindable>)) } } +function HookWriteTextPickerDialogOptions(valueSerializer : Serializer, value: TextPickerDialogOptions): void { + const value_range = value.range + let value_range_type : int32 = RuntimeType.UNDEFINED + value_range_type = runtimeType(value_range) + if (((RuntimeType.OBJECT) == (value_range_type)) && (CheckTextPickerOptions.isArray_String(value_range))) { + valueSerializer.writeInt8(0 as int32) + const value_range_0 = value_range as Array + valueSerializer.writeInt32(value_range_0.length as int32) + for (let i = 0; i < value_range_0.length; i++) { + const value_range_0_element : string = value_range_0[i] + valueSerializer.writeString(value_range_0_element) + } + } + else if (((RuntimeType.OBJECT) == (value_range_type)) && (CheckTextPickerOptions.isArray_Array_String(value_range))) { + valueSerializer.writeInt8(1 as int32) + const value_range_1 = value_range as Array> + valueSerializer.writeInt32(value_range_1.length as int32) + for (let i = 0; i < value_range_1.length; i++) { + const value_range_1_element : Array = value_range_1[i] + valueSerializer.writeInt32(value_range_1_element.length as int32) + for (let i = 0; i < value_range_1_element.length; i++) { + const value_range_1_element_element : string = value_range_1_element[i] + valueSerializer.writeString(value_range_1_element_element) + } + } + } + else if (TypeChecker.isResource(value_range, false, false, false, false, false)) { + valueSerializer.writeInt8(2 as int32) + const value_range_2 = value_range as Resource + valueSerializer.writeResource(value_range_2) + } + else if (((RuntimeType.OBJECT) == (value_range_type)) && (CheckTextPickerOptions.isArray_TextPickerRangeContent(value_range))) { + valueSerializer.writeInt8(3 as int32) + const value_range_3 = value_range as Array + valueSerializer.writeInt32(value_range_3.length as int32) + for (let i = 0; i < value_range_3.length; i++) { + const value_range_3_element : TextPickerRangeContent = value_range_3[i] + valueSerializer.writeTextPickerRangeContent(value_range_3_element) + } + } + else if (((RuntimeType.OBJECT) == (value_range_type)) && (CheckTextPickerOptions.isArray_TextCascadePickerRangeContent(value_range))) { + valueSerializer.writeInt8(4 as int32) + const value_range_4 = value_range as Array + valueSerializer.writeInt32(value_range_4.length as int32) + for (let i = 0; i < value_range_4.length; i++) { + const value_range_4_element : TextCascadePickerRangeContent = value_range_4[i] + valueSerializer.writeTextCascadePickerRangeContent(value_range_4_element) + } + } + const value_value = value.value + let value_value_type : int32 = RuntimeType.UNDEFINED + value_value_type = runtimeType(value_value) + valueSerializer.writeInt8(value_value_type as int32) + if ((RuntimeType.UNDEFINED) != (value_value_type)) { + const value_value_value = value_value! + let value_value_value_type : int32 = RuntimeType.UNDEFINED + value_value_value_type = runtimeType(value_value_value) + if (RuntimeType.STRING == value_value_value_type) { + valueSerializer.writeInt8(0 as int32) + const value_value_value_0 = value_value_value as string + valueSerializer.writeString(value_value_value_0) + } + else if (TypeChecker.isBindableString(value_value) || TypeChecker.isBindableArrayString(value_value)) { + valueSerializer.writeInt8(3 as int32) + } + else if (RuntimeType.OBJECT == value_value_value_type) { + valueSerializer.writeInt8(1 as int32) + const value_value_value_1 = value_value_value as Array + valueSerializer.writeInt32(value_value_value_1.length as int32) + for (let i = 0; i < value_value_value_1.length; i++) { + const value_value_value_1_element : string = value_value_value_1[i] + valueSerializer.writeString(value_value_value_1_element) + } + } + } + const value_selected = value.selected + let value_selected_type : int32 = RuntimeType.UNDEFINED + value_selected_type = runtimeType(value_selected) + valueSerializer.writeInt8(value_selected_type as int32) + if ((RuntimeType.UNDEFINED) != (value_selected_type)) { + const value_selected_value = value_selected! + let value_selected_value_type : int32 = RuntimeType.UNDEFINED + value_selected_value_type = runtimeType(value_selected_value) + if (RuntimeType.NUMBER == value_selected_value_type) { + valueSerializer.writeInt8(0 as int32) + const value_selected_value_0 = value_selected_value as number + valueSerializer.writeNumber(value_selected_value_0) + } + else if (TypeChecker.isBindableNumber(value_value) || TypeChecker.isBindableArrayNumber(value_value)) { + valueSerializer.writeInt8(3 as int32) + } + else if (RuntimeType.OBJECT == value_selected_value_type) { + valueSerializer.writeInt8(1 as int32) + const value_selected_value_1 = value_selected_value as Array + valueSerializer.writeInt32(value_selected_value_1.length as int32) + for (let i = 0; i < value_selected_value_1.length; i++) { + const value_selected_value_1_element : number = value_selected_value_1[i] + valueSerializer.writeNumber(value_selected_value_1_element) + } + } + } + const value_columnWidths = value.columnWidths + let value_columnWidths_type : int32 = RuntimeType.UNDEFINED + value_columnWidths_type = runtimeType(value_columnWidths) + valueSerializer.writeInt8(value_columnWidths_type as int32) + if ((RuntimeType.UNDEFINED) != (value_columnWidths_type)) { + const value_columnWidths_value = value_columnWidths! + valueSerializer.writeInt32(value_columnWidths_value.length as int32) + for (let i = 0; i < value_columnWidths_value.length; i++) { + const value_columnWidths_value_element : LengthMetrics = value_columnWidths_value[i] + valueSerializer.writeLengthMetrics(value_columnWidths_value_element) + } + } + const value_defaultPickerItemHeight = value.defaultPickerItemHeight + let value_defaultPickerItemHeight_type : int32 = RuntimeType.UNDEFINED + value_defaultPickerItemHeight_type = runtimeType(value_defaultPickerItemHeight) + valueSerializer.writeInt8(value_defaultPickerItemHeight_type as int32) + if ((RuntimeType.UNDEFINED) != (value_defaultPickerItemHeight_type)) { + const value_defaultPickerItemHeight_value = value_defaultPickerItemHeight! + let value_defaultPickerItemHeight_value_type : int32 = RuntimeType.UNDEFINED + value_defaultPickerItemHeight_value_type = runtimeType(value_defaultPickerItemHeight_value) + if (RuntimeType.NUMBER == value_defaultPickerItemHeight_value_type) { + valueSerializer.writeInt8(0 as int32) + const value_defaultPickerItemHeight_value_0 = value_defaultPickerItemHeight_value as number + valueSerializer.writeNumber(value_defaultPickerItemHeight_value_0) + } + else if (RuntimeType.STRING == value_defaultPickerItemHeight_value_type) { + valueSerializer.writeInt8(1 as int32) + const value_defaultPickerItemHeight_value_1 = value_defaultPickerItemHeight_value as string + valueSerializer.writeString(value_defaultPickerItemHeight_value_1) + } + } + const value_canLoop = value.canLoop + let value_canLoop_type : int32 = RuntimeType.UNDEFINED + value_canLoop_type = runtimeType(value_canLoop) + valueSerializer.writeInt8(value_canLoop_type as int32) + if ((RuntimeType.UNDEFINED) != (value_canLoop_type)) { + const value_canLoop_value = value_canLoop! + valueSerializer.writeBoolean(value_canLoop_value) + } + const value_disappearTextStyle = value.disappearTextStyle + let value_disappearTextStyle_type : int32 = RuntimeType.UNDEFINED + value_disappearTextStyle_type = runtimeType(value_disappearTextStyle) + valueSerializer.writeInt8(value_disappearTextStyle_type as int32) + if ((RuntimeType.UNDEFINED) != (value_disappearTextStyle_type)) { + const value_disappearTextStyle_value = value_disappearTextStyle! + valueSerializer.writePickerTextStyle(value_disappearTextStyle_value) + } + const value_textStyle = value.textStyle + let value_textStyle_type : int32 = RuntimeType.UNDEFINED + value_textStyle_type = runtimeType(value_textStyle) + valueSerializer.writeInt8(value_textStyle_type as int32) + if ((RuntimeType.UNDEFINED) != (value_textStyle_type)) { + const value_textStyle_value = value_textStyle! + valueSerializer.writePickerTextStyle(value_textStyle_value) + } + const value_acceptButtonStyle = value.acceptButtonStyle + let value_acceptButtonStyle_type : int32 = RuntimeType.UNDEFINED + value_acceptButtonStyle_type = runtimeType(value_acceptButtonStyle) + valueSerializer.writeInt8(value_acceptButtonStyle_type as int32) + if ((RuntimeType.UNDEFINED) != (value_acceptButtonStyle_type)) { + const value_acceptButtonStyle_value = value_acceptButtonStyle! + valueSerializer.writePickerDialogButtonStyle(value_acceptButtonStyle_value) + } + const value_cancelButtonStyle = value.cancelButtonStyle + let value_cancelButtonStyle_type : int32 = RuntimeType.UNDEFINED + value_cancelButtonStyle_type = runtimeType(value_cancelButtonStyle) + valueSerializer.writeInt8(value_cancelButtonStyle_type as int32) + if ((RuntimeType.UNDEFINED) != (value_cancelButtonStyle_type)) { + const value_cancelButtonStyle_value = value_cancelButtonStyle! + valueSerializer.writePickerDialogButtonStyle(value_cancelButtonStyle_value) + } + const value_selectedTextStyle = value.selectedTextStyle + let value_selectedTextStyle_type : int32 = RuntimeType.UNDEFINED + value_selectedTextStyle_type = runtimeType(value_selectedTextStyle) + valueSerializer.writeInt8(value_selectedTextStyle_type as int32) + if ((RuntimeType.UNDEFINED) != (value_selectedTextStyle_type)) { + const value_selectedTextStyle_value = value_selectedTextStyle! + valueSerializer.writePickerTextStyle(value_selectedTextStyle_value) + } + const value_disableTextStyleAnimation = value.disableTextStyleAnimation + let value_disableTextStyleAnimation_type : int32 = RuntimeType.UNDEFINED + value_disableTextStyleAnimation_type = runtimeType(value_disableTextStyleAnimation) + valueSerializer.writeInt8(value_disableTextStyleAnimation_type as int32) + if ((RuntimeType.UNDEFINED) != (value_disableTextStyleAnimation_type)) { + const value_disableTextStyleAnimation_value = value_disableTextStyleAnimation! + valueSerializer.writeBoolean(value_disableTextStyleAnimation_value) + } + const value_defaultTextStyle = value.defaultTextStyle + let value_defaultTextStyle_type : int32 = RuntimeType.UNDEFINED + value_defaultTextStyle_type = runtimeType(value_defaultTextStyle) + valueSerializer.writeInt8(value_defaultTextStyle_type as int32) + if ((RuntimeType.UNDEFINED) != (value_defaultTextStyle_type)) { + const value_defaultTextStyle_value = value_defaultTextStyle! + valueSerializer.writeTextPickerTextStyle(value_defaultTextStyle_value) + } + const value_onAccept = value.onAccept + let value_onAccept_type : int32 = RuntimeType.UNDEFINED + value_onAccept_type = runtimeType(value_onAccept) + valueSerializer.writeInt8(value_onAccept_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onAccept_type)) { + const value_onAccept_value = value_onAccept! + valueSerializer.holdAndWriteCallback(value_onAccept_value) + } + const value_onCancel = value.onCancel + let value_onCancel_type : int32 = RuntimeType.UNDEFINED + value_onCancel_type = runtimeType(value_onCancel) + valueSerializer.writeInt8(value_onCancel_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onCancel_type)) { + const value_onCancel_value = value_onCancel! + valueSerializer.holdAndWriteCallback(value_onCancel_value) + } + const value_onChange = value.onChange + let value_onChange_type : int32 = RuntimeType.UNDEFINED + value_onChange_type = runtimeType(value_onChange) + valueSerializer.writeInt8(value_onChange_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onChange_type)) { + const value_onChange_value = value_onChange! + valueSerializer.holdAndWriteCallback(value_onChange_value) + } + const value_onScrollStop = value.onScrollStop + let value_onScrollStop_type : int32 = RuntimeType.UNDEFINED + value_onScrollStop_type = runtimeType(value_onScrollStop) + valueSerializer.writeInt8(value_onScrollStop_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onScrollStop_type)) { + const value_onScrollStop_value = value_onScrollStop! + valueSerializer.holdAndWriteCallback(value_onScrollStop_value) + } + const value_onEnterSelectedArea = value.onEnterSelectedArea + let value_onEnterSelectedArea_type : int32 = RuntimeType.UNDEFINED + value_onEnterSelectedArea_type = runtimeType(value_onEnterSelectedArea) + valueSerializer.writeInt8(value_onEnterSelectedArea_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onEnterSelectedArea_type)) { + const value_onEnterSelectedArea_value = value_onEnterSelectedArea! + valueSerializer.holdAndWriteCallback(value_onEnterSelectedArea_value) + } + const value_maskRect = value.maskRect + let value_maskRect_type : int32 = RuntimeType.UNDEFINED + value_maskRect_type = runtimeType(value_maskRect) + valueSerializer.writeInt8(value_maskRect_type as int32) + if ((RuntimeType.UNDEFINED) != (value_maskRect_type)) { + const value_maskRect_value = value_maskRect! + valueSerializer.writeRectangle(value_maskRect_value) + } + const value_alignment = value.alignment + let value_alignment_type : int32 = RuntimeType.UNDEFINED + value_alignment_type = runtimeType(value_alignment) + valueSerializer.writeInt8(value_alignment_type as int32) + if ((RuntimeType.UNDEFINED) != (value_alignment_type)) { + const value_alignment_value = (value_alignment as DialogAlignment) + valueSerializer.writeInt32(TypeChecker.DialogAlignment_ToNumeric(value_alignment_value)) + } + const value_offset = value.offset + let value_offset_type : int32 = RuntimeType.UNDEFINED + value_offset_type = runtimeType(value_offset) + valueSerializer.writeInt8(value_offset_type as int32) + if ((RuntimeType.UNDEFINED) != (value_offset_type)) { + const value_offset_value = value_offset! + valueSerializer.writeOffset(value_offset_value) + } + const value_backgroundColor = value.backgroundColor + let value_backgroundColor_type : int32 = RuntimeType.UNDEFINED + value_backgroundColor_type = runtimeType(value_backgroundColor) + valueSerializer.writeInt8(value_backgroundColor_type as int32) + if ((RuntimeType.UNDEFINED) != (value_backgroundColor_type)) { + const value_backgroundColor_value = value_backgroundColor! + let value_backgroundColor_value_type : int32 = RuntimeType.UNDEFINED + value_backgroundColor_value_type = runtimeType(value_backgroundColor_value) + if (TypeChecker.isColor(value_backgroundColor_value)) { + valueSerializer.writeInt8(0 as int32) + const value_backgroundColor_value_0 = value_backgroundColor_value as Color + valueSerializer.writeInt32(TypeChecker.Color_ToNumeric(value_backgroundColor_value_0)) + } + else if (RuntimeType.NUMBER == value_backgroundColor_value_type) { + valueSerializer.writeInt8(1 as int32) + const value_backgroundColor_value_1 = value_backgroundColor_value as number + valueSerializer.writeNumber(value_backgroundColor_value_1) + } + else if (RuntimeType.STRING == value_backgroundColor_value_type) { + valueSerializer.writeInt8(2 as int32) + const value_backgroundColor_value_2 = value_backgroundColor_value as string + valueSerializer.writeString(value_backgroundColor_value_2) + } + else if (RuntimeType.OBJECT == value_backgroundColor_value_type) { + valueSerializer.writeInt8(3 as int32) + const value_backgroundColor_value_3 = value_backgroundColor_value as Resource + valueSerializer.writeResource(value_backgroundColor_value_3) + } + } + const value_backgroundBlurStyle = value.backgroundBlurStyle + let value_backgroundBlurStyle_type : int32 = RuntimeType.UNDEFINED + value_backgroundBlurStyle_type = runtimeType(value_backgroundBlurStyle) + valueSerializer.writeInt8(value_backgroundBlurStyle_type as int32) + if ((RuntimeType.UNDEFINED) != (value_backgroundBlurStyle_type)) { + const value_backgroundBlurStyle_value = (value_backgroundBlurStyle as BlurStyle) + valueSerializer.writeInt32(TypeChecker.BlurStyle_ToNumeric(value_backgroundBlurStyle_value)) + } + const value_backgroundBlurStyleOptions = value.backgroundBlurStyleOptions + let value_backgroundBlurStyleOptions_type : int32 = RuntimeType.UNDEFINED + value_backgroundBlurStyleOptions_type = runtimeType(value_backgroundBlurStyleOptions) + valueSerializer.writeInt8(value_backgroundBlurStyleOptions_type as int32) + if ((RuntimeType.UNDEFINED) != (value_backgroundBlurStyleOptions_type)) { + const value_backgroundBlurStyleOptions_value = value_backgroundBlurStyleOptions! + valueSerializer.writeBackgroundBlurStyleOptions(value_backgroundBlurStyleOptions_value) + } + const value_backgroundEffect = value.backgroundEffect + let value_backgroundEffect_type : int32 = RuntimeType.UNDEFINED + value_backgroundEffect_type = runtimeType(value_backgroundEffect) + valueSerializer.writeInt8(value_backgroundEffect_type as int32) + if ((RuntimeType.UNDEFINED) != (value_backgroundEffect_type)) { + const value_backgroundEffect_value = value_backgroundEffect! + valueSerializer.writeBackgroundEffectOptions(value_backgroundEffect_value) + } + const value_onDidAppear = value.onDidAppear + let value_onDidAppear_type : int32 = RuntimeType.UNDEFINED + value_onDidAppear_type = runtimeType(value_onDidAppear) + valueSerializer.writeInt8(value_onDidAppear_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onDidAppear_type)) { + const value_onDidAppear_value = value_onDidAppear! + valueSerializer.holdAndWriteCallback(value_onDidAppear_value) + } + const value_onDidDisappear = value.onDidDisappear + let value_onDidDisappear_type : int32 = RuntimeType.UNDEFINED + value_onDidDisappear_type = runtimeType(value_onDidDisappear) + valueSerializer.writeInt8(value_onDidDisappear_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onDidDisappear_type)) { + const value_onDidDisappear_value = value_onDidDisappear! + valueSerializer.holdAndWriteCallback(value_onDidDisappear_value) + } + const value_onWillAppear = value.onWillAppear + let value_onWillAppear_type : int32 = RuntimeType.UNDEFINED + value_onWillAppear_type = runtimeType(value_onWillAppear) + valueSerializer.writeInt8(value_onWillAppear_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onWillAppear_type)) { + const value_onWillAppear_value = value_onWillAppear! + valueSerializer.holdAndWriteCallback(value_onWillAppear_value) + } + const value_onWillDisappear = value.onWillDisappear + let value_onWillDisappear_type : int32 = RuntimeType.UNDEFINED + value_onWillDisappear_type = runtimeType(value_onWillDisappear) + valueSerializer.writeInt8(value_onWillDisappear_type as int32) + if ((RuntimeType.UNDEFINED) != (value_onWillDisappear_type)) { + const value_onWillDisappear_value = value_onWillDisappear! + valueSerializer.holdAndWriteCallback(value_onWillDisappear_value) + } + const value_shadow = value.shadow + let value_shadow_type : int32 = RuntimeType.UNDEFINED + value_shadow_type = runtimeType(value_shadow) + valueSerializer.writeInt8(value_shadow_type as int32) + if ((RuntimeType.UNDEFINED) != (value_shadow_type)) { + const value_shadow_value = value_shadow! + let value_shadow_value_type : int32 = RuntimeType.UNDEFINED + value_shadow_value_type = runtimeType(value_shadow_value) + if (TypeChecker.isShadowOptions(value_shadow_value_type, false, false, false, false, false, false)) { + valueSerializer.writeInt8(0 as int32) + const value_shadow_value_0 = value_shadow_value as ShadowOptions + valueSerializer.writeShadowOptions(value_shadow_value_0) + } + else if (TypeChecker.isShadowStyle(value_shadow_value)) { + valueSerializer.writeInt8(1 as int32) + const value_shadow_value_1 = value_shadow_value as ShadowStyle + valueSerializer.writeInt32(TypeChecker.ShadowStyle_ToNumeric(value_shadow_value_1)) + } + } + const value_enableHoverMode = value.enableHoverMode + let value_enableHoverMode_type : int32 = RuntimeType.UNDEFINED + value_enableHoverMode_type = runtimeType(value_enableHoverMode) + valueSerializer.writeInt8(value_enableHoverMode_type as int32) + if ((RuntimeType.UNDEFINED) != (value_enableHoverMode_type)) { + const value_enableHoverMode_value = value_enableHoverMode! + valueSerializer.writeBoolean(value_enableHoverMode_value) + } + const value_hoverModeArea = value.hoverModeArea + let value_hoverModeArea_type : int32 = RuntimeType.UNDEFINED + value_hoverModeArea_type = runtimeType(value_hoverModeArea) + valueSerializer.writeInt8(value_hoverModeArea_type as int32) + if ((RuntimeType.UNDEFINED) != (value_hoverModeArea_type)) { + const value_hoverModeArea_value = (value_hoverModeArea as HoverModeAreaType) + valueSerializer.writeInt32(TypeChecker.HoverModeAreaType_ToNumeric(value_hoverModeArea_value)) + } + const value_enableHapticFeedback = value.enableHapticFeedback + let value_enableHapticFeedback_type : int32 = RuntimeType.UNDEFINED + value_enableHapticFeedback_type = runtimeType(value_enableHapticFeedback) + valueSerializer.writeInt8(value_enableHapticFeedback_type as int32) + if ((RuntimeType.UNDEFINED) != (value_enableHapticFeedback_type)) { + const value_enableHapticFeedback_value = value_enableHapticFeedback! + valueSerializer.writeBoolean(value_enableHapticFeedback_value) + } +} class TextPickerOpsHandWritten { static hookTextPickerSelectedImpl(peer: ArkTextPickerPeer, value: Bindable>) { diff --git a/frameworks/core/components_ng/pattern/picker/picker_model.h b/frameworks/core/components_ng/pattern/picker/picker_model.h index 6a1bf46d409147ff78ee923e29c987bd1e2c4638..1fa953b2473005b54af7524d699b9d1a2dd62a08 100644 --- a/frameworks/core/components_ng/pattern/picker/picker_model.h +++ b/frameworks/core/components_ng/pattern/picker/picker_model.h @@ -56,6 +56,14 @@ struct PickerDialogEvent { std::function onWillAppear; std::function onWillDisappear; }; +struct PickerDialogInteractiveEvent { + std::function cancelEvent; + std::function acceptEvent; + std::function changeEvent; + std::function dateAcceptEvent; + std::function dateChangeEvent; +}; + class ACE_FORCE_EXPORT DatePickerModel { public: static DatePickerModel* GetInstance(); diff --git a/frameworks/core/components_ng/pattern/text_picker/textpicker_event_hub.h b/frameworks/core/components_ng/pattern/text_picker/textpicker_event_hub.h index 1d486cb09b9ff5ad2d66cde579042151e6b1a238..35c019a82d9246db4316ba0616e809a3af585ae8 100644 --- a/frameworks/core/components_ng/pattern/text_picker/textpicker_event_hub.h +++ b/frameworks/core/components_ng/pattern/text_picker/textpicker_event_hub.h @@ -28,6 +28,14 @@ using DialogTextEvent = std::function; using DialogCancelEvent = std::function; using DialogGestureEvent = std::function; +struct TextPickerInteractiveEvent { + DialogCancelEvent cancelEvent; + DialogTextEvent acceptEvent; + DialogTextEvent changeEvent; + DialogTextEvent scrollStopEvent; + DialogTextEvent enterSelectedAreaEvent; +}; + class TextPickerEventHub : public EventHub { DECLARE_ACE_TYPE(TextPickerEventHub, EventHub) diff --git a/frameworks/core/interfaces/native/implementation/calendar_picker_dialog_accessor.cpp b/frameworks/core/interfaces/native/implementation/calendar_picker_dialog_accessor.cpp index 0f62606751910a616e546258dca553f98660dbfe..29cf55704dd43e8aff06c31b1948c6534a1929b8 100644 --- a/frameworks/core/interfaces/native/implementation/calendar_picker_dialog_accessor.cpp +++ b/frameworks/core/interfaces/native/implementation/calendar_picker_dialog_accessor.cpp @@ -85,11 +85,15 @@ std::vector BuildButtonInfos(const Ark_CalendarDialogOptions options std::vector buttonInfos; auto acceptButtonInfo = Converter::OptConvert(options.acceptButtonStyle); if (acceptButtonInfo.has_value()) { - buttonInfos.push_back(acceptButtonInfo.value()); + buttonInfos.emplace_back(acceptButtonInfo.value()); + buttonInfos[0].isAcceptButton = true; + } else { + ButtonInfo buttonInfo; + buttonInfos.emplace_back(buttonInfo); } auto cancelButtonInfo = Converter::OptConvert(options.cancelButtonStyle); if (cancelButtonInfo.has_value()) { - buttonInfos.push_back(cancelButtonInfo.value()); + buttonInfos.emplace_back(cancelButtonInfo.value()); } return buttonInfos; } diff --git a/frameworks/core/interfaces/native/implementation/date_picker_dialog_accessor.cpp b/frameworks/core/interfaces/native/implementation/date_picker_dialog_accessor.cpp index dbdbd421806f8cbbe2e775373962e4b01a2fa02e..971c41c8e9f0e37970da19cc098655090bf6491e 100644 --- a/frameworks/core/interfaces/native/implementation/date_picker_dialog_accessor.cpp +++ b/frameworks/core/interfaces/native/implementation/date_picker_dialog_accessor.cpp @@ -13,6 +13,8 @@ * limitations under the License. */ +#include +#include #include "core/components_ng/base/frame_node.h" #include "core/interfaces/native/utility/converter.h" #include "core/interfaces/native/utility/reverse_converter.h" @@ -23,86 +25,89 @@ namespace OHOS::Ace::NG::GeneratedModifier { namespace DatePickerDialogAccessor { -void BuildDialogPropertiesCallbacks(const Ark_DatePickerDialogOptions options, DialogProperties& dialogProps) + +void ParseDate(const Ark_DatePickerDialogOptions& options, PickerDialogInfo& dialogInfo) { - auto didAppearCallbackOpt = Converter::OptConvert(options.onDidAppear); - if (didAppearCallbackOpt) { - auto onDidAppear = [arkCallback = CallbackHelper(*didAppearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onDidAppear = onDidAppear; + auto pipeline = PipelineBase::GetCurrentContextSafelyWithCheck(); + CHECK_NULL_VOID(pipeline); + auto pickerTheme = pipeline->GetTheme(); + CHECK_NULL_VOID(pickerTheme); + // parse start and end date + auto parseStartDate = pickerTheme->GetDefaultStartDate(); + auto parseEndDate = pickerTheme->GetDefaultEndDate(); + auto start = Converter::OptConvert(options.start); + if (start) { + dialogInfo.isStartDate = true; + parseStartDate = start.value(); } - auto didDisappearCallbackOpt = Converter::OptConvert(options.onDidDisappear); - if (didDisappearCallbackOpt) { - auto onDidDisappear = [arkCallback = CallbackHelper(*didDisappearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onDidDisappear = onDidDisappear; + auto end = Converter::OptConvert(options.end); + if (end) { + dialogInfo.isEndDate = true; + parseEndDate = end.value(); } - auto willAppearCallbackOpt = Converter::OptConvert(options.onWillAppear); - if (willAppearCallbackOpt) { - auto onWillAppear = [arkCallback = CallbackHelper(*willAppearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onWillAppear = onWillAppear; + if (parseStartDate.GetYear() <= 0) { + parseStartDate = pickerTheme->GetDefaultStartDate(); } - auto willDisappearCallbackOpt = Converter::OptConvert(options.onWillDisappear); - if (willDisappearCallbackOpt) { - auto onWillDisappear = [arkCallback = CallbackHelper(*willDisappearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onWillDisappear = onWillDisappear; + if (parseEndDate.GetYear() <= 0) { + parseEndDate = pickerTheme->GetDefaultEndDate(); + } + if (parseStartDate.ToDays() > parseEndDate.ToDays()) { + parseStartDate = pickerTheme->GetDefaultStartDate(); + parseEndDate = pickerTheme->GetDefaultEndDate(); + } + dialogInfo.parseStartDate = parseStartDate; + dialogInfo.parseEndDate = parseEndDate; + dialogInfo.parseSelectedDate = PickerDate(); + auto selectedDate = Converter::OptConvert(options.selected); + if (selectedDate) { + dialogInfo.isSelectedDate = true; + dialogInfo.parseSelectedDate = selectedDate.value(); + } + dialogInfo.pickerTime = PickerTime(); + auto selectedTime = Converter::OptConvert(options.selected); + if (selectedTime) { + dialogInfo.pickerTime = selectedTime.value(); } } -DialogProperties BuildDialogProperties(const Ark_DatePickerDialogOptions options) -{ - DialogProperties dialogProps; - auto pipeline = PipelineBase::GetCurrentContextSafelyWithCheck(); - CHECK_NULL_RETURN(pipeline, dialogProps); - auto dialogTheme = pipeline->GetTheme(); - CHECK_NULL_RETURN(dialogTheme, dialogProps); - dialogProps.alignment = dialogTheme->GetAlignment(); - if (dialogProps.alignment == DialogAlignment::BOTTOM) { - dialogProps.offset = DimensionOffset(Offset(0, -dialogTheme->GetMarginBottom().ConvertToPx())); +PickerDialogInfo BuildDatePickerDialogInfo(const Ark_DatePickerDialogOptions& options) +{ + PickerDialogInfo dialogInfo; + ParseDate(options, dialogInfo); + auto alignment = Converter::OptConvert(options.alignment); + if (alignment) { + dialogInfo.alignment = alignment.value(); } - dialogProps.customStyle = false; - dialogProps.backgroundBlurStyle = static_cast(Converter::OptConvert( + auto offset = Converter::OptConvert(options.offset); + if (offset) { + dialogInfo.offset = offset.value(); + } + dialogInfo.backgroundBlurStyle = static_cast(Converter::OptConvert( options.backgroundBlurStyle).value_or(BlurStyle::COMPONENT_REGULAR)); - dialogProps.backgroundColor = Converter::OptConvert(options.backgroundColor); - dialogProps.shadow = Converter::OptConvert(options.shadow); - dialogProps.maskRect = Converter::OptConvert(options.maskRect); + dialogInfo.blurStyleOption = Converter::OptConvert(options.backgroundBlurStyleOptions); + dialogInfo.effectOption = Converter::OptConvert(options.backgroundEffect); + dialogInfo.backgroundColor = Converter::OptConvert(options.backgroundColor); + dialogInfo.shadow = Converter::OptConvert(options.shadow); + dialogInfo.maskRect = Converter::OptConvert(options.maskRect); auto enableHoverMode = Converter::OptConvert(options.enableHoverMode); if (enableHoverMode.has_value()) { - dialogProps.enableHoverMode = enableHoverMode.value(); + dialogInfo.enableHoverMode = enableHoverMode.value(); } - dialogProps.hoverModeArea = Converter::OptConvert(options.hoverModeArea); - BuildDialogPropertiesCallbacks(options, dialogProps); - return dialogProps; + dialogInfo.hoverModeArea = Converter::OptConvert(options.hoverModeArea); + return dialogInfo; } -DatePickerSettingData BuildSettingData(const Ark_DatePickerDialogOptions options) + +DatePickerSettingData BuildSettingData(const Ark_DatePickerDialogOptions& options) { - DatePickerSettingData settingData; + DatePickerSettingData settingData = { .isLunar = false, .lunarswitch = false, .showTime = false, + .isEnableHapticFeedback = true, .useMilitary = false, .mode = DatePickerMode::DATE }; + settingData.isLunar = Converter::OptConvert(options.lunar).value_or(settingData.isLunar); settingData.lunarswitch = Converter::OptConvert(options.lunarSwitch).value_or(settingData.lunarswitch); - auto checkboxSettingData = Converter::OptConvert(options.lunarSwitchStyle); - if (checkboxSettingData) { - settingData.checkboxSettingData = *checkboxSettingData; - } - auto start = Converter::OptConvert(options.start); - if (start) { - settingData.datePickerProperty["start"] = *start; - } - auto end = Converter::OptConvert(options.end); - if (end) { - settingData.datePickerProperty["end"] = *end; - } - auto selectedDate = Converter::OptConvert(options.selected); - auto selectedTime = Converter::OptConvert(options.selected); - if (selectedDate) { - settingData.datePickerProperty["selected"] = *selectedDate; - if (selectedTime) { - settingData.timePickerProperty["selected"] = *selectedTime; + if (settingData.lunarswitch) { + auto checkboxSettingData = Converter::OptConvert(options.lunarSwitchStyle); + if (checkboxSettingData) { + settingData.checkboxSettingData = *checkboxSettingData; } } settingData.showTime = Converter::OptConvert(options.showTime).value_or(settingData.showTime); @@ -123,60 +128,135 @@ DatePickerSettingData BuildSettingData(const Ark_DatePickerDialogOptions options if (selectedTextStyle) { settingData.properties.selectedTextStyle_ = *selectedTextStyle; } + auto pickerMode = Converter::OptConvert(options.mode); + if (pickerMode) { + settingData.mode = *pickerMode; + } + auto enableHapticFeedback = Converter::OptConvert(options.enableHapticFeedback); + if (enableHapticFeedback) { + settingData.isEnableHapticFeedback = enableHapticFeedback.value(); + } return settingData; } -std::vector BuildButtonInfos(const Ark_DatePickerDialogOptions options) + +PickerDialogEvent BuildPickerDialogEvents(const Ark_DatePickerDialogOptions& options) { - std::vector buttonInfos; - auto acceptButtonInfo = Converter::OptConvert(options.acceptButtonStyle); - if (acceptButtonInfo.has_value()) { - buttonInfos.push_back(acceptButtonInfo.value()); + PickerDialogEvent dialogEvent; + auto didAppearCallbackOpt = Converter::OptConvert(options.onDidAppear); + if (didAppearCallbackOpt) { + auto onDidAppear = [arkCallback = CallbackHelper(*didAppearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onDidAppear = onDidAppear; } - auto cancelButtonInfo = Converter::OptConvert(options.cancelButtonStyle); - if (cancelButtonInfo.has_value()) { - buttonInfos.push_back(cancelButtonInfo.value()); + auto didDisappearCallbackOpt = Converter::OptConvert(options.onDidDisappear); + if (didDisappearCallbackOpt) { + auto onDidDisappear = [arkCallback = CallbackHelper(*didDisappearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onDidDisappear = onDidDisappear; } - return buttonInfos; + auto willAppearCallbackOpt = Converter::OptConvert(options.onWillAppear); + if (willAppearCallbackOpt) { + auto onWillAppear = [arkCallback = CallbackHelper(*willAppearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onWillAppear = onWillAppear; + } + auto willDisappearCallbackOpt = Converter::OptConvert(options.onWillDisappear); + if (willDisappearCallbackOpt) { + auto onWillDisappear = [arkCallback = CallbackHelper(*willDisappearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onWillDisappear = onWillDisappear; + } + return dialogEvent; } -std::map CreateDialogEvent(const Ark_DatePickerDialogOptions options) +std::string ConvertDateString(const std::string& info) { - std::map dialogEvent; - auto acceptCallbackOpt = Converter::OptConvert(options.onAccept); - if (acceptCallbackOpt) { - auto onAcceptFunc = [arkCallback = CallbackHelper(*acceptCallbackOpt)](const std::string& info) -> void { - auto result = Converter::ArkValue(info); - arkCallback.Invoke(result); - }; - dialogEvent["acceptId"] = onAcceptFunc; + std::unique_ptr datePtr = JsonUtil::ParseJsonString(info); + CHECK_NULL_RETURN(datePtr, info); + int32_t year = 0; + auto yearPtr = datePtr->GetValue("year"); + if (yearPtr && yearPtr->IsNumber()) { + year = yearPtr->GetInt(); } - auto changeCallbackOpt = Converter::OptConvert(options.onChange); - if (changeCallbackOpt) { - auto onChangeFunc = [arkCallback = CallbackHelper(*changeCallbackOpt)](const std::string& info) -> void { - auto result = Converter::ArkValue(info); - arkCallback.Invoke(result); + int32_t month = 0; + auto monthPtr = datePtr->GetValue("month"); + if (monthPtr && monthPtr->IsNumber()) { + // 0-11 means 1 to 12 months + month = monthPtr->GetInt() + 1; + } + int32_t day = 0; + auto dayPtr = datePtr->GetValue("day"); + if (dayPtr && dayPtr->IsNumber()) { + day = dayPtr->GetInt(); + } + int32_t hour = 0; + auto hourPtr = datePtr->GetValue("hour"); + if (hourPtr && hourPtr->IsNumber()) { + hour = hourPtr->GetInt(); + } + int32_t minute = 0; + auto minutePtr = datePtr->GetValue("minute"); + if (minutePtr && minutePtr->IsNumber()) { + minute = minutePtr->GetInt(); + } + PickerDateTime dateTime; + dateTime.SetDate(PickerDate(year, month, day)); + dateTime.SetTime(PickerTime(hour, minute, 0)); + return dateTime.ToString(true); +} + +PickerDialogInteractiveEvent BuildSelectInteractiveEvents(const Ark_DatePickerDialogOptions& arkOptions) +{ + PickerDialogInteractiveEvent events; + // onCancel + auto cancelCallbackOpt = Converter::OptConvert(arkOptions.onCancel); + if (cancelCallbackOpt) { + events.cancelEvent = [arkCallback = CallbackHelper(*cancelCallbackOpt)]() -> void { + arkCallback.Invoke(); }; - dialogEvent["changeId"] = onChangeFunc; } - auto dateAcceptCallbackOpt = Converter::OptConvert(options.onDateAccept); + // onDateAccept + auto dateAcceptCallbackOpt = Converter::OptConvert(arkOptions.onDateAccept); if (dateAcceptCallbackOpt) { - auto onDateAcceptFunc = [arkCallback = CallbackHelper(*dateAcceptCallbackOpt)]( - const std::string& info) -> void { - auto result = Converter::ArkValue(info); + events.dateAcceptEvent = + [arkCallback = CallbackHelper(*dateAcceptCallbackOpt)](const std::string& info) -> void { + auto result = Converter::ArkValue(ConvertDateString(info)); arkCallback.Invoke(result); }; - dialogEvent["dateAcceptId"] = onDateAcceptFunc; } - auto dateChangeCallbackOpt = Converter::OptConvert(options.onDateChange); + // onDateChange + auto dateChangeCallbackOpt = Converter::OptConvert(arkOptions.onDateChange); if (dateChangeCallbackOpt) { - auto onDateChangeFunc = [arkCallback = CallbackHelper(*dateChangeCallbackOpt)]( - const std::string& info) -> void { - auto result = Converter::ArkValue(info); + events.dateChangeEvent = + [arkCallback = CallbackHelper(*dateChangeCallbackOpt)](const std::string& info) -> void { + auto result = Converter::ArkValue(ConvertDateString(info)); arkCallback.Invoke(result); }; - dialogEvent["dateChangeId"] = onDateChangeFunc; } - return dialogEvent; + return events; +} + +std::vector BuildButtonInfos(const Ark_DatePickerDialogOptions& options) +{ + std::vector buttonInfos; + auto acceptButtonInfo = Converter::OptConvert(options.acceptButtonStyle); + if (acceptButtonInfo.has_value()) { + buttonInfos.emplace_back(acceptButtonInfo.value()); + buttonInfos[0].isAcceptButton = true; + } else { + ButtonInfo buttonInfo; + buttonInfos.emplace_back(buttonInfo); + } + auto cancelButtonInfo = Converter::OptConvert(options.cancelButtonStyle); + if (cancelButtonInfo.has_value()) { + buttonInfos.emplace_back(cancelButtonInfo.value()); + } + return buttonInfos; } + void ShowImpl(const Opt_DatePickerDialogOptions* options) { CHECK_NULL_VOID(options); @@ -184,21 +264,19 @@ void ShowImpl(const Opt_DatePickerDialogOptions* options) if (!arkOptionsOpt.has_value()) { return; } Ark_DatePickerDialogOptions arkOptions = *arkOptionsOpt; - DialogProperties dialogProps = BuildDialogProperties(arkOptions); + PickerDialogInfo dialogInfo = BuildDatePickerDialogInfo(arkOptions); DatePickerSettingData settingData = BuildSettingData(arkOptions); + PickerDialogInteractiveEvent interEvents = BuildSelectInteractiveEvents(arkOptions); + DatePickerType pickType = DATE; + PickerDialogEvent datePickerDialogEvent = BuildPickerDialogEvents(arkOptions); std::vector buttonInfos = BuildButtonInfos(arkOptions); - std::map dialogEvent = CreateDialogEvent(arkOptions); - std::map dialogCancelEvent; - auto cancelCallbackOpt = Converter::OptConvert(arkOptions.onCancel); - if (cancelCallbackOpt) { - auto onCancelFunc = [arkCallback = CallbackHelper(*cancelCallbackOpt)](const GestureEvent& info) -> void { - arkCallback.Invoke(); - }; - dialogCancelEvent["cancelId"] = onCancelFunc; - } - DatePickerDialogView::Show(dialogProps, settingData, buttonInfos, dialogEvent, dialogCancelEvent); + DatePickerDialogModel::GetInstance()->SetDatePickerDialogShow(dialogInfo, settingData, + std::move(interEvents.cancelEvent), std::move(interEvents.acceptEvent), std::move(interEvents.changeEvent), + std::move(interEvents.dateAcceptEvent), std::move(interEvents.dateChangeEvent), + pickType, datePickerDialogEvent, buttonInfos); } } // DatePickerDialogAccessor + const GENERATED_ArkUIDatePickerDialogAccessor* GetDatePickerDialogAccessor() { static const GENERATED_ArkUIDatePickerDialogAccessor DatePickerDialogAccessorImpl { diff --git a/frameworks/core/interfaces/native/implementation/text_picker_dialog_accessor.cpp b/frameworks/core/interfaces/native/implementation/text_picker_dialog_accessor.cpp index 1f59932a3af01d270775ade36dbd3f5302a39196..94f904a37ab5c3158bd6e5ac13533fb4893f42af 100644 --- a/frameworks/core/interfaces/native/implementation/text_picker_dialog_accessor.cpp +++ b/frameworks/core/interfaces/native/implementation/text_picker_dialog_accessor.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include #include "core/components_ng/base/frame_node.h" #include "core/interfaces/native/utility/converter.h" #include "core/interfaces/native/utility/reverse_converter.h" @@ -20,199 +21,149 @@ #include "test/unittest/capi/stubs/mock_text_picker_dialog_view.h" #else #include "core/components_ng/pattern/text_picker/textpicker_dialog_view.h" +#include "core/components_ng/pattern/text_picker/textpicker_model.h" #endif #include "core/interfaces/native/utility/callback_helper.h" #include "arkoala_api_generated.h" +#include "text_picker_modifier.h" namespace OHOS::Ace::NG::GeneratedModifier { namespace TextPickerDialogAccessor { -void BuildDialogPropertiesCallbacks(const Ark_TextPickerDialogOptions options, DialogProperties& dialogProps) -{ - auto didAppearCallbackOpt = Converter::OptConvert(options.onDidAppear); - if (didAppearCallbackOpt) { - auto onDidAppear = [arkCallback = CallbackHelper(*didAppearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onDidAppear = onDidAppear; - } - auto didDisappearCallbackOpt = Converter::OptConvert(options.onDidDisappear); - if (didDisappearCallbackOpt) { - auto onDidDisappear = [arkCallback = CallbackHelper(*didDisappearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onDidDisappear = onDidDisappear; - } - auto willAppearCallbackOpt = Converter::OptConvert(options.onWillAppear); - if (willAppearCallbackOpt) { - auto onWillAppear = [arkCallback = CallbackHelper(*willAppearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onWillAppear = onWillAppear; - } - auto willDisappearCallbackOpt = Converter::OptConvert(options.onWillDisappear); - if (willDisappearCallbackOpt) { - auto onWillDisappear = [arkCallback = CallbackHelper(*willDisappearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onWillDisappear = onWillDisappear; - } -} -DialogProperties BuildDialogProperties(const Ark_TextPickerDialogOptions options) -{ - DialogProperties dialogProps; - auto alignment = Converter::OptConvert(options.alignment); - if (alignment) { - dialogProps.alignment = alignment.value(); - } - auto offset = Converter::OptConvert(options.offset); - if (offset) { - dialogProps.offset = offset.value(); - } - dialogProps.backgroundBlurStyle = static_cast(Converter::OptConvert( - options.backgroundBlurStyle).value_or(BlurStyle::COMPONENT_REGULAR)); - dialogProps.backgroundColor = Converter::OptConvert(options.backgroundColor); - dialogProps.shadow = Converter::OptConvert(options.shadow); - auto enableHoverMode = Converter::OptConvert(options.enableHoverMode); - if (enableHoverMode) { - dialogProps.enableHoverMode = enableHoverMode.value(); - } - auto hoverModeArea = Converter::OptConvert(options.hoverModeArea); - if (hoverModeArea) { - dialogProps.hoverModeArea = hoverModeArea.value(); - } - dialogProps.maskRect = Converter::OptConvert(options.maskRect); - BuildDialogPropertiesCallbacks(options, dialogProps); - return dialogProps; -} -void BuildCascadeSelection(std::vector& opts, - TextPickerSettingData& settingData, std::vector selectedIndexes, - std::vector selectedValues) + +uint32_t CalculateKind(bool fromRangeContent, const std::vector& range) { - if (static_cast(selectedIndexes.size()) > 0) { - auto tmpOpts = opts; - for (int i = 0; i < static_cast(selectedIndexes.size()); i++) { - if (static_cast(tmpOpts.size()) == 0) { + uint32_t kind = 0; + if (!fromRangeContent) { + kind = NG::TEXT; + } else { + kind |= NG::ICON; + for (const auto& rangeContent : range) { + if (!rangeContent.text_.empty()) { + kind |= NG::TEXT; break; } - auto index = selectedIndexes.at(i); - if (index >= static_cast(tmpOpts.size()) || index < 0) { - index = 0; - } - settingData.selectedValues.push_back(index); - settingData.values.push_back(tmpOpts.at(index).rangeResult.at(0)); - tmpOpts = tmpOpts.at(index).children; - } - } else if (static_cast(selectedValues.size()) > 0) { - auto tmpOpts = opts; - for (int i = 0; i < static_cast(selectedValues.size()); i++) { - if (static_cast(tmpOpts.size()) == 0) { - break; - } - auto valueStr = selectedValues.at(i); - auto index = 0; - - auto checkValidValue = (std::find_if(tmpOpts.begin(), tmpOpts.end(), - [valueStr](TextCascadePickerOptions item) { return item.rangeResult[0] == valueStr; })); - if (checkValidValue != tmpOpts.end()) { - index = static_cast(std::distance(tmpOpts.begin(), checkValidValue)); - } - if (index >= static_cast(tmpOpts.size()) || index < 0) { - index = 0; - } - settingData.selectedValues.push_back(index); - settingData.values.push_back(tmpOpts.at(index).rangeResult.at(0)); - tmpOpts = tmpOpts.at(index).children; } } + return kind; } -void CreateRangeWithSelection(const Ark_TextPickerDialogOptions options, TextPickerSettingData& settingData) +void ParseTextPickerOptions(const Ark_TextPickerDialogOptions& src, TextPickerOptions& dst) { - std::vector selectedIndexes; - auto pickerSelectedOpt = Converter::OptConvert(options.selected); - if (pickerSelectedOpt) { - auto selectedValue = pickerSelectedOpt.value(); - if (auto selected = std::get_if(&selectedValue); selected) { - selectedIndexes.push_back(*selected); - } else { - selectedIndexes = std::get>(selectedValue); - } - } - std::vector selectedValues; - auto pickerValueOpt = Converter::OptConvert(options.value); + auto pickerValueOpt = Converter::OptConvert(src.value); if (pickerValueOpt) { auto pickerValue = pickerValueOpt.value(); + dst.hasValue = true; if (auto value = std::get_if(&pickerValue); value) { - selectedValues.push_back(*value); + dst.value = *value; + dst.values.emplace_back(dst.value); } else { - selectedValues = std::get>(pickerValue); + dst.values = std::move(std::get>(pickerValue)); } } - - auto pickerRangeOpt = Converter::OptConvert(options.range); + auto pickerSelectedOpt = Converter::OptConvert(src.selected); + if (pickerSelectedOpt) { + auto pickerSelected = pickerSelectedOpt.value(); + dst.hasSelected = true; + if (auto selected = std::get_if(&pickerSelected); selected) { + dst.selected = *selected; + dst.selecteds.emplace_back(dst.selected); + } else { + dst.selecteds = std::move(std::get>(pickerSelected)); + } + } + auto pickerRangeOpt = Converter::OptConvert(src.range); if (pickerRangeOpt) { auto pickerRange = pickerRangeOpt.value(); auto rangeVector = std::get_if>>(&pickerRange); - auto optionsVector = std::get_if>>(&pickerRange); - - if (rangeVector && (static_cast(rangeVector->second.size()) > 0)) { - auto range = rangeVector->second; - settingData.rangeVector = range; - - auto selectedIndex = static_cast(selectedIndexes.size()) > 0 ? selectedIndexes.at(0) : 0; - if (selectedIndex >= static_cast(range.size()) || selectedIndex < 0) { - selectedIndex = 0; + if (rangeVector) { + auto fromRangeContent = rangeVector->first; + dst.range = rangeVector->second; + dst.kind = CalculateKind(fromRangeContent, dst.range); + if (fromRangeContent) { + dst.value = ""; + dst.hasValue = true; } - settingData.selected = selectedIndex; - settingData.selectedValues.push_back(selectedIndex); - } else if (optionsVector && (static_cast(optionsVector->second.size()) > 0)) { - auto opts = optionsVector->second; - settingData.options = opts; - BuildCascadeSelection(opts, settingData, selectedIndexes, selectedValues); + } else { + auto options = std::get>>(pickerRange); + dst.options = std::move(options.second); + dst.isCascade = options.first; + dst.kind = NG::TEXT; } } } -TextPickerSettingData BuildPickerSettingData(const Ark_TextPickerDialogOptions options) + +void TextPickerOptions2SettingData(TextPickerOptions& textPickerOptions, TextPickerSettingData& settingData) { - TextPickerSettingData settingData; - CreateRangeWithSelection(options, settingData); + // Verify the data to prevent triggering of exceptions + if (!textPickerOptions.range.empty()) { + ValidateSingleTextPickerOptions(textPickerOptions); + } else if (!textPickerOptions.options.empty()) { + ValidateMultiTextPickerOptions(textPickerOptions); + } + // data conversion + settingData.rangeVector = std::move(textPickerOptions.range); + settingData.selected = textPickerOptions.selected; + settingData.columnKind = textPickerOptions.kind; + settingData.selectedValues = std::move(textPickerOptions.selecteds); + settingData.values = std::move(textPickerOptions.values); + settingData.options = std::move(textPickerOptions.options); + settingData.attr.isCascade = textPickerOptions.isCascade; + settingData.attr.isHasSelectAttr = textPickerOptions.hasSelected; +} + +void BuildTextPickerSettingData(const Ark_TextPickerDialogOptions& arkOptions, + TextPickerSettingData& settingData, TextPickerDialog& pickerDialog) +{ + // parse frontend input parameter type TextPickerOptions + TextPickerOptions textPickerOptions; + ParseTextPickerOptions(arkOptions, textPickerOptions); + TextPickerOptions2SettingData(textPickerOptions, settingData); - auto height = Converter::OptConvert(options.defaultPickerItemHeight); + pickerDialog.isDefaultHeight = false; + auto height = Converter::OptConvert(arkOptions.defaultPickerItemHeight); if (height) { settingData.height = height.value(); + pickerDialog.height = settingData.height; + pickerDialog.isDefaultHeight = true; } - - auto canLoop = Converter::OptConvert(options.canLoop); + settingData.canLoop = true; + auto canLoop = Converter::OptConvert(arkOptions.canLoop); if (canLoop) { settingData.canLoop = canLoop.value(); } - - auto disappearTextStyle = Converter::OptConvert(options.disappearTextStyle); + // pickerBgStyle, temporarily set as default value + settingData.pickerBgStyle.color = Color::TRANSPARENT; + settingData.pickerBgStyle.borderRadius = NG::BorderRadiusProperty(8.0_vp); + // property for text style + auto disappearTextStyle = Converter::OptConvert(arkOptions.disappearTextStyle); if (disappearTextStyle) { settingData.properties.disappearTextStyle_ = disappearTextStyle.value(); } - auto textStyle = Converter::OptConvert(options.textStyle); + auto textStyle = Converter::OptConvert(arkOptions.textStyle); if (textStyle) { settingData.properties.normalTextStyle_ = textStyle.value(); } - auto selectedTextStyle = Converter::OptConvert(options.selectedTextStyle); + auto selectedTextStyle = Converter::OptConvert(arkOptions.selectedTextStyle); if (selectedTextStyle) { settingData.properties.selectedTextStyle_ = selectedTextStyle.value(); } - return settingData; -} -std::vector BuildButtonInfos(const Ark_TextPickerDialogOptions options) -{ - std::vector buttonInfos; - auto acceptButtonInfo = Converter::OptConvert(options.acceptButtonStyle); - if (acceptButtonInfo.has_value()) { - buttonInfos.push_back(acceptButtonInfo.value()); + auto defaultTextStyle = Converter::OptConvert(arkOptions.defaultTextStyle); + if (defaultTextStyle) { + settingData.properties.defaultTextStyle_ = defaultTextStyle.value(); } - auto cancelButtonInfo = Converter::OptConvert(options.cancelButtonStyle); - if (cancelButtonInfo.has_value()) { - buttonInfos.push_back(cancelButtonInfo.value()); + + // disableTextStyleAnimation + settingData.isDisableTextStyleAnimation = false; + auto disableTextStyleAnimation = Converter::OptConvert(arkOptions.disableTextStyleAnimation); + if (disableTextStyleAnimation) { + settingData.isDisableTextStyleAnimation = disableTextStyleAnimation.value(); + } + settingData.isEnableHapticFeedback = true; + auto enableHapticFeedback = Converter::OptConvert(arkOptions.enableHapticFeedback); + if (enableHapticFeedback) { + settingData.isEnableHapticFeedback = enableHapticFeedback.value(); } - return buttonInfos; } + DialogTextEvent BuildTextEvent(Callback_TextPickerResult_Void callback) { return [arkCallback = CallbackHelper(callback)](const std::string& info) -> void { @@ -260,42 +211,145 @@ DialogTextEvent BuildTextEvent(Callback_TextPickerResult_Void callback) arkCallback.Invoke(textPickerRes); }; } -void ShowImpl(const Opt_TextPickerDialogOptions* options) + +void BuildTextPickerDialog(const Ark_TextPickerDialogOptions& options, TextPickerDialog& pickerDialog) { - CHECK_NULL_VOID(options); - auto arkOptionsOpt = Converter::OptConvert(*options); - if (!arkOptionsOpt.has_value()) { return; } + // selectedValue getRangeVector + auto enableHoverMode = Converter::OptConvert(options.enableHoverMode); + if (enableHoverMode) { + pickerDialog.enableHoverMode = enableHoverMode.value(); + } + auto alignment = Converter::OptConvert(options.alignment); + if (alignment) { + pickerDialog.alignment = alignment.value(); + } + auto offset = Converter::OptConvert(options.offset); + if (offset) { + pickerDialog.offset = offset.value(); + } + pickerDialog.maskRect = Converter::OptConvert(options.maskRect); + pickerDialog.backgroundColor = Converter::OptConvert(options.backgroundColor); + pickerDialog.backgroundBlurStyle = static_cast(Converter::OptConvert( + options.backgroundBlurStyle).value_or(BlurStyle::COMPONENT_REGULAR)); + pickerDialog.blurStyleOption = Converter::OptConvert(options.backgroundBlurStyleOptions); + pickerDialog.effectOption = Converter::OptConvert(options.backgroundEffect); + pickerDialog.shadow = Converter::OptConvert(options.shadow); + auto hoverModeArea = Converter::OptConvert(options.hoverModeArea); + if (hoverModeArea) { + pickerDialog.hoverModeArea = hoverModeArea.value(); + } +} - Ark_TextPickerDialogOptions arkOptions = arkOptionsOpt.value(); - DialogProperties dialogProps = BuildDialogProperties(arkOptions); - TextPickerSettingData settingData = BuildPickerSettingData(arkOptions); - std::vector buttonInfos = BuildButtonInfos(arkOptions); +TextPickerDialogEvent BuildTextPickerDialogEvents(const Ark_TextPickerDialogOptions& options) +{ + TextPickerDialogEvent dialogEvent; + auto didAppearCallbackOpt = Converter::OptConvert(options.onDidAppear); + if (didAppearCallbackOpt) { + auto onDidAppear = [arkCallback = CallbackHelper(*didAppearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onDidAppear = onDidAppear; + } + auto didDisappearCallbackOpt = Converter::OptConvert(options.onDidDisappear); + if (didDisappearCallbackOpt) { + auto onDidDisappear = [arkCallback = CallbackHelper(*didDisappearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onDidDisappear = onDidDisappear; + } + auto willAppearCallbackOpt = Converter::OptConvert(options.onWillAppear); + if (willAppearCallbackOpt) { + auto onWillAppear = [arkCallback = CallbackHelper(*willAppearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onWillAppear = onWillAppear; + } + auto willDisappearCallbackOpt = Converter::OptConvert(options.onWillDisappear); + if (willDisappearCallbackOpt) { + auto onWillDisappear = [arkCallback = CallbackHelper(*willDisappearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onWillDisappear = onWillDisappear; + } + return dialogEvent; +} - std::map dialogEvent; +TextPickerInteractiveEvent BuildSelectInteractiveEvents(const Ark_TextPickerDialogOptions& arkOptions) +{ + TextPickerInteractiveEvent events; + // onCancel + auto cancelCallbackOpt = Converter::OptConvert(arkOptions.onCancel); + if (cancelCallbackOpt) { + events.cancelEvent = [arkCallback = CallbackHelper(*cancelCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + } + // onAccept auto acceptCallbackOpt = Converter::OptConvert(arkOptions.onAccept); if (acceptCallbackOpt) { - dialogEvent["acceptId"] = BuildTextEvent(*acceptCallbackOpt); + events.acceptEvent = BuildTextEvent(*acceptCallbackOpt); } + // onChange auto changeCallbackOpt = Converter::OptConvert(arkOptions.onChange); if (changeCallbackOpt) { - dialogEvent["changeId"] = BuildTextEvent(*changeCallbackOpt); + events.changeEvent = BuildTextEvent(*changeCallbackOpt); + } + // onScrollStop + auto scrollStopCallbackOpt = Converter::OptConvert(arkOptions.onScrollStop); + if (scrollStopCallbackOpt) { + events.scrollStopEvent = BuildTextEvent(*scrollStopCallbackOpt); } + // onEnterSelectedAreaEvent + auto enterSelectedAreaCallbackOpt = + Converter::OptConvert(arkOptions.onEnterSelectedArea); + if (enterSelectedAreaCallbackOpt) { + events.enterSelectedAreaEvent = BuildTextEvent(*enterSelectedAreaCallbackOpt); + } + return events; +} - std::map dialogCancelEvent; - auto cancelCallbackOpt = Converter::OptConvert(arkOptions.onCancel); - if (cancelCallbackOpt) { - auto onCancelFunc = [arkCallback = CallbackHelper(*cancelCallbackOpt)](const GestureEvent& info) -> void { - arkCallback.Invoke(); - }; - dialogCancelEvent["cancelId"] = onCancelFunc; +std::vector BuildButtonInfos(const Ark_TextPickerDialogOptions& options) +{ + std::vector buttonInfos; + auto acceptButtonInfo = Converter::OptConvert(options.acceptButtonStyle); + if (acceptButtonInfo.has_value()) { + buttonInfos.emplace_back(acceptButtonInfo.value()); + buttonInfos[0].isAcceptButton = true; + } else { + ButtonInfo buttonInfo; + buttonInfos.emplace_back(buttonInfo); } -#ifndef ARKUI_CAPI_UNITTEST - TextPickerDialogView::Show(dialogProps, settingData, buttonInfos, dialogEvent, dialogCancelEvent); -#else - MockTextPickerDialogView::Show(dialogProps, settingData, buttonInfos, dialogEvent, dialogCancelEvent); -#endif + auto cancelButtonInfo = Converter::OptConvert(options.cancelButtonStyle); + if (cancelButtonInfo.has_value()) { + buttonInfos.emplace_back(cancelButtonInfo.value()); + } + return buttonInfos; +} + +void ShowImpl(const Opt_TextPickerDialogOptions* options) +{ + CHECK_NULL_VOID(options); + auto arkOptionsOpt = Converter::OptConvert(*options); + if (!arkOptionsOpt.has_value()) { return; } + + Ark_TextPickerDialogOptions arkOptions = arkOptionsOpt.value(); + + TextPickerSettingData settingData; + TextPickerDialog textPickerDialog; + BuildTextPickerSettingData(arkOptions, settingData, textPickerDialog); + BuildTextPickerDialog(arkOptions, textPickerDialog); + auto interEvents = BuildSelectInteractiveEvents(arkOptions); + auto dialogEvents = BuildTextPickerDialogEvents(arkOptions); + std::vector buttonInfos = BuildButtonInfos(arkOptions); + // WARING: don't use, only adapter backend function interface. + RefPtr pickerText = nullptr; + TextPickerDialogModel::GetInstance()->SetTextPickerDialogShow(pickerText, settingData, + std::move(interEvents.cancelEvent), std::move(interEvents.acceptEvent), std::move(interEvents.changeEvent), + std::move(interEvents.scrollStopEvent), std::move(interEvents.enterSelectedAreaEvent), + textPickerDialog, dialogEvents, buttonInfos); } } // TextPickerDialogAccessor + const GENERATED_ArkUITextPickerDialogAccessor* GetTextPickerDialogAccessor() { static const GENERATED_ArkUITextPickerDialogAccessor TextPickerDialogAccessorImpl { @@ -303,5 +357,4 @@ const GENERATED_ArkUITextPickerDialogAccessor* GetTextPickerDialogAccessor() }; return &TextPickerDialogAccessorImpl; } - } diff --git a/frameworks/core/interfaces/native/implementation/text_picker_modifier.cpp b/frameworks/core/interfaces/native/implementation/text_picker_modifier.cpp index cb8c496a0587ecc2f68aff281226ab49cf670d64..a19e497feeafcf81774fef000154dcb78cf06553 100644 --- a/frameworks/core/interfaces/native/implementation/text_picker_modifier.cpp +++ b/frameworks/core/interfaces/native/implementation/text_picker_modifier.cpp @@ -26,6 +26,7 @@ #include "core/interfaces/native/utility/callback_helper.h" #include "core/interfaces/native/utility/validators.h" #include "length_metrics_peer.h" +#include "text_picker_modifier.h" namespace OHOS::Ace::NG { namespace { @@ -34,21 +35,6 @@ namespace { const int32_t CROWN_SENSITIVITY_HIGH = 2; } -struct TextPickerOptions { - std::vector range; - uint32_t kind = 0; - uint32_t selected = 0; - std::string value = ""; - std::vector options; - std::vector selecteds; - std::vector values; - std::vector columnWidths; - bool hasValue = false; - bool hasSelected = false; - bool isCascade = false; - uint32_t maxCount = 0; -}; - size_t ProcessCascadeOptionDepth(const NG::TextCascadePickerOptions& option) { size_t depth = 1; diff --git a/frameworks/core/interfaces/native/implementation/text_picker_modifier.h b/frameworks/core/interfaces/native/implementation/text_picker_modifier.h new file mode 100644 index 0000000000000000000000000000000000000000..9d1d4e6b853dcc680c0edee16038e67b93d85b36 --- /dev/null +++ b/frameworks/core/interfaces/native/implementation/text_picker_modifier.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef FOUNDATION_ARKUI_ACE_ENGINE_FRAMEWORKS_CORE_INTERFACES_NATIVE_IMPL_TEXT_PICKER_MODIFIER_H +#define FOUNDATION_ARKUI_ACE_ENGINE_FRAMEWORKS_CORE_INTERFACES_NATIVE_IMPL_TEXT_PICKER_MODIFIER_H + +namespace OHOS::Ace::NG { + +struct TextPickerOptions { + std::vector range; + uint32_t kind = 0; + uint32_t selected = 0; + std::string value = ""; + std::vector options; + std::vector selecteds; + std::vector values; + std::vector columnWidths; + bool hasValue = false; + bool hasSelected = false; + bool isCascade = false; + uint32_t maxCount = 0; +}; +void ValidateSingleTextPickerOptions(TextPickerOptions& options); +void ValidateMultiTextPickerOptions(TextPickerOptions& options); + +} + +#endif // FOUNDATION_ARKUI_ACE_ENGINE_FRAMEWORKS_CORE_INTERFACES_NATIVE_IMPL_TEXT_PICKER_MODIFIER_H \ No newline at end of file diff --git a/frameworks/core/interfaces/native/implementation/time_picker_dialog_accessor.cpp b/frameworks/core/interfaces/native/implementation/time_picker_dialog_accessor.cpp index 7ec02126fb8b8a505db19427b1a277dd23e4d392..390a096b975c4f194e264bcc23ac21b7571a4bf6 100644 --- a/frameworks/core/interfaces/native/implementation/time_picker_dialog_accessor.cpp +++ b/frameworks/core/interfaces/native/implementation/time_picker_dialog_accessor.cpp @@ -13,6 +13,8 @@ * limitations under the License. */ +#include +#include #include "core/components_ng/base/frame_node.h" #include "core/interfaces/native/utility/converter.h" #include "core/interfaces/native/utility/reverse_converter.h" @@ -26,74 +28,70 @@ namespace OHOS::Ace::NG::GeneratedModifier { namespace TimePickerDialogAccessor { -void BuildDialogPropertiesCallbacks(const Ark_TimePickerDialogOptions options, DialogProperties& dialogProps) +PickerDialogInfo BuildTimePickerDialogInfo(const Ark_TimePickerDialogOptions& options) { - auto didAppearCallbackOpt = Converter::OptConvert(options.onDidAppear); - if (didAppearCallbackOpt) { - auto onDidAppear = [arkCallback = CallbackHelper(*didAppearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onDidAppear = onDidAppear; - } - auto didDisappearCallbackOpt = Converter::OptConvert(options.onDidDisappear); - if (didDisappearCallbackOpt) { - auto onDidDisappear = [arkCallback = CallbackHelper(*didDisappearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onDidDisappear = onDidDisappear; - } - auto willAppearCallbackOpt = Converter::OptConvert(options.onWillAppear); - if (willAppearCallbackOpt) { - auto onWillAppear = [arkCallback = CallbackHelper(*willAppearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onWillAppear = onWillAppear; - } - auto willDisappearCallbackOpt = Converter::OptConvert(options.onWillDisappear); - if (willDisappearCallbackOpt) { - auto onWillDisappear = [arkCallback = CallbackHelper(*willDisappearCallbackOpt)]() -> void { - arkCallback.Invoke(); - }; - dialogProps.onWillDisappear = onWillDisappear; + PickerDialogInfo dialogInfo; + + auto pipeline = PipelineBase::GetCurrentContextSafelyWithCheck(); + CHECK_NULL_RETURN(pipeline, dialogInfo); + + auto pickerTheme = pipeline->GetTheme(); + auto parseStartTime = pickerTheme->GetDefaultStartTime(); + auto parseEndTime = pickerTheme->GetDefaultEndTime(); + // start & end time + auto start = Converter::OptConvert(options.start); + if (start) { + parseStartTime = start.value(); + } + auto end = Converter::OptConvert(options.end); + if (end) { + parseEndTime = end.value(); + } + dialogInfo.parseStartTime = parseStartTime; + dialogInfo.parseEndTime = parseEndTime; + // select time + auto selectedTime = Converter::OptConvert(options.selected); + if (selectedTime) { + dialogInfo.isSelectedTime = true; + dialogInfo.pickerTime = selectedTime.value(); } -} -DialogProperties BuildDialogProperties(const Ark_TimePickerDialogOptions options) -{ - DialogProperties dialogProps; auto alignment = Converter::OptConvert(options.alignment); if (alignment) { - dialogProps.alignment = alignment.value(); + dialogInfo.alignment = alignment.value(); } auto offset = Converter::OptConvert(options.offset); if (offset) { - dialogProps.offset = offset.value(); + dialogInfo.offset = offset.value(); } - dialogProps.backgroundBlurStyle = static_cast(Converter::OptConvert( + dialogInfo.backgroundBlurStyle = static_cast(Converter::OptConvert( options.backgroundBlurStyle).value_or(BlurStyle::COMPONENT_REGULAR)); - dialogProps.backgroundColor = Converter::OptConvert(options.backgroundColor); - dialogProps.shadow = Converter::OptConvert(options.shadow); + dialogInfo.blurStyleOption = Converter::OptConvert(options.backgroundBlurStyleOptions); + dialogInfo.effectOption = Converter::OptConvert(options.backgroundEffect); + dialogInfo.backgroundColor = Converter::OptConvert(options.backgroundColor); + dialogInfo.shadow = Converter::OptConvert(options.shadow); auto enableHoverMode = Converter::OptConvert(options.enableHoverMode); if (enableHoverMode) { - dialogProps.enableHoverMode = enableHoverMode.value(); + dialogInfo.enableHoverMode = enableHoverMode.value(); } auto hoverModeArea = Converter::OptConvert(options.hoverModeArea); if (hoverModeArea) { - dialogProps.hoverModeArea = hoverModeArea.value(); + dialogInfo.hoverModeArea = hoverModeArea.value(); } - dialogProps.maskRect = Converter::OptConvert(options.maskRect); - BuildDialogPropertiesCallbacks(options, dialogProps); - return dialogProps; + dialogInfo.maskRect = Converter::OptConvert(options.maskRect); + return dialogInfo; } -TimePickerSettingData BuildPickerSettingData(const Ark_TimePickerDialogOptions options) + +TimePickerSettingData BuildPickerSettingData(const Ark_TimePickerDialogOptions& options) { TimePickerSettingData settingData; - auto format = Converter::OptConvert(options.format); - bool showSecond = format.has_value() && format.value() == TimePickerFormat::HOUR_MINUTE_SECOND; - settingData.showSecond = showSecond; auto useMilitaryTime = Converter::OptConvert(options.useMilitaryTime); if (useMilitaryTime) { settingData.isUseMilitaryTime = useMilitaryTime.value(); } + auto selectedDate = Converter::OptConvert(options.selected); + if (selectedDate) { + settingData.dialogTitleDate = selectedDate.value(); + } auto disappearTextStyle = Converter::OptConvert(options.disappearTextStyle); if (disappearTextStyle) { settingData.properties.disappearTextStyle_ = disappearTextStyle.value(); @@ -106,21 +104,78 @@ TimePickerSettingData BuildPickerSettingData(const Ark_TimePickerDialogOptions o if (selectedTextStyle) { settingData.properties.selectedTextStyle_ = selectedTextStyle.value(); } + auto dateTimeOptions = Converter::OptConvert(options.dateTimeOptions); + if (dateTimeOptions) { + settingData.dateTimeOptions.hourType = dateTimeOptions->hourType; + settingData.dateTimeOptions.minuteType = dateTimeOptions->minuteType; + settingData.dateTimeOptions.secondType = dateTimeOptions->secondType; + } + auto enableHapticFeedback = Converter::OptConvert(options.enableHapticFeedback); + if (enableHapticFeedback) { + settingData.isEnableHapticFeedback = enableHapticFeedback.value(); + } + auto format = Converter::OptConvert(options.format); + bool showSecond = format.has_value() && format.value() == TimePickerFormat::HOUR_MINUTE_SECOND; + settingData.showSecond = showSecond; + auto enableCascade = Converter::OptConvert(options.enableCascade); + if (enableCascade) { + settingData.isEnableCascade = enableCascade.value(); + } return settingData; } -std::vector BuildButtonInfos(const Ark_TimePickerDialogOptions options) + +TimePickerDialogEvent BuildTimePickerDialogEvents(const Ark_TimePickerDialogOptions& options) +{ + TimePickerDialogEvent dialogEvent; + auto didAppearCallbackOpt = Converter::OptConvert(options.onDidAppear); + if (didAppearCallbackOpt) { + auto onDidAppear = [arkCallback = CallbackHelper(*didAppearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onDidAppear = onDidAppear; + } + auto didDisappearCallbackOpt = Converter::OptConvert(options.onDidDisappear); + if (didDisappearCallbackOpt) { + auto onDidDisappear = [arkCallback = CallbackHelper(*didDisappearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onDidDisappear = onDidDisappear; + } + auto willAppearCallbackOpt = Converter::OptConvert(options.onWillAppear); + if (willAppearCallbackOpt) { + auto onWillAppear = [arkCallback = CallbackHelper(*willAppearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onWillAppear = onWillAppear; + } + auto willDisappearCallbackOpt = Converter::OptConvert(options.onWillDisappear); + if (willDisappearCallbackOpt) { + auto onWillDisappear = [arkCallback = CallbackHelper(*willDisappearCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; + dialogEvent.onWillDisappear = onWillDisappear; + } + return dialogEvent; +} + +std::vector BuildButtonInfos(const Ark_TimePickerDialogOptions& options) { std::vector buttonInfos; auto acceptButtonInfo = Converter::OptConvert(options.acceptButtonStyle); if (acceptButtonInfo.has_value()) { - buttonInfos.push_back(acceptButtonInfo.value()); + buttonInfos.emplace_back(acceptButtonInfo.value()); + buttonInfos[0].isAcceptButton = true; + } else { + ButtonInfo buttonInfo; + buttonInfos.emplace_back(buttonInfo); } auto cancelButtonInfo = Converter::OptConvert(options.cancelButtonStyle); if (cancelButtonInfo.has_value()) { - buttonInfos.push_back(cancelButtonInfo.value()); + buttonInfos.emplace_back(cancelButtonInfo.value()); } return buttonInfos; } + void ShowImpl(const Opt_TimePickerDialogOptions* options) { CHECK_NULL_VOID(options); @@ -128,51 +183,55 @@ void ShowImpl(const Opt_TimePickerDialogOptions* options) if (!arkOptionsOpt.has_value()) { return; } Ark_TimePickerDialogOptions arkOptions = arkOptionsOpt.value(); - DialogProperties dialogProps = BuildDialogProperties(arkOptions); + PickerDialogInfo dialogInfo = BuildTimePickerDialogInfo(arkOptions); TimePickerSettingData settingData = BuildPickerSettingData(arkOptions); - std::vector buttonInfos = BuildButtonInfos(arkOptions); - - std::map timePickerProp; - auto time = Converter::OptConvert(arkOptions.selected); - if (time) { - timePickerProp.insert({"selected", time.value()}); + dialogInfo.isUseMilitaryTime = settingData.isUseMilitaryTime; + // onCancel + std::function cancelEvent; + auto cancelCallbackOpt = Converter::OptConvert(arkOptions.onCancel); + if (cancelCallbackOpt) { + cancelEvent = [arkCallback = CallbackHelper(*cancelCallbackOpt)]() -> void { + arkCallback.Invoke(); + }; } - - std::map dialogEvent; + // onAccept + std::function acceptEvent; auto acceptCallbackOpt = Converter::OptConvert(arkOptions.onAccept); if (acceptCallbackOpt) { - auto onAcceptFunc = [arkCallback = CallbackHelper(*acceptCallbackOpt)](const std::string& info) -> void { - auto timePickerRes = Converter::ArkValue(info); - arkCallback.Invoke(timePickerRes); + acceptEvent = [arkCallback = CallbackHelper(*acceptCallbackOpt)](const std::string& info) -> void { + auto result = Converter::ArkValue(info); + arkCallback.Invoke(result); }; - dialogEvent["acceptId"] = onAcceptFunc; } + // onChange + std::function changeEvent; auto changeCallbackOpt = Converter::OptConvert(arkOptions.onChange); if (changeCallbackOpt) { - auto onChangeFunc = [arkCallback = CallbackHelper(*changeCallbackOpt)](const std::string& info) -> void { - auto timePickerRes = Converter::ArkValue(info); - arkCallback.Invoke(timePickerRes); + changeEvent = [arkCallback = CallbackHelper(*changeCallbackOpt)](const std::string& info) -> void { + auto result = Converter::ArkValue(info); + arkCallback.Invoke(result); }; - dialogEvent["changeId"] = onChangeFunc; } - - std::map dialogCancelEvent; - auto cancelCallbackOpt = Converter::OptConvert(arkOptions.onCancel); - if (cancelCallbackOpt) { - auto onCancelFunc = [arkCallback = CallbackHelper(*cancelCallbackOpt)](const GestureEvent& info) -> void { - arkCallback.Invoke(); + // onEnterSelectedAreaEvent + std::function enterSelectedAreaEvent; + auto enterSelectedAreaCallbackOpt = + Converter::OptConvert(arkOptions.onEnterSelectedArea); + if (enterSelectedAreaCallbackOpt) { + enterSelectedAreaEvent = + [arkCallback = CallbackHelper(*enterSelectedAreaCallbackOpt)](const std::string& info) -> void { + auto result = Converter::ArkValue(info); + arkCallback.Invoke(result); }; - dialogCancelEvent["cancelId"] = onCancelFunc; } -#ifndef ARKUI_CAPI_UNITTEST - TimePickerDialogView::Show(dialogProps, settingData, buttonInfos, - timePickerProp, dialogEvent, dialogCancelEvent); -#else - MockTimePickerDialogView::SetData(dialogProps, settingData, buttonInfos, timePickerProp); - MockTimePickerDialogView::SetCallbacks(dialogEvent, dialogCancelEvent); -#endif + // window lifecycle callback event + TimePickerDialogEvent timePickerDialogEvent = BuildTimePickerDialogEvents(arkOptions); + std::vector buttonInfos = BuildButtonInfos(arkOptions); + TimePickerDialogModel::GetInstance()->SetTimePickerDialogShow(dialogInfo, settingData, std::move(cancelEvent), + std::move(acceptEvent), std::move(changeEvent), std::move(enterSelectedAreaEvent), + timePickerDialogEvent, buttonInfos); } } // TimePickerDialogAccessor + const GENERATED_ArkUITimePickerDialogAccessor* GetTimePickerDialogAccessor() { static const GENERATED_ArkUITimePickerDialogAccessor TimePickerDialogAccessorImpl { @@ -180,5 +239,4 @@ const GENERATED_ArkUITimePickerDialogAccessor* GetTimePickerDialogAccessor() }; return &TimePickerDialogAccessorImpl; } - } diff --git a/frameworks/core/interfaces/native/utility/converter.cpp b/frameworks/core/interfaces/native/utility/converter.cpp index e11659485d3623e7abe41751fd9a01048295b97a..8dc506cdee71d5ed05544318231957a12c135dce 100644 --- a/frameworks/core/interfaces/native/utility/converter.cpp +++ b/frameworks/core/interfaces/native/utility/converter.cpp @@ -2085,6 +2085,9 @@ template<> DimensionRect Convert(const Ark_Rectangle &src) { DimensionRect dst; + dst.SetOffset(DimensionOffset(CalcDimension(0, DimensionUnit::VP), CalcDimension(0, DimensionUnit::VP))); + dst.SetSize(DimensionSize(CalcDimension(1, DimensionUnit::PERCENT), CalcDimension(1, DimensionUnit::PERCENT))); + if (auto dim = OptConvert(src.width); dim) { Validator::ValidateNonNegative(dim); if (dim) { @@ -2582,6 +2585,7 @@ ButtonInfo Convert(const Ark_PickerDialogButtonStyle& src) info.fontFamily = fontfamiliesOpt->families; } info.fontWeight = OptConvert(src.fontWeight); + info.fontStyle = OptConvert(src.fontStyle); info.backgroundColor = OptConvert(src.backgroundColor); info.borderRadius = OptConvert(src.borderRadius);