1 /* 2 * Copyright (c) 2022-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 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_GAUGE_GAUGE_PAINT_PROPERTY_H 17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_GAUGE_GAUGE_PAINT_PROPERTY_H 18 19 #include "core/common/container.h" 20 #include "core/components/common/layout/constants.h" 21 #include "core/components/common/properties/color.h" 22 #include "core/components_ng/base/inspector_filter.h" 23 #include "core/components_ng/pattern/gauge/gauge_theme.h" 24 #include "core/components_ng/render/paint_property.h" 25 #include "core/image/image_source_info.h" 26 27 namespace OHOS::Ace::NG { 28 using ColorStopArray = std::vector<std::pair<Color, Dimension>>; 29 enum class GaugeType : int32_t { 30 TYPE_CIRCULAR_MULTI_SEGMENT_GRADIENT = 0, 31 TYPE_CIRCULAR_SINGLE_SEGMENT_GRADIENT = 1, 32 TYPE_CIRCULAR_MONOCHROME = 2, 33 }; 34 35 struct GaugeShadowOptions { 36 bool isShadowVisible = true; 37 float radius = DEFAULT_GAUGE_SHADOW_RADIUS; 38 float offsetX = DEFAULT_GAUGE_SHADOW_OFFSETX; 39 float offsetY = DEFAULT_GAUGE_SHADOW_OFFSETY; 40 bool operator==(const GaugeShadowOptions& rhs) const 41 { 42 return radius == rhs.radius && offsetX == rhs.offsetX && offsetY == rhs.offsetY && 43 isShadowVisible == rhs.isShadowVisible; 44 } 45 }; 46 class GaugePaintProperty : public PaintProperty { 47 DECLARE_ACE_TYPE(GaugePaintProperty, PaintProperty) 48 49 public: 50 GaugePaintProperty() = default; 51 ~GaugePaintProperty() override = default; 52 Clone()53 RefPtr<PaintProperty> Clone() const override 54 { 55 auto paintProperty = MakeRefPtr<GaugePaintProperty>(); 56 paintProperty->UpdatePaintProperty(this); 57 paintProperty->propValue_ = CloneValue(); 58 paintProperty->propMin_ = CloneMin(); 59 paintProperty->propMax_ = CloneMax(); 60 paintProperty->propStartAngle_ = CloneStartAngle(); 61 paintProperty->propEndAngle_ = CloneEndAngle(); 62 paintProperty->propColors_ = CloneColors(); 63 paintProperty->propGradientColors_ = CloneGradientColors(); 64 paintProperty->propValues_ = CloneValues(); 65 paintProperty->propStrokeWidth_ = CloneStrokeWidth(); 66 paintProperty->propGaugeType_ = CloneGaugeType(); 67 paintProperty->propShadowOptions_ = CloneShadowOptions(); 68 paintProperty->propIsShowIndicator_ = CloneIsShowIndicator(); 69 paintProperty->propIndicatorIconSourceInfo_ = CloneIndicatorIconSourceInfo(); 70 paintProperty->propIndicatorSpace_ = CloneIndicatorSpace(); 71 paintProperty->propIndicatorChange_ = CloneIndicatorChange(); 72 paintProperty->propIsSensitive_ = CloneIsSensitive(); 73 return paintProperty; 74 } 75 Reset()76 void Reset() override 77 { 78 PaintProperty::Reset(); 79 ResetValue(); 80 ResetMin(); 81 ResetMax(); 82 ResetStartAngle(); 83 ResetEndAngle(); 84 ResetColors(); 85 ResetGradientColors(); 86 ResetValues(); 87 ResetStrokeWidth(); 88 ResetGaugeType(); 89 ResetShadowOptions(); 90 ResetIsShowIndicator(); 91 ResetIndicatorIconSourceInfo(); 92 ResetIndicatorSpace(); 93 ResetIsSensitive(); 94 } 95 ToJsonValue(std::unique_ptr<JsonValue> & json,const InspectorFilter & filter)96 void ToJsonValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const override 97 { 98 PaintProperty::ToJsonValue(json, filter); 99 /* no fixed attr below, just return */ 100 if (filter.IsFastFilter()) { 101 if (Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_ELEVEN)) { 102 ToJsonColor(json, filter); 103 ToJsonIndicator(json, filter); 104 ToJsonTrackShadow(json, filter); 105 } 106 return; 107 } 108 json->PutExtAttr("value", StringUtils::DoubleToString(propValue_.value_or(0)).c_str(), filter); 109 json->PutExtAttr("max", StringUtils::DoubleToString(propMax_.value_or(100)).c_str(), filter); 110 json->PutExtAttr("min", StringUtils::DoubleToString(propMin_.value_or(0)).c_str(), filter); 111 json->PutExtAttr("startAngle", StringUtils::DoubleToString(propStartAngle_.value_or(0)).c_str(), filter); 112 json->PutExtAttr("endAngle", StringUtils::DoubleToString(propEndAngle_.value_or(360)).c_str(), filter); 113 json->PutExtAttr("isSensitive", std::to_string(GetIsSensitive().value_or(false)).c_str(), filter); 114 json->PutExtAttr("privacySensitive", GetIsSensitive().value_or(false)? "true": "false", filter); 115 if (propStrokeWidth_.has_value()) { 116 json->PutExtAttr("strokeWidth", propStrokeWidth_.value().ToString().c_str(), filter); 117 } else { 118 json->PutExtAttr("strokeWidth", "", filter); 119 } 120 121 if (Container::LessThanAPIVersion(PlatformVersion::VERSION_ELEVEN)) { 122 auto jsonColors = JsonUtil::CreateArray(true); 123 if (propColors_.has_value() && propColors_.has_value()) { 124 for (size_t i = 0; i < propValues_.value().size(); i++) { 125 auto jsonObject = JsonUtil::CreateArray(true); 126 jsonObject->Put("0", propColors_.value()[i].ColorToString().c_str()); 127 jsonObject->Put("1", propValues_.value()[i]); 128 auto index = std::to_string(i); 129 jsonColors->Put(index.c_str(), jsonObject); 130 } 131 } 132 json->PutExtAttr("colors", jsonColors->ToString().c_str(), filter); 133 } else { 134 ToJsonColor(json, filter); 135 ToJsonIndicator(json, filter); 136 ToJsonTrackShadow(json, filter); 137 } 138 } 139 ToJsonColor(std::unique_ptr<JsonValue> & json,const InspectorFilter & filter)140 void ToJsonColor(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const 141 { 142 /* no fixed attr below, just return */ 143 if (filter.IsFastFilter()) { 144 return; 145 } 146 if (!propGaugeType_.has_value()) { 147 auto jsonColor = JsonUtil::CreateArray(true); 148 for (size_t j = 0; j < GAUGE_DEFAULT_COLOR.size(); j++) { 149 jsonColor->Put(std::to_string(j).c_str(), GAUGE_DEFAULT_COLOR[j].ColorToString().c_str()); 150 } 151 json->PutExtAttr("colors", jsonColor->ToString().c_str(), filter); 152 return; 153 } 154 155 if (propGaugeType_.value() == GaugeType::TYPE_CIRCULAR_MONOCHROME) { 156 if (propGradientColors_.has_value()) { 157 json->PutExtAttr("colors", 158 propGradientColors_.value().at(0).at(0).first.ColorToString().c_str(), filter); 159 } 160 return; 161 } 162 163 if (propGaugeType_.value() == GaugeType::TYPE_CIRCULAR_SINGLE_SEGMENT_GRADIENT) { 164 if (propGradientColors_.has_value()) { 165 auto jsonColor = JsonUtil::CreateArray(true); 166 auto colorStopArray = propGradientColors_.value().at(0); 167 for (size_t j = 0; j < colorStopArray.size(); j++) { 168 auto jsonColorObject = JsonUtil::CreateArray(true); 169 jsonColorObject->Put("0", colorStopArray[j].first.ColorToString().c_str()); 170 jsonColorObject->Put("1", std::to_string(colorStopArray[j].second.Value()).c_str()); 171 auto indexStr = std::to_string(j); 172 jsonColor->Put(indexStr.c_str(), jsonColorObject); 173 } 174 json->PutExtAttr("colors", jsonColor->ToString().c_str(), filter); 175 } 176 return; 177 } 178 ToJsonColorHasValue(json, filter); 179 } 180 ToJsonColorHasValue(std::unique_ptr<JsonValue> & json,const InspectorFilter & filter)181 void ToJsonColorHasValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const 182 { 183 auto jsonGradientColors = JsonUtil::CreateArray(true); 184 if (propGradientColors_.has_value() && propValues_.has_value() && 185 (propGradientColors_.value().size() == propValues_.value().size())) { 186 for (size_t i = 0; i < propValues_.value().size(); i++) { 187 auto jsonObject = JsonUtil::CreateArray(true); 188 auto jsonColor = JsonUtil::CreateArray(true); 189 auto colorStopArray = propGradientColors_.value()[i]; 190 for (size_t j = 0; j < colorStopArray.size(); j++) { 191 auto jsonColorObject = JsonUtil::CreateArray(true); 192 jsonColorObject->Put("0", colorStopArray[j].first.ColorToString().c_str()); 193 jsonColorObject->Put("1", std::to_string(colorStopArray[j].second.Value()).c_str()); 194 auto indexStr = std::to_string(j); 195 jsonColor->Put(indexStr.c_str(), jsonColorObject); 196 } 197 jsonObject->Put("0", jsonColor); 198 jsonObject->Put("1", propValues_.value()[i]); 199 auto index = std::to_string(i); 200 jsonGradientColors->Put(index.c_str(), jsonObject); 201 } 202 } 203 json->PutExtAttr("colors", jsonGradientColors->ToString().c_str(), filter); 204 } 205 ToJsonIndicator(std::unique_ptr<JsonValue> & json,const InspectorFilter & filter)206 void ToJsonIndicator(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const 207 { 208 /* no fixed attr below, just return */ 209 if (filter.IsFastFilter()) { 210 return; 211 } 212 if (!propIsShowIndicator_.value_or(true)) { 213 json->PutExtAttr("indicator", "null", filter); 214 return; 215 } 216 auto indicatorJsonValue = JsonUtil::Create(true); 217 if (propIndicatorIconSourceInfo_.has_value()) { 218 indicatorJsonValue->Put("icon", propIndicatorIconSourceInfo_.value().GetSrc().c_str()); 219 } else { 220 indicatorJsonValue->Put("icon", "SystemStyle"); 221 } 222 223 if (propIndicatorSpace_.has_value()) { 224 indicatorJsonValue->Put("space", propIndicatorSpace_.value().ToString().c_str()); 225 } else { 226 indicatorJsonValue->Put("space", INDICATOR_DISTANCE_TO_TOP.ToString().c_str()); 227 } 228 json->PutExtAttr("indicator", indicatorJsonValue, filter); 229 } 230 ToJsonTrackShadow(std::unique_ptr<JsonValue> & json,const InspectorFilter & filter)231 void ToJsonTrackShadow(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const 232 { 233 /* no fixed attr below, just return */ 234 if (filter.IsFastFilter()) { 235 return; 236 } 237 GaugeShadowOptions trackShadow; 238 if (propShadowOptions_.has_value()) { 239 trackShadow.radius = propShadowOptions_.value().radius; 240 trackShadow.offsetX = propShadowOptions_.value().offsetX; 241 trackShadow.offsetY = propShadowOptions_.value().offsetY; 242 trackShadow.isShadowVisible = propShadowOptions_.value().isShadowVisible; 243 } else { 244 trackShadow.radius = DEFAULT_GAUGE_SHADOW_RADIUS; 245 trackShadow.offsetX = DEFAULT_GAUGE_SHADOW_OFFSETX; 246 trackShadow.offsetY = DEFAULT_GAUGE_SHADOW_OFFSETY; 247 } 248 249 if (!trackShadow.isShadowVisible) { 250 json->PutExtAttr("trackShadow", "null", filter); 251 return; 252 } 253 254 auto shadowOptionJson = JsonUtil::Create(true); 255 shadowOptionJson->Put("radius", std::to_string(trackShadow.radius).c_str()); 256 shadowOptionJson->Put("offsetX", std::to_string(trackShadow.offsetX).c_str()); 257 shadowOptionJson->Put("offsetY", std::to_string(trackShadow.offsetY).c_str()); 258 259 json->PutExtAttr("trackShadow", shadowOptionJson, filter); 260 } 261 262 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(Value, float, PROPERTY_UPDATE_RENDER); 263 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(Min, float, PROPERTY_UPDATE_RENDER); 264 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(Max, float, PROPERTY_UPDATE_RENDER); 265 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(StartAngle, float, PROPERTY_UPDATE_RENDER); 266 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(EndAngle, float, PROPERTY_UPDATE_RENDER); 267 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(GaugeType, GaugeType, PROPERTY_UPDATE_RENDER); 268 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(Colors, std::vector<Color>, PROPERTY_UPDATE_RENDER); 269 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(GradientColors, std::vector<ColorStopArray>, PROPERTY_UPDATE_RENDER); 270 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(Values, std::vector<float>, PROPERTY_UPDATE_RENDER); 271 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(StrokeWidth, Dimension, PROPERTY_UPDATE_RENDER); 272 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(ShadowOptions, GaugeShadowOptions, PROPERTY_UPDATE_RENDER); 273 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(IsShowIndicator, bool, PROPERTY_UPDATE_RENDER); 274 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(IndicatorIconSourceInfo, ImageSourceInfo, PROPERTY_UPDATE_RENDER); 275 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(IndicatorSpace, Dimension, PROPERTY_UPDATE_RENDER); 276 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(IndicatorChange, bool, PROPERTY_UPDATE_RENDER); 277 ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(IsSensitive, bool, PROPERTY_UPDATE_RENDER); 278 ACE_DISALLOW_COPY_AND_MOVE(GaugePaintProperty); 279 }; 280 281 } // namespace OHOS::Ace::NG 282 283 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERN_GAUGE_GAUGE_PAINT_PROPERTY_H 284