Tizen.NUI/src/internal/PropertyRangeManager.cs

   1 using System;
   2 using System.Runtime.InteropServices;
   3 using System.Collections.Generic;
   4
   5 #if true
   6 using System.Reflection;
   7 #endif
   8
   9 namespace Tizen.NUI
  10 {
  11   /// <summary>
  12   /// Helper class for calculating what property indexes should be assigned to C# View (view) classes.
  13   /// </summary>
  14   public 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">View name</param>
  57     /// <param name="viewType">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  heirachy, e.g. 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
 101         //Console.WriteLine ("getStartPropertyIndex =  " + viewType.Name +"current index " + startEventPropertyIndex);
 102         viewType = viewType.GetTypeInfo().BaseType;
 103       }
 104
 105       range.startEventIndex = startEventPropertyIndex;
 106       range.lastUsedEventIndex = startEventPropertyIndex;
 107
 108       range.startAnimationIndex = startAnimatablePropertyIndex;
 109       range.lastUsedAnimationIndex = startAnimatablePropertyIndex;
 110
 111     }
 112
 113
 114     public struct PropertyRange
 115     {
 116
 117       public int GetNextFreePropertyIndex( ScriptableProperty.ScriptableType type)
 118       {
 119         if ( type == ScriptableProperty.ScriptableType.Default )
 120         {
 121            lastUsedEventIndex++;
 122            return lastUsedEventIndex;
 123         }
 124         else
 125         {
 126           lastUsedAnimationIndex++;
 127           return lastUsedAnimationIndex ;
 128         }
 129       }
 130
 131
 132       public int startEventIndex;    /// start of the property range
 133       public int lastUsedEventIndex;    /// last used of the property index
 134
 135       public int startAnimationIndex;  /// start of the property range
 136       public int lastUsedAnimationIndex; /// last used of the property index
 137     };
 138
 139
 140
 141 }
 142 }