src/Tizen.NUI/src/internal/PropertyRangeManager.cs

   1
   2
   3 using System.Reflection;
   4 using System;
   5 using System.Runtime.InteropServices;
   6 using System.Collections.Generic;
   7 using Tizen.NUI.BaseComponents;
   8
   9 namespace Tizen.NUI
  10 {
  11     /// <summary>
  12     /// The helper class for calculating what property indexes should be assigned to the C# View (view) classes.
  13     /// </summary>
  14     internal class PropertyRangeManager
  15     {
  16         private Dictionary<String, PropertyRange> _propertyRange;
  17
  18         /// <summary>
  19         /// Initializes a new instance of the <see cref="Tizen.NUI.PropertyRangeManager"/> class.
  20         /// </summary>
  21         public PropertyRangeManager()
  22         {
  23             _propertyRange = new Dictionary<String, PropertyRange>();
  24         }
  25
  26         /// <summary>
  27         /// Only called if a view has scriptable properties.
  28         /// </summary>
  29         private PropertyRange RegisterView(string viewName, System.Type viewType)
  30         {
  31             PropertyRange range;
  32
  33             if (_propertyRange.TryGetValue(viewName, out range))
  34             {
  35                 // already registered
  36                 return range;
  37             }
  38
  39             // Find out the event and animatable start indexes for the type
  40             range = new PropertyRange();
  41
  42             GetPropertyStartRange(viewType, ref range);
  43
  44             // add it to our dictionary
  45             _propertyRange.Add(viewName, range);
  46
  47             return range;
  48
  49         }
  50
  51         /// <summary>
  52         /// Gets the index of the property.
  53         /// Each property has to have unique index for this view type.
  54         /// </summary>
  55         /// <returns>The property index.</returns>
  56         /// <param name="viewName">The view name.</param>
  57         /// <param name="viewType">The view type.</param>
  58         /// <param name="type">Type.</param>
  59         public int GetPropertyIndex(string viewName, System.Type viewType, ScriptableProperty.ScriptableType type)
  60         {
  61
  62             PropertyRange range;
  63
  64             if (!_propertyRange.TryGetValue(viewName, out range))
  65             {
  66                 // view not found, register it now
  67                 range = RegisterView(viewName, viewType);
  68             }
  69
  70             int index = range.GetNextFreePropertyIndex(type);
  71
  72             // update the dictionary
  73             _propertyRange[viewName] = range;
  74
  75             return index;
  76
  77         }
  78
  79         ///<summary>
  80         /// We calculate the start property indices, based on the type and it's class hierarchy, for example, DateView (70,000)- > Spin (60,000) -> View (50,000).
  81         /// </summary>
  82         private void GetPropertyStartRange(System.Type viewType, ref PropertyRange range)
  83         {
  84             const int maxCountPerDerivation = 1000; // For child and animtable properties we use a gap of 1000 between each
  85                                                     // views property range in the heirachy
  86
  87             // custom views start there property index, at view_PROPERTY_END_INDEX
  88             // we add 1000, just incase View class (our C# custom view base) starts using scriptable properties
  89             int startEventPropertyIndex = (int)View.PropertyRange.CONTROL_PROPERTY_END_INDEX + maxCountPerDerivation;
  90
  91             // for animatable properties current range starts at ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX,
  92             // we add 1000, just incase View class starts using animatable properties
  93             int startAnimatablePropertyIndex = (int)Tizen.NUI.PropertyRanges.ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + maxCountPerDerivation;
  94
  95             while (viewType.GetTypeInfo().BaseType.Name != "CustomView")   // custom view is our C# view base class. we don't go any deeper.
  96             {
  97                 // for every base class increase property start index
  98                 startEventPropertyIndex += (int)Tizen.NUI.PropertyRanges.DEFAULT_PROPERTY_MAX_COUNT_PER_DERIVATION; // DALi uses 10,000
  99                 startAnimatablePropertyIndex += maxCountPerDerivation;
 100                 NUILog.Debug("getStartPropertyIndex =  " + viewType.Name + "current index " + startEventPropertyIndex);
 101                 viewType = viewType.GetTypeInfo().BaseType;
 102             }
 103
 104             range.startEventIndex = startEventPropertyIndex;
 105             range.lastUsedEventIndex = startEventPropertyIndex;
 106
 107             range.startAnimationIndex = startAnimatablePropertyIndex;
 108             range.lastUsedAnimationIndex = startAnimatablePropertyIndex;
 109
 110         }
 111
 112
 113         public struct PropertyRange
 114         {
 115
 116             public int GetNextFreePropertyIndex(ScriptableProperty.ScriptableType type)
 117             {
 118                 if (type == ScriptableProperty.ScriptableType.Default)
 119                 {
 120                     lastUsedEventIndex++;
 121                     return lastUsedEventIndex;
 122                 }
 123                 else
 124                 {
 125                     lastUsedAnimationIndex++;
 126                     return lastUsedAnimationIndex;
 127                 }
 128             }
 129
 130
 131             public int startEventIndex;    /// start of the property range
 132             public int lastUsedEventIndex;    /// last used of the property index
 133
 134             public int startAnimationIndex;  /// start of the property range
 135             public int lastUsedAnimationIndex; /// last used of the property index
 136         };
 137
 138
 139
 140     }
 141 }