src/Tizen.NUI/src/public/VisualMaps.cs

   1 /*
   2  * Copyright(c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System.Text;
  18 using System.Collections.Generic;
  19 using Tizen.NUI.BaseComponents;
  20 using System.ComponentModel;
  21
  22 namespace Tizen.NUI
  23 {
  24     /// <summary>
  25     /// A class encapsulating the transform map of the visual.
  26     /// </summary>
  27     /// <since_tizen> 3 </since_tizen>
  28     public class VisualMap
  29     {
  30         private Vector2 _visualSize = null;
  31         private Vector2 _visualOffset = null;
  32         private Vector2 _visualOffsetPolicy = null;
  33         private Vector2 _visualSizePolicy = null;
  34         private Visual.AlignType? _visualOrigin = null;
  35         private Visual.AlignType? _visualAnchorPoint = null;
  36
  37         private PropertyMap _visualTransformMap = null;
  38
  39         private int? _depthIndex = null;
  40
  41         /// <summary>
  42         /// outputVisualMap.
  43         /// </summary>
  44         /// <since_tizen> 3 </since_tizen>
  45         protected PropertyMap _outputVisualMap = null;
  46
  47         internal string Name
  48         {
  49             set;
  50             get;
  51         }
  52
  53         internal int VisualIndex
  54         {
  55             set;
  56             get;
  57         }
  58
  59         internal VisualView Parent
  60         {
  61             set;
  62             get;
  63         }
  64
  65         /// <summary>
  66         /// Constructor.
  67         /// </summary>
  68         /// <since_tizen> 3 </since_tizen>
  69         public VisualMap()
  70         {
  71         }
  72
  73         /// <summary>
  74         /// Gets or sets the size of the visual.<br />
  75         /// It can be either relative (percentage of the parent)
  76         /// or absolute (in world units).<br />
  77         /// Optional.
  78         /// </summary>
  79         /// <since_tizen> 3 </since_tizen>
  80         public Size2D Size
  81         {
  82             get
  83             {
  84                 return _visualSize ?? (new Size2D(1, 1));
  85             }
  86             set
  87             {
  88                 _visualSize = value;
  89                 if (_visualSizePolicy == null)
  90                 {
  91                     _visualSizePolicy = new Vector2(1.0f, 1.0f);
  92                 }
  93                 UpdateVisual();
  94             }
  95         }
  96
  97         /// <summary>
  98         /// Gets or sets the offset of the visual.<br />
  99         /// It can be either relative (percentage of the parent)
 100         /// or absolute (in world units).<br />
 101         /// Optional.
 102         /// </summary>
 103         /// <since_tizen> 3 </since_tizen>
 104         public Vector2 Position
 105         {
 106             get
 107             {
 108                 return _visualOffset ?? (new Vector2(0.0f, 0.0f));
 109             }
 110             set
 111             {
 112                 _visualOffset = value;
 113                 if (_visualOffsetPolicy == null)
 114                 {
 115                     _visualOffsetPolicy = new Vector2(1.0f, 1.0f);
 116                 }
 117                 UpdateVisual();
 118             }
 119         }
 120
 121         /// <summary>
 122         /// Gets or sets the relative size of the visual<br />
 123         /// (percentage [0.0f to 1.0f] of the control).<br />
 124         /// Optional.
 125         /// </summary>
 126         /// <since_tizen> 3 </since_tizen>
 127         public RelativeVector2 RelativeSize
 128         {
 129             get
 130             {
 131                 return _visualSize ?? (new RelativeVector2(1.0f, 1.0f));
 132             }
 133             set
 134             {
 135                 _visualSize = value;
 136                 _visualSizePolicy = new Vector2(0.0f, 0.0f);
 137                 UpdateVisual();
 138             }
 139         }
 140
 141         /// <summary>
 142         /// Gets or sets the relative offset of the visual<br />
 143         /// (percentage [0.0f to 1.0f] of the control).<br />
 144         /// Optional.
 145         /// </summary>
 146         /// <since_tizen> 3 </since_tizen>
 147         public RelativeVector2 RelativePosition
 148         {
 149             get
 150             {
 151                 return _visualOffset ?? (new RelativeVector2(0.0f, 0.0f));
 152             }
 153             set
 154             {
 155                 _visualOffset = value;
 156                 _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 157                 UpdateVisual();
 158             }
 159         }
 160
 161         /// <summary>
 162         /// Gets or sets whether the x and y offset values are relative<br />
 163         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 164         /// By default, both the x and the y offset are relative.<br />
 165         /// Optional.
 166         /// </summary>
 167         /// <since_tizen> 3 </since_tizen>
 168         public VisualTransformPolicyType PositionPolicy
 169         {
 170             get
 171             {
 172                 if (_visualOffsetPolicy != null && _visualOffsetPolicy.X == 1.0f
 173                     && _visualOffsetPolicy.Y == 1.0f)
 174                 {
 175                     return VisualTransformPolicyType.Absolute;
 176                 }
 177                 return VisualTransformPolicyType.Relative;
 178             }
 179             set
 180             {
 181                 switch (value)
 182                 {
 183                     case VisualTransformPolicyType.Relative:
 184                         _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 185                         break;
 186                     case VisualTransformPolicyType.Absolute:
 187                         _visualOffsetPolicy = new Vector2(1.0f, 1.0f);
 188                         break;
 189                     default:
 190                         _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 191                         break;
 192                 }
 193                 UpdateVisual();
 194             }
 195         }
 196
 197         /// <summary>
 198         /// Gets or sets whether the x offset values are relative<br />
 199         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 200         /// By default, the x offset is relative.<br />
 201         /// Optional.
 202         /// </summary>
 203         /// <since_tizen> 3 </since_tizen>
 204         public VisualTransformPolicyType PositionPolicyX
 205         {
 206             get
 207             {
 208                 if (_visualOffsetPolicy != null && _visualOffsetPolicy.X == 1.0f)
 209                 {
 210                     return VisualTransformPolicyType.Absolute;
 211                 }
 212                 return VisualTransformPolicyType.Relative;
 213             }
 214             set
 215             {
 216                 if (_visualOffsetPolicy == null)
 217                 {
 218                     _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 219                 }
 220
 221                 switch (value)
 222                 {
 223                     case VisualTransformPolicyType.Relative:
 224                         _visualOffsetPolicy.X = 0.0f;
 225                         break;
 226                     case VisualTransformPolicyType.Absolute:
 227                         _visualOffsetPolicy.X = 1.0f;
 228                         break;
 229                     default:
 230                         _visualOffsetPolicy.X = 0.0f;
 231                         break;
 232                 }
 233
 234                 UpdateVisual();
 235             }
 236         }
 237
 238         /// <summary>
 239         /// Gets or sets whether the y offset values are relative<br />
 240         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 241         /// By default, the y offset is relative.<br />
 242         /// Optional.
 243         /// </summary>
 244         /// <since_tizen> 3 </since_tizen>
 245         public VisualTransformPolicyType PositionPolicyY
 246         {
 247             get
 248             {
 249                 if (_visualOffsetPolicy != null && _visualOffsetPolicy.Y == 1.0f)
 250                 {
 251                     return VisualTransformPolicyType.Absolute;
 252                 }
 253                 return VisualTransformPolicyType.Relative;
 254             }
 255             set
 256             {
 257                 if (_visualOffsetPolicy == null)
 258                 {
 259                     _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 260                 }
 261
 262                 switch (value)
 263                 {
 264                     case VisualTransformPolicyType.Relative:
 265                         _visualOffsetPolicy.Y = 0.0f;
 266                         break;
 267                     case VisualTransformPolicyType.Absolute:
 268                         _visualOffsetPolicy.Y = 1.0f;
 269                         break;
 270                     default:
 271                         _visualOffsetPolicy.Y = 0.0f;
 272                         break;
 273                 }
 274                 UpdateVisual();
 275             }
 276         }
 277
 278         /// <summary>
 279         /// Gets or sets whether the size values of the width or the height are relative<br />
 280         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 281         /// By default, offsets of both the width and the height are relative to the control's size.<br />
 282         /// Optional.
 283         /// </summary>
 284         /// <since_tizen> 3 </since_tizen>
 285         public VisualTransformPolicyType SizePolicy
 286         {
 287             get
 288             {
 289                 if (_visualSizePolicy != null && _visualSizePolicy.X == 1.0f
 290                     && _visualSizePolicy.Y == 1.0f)
 291                 {
 292                     return VisualTransformPolicyType.Absolute;
 293                 }
 294                 return VisualTransformPolicyType.Relative;
 295             }
 296             set
 297             {
 298                 switch (value)
 299                 {
 300                     case VisualTransformPolicyType.Relative:
 301                         _visualSizePolicy = new Vector2(0.0f, 0.0f);
 302                         break;
 303                     case VisualTransformPolicyType.Absolute:
 304                         _visualSizePolicy = new Vector2(1.0f, 1.0f);
 305                         break;
 306                     default:
 307                         _visualSizePolicy = new Vector2(0.0f, 0.0f);
 308                         break;
 309                 }
 310                 UpdateVisual();
 311             }
 312         }
 313
 314         /// <summary>
 315         /// Gets or sets whether size values of the width are relative.<br />
 316         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 317         /// By default, the value of the width is relative to the control's width.<br />
 318         /// Optional.
 319         /// </summary>
 320         /// <since_tizen> 3 </since_tizen>
 321         public VisualTransformPolicyType SizePolicyWidth
 322         {
 323             get
 324             {
 325                 if (_visualSizePolicy != null && _visualSizePolicy.Width == 1.0f)
 326                 {
 327                     return VisualTransformPolicyType.Absolute;
 328                 }
 329                 return VisualTransformPolicyType.Relative;
 330             }
 331             set
 332             {
 333                 if (_visualSizePolicy == null)
 334                 {
 335                     _visualSizePolicy = new Vector2(0.0f, 0.0f);
 336                 }
 337
 338                 switch (value)
 339                 {
 340                     case VisualTransformPolicyType.Relative:
 341                         _visualSizePolicy.Width = 0.0f;
 342                         break;
 343                     case VisualTransformPolicyType.Absolute:
 344                         _visualSizePolicy.Width = 1.0f;
 345                         break;
 346                     default:
 347                         _visualSizePolicy.Width = 0.0f;
 348                         break;
 349                 }
 350                 UpdateVisual();
 351             }
 352         }
 353
 354         /// <summary>
 355         /// Gets or sets whether size values of the height are relative<br />
 356         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 357         /// By default, the height value is relative to the control's height.<br />
 358         /// Optional.
 359         /// </summary>
 360         /// <since_tizen> 3 </since_tizen>
 361         public VisualTransformPolicyType SizePolicyHeight
 362         {
 363             get
 364             {
 365                 if (_visualSizePolicy != null && _visualSizePolicy.Height == 1.0f)
 366                 {
 367                     return VisualTransformPolicyType.Absolute;
 368                 }
 369                 return VisualTransformPolicyType.Relative;
 370             }
 371             set
 372             {
 373                 if (_visualSizePolicy == null)
 374                 {
 375                     _visualSizePolicy = new Vector2(0.0f, 0.0f);
 376                 }
 377
 378                 switch (value)
 379                 {
 380                     case VisualTransformPolicyType.Relative:
 381                         _visualSizePolicy.Height = 0.0f;
 382                         break;
 383                     case VisualTransformPolicyType.Absolute:
 384                         _visualSizePolicy.Height = 1.0f;
 385                         break;
 386                     default:
 387                         _visualSizePolicy.Height = 0.0f;
 388                         break;
 389                 }
 390                 UpdateVisual();
 391             }
 392         }
 393
 394         /// <summary>
 395         /// Gets or sets the origin of the visual within its control area.<br />
 396         /// By default, the origin is center.<br />
 397         /// Optional.
 398         /// </summary>
 399         /// <since_tizen> 3 </since_tizen>
 400         public Visual.AlignType Origin
 401         {
 402             get
 403             {
 404                 return _visualOrigin ?? (Visual.AlignType.Center);
 405             }
 406             set
 407             {
 408                 _visualOrigin = value;
 409                 UpdateVisual();
 410             }
 411         }
 412
 413         /// <summary>
 414         /// Gets or sets the anchor point of the visual.<br />
 415         /// By default, the anchor point is center.<br />
 416         /// Optional.
 417         /// </summary>
 418         /// <since_tizen> 3 </since_tizen>
 419         public Visual.AlignType AnchorPoint
 420         {
 421             get
 422             {
 423                 return _visualAnchorPoint ?? (Visual.AlignType.Center);
 424             }
 425             set
 426             {
 427                 _visualAnchorPoint = value;
 428                 UpdateVisual();
 429             }
 430         }
 431
 432         /// <summary>
 433         /// Gets or sets the depth index of the visual.<br />
 434         /// By default, the depth index is 0.<br />
 435         /// Optional.
 436         /// </summary>
 437         /// <since_tizen> 3 </since_tizen>
 438         public int DepthIndex
 439         {
 440             get
 441             {
 442                 return _depthIndex ?? (0);
 443             }
 444             set
 445             {
 446                 _depthIndex = value;
 447             }
 448         }
 449
 450         private void ComposingTransformMap()
 451         {
 452             _visualTransformMap = new PropertyMap();
 453             if (_visualSize != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Size, new PropertyValue(_visualSize)); }
 454             if (_visualOffset != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Offset, new PropertyValue(_visualOffset)); }
 455             if (_visualOffsetPolicy != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.OffsetPolicy, new PropertyValue(_visualOffsetPolicy)); }
 456             if (_visualSizePolicy != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.SizePolicy, new PropertyValue(_visualSizePolicy)); }
 457             if (_visualOrigin != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Origin, new PropertyValue((int)_visualOrigin)); }
 458             if (_visualAnchorPoint != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.AnchorPoint, new PropertyValue((int)_visualAnchorPoint)); }
 459         }
 460
 461         /// <summary>
 462         /// Gets the transform map used by the visual.
 463         /// </summary>
 464         /// <since_tizen> 3 </since_tizen>
 465         public PropertyMap OutputTransformMap
 466         {
 467             get
 468             {
 469                 ComposingTransformMap();
 470                 return _visualTransformMap;
 471             }
 472         }
 473
 474         /// <summary>
 475         /// Compose the out visual map.
 476         /// </summary>
 477         /// <since_tizen> 3 </since_tizen>
 478         protected virtual void ComposingPropertyMap()
 479         {
 480             _outputVisualMap = new PropertyMap();
 481         }
 482
 483         /// <summary>
 484         /// Gets the property map to create the visual.
 485         /// </summary>
 486         /// <since_tizen> 3 </since_tizen>
 487         public PropertyMap OutputVisualMap
 488         {
 489             get
 490             {
 491                 ComposingPropertyMap();
 492                 return _outputVisualMap;
 493             }
 494         }
 495
 496         internal void UpdateVisual()
 497         {
 498             if (VisualIndex > 0)
 499             {
 500                 NUILog.Debug("UpdateVisual()! VisualIndex=" + VisualIndex);
 501                 Parent.UpdateVisual(VisualIndex, Name, this);
 502             }
 503             else
 504             {
 505                 NUILog.Debug("VisualIndex was not set");
 506             }
 507         }
 508
 509         /// <summary>
 510         /// The shader of the visual.
 511         /// </summary>
 512         /// <since_tizen> 3 </since_tizen>
 513         protected PropertyMap _shader = null;
 514         //private PropertyMap _transform = null;
 515
 516         /// <summary>
 517         /// The premultipliedAlpha of the visual.
 518         /// </summary>
 519         /// <since_tizen> 3 </since_tizen>
 520         protected bool? _premultipliedAlpha = null;
 521
 522         /// <summary>
 523         /// The mixColor of the Visual.
 524         /// </summary>
 525         /// <since_tizen> 3 </since_tizen>
 526         protected Color _mixColor = null;
 527
 528         /// <summary>
 529         /// The opacity of the visual.
 530         /// </summary>
 531         /// <since_tizen> 3 </since_tizen>
 532         protected float? _opacity = null;
 533
 534         /// <summary>
 535         /// The FittingMode of the visual.
 536         /// </summary>
 537         /// <since_tizen> 5 </since_tizen>
 538         protected VisualFittingModeType? _visualFittingMode = null;
 539
 540         /// <summary>
 541         /// The map for visual.
 542         /// </summary>
 543         /// <since_tizen> 3 </since_tizen>
 544         protected PropertyMap _commonlyUsedMap = null;
 545
 546         /// <summary>
 547         /// The shader to use in the visual.
 548         /// </summary>
 549         /// <since_tizen> 3 </since_tizen>
 550         public PropertyMap Shader
 551         {
 552             get
 553             {
 554                 return _shader;
 555             }
 556             set
 557             {
 558                 _shader = value;
 559                 UpdateVisual();
 560             }
 561         }
 562
 563         /// <summary>
 564         /// Enables or disables the premultiplied alpha. <br />
 565         /// The premultiplied alpha is false by default unless this behavior is modified by the derived visual type.
 566         /// </summary>
 567         /// <since_tizen> 3 </since_tizen>
 568         public bool PremultipliedAlpha
 569         {
 570             get
 571             {
 572                 return _premultipliedAlpha ?? (false);
 573             }
 574             set
 575             {
 576                 _premultipliedAlpha = value;
 577                 UpdateVisual();
 578             }
 579         }
 580
 581         /// <summary>
 582         /// Mix color is a blend color for any visual.
 583         /// </summary>
 584         /// <since_tizen> 3 </since_tizen>
 585         public Color MixColor
 586         {
 587             get
 588             {
 589                 return _mixColor;
 590             }
 591             set
 592             {
 593                 _mixColor = value;
 594                 UpdateVisual();
 595             }
 596         }
 597
 598         /// <summary>
 599         /// Opacity is the alpha component of the mix color discussed above.
 600         /// </summary>
 601         /// <since_tizen> 3 </since_tizen>
 602         public float Opacity
 603         {
 604             get
 605             {
 606                 return _opacity ?? (1.0f);
 607             }
 608             set
 609             {
 610                 _opacity = value;
 611                 UpdateVisual();
 612             }
 613         }
 614
 615         /// <summary>
 616         /// The fitting mode of the visual.
 617         /// The default is defined by the type of visual (if it is suitable to be stretched or not).
 618         /// </summary>
 619         /// <since_tizen> 5 </since_tizen>
 620         public VisualFittingModeType VisualFittingMode
 621         {
 622             get
 623             {
 624                 if (_visualFittingMode == null)
 625                 {
 626                     if (this is AnimatedImageVisual ||
 627                         this is MeshVisual ||
 628                         this is PrimitiveVisual ||
 629                         this is TextVisual)
 630                     {
 631                         return VisualFittingModeType.FitKeepAspectRatio;
 632                     }
 633                     else
 634                     {
 635                         return VisualFittingModeType.Fill;
 636                     }
 637                 }
 638                 else
 639                 {
 640                     return (VisualFittingModeType)_visualFittingMode;
 641                 }
 642             }
 643             set
 644             {
 645                 _visualFittingMode = value;
 646                 UpdateVisual();
 647             }
 648         }
 649     }
 650
 651     /// <summary>
 652     /// A class encapsulating the property map of the image visual.
 653     /// </summary>
 654     /// <since_tizen> 3 </since_tizen>
 655     public class ImageVisual : VisualMap
 656     {
 657         /// <summary>
 658         /// Constructor.
 659         /// </summary>
 660         /// <since_tizen> 3 </since_tizen>
 661         public ImageVisual() : base()
 662         {
 663         }
 664
 665         private string _url = null;
 666         private string _alphaMaskUrl = null;
 667         private string _auxiliaryImageUrl = null;
 668         private FittingModeType? _fittingMode = null;
 669         private SamplingModeType? _samplingMode = null;
 670         private int? _desiredWidth = null;
 671         private int? _desiredHeight = null;
 672         private bool? _synchronousLoading = false;
 673         private bool? _borderOnly = null;
 674         private Vector4 _pixelArea = null;
 675         private WrapModeType? _wrapModeU = null;
 676         private WrapModeType? _wrapModeV = null;
 677         private float? _auxiliaryImageAlpha = null;
 678         private float? _maskContentScale = null;
 679         private bool? _cropToMask = null;
 680         private ReleasePolicyType? _releasePolicy = null;
 681         private LoadPolicyType? _loadPolicy = null;
 682         private bool? _orientationCorrection = true;
 683         private bool? _atlasing = false;
 684
 685         /// <summary>
 686         /// Gets or sets the URL of the image.<br />
 687         /// Mandatory.
 688         /// </summary>
 689         /// <since_tizen> 3 </since_tizen>
 690         public string URL
 691         {
 692             get
 693             {
 694                 return _url;
 695             }
 696             set
 697             {
 698                 _url = value;
 699                 UpdateVisual();
 700             }
 701         }
 702
 703
 704         /// <summary>
 705         /// Gets or sets the URL of the alpha mask.<br />
 706         /// Optional.
 707         /// </summary>
 708         /// <since_tizen> 3 </since_tizen>
 709         public string AlphaMaskURL
 710         {
 711             get
 712             {
 713                 return _alphaMaskUrl;
 714             }
 715             set
 716             {
 717                 _alphaMaskUrl = value;
 718                 UpdateVisual();
 719             }
 720         }
 721
 722         /// <summary>
 723         /// Overlays the auxiliary image on top of an NPatch image.
 724         /// The resulting visual image will be at least as large as the smallest possible n-patch or the auxiliary image, whichever is larger.
 725         /// </summary>
 726         /// <since_tizen> 5 </since_tizen>
 727         public string AuxiliaryImageURL
 728         {
 729             get
 730             {
 731                 return _auxiliaryImageUrl;
 732             }
 733             set
 734             {
 735                 _auxiliaryImageUrl = value;
 736                 UpdateVisual();
 737             }
 738         }
 739
 740         /// <summary>
 741         /// Gets or sets fitting options used when resizing images to fit the desired dimensions.<br />
 742         /// If not supplied, the default is FittingModeType.ShrinkToFit.<br />
 743         /// For normal quad images only.<br />
 744         /// Optional.
 745         /// </summary>
 746         /// <since_tizen> 3 </since_tizen>
 747         public FittingModeType FittingMode
 748         {
 749             get
 750             {
 751                 return _fittingMode ?? (FittingModeType.ShrinkToFit);
 752             }
 753             set
 754             {
 755                 _fittingMode = value;
 756                 UpdateVisual();
 757             }
 758         }
 759
 760         /// <summary>
 761         /// Gets or sets filtering options used when resizing images to the sample original pixels.<br />
 762         /// If not supplied, the default is SamplingModeType.Box.<br />
 763         /// For normal quad images only.<br />
 764         /// Optional.
 765         /// </summary>
 766         /// <since_tizen> 3 </since_tizen>
 767         public SamplingModeType SamplingMode
 768         {
 769             get
 770             {
 771                 return _samplingMode ?? (SamplingModeType.Box);
 772             }
 773             set
 774             {
 775                 _samplingMode = value;
 776                 UpdateVisual();
 777             }
 778         }
 779
 780         /// <summary>
 781         /// Gets or sets the desired image width.<br />
 782         /// If not specified, the actual image width is used.<br />
 783         /// For normal quad images only.<br />
 784         /// Optional.
 785         /// </summary>
 786         /// <since_tizen> 3 </since_tizen>
 787         public int DesiredWidth
 788         {
 789             get
 790             {
 791                 return _desiredWidth ?? (-1);
 792             }
 793             set
 794             {
 795                 _desiredWidth = value;
 796                 UpdateVisual();
 797             }
 798         }
 799
 800         /// <summary>
 801         /// Gets or sets the desired image height.<br />
 802         /// If not specified, the actual image height is used.<br />
 803         /// For normal quad images only.<br />
 804         /// Optional.
 805         /// </summary>
 806         /// <since_tizen> 3 </since_tizen>
 807         public int DesiredHeight
 808         {
 809             get
 810             {
 811                 return _desiredHeight ?? (-1);
 812             }
 813             set
 814             {
 815                 _desiredHeight = value;
 816                 UpdateVisual();
 817             }
 818         }
 819
 820         /// <summary>
 821         /// Gets or sets whether to load the image synchronously.<br />
 822         /// If not specified, the default is false, i.e., the image is loaded asynchronously.<br />
 823         /// For normal quad images only.<br />
 824         /// Optional.
 825         /// </summary>
 826         /// <since_tizen> 3 </since_tizen>
 827         public bool SynchronousLoading
 828         {
 829             get
 830             {
 831                 return _synchronousLoading ?? (false);
 832             }
 833             set
 834             {
 835                 _synchronousLoading = value;
 836                 UpdateVisual();
 837             }
 838         }
 839
 840         /// <summary>
 841         /// Gets or sets whether to draw the borders only (If true).<br />
 842         /// If not specified, the default is false.<br />
 843         /// For n-patch images only.<br />
 844         /// Optional.
 845         /// </summary>
 846         /// <since_tizen> 3 </since_tizen>
 847         public bool BorderOnly
 848         {
 849             get
 850             {
 851                 return _borderOnly ?? (false);
 852             }
 853             set
 854             {
 855                 _borderOnly = value;
 856                 UpdateVisual();
 857             }
 858         }
 859
 860         /// <summary>
 861         /// Gets or sets the image area to be displayed.<br />
 862         /// It is a rectangular area.<br />
 863         /// The first two elements indicate the top-left position of the area, and the last two elements are the areas of the width and the height respectively.<br />
 864         /// If not specified, the default value is Vector4 (0.0, 0.0, 1.0, 1.0), i.e., the entire area of the image.<br />
 865         /// For normal quad images only.<br />
 866         /// Optional.
 867         /// </summary>
 868         /// <since_tizen> 3 </since_tizen>
 869         public Vector4 PixelArea
 870         {
 871             get
 872             {
 873                 return _pixelArea ?? (new Vector4(0.0f, 0.0f, 1.0f, 1.0f));
 874             }
 875             set
 876             {
 877                 _pixelArea = value;
 878                 UpdateVisual();
 879             }
 880         }
 881
 882         /// <summary>
 883         /// Gets or sets the wrap mode for the u coordinate.<br />
 884         /// It decides how the texture should be sampled when the u coordinate exceeds the range of 0.0 to 1.0.<br />
 885         /// If not specified, the default is WrapModeType.Default(CLAMP).<br />
 886         /// For normal quad images only.<br />
 887         /// Optional.
 888         /// </summary>
 889         /// <since_tizen> 3 </since_tizen>
 890         public WrapModeType WrapModeU
 891         {
 892             get
 893             {
 894                 return _wrapModeU ?? (WrapModeType.Default);
 895             }
 896             set
 897             {
 898                 _wrapModeU = value;
 899                 UpdateVisual();
 900             }
 901         }
 902
 903         /// <summary>
 904         /// Gets or sets the wrap mode for the v coordinate.<br />
 905         /// It decides how the texture should be sampled when the v coordinate exceeds the range of 0.0 to 1.0.<br />
 906         /// The first two elements indicate the top-left position of the area, and the last two elements are the areas of the width and the height respectively.<br />
 907         /// If not specified, the default is WrapModeType.Default(CLAMP).<br />
 908         /// For normal quad images only.
 909         /// Optional.
 910         /// </summary>
 911         /// <since_tizen> 3 </since_tizen>
 912         public WrapModeType WrapModeV
 913         {
 914             get
 915             {
 916                 return _wrapModeV ?? (WrapModeType.Default);
 917             }
 918             set
 919             {
 920                 _wrapModeV = value;
 921                 UpdateVisual();
 922             }
 923         }
 924
 925         /// <summary>
 926         /// Gets or sets scale factor to apply to the content image before masking.
 927         /// </summary>
 928         /// <since_tizen> 4 </since_tizen>
 929         public float MaskContentScale
 930         {
 931             get
 932             {
 933                 return _maskContentScale ?? 1.0f;
 934             }
 935             set
 936             {
 937                 _maskContentScale = value;
 938                 UpdateVisual();
 939             }
 940         }
 941
 942         /// <summary>
 943         ///  Whether to crop image to mask or scale mask to fit image.
 944         /// </summary>
 945         /// <since_tizen> 4 </since_tizen>
 946         public bool CropToMask
 947         {
 948             get
 949             {
 950                 return _cropToMask ?? false;
 951             }
 952             set
 953             {
 954                 _cropToMask = value;
 955                 UpdateVisual();
 956             }
 957         }
 958
 959         /// <summary>
 960         ///  An alpha value for mixing between the masked main NPatch image and the auxiliary image.
 961         /// </summary>
 962         /// <since_tizen> 5 </since_tizen>
 963         public float AuxiliaryImageAlpha
 964         {
 965             get
 966             {
 967                 return _auxiliaryImageAlpha ?? 1.0f;
 968             }
 969             set
 970             {
 971                 _auxiliaryImageAlpha = value;
 972                 UpdateVisual();
 973             }
 974         }
 975
 976         /// <summary>
 977         /// Gets or sets the Image Visual release policy.<br/>
 978         /// It decides if a texture should be released from the cache or kept to reduce the loading time.<br/>
 979         /// </summary>
 980         /// <since_tizen> 5 </since_tizen>
 981         public ReleasePolicyType ReleasePolicy
 982         {
 983             get
 984             {
 985                 return _releasePolicy ?? (ReleasePolicyType.Destroyed );
 986             }
 987             set
 988             {
 989                 _releasePolicy = value;
 990                 UpdateVisual();
 991             }
 992         }
 993
 994
 995         /// <summary>
 996         /// Gets or sets the Image Visual image loading policy.<br />
 997         /// It decides if a texture should be loaded immediately after source set or only after the visual is added to the window.<br />
 998         /// </summary>
 999         /// <since_tizen> 5 </since_tizen>
1000         public LoadPolicyType LoadPolicy
1001         {
1002             get
1003             {
1004                 return _loadPolicy ?? (LoadPolicyType.Attached);
1005             }
1006             set
1007             {
1008                 _loadPolicy = value;
1009                 UpdateVisual();
1010             }
1011         }
1012
1013         /// <summary>
1014         /// Gets or sets whether to automatically correct the orientation based on the Exchangeable Image File (EXIF) data.<br />
1015         /// If not specified, the default is true.<br />
1016         /// For JPEG images only.<br />
1017         /// Optional.
1018         /// </summary>
1019         /// <since_tizen> 5 </since_tizen>
1020         public bool OrientationCorrection
1021         {
1022             get
1023             {
1024                 return _orientationCorrection ?? (true);
1025             }
1026             set
1027             {
1028                 _orientationCorrection = value;
1029                 UpdateVisual();
1030             }
1031         }
1032
1033         /// <summary>
1034         /// Whether to use the texture atlas or not.
1035         /// Optional. By default atlasing is off.
1036         /// </summary>
1037         /// <since_tizen> 5 </since_tizen>
1038         public bool Atlasing
1039         {
1040             get
1041             {
1042                 return _atlasing ?? (false);
1043             }
1044             set
1045             {
1046                 _atlasing = value;
1047                 UpdateVisual();
1048             }
1049         }
1050
1051         /// <summary>
1052         /// Compose the out visual map.
1053         /// </summary>
1054         /// <since_tizen> 3 </since_tizen>
1055         protected override void ComposingPropertyMap()
1056         {
1057             if (_url != null)
1058             {
1059                 _outputVisualMap = new PropertyMap();
1060                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Image));
1061                 _outputVisualMap.Add(ImageVisualProperty.URL, new PropertyValue(_url));
1062                 if (_alphaMaskUrl != null ) { _outputVisualMap.Add(ImageVisualProperty.AlphaMaskURL, new PropertyValue(_alphaMaskUrl)); }
1063                 if (_auxiliaryImageUrl != null ) { _outputVisualMap.Add(ImageVisualProperty.AuxiliaryImageURL, new PropertyValue(_auxiliaryImageUrl)); }
1064                 if (_fittingMode != null) { _outputVisualMap.Add(ImageVisualProperty.FittingMode, new PropertyValue((int)_fittingMode)); }
1065                 if (_samplingMode != null) { _outputVisualMap.Add(ImageVisualProperty.SamplingMode, new PropertyValue((int)_samplingMode)); }
1066                 if (_desiredWidth != null) { _outputVisualMap.Add(ImageVisualProperty.DesiredWidth, new PropertyValue((int)_desiredWidth)); }
1067                 if (_desiredHeight != null) { _outputVisualMap.Add(ImageVisualProperty.DesiredHeight, new PropertyValue((int)_desiredHeight)); }
1068                 if (_synchronousLoading != null) { _outputVisualMap.Add(ImageVisualProperty.SynchronousLoading, new PropertyValue((bool)_synchronousLoading)); }
1069                 if (_borderOnly != null) { _outputVisualMap.Add(ImageVisualProperty.BorderOnly, new PropertyValue((bool)_borderOnly)); }
1070                 if (_pixelArea != null) { _outputVisualMap.Add(ImageVisualProperty.PixelArea, new PropertyValue(_pixelArea)); }
1071                 if (_wrapModeU != null) { _outputVisualMap.Add(ImageVisualProperty.WrapModeU, new PropertyValue((int)_wrapModeU)); }
1072                 if (_wrapModeV != null) { _outputVisualMap.Add(ImageVisualProperty.WrapModeV, new PropertyValue((int)_wrapModeV)); }
1073                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
1074                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
1075                 if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
1076                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
1077                 if (_maskContentScale != null) { _outputVisualMap.Add((int)ImageVisualProperty.MaskContentScale, new PropertyValue((float)_maskContentScale)); }
1078                 if (_cropToMask != null) { _outputVisualMap.Add((int)ImageVisualProperty.CropToMask, new PropertyValue((bool)_cropToMask)); }
1079                 if (_auxiliaryImageAlpha != null) { _outputVisualMap.Add((int)ImageVisualProperty.AuxiliaryImageAlpha, new PropertyValue((float)_auxiliaryImageAlpha)); }
1080                 if (_releasePolicy != null) { _outputVisualMap.Add( ImageVisualProperty.ReleasePolicy , new PropertyValue((int)_releasePolicy)); }
1081                 if (_loadPolicy != null) { _outputVisualMap.Add( ImageVisualProperty.LoadPolicy, new PropertyValue((int)_loadPolicy)); }
1082                 if (_orientationCorrection != null) { _outputVisualMap.Add( ImageVisualProperty.OrientationCorrection, new PropertyValue((bool)_orientationCorrection)); }
1083                 if (_atlasing != null) { _outputVisualMap.Add( ImageVisualProperty.Atlasing, new PropertyValue((bool)_atlasing)); }
1084                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
1085             }
1086         }
1087     }
1088
1089     /// <summary>
1090     /// A class encapsulating the property map of the text visual.
1091     /// </summary>
1092     /// <since_tizen> 3 </since_tizen>
1093     public class TextVisual : VisualMap
1094     {
1095         /// <summary>
1096         /// Constructor.
1097         /// </summary>
1098         /// <since_tizen> 3 </since_tizen>
1099         public TextVisual() : base()
1100         {
1101         }
1102
1103         private string _text = null;
1104         private string _fontFamily = null;
1105         private PropertyMap _fontStyle = null;
1106         private float? _pointSize = null;
1107         private bool? _multiLine = null;
1108         private string _horizontalAlignment = null;
1109         private string _verticalAlignment = null;
1110         private Color _textColor = null;
1111         private bool? _enableMarkup = null;
1112         private PropertyMap _shadow = null;
1113         private PropertyMap _underline = null;
1114         private PropertyMap _outline = null;
1115         private PropertyMap _background = null;
1116
1117         /// <summary>
1118         /// Gets or sets the text to display in the UTF-8 format.<br />
1119         /// Mandatory.
1120         /// </summary>
1121         /// <since_tizen> 3 </since_tizen>
1122         public string Text
1123         {
1124             get
1125             {
1126                 return _text;
1127             }
1128             set
1129             {
1130                 _text = value;
1131                 UpdateVisual();
1132             }
1133         }
1134
1135         /// <summary>
1136         /// Gets or sets the requested font family to use.<br />
1137         /// Optional.
1138         /// </summary>
1139         /// <since_tizen> 3 </since_tizen>
1140         public string FontFamily
1141         {
1142             get
1143             {
1144                 return _fontFamily;
1145             }
1146             set
1147             {
1148                 _fontFamily = value;
1149                 UpdateVisual();
1150             }
1151         }
1152
1153         /// <summary>
1154         /// Gets or sets the requested font style to use.<br />
1155         /// Optional.
1156         /// </summary>
1157         /// <since_tizen> 3 </since_tizen>
1158         public PropertyMap FontStyle
1159         {
1160             get
1161             {
1162                 return _fontStyle;
1163             }
1164             set
1165             {
1166                 _fontStyle = value;
1167                 UpdateVisual();
1168             }
1169         }
1170
1171         /// <summary>
1172         /// Gets or sets the size of font in points.<br />
1173         /// Mandatory.
1174         /// </summary>
1175         /// <since_tizen> 3 </since_tizen>
1176         public float PointSize
1177         {
1178             get
1179             {
1180                 return _pointSize ?? (0.0f);
1181             }
1182             set
1183             {
1184                 _pointSize = value;
1185                 UpdateVisual();
1186             }
1187         }
1188
1189         /// <summary>
1190         /// Gets or sets the single-line or multi-line layout option.<br />
1191         /// If not specified, the default is false.<br />
1192         /// Optional.
1193         /// </summary>
1194         /// <since_tizen> 3 </since_tizen>
1195         public bool MultiLine
1196         {
1197             get
1198             {
1199                 return _multiLine ?? (false);
1200             }
1201             set
1202             {
1203                 _multiLine = value;
1204                 UpdateVisual();
1205             }
1206         }
1207
1208         /// <summary>
1209         /// Gets or sets the line horizontal alignment.<br />
1210         /// If not specified, the default is begin.<br />
1211         /// Optional.
1212         /// </summary>
1213         /// <since_tizen> 3 </since_tizen>
1214         public HorizontalAlignment HorizontalAlignment
1215         {
1216             get
1217             {
1218                 switch (_horizontalAlignment)
1219                 {
1220                     case "BEGIN":
1221                         return HorizontalAlignment.Begin;
1222                     case "CENTER":
1223                         return HorizontalAlignment.Center;
1224                     case "END":
1225                         return HorizontalAlignment.End;
1226                     default:
1227                         return HorizontalAlignment.Begin;
1228                 }
1229             }
1230             set
1231             {
1232                 switch (value)
1233                 {
1234                     case HorizontalAlignment.Begin:
1235                     {
1236                         _horizontalAlignment = "BEGIN";
1237                         break;
1238                     }
1239                     case HorizontalAlignment.Center:
1240                     {
1241                         _horizontalAlignment = "CENTER";
1242                         break;
1243                     }
1244                     case HorizontalAlignment.End:
1245                     {
1246                         _horizontalAlignment = "END";
1247                         break;
1248                     }
1249                     default:
1250                     {
1251                         _horizontalAlignment = "BEGIN";
1252                         break;
1253                     }
1254                 }
1255                 UpdateVisual();
1256             }
1257         }
1258
1259         /// <summary>
1260         /// Gets or sets the line vertical alignment.<br />
1261         /// If not specified, the default is top.<br />
1262         /// Optional.
1263         /// </summary>
1264         /// <since_tizen> 3 </since_tizen>
1265         public VerticalAlignment VerticalAlignment
1266         {
1267             get
1268             {
1269                 switch (_verticalAlignment)
1270                 {
1271                     case "TOP":
1272                         return VerticalAlignment.Top;
1273                     case "CENTER":
1274                         return VerticalAlignment.Center;
1275                     case "BOTTOM":
1276                         return VerticalAlignment.Bottom;
1277                     default:
1278                         return VerticalAlignment.Top;
1279                 }
1280             }
1281             set
1282             {
1283                 switch (value)
1284                 {
1285                     case VerticalAlignment.Top:
1286                     {
1287                         _verticalAlignment = "TOP";
1288                         break;
1289                     }
1290                     case VerticalAlignment.Center:
1291                     {
1292                         _verticalAlignment = "CENTER";
1293                         break;
1294                     }
1295                     case VerticalAlignment.Bottom:
1296                     {
1297                         _verticalAlignment = "BOTTOM";
1298                         break;
1299                     }
1300                     default:
1301                     {
1302                         _verticalAlignment = "TOP";
1303                         break;
1304                     }
1305                 }
1306                 UpdateVisual();
1307             }
1308         }
1309
1310         /// <summary>
1311         /// Gets or sets the color of the text.<br />
1312         /// Optional.
1313         /// </summary>
1314         /// <since_tizen> 3 </since_tizen>
1315         public Color TextColor
1316         {
1317             get
1318             {
1319                 return _textColor;
1320             }
1321             set
1322             {
1323                 _textColor = value;
1324                 UpdateVisual();
1325             }
1326         }
1327
1328         /// <summary>
1329         /// Gets or sets whether the mark-up processing is enabled.<br />
1330         /// Optional.
1331         /// </summary>
1332         /// <since_tizen> 3 </since_tizen>
1333         public bool EnableMarkup
1334         {
1335             get
1336             {
1337                 return _enableMarkup ?? (false);
1338             }
1339             set
1340             {
1341                 _enableMarkup = value;
1342                 UpdateVisual();
1343             }
1344         }
1345
1346         /// <summary>
1347         /// Gets or sets the shadow parameters.
1348         /// </summary>
1349         /// <since_tizen> 5 </since_tizen>
1350         public PropertyMap Shadow
1351         {
1352             get
1353             {
1354                 return _shadow;
1355             }
1356             set
1357             {
1358                 _shadow = value;
1359                 UpdateVisual();
1360             }
1361         }
1362
1363         /// <summary>
1364         /// Gets or sets the underline parameters.
1365         /// </summary>
1366         /// <since_tizen> 5 </since_tizen>
1367         public PropertyMap Underline
1368         {
1369             get
1370             {
1371                 return _underline;
1372             }
1373             set
1374             {
1375                 _underline = value;
1376                 UpdateVisual();
1377             }
1378         }
1379
1380         /// <summary>
1381         /// Gets or sets the outline parameters.
1382         /// </summary>
1383         /// <since_tizen> 5 </since_tizen>
1384         public PropertyMap Outline
1385         {
1386             get
1387             {
1388                 return _outline;
1389             }
1390             set
1391             {
1392                 _outline = value;
1393                 UpdateVisual();
1394             }
1395         }
1396
1397         /// <summary>
1398         /// Gets or sets the background parameters.
1399         /// </summary>
1400         /// <since_tizen> 5 </since_tizen>
1401         public PropertyMap Background
1402         {
1403             get
1404             {
1405                 return _background;
1406             }
1407             set
1408             {
1409                 _background = value;
1410                 UpdateVisual();
1411             }
1412         }
1413
1414         /// <summary>
1415         /// Compose the out visual map.
1416         /// </summary>
1417         /// <since_tizen> 3 </since_tizen>
1418         protected override void ComposingPropertyMap()
1419         {
1420             if (_text != null && _pointSize != null)
1421             {
1422                 _outputVisualMap = new PropertyMap();
1423                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Text));
1424                 _outputVisualMap.Add(TextVisualProperty.Text, new PropertyValue(_text));
1425                 _outputVisualMap.Add(TextVisualProperty.PointSize, new PropertyValue((float)_pointSize));
1426                 if (_fontFamily != null) { _outputVisualMap.Add(TextVisualProperty.FontFamily, new PropertyValue(_fontFamily)); }
1427                 if (_fontStyle != null) { _outputVisualMap.Add(TextVisualProperty.FontStyle, new PropertyValue(_fontStyle)); }
1428                 if (_multiLine != null) { _outputVisualMap.Add(TextVisualProperty.MultiLine, new PropertyValue((bool)_multiLine)); }
1429                 if (_horizontalAlignment != null) { _outputVisualMap.Add(TextVisualProperty.HorizontalAlignment, new PropertyValue(_horizontalAlignment)); }
1430                 if (_verticalAlignment != null) { _outputVisualMap.Add(TextVisualProperty.VerticalAlignment, new PropertyValue(_verticalAlignment)); }
1431                 if (_textColor != null) { _outputVisualMap.Add(TextVisualProperty.TextColor, new PropertyValue(_textColor)); }
1432                 if (_enableMarkup != null) { _outputVisualMap.Add(TextVisualProperty.EnableMarkup, new PropertyValue((bool)_enableMarkup)); }
1433                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
1434                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
1435                 if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
1436                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
1437                 if (_shadow != null) { _outputVisualMap.Add(TextVisualProperty.Shadow, new PropertyValue(_shadow)); }
1438                 if (_underline != null) { _outputVisualMap.Add(TextVisualProperty.Underline, new PropertyValue(_underline)); }
1439                 if (_outline != null) { _outputVisualMap.Add(TextVisualProperty.Outline, new PropertyValue(_outline)); }
1440                 if (_background != null) { _outputVisualMap.Add(TextVisualProperty.Background, new PropertyValue(_background)); }
1441                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
1442             }
1443         }
1444     }
1445
1446     /// <summary>
1447     /// A class encapsulating the property map of the border visual.
1448     /// </summary>
1449     /// <since_tizen> 3 </since_tizen>
1450     public class BorderVisual : VisualMap
1451     {
1452         /// <summary>
1453         /// Constructor.
1454         /// </summary>
1455         /// <since_tizen> 3 </since_tizen>
1456         public BorderVisual() : base()
1457         {
1458         }
1459
1460         private Color _color = null;
1461         private float? _size = null;
1462         private bool? _antiAliasing = null;
1463
1464         /// <summary>
1465         /// Gets or sets the color of the border.<br />
1466         /// Mandatory.
1467         /// </summary>
1468         /// <since_tizen> 3 </since_tizen>
1469         public Color Color
1470         {
1471             get
1472             {
1473                 return _color;
1474             }
1475             set
1476             {
1477                 _color = value;
1478                 UpdateVisual();
1479             }
1480         }
1481
1482         /// <summary>
1483         /// Gets or sets the width of the border (in pixels).<br />
1484         /// Mandatory.
1485         /// </summary>
1486         /// <since_tizen> 3 </since_tizen>
1487         public float BorderSize
1488         {
1489             get
1490             {
1491                 return _size ?? (-1.0f);
1492             }
1493             set
1494             {
1495                 _size = value;
1496                 UpdateVisual();
1497             }
1498         }
1499
1500         /// <summary>
1501         /// Gets or sets whether the anti-aliasing of the border is required.<br />
1502         /// If not supplied, the default is false.<br />
1503         /// Optional.
1504         /// </summary>
1505         /// <since_tizen> 3 </since_tizen>
1506         public bool AntiAliasing
1507         {
1508             get
1509             {
1510                 return _antiAliasing ?? (false);
1511             }
1512             set
1513             {
1514                 _antiAliasing = value;
1515                 UpdateVisual();
1516             }
1517         }
1518
1519         /// <summary>
1520         /// Compose the out visual map.
1521         /// </summary>
1522         /// <since_tizen> 3 </since_tizen>
1523         protected override void ComposingPropertyMap()
1524         {
1525             if (_color != null && _size != null)
1526             {
1527                 _outputVisualMap = new PropertyMap();
1528                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Border));
1529                 _outputVisualMap.Add(BorderVisualProperty.Size, new PropertyValue((float)_size));
1530                 _outputVisualMap.Add(BorderVisualProperty.Color, new PropertyValue(_color));
1531                 if (_antiAliasing != null) { _outputVisualMap.Add(BorderVisualProperty.AntiAliasing, new PropertyValue((bool)_antiAliasing)); }
1532                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
1533                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
1534                 if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
1535                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
1536                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
1537             }
1538         }
1539     }
1540
1541     /// <summary>
1542     /// A class encapsulating the property map of the color visual.
1543     /// </summary>
1544     /// <since_tizen> 3 </since_tizen>
1545     public class ColorVisual : VisualMap
1546     {
1547         /// <summary>
1548         /// Constructor.
1549         /// </summary>
1550         /// <since_tizen> 3 </since_tizen>
1551         public ColorVisual() : base()
1552         {
1553         }
1554
1555         private Color _mixColorForColorVisual = null;
1556         private bool? _renderIfTransparent = false;
1557
1558         /// <summary>
1559         /// Gets or sets the solid color required.<br />
1560         /// Mandatory.
1561         /// </summary>
1562         /// <since_tizen> 3 </since_tizen>
1563         public Color Color
1564         {
1565             get
1566             {
1567                 return _mixColorForColorVisual;
1568             }
1569             set
1570             {
1571                 _mixColorForColorVisual = value;
1572                 UpdateVisual();
1573             }
1574         }
1575
1576         /// <summary>
1577         /// Gets or sets whether to render if the MixColor is transparent.
1578         /// By default it is false, which means that the ColorVisual will not render if the MIX_COLOR is transparent.
1579         /// </summary>
1580         /// <since_tizen> 5 </since_tizen>
1581         public bool RenderIfTransparent
1582         {
1583             get
1584             {
1585                 return _renderIfTransparent ?? (false);
1586             }
1587             set
1588             {
1589                 _renderIfTransparent = value;
1590                 UpdateVisual();
1591             }
1592         }
1593
1594         /// <summary>
1595         /// Compose the out visual map.
1596         /// </summary>
1597         /// <since_tizen> 3 </since_tizen>
1598         protected override void ComposingPropertyMap()
1599         {
1600             if (_mixColorForColorVisual != null)
1601             {
1602                 _outputVisualMap = new PropertyMap();
1603                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Color));
1604                 _outputVisualMap.Add(ColorVisualProperty.MixColor, new PropertyValue(_mixColorForColorVisual));
1605                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
1606                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
1607                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
1608                 if (_renderIfTransparent != null) { _outputVisualMap.Add(ColorVisualProperty.RenderIfTransparent, new PropertyValue((bool)_renderIfTransparent)); }
1609                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
1610             }
1611         }
1612     }
1613
1614     /// <summary>
1615     /// A class encapsulating the property map of the gradient visual.
1616     /// </summary>
1617     /// <since_tizen> 3 </since_tizen>
1618     public class GradientVisual : VisualMap
1619     {
1620         /// <summary>
1621         /// Constructor.
1622         /// </summary>
1623         /// <since_tizen> 3 </since_tizen>
1624         public GradientVisual() : base()
1625         {
1626         }
1627
1628         private Vector2 _startPosition = null;
1629         private Vector2 _endPosition = null;
1630         private Vector2 _center = null;
1631         private float? _radius = null;
1632         private PropertyArray _stopOffset = null;
1633         private PropertyArray _stopColor = null;
1634         private GradientVisualUnitsType? _units = null;
1635         private GradientVisualSpreadMethodType? _spreadMethod = null;
1636
1637         /// <summary>
1638         /// Gets or sets the start position of a linear gradient.<br />
1639         /// Mandatory for linear.<br />
1640         /// </summary>
1641         /// <since_tizen> 3 </since_tizen>
1642         public Vector2 StartPosition
1643         {
1644             get
1645             {
1646                 return _startPosition;
1647             }
1648             set
1649             {
1650                 _startPosition = value;
1651                 UpdateVisual();
1652             }
1653         }
1654
1655         /// <summary>
1656         /// Gets or sets the end position of a linear gradient.<br />
1657         /// Mandatory for linear.<br />
1658         /// </summary>
1659         /// <since_tizen> 3 </since_tizen>
1660         public Vector2 EndPosition
1661         {
1662             get
1663             {
1664                 return _endPosition;
1665             }
1666             set
1667             {
1668                 _endPosition = value;
1669                 UpdateVisual();
1670             }
1671         }
1672
1673         /// <summary>
1674         /// Gets or sets the center point of a radial gradient.<br />
1675         /// Mandatory for radial.<br />
1676         /// </summary>
1677         /// <since_tizen> 3 </since_tizen>
1678         public Vector2 Center
1679         {
1680             get
1681             {
1682                 return _center;
1683             }
1684             set
1685             {
1686                 _center = value;
1687                 UpdateVisual();
1688             }
1689         }
1690
1691         /// <summary>
1692         /// Gets or sets the size of the radius of a radial gradient.<br />
1693         /// Mandatory for radial.<br />
1694         /// </summary>
1695         /// <since_tizen> 3 </since_tizen>
1696         public float Radius
1697         {
1698             get
1699             {
1700                 return _radius ?? (-1.0f);
1701             }
1702             set
1703             {
1704                 _radius = value;
1705                 UpdateVisual();
1706             }
1707         }
1708
1709         /// <summary>
1710         /// Gets or sets all the stop offsets.<br />
1711         /// A PropertyArray of float.<br />
1712         /// If not supplied, the default is 0.0f and 1.0f.<br />
1713         /// Optional.
1714         /// </summary>
1715         /// <since_tizen> 3 </since_tizen>
1716         public PropertyArray StopOffset
1717         {
1718             get
1719             {
1720                 return _stopOffset;
1721             }
1722             set
1723             {
1724                 _stopOffset = value;
1725                 UpdateVisual();
1726             }
1727         }
1728
1729         /// <summary>
1730         /// Gets or sets the color at the stop offsets.<br />
1731         /// A PropertyArray of color.<br />
1732         /// At least 2 values are required to show a gradient.<br />
1733         /// Mandatory.
1734         /// </summary>
1735         /// <since_tizen> 3 </since_tizen>
1736         public PropertyArray StopColor
1737         {
1738             get
1739             {
1740                 return _stopColor;
1741             }
1742             set
1743             {
1744                 _stopColor = value;
1745                 UpdateVisual();
1746             }
1747         }
1748
1749         /// <summary>
1750         /// Gets or sets descriptions of the coordinate system for certain attributes of the points in a gradient.<br />
1751         /// If not supplied, the default is GradientVisualUnitsType.ObjectBoundingBox.<br />
1752         /// Optional.
1753         /// </summary>
1754         /// <since_tizen> 3 </since_tizen>
1755         public GradientVisualUnitsType Units
1756         {
1757             get
1758             {
1759                 return _units ?? (GradientVisualUnitsType.ObjectBoundingBox);
1760             }
1761             set
1762             {
1763                 _units = value;
1764                 UpdateVisual();
1765             }
1766         }
1767
1768         /// <summary>
1769         /// Gets or sets indications of what happens if the gradient starts or ends inside the bounds of the target rectangle.<br />
1770         /// If not supplied, the default is GradientVisualSpreadMethodType.Pad.<br />
1771         /// Optional.
1772         /// </summary>
1773         /// <since_tizen> 3 </since_tizen>
1774         public GradientVisualSpreadMethodType SpreadMethod
1775         {
1776             get
1777             {
1778                 return _spreadMethod ?? (GradientVisualSpreadMethodType.Pad);
1779             }
1780             set
1781             {
1782                 _spreadMethod = value;
1783                 UpdateVisual();
1784             }
1785         }
1786
1787         /// <summary>
1788         /// Compose the out visual map.
1789         /// </summary>
1790         /// <since_tizen> 3 </since_tizen>
1791         protected override void ComposingPropertyMap()
1792         {
1793             if (((_startPosition != null && _endPosition != null) || (_center != null && _radius != null)) && _stopColor != null)
1794             {
1795                 _outputVisualMap = new PropertyMap();
1796                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Gradient));
1797                 _outputVisualMap.Add(GradientVisualProperty.StopColor, new PropertyValue(_stopColor));
1798                 if (_startPosition != null) { _outputVisualMap.Add(GradientVisualProperty.StartPosition, new PropertyValue(_startPosition)); }
1799                 if (_endPosition != null) { _outputVisualMap.Add(GradientVisualProperty.EndPosition, new PropertyValue(_endPosition)); }
1800                 if (_center != null) { _outputVisualMap.Add(GradientVisualProperty.Center, new PropertyValue(_center)); }
1801                 if (_radius != null) { _outputVisualMap.Add(GradientVisualProperty.Radius, new PropertyValue((float)_radius)); }
1802                 if (_stopOffset != null) { _outputVisualMap.Add(GradientVisualProperty.StopOffset, new PropertyValue(_stopOffset)); }
1803                 if (_units != null) { _outputVisualMap.Add(GradientVisualProperty.Units, new PropertyValue((int)_units)); }
1804                 if (_spreadMethod != null) { _outputVisualMap.Add(GradientVisualProperty.SpreadMethod, new PropertyValue((int)_spreadMethod)); }
1805                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
1806                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
1807                 if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
1808                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
1809                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
1810             }
1811         }
1812     }
1813
1814     /// <summary>
1815     /// A class encapsulating the property map of the mesh visual.
1816     /// </summary>
1817     /// <since_tizen> 3 </since_tizen>
1818     public class MeshVisual : VisualMap
1819     {
1820         /// <summary>
1821         /// Constructor.
1822         /// </summary>
1823         /// <since_tizen> 3 </since_tizen>
1824         public MeshVisual() : base()
1825         {
1826         }
1827
1828         private string _objectURL = null;
1829         private string _materialtURL = null;
1830         private string _texturesPath = null;
1831         private MeshVisualShadingModeValue? _shadingMode = null;
1832         private bool? _useMipmapping = null;
1833         private bool? _useSoftNormals = null;
1834         private Vector3 _lightPosition = null;
1835
1836         /// <summary>
1837         /// Gets or sets the location of the ".obj" file.<br />
1838         /// Mandatory.
1839         /// </summary>
1840         /// <since_tizen> 3 </since_tizen>
1841         public string ObjectURL
1842         {
1843             get
1844             {
1845                 return _objectURL;
1846             }
1847             set
1848             {
1849                 _objectURL = value;
1850                 UpdateVisual();
1851             }
1852         }
1853
1854         /// <summary>
1855         /// Gets or sets the location of the ".mtl" file.<br />
1856         /// If not specified, then a textureless object is assumed.<br />
1857         /// Optional.
1858         /// </summary>
1859         /// <since_tizen> 3 </since_tizen>
1860         public string MaterialtURL
1861         {
1862             get
1863             {
1864                 return _materialtURL;
1865             }
1866             set
1867             {
1868                 _materialtURL = value;
1869                 UpdateVisual();
1870             }
1871         }
1872
1873         /// <summary>
1874         /// Gets or sets the path to the directory the textures (including gloss and normal) are stored in.<br />
1875         /// Mandatory if using material.<br />
1876         /// </summary>
1877         /// <since_tizen> 3 </since_tizen>
1878         public string TexturesPath
1879         {
1880             get
1881             {
1882                 return _texturesPath;
1883             }
1884             set
1885             {
1886                 _texturesPath = value;
1887                 UpdateVisual();
1888             }
1889         }
1890
1891         /// <summary>
1892         /// Gets or sets the type of shading mode that the mesh will use.<br />
1893         /// If anything the specified shading mode requires is missing, a simpler mode that can be handled with what has been supplied will be used instead.<br />
1894         /// If not specified, it will use the best it can support (will try MeshVisualShadingModeValue.TexturedWithDetailedSpecularLighting first).<br />
1895         /// Optional.
1896         /// </summary>
1897         /// <since_tizen> 3 </since_tizen>
1898         public MeshVisualShadingModeValue ShadingMode
1899         {
1900             get
1901             {
1902                 return _shadingMode ?? (MeshVisualShadingModeValue.TexturedWithDetailedSpecularLighting);
1903             }
1904             set
1905             {
1906                 _shadingMode = value;
1907                 UpdateVisual();
1908             }
1909         }
1910
1911         /// <summary>
1912         /// Gets or sets whether to use mipmaps for textures or not.<br />
1913         /// If not specified, the default is true.<br />
1914         /// Optional.
1915         /// </summary>
1916         /// <since_tizen> 3 </since_tizen>
1917         public bool UseMipmapping
1918         {
1919             get
1920             {
1921                 return _useMipmapping ?? (true);
1922             }
1923             set
1924             {
1925                 _useMipmapping = value;
1926                 UpdateVisual();
1927             }
1928         }
1929
1930         /// <summary>
1931         /// Gets or sets whether to average normals at each point to smooth textures or not.<br />
1932         /// If not specified, the default is true.<br />
1933         /// Optional.
1934         /// </summary>
1935         /// <since_tizen> 3 </since_tizen>
1936         public bool UseSoftNormals
1937         {
1938             get
1939             {
1940                 return _useSoftNormals ?? (true);
1941             }
1942             set
1943             {
1944                 _useSoftNormals = value;
1945                 UpdateVisual();
1946             }
1947         }
1948
1949         /// <summary>
1950         /// Gets or sets the position, in the stage space, of the point light that applies lighting to the model.<br />
1951         /// This is based off the stage's dimensions, so using the width and the height of the stage halved will correspond to the center,
1952         /// and using all zeroes will place the light at the top-left corner.<br />
1953         /// If not specified, the default is an offset outwards from the center of the screen.<br />
1954         /// Optional.
1955         /// </summary>
1956         /// <since_tizen> 3 </since_tizen>
1957         public Vector3 LightPosition
1958         {
1959             get
1960             {
1961                 return _lightPosition;
1962             }
1963             set
1964             {
1965                 _lightPosition = value;
1966                 UpdateVisual();
1967             }
1968         }
1969
1970         /// <summary>
1971         /// Compose the out visual map.
1972         /// </summary>
1973         /// <since_tizen> 3 </since_tizen>
1974         protected override void ComposingPropertyMap()
1975         {
1976             if (_objectURL != null)
1977             {
1978                 _outputVisualMap = new PropertyMap();
1979                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Mesh));
1980                 _outputVisualMap.Add(MeshVisualProperty.ObjectURL, new PropertyValue(_objectURL));
1981                 if (_materialtURL != null) { _outputVisualMap.Add(MeshVisualProperty.MaterialtURL, new PropertyValue(_materialtURL)); }
1982                 if (_texturesPath != null) { _outputVisualMap.Add(MeshVisualProperty.TexturesPath, new PropertyValue(_texturesPath)); }
1983                 if (_shadingMode != null) { _outputVisualMap.Add(MeshVisualProperty.ShadingMode, new PropertyValue((int)_shadingMode)); }
1984                 if (_useMipmapping != null) { _outputVisualMap.Add(MeshVisualProperty.UseMipmapping, new PropertyValue((bool)_useMipmapping)); }
1985                 if (_useSoftNormals != null) { _outputVisualMap.Add(MeshVisualProperty.UseSoftNormals, new PropertyValue((bool)_useSoftNormals)); }
1986                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
1987                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
1988                 if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
1989                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
1990                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
1991             }
1992         }
1993     }
1994
1995     /// <summary>
1996     /// A class encapsulating the property map of the primetive visual.
1997     /// </summary>
1998     /// <since_tizen> 3 </since_tizen>
1999     public class PrimitiveVisual : VisualMap
2000     {
2001         /// <summary>
2002         /// Constructor.
2003         /// </summary>
2004         /// <since_tizen> 3 </since_tizen>
2005         public PrimitiveVisual() : base()
2006         {
2007         }
2008
2009         private PrimitiveVisualShapeType? _shape = null;
2010         private Color _mixColorForPrimitiveVisual = null;
2011         private int? _slices = null;
2012         private int? _stacks = null;
2013         private float? _scaleTopRadius = null;
2014         private float? _scaleBottomRadius = null;
2015         private float? _scaleHeight = null;
2016         private float? _scaleRadius = null;
2017         private Vector3 _scaleDimensions = null;
2018         private float? _bevelPercentage = null;
2019         private float? _bevelSmoothness = null;
2020         private Vector3 _lightPosition = null;
2021
2022         /// <summary>
2023         /// Gets or sets the specific shape to render.<br />
2024         /// If not specified, the default is PrimitiveVisualShapeType.Sphere.<br />
2025         /// Optional.
2026         /// </summary>
2027         /// <since_tizen> 3 </since_tizen>
2028         public PrimitiveVisualShapeType Shape
2029         {
2030             get
2031             {
2032                 return _shape ?? (PrimitiveVisualShapeType.Sphere);
2033             }
2034             set
2035             {
2036                 _shape = value;
2037                 UpdateVisual();
2038             }
2039         }
2040
2041         /// <summary>
2042         /// Gets or sets the color of the shape.<br />
2043         /// If not specified, the default is Color (0.5, 0.5, 0.5, 1.0).<br />
2044         /// Applies to all shapes.<br />
2045         /// Optional.
2046         /// </summary>
2047         /// <since_tizen> 3 </since_tizen>
2048         public new Color MixColor
2049         {
2050             get
2051             {
2052                 return _mixColorForPrimitiveVisual ?? (new Color(0.5f, 0.5f, 0.5f, 1.0f));
2053             }
2054             set
2055             {
2056                 _mixColorForPrimitiveVisual = value;
2057                 UpdateVisual();
2058             }
2059         }
2060
2061         /// <summary>
2062         /// Gets or sets the number of slices as you go around the shape.<br />
2063         /// For spheres and conical frustrums, this determines how many divisions there are as you go around the object.<br />
2064         /// If not specified, the default is 128.<br />
2065         /// The range is from 1 to 255.<br />
2066         /// Optional.
2067         /// </summary>
2068         /// <since_tizen> 3 </since_tizen>
2069         public int Slices
2070         {
2071             get
2072             {
2073                 return _slices ?? (128);
2074             }
2075             set
2076             {
2077                 _slices = value;
2078                 UpdateVisual();
2079             }
2080         }
2081
2082         /// <summary>
2083         /// Gets or sets the number of stacks as you go down the shape.<br />
2084         /// For spheres, 'stacks' determines how many layers there are as you go down the object.<br />
2085         /// If not specified, the default is 128.<br />
2086         /// The range is from 1 to 255.<br />
2087         /// Optional.
2088         /// </summary>
2089         /// <since_tizen> 3 </since_tizen>
2090         public int Stacks
2091         {
2092             get
2093             {
2094                 return _stacks ?? (128);
2095             }
2096             set
2097             {
2098                 _stacks = value;
2099                 UpdateVisual();
2100             }
2101         }
2102
2103         /// <summary>
2104         /// Gets or sets the scale of the radius of the top circle of a conical frustrum.<br />
2105         /// If not specified, the default is 1.0f.<br />
2106         /// Applies to: - PrimitiveVisualShapeType.ConicalFrustrum<br />
2107         /// Only values greater than or equal to 0.0f are accepted.<br />
2108         /// Optional.
2109         /// </summary>
2110         /// <since_tizen> 3 </since_tizen>
2111         public float ScaleTopRadius
2112         {
2113             get
2114             {
2115                 return _scaleTopRadius ?? (1.0f);
2116             }
2117             set
2118             {
2119                 _scaleTopRadius = value;
2120                 UpdateVisual();
2121             }
2122         }
2123
2124         /// <summary>
2125         /// Gets or sets the scale of the radius of the bottom circle of a conical frustrum.<br />
2126         /// If not specified, the default is 1.5f.<br />
2127         /// Applies to:  - PrimitiveVisualShapeType.ConicalFrustrum<br />
2128         ///              - PrimitiveVisualShapeType.Cone<br />
2129         /// Only values greater than or equal to 0.0f are accepted.<br />
2130         /// Optional.
2131         /// </summary>
2132         /// <since_tizen> 3 </since_tizen>
2133         public float ScaleBottomRadius
2134         {
2135             get
2136             {
2137                 return _scaleBottomRadius ?? (1.5f);
2138             }
2139             set
2140             {
2141                 _scaleBottomRadius = value;
2142                 UpdateVisual();
2143             }
2144         }
2145
2146         /// <summary>
2147         /// Gets or sets the scale of the height of a conic.<br />
2148         /// If not specified, the default is 3.0f.<br />
2149         /// Applies to:<br />
2150         ///      - PrimitiveVisualShapeType.ConicalFrustrum<br />
2151         ///      - PrimitiveVisualShapeType.Cone<br />
2152         ///      - PrimitiveVisualShapeType.Cylinder<br />
2153         /// Only values greater than or equal to 0.0f are accepted.<br />
2154         /// Optional.
2155         /// </summary>
2156         /// <since_tizen> 3 </since_tizen>
2157         public float ScaleHeight
2158         {
2159             get
2160             {
2161                 return _scaleHeight ?? (3.0f);
2162             }
2163             set
2164             {
2165                 _scaleHeight = value;
2166                 UpdateVisual();
2167             }
2168         }
2169
2170         /// <summary>
2171         /// Gets or sets the scale of the radius of a cylinder.<br />
2172         /// If not specified, the default is 1.0f.<br />
2173         /// Applies to:<br />
2174         ///      - PrimitiveVisualShapeType.Cylinder<br />
2175         /// Only values greater than or equal to 0.0f are accepted.<br />
2176         /// Optional.
2177         /// </summary>
2178         /// <since_tizen> 3 </since_tizen>
2179         public float ScaleRadius
2180         {
2181             get
2182             {
2183                 return _scaleRadius ?? (1.0f);
2184             }
2185             set
2186             {
2187                 _scaleRadius = value;
2188                 UpdateVisual();
2189             }
2190         }
2191
2192         /// <summary>
2193         /// Gets or sets the dimensions of a cuboid. Scales in the same fashion as a 9-patch image.<br />
2194         /// If not specified, the default is Vector3.One.<br />
2195         /// Applies to:<br />
2196         ///      - PrimitiveVisualShapeType.Cube<br />
2197         ///      - PrimitiveVisualShapeType.Octahedron<br />
2198         ///      - PrimitiveVisualShapeType.BevelledCube<br />
2199         /// Each Vector3 parameter should be greater than or equal to 0.0f.<br />
2200         /// Optional.
2201         /// </summary>
2202         /// <since_tizen> 3 </since_tizen>
2203         public Vector3 ScaleDimensions
2204         {
2205             get
2206             {
2207                 return _scaleDimensions ?? (Vector3.One);
2208             }
2209             set
2210             {
2211                 _scaleDimensions = value;
2212                 UpdateVisual();
2213             }
2214         }
2215
2216         /// <summary>
2217         /// Gets or sets determines how bevelled the cuboid should be, based off the smallest dimension.<br />
2218         /// Bevel percentage ranges from 0.0 to 1.0. It affects the ratio of the outer face widths to the width of the overall cube.<br />
2219         /// If not specified, the default is 0.0f (no bevel).<br />
2220         /// Applies to:<br />
2221         ///      - PrimitiveVisualShapeType.BevelledCube<br />
2222         /// The range is from 0.0f to 1.0f.<br />
2223         /// Optional.
2224         /// </summary>
2225         /// <since_tizen> 3 </since_tizen>
2226         public float BevelPercentage
2227         {
2228             get
2229             {
2230                 return _bevelPercentage ?? (0.0f);
2231             }
2232             set
2233             {
2234                 _bevelPercentage = value;
2235                 UpdateVisual();
2236             }
2237         }
2238
2239         /// <summary>
2240         /// Gets or sets descriptions of how smooth the bevelled edges should be.<br />
2241         /// If not specified, the default is 0.0f (sharp edges).<br />
2242         /// Applies to:<br />
2243         ///      - PrimitiveVisualShapeType.BevelledCube<br />
2244         /// The range is from 0.0f to 1.0f.<br />
2245         /// Optional.
2246         /// </summary>
2247         /// <since_tizen> 3 </since_tizen>
2248         public float BevelSmoothness
2249         {
2250             get
2251             {
2252                 return _bevelSmoothness ?? (0.0f);
2253             }
2254             set
2255             {
2256                 _bevelSmoothness = value;
2257                 UpdateVisual();
2258             }
2259         }
2260
2261         /// <summary>
2262         /// Gets or sets the position, in the stage space, of the point light that applies lighting to the model.<br />
2263         /// This is based off the stage's dimensions, so using the width and the height of the stage halved will correspond to the center,
2264         /// and using all zeroes will place the light at the top-left corner.<br />
2265         /// If not specified, the default is an offset outwards from the center of the screen.<br />
2266         /// Applies to all shapes.<br />
2267         /// Optional.
2268         /// </summary>
2269         /// <since_tizen> 3 </since_tizen>
2270         public Vector3 LightPosition
2271         {
2272             get
2273             {
2274                 return _lightPosition;
2275             }
2276             set
2277             {
2278                 _lightPosition = value;
2279                 UpdateVisual();
2280             }
2281         }
2282
2283         /// <summary>
2284         /// Compose the out visual map.
2285         /// </summary>
2286         /// <since_tizen> 3 </since_tizen>
2287         protected override void ComposingPropertyMap()
2288         {
2289             _outputVisualMap = new PropertyMap(); ;
2290             _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Primitive));
2291             if (_shape != null) { _outputVisualMap.Add(PrimitiveVisualProperty.Shape, new PropertyValue((int)_shape)); }
2292             if (_mixColorForPrimitiveVisual != null) { _outputVisualMap.Add(PrimitiveVisualProperty.MixColor, new PropertyValue(_mixColorForPrimitiveVisual)); }
2293             if (_slices != null) { _outputVisualMap.Add(PrimitiveVisualProperty.Slices, new PropertyValue((int)_slices)); }
2294             if (_stacks != null) { _outputVisualMap.Add(PrimitiveVisualProperty.Stacks, new PropertyValue((int)_stacks)); }
2295             if (_scaleTopRadius != null) { _outputVisualMap.Add(PrimitiveVisualProperty.ScaleTopRadius, new PropertyValue((float)_scaleTopRadius)); }
2296             if (_scaleBottomRadius != null) { _outputVisualMap.Add(PrimitiveVisualProperty.ScaleBottomRadius, new PropertyValue((float)_scaleBottomRadius)); }
2297             if (_scaleHeight != null) { _outputVisualMap.Add(PrimitiveVisualProperty.ScaleHeight, new PropertyValue((float)_scaleHeight)); }
2298             if (_scaleRadius != null) { _outputVisualMap.Add(PrimitiveVisualProperty.ScaleRadius, new PropertyValue((float)_scaleRadius)); }
2299             if (_scaleDimensions != null) { _outputVisualMap.Add(PrimitiveVisualProperty.ScaleDimensions, new PropertyValue(_scaleDimensions)); }
2300             if (_bevelPercentage != null) { _outputVisualMap.Add(PrimitiveVisualProperty.BevelPercentage, new PropertyValue((float)_bevelPercentage)); }
2301             if (_bevelSmoothness != null) { _outputVisualMap.Add(PrimitiveVisualProperty.BevelSmoothness, new PropertyValue((float)_bevelSmoothness)); }
2302             if (_lightPosition != null) { _outputVisualMap.Add(PrimitiveVisualProperty.LightPosition, new PropertyValue(_lightPosition)); }
2303             if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
2304             if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
2305             if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
2306             if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
2307         }
2308     }
2309
2310     /// <summary>
2311     /// A class encapsulating the property map of the n-patch image visual.
2312     /// </summary>
2313     /// <since_tizen> 3 </since_tizen>
2314     public class NPatchVisual : VisualMap
2315     {
2316         /// <summary>
2317         /// Constructor.
2318         /// </summary>
2319         /// <since_tizen> 3 </since_tizen>
2320         public NPatchVisual() : base()
2321         {
2322         }
2323
2324         private string _url = null;
2325         private bool? _borderOnly = null;
2326         private Rectangle _border = null;
2327
2328         /// <summary>
2329         /// Gets or sets the URL of the image.<br />
2330         /// Mandatory.
2331         /// </summary>
2332         /// <since_tizen> 3 </since_tizen>
2333         public string URL
2334         {
2335             get
2336             {
2337                 return _url;
2338             }
2339             set
2340             {
2341                 _url = value;
2342                 UpdateVisual();
2343             }
2344         }
2345
2346         /// <summary>
2347         /// Gets or sets whether to draw the borders only (If true).<br />
2348         /// If not specified, the default is false.<br />
2349         /// For n-patch images only.<br />
2350         /// Optional.
2351         /// </summary>
2352         /// <since_tizen> 3 </since_tizen>
2353         public bool BorderOnly
2354         {
2355             get
2356             {
2357                 return _borderOnly ?? false;
2358             }
2359             set
2360             {
2361                 _borderOnly = value;
2362                 UpdateVisual();
2363             }
2364         }
2365
2366         /// <summary>
2367         /// The border of the image is in the order: left, right, bottom, top.<br />
2368         /// For n-patch images only.<br />
2369         /// Optional.
2370         /// </summary>
2371         /// <since_tizen> 3 </since_tizen>
2372         public Rectangle Border
2373         {
2374             get
2375             {
2376                 return _border;
2377             }
2378             set
2379             {
2380                 _border = value;
2381                 UpdateVisual();
2382             }
2383         }
2384
2385         /// <summary>
2386         /// Compose the out visual map.
2387         /// </summary>
2388         /// <since_tizen> 3 </since_tizen>
2389         protected override void ComposingPropertyMap()
2390         {
2391             if (_url != null)
2392             {
2393                 _outputVisualMap = new PropertyMap();
2394                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.NPatch));
2395                 _outputVisualMap.Add(NpatchImageVisualProperty.URL, new PropertyValue(_url));
2396                 if (_borderOnly != null) { _outputVisualMap.Add(NpatchImageVisualProperty.BorderOnly, new PropertyValue((bool)_borderOnly)); }
2397                 if (_border != null) { _outputVisualMap.Add(NpatchImageVisualProperty.Border, new PropertyValue(_border)); }
2398                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
2399                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
2400                 if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
2401                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
2402                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
2403             }
2404         }
2405     }
2406
2407     /// <summary>
2408     /// A class encapsulating the property map of the SVG visual.
2409     /// </summary>
2410     /// <since_tizen> 3 </since_tizen>
2411     public class SVGVisual : VisualMap
2412     {
2413         /// <summary>
2414         /// Constructor.
2415         /// </summary>
2416         /// <since_tizen> 3 </since_tizen>
2417         public SVGVisual() : base()
2418         {
2419         }
2420
2421         private string _url = null;
2422
2423         /// <summary>
2424         /// The url of the svg resource.
2425         /// </summary>
2426         /// <since_tizen> 3 </since_tizen>
2427         public string URL
2428         {
2429             get
2430             {
2431                 return _url;
2432             }
2433             set
2434             {
2435                 _url = value;
2436                 UpdateVisual();
2437             }
2438         }
2439
2440         /// <summary>
2441         /// Compose the out visual map.
2442         /// </summary>
2443         /// <since_tizen> 3 </since_tizen>
2444         protected override void ComposingPropertyMap()
2445         {
2446             if (_url != null)
2447             {
2448                 _outputVisualMap = new PropertyMap();
2449                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.SVG));
2450                 _outputVisualMap.Add(ImageVisualProperty.URL, new PropertyValue(_url));
2451                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
2452                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
2453                 if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
2454                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
2455                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
2456             }
2457         }
2458     }
2459
2460     /// <summary>
2461     /// A class encapsulating the property map of the animated image (AGIF) visual.
2462     /// </summary>
2463     /// <since_tizen> 3 </since_tizen>
2464     public class AnimatedImageVisual : VisualMap
2465     {
2466         /// <summary>
2467         /// Constructor.
2468         /// </summary>
2469         /// <since_tizen> 3 </since_tizen>
2470         public AnimatedImageVisual() : base()
2471         {
2472         }
2473
2474         private List<string> _urls = null;
2475         private int? _batchSize = null;
2476         private int? _cacheSize = null;
2477         private float? _frameDelay = null;
2478         private float? _loopCount = null;
2479
2480         /// <summary>
2481         /// Gets and Sets the url in the AnimatedImageVisual.
2482         /// </summary>
2483         /// <since_tizen> 3 </since_tizen>
2484         public string URL
2485         {
2486             get
2487             {
2488                 if( _urls != null )
2489                 {
2490                     return _urls[0];
2491                 }
2492                 else
2493                 {
2494                     return null;
2495                 }
2496             }
2497             set
2498             {
2499                 if( _urls == null )
2500                 {
2501                     _urls = new List<string>();
2502                     _urls.Add(value);
2503                 }
2504                 else
2505                 {
2506                     _urls[0] = value;
2507                 }
2508                 UpdateVisual();
2509             }
2510         }
2511
2512         /// <summary>
2513         /// Gets and Sets the url list in the AnimatedImageVisual.
2514         /// </summary>
2515         /// <since_tizen> 4 </since_tizen>
2516         public List<string> URLS
2517         {
2518             get
2519             {
2520                 return _urls;
2521             }
2522             set
2523             {
2524                 _urls = value;
2525                 UpdateVisual();
2526             }
2527         }
2528
2529         /// <summary>
2530         /// Gets and Sets the batch size for pre-loading images in the AnimatedImageVisual.
2531         /// </summary>
2532         /// <since_tizen> 4 </since_tizen>
2533         public int BatchSize
2534         {
2535             get
2536             {
2537                 return _batchSize ?? 1;
2538             }
2539             set
2540             {
2541                 _batchSize = value;
2542                 UpdateVisual();
2543             }
2544         }
2545
2546         /// <summary>
2547         /// Gets and Sets the cache size for loading images in the AnimatedImageVisual.
2548         /// </summary>
2549         /// <since_tizen> 4 </since_tizen>
2550         public int CacheSize
2551         {
2552             get
2553             {
2554                 return _cacheSize ?? 1;
2555             }
2556             set
2557             {
2558                 _cacheSize = value;
2559                 UpdateVisual();
2560             }
2561         }
2562
2563         /// <summary>
2564         /// Gets and Sets The number of milliseconds between each frame in the AnimatedImageVisual.
2565         /// </summary>
2566         /// <since_tizen> 4 </since_tizen>
2567         public float FrameDelay
2568         {
2569             get
2570             {
2571                 return _frameDelay ?? 0.1f;
2572             }
2573             set
2574             {
2575                 _frameDelay = value;
2576                 UpdateVisual();
2577             }
2578         }
2579
2580         /// <summary>
2581         /// Gets and sets the number of times the AnimatedImageVisual will be looped.
2582         /// The default is -1. If the number is less than 0 then it loops unlimited,otherwise loop loopCount times.
2583         /// </summary>
2584         /// <since_tizen> 5 </since_tizen>
2585         public float LoopCount
2586         {
2587             get
2588             {
2589                 return _loopCount ?? -1;
2590             }
2591             set
2592             {
2593                 _loopCount = value;
2594                 UpdateVisual();
2595             }
2596         }
2597
2598         /// <summary>
2599         /// Compose the out visual map.
2600         /// </summary>
2601         /// <since_tizen> 3 </since_tizen>
2602         protected override void ComposingPropertyMap()
2603         {
2604             if (_urls != null)
2605             {
2606                 _outputVisualMap = new PropertyMap();
2607                 _outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.AnimatedImage));
2608                 if( _urls.Count == 1 )
2609                 {
2610                     _outputVisualMap.Add(ImageVisualProperty.URL, new PropertyValue(_urls[0]));
2611                 }
2612                 else
2613                 {
2614                     var urlArray = new PropertyArray();
2615                     foreach( var url in _urls)
2616                     {
2617                         urlArray.Add(new PropertyValue(url));
2618                     }
2619                     _outputVisualMap.Add( ImageVisualProperty.URL, ( new PropertyValue( urlArray ) ) );
2620                 }
2621                 if (_batchSize != null ) {_outputVisualMap.Add((int)ImageVisualProperty.BatchSize, new PropertyValue((int)_batchSize)); }
2622                 if (_cacheSize != null ) {_outputVisualMap.Add((int)ImageVisualProperty.CacheSize, new PropertyValue((int)_cacheSize)); }
2623                 if (_frameDelay != null ) {_outputVisualMap.Add((int)ImageVisualProperty.FrameDelay, new PropertyValue((float)_frameDelay)); }
2624                 if (_loopCount != null ) {_outputVisualMap.Add((int)ImageVisualProperty.LoopCount, new PropertyValue((int)_loopCount)); }
2625                 if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
2626                 if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
2627                 if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
2628                 if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
2629                 if (_visualFittingMode != null) { _outputVisualMap.Add((int)Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
2630             }
2631         }
2632     }
2633
2634
2635     //temporary fix for TCT
2636     /// <summary>
2637     /// A class encapsulating the property map of the transition data.
2638     /// </summary>
2639     /// <since_tizen> 3 </since_tizen>
2640     public class VisualAnimator : VisualMap
2641     {
2642         /// <summary>
2643         /// Create VisualAnimator object.
2644         /// </summary>
2645         /// <since_tizen> 3 </since_tizen>
2646         public VisualAnimator() : base()
2647         {
2648         }
2649
2650         private string _alphaFunction = null;
2651         private int _startTime = 0;
2652         private int _endTime = 0;
2653         private string _target = null;
2654         private string _propertyIndex = null;
2655         private object _destinationValue = null;
2656
2657         /// <summary>
2658         /// Sets and Gets the AlphaFunction of this transition.
2659         /// </summary>
2660         /// <since_tizen> 3 </since_tizen>
2661         public AlphaFunction.BuiltinFunctions AlphaFunction
2662         {
2663             get
2664             {
2665                 switch (_alphaFunction)
2666                 {
2667                     case "LINEAR":
2668                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.Linear;
2669                     case "REVERSE":
2670                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.Reverse;
2671                     case "EASE_IN_SQUARE":
2672                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSquare;
2673                     case "EASE_OUT_SQUARE":
2674                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSquare;
2675                     case "EASE_IN":
2676                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseIn;
2677                     case "EASE_OUT":
2678                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOut;
2679                     case "EASE_IN_OUT":
2680                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOut;
2681                     case "EASE_IN_SINE":
2682                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSine;
2683                     case "EASE_OUT_SINE":
2684                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSine;
2685                     case "EASE_IN_OUT_SINE":
2686                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOutSine;
2687                     case "BOUNCE":
2688                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.Bounce;
2689                     case "SIN":
2690                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.Sin;
2691                     case "EASE_OUT_BACK":
2692                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutBack;
2693                     default:
2694                         return Tizen.NUI.AlphaFunction.BuiltinFunctions.Default;
2695                 }
2696             }
2697             set
2698             {
2699                 switch (value)
2700                 {
2701                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Linear:
2702                         {
2703                             _alphaFunction = "LINEAR";
2704                             break;
2705                         }
2706                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Reverse:
2707                         {
2708                             _alphaFunction = "REVERSE";
2709                             break;
2710                         }
2711                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSquare:
2712                         {
2713                             _alphaFunction = "EASE_IN_SQUARE";
2714                             break;
2715                         }
2716                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSquare:
2717                         {
2718                             _alphaFunction = "EASE_OUT_SQUARE";
2719                             break;
2720                         }
2721                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseIn:
2722                         {
2723                             _alphaFunction = "EASE_IN";
2724                             break;
2725                         }
2726                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOut:
2727                         {
2728                             _alphaFunction = "EASE_OUT";
2729                             break;
2730                         }
2731                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOut:
2732                         {
2733                             _alphaFunction = "EASE_IN_OUT";
2734                             break;
2735                         }
2736                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInSine:
2737                         {
2738                             _alphaFunction = "EASE_IN_SINE";
2739                             break;
2740                         }
2741                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutSine:
2742                         {
2743                             _alphaFunction = "EASE_OUT_SINE";
2744                             break;
2745                         }
2746                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseInOutSine:
2747                         {
2748                             _alphaFunction = "EASE_IN_OUT_SINE";
2749                             break;
2750                         }
2751                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Bounce:
2752                         {
2753                             _alphaFunction = "BOUNCE";
2754                             break;
2755                         }
2756                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.Sin:
2757                         {
2758                             _alphaFunction = "SIN";
2759                             break;
2760                         }
2761                     case Tizen.NUI.AlphaFunction.BuiltinFunctions.EaseOutBack:
2762                         {
2763                             _alphaFunction = "EASE_OUT_BACK";
2764                             break;
2765                         }
2766                     default:
2767                         {
2768                             _alphaFunction = "DEFAULT";
2769                             break;
2770                         }
2771                 }
2772             }
2773         }
2774
2775         /// <summary>
2776         /// Sets and Gets the StartTime of this transition.
2777         /// </summary>
2778         /// <since_tizen> 3 </since_tizen>
2779         public int StartTime
2780         {
2781             get
2782             {
2783                 return _startTime;
2784             }
2785             set
2786             {
2787                 _startTime = value;
2788             }
2789         }
2790
2791         /// <summary>
2792         /// Sets and Gets the EndTime of this transition.
2793         /// </summary>
2794         /// <since_tizen> 3 </since_tizen>
2795         public int EndTime
2796         {
2797             get
2798             {
2799                 return _endTime;
2800             }
2801             set
2802             {
2803                 _endTime = value;
2804             }
2805         }
2806
2807         /// <summary>
2808         /// Sets and Gets the Target of this transition.
2809         /// </summary>
2810         /// <since_tizen> 3 </since_tizen>
2811         public string Target
2812         {
2813             get
2814             {
2815                 return _target;
2816             }
2817             set
2818             {
2819                 _target = value;
2820             }
2821         }
2822
2823         /// <summary>
2824         /// Sets and Gets the PropertyIndex of this transition.
2825         /// </summary>
2826         /// <since_tizen> 3 </since_tizen>
2827         public string PropertyIndex
2828         {
2829             get
2830             {
2831                 return _propertyIndex;
2832             }
2833             set
2834             {
2835                 _propertyIndex = value;
2836             }
2837         }
2838
2839         /// <summary>
2840         /// Sets and Gets the DestinationValue of this transition.
2841         /// </summary>
2842         /// <since_tizen> 3 </since_tizen>
2843         public object DestinationValue
2844         {
2845             get
2846             {
2847                 return _destinationValue;
2848             }
2849             set
2850             {
2851                 _destinationValue = value;
2852             }
2853         }
2854
2855         /// <summary>
2856         /// Compose the out visual map.
2857         /// </summary>
2858         /// <since_tizen> 3 </since_tizen>
2859         protected override void ComposingPropertyMap()
2860         {
2861             PropertyMap _animator = new PropertyMap();
2862             _animator.Add("alphaFunction", new PropertyValue(_alphaFunction));
2863
2864             PropertyMap _timePeriod = new PropertyMap();
2865             _timePeriod.Add("duration", new PropertyValue((_endTime - _startTime) / 1000.0f));
2866             _timePeriod.Add("delay", new PropertyValue(_startTime / 1000.0f));
2867             _animator.Add("timePeriod", new PropertyValue(_timePeriod));
2868
2869             StringBuilder sb = new StringBuilder(_propertyIndex);
2870             sb[0] = (char)(sb[0] | 0x20);
2871             string _str = sb.ToString();
2872
2873             PropertyValue val = PropertyValue.CreateFromObject(_destinationValue);
2874
2875             PropertyMap _transition = new PropertyMap();
2876             _transition.Add("target", new PropertyValue(_target));
2877             _transition.Add("property", new PropertyValue(_str));
2878             _transition.Add("targetValue", val);
2879             _transition.Add("animator", new PropertyValue(_animator));
2880
2881             _outputVisualMap = _transition;
2882         }
2883     }
2884     //temporary fix for TCT
2885
2886
2887
2888 }