| #ifndef _RIVE_SEMANTIC_DATA_BASE_HPP_ |
| #define _RIVE_SEMANTIC_DATA_BASE_HPP_ |
| #include <string> |
| #include "rive/component.hpp" |
| #include "rive/core/field_types/core_bool_type.hpp" |
| #include "rive/core/field_types/core_string_type.hpp" |
| #include "rive/core/field_types/core_uint_type.hpp" |
| namespace rive |
| { |
| class SemanticDataBase : public Component |
| { |
| protected: |
| typedef Component Super; |
| |
| public: |
| static const uint16_t typeKey = 668; |
| |
| /// Helper to quickly determine if a core object extends another without |
| /// RTTI at runtime. |
| bool isTypeOf(uint16_t typeKey) const override |
| { |
| switch (typeKey) |
| { |
| case SemanticDataBase::typeKey: |
| case ComponentBase::typeKey: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| uint16_t coreType() const override { return typeKey; } |
| |
| static const uint16_t rolePropertyKey = 982; |
| static const uint16_t labelPropertyKey = 983; |
| static const uint16_t valuePropertyKey = 984; |
| static const uint16_t hintPropertyKey = 985; |
| static const uint16_t headingLevelPropertyKey = 986; |
| static const uint16_t traitFlagsPropertyKey = 987; |
| static const uint16_t stateFlagsPropertyKey = 988; |
| static const uint16_t isExpandablePropertyKey = 989; |
| static const uint32_t isExpandableBitmask = 1u << 0; |
| static const uint16_t isSelectablePropertyKey = 990; |
| static const uint32_t isSelectableBitmask = 1u << 1; |
| static const uint16_t isCheckablePropertyKey = 991; |
| static const uint32_t isCheckableBitmask = 1u << 2; |
| static const uint16_t isToggleablePropertyKey = 992; |
| static const uint32_t isToggleableBitmask = 1u << 3; |
| static const uint16_t isRequirablePropertyKey = 993; |
| static const uint32_t isRequirableBitmask = 1u << 4; |
| static const uint16_t isEnablablePropertyKey = 994; |
| static const uint32_t isEnablableBitmask = 1u << 5; |
| static const uint16_t isFocusablePropertyKey = 995; |
| static const uint32_t isFocusableBitmask = 1u << 6; |
| static const uint16_t isExpandedPropertyKey = 996; |
| static const uint32_t isExpandedBitmask = 1u << 0; |
| static const uint16_t isSelectedPropertyKey = 997; |
| static const uint32_t isSelectedBitmask = 1u << 1; |
| static const uint16_t isCheckedPropertyKey = 998; |
| static const uint32_t isCheckedBitOffset = 2; |
| static const uint32_t isCheckedFieldMask = 12u; |
| static const uint16_t isToggledPropertyKey = 1000; |
| static const uint32_t isToggledBitmask = 1u << 4; |
| static const uint16_t isRequiredPropertyKey = 1001; |
| static const uint32_t isRequiredBitmask = 1u << 5; |
| static const uint16_t isDisabledPropertyKey = 1002; |
| static const uint32_t isDisabledBitmask = 1u << 6; |
| static const uint16_t isFocusedPropertyKey = 1003; |
| static const uint32_t isFocusedBitmask = 1u << 7; |
| static const uint16_t isHiddenPropertyKey = 1004; |
| static const uint32_t isHiddenBitmask = 1u << 8; |
| static const uint16_t isLiveRegionPropertyKey = 1005; |
| static const uint32_t isLiveRegionBitmask = 1u << 9; |
| static const uint16_t isReadOnlyPropertyKey = 1006; |
| static const uint32_t isReadOnlyBitmask = 1u << 10; |
| static const uint16_t isModalPropertyKey = 1007; |
| static const uint32_t isModalBitmask = 1u << 11; |
| static const uint16_t isObscuredPropertyKey = 1008; |
| static const uint32_t isObscuredBitmask = 1u << 12; |
| static const uint16_t isMultilinePropertyKey = 1009; |
| static const uint32_t isMultilineBitmask = 1u << 13; |
| |
| protected: |
| uint32_t m_Role = 0; |
| std::string m_Label = ""; |
| std::string m_Value = ""; |
| std::string m_Hint = ""; |
| uint32_t m_HeadingLevel = 0; |
| uint32_t m_TraitFlags = 0; |
| uint32_t m_StateFlags = 0; |
| |
| public: |
| inline uint32_t role() const { return m_Role; } |
| void role(uint32_t value) |
| { |
| if (m_Role == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(rolePropertyKey, &m_Role, &value); |
| m_Role = value; |
| RIVE_EDITOR_CHANGED(roleChanged()); |
| notifyPropertyChanged(rolePropertyKey); |
| } |
| |
| inline const std::string& label() const { return m_Label; } |
| void label(std::string value) |
| { |
| if (m_Label == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_STRING_CHANGING(labelPropertyKey, m_Label, value); |
| m_Label = value; |
| RIVE_EDITOR_CHANGED(labelChanged()); |
| notifyPropertyChanged(labelPropertyKey); |
| } |
| |
| inline const std::string& value() const { return m_Value; } |
| void value(std::string value) |
| { |
| if (m_Value == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_STRING_CHANGING(valuePropertyKey, m_Value, value); |
| m_Value = value; |
| RIVE_EDITOR_CHANGED(valueChanged()); |
| notifyPropertyChanged(valuePropertyKey); |
| } |
| |
| inline const std::string& hint() const { return m_Hint; } |
| void hint(std::string value) |
| { |
| if (m_Hint == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_STRING_CHANGING(hintPropertyKey, m_Hint, value); |
| m_Hint = value; |
| RIVE_EDITOR_CHANGED(hintChanged()); |
| notifyPropertyChanged(hintPropertyKey); |
| } |
| |
| inline uint32_t headingLevel() const { return m_HeadingLevel; } |
| void headingLevel(uint32_t value) |
| { |
| if (m_HeadingLevel == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(headingLevelPropertyKey, &m_HeadingLevel, &value); |
| m_HeadingLevel = value; |
| RIVE_EDITOR_CHANGED(headingLevelChanged()); |
| notifyPropertyChanged(headingLevelPropertyKey); |
| } |
| |
| inline uint32_t traitFlags() const { return m_TraitFlags; } |
| void traitFlags(uint32_t value) |
| { |
| if (m_TraitFlags == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(traitFlagsPropertyKey, &m_TraitFlags, &value); |
| m_TraitFlags = value; |
| RIVE_EDITOR_CHANGED(traitFlagsChanged()); |
| notifyPropertyChanged(traitFlagsPropertyKey); |
| } |
| |
| inline uint32_t stateFlags() const { return m_StateFlags; } |
| void stateFlags(uint32_t value) |
| { |
| if (m_StateFlags == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(stateFlagsPropertyKey, &m_StateFlags, &value); |
| m_StateFlags = value; |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| |
| inline bool isExpandable() const |
| { |
| return (m_TraitFlags & isExpandableBitmask) != 0; |
| } |
| void isExpandable(bool value) |
| { |
| const bool prev = (m_TraitFlags & isExpandableBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isExpandablePropertyKey, &prev, &value); |
| m_TraitFlags = value ? (m_TraitFlags | isExpandableBitmask) |
| : (m_TraitFlags & ~isExpandableBitmask); |
| RIVE_EDITOR_CHANGED(traitFlagsChanged()); |
| notifyPropertyChanged(traitFlagsPropertyKey); |
| } |
| inline bool isSelectable() const |
| { |
| return (m_TraitFlags & isSelectableBitmask) != 0; |
| } |
| void isSelectable(bool value) |
| { |
| const bool prev = (m_TraitFlags & isSelectableBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isSelectablePropertyKey, &prev, &value); |
| m_TraitFlags = value ? (m_TraitFlags | isSelectableBitmask) |
| : (m_TraitFlags & ~isSelectableBitmask); |
| RIVE_EDITOR_CHANGED(traitFlagsChanged()); |
| notifyPropertyChanged(traitFlagsPropertyKey); |
| } |
| inline bool isCheckable() const |
| { |
| return (m_TraitFlags & isCheckableBitmask) != 0; |
| } |
| void isCheckable(bool value) |
| { |
| const bool prev = (m_TraitFlags & isCheckableBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isCheckablePropertyKey, &prev, &value); |
| m_TraitFlags = value ? (m_TraitFlags | isCheckableBitmask) |
| : (m_TraitFlags & ~isCheckableBitmask); |
| RIVE_EDITOR_CHANGED(traitFlagsChanged()); |
| notifyPropertyChanged(traitFlagsPropertyKey); |
| } |
| inline bool isToggleable() const |
| { |
| return (m_TraitFlags & isToggleableBitmask) != 0; |
| } |
| void isToggleable(bool value) |
| { |
| const bool prev = (m_TraitFlags & isToggleableBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isToggleablePropertyKey, &prev, &value); |
| m_TraitFlags = value ? (m_TraitFlags | isToggleableBitmask) |
| : (m_TraitFlags & ~isToggleableBitmask); |
| RIVE_EDITOR_CHANGED(traitFlagsChanged()); |
| notifyPropertyChanged(traitFlagsPropertyKey); |
| } |
| inline bool isRequirable() const |
| { |
| return (m_TraitFlags & isRequirableBitmask) != 0; |
| } |
| void isRequirable(bool value) |
| { |
| const bool prev = (m_TraitFlags & isRequirableBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isRequirablePropertyKey, &prev, &value); |
| m_TraitFlags = value ? (m_TraitFlags | isRequirableBitmask) |
| : (m_TraitFlags & ~isRequirableBitmask); |
| RIVE_EDITOR_CHANGED(traitFlagsChanged()); |
| notifyPropertyChanged(traitFlagsPropertyKey); |
| } |
| inline bool isEnablable() const |
| { |
| return (m_TraitFlags & isEnablableBitmask) != 0; |
| } |
| void isEnablable(bool value) |
| { |
| const bool prev = (m_TraitFlags & isEnablableBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isEnablablePropertyKey, &prev, &value); |
| m_TraitFlags = value ? (m_TraitFlags | isEnablableBitmask) |
| : (m_TraitFlags & ~isEnablableBitmask); |
| RIVE_EDITOR_CHANGED(traitFlagsChanged()); |
| notifyPropertyChanged(traitFlagsPropertyKey); |
| } |
| inline bool isFocusable() const |
| { |
| return (m_TraitFlags & isFocusableBitmask) != 0; |
| } |
| void isFocusable(bool value) |
| { |
| const bool prev = (m_TraitFlags & isFocusableBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isFocusablePropertyKey, &prev, &value); |
| m_TraitFlags = value ? (m_TraitFlags | isFocusableBitmask) |
| : (m_TraitFlags & ~isFocusableBitmask); |
| RIVE_EDITOR_CHANGED(traitFlagsChanged()); |
| notifyPropertyChanged(traitFlagsPropertyKey); |
| } |
| inline bool isExpanded() const |
| { |
| return (m_StateFlags & isExpandedBitmask) != 0; |
| } |
| void isExpanded(bool value) |
| { |
| const bool prev = (m_StateFlags & isExpandedBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isExpandedPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isExpandedBitmask) |
| : (m_StateFlags & ~isExpandedBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isSelected() const |
| { |
| return (m_StateFlags & isSelectedBitmask) != 0; |
| } |
| void isSelected(bool value) |
| { |
| const bool prev = (m_StateFlags & isSelectedBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isSelectedPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isSelectedBitmask) |
| : (m_StateFlags & ~isSelectedBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline uint8_t isChecked() const |
| { |
| return (m_StateFlags & isCheckedFieldMask) >> isCheckedBitOffset; |
| } |
| void isChecked(uint8_t value) |
| { |
| const uint8_t prev = |
| (m_StateFlags & isCheckedFieldMask) >> isCheckedBitOffset; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isCheckedPropertyKey, &prev, &value); |
| m_StateFlags = (m_StateFlags & ~isCheckedFieldMask) | |
| ((value << isCheckedBitOffset) & isCheckedFieldMask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isToggled() const |
| { |
| return (m_StateFlags & isToggledBitmask) != 0; |
| } |
| void isToggled(bool value) |
| { |
| const bool prev = (m_StateFlags & isToggledBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isToggledPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isToggledBitmask) |
| : (m_StateFlags & ~isToggledBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isRequired() const |
| { |
| return (m_StateFlags & isRequiredBitmask) != 0; |
| } |
| void isRequired(bool value) |
| { |
| const bool prev = (m_StateFlags & isRequiredBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isRequiredPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isRequiredBitmask) |
| : (m_StateFlags & ~isRequiredBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isDisabled() const |
| { |
| return (m_StateFlags & isDisabledBitmask) != 0; |
| } |
| void isDisabled(bool value) |
| { |
| const bool prev = (m_StateFlags & isDisabledBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isDisabledPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isDisabledBitmask) |
| : (m_StateFlags & ~isDisabledBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isFocused() const |
| { |
| return (m_StateFlags & isFocusedBitmask) != 0; |
| } |
| void isFocused(bool value) |
| { |
| const bool prev = (m_StateFlags & isFocusedBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isFocusedPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isFocusedBitmask) |
| : (m_StateFlags & ~isFocusedBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isHidden() const |
| { |
| return (m_StateFlags & isHiddenBitmask) != 0; |
| } |
| void isHidden(bool value) |
| { |
| const bool prev = (m_StateFlags & isHiddenBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isHiddenPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isHiddenBitmask) |
| : (m_StateFlags & ~isHiddenBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isLiveRegion() const |
| { |
| return (m_StateFlags & isLiveRegionBitmask) != 0; |
| } |
| void isLiveRegion(bool value) |
| { |
| const bool prev = (m_StateFlags & isLiveRegionBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isLiveRegionPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isLiveRegionBitmask) |
| : (m_StateFlags & ~isLiveRegionBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isReadOnly() const |
| { |
| return (m_StateFlags & isReadOnlyBitmask) != 0; |
| } |
| void isReadOnly(bool value) |
| { |
| const bool prev = (m_StateFlags & isReadOnlyBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isReadOnlyPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isReadOnlyBitmask) |
| : (m_StateFlags & ~isReadOnlyBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isModal() const { return (m_StateFlags & isModalBitmask) != 0; } |
| void isModal(bool value) |
| { |
| const bool prev = (m_StateFlags & isModalBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isModalPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isModalBitmask) |
| : (m_StateFlags & ~isModalBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isObscured() const |
| { |
| return (m_StateFlags & isObscuredBitmask) != 0; |
| } |
| void isObscured(bool value) |
| { |
| const bool prev = (m_StateFlags & isObscuredBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isObscuredPropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isObscuredBitmask) |
| : (m_StateFlags & ~isObscuredBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| inline bool isMultiline() const |
| { |
| return (m_StateFlags & isMultilineBitmask) != 0; |
| } |
| void isMultiline(bool value) |
| { |
| const bool prev = (m_StateFlags & isMultilineBitmask) != 0; |
| if (prev == value) |
| { |
| return; |
| } |
| RIVE_EDITOR_CHANGING(isMultilinePropertyKey, &prev, &value); |
| m_StateFlags = value ? (m_StateFlags | isMultilineBitmask) |
| : (m_StateFlags & ~isMultilineBitmask); |
| RIVE_EDITOR_CHANGED(stateFlagsChanged()); |
| notifyPropertyChanged(stateFlagsPropertyKey); |
| } |
| Core* clone() const override; |
| void copy(const SemanticDataBase& object) |
| { |
| m_Role = object.m_Role; |
| m_Label = object.m_Label; |
| m_Value = object.m_Value; |
| m_Hint = object.m_Hint; |
| m_HeadingLevel = object.m_HeadingLevel; |
| m_TraitFlags = object.m_TraitFlags; |
| m_StateFlags = object.m_StateFlags; |
| Component::copy(object); |
| } |
| |
| bool deserialize(uint16_t propertyKey, BinaryReader& reader) override |
| { |
| switch (propertyKey) |
| { |
| case rolePropertyKey: |
| m_Role = CoreUintType::deserialize(reader); |
| return true; |
| case labelPropertyKey: |
| m_Label = CoreStringType::deserialize(reader); |
| return true; |
| case valuePropertyKey: |
| m_Value = CoreStringType::deserialize(reader); |
| return true; |
| case hintPropertyKey: |
| m_Hint = CoreStringType::deserialize(reader); |
| return true; |
| case headingLevelPropertyKey: |
| m_HeadingLevel = CoreUintType::deserialize(reader); |
| return true; |
| case traitFlagsPropertyKey: |
| m_TraitFlags = CoreUintType::deserialize(reader); |
| return true; |
| case stateFlagsPropertyKey: |
| m_StateFlags = CoreUintType::deserialize(reader); |
| return true; |
| } |
| return Component::deserialize(propertyKey, reader); |
| } |
| |
| protected: |
| virtual void roleChanged() {} |
| virtual void labelChanged() {} |
| virtual void valueChanged() {} |
| virtual void hintChanged() {} |
| virtual void headingLevelChanged() {} |
| virtual void traitFlagsChanged() {} |
| virtual void stateFlagsChanged() {} |
| #ifdef WITH_RIVE_EDITOR |
| #include "editor_native/generated/semantic/semantic_data_ext.inl" |
| #endif |
| }; |
| } // namespace rive |
| |
| #endif |
