static View()
{
+#if REMOVE_READONLY_FOR_BINDABLE_PROPERTY
+ //to get "IsUsingXaml" feature working at preload, we need to remove readonly for BindableProperty.
+#else
if (NUIApplication.IsUsingXaml)
{
-#if REMOVE_READONLY
- CreateBindableProperties();
-#else
+ StyleNameProperty = BindableProperty.Create(nameof(StyleName), typeof(string), typeof(View), string.Empty,
+ propertyChanged: SetInternalStyleNameProperty, defaultValueCreator: GetInternalStyleNameProperty);
+
+ KeyInputFocusProperty = BindableProperty.Create(nameof(KeyInputFocus), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalKeyInputFocusProperty, defaultValueCreator: GetInternalKeyInputFocusProperty);
+
BackgroundColorProperty = BindableProperty.Create(nameof(BackgroundColor), typeof(Color), typeof(View), null,
propertyChanged: SetInternalBackgroundColorProperty, defaultValueCreator: GetInternalBackgroundColorProperty);
ColorBlueProperty = BindableProperty.Create(nameof(ColorBlue), typeof(float), typeof(View), default(float),
propertyChanged: SetInternalColorBlueProperty, defaultValueCreator: GetInternalColorBlueProperty);
+ BackgroundImageProperty = BindableProperty.Create(nameof(BackgroundImage), typeof(string), typeof(View), default(string),
+ propertyChanged: SetInternalBackgroundImageProperty, defaultValueCreator: GetInternalBackgroundImageProperty);
+
+ BackgroundImageBorderProperty = BindableProperty.Create(nameof(BackgroundImageBorder), typeof(Rectangle), typeof(View), default(Rectangle),
+ propertyChanged: SetInternalBackgroundImageBorderProperty, defaultValueCreator: GetInternalBackgroundImageBorderProperty);
+
+ BackgroundProperty = BindableProperty.Create(nameof(Background), typeof(PropertyMap), typeof(View), null,
+ propertyChanged: SetInternalBackgroundProperty, defaultValueCreator: GetInternalBackgroundProperty);
+
+ StateProperty = BindableProperty.Create(nameof(State), typeof(States), typeof(View), States.Normal,
+ propertyChanged: SetInternalStateProperty, defaultValueCreator: GetInternalStateProperty);
+
+ SubStateProperty = BindableProperty.Create(nameof(SubState), typeof(States), typeof(View), States.Normal,
+ propertyChanged: SetInternalSubStateProperty, defaultValueCreator: GetInternalSubStateProperty);
+
+ TooltipProperty = BindableProperty.Create(nameof(Tooltip), typeof(PropertyMap), typeof(View), null,
+ propertyChanged: SetInternalTooltipProperty, defaultValueCreator: GetInternalTooltipProperty);
+
+ FlexProperty = BindableProperty.Create(nameof(Flex), typeof(float), typeof(View), default(float),
+ propertyChanged: SetInternalFlexProperty, defaultValueCreator: GetInternalFlexProperty);
+
+ AlignSelfProperty = BindableProperty.Create(nameof(AlignSelf), typeof(int), typeof(View), default(int),
+ propertyChanged: SetInternalAlignSelfProperty, defaultValueCreator: GetInternalAlignSelfProperty);
+
+ FlexMarginProperty = BindableProperty.Create(nameof(FlexMargin), typeof(Vector4), typeof(View), null,
+ propertyChanged: SetInternalFlexMarginProperty, defaultValueCreator: GetInternalFlexMarginProperty);
+
CellIndexProperty = BindableProperty.Create(nameof(CellIndex), typeof(Vector2), typeof(View), null,
propertyChanged: SetInternalCellIndexProperty, defaultValueCreator: GetInternalCellIndexProperty);
+ RowSpanProperty = BindableProperty.Create(nameof(RowSpan), typeof(float), typeof(View), default(float),
+ propertyChanged: SetInternalRowSpanProperty, defaultValueCreator: GetInternalRowSpanProperty);
+
+ ColumnSpanProperty = BindableProperty.Create(nameof(ColumnSpan), typeof(float), typeof(View), default(float),
+ propertyChanged: SetInternalColumnSpanProperty, defaultValueCreator: GetInternalColumnSpanProperty);
+
+ CellHorizontalAlignmentProperty = BindableProperty.Create(nameof(CellHorizontalAlignment), typeof(HorizontalAlignmentType), typeof(View), HorizontalAlignmentType.Left,
+ propertyChanged: SetInternalCellHorizontalAlignmentProperty, defaultValueCreator: GetInternalCellHorizontalAlignmentProperty);
+
+ CellVerticalAlignmentProperty = BindableProperty.Create(nameof(CellVerticalAlignment), typeof(VerticalAlignmentType), typeof(View), VerticalAlignmentType.Top,
+ propertyChanged: SetInternalCellVerticalAlignmentProperty, defaultValueCreator: GetInternalCellVerticalAlignmentProperty);
+
+ WeightProperty = BindableProperty.Create(nameof(Weight), typeof(float), typeof(View), default(float),
+ propertyChanged: SetInternalWeightProperty, defaultValueCreator: GetInternalWeightProperty);
+
+ LeftFocusableViewProperty = BindableProperty.Create(nameof(View.LeftFocusableView), typeof(View), typeof(View), null,
+ propertyChanged: SetInternalLeftFocusableViewProperty, defaultValueCreator: GetInternalLeftFocusableViewProperty);
+
+ RightFocusableViewProperty = BindableProperty.Create(nameof(View.RightFocusableView), typeof(View), typeof(View), null,
+ propertyChanged: SetInternalRightFocusableViewProperty, defaultValueCreator: GetInternalRightFocusableViewProperty);
+
+ UpFocusableViewProperty = BindableProperty.Create(nameof(View.UpFocusableView), typeof(View), typeof(View), null,
+ propertyChanged: SetInternalUpFocusableViewProperty, defaultValueCreator: GetInternalUpFocusableViewProperty);
+
+ DownFocusableViewProperty = BindableProperty.Create(nameof(View.DownFocusableView), typeof(View), typeof(View), null,
+ propertyChanged: SetInternalDownFocusableViewProperty, defaultValueCreator: GetInternalDownFocusableViewProperty);
+
+ ClockwiseFocusableViewProperty = BindableProperty.Create(nameof(View.ClockwiseFocusableView), typeof(View), typeof(View), null,
+ propertyChanged: SetInternalClockwiseFocusableViewProperty, defaultValueCreator: GetInternalClockwiseFocusableViewProperty);
+
+ CounterClockwiseFocusableViewProperty = BindableProperty.Create(nameof(View.CounterClockwiseFocusableView), typeof(View), typeof(View), null,
+ propertyChanged: SetInternalCounterClockwiseFocusableViewProperty, defaultValueCreator: GetInternalCounterClockwiseFocusableViewProperty);
+
+ FocusableProperty = BindableProperty.Create(nameof(Focusable), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalFocusableProperty, defaultValueCreator: GetInternalFocusableProperty);
+
+ FocusableChildrenProperty = BindableProperty.Create(nameof(FocusableChildren), typeof(bool), typeof(View), true,
+ propertyChanged: SetInternalFocusableChildrenProperty, defaultValueCreator: GetInternalFocusableChildrenProperty);
+
+ FocusableInTouchProperty = BindableProperty.Create(nameof(FocusableInTouch), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalFocusableInTouchProperty, defaultValueCreator: GetInternalFocusableInTouchProperty);
+
Size2DProperty = BindableProperty.Create(nameof(Size2D), typeof(Size2D), typeof(View), null,
propertyChanged: SetInternalSize2DProperty, defaultValueCreator: GetInternalSize2DProperty);
+ OpacityProperty = BindableProperty.Create(nameof(Opacity), typeof(float), typeof(View), default(float),
+ propertyChanged: SetInternalOpacityProperty, defaultValueCreator: GetInternalOpacityProperty);
+
Position2DProperty = BindableProperty.Create(nameof(Position2D), typeof(Position2D), typeof(View), null,
propertyChanged: SetInternalPosition2DProperty, defaultValueCreator: GetInternalPosition2DProperty);
+ PositionUsesPivotPointProperty = BindableProperty.Create(nameof(PositionUsesPivotPoint), typeof(bool), typeof(View), true,
+ propertyChanged: SetInternalPositionUsesPivotPointProperty, defaultValueCreator: GetInternalPositionUsesPivotPointProperty);
+
+ SiblingOrderProperty = BindableProperty.Create(nameof(SiblingOrder), typeof(int), typeof(View), default(int),
+ propertyChanged: SetInternalSiblingOrderProperty, defaultValueCreator: GetInternalSiblingOrderProperty);
+
ParentOriginProperty = BindableProperty.Create(nameof(ParentOrigin), typeof(Position), typeof(View), null,
propertyChanged: SetInternalParentOriginProperty, defaultValueCreator: GetInternalParentOriginProperty);
PositionZProperty = BindableProperty.Create(nameof(PositionZ), typeof(float), typeof(View), default(float),
propertyChanged: SetInternalPositionZProperty, defaultValueCreator: GetInternalPositionZProperty);
+ OrientationProperty = BindableProperty.Create(nameof(Orientation), typeof(Rotation), typeof(View), null,
+ propertyChanged: SetInternalOrientationProperty, defaultValueCreator: GetInternalOrientationProperty);
+
ScaleProperty = BindableProperty.Create(nameof(Scale), typeof(Vector3), typeof(View), null,
propertyChanged: SetInternalScaleProperty, defaultValueCreator: GetInternalScaleProperty);
NameProperty = BindableProperty.Create(nameof(Name), typeof(string), typeof(View), string.Empty,
propertyChanged: SetInternalNameProperty, defaultValueCreator: GetInternalNameProperty);
+ SensitiveProperty = BindableProperty.Create(nameof(Sensitive), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalSensitiveProperty, defaultValueCreator: GetInternalSensitiveProperty);
+
+ IsEnabledProperty = BindableProperty.Create(nameof(IsEnabled), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalIsEnabledProperty, defaultValueCreator: GetInternalIsEnabledProperty);
+
+ DispatchKeyEventsProperty = BindableProperty.Create(nameof(DispatchKeyEvents), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalDispatchKeyEventsProperty, defaultValueCreator: GetInternalDispatchKeyEventsProperty);
+
+ LeaveRequiredProperty = BindableProperty.Create(nameof(LeaveRequired), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalLeaveRequiredProperty, defaultValueCreator: GetInternalLeaveRequiredProperty);
+
+ InheritOrientationProperty = BindableProperty.Create(nameof(InheritOrientation), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalInheritOrientationProperty, defaultValueCreator: GetInternalInheritOrientationProperty);
+
+ InheritScaleProperty = BindableProperty.Create(nameof(InheritScale), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalInheritScaleProperty, defaultValueCreator: GetInternalInheritScaleProperty);
+
+ DrawModeProperty = BindableProperty.Create(nameof(DrawMode), typeof(DrawModeType), typeof(View), DrawModeType.Normal,
+ propertyChanged: SetInternalDrawModeProperty, defaultValueCreator: GetInternalDrawModeProperty);
+
SizeModeFactorProperty = BindableProperty.Create(nameof(SizeModeFactor), typeof(Vector3), typeof(View), null,
propertyChanged: SetInternalSizeModeFactorProperty, defaultValueCreator: GetInternalSizeModeFactorProperty);
+ WidthResizePolicyProperty = BindableProperty.Create(nameof(WidthResizePolicy), typeof(ResizePolicyType), typeof(View), ResizePolicyType.Fixed,
+ propertyChanged: SetInternalWidthResizePolicyProperty, defaultValueCreator: GetInternalWidthResizePolicyProperty);
+
+ HeightResizePolicyProperty = BindableProperty.Create(nameof(HeightResizePolicy), typeof(ResizePolicyType), typeof(View), ResizePolicyType.Fixed,
+ propertyChanged: SetInternalHeightResizePolicyProperty, defaultValueCreator: GetInternalHeightResizePolicyProperty);
+
+ SizeScalePolicyProperty = BindableProperty.Create(nameof(SizeScalePolicy), typeof(SizeScalePolicyType), typeof(View), SizeScalePolicyType.UseSizeSet,
+ propertyChanged: SetInternalSizeScalePolicyProperty, defaultValueCreator: GetInternalSizeScalePolicyProperty);
+
+ WidthForHeightProperty = BindableProperty.Create(nameof(WidthForHeight), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalWidthForHeightProperty, defaultValueCreator: GetInternalWidthForHeightProperty);
+
+ HeightForWidthProperty = BindableProperty.Create(nameof(HeightForWidth), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalHeightForWidthProperty, defaultValueCreator: GetInternalHeightForWidthProperty);
+
PaddingProperty = BindableProperty.Create(nameof(Padding), typeof(Extents), typeof(View), null,
propertyChanged: SetInternalPaddingProperty, defaultValueCreator: GetInternalPaddingProperty);
MaximumSizeProperty = BindableProperty.Create(nameof(MaximumSize), typeof(Size2D), typeof(View), null,
propertyChanged: SetInternalMaximumSizeProperty, defaultValueCreator: GetInternalMaximumSizeProperty);
+ InheritPositionProperty = BindableProperty.Create(nameof(InheritPosition), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalInheritPositionProperty, defaultValueCreator: GetInternalInheritPositionProperty);
+
+ ClippingModeProperty = BindableProperty.Create(nameof(ClippingMode), typeof(ClippingModeType), typeof(View), ClippingModeType.Disabled,
+ propertyChanged: SetInternalClippingModeProperty, defaultValueCreator: GetInternalClippingModeProperty);
+
+ InheritLayoutDirectionProperty = BindableProperty.Create(nameof(InheritLayoutDirection), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalInheritLayoutDirectionProperty, defaultValueCreator: GetInternalInheritLayoutDirectionProperty);
+
+ LayoutDirectionProperty = BindableProperty.Create(nameof(LayoutDirection), typeof(ViewLayoutDirectionType), typeof(View), ViewLayoutDirectionType.LTR,
+ propertyChanged: SetInternalLayoutDirectionProperty, defaultValueCreator: GetInternalLayoutDirectionProperty);
+
MarginProperty = BindableProperty.Create(nameof(Margin), typeof(Extents), typeof(View), null,
propertyChanged: SetInternalMarginProperty, defaultValueCreator: GetInternalMarginProperty);
+ UpdateAreaHintProperty = BindableProperty.Create(nameof(UpdateAreaHint), typeof(Vector4), typeof(View), null,
+ propertyChanged: SetInternalUpdateAreaHintProperty, defaultValueCreator: GetInternalUpdateAreaHintProperty);
+
+ ImageShadowProperty = BindableProperty.Create(nameof(ImageShadow), typeof(ImageShadow), typeof(View), null,
+ propertyChanged: SetInternalImageShadowProperty, defaultValueCreator: GetInternalImageShadowProperty);
+
+ BoxShadowProperty = BindableProperty.Create(nameof(BoxShadow), typeof(Shadow), typeof(View), null,
+ propertyChanged: SetInternalBoxShadowProperty, defaultValueCreator: GetInternalBoxShadowProperty);
+
+ CornerRadiusProperty = BindableProperty.Create(nameof(CornerRadius), typeof(Vector4), typeof(View), null,
+ propertyChanged: SetInternalCornerRadiusProperty, defaultValueCreator: GetInternalCornerRadiusProperty);
+
+ CornerRadiusPolicyProperty = BindableProperty.Create(nameof(CornerRadiusPolicy), typeof(VisualTransformPolicyType), typeof(View), VisualTransformPolicyType.Absolute,
+ propertyChanged: SetInternalCornerRadiusPolicyProperty, defaultValueCreator: GetInternalCornerRadiusPolicyProperty);
+
+ BorderlineWidthProperty = BindableProperty.Create(nameof(BorderlineWidth), typeof(float), typeof(View), default(float),
+ propertyChanged: SetInternalBorderlineWidthProperty, defaultValueCreator: GetInternalBorderlineWidthProperty);
+
+ BorderlineColorProperty = BindableProperty.Create(nameof(BorderlineColor), typeof(Color), typeof(View), null,
+ propertyChanged: SetInternalBorderlineColorProperty, defaultValueCreator: GetInternalBorderlineColorProperty);
+
+ BorderlineColorSelectorProperty = BindableProperty.Create(nameof(BorderlineColorSelector), typeof(Selector<Color>), typeof(View), null,
+ propertyChanged: SetInternalBorderlineColorSelectorProperty, defaultValueCreator: GetInternalBorderlineColorSelectorProperty);
+
+ BorderlineOffsetProperty = BindableProperty.Create(nameof(BorderlineOffset), typeof(float), typeof(View), default(float),
+ propertyChanged: SetInternalBorderlineOffsetProperty, defaultValueCreator: GetInternalBorderlineOffsetProperty);
+
+ EnableControlStateProperty = BindableProperty.Create(nameof(EnableControlState), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalEnableControlStateProperty, defaultValueCreator: GetInternalEnableControlStateProperty);
+
+ ThemeChangeSensitiveProperty = BindableProperty.Create(nameof(ThemeChangeSensitive), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalThemeChangeSensitiveProperty, defaultValueCreator: GetInternalThemeChangeSensitiveProperty);
+
+ AccessibilityNameProperty = BindableProperty.Create(nameof(AccessibilityName), typeof(string), typeof(View), string.Empty,
+ propertyChanged: SetInternalAccessibilityNameProperty, defaultValueCreator: GetInternalAccessibilityNameProperty);
+
+ AccessibilityDescriptionProperty = BindableProperty.Create(nameof(AccessibilityDescription), typeof(string), typeof(View), string.Empty,
+ propertyChanged: SetInternalAccessibilityDescriptionProperty, defaultValueCreator: GetInternalAccessibilityDescriptionProperty);
+
+ AccessibilityTranslationDomainProperty = BindableProperty.Create(nameof(AccessibilityTranslationDomain), typeof(string), typeof(View), string.Empty,
+ propertyChanged: SetInternalAccessibilityTranslationDomainProperty, defaultValueCreator: GetInternalAccessibilityTranslationDomainProperty);
+
+ AccessibilityRoleProperty = BindableProperty.Create(nameof(AccessibilityRole), typeof(Role), typeof(View), default(Role),
+ propertyChanged: SetInternalAccessibilityRoleProperty, defaultValueCreator: GetInternalAccessibilityRoleProperty);
+
+ AccessibilityHighlightableProperty = BindableProperty.Create(nameof(AccessibilityHighlightable), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalAccessibilityHighlightableProperty, defaultValueCreator: GetInternalAccessibilityHighlightableProperty);
+
+ AccessibilityHiddenProperty = BindableProperty.Create(nameof(AccessibilityHidden), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalAccessibilityHiddenProperty, defaultValueCreator: GetInternalAccessibilityHiddenProperty);
+
+ ExcludeLayoutingProperty = BindableProperty.Create(nameof(ExcludeLayouting), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalExcludeLayoutingProperty, defaultValueCreator: GetInternalExcludeLayoutingProperty);
+
+ TooltipTextProperty = BindableProperty.Create(nameof(TooltipText), typeof(string), typeof(View), string.Empty,
+ propertyChanged: SetInternalTooltipTextProperty, defaultValueCreator: GetInternalTooltipTextProperty);
+
+ PositionUsesAnchorPointProperty = BindableProperty.Create(nameof(PositionUsesAnchorPoint), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalPositionUsesAnchorPointProperty, defaultValueCreator: GetInternalPositionUsesAnchorPointProperty);
+
AnchorPointProperty = BindableProperty.Create(nameof(AnchorPoint), typeof(Tizen.NUI.Position), typeof(View), null,
propertyChanged: SetInternalAnchorPointProperty, defaultValueCreator: GetInternalAnchorPointProperty);
-#endif
+
+ WidthSpecificationProperty = BindableProperty.Create(nameof(WidthSpecification), typeof(int), typeof(View), 0,
+ propertyChanged: SetInternalWidthSpecificationProperty, defaultValueCreator: GetInternalWidthSpecificationProperty);
+
+ HeightSpecificationProperty = BindableProperty.Create(nameof(HeightSpecification), typeof(int), typeof(View), 0,
+ propertyChanged: SetInternalHeightSpecificationProperty, defaultValueCreator: GetInternalHeightSpecificationProperty);
+
+ LayoutTransitionProperty = BindableProperty.Create(nameof(LayoutTransition), typeof(Tizen.NUI.LayoutTransition), typeof(View), null,
+ propertyChanged: SetInternalLayoutTransitionProperty, defaultValueCreator: GetInternalLayoutTransitionProperty);
+
+ PaddingEXProperty = BindableProperty.Create(nameof(PaddingEX), typeof(Tizen.NUI.Extents), typeof(View), null,
+ propertyChanged: SetInternalPaddingEXProperty, defaultValueCreator: GetInternalPaddingEXProperty);
+
+ LayoutProperty = BindableProperty.Create(nameof(Layout), typeof(Tizen.NUI.LayoutItem), typeof(View), null,
+ propertyChanged: SetInternalLayoutProperty, defaultValueCreator: GetInternalLayoutProperty);
+
+ BackgroundImageSynchronosLoadingProperty = BindableProperty.Create(nameof(BackgroundImageSynchronosLoading), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalBackgroundImageSynchronosLoadingProperty, defaultValueCreator: GetInternalBackgroundImageSynchronosLoadingProperty);
+
+ BackgroundImageSynchronousLoadingProperty = BindableProperty.Create(nameof(BackgroundImageSynchronousLoading), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalBackgroundImageSynchronousLoadingProperty, defaultValueCreator: GetInternalBackgroundImageSynchronousLoadingProperty);
+
+ EnableControlStatePropagationProperty = BindableProperty.Create(nameof(EnableControlStatePropagation), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalEnableControlStatePropagationProperty, defaultValueCreator: GetInternalEnableControlStatePropagationProperty);
+
+ PropagatableControlStatesProperty = BindableProperty.Create(nameof(PropagatableControlStates), typeof(ControlState), typeof(View), ControlState.All,
+ propertyChanged: SetInternalPropagatableControlStatesProperty, defaultValueCreator: GetInternalPropagatableControlStatesProperty);
+
+ GrabTouchAfterLeaveProperty = BindableProperty.Create(nameof(GrabTouchAfterLeave), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalGrabTouchAfterLeaveProperty, defaultValueCreator: GetInternalGrabTouchAfterLeaveProperty);
+
+ AllowOnlyOwnTouchProperty = BindableProperty.Create(nameof(AllowOnlyOwnTouch), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalAllowOnlyOwnTouchProperty, defaultValueCreator: GetInternalAllowOnlyOwnTouchProperty);
+
+ BlendEquationProperty = BindableProperty.Create(nameof(BlendEquation), typeof(BlendEquationType), typeof(View), default(BlendEquationType),
+ propertyChanged: SetInternalBlendEquationProperty, defaultValueCreator: GetInternalBlendEquationProperty);
+
+ TransitionOptionsProperty = BindableProperty.Create(nameof(TransitionOptions), typeof(TransitionOptions), typeof(View), default(TransitionOptions),
+ propertyChanged: SetInternalTransitionOptionsProperty, defaultValueCreator: GetInternalTransitionOptionsProperty);
+
+ AutomationIdProperty = BindableProperty.Create(nameof(AutomationId), typeof(string), typeof(View), string.Empty,
+ propertyChanged: SetInternalAutomationIdProperty, defaultValueCreator: GetInternalAutomationIdProperty);
+
+ TouchAreaOffsetProperty = BindableProperty.Create(nameof(TouchAreaOffset), typeof(Offset), typeof(View), default(Offset),
+ propertyChanged: SetInternalTouchAreaOffsetProperty, defaultValueCreator: GetInternalTouchAreaOffsetProperty);
+
+ DispatchTouchMotionProperty = BindableProperty.Create(nameof(DispatchTouchMotion), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalDispatchTouchMotionProperty, defaultValueCreator: GetInternalDispatchTouchMotionProperty);
+
+ DispatchHoverMotionProperty = BindableProperty.Create(nameof(DispatchHoverMotion), typeof(bool), typeof(View), false,
+ propertyChanged: SetInternalDispatchHoverMotionProperty, defaultValueCreator: GetInternalDispatchHoverMotionProperty);
RegisterPropertyGroup(PositionProperty, positionPropertyGroup);
RegisterPropertyGroup(Position2DProperty, positionPropertyGroup);
RegisterPropertyGroup(ScaleYProperty, scalePropertyGroup);
RegisterPropertyGroup(ScaleZProperty, scalePropertyGroup);
}
-
- RegisterAccessibilityDelegate();
+#endif
}
static internal new void Preload()
{
Container.Preload();
- if (NUIApplication.IsUsingXaml)
- {
- // Do nothing. Just call for load static values.
- var temporalPositionPropertyGroup = positionPropertyGroup;
- var temporalSizePropertyGroup = sizePropertyGroup;
- var temporalScalePropertyGroup = scalePropertyGroup;
- }
+ // not needed, at preload, APP can not set the "IsUsingXaml" flag, it have the default value at preload
+ // if (NUIApplication.IsUsingXaml)
+ // {
+ // // Do nothing. Just call for load static values.
+ // var temporalPositionPropertyGroup = positionPropertyGroup;
+ // var temporalSizePropertyGroup = sizePropertyGroup;
+ // var temporalScalePropertyGroup = scalePropertyGroup;
+ // }
}
/// <summary>
{
get
{
- return (bool)GetValue(ExcludeLayoutingProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(ExcludeLayoutingProperty);
+ }
+ else
+ {
+ return (bool)GetInternalExcludeLayoutingProperty(this);
+ }
}
set
{
- SetValue(ExcludeLayoutingProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(ExcludeLayoutingProperty, value);
+ }
+ else
+ {
+ SetInternalExcludeLayoutingProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (string)GetValue(StyleNameProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (string)GetValue(StyleNameProperty);
+ }
+ else
+ {
+ return (string)GetInternalStyleNameProperty(this);
+ }
}
set
{
- SetValue(StyleNameProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(StyleNameProperty, value);
+ }
+ else
+ {
+ SetInternalStyleNameProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(KeyInputFocusProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(KeyInputFocusProperty);
+ }
+ else
+ {
+ return (bool)GetInternalKeyInputFocusProperty(this);
+ }
}
set
{
- SetValue(KeyInputFocusProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(KeyInputFocusProperty, value);
+ }
+ else
+ {
+ SetInternalKeyInputFocusProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (string)GetValue(BackgroundImageProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (string)GetValue(BackgroundImageProperty);
+ }
+ else
+ {
+ return (string)GetInternalBackgroundImageProperty(this);
+ }
}
set
{
- SetValue(BackgroundImageProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BackgroundImageProperty, value);
+ }
+ else
+ {
+ SetInternalBackgroundImageProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (Rectangle)GetValue(BackgroundImageBorderProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (Rectangle)GetValue(BackgroundImageBorderProperty);
+ }
+ else
+ {
+ return (Rectangle)GetInternalBackgroundImageBorderProperty(this);
+ }
}
set
{
- SetValue(BackgroundImageBorderProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BackgroundImageBorderProperty, value);
+ }
+ else
+ {
+ SetInternalBackgroundImageBorderProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (PropertyMap)GetValue(BackgroundProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (PropertyMap)GetValue(BackgroundProperty);
+ }
+ else
+ {
+ return (PropertyMap)GetInternalBackgroundProperty(this);
+ }
}
set
{
- SetValue(BackgroundProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BackgroundProperty, value);
+ }
+ else
+ {
+ SetInternalBackgroundProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (ImageShadow)GetValue(ImageShadowProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (ImageShadow)GetValue(ImageShadowProperty);
+ }
+ else
+ {
+ return (ImageShadow)GetInternalImageShadowProperty(this);
+ }
}
set
{
- SetValue(ImageShadowProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(ImageShadowProperty, value);
+ }
+ else
+ {
+ SetInternalImageShadowProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (Shadow)GetValue(BoxShadowProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (Shadow)GetValue(BoxShadowProperty);
+ }
+ else
+ {
+ return (Shadow)GetInternalBoxShadowProperty(this);
+ }
}
set
{
- SetValue(BoxShadowProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BoxShadowProperty, value);
+ }
+ else
+ {
+ SetInternalBoxShadowProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (Vector4)GetValue(CornerRadiusProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (Vector4)GetValue(CornerRadiusProperty);
+ }
+ else
+ {
+ return (Vector4)GetInternalCornerRadiusProperty(this);
+ }
}
set
{
- SetValue(CornerRadiusProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(CornerRadiusProperty, value);
+ }
+ else
+ {
+ SetInternalCornerRadiusProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
/// <since_tizen> 9 </since_tizen>
public VisualTransformPolicyType CornerRadiusPolicy
{
- get => (VisualTransformPolicyType)GetValue(CornerRadiusPolicyProperty);
- set => SetValue(CornerRadiusPolicyProperty, value);
+ get
+ {
+
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (VisualTransformPolicyType)GetValue(CornerRadiusPolicyProperty);
+ }
+ else
+ {
+ return (VisualTransformPolicyType)GetInternalCornerRadiusPolicyProperty(this);
+ }
+ }
+ set
+ {
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(CornerRadiusPolicyProperty, value);
+ }
+ else
+ {
+ SetInternalCornerRadiusPolicyProperty(this, null, value);
+ }
+ }
}
/// <summary>
{
get
{
- return (float)GetValue(BorderlineWidthProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (float)GetValue(BorderlineWidthProperty);
+ }
+ else
+ {
+ return (float)GetInternalBorderlineWidthProperty(this);
+ }
}
set
{
- SetValue(BorderlineWidthProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BorderlineWidthProperty, value);
+ }
+ else
+ {
+ SetInternalBorderlineWidthProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (Color)GetValue(BorderlineColorProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (Color)GetValue(BorderlineColorProperty);
+ }
+ else
+ {
+ return (Color)GetInternalBorderlineColorProperty(this);
+ }
}
set
{
- SetValue(BorderlineColorProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BorderlineColorProperty, value);
+ }
+ else
+ {
+ SetInternalBorderlineColorProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (Selector<Color>)GetValue(BorderlineColorSelectorProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (Selector<Color>)GetValue(BorderlineColorSelectorProperty);
+ }
+ else
+ {
+ return (Selector<Color>)GetInternalBorderlineColorSelectorProperty(this);
+ }
}
set
{
- SetValue(BorderlineColorSelectorProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BorderlineColorSelectorProperty, value);
+ }
+ else
+ {
+ SetInternalBorderlineColorSelectorProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (float)GetValue(BorderlineOffsetProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (float)GetValue(BorderlineOffsetProperty);
+ }
+ else
+ {
+ return (float)GetInternalBorderlineOffsetProperty(this);
+ }
}
set
{
- SetValue(BorderlineOffsetProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BorderlineOffsetProperty, value);
+ }
+ else
+ {
+ SetInternalBorderlineOffsetProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (States)GetValue(StateProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (States)GetValue(StateProperty);
+ }
+ else
+ {
+ return (States)GetInternalStateProperty(this);
+ }
}
set
{
- SetValue(StateProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(StateProperty, value);
+ }
+ else
+ {
+ SetInternalStateProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (States)GetValue(SubStateProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (States)GetValue(SubStateProperty);
+ }
+ else
+ {
+ return (States)GetInternalSubStateProperty(this);
+ }
}
set
{
- SetValue(SubStateProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(SubStateProperty, value);
+ }
+ else
+ {
+ SetInternalSubStateProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (PropertyMap)GetValue(TooltipProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (PropertyMap)GetValue(TooltipProperty);
+ }
+ else
+ {
+ return (PropertyMap)GetInternalTooltipProperty(this);
+ }
}
set
{
- SetValue(TooltipProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(TooltipProperty, value);
+ }
+ else
+ {
+ SetInternalTooltipProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return GetValue(TooltipTextProperty) as string;
+ if (NUIApplication.IsUsingXaml)
+ {
+ return GetValue(TooltipTextProperty) as string;
+ }
+ else
+ {
+ return GetInternalTooltipTextProperty(this) as string;
+ }
}
set
{
- SetValue(TooltipTextProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(TooltipTextProperty, value);
+ }
+ else
+ {
+ SetInternalTooltipTextProperty(this, null, value);
+ }
}
}
{
get
{
- return (float)GetValue(FlexProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (float)GetValue(FlexProperty);
+ }
+ else
+ {
+ return (float)GetInternalFlexProperty(this);
+ }
}
set
{
- SetValue(FlexProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(FlexProperty, value);
+ }
+ else
+ {
+ SetInternalFlexProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (int)GetValue(AlignSelfProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (int)GetValue(AlignSelfProperty);
+ }
+ else
+ {
+ return (int)GetInternalAlignSelfProperty(this);
+ }
}
set
{
- SetValue(AlignSelfProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(AlignSelfProperty, value);
+ }
+ else
+ {
+ SetInternalAlignSelfProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- Vector4 temp = (Vector4)GetValue(FlexMarginProperty);
- return new Vector4(OnFlexMarginChanged, temp.X, temp.Y, temp.Z, temp.W);
+ if (NUIApplication.IsUsingXaml)
+ {
+ Vector4 temp = (Vector4)GetValue(FlexMarginProperty);
+ return new Vector4(OnFlexMarginChanged, temp.X, temp.Y, temp.Z, temp.W);
+ }
+ else
+ {
+ Vector4 temp = (Vector4)GetInternalFlexMarginProperty(this);
+ return new Vector4(OnFlexMarginChanged, temp.X, temp.Y, temp.Z, temp.W);
+ }
}
set
{
- SetValue(FlexMarginProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(FlexMarginProperty, value);
+ }
+ else
+ {
+ SetInternalFlexMarginProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (float)GetValue(RowSpanProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (float)GetValue(RowSpanProperty);
+ }
+ else
+ {
+ return (float)GetInternalRowSpanProperty(this);
+ }
}
set
{
- SetValue(RowSpanProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(RowSpanProperty, value);
+ }
+ else
+ {
+ SetInternalRowSpanProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (float)GetValue(ColumnSpanProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (float)GetValue(ColumnSpanProperty);
+ }
+ else
+ {
+ return (float)GetInternalColumnSpanProperty(this);
+ }
}
set
{
- SetValue(ColumnSpanProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(ColumnSpanProperty, value);
+ }
+ else
+ {
+ SetInternalColumnSpanProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (HorizontalAlignmentType)GetValue(CellHorizontalAlignmentProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (HorizontalAlignmentType)GetValue(CellHorizontalAlignmentProperty);
+ }
+ else
+ {
+ return (HorizontalAlignmentType)GetInternalCellHorizontalAlignmentProperty(this);
+ }
}
set
{
- SetValue(CellHorizontalAlignmentProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(CellHorizontalAlignmentProperty, value);
+ }
+ else
+ {
+ SetInternalCellHorizontalAlignmentProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (VerticalAlignmentType)GetValue(CellVerticalAlignmentProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (VerticalAlignmentType)GetValue(CellVerticalAlignmentProperty);
+ }
+ else
+ {
+ return (VerticalAlignmentType)GetInternalCellVerticalAlignmentProperty(this);
+ }
}
set
{
- SetValue(CellVerticalAlignmentProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(CellVerticalAlignmentProperty, value);
+ }
+ else
+ {
+ SetInternalCellVerticalAlignmentProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- return (View)GetValue(LeftFocusableViewProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (View)GetValue(LeftFocusableViewProperty);
+ }
+ else
+ {
+ return (View)GetInternalLeftFocusableViewProperty(this);
+ }
}
set
{
- SetValue(LeftFocusableViewProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(LeftFocusableViewProperty, value);
+ }
+ else
+ {
+ SetInternalLeftFocusableViewProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- return (View)GetValue(RightFocusableViewProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (View)GetValue(RightFocusableViewProperty);
+ }
+ else
+ {
+ return (View)GetInternalRightFocusableViewProperty(this);
+ }
}
set
{
- SetValue(RightFocusableViewProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(RightFocusableViewProperty, value);
+ }
+ else
+ {
+ SetInternalRightFocusableViewProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- return (View)GetValue(UpFocusableViewProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (View)GetValue(UpFocusableViewProperty);
+ }
+ else
+ {
+ return (View)GetInternalUpFocusableViewProperty(this);
+ }
}
set
{
- SetValue(UpFocusableViewProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(UpFocusableViewProperty, value);
+ }
+ else
+ {
+ SetInternalUpFocusableViewProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- return (View)GetValue(DownFocusableViewProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (View)GetValue(DownFocusableViewProperty);
+ }
+ else
+ {
+ return (View)GetInternalDownFocusableViewProperty(this);
+ }
}
set
{
- SetValue(DownFocusableViewProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(DownFocusableViewProperty, value);
+ }
+ else
+ {
+ SetInternalDownFocusableViewProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- return (View)GetValue(ClockwiseFocusableViewProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (View)GetValue(ClockwiseFocusableViewProperty);
+ }
+ else
+ {
+ return (View)GetInternalClockwiseFocusableViewProperty(this);
+ }
}
set
{
- SetValue(ClockwiseFocusableViewProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(ClockwiseFocusableViewProperty, value);
+ }
+ else
+ {
+ SetInternalClockwiseFocusableViewProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- return (View)GetValue(CounterClockwiseFocusableViewProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (View)GetValue(CounterClockwiseFocusableViewProperty);
+ }
+ else
+ {
+ return (View)GetInternalCounterClockwiseFocusableViewProperty(this);
+ }
}
set
{
- SetValue(CounterClockwiseFocusableViewProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(CounterClockwiseFocusableViewProperty, value);
+ }
+ else
+ {
+ SetInternalCounterClockwiseFocusableViewProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
/// <since_tizen> 3 </since_tizen>
public bool Focusable
{
- set
+ get
{
- SetValue(FocusableProperty, value);
- NotifyPropertyChanged();
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(FocusableProperty);
+ }
+ else
+ {
+ return (bool)GetInternalFocusableProperty(this);
+ }
}
- get
+ set
{
- return (bool)GetValue(FocusableProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(FocusableProperty, value);
+ }
+ else
+ {
+ SetInternalFocusableProperty(this, null, value);
+ }
+ NotifyPropertyChanged();
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
public bool FocusableChildren
{
- set
+ get
{
- SetValue(FocusableChildrenProperty, value);
- NotifyPropertyChanged();
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(FocusableChildrenProperty);
+ }
+ else
+ {
+ return (bool)GetInternalFocusableChildrenProperty(this);
+ }
}
- get
+ set
{
- return (bool)GetValue(FocusableChildrenProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(FocusableChildrenProperty, value);
+ }
+ else
+ {
+ SetInternalFocusableChildrenProperty(this, null, value);
+ }
+ NotifyPropertyChanged();
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
public bool FocusableInTouch
{
- set
+ get
{
- SetValue(FocusableInTouchProperty, value);
- NotifyPropertyChanged();
+
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(FocusableInTouchProperty);
+ }
+ else
+ {
+ return (bool)GetInternalFocusableInTouchProperty(this);
+ }
}
- get
+ set
{
- return (bool)GetValue(FocusableInTouchProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(FocusableInTouchProperty, value);
+ }
+ else
+ {
+ SetInternalFocusableInTouchProperty(this, null, value);
+ }
+ NotifyPropertyChanged();
}
}
{
get
{
- return (float)GetValue(OpacityProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (float)GetValue(OpacityProperty);
+ }
+ else
+ {
+ return (float)GetInternalOpacityProperty(this);
+ }
}
set
{
- SetValue(OpacityProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(OpacityProperty, value);
+ }
+ else
+ {
+ SetInternalOpacityProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(PositionUsesPivotPointProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(PositionUsesPivotPointProperty);
+ }
+ else
+ {
+ return (bool)GetInternalPositionUsesPivotPointProperty(this);
+ }
}
set
{
- SetValue(PositionUsesPivotPointProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(PositionUsesPivotPointProperty, value);
+ }
+ else
+ {
+ SetInternalPositionUsesPivotPointProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(PositionUsesAnchorPointProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(PositionUsesAnchorPointProperty);
+ }
+ else
+ {
+ return (bool)GetInternalPositionUsesAnchorPointProperty(this);
+ }
}
set
{
- SetValue(PositionUsesAnchorPointProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(PositionUsesAnchorPointProperty, value);
+ }
+ else
+ {
+ SetInternalPositionUsesAnchorPointProperty(this, null, value);
+ }
}
}
{
get
{
- return (int)GetValue(SiblingOrderProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (int)GetValue(SiblingOrderProperty);
+ }
+ else
+ {
+ return (int)GetInternalSiblingOrderProperty(this);
+ }
}
set
{
- SetValue(SiblingOrderProperty, value);
-
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(SiblingOrderProperty, value);
+ }
+ else
+ {
+ SetInternalSiblingOrderProperty(this, null, value);
+ }
Layout?.ChangeLayoutSiblingOrder(value);
-
NotifyPropertyChanged();
}
}
{
return (Position)GetInternalPivotPointProperty(this);
}
-
-
}
set
{
{
SetInternalPivotPointProperty(this, null, value);
}
-
NotifyPropertyChanged();
}
}
{
return (float)GetInternalPositionZProperty(this);
}
-
-
}
set
{
{
SetInternalPositionZProperty(this, null, value);
}
-
NotifyPropertyChanged();
}
}
{
get
{
- return (Rotation)GetValue(OrientationProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (Rotation)GetValue(OrientationProperty);
+ }
+ else
+ {
+ return (Rotation)GetInternalOrientationProperty(this);
+ }
}
set
{
- SetValue(OrientationProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(OrientationProperty, value);
+ }
+ else
+ {
+ SetInternalOrientationProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(SensitiveProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(SensitiveProperty);
+ }
+ else
+ {
+ return (bool)GetInternalSensitiveProperty(this);
+ }
}
set
{
- SetValue(SensitiveProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(SensitiveProperty, value);
+ }
+ else
+ {
+ SetInternalSensitiveProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(IsEnabledProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(IsEnabledProperty);
+ }
+ else
+ {
+ return (bool)GetInternalIsEnabledProperty(this);
+ }
}
set
{
- SetValue(IsEnabledProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(IsEnabledProperty, value);
+ }
+ else
+ {
+ SetInternalIsEnabledProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(LeaveRequiredProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(LeaveRequiredProperty);
+ }
+ else
+ {
+ return (bool)GetInternalLeaveRequiredProperty(this);
+ }
}
set
{
- SetValue(LeaveRequiredProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(LeaveRequiredProperty, value);
+ }
+ else
+ {
+ SetInternalLeaveRequiredProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(InheritOrientationProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(InheritOrientationProperty);
+ }
+ else
+ {
+ return (bool)GetInternalInheritOrientationProperty(this);
+ }
}
set
{
- SetValue(InheritOrientationProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(InheritOrientationProperty, value);
+ }
+ else
+ {
+ SetInternalInheritOrientationProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(InheritScaleProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(InheritScaleProperty);
+ }
+ else
+ {
+ return (bool)GetInternalInheritScaleProperty(this);
+ }
}
set
{
- SetValue(InheritScaleProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(InheritScaleProperty, value);
+ }
+ else
+ {
+ SetInternalInheritScaleProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (DrawModeType)GetValue(DrawModeProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (DrawModeType)GetValue(DrawModeProperty);
+ }
+ else
+ {
+ return (DrawModeType)GetInternalDrawModeProperty(this);
+ }
}
set
{
- SetValue(DrawModeProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(DrawModeProperty, value);
+ }
+ else
+ {
+ SetInternalDrawModeProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (ResizePolicyType)GetValue(WidthResizePolicyProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (ResizePolicyType)GetValue(WidthResizePolicyProperty);
+ }
+ else
+ {
+ return (ResizePolicyType)GetInternalWidthResizePolicyProperty(this);
+ }
}
set
{
- SetValue(WidthResizePolicyProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(WidthResizePolicyProperty, value);
+ }
+ else
+ {
+ SetInternalWidthResizePolicyProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (ResizePolicyType)GetValue(HeightResizePolicyProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (ResizePolicyType)GetValue(HeightResizePolicyProperty);
+ }
+ else
+ {
+ return (ResizePolicyType)GetInternalHeightResizePolicyProperty(this);
+ }
}
set
{
- SetValue(HeightResizePolicyProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(HeightResizePolicyProperty, value);
+ }
+ else
+ {
+ SetInternalHeightResizePolicyProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (SizeScalePolicyType)GetValue(SizeScalePolicyProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (SizeScalePolicyType)GetValue(SizeScalePolicyProperty);
+ }
+ else
+ {
+ return (SizeScalePolicyType)GetInternalSizeScalePolicyProperty(this);
+ }
}
set
{
- SetValue(SizeScalePolicyProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(SizeScalePolicyProperty, value);
+ }
+ else
+ {
+ SetInternalSizeScalePolicyProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(WidthForHeightProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(WidthForHeightProperty);
+ }
+ else
+ {
+ return (bool)GetInternalWidthForHeightProperty(this);
+ }
}
set
{
- SetValue(WidthForHeightProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(WidthForHeightProperty, value);
+ }
+ else
+ {
+ SetInternalWidthForHeightProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(HeightForWidthProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(HeightForWidthProperty);
+ }
+ else
+ {
+ return (bool)GetInternalHeightForWidthProperty(this);
+ }
}
set
{
- SetValue(HeightForWidthProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(HeightForWidthProperty, value);
+ }
+ else
+ {
+ SetInternalHeightForWidthProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(InheritPositionProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(InheritPositionProperty);
+ }
+ else
+ {
+ return (bool)GetInternalInheritPositionProperty(this);
+ }
}
set
{
- SetValue(InheritPositionProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(InheritPositionProperty, value);
+ }
+ else
+ {
+ SetInternalInheritPositionProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (ClippingModeType)GetValue(ClippingModeProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (ClippingModeType)GetValue(ClippingModeProperty);
+ }
+ else
+ {
+ return (ClippingModeType)GetInternalClippingModeProperty(this);
+ }
}
set
{
- SetValue(ClippingModeProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(ClippingModeProperty, value);
+ }
+ else
+ {
+ SetInternalClippingModeProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(InheritLayoutDirectionProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(InheritLayoutDirectionProperty);
+ }
+ else
+ {
+ return (bool)GetInternalInheritLayoutDirectionProperty(this);
+ }
}
set
{
- SetValue(InheritLayoutDirectionProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(InheritLayoutDirectionProperty, value);
+ }
+ else
+ {
+ SetInternalInheritLayoutDirectionProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (ViewLayoutDirectionType)GetValue(LayoutDirectionProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (ViewLayoutDirectionType)GetValue(LayoutDirectionProperty);
+ }
+ else
+ {
+ return (ViewLayoutDirectionType)GetInternalLayoutDirectionProperty(this);
+ }
}
set
{
- SetValue(LayoutDirectionProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(LayoutDirectionProperty, value);
+ }
+ else
+ {
+ SetInternalLayoutDirectionProperty(this, null, value);
+ }
NotifyPropertyChanged();
layout?.RequestLayout();
}
{
get
{
- return (int)GetValue(WidthSpecificationProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (int)GetValue(WidthSpecificationProperty);
+ }
+ else
+ {
+ return (int)GetInternalWidthSpecificationProperty(this);
+ }
}
set
{
- SetValue(WidthSpecificationProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(WidthSpecificationProperty, value);
+ }
+ else
+ {
+ SetInternalWidthSpecificationProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (int)GetValue(HeightSpecificationProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (int)GetValue(HeightSpecificationProperty);
+ }
+ else
+ {
+ return (int)GetInternalHeightSpecificationProperty(this);
+ }
}
set
{
- SetValue(HeightSpecificationProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(HeightSpecificationProperty, value);
+ }
+ else
+ {
+ SetInternalHeightSpecificationProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return GetValue(LayoutTransitionProperty) as LayoutTransition;
+ if (NUIApplication.IsUsingXaml)
+ {
+ return GetValue(LayoutTransitionProperty) as LayoutTransition;
+ }
+ else
+ {
+ return GetInternalLayoutTransitionProperty(this) as LayoutTransition;
+ }
}
set
{
- SetValue(LayoutTransitionProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(LayoutTransitionProperty, value);
+ }
+ else
+ {
+ SetInternalLayoutTransitionProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return GetValue(PaddingEXProperty) as Extents;
+ if (NUIApplication.IsUsingXaml)
+ {
+ return GetValue(PaddingEXProperty) as Extents;
+ }
+ else
+ {
+ return GetInternalPaddingEXProperty(this) as Extents;
+ }
}
set
{
- SetValue(PaddingEXProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(PaddingEXProperty, value);
+ }
+ else
+ {
+ SetInternalPaddingEXProperty(this, null, value);
+ }
}
}
{
get
{
- return GetValue(LayoutProperty) as LayoutItem;
+ if (NUIApplication.IsUsingXaml)
+ {
+ return GetValue(LayoutProperty) as LayoutItem;
+ }
+ else
+ {
+ return GetInternalLayoutProperty(this) as LayoutItem;
+ }
}
set
{
- SetValue(LayoutProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(LayoutProperty, value);
+ }
+ else
+ {
+ SetInternalLayoutProperty(this, null, value);
+ }
}
}
{
get
{
- return (bool)GetValue(BackgroundImageSynchronosLoadingProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(BackgroundImageSynchronosLoadingProperty);
+ }
+ else
+ {
+ return (bool)GetInternalBackgroundImageSynchronosLoadingProperty(this);
+ }
}
set
{
- SetValue(BackgroundImageSynchronosLoadingProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BackgroundImageSynchronosLoadingProperty, value);
+ }
+ else
+ {
+ SetInternalBackgroundImageSynchronosLoadingProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(BackgroundImageSynchronousLoadingProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(BackgroundImageSynchronousLoadingProperty);
+ }
+ else
+ {
+ return (bool)GetInternalBackgroundImageSynchronousLoadingProperty(this);
+ }
}
set
{
- SetValue(BackgroundImageSynchronousLoadingProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BackgroundImageSynchronousLoadingProperty, value);
+ }
+ else
+ {
+ SetInternalBackgroundImageSynchronousLoadingProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (Vector4)GetValue(UpdateAreaHintProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (Vector4)GetValue(UpdateAreaHintProperty);
+ }
+ else
+ {
+ return (Vector4)GetInternalUpdateAreaHintProperty(this);
+ }
}
set
{
- SetValue(UpdateAreaHintProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(UpdateAreaHintProperty, value);
+ }
+ else
+ {
+ SetInternalUpdateAreaHintProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(EnableControlStatePropagationProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(EnableControlStatePropagationProperty);
+ }
+ else
+ {
+ return (bool)GetInternalEnableControlStatePropagationProperty(this);
+ }
}
set
{
- SetValue(EnableControlStatePropagationProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(EnableControlStatePropagationProperty, value);
+ }
+ else
+ {
+ SetInternalEnableControlStatePropagationProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (ControlState)GetValue(PropagatableControlStatesProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (ControlState)GetValue(PropagatableControlStatesProperty);
+ }
+ else
+ {
+ return (ControlState)GetInternalPropagatableControlStatesProperty(this);
+ }
}
set
{
- SetValue(PropagatableControlStatesProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(PropagatableControlStatesProperty, value);
+ }
+ else
+ {
+ SetInternalPropagatableControlStatesProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
{
get
{
- return (bool)GetValue(EnableControlStateProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(EnableControlStateProperty);
+ }
+ else
+ {
+ return (bool)GetInternalEnableControlStateProperty(this);
+ }
}
set
{
- SetValue(EnableControlStateProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(EnableControlStateProperty, value);
+ }
+ else
+ {
+ SetInternalEnableControlStateProperty(this, null, value);
+ }
}
}
{
get
{
- return (bool)GetValue(GrabTouchAfterLeaveProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(GrabTouchAfterLeaveProperty);
+ }
+ else
+ {
+ return (bool)GetInternalGrabTouchAfterLeaveProperty(this);
+ }
}
set
{
- SetValue(GrabTouchAfterLeaveProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(GrabTouchAfterLeaveProperty, value);
+ }
+ else
+ {
+ SetInternalGrabTouchAfterLeaveProperty(this, null, value);
+ }
}
}
{
get
{
- return (bool)GetValue(AllowOnlyOwnTouchProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(AllowOnlyOwnTouchProperty);
+ }
+ else
+ {
+ return (bool)GetInternalAllowOnlyOwnTouchProperty(this);
+ }
}
set
{
- SetValue(AllowOnlyOwnTouchProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(AllowOnlyOwnTouchProperty, value);
+ }
+ else
+ {
+ SetInternalAllowOnlyOwnTouchProperty(this, null, value);
+ }
}
}
{
get
{
- return (BlendEquationType)GetValue(BlendEquationProperty);
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (BlendEquationType)GetValue(BlendEquationProperty);
+ }
+ else
+ {
+ return (BlendEquationType)GetInternalBlendEquationProperty(this);
+ }
}
set
{
- SetValue(BlendEquationProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(BlendEquationProperty, value);
+ }
+ else
+ {
+ SetInternalBlendEquationProperty(this, null, value);
+ }
}
}
/// <since_tizen> 9 </since_tizen>
public bool ThemeChangeSensitive
{
- get => (bool)GetValue(ThemeChangeSensitiveProperty);
- set => SetValue(ThemeChangeSensitiveProperty, value);
+ get
+ {
+ if (NUIApplication.IsUsingXaml)
+ {
+ return (bool)GetValue(ThemeChangeSensitiveProperty);
+ }
+ else
+ {
+ return (bool)GetInternalThemeChangeSensitiveProperty(this);
+ }
+ }
+ set
+ {
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(ThemeChangeSensitiveProperty, value);
+ }
+ else
+ {
+ SetInternalThemeChangeSensitiveProperty(this, null, value);
+ }
+ }
}
/// <summary>
{
get
{
- return GetValue(TransitionOptionsProperty) as TransitionOptions;
+ if (NUIApplication.IsUsingXaml)
+ {
+ return GetValue(TransitionOptionsProperty) as TransitionOptions;
+ }
+ else
+ {
+ return GetInternalTransitionOptionsProperty(this) as TransitionOptions;
+ }
}
set
{
- SetValue(TransitionOptionsProperty, value);
+ if (NUIApplication.IsUsingXaml)
+ {
+ SetValue(TransitionOptionsProperty, value);
+ }
+ else
+ {
+ SetInternalTransitionOptionsProperty(this, null, value);
+ }
NotifyPropertyChanged();
}
}
projects / platform / core / csapi / tizenfx.git / blobdiff