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 16/// <reference path='./import.ts' /> 17class ArkGaugeComponent extends ArkComponent implements GaugeAttribute { 18 builder: WrappedBuilder<Object[]> | null = null; 19 gaugeNode: BuilderNode<[GaugeConfiguration]> | null = null; 20 modifier: ContentModifier<GaugeConfiguration>; 21 needRebuild: boolean = false; 22 constructor(nativePtr: KNode, classType?: ModifierType) { 23 super(nativePtr, classType); 24 } 25 value(value: number): this { 26 modifierWithKey(this._modifiersWithKeys, GaugeVauleModifier.identity, GaugeVauleModifier, value); 27 return this; 28 } 29 startAngle(angle: number): this { 30 modifierWithKey(this._modifiersWithKeys, GaugeStartAngleModifier.identity, GaugeStartAngleModifier, angle); 31 return this; 32 } 33 endAngle(angle: number): this { 34 modifierWithKey(this._modifiersWithKeys, GaugeEndAngleModifier.identity, GaugeEndAngleModifier, angle); 35 return this; 36 } 37 colors(colors: ResourceColor | LinearGradient | Array<[ResourceColor | LinearGradient, number]>): this { 38 modifierWithKey(this._modifiersWithKeys, GaugeColorsModifier.identity, GaugeColorsModifier, colors); 39 return this; 40 } 41 strokeWidth(length: any): this { 42 modifierWithKey(this._modifiersWithKeys, GaugeStrokeWidthModifier.identity, GaugeStrokeWidthModifier, length); 43 return this; 44 } 45 description(value: CustomBuilder): this { 46 throw new Error('Method not implemented.'); 47 } 48 trackShadow(value: GaugeShadowOptions): this { 49 modifierWithKey(this._modifiersWithKeys, GaugeTrackShadowModifier.identity, GaugeTrackShadowModifier, value); 50 return this; 51 } 52 indicator(value: GaugeIndicatorOptions): this { 53 modifierWithKey(this._modifiersWithKeys, GaugeIndicatorModifier.identity, GaugeIndicatorModifier, value); 54 return this; 55 } 56 contentModifier(value: ContentModifier<GaugeConfiguration>): this { 57 modifierWithKey(this._modifiersWithKeys, GaugeContentModifier.identity, GaugeContentModifier, value); 58 return this; 59 } 60 setContentModifier(modifier: ContentModifier<GaugeConfiguration>): this { 61 if (modifier === undefined || modifier === null) { 62 getUINativeModule().gauge.setContentModifierBuilder(this.nativePtr, false); 63 return; 64 } 65 this.needRebuild = false; 66 if (this.builder !== modifier.applyContent()) { 67 this.needRebuild = true; 68 } 69 this.builder = modifier.applyContent(); 70 this.modifier = modifier; 71 getUINativeModule().gauge.setContentModifierBuilder(this.nativePtr, this); 72 } 73 makeContentModifierNode(context: UIContext, gaugeConfiguration: GaugeConfiguration): FrameNode | null { 74 gaugeConfiguration.contentModifier = this.modifier; 75 if (isUndefined(this.gaugeNode) || this.needRebuild) { 76 let xNode = globalThis.requireNapi('arkui.node'); 77 this.gaugeNode = new xNode.BuilderNode(context); 78 this.gaugeNode.build(this.builder, gaugeConfiguration); 79 this.needRebuild = false; 80 } else { 81 this.gaugeNode.update(gaugeConfiguration); 82 } 83 return this.gaugeNode.getFrameNode(); 84 } 85 privacySensitive(value: boolean): this { 86 modifierWithKey(this._modifiersWithKeys, GaugePrivacySensitiveModifier.identity, GaugePrivacySensitiveModifier, value); 87 return this; 88 } 89} 90 91class GaugeIndicatorModifier extends ModifierWithKey<GaugeIndicatorOptions> { 92 static identity: Symbol = Symbol('gaugeIndicator'); 93 applyPeer(node: KNode, reset: boolean): void { 94 if (reset) { 95 getUINativeModule().gauge.resetGaugeIndicator(node, this.value); 96 } else { 97 getUINativeModule().gauge.setGaugeIndicator(node, this.value.icon, this.value.space); 98 } 99 } 100 101 checkObjectDiff(): boolean { 102 return !isBaseOrResourceEqual(this.stageValue.icon, this.value.icon) || 103 !isBaseOrResourceEqual(this.stageValue.space, this.value.space); 104 } 105} 106 107class GaugeContentModifier extends ModifierWithKey<ContentModifier<GaugeConfiguration>> { 108 constructor(value: ContentModifier<GaugeConfiguration>) { 109 super(value); 110 } 111 static identity: Symbol = Symbol('gaugeContentModifier'); 112 applyPeer(node: KNode, reset: boolean, component: ArkComponent) { 113 let gaugeComponent = component as ArkGaugeComponent; 114 gaugeComponent.setContentModifier(this.value); 115 } 116} 117 118class GaugeColorsModifier extends ModifierWithKey<ResourceColor | LinearGradient | Array<[ResourceColor | LinearGradient, number]>> { 119 static identity = Symbol('gaugeColors'); 120 applyPeer(node: KNode, reset: boolean): void { 121 if (reset) { 122 getUINativeModule().gauge.resetGaugeColors(node); 123 } else { 124 getUINativeModule().gauge.setGaugeColors(node, this.value!); 125 } 126 } 127 checkObjectDiff(): boolean { 128 return true; 129 } 130} 131 132class GaugeVauleModifier extends ModifierWithKey<number> { 133 static identity: Symbol = Symbol('gaugeVaule'); 134 applyPeer(node: KNode, reset: boolean): void { 135 if (reset) { 136 getUINativeModule().gauge.resetGaugeVaule(node); 137 } else { 138 getUINativeModule().gauge.setGaugeVaule(node, this.value); 139 } 140 } 141 142 checkObjectDiff(): boolean { 143 return !isBaseOrResourceEqual(this.stageValue, this.value); 144 } 145} 146 147class GaugeStartAngleModifier extends ModifierWithKey<number> { 148 static identity: Symbol = Symbol('gaugeStartAngle'); 149 applyPeer(node: KNode, reset: boolean): void { 150 if (reset) { 151 getUINativeModule().gauge.resetGaugeStartAngle(node); 152 } else { 153 getUINativeModule().gauge.setGaugeStartAngle(node, this.value); 154 } 155 } 156 157 checkObjectDiff(): boolean { 158 return !isBaseOrResourceEqual(this.stageValue, this.value); 159 } 160} 161 162class GaugeEndAngleModifier extends ModifierWithKey<number> { 163 static identity: Symbol = Symbol('gaugeEndAngle'); 164 applyPeer(node: KNode, reset: boolean): void { 165 if (reset) { 166 getUINativeModule().gauge.resetGaugeEndAngle(node); 167 } else { 168 getUINativeModule().gauge.setGaugeEndAngle(node, this.value); 169 } 170 } 171 172 checkObjectDiff(): boolean { 173 return !isBaseOrResourceEqual(this.stageValue, this.value); 174 } 175} 176 177class GaugeStrokeWidthModifier extends ModifierWithKey<Length> { 178 static identity: Symbol = Symbol('gaugeStrokeWidth'); 179 applyPeer(node: KNode, reset: boolean): void { 180 if (reset) { 181 getUINativeModule().gauge.resetGaugeStrokeWidth(node); 182 } else { 183 getUINativeModule().gauge.setGaugeStrokeWidth(node, this.value); 184 } 185 } 186 187 checkObjectDiff(): boolean { 188 return !isBaseOrResourceEqual(this.stageValue, this.value); 189 } 190} 191 192class GaugeTrackShadowModifier extends ModifierWithKey<GaugeShadowOptions> { 193 static identity: Symbol = Symbol('gaugeTrackShadow'); 194 applyPeer(node: KNode, reset: boolean): void { 195 if (reset) { 196 getUINativeModule().gauge.resetGaugeTrackShadow(node); 197 } else { 198 getUINativeModule().gauge.setGaugeTrackShadow(node, this.value, this.value.radius, this.value.offsetX, this.value.offsetY); 199 } 200 } 201 202 checkObjectDiff(): boolean { 203 return !isBaseOrResourceEqual(this.stageValue, this.value); 204 } 205} 206 207class GaugePrivacySensitiveModifier extends ModifierWithKey<boolean> { 208 constructor(value: boolean) { 209 super(value); 210 } 211 static identity: Symbol = Symbol('gaugePrivacySensitive'); 212 applyPeer(node: KNode, reset: boolean): void { 213 if (reset) { 214 getUINativeModule().gauge.resetGaugePrivacySensitive(node); 215 } else { 216 getUINativeModule().gauge.setGaugePrivacySensitive(node, this.value); 217 } 218 } 219} 220 221// @ts-ignore 222globalThis.Gauge.attributeModifier = function (modifier: ArkComponent): void { 223 attributeModifierFunc.call(this, modifier, (nativePtr: KNode) => { 224 return new ArkGaugeComponent(nativePtr); 225 }, (nativePtr: KNode, classType: ModifierType, modifierJS: ModifierJS) => { 226 return new modifierJS.GaugeModifier(nativePtr, classType); 227 }); 228}; 229// @ts-ignore 230globalThis.Gauge.contentModifier = function (modifier) { 231 const elmtId = ViewStackProcessor.GetElmtIdToAccountFor(); 232 let nativeNode = getUINativeModule().getFrameNodeById(elmtId); 233 let component = this.createOrGetNode(elmtId, () => { 234 return new ArkGaugeComponent(nativeNode); 235 }); 236 component.setContentModifier(modifier); 237}; 238