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.Text;
  20     using System.Runtime.InteropServices;
  21     using System.Collections.Generic;
  22     using System.Linq;
  23
  24     /// <summary>
  25     /// A visual view control if a user adds any visual to it.
  26     /// </summary>
  27     /// <example>
  28     /// Example:
  29     /// <code>
  30     /// VisualView _visualView = new VisualView();
  31     /// ImageVisualMap imageVisualMap1 = new ImageVisualMap();
  32     /// imageVisualMap1.URL = "./NUISample/res/images/image-1.jpg";
  33     /// imageVisualMap1.VisualSize = new Vector2( 300.0f, 300.0f );
  34     /// imageVisualMap1.Offset = new Vector2( 50.0f, 50.0f );
  35     /// imageVisualMap1.OffsetSizeMode = new Vector4( 1.0f, 1.0f, 1.0f, 1.0f );
  36     /// imageVisualMap1.Origin = AlignType.TOP_BEGIN;
  37     /// imageVisualMap1.AnchorPoint = AlignType.TOP_BEGIN;
  38     /// _visualView.AddVisual("imageVisual1", imageVisualMap1);
  39     /// </code>
  40     /// </example>
  41     public class VisualView : CustomView
  42     {
  43         //private LinkedList<VisualBase> _visualList = null;
  44         private Dictionary<int, VisualBase> _visualDictionary = null;
  45         private Dictionary<int, PropertyMap> _tranformDictionary = null;
  46         private PropertyArray _animateArray = null;
  47
  48         static CustomView CreateInstance()
  49         {
  50             return new VisualView();
  51         }
  52
  53         // static constructor registers the control type (for user can add kinds of visuals to it)
  54         static VisualView()
  55         {
  56             // ViewRegistry registers control type with DALi type registery
  57             // also uses introspection to find any properties that need to be registered with type registry
  58             CustomViewRegistry.Instance.Register(CreateInstance, typeof(VisualView));
  59         }
  60
  61         public VisualView() : base(typeof(VisualView).FullName, CustomViewBehaviour.ViewBehaviourDefault)
  62         {
  63         }
  64
  65         /// <summary>
  66         /// Overrides the parent method.
  67         /// </summary>
  68         /// <since_tizen> 3 </since_tizen>
  69         public override void OnInitialize()
  70         {
  71             //Initialize empty
  72             _visualDictionary = new Dictionary<int, VisualBase>();
  73             _tranformDictionary = new Dictionary<int, PropertyMap>();
  74             _animateArray = new PropertyArray();
  75         }
  76
  77         /// <summary>
  78         /// Adds or updates a visual to visual view.
  79         /// </summary>
  80         /// <param name="visualName">The name of a visual to add. If a name is added to an existing visual name, the visual will be replaced.</param>
  81         /// <param name="visualMap">The property map of a visual to create.</param>
  82         /// <since_tizen> 3 </since_tizen>
  83         public void AddVisual(string visualName, VisualMap visualMap)
  84         {
  85             VisualBase visual = null;
  86             int visualIndex = -1;
  87
  88             /* If the visual had added, then replace it using RegisterVusal. */
  89             //visual.Name = name;
  90             foreach (var item in _visualDictionary)
  91             {
  92                 if (item.Value.Name == visualName)
  93                 {
  94                     /* Find a existed visual, its key also exited. */
  95                     visualIndex = item.Key;
  96                     UnregisterVisual(visualIndex);
  97                     _visualDictionary.Remove(visualIndex);
  98                     _tranformDictionary.Remove(visualIndex);
  99                     break;
 100                 }
 101             }
 102
 103             if (visualIndex == -1) // The visual is a new one, create index for it. */
 104             {
 105                 visualIndex = RegisterProperty(visualName, new PropertyValue(visualName), PropertyAccessMode.ReadWrite);
 106             }
 107
 108             if (visualIndex > 0)
 109             {
 110                 visual = VisualFactory.Instance.CreateVisual(visualMap.OutputVisualMap); // Create a visual for the new one.
 111                 visual.Name = visualName;
 112                 visual.DepthIndex = visualMap.DepthIndex;
 113
 114                 RegisterVisual(visualIndex, visual);
 115
 116                 _visualDictionary.Add(visualIndex, visual);
 117                 _tranformDictionary.Add(visualIndex, visualMap.OutputTransformMap);
 118
 119                 visualMap.VisualIndex = visualIndex;
 120                 visualMap.Name = visualName;
 121                 visualMap.Parent = this;
 122
 123                 RelayoutRequest();
 124             }
 125         }
 126
 127         /// <summary>
 128         /// Removes a visual by name.
 129         /// </summary>
 130         /// <param name="visualName">The name of a visual to remove.</param>
 131         /// <since_tizen> 3 </since_tizen>
 132         public void RemoveVisual(string visualName)
 133         {
 134             foreach (var item in _visualDictionary)
 135             {
 136                 if (item.Value.Name == visualName)
 137                 {
 138                     EnableVisual(item.Key, false);
 139                     UnregisterVisual(item.Key);
 140                     _tranformDictionary.Remove(item.Key);
 141                     _visualDictionary.Remove(item.Key);
 142
 143                     RelayoutRequest();
 144                     break;
 145                 }
 146             }
 147         }
 148
 149         /// <summary>
 150         /// Gets the total number of visuals which are added by users.
 151         /// </summary>
 152         /// <since_tizen> 3 </since_tizen>
 153         public int NumberOfVisuals
 154         {
 155             get
 156             {
 157                 return _visualDictionary.Count;
 158             }
 159         }
 160
 161         /// <summary>
 162         /// Removes all visuals of the visual view.
 163         /// </summary>
 164         /// <since_tizen> 3 </since_tizen>
 165         public void RemoveAll()
 166         {
 167             foreach (var item in _visualDictionary)
 168             {
 169                 EnableVisual(item.Key, false);
 170                 UnregisterVisual(item.Key);
 171             }
 172             _visualDictionary.Clear();
 173             _tranformDictionary.Clear();
 174             RelayoutRequest();
 175         }
 176
 177         /// <summary>
 178         /// Overrides the method of OnRelayout() for CustomView class.<br>
 179         /// Called after the size negotiation has been finished for this control.<br>
 180         /// The control is expected to assign this given size to itself or its children.<br>
 181         /// 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>
 182         /// </summary>
 183         /// <remarks>As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored).</remarks>
 184         /// <param name="size">The allocated size.</param>
 185         /// <param name="container">The control should add actors to this container that it is not able to allocate a size for.</param>
 186         /// <since_tizen> 3 </since_tizen>
 187         public override void OnRelayout(Vector2 size, RelayoutContainer container)
 188         {
 189             foreach (var item in _visualDictionary)
 190             {
 191                 item.Value.SetTransformAndSize(_tranformDictionary[item.Key], size);
 192                 EnableVisual(item.Key, true);
 193             }
 194         }
 195
 196         internal void UpdateVisual(int visualIndex, string visualName, VisualMap visualMap)
 197         {
 198             VisualBase visual = null;
 199
 200             visual = VisualFactory.Instance.CreateVisual(visualMap.OutputVisualMap);
 201             visual.Name = visualName;
 202             visual.DepthIndex = visualMap.DepthIndex;
 203
 204             RegisterVisual(visualIndex, visual);
 205
 206             _visualDictionary[visualIndex] = visual;
 207             _tranformDictionary[visualIndex] = visualMap.OutputTransformMap;
 208
 209             RelayoutRequest();
 210             NUILog.Debug("UpdateVisual() name=" + visualName);
 211         }
 212
 213         /// <summary>
 214         /// Creates a visual animation (transition) with the input parameters.
 215         /// </summary>
 216         /// <param name="target">The visual map to animation.</param>
 217         /// <param name="property">The property of visual to animation.</param>
 218         /// <param name="destinationValue">The destination value of property after animation.</param>
 219         /// <param name="startTime">The start time of visual animation.</param>
 220         /// <param name="endTime">The end time of visual animation.</param>
 221         /// <param name="alphaFunction">The alpha function of visual animation.</param>
 222         /// <param name="initialValue">The initial property value of visual animation.</param>
 223         /// <returns>Animation instance</returns>
 224         /// <since_tizen> 3 </since_tizen>
 225         public Animation AnimateVisual(VisualMap target, string property, object destinationValue, int startTime, int endTime, AlphaFunction.BuiltinFunctions? alphaFunction = null, object initialValue = null)
 226         {
 227             string _alphaFunction = null;
 228             if (alphaFunction != null)
 229             {
 230                 switch (alphaFunction)
 231                 {
 232                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Linear:
 233                     {
 234                         _alphaFunction = "LINEAR";
 235                         break;
 236                     }
 237                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Reverse:
 238                     {
 239                         _alphaFunction = "REVERSE";
 240                         break;
 241                     }
 242                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSquare:
 243                     {
 244                         _alphaFunction = "EASE_IN_SQUARE";
 245                         break;
 246                     }
 247                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSquare:
 248                     {
 249                         _alphaFunction = "EASE_OUT_SQUARE";
 250                         break;
 251                     }
 252                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseIn:
 253                     {
 254                         _alphaFunction = "EASE_IN";
 255                         break;
 256                     }
 257                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOut:
 258                     {
 259                         _alphaFunction = "EASE_OUT";
 260                         break;
 261                     }
 262                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOut:
 263                     {
 264                         _alphaFunction = "EASE_IN_OUT";
 265                         break;
 266                     }
 267                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSine:
 268                     {
 269                         _alphaFunction = "EASE_IN_SINE";
 270                         break;
 271                     }
 272                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSine:
 273                     {
 274                         _alphaFunction = "EASE_OUT_SINE";
 275                         break;
 276                     }
 277                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOutSine:
 278                     {
 279                         _alphaFunction = "EASE_IN_OUT_SINE";
 280                         break;
 281                     }
 282                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Bounce:
 283                     {
 284                         _alphaFunction = "BOUNCE";
 285                         break;
 286                     }
 287                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Sin:
 288                     {
 289                         _alphaFunction = "SIN";
 290                         break;
 291                     }
 292                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutBack:
 293                     {
 294                         _alphaFunction = "EASE_OUT_BACK";
 295                         break;
 296                     }
 297                     default:
 298                     {
 299                         _alphaFunction = "DEFAULT";
 300                         break;
 301                     }
 302                 }
 303             }
 304
 305             foreach (var item in _visualDictionary.ToList())
 306             {
 307                 if (item.Value.Name == target.Name)
 308                 {
 309                     PropertyMap _animator = new PropertyMap();
 310                     if ( _alphaFunction != null) {_animator.Add("alphaFunction", new PropertyValue(_alphaFunction));}
 311
 312                     PropertyMap _timePeriod = new PropertyMap();
 313                     _timePeriod.Add("duration", new PropertyValue((endTime - startTime) / 1000.0f));
 314                     _timePeriod.Add("delay", new PropertyValue(startTime / 1000.0f));
 315                     _animator.Add("timePeriod", new PropertyValue(_timePeriod));
 316
 317                     StringBuilder sb = new StringBuilder(property);
 318                     sb[0] = (char)(sb[0] | 0x20);
 319                     string _str = sb.ToString();
 320                     if (_str == "position") {_str = "offset";}
 321
 322                     PropertyValue destVal = PropertyValue.CreateFromObject(destinationValue);
 323
 324                     PropertyMap _transition = new PropertyMap();
 325                     _transition.Add("target", new PropertyValue(target.Name));
 326                     _transition.Add("property", new PropertyValue(_str));
 327                     if (initialValue != null)
 328                     {
 329                         PropertyValue initVal = PropertyValue.CreateFromObject(initialValue);
 330                         _transition.Add("initialValue", new PropertyValue(initVal));
 331                     }
 332                     _transition.Add("targetValue", destVal);
 333                     _transition.Add("animator", new PropertyValue(_animator));
 334
 335                     TransitionData _transitionData = new TransitionData(_transition);
 336                     return this.CreateTransition(_transitionData);
 337                 }
 338             }
 339             return null;
 340         }
 341
 342         /// <summary>
 343         /// Adds a group visual animation (transition) map with the input parameters.
 344         /// </summary>
 345         /// <param name="target">The visual map to animation.</param>
 346         /// <param name="property">The property of visual to animation.</param>
 347         /// <param name="destinationValue">The destination value of property after animation.</param>
 348         /// <param name="startTime">The start time of visual animation.</param>
 349         /// <param name="endTime">The end time of visual animation.</param>
 350         /// <param name="alphaFunction">The alpha function of visual animation.</param>
 351         /// <param name="initialValue">The initial property value of visual animation.</param>
 352         /// <since_tizen> 3 </since_tizen>
 353         public void AnimateVisualAdd(VisualMap target, string property, object destinationValue, int startTime, int endTime, AlphaFunction.BuiltinFunctions? alphaFunction = null, object initialValue = null)
 354         {
 355             string _alphaFunction = null;
 356             if (alphaFunction != null)
 357             {
 358                 switch (alphaFunction)
 359                 {
 360                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Linear:
 361                     {
 362                         _alphaFunction = "LINEAR";
 363                         break;
 364                     }
 365                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Reverse:
 366                     {
 367                         _alphaFunction = "REVERSE";
 368                         break;
 369                     }
 370                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSquare:
 371                     {
 372                         _alphaFunction = "EASE_IN_SQUARE";
 373                         break;
 374                     }
 375                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSquare:
 376                     {
 377                         _alphaFunction = "EASE_OUT_SQUARE";
 378                         break;
 379                     }
 380                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseIn:
 381                     {
 382                         _alphaFunction = "EASE_IN";
 383                         break;
 384                     }
 385                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOut:
 386                     {
 387                         _alphaFunction = "EASE_OUT";
 388                         break;
 389                     }
 390                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOut:
 391                     {
 392                         _alphaFunction = "EASE_IN_OUT";
 393                         break;
 394                     }
 395                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSine:
 396                     {
 397                         _alphaFunction = "EASE_IN_SINE";
 398                         break;
 399                     }
 400                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSine:
 401                     {
 402                         _alphaFunction = "EASE_OUT_SINE";
 403                         break;
 404                     }
 405                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOutSine:
 406                     {
 407                         _alphaFunction = "EASE_IN_OUT_SINE";
 408                         break;
 409                     }
 410                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Bounce:
 411                     {
 412                         _alphaFunction = "BOUNCE";
 413                         break;
 414                     }
 415                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Sin:
 416                     {
 417                         _alphaFunction = "SIN";
 418                         break;
 419                     }
 420                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutBack:
 421                     {
 422                         _alphaFunction = "EASE_OUT_BACK";
 423                         break;
 424                     }
 425                     default:
 426                     {
 427                         _alphaFunction = "DEFAULT";
 428                         break;
 429                     }
 430                 }
 431             }
 432
 433             foreach (var item in _visualDictionary.ToList())
 434             {
 435                 if (item.Value.Name == target.Name)
 436                 {
 437                     PropertyMap _animator = new PropertyMap();
 438                     if ( _alphaFunction != null) {_animator.Add("alphaFunction", new PropertyValue(_alphaFunction));}
 439
 440                     PropertyMap _timePeriod = new PropertyMap();
 441                     _timePeriod.Add("duration", new PropertyValue((endTime - startTime) / 1000.0f));
 442                     _timePeriod.Add("delay", new PropertyValue(startTime / 1000.0f));
 443                     _animator.Add("timePeriod", new PropertyValue(_timePeriod));
 444
 445                     StringBuilder sb = new StringBuilder(property);
 446                     sb[0] = (char)(sb[0] | 0x20);
 447                     string _str = sb.ToString();
 448                     if (_str == "position") {_str = "offset";}
 449
 450                     PropertyValue destVal = PropertyValue.CreateFromObject(destinationValue);
 451
 452                     PropertyMap _transition = new PropertyMap();
 453                     _transition.Add("target", new PropertyValue(target.Name));
 454                     _transition.Add("property", new PropertyValue(_str));
 455                     if (initialValue != null)
 456                     {
 457                         PropertyValue initVal = PropertyValue.CreateFromObject(initialValue);
 458                         _transition.Add("initialValue", new PropertyValue(initVal));
 459                     }
 460                     _transition.Add("targetValue", destVal);
 461                     _transition.Add("animator", new PropertyValue(_animator));
 462
 463                     _animateArray.Add(new PropertyValue(_transition));
 464                 }
 465             }
 466         }
 467
 468         /// <summary>
 469         /// Finishes to add a visual animation (transition) map and creates a transition animation.
 470         /// </summary>
 471         /// <returns>Animation instance.</returns>
 472         /// <since_tizen> 3 </since_tizen>
 473         public Animation AnimateVisualAddFinish()
 474         {
 475             if ( _animateArray == null || _animateArray.Empty())
 476             {
 477                 Tizen.Log.Fatal("NUI", "animate visual property array is empty!");
 478                 return null;
 479             }
 480             TransitionData _transitionData = new TransitionData(_animateArray);
 481
 482             return this.CreateTransition(_transitionData);
 483         }
 484
 485
 486         //temporary fix to pass TCT
 487         public Animation VisualAnimate(Tizen.NUI.VisualAnimator visualMap)
 488         {
 489             foreach (var item in _visualDictionary.ToList())
 490             {
 491                 if (item.Value.Name == visualMap.Target)
 492                 {
 493                     TransitionData _transitionData = new TransitionData(visualMap.OutputVisualMap);
 494                     return this.CreateTransition(_transitionData);
 495                 }
 496             }
 497             return null;
 498         }
 499         //temporary fix to pass TCT
 500
 501     }
 502 }