src/Tizen.NUI/src/public/BaseComponents/VisualView.cs

   1 // Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 //
   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 namespace Tizen.NUI.BaseComponents
  17 {
  18     using System;
  19     using System.Runtime.InteropServices;
  20     using System.Collections.Generic;
  21     using System.Linq;
  22
  23     /// <summary>
  24     /// A visual view control for user add any visual to it.
  25     /// </summary>
  26     /// <example>
  27     /// Example:
  28     /// <code>
  29     /// VisualView _visualView = new VisualView();
  30     /// ImageVisualMap imageVisualMap1 = new ImageVisualMap();
  31     /// imageVisualMap1.URL = "./NUISample/res/images/image-1.jpg";
  32     /// imageVisualMap1.VisualSize = new Vector2( 300.0f, 300.0f );
  33     /// imageVisualMap1.Offset = new Vector2( 50.0f, 50.0f );
  34     /// imageVisualMap1.OffsetSizeMode = new Vector4( 1.0f, 1.0f, 1.0f, 1.0f );
  35     /// imageVisualMap1.Origin = AlignType.TOP_BEGIN;
  36     /// imageVisualMap1.AnchorPoint = AlignType.TOP_BEGIN;
  37     /// _visualView.AddVisual("imageVisual1", imageVisualMap1);
  38     /// </code>
  39     /// </example>
  40     public class VisualView : CustomView
  41     {
  42         //private LinkedList<VisualBase> _visualList = null;
  43         private Dictionary<int, VisualBase> _visualDictionary = null;
  44         private Dictionary<int, PropertyMap> _tranformDictionary = null;
  45
  46         static CustomView CreateInstance()
  47         {
  48             return new VisualView();
  49         }
  50
  51         // static constructor registers the control type (for user can add kinds of visuals to it)
  52         static VisualView()
  53         {
  54             // ViewRegistry registers control type with DALi type registery
  55             // also uses introspection to find any properties that need to be registered with type registry
  56             ViewRegistry.Instance.Register(CreateInstance, typeof(VisualView));
  57         }
  58
  59         public VisualView() : base(typeof(VisualView).Name, CustomViewBehaviour.ViewBehaviourDefault)
  60         {
  61         }
  62
  63         /// <summary>
  64         /// Override the parent method.
  65         /// </summary>
  66         public override void OnInitialize()
  67         {
  68             //Initialize empty
  69             _visualDictionary = new Dictionary<int, VisualBase>();
  70             _tranformDictionary = new Dictionary<int, PropertyMap>();
  71         }
  72
  73         /// <summary>
  74         /// Add or update a visual to visual view.
  75         /// </summary>
  76         /// <param name="visualName"> The name of visual to add. If add a existed visual name, the visual will be replaced. </param>
  77         /// <param name="visualMap"> The property map of visual to create.  </param>
  78         public void AddVisual(string visualName, VisualMap visualMap)
  79         {
  80             VisualBase visual = null;
  81             int visualIndex = -1;
  82
  83             /* If the visual had added, then replace it using RegisterVusal. */
  84             //visual.Name = name;
  85             foreach (var item in _visualDictionary)
  86             {
  87                 if (item.Value.Name == visualName)
  88                 {
  89                     /* Find a existed visual, its key also exited. */
  90                     visualIndex = item.Key;
  91                     UnregisterVisual(visualIndex);
  92                     _visualDictionary.Remove(visualIndex);
  93                     _tranformDictionary.Remove(visualIndex);
  94                     break;
  95                 }
  96             }
  97
  98             if (visualIndex == -1) // The visual is a new one, create index for it. */
  99             {
 100                 visualIndex = RegisterProperty(visualName, new PropertyValue(visualName), PropertyAccessMode.ReadWrite);
 101             }
 102
 103             if (visualIndex > 0)
 104             {
 105                 visual = VisualFactory.Get().CreateVisual(visualMap.OutputVisualMap); // Create a visual for the new one.
 106                 visual.Name = visualName;
 107                 visual.DepthIndex = visualMap.DepthIndex;
 108
 109                 RegisterVisual(visualIndex, visual);
 110
 111                 _visualDictionary.Add(visualIndex, visual);
 112                 _tranformDictionary.Add(visualIndex, visualMap.OutputTransformMap);
 113
 114                 visualMap.VisualIndex = visualIndex;
 115                 visualMap.Name = visualName;
 116                 visualMap.Parent = this;
 117
 118                 RelayoutRequest();
 119             }
 120         }
 121
 122         /// <summary>
 123         /// Remove a visual by name.
 124         /// </summary>
 125         /// <param name="visualName"> The name of visual to remove. </param>
 126         public void RemoveVisual(string visualName)
 127         {
 128             foreach (var item in _visualDictionary)
 129             {
 130                 if (item.Value.Name == visualName)
 131                 {
 132                     EnableVisual(item.Key, false);
 133                     UnregisterVisual(item.Key);
 134                     _tranformDictionary.Remove(item.Key);
 135                     _visualDictionary.Remove(item.Key);
 136
 137                     RelayoutRequest();
 138                     break;
 139                 }
 140             }
 141         }
 142
 143         /// <summary>
 144         ///  Get the total number of Visuals which are added by users
 145         /// </summary>
 146         public int NumberOfVisuals
 147         {
 148             get
 149             {
 150                 return _visualDictionary.Count;
 151             }
 152         }
 153
 154         /// <summary>
 155         /// Remove all visuals of visual view.
 156         /// </summary>
 157         public void RemoveAll()
 158         {
 159             foreach (var item in _visualDictionary)
 160             {
 161                 EnableVisual(item.Key, false);
 162                 UnregisterVisual(item.Key);
 163             }
 164             _visualDictionary.Clear();
 165             _tranformDictionary.Clear();
 166             RelayoutRequest();
 167         }
 168
 169         /// <summary>
 170         /// Override method of OnRelayout() for CustomView class.<br>
 171         /// Called after the size negotiation has been finished for this control.<br>
 172         /// The control is expected to assign this given size to itself/its children.<br>
 173         /// Should be overridden by derived classes if they need to layout actors differently after certain operations like add or remove actors, resize or after changing specific properties.<br>
 174         /// </summary>
 175         /// <remarks>As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored)</remarks>
 176         /// <param name="size">The allocated size</param>
 177         /// <param name="container">The control should add actors to this container that it is not able to allocate a size for.</param>
 178         public override void OnRelayout(Vector2 size, RelayoutContainer container)
 179         {
 180             foreach (var item in _visualDictionary)
 181             {
 182                 item.Value.SetTransformAndSize(_tranformDictionary[item.Key], size);
 183                 EnableVisual(item.Key, true);
 184             }
 185         }
 186
 187         internal void UpdateVisual(int visualIndex, string visualName, VisualMap visualMap)
 188         {
 189             VisualBase visual = null;
 190
 191             visual = VisualFactory.Get().CreateVisual(visualMap.OutputVisualMap);
 192             visual.Name = visualName;
 193             visual.DepthIndex = visualMap.DepthIndex;
 194
 195             RegisterVisual(visualIndex, visual);
 196
 197             _visualDictionary[visualIndex] = visual;
 198             _tranformDictionary[visualIndex] = visualMap.OutputTransformMap;
 199
 200             RelayoutRequest();
 201 #if DEBUG_ON
 202             Tizen.Log.Debug("NUI", "UpdateVisual() name=" + visualName);
 203 #endif
 204         }
 205
 206         /// <summary>
 207         /// Create visual animation (transition) with the input parameters.
 208         /// </summary>
 209         /// <param name="target"> The visual map to animation.</param>
 210         /// <param name="property"> The property of visual to animation.</param>
 211         /// <param name="destinationValue"> The destination value of property after animation.</param>
 212         /// <param name="startTime"> The start time of visual animation.</param>
 213         /// <param name="endTime"> The end time of visual animation.</param>
 214         /// <param name="alphaFunction"> The alpha function of visual animation</param>
 215         /// <returns>Animation instance</returns>
 216         public Animation AnimateVisual(VisualMap target, string property, object destinationValue, int startTime, int endTime, AlphaFunction.BuiltinFunctions alphaFunction)
 217         {
 218             string _alphaFunction = "";
 219             switch (alphaFunction)
 220             {
 221                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.Linear:
 222                 {
 223                     _alphaFunction = "LINEAR";
 224                     break;
 225                 }
 226                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.Reverse:
 227                 {
 228                     _alphaFunction = "REVERSE";
 229                     break;
 230                 }
 231                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSquare:
 232                 {
 233                     _alphaFunction = "EASE_IN_SQUARE";
 234                     break;
 235                 }
 236                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSquare:
 237                 {
 238                     _alphaFunction = "EASE_OUT_SQUARE";
 239                     break;
 240                 }
 241                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseIn:
 242                 {
 243                     _alphaFunction = "EASE_IN";
 244                     break;
 245                 }
 246                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOut:
 247                 {
 248                     _alphaFunction = "EASE_OUT";
 249                     break;
 250                 }
 251                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOut:
 252                 {
 253                     _alphaFunction = "EASE_IN_OUT";
 254                     break;
 255                 }
 256                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSine:
 257                 {
 258                     _alphaFunction = "EASE_IN_SINE";
 259                     break;
 260                 }
 261                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSine:
 262                 {
 263                     _alphaFunction = "EASE_OUT_SINE";
 264                     break;
 265                 }
 266                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOutSine:
 267                 {
 268                     _alphaFunction = "EASE_IN_OUT_SINE";
 269                     break;
 270                 }
 271                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.Bounce:
 272                 {
 273                     _alphaFunction = "BOUNCE";
 274                     break;
 275                 }
 276                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.Sin:
 277                 {
 278                     _alphaFunction = "SIN";
 279                     break;
 280                 }
 281                 case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutBack:
 282                 {
 283                     _alphaFunction = "EASE_OUT_BACK";
 284                     break;
 285                 }
 286                 default:
 287                 {
 288                     _alphaFunction = "DEFAULT";
 289                     break;
 290                 }
 291             }
 292
 293             foreach (var item in _visualDictionary.ToList())
 294             {
 295                 if (item.Value.Name == target.Name)
 296                 {
 297                     PropertyMap _animator = new PropertyMap();
 298                     _animator.Add("alphaFunction", new PropertyValue(_alphaFunction));
 299
 300                     PropertyMap _timePeriod = new PropertyMap();
 301                     _timePeriod.Add("duration", new PropertyValue((endTime - startTime) / 1000.0f));
 302                     _timePeriod.Add("delay", new PropertyValue(startTime / 1000.0f));
 303                     _animator.Add("timePeriod", new PropertyValue(_timePeriod));
 304
 305                     string _str1 = property.Substring(0, 1);
 306                     string _str2 = property.Substring(1);
 307                     string _str = _str1.ToLower() + _str2;
 308
 309                     PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
 310
 311                     PropertyMap _transition = new PropertyMap();
 312                     _transition.Add("target", new PropertyValue(target.Name));
 313                     _transition.Add("property", new PropertyValue(_str));
 314                     _transition.Add("targetValue", val);
 315                     _transition.Add("animator", new PropertyValue(_animator));
 316
 317                     TransitionData _transitionData = new TransitionData(_transition);
 318                     return this.CreateTransition(_transitionData);
 319                 }
 320             }
 321             return null;
 322         }
 323
 324     }
 325 }