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

   1 /*
   2  * Copyright(c) 2019 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.ComponentModel;
  18 using Tizen.NUI.BaseComponents;
  19
  20 namespace Tizen.NUI
  21 {
  22     /// <summary>
  23     /// A class encapsulating the transform map of the visual.
  24     /// </summary>
  25     /// <since_tizen> 3 </since_tizen>
  26     public class VisualMap
  27     {
  28         /// <summary>
  29         /// outputVisualMap.
  30         /// </summary>
  31         /// <since_tizen> 3 </since_tizen>
  32         protected PropertyMap _outputVisualMap = null;
  33
  34         /// <summary>
  35         /// The shader of the visual.
  36         /// </summary>
  37         /// <since_tizen> 3 </since_tizen>
  38         protected PropertyMap _shader = null;
  39         //private PropertyMap _transform = null;
  40
  41         /// <summary>
  42         /// The premultipliedAlpha of the visual.
  43         /// </summary>
  44         /// <since_tizen> 3 </since_tizen>
  45         protected bool? _premultipliedAlpha = null;
  46
  47         /// <summary>
  48         /// The mixColor of the Visual.
  49         /// </summary>
  50         /// <since_tizen> 3 </since_tizen>
  51         protected Color _mixColor = null;
  52
  53         /// <summary>
  54         /// The opacity of the visual.
  55         /// </summary>
  56         /// <since_tizen> 3 </since_tizen>
  57         protected float? _opacity = null;
  58
  59         /// <summary>
  60         /// The FittingMode of the visual.
  61         /// </summary>
  62         /// <since_tizen> 5 </since_tizen>
  63         protected VisualFittingModeType? _visualFittingMode = null;
  64
  65         /// <summary>
  66         /// The corner radius value of the visual.
  67         /// </summary>
  68         [EditorBrowsable(EditorBrowsableState.Never)]
  69         private float? cornerRadius = null;
  70
  71         /// <summary>
  72         /// The map for visual.
  73         /// </summary>
  74         /// <since_tizen> 3 </since_tizen>
  75         protected PropertyMap _commonlyUsedMap = null;
  76
  77         private Vector2 _visualSize = null;
  78         private Vector2 _visualOffset = null;
  79         private Vector2 _visualOffsetPolicy = null;
  80         private Vector2 _visualSizePolicy = null;
  81         private Visual.AlignType? _visualOrigin = null;
  82         private Visual.AlignType? _visualAnchorPoint = null;
  83
  84         private PropertyMap _visualTransformMap = null;
  85
  86         private int? _depthIndex = null;
  87
  88         /// <summary>
  89         /// Constructor.
  90         /// </summary>
  91         /// <since_tizen> 3 </since_tizen>
  92         public VisualMap()
  93         {
  94         }
  95
  96         /// <summary>
  97         /// Gets or sets the size of the visual.<br />
  98         /// It can be either relative (percentage of the parent)
  99         /// or absolute (in world units).<br />
 100         /// Optional.
 101         /// </summary>
 102         /// <since_tizen> 3 </since_tizen>
 103         public Size2D Size
 104         {
 105             get
 106             {
 107                 return _visualSize ?? (new Size2D(1, 1));
 108             }
 109             set
 110             {
 111                 _visualSize = value;
 112                 if (_visualSizePolicy == null)
 113                 {
 114                     _visualSizePolicy = new Vector2(1.0f, 1.0f);
 115                 }
 116                 UpdateVisual();
 117             }
 118         }
 119
 120         /// <summary>
 121         /// Gets or sets the offset of the visual.<br />
 122         /// It can be either relative (percentage of the parent)
 123         /// or absolute (in world units).<br />
 124         /// Optional.
 125         /// </summary>
 126         /// <since_tizen> 3 </since_tizen>
 127         public Vector2 Position
 128         {
 129             get
 130             {
 131                 return _visualOffset ?? (new Vector2(0.0f, 0.0f));
 132             }
 133             set
 134             {
 135                 _visualOffset = value;
 136                 if (_visualOffsetPolicy == null)
 137                 {
 138                     _visualOffsetPolicy = new Vector2(1.0f, 1.0f);
 139                 }
 140                 UpdateVisual();
 141             }
 142         }
 143
 144         /// <summary>
 145         /// Gets or sets the relative size of the visual<br />
 146         /// (percentage [0.0f to 1.0f] of the control).<br />
 147         /// Optional.
 148         /// </summary>
 149         /// <since_tizen> 3 </since_tizen>
 150         public RelativeVector2 RelativeSize
 151         {
 152             get
 153             {
 154                 return _visualSize ?? (new RelativeVector2(1.0f, 1.0f));
 155             }
 156             set
 157             {
 158                 _visualSize = value;
 159                 _visualSizePolicy = new Vector2(0.0f, 0.0f);
 160                 UpdateVisual();
 161             }
 162         }
 163
 164         /// <summary>
 165         /// Gets or sets the relative offset of the visual<br />
 166         /// (percentage [0.0f to 1.0f] of the control).<br />
 167         /// Optional.
 168         /// </summary>
 169         /// <since_tizen> 3 </since_tizen>
 170         public RelativeVector2 RelativePosition
 171         {
 172             get
 173             {
 174                 return _visualOffset ?? (new RelativeVector2(0.0f, 0.0f));
 175             }
 176             set
 177             {
 178                 _visualOffset = value;
 179                 _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 180                 UpdateVisual();
 181             }
 182         }
 183
 184         /// <summary>
 185         /// Gets or sets whether the x and y offset values are relative<br />
 186         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 187         /// By default, both the x and the y offset are relative.<br />
 188         /// Optional.
 189         /// </summary>
 190         /// <since_tizen> 3 </since_tizen>
 191         public VisualTransformPolicyType PositionPolicy
 192         {
 193             get
 194             {
 195                 if (_visualOffsetPolicy != null && _visualOffsetPolicy.X == 1.0f
 196                     && _visualOffsetPolicy.Y == 1.0f)
 197                 {
 198                     return VisualTransformPolicyType.Absolute;
 199                 }
 200                 return VisualTransformPolicyType.Relative;
 201             }
 202             set
 203             {
 204                 switch (value)
 205                 {
 206                     case VisualTransformPolicyType.Relative:
 207                         _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 208                         break;
 209                     case VisualTransformPolicyType.Absolute:
 210                         _visualOffsetPolicy = new Vector2(1.0f, 1.0f);
 211                         break;
 212                     default:
 213                         _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 214                         break;
 215                 }
 216                 UpdateVisual();
 217             }
 218         }
 219
 220         /// <summary>
 221         /// Gets or sets whether the x offset values are relative<br />
 222         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 223         /// By default, the x offset is relative.<br />
 224         /// Optional.
 225         /// </summary>
 226         /// <since_tizen> 3 </since_tizen>
 227         public VisualTransformPolicyType PositionPolicyX
 228         {
 229             get
 230             {
 231                 if (_visualOffsetPolicy != null && _visualOffsetPolicy.X == 1.0f)
 232                 {
 233                     return VisualTransformPolicyType.Absolute;
 234                 }
 235                 return VisualTransformPolicyType.Relative;
 236             }
 237             set
 238             {
 239                 float x = 0.0f;
 240
 241                 switch (value)
 242                 {
 243                     case VisualTransformPolicyType.Relative:
 244                         x = 0.0f;
 245                         break;
 246                     case VisualTransformPolicyType.Absolute:
 247                         x = 1.0f;
 248                         break;
 249                     default:
 250                         x = 0.0f;
 251                         break;
 252                 }
 253                 _visualOffsetPolicy = new Vector2(x, _visualOffsetPolicy?.Y ?? 0);
 254
 255                 UpdateVisual();
 256             }
 257         }
 258
 259         /// <summary>
 260         /// Gets or sets whether the y offset values are relative<br />
 261         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 262         /// By default, the y offset is relative.<br />
 263         /// Optional.
 264         /// </summary>
 265         /// <since_tizen> 3 </since_tizen>
 266         public VisualTransformPolicyType PositionPolicyY
 267         {
 268             get
 269             {
 270                 if (_visualOffsetPolicy != null && _visualOffsetPolicy.Y == 1.0f)
 271                 {
 272                     return VisualTransformPolicyType.Absolute;
 273                 }
 274                 return VisualTransformPolicyType.Relative;
 275             }
 276             set
 277             {
 278                 float y = 0.0f;
 279
 280                 switch (value)
 281                 {
 282                     case VisualTransformPolicyType.Relative:
 283                         y = 0.0f;
 284                         break;
 285                     case VisualTransformPolicyType.Absolute:
 286                         y = 1.0f;
 287                         break;
 288                     default:
 289                         y = 0.0f;
 290                         break;
 291                 }
 292                 _visualOffsetPolicy = new Vector2(_visualOffsetPolicy?.X ?? 0, y);
 293                 UpdateVisual();
 294             }
 295         }
 296
 297         /// <summary>
 298         /// Gets or sets whether the size values of the width or the height are relative<br />
 299         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 300         /// By default, offsets of both the width and the height are relative to the control's size.<br />
 301         /// Optional.
 302         /// </summary>
 303         /// <since_tizen> 3 </since_tizen>
 304         public VisualTransformPolicyType SizePolicy
 305         {
 306             get
 307             {
 308                 if (_visualSizePolicy != null && _visualSizePolicy.X == 1.0f
 309                     && _visualSizePolicy.Y == 1.0f)
 310                 {
 311                     return VisualTransformPolicyType.Absolute;
 312                 }
 313                 return VisualTransformPolicyType.Relative;
 314             }
 315             set
 316             {
 317                 switch (value)
 318                 {
 319                     case VisualTransformPolicyType.Relative:
 320                         _visualSizePolicy = new Vector2(0.0f, 0.0f);
 321                         break;
 322                     case VisualTransformPolicyType.Absolute:
 323                         _visualSizePolicy = new Vector2(1.0f, 1.0f);
 324                         break;
 325                     default:
 326                         _visualSizePolicy = new Vector2(0.0f, 0.0f);
 327                         break;
 328                 }
 329                 UpdateVisual();
 330             }
 331         }
 332
 333         /// <summary>
 334         /// Gets or sets whether size values of the width are relative.<br />
 335         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 336         /// By default, the value of the width is relative to the control's width.<br />
 337         /// Optional.
 338         /// </summary>
 339         /// <since_tizen> 3 </since_tizen>
 340         public VisualTransformPolicyType SizePolicyWidth
 341         {
 342             get
 343             {
 344                 if (_visualSizePolicy != null && _visualSizePolicy.Width == 1.0f)
 345                 {
 346                     return VisualTransformPolicyType.Absolute;
 347                 }
 348                 return VisualTransformPolicyType.Relative;
 349             }
 350             set
 351             {
 352                 float width = 0.0f;
 353                 switch (value)
 354                 {
 355                     case VisualTransformPolicyType.Relative:
 356                         width = 0.0f;
 357                         break;
 358                     case VisualTransformPolicyType.Absolute:
 359                         width = 1.0f;
 360                         break;
 361                     default:
 362                         width = 0.0f;
 363                         break;
 364                 }
 365
 366                 _visualSizePolicy = new Vector2(width, _visualSizePolicy?.Height ?? 0);
 367                 UpdateVisual();
 368             }
 369         }
 370
 371         /// <summary>
 372         /// Gets or sets whether size values of the height are relative<br />
 373         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 374         /// By default, the height value is relative to the control's height.<br />
 375         /// Optional.
 376         /// </summary>
 377         /// <since_tizen> 3 </since_tizen>
 378         public VisualTransformPolicyType SizePolicyHeight
 379         {
 380             get
 381             {
 382                 if (_visualSizePolicy != null && _visualSizePolicy.Height == 1.0f)
 383                 {
 384                     return VisualTransformPolicyType.Absolute;
 385                 }
 386                 return VisualTransformPolicyType.Relative;
 387             }
 388             set
 389             {
 390                 float height = 0.0f;
 391
 392                 switch (value)
 393                 {
 394                     case VisualTransformPolicyType.Relative:
 395                         height = 0.0f;
 396                         break;
 397                     case VisualTransformPolicyType.Absolute:
 398                         height = 1.0f;
 399                         break;
 400                     default:
 401                         height = 0.0f;
 402                         break;
 403                 }
 404                 _visualSizePolicy = new Vector2(_visualSizePolicy?.Width ?? 0, height);
 405                 UpdateVisual();
 406             }
 407         }
 408
 409         /// <summary>
 410         /// Gets or sets the origin of the visual within its control area.<br />
 411         /// By default, the origin is center.<br />
 412         /// Optional.
 413         /// </summary>
 414         /// <since_tizen> 3 </since_tizen>
 415         public Visual.AlignType Origin
 416         {
 417             get
 418             {
 419                 return _visualOrigin ?? (Visual.AlignType.Center);
 420             }
 421             set
 422             {
 423                 _visualOrigin = value;
 424                 UpdateVisual();
 425             }
 426         }
 427
 428         /// <summary>
 429         /// Gets or sets the anchor point of the visual.<br />
 430         /// By default, the anchor point is center.<br />
 431         /// Optional.
 432         /// </summary>
 433         /// <since_tizen> 3 </since_tizen>
 434         public Visual.AlignType AnchorPoint
 435         {
 436             get
 437             {
 438                 return _visualAnchorPoint ?? (Visual.AlignType.Center);
 439             }
 440             set
 441             {
 442                 _visualAnchorPoint = value;
 443                 UpdateVisual();
 444             }
 445         }
 446
 447         /// <summary>
 448         /// Gets or sets the depth index of the visual.<br />
 449         /// By default, the depth index is 0.<br />
 450         /// Optional.
 451         /// </summary>
 452         /// <since_tizen> 3 </since_tizen>
 453         public int DepthIndex
 454         {
 455             get
 456             {
 457                 return _depthIndex ?? (0);
 458             }
 459             set
 460             {
 461                 _depthIndex = value;
 462             }
 463         }
 464
 465         /// <summary>
 466         /// Gets the transform map used by the visual.
 467         /// </summary>
 468         /// <since_tizen> 3 </since_tizen>
 469         public PropertyMap OutputTransformMap
 470         {
 471             get
 472             {
 473                 ComposingTransformMap();
 474                 return _visualTransformMap;
 475             }
 476         }
 477
 478         /// <summary>
 479         /// Gets the property map to create the visual.
 480         /// </summary>
 481         /// <since_tizen> 3 </since_tizen>
 482         public PropertyMap OutputVisualMap
 483         {
 484             get
 485             {
 486                 ComposingPropertyMap();
 487                 return _outputVisualMap;
 488             }
 489         }
 490
 491
 492         /// <summary>
 493         /// The shader to use in the visual.
 494         /// </summary>
 495         /// <since_tizen> 3 </since_tizen>
 496         public PropertyMap Shader
 497         {
 498             get
 499             {
 500                 return _shader;
 501             }
 502             set
 503             {
 504                 _shader = value;
 505                 UpdateVisual();
 506             }
 507         }
 508
 509         /// <summary>
 510         /// Enables or disables the premultiplied alpha. <br />
 511         /// The premultiplied alpha is false by default unless this behavior is modified by the derived visual type.
 512         /// </summary>
 513         /// <since_tizen> 3 </since_tizen>
 514         public bool PremultipliedAlpha
 515         {
 516             get
 517             {
 518                 return _premultipliedAlpha ?? (false);
 519             }
 520             set
 521             {
 522                 _premultipliedAlpha = value;
 523                 UpdateVisual();
 524             }
 525         }
 526
 527         /// <summary>
 528         /// Mix color is a blend color for any visual.
 529         /// </summary>
 530         /// <since_tizen> 3 </since_tizen>
 531         public Color MixColor
 532         {
 533             get
 534             {
 535                 return _mixColor;
 536             }
 537             set
 538             {
 539                 _mixColor = value;
 540                 UpdateVisual();
 541             }
 542         }
 543
 544         /// <summary>
 545         /// Opacity is the alpha component of the mix color discussed above.
 546         /// </summary>
 547         /// <since_tizen> 3 </since_tizen>
 548         public float Opacity
 549         {
 550             get
 551             {
 552                 return _opacity ?? (1.0f);
 553             }
 554             set
 555             {
 556                 _opacity = value;
 557                 UpdateVisual();
 558             }
 559         }
 560
 561         /// <summary>
 562         /// The fitting mode of the visual.
 563         /// The default is defined by the type of visual (if it is suitable to be stretched or not).
 564         /// </summary>
 565         /// <since_tizen> 5 </since_tizen>
 566         public VisualFittingModeType VisualFittingMode
 567         {
 568             get
 569             {
 570                 if (_visualFittingMode == null)
 571                 {
 572                     if (this is AnimatedImageVisual ||
 573                         this is MeshVisual ||
 574                         this is PrimitiveVisual ||
 575                         this is TextVisual)
 576                     {
 577                         return VisualFittingModeType.FitKeepAspectRatio;
 578                     }
 579                     else
 580                     {
 581                         return VisualFittingModeType.Fill;
 582                     }
 583                 }
 584                 else
 585                 {
 586                     return (VisualFittingModeType)_visualFittingMode;
 587                 }
 588             }
 589             set
 590             {
 591                 _visualFittingMode = value;
 592                 UpdateVisual();
 593             }
 594         }
 595
 596         /// <summary>
 597         /// The corner radius of the visual.
 598         /// </summary>
 599         [EditorBrowsable(EditorBrowsableState.Never)]
 600         public float CornerRadius
 601         {
 602             protected get
 603             {
 604                 return cornerRadius ?? (0.0f);
 605             }
 606             set
 607             {
 608                 cornerRadius = value;
 609                 UpdateVisual();
 610             }
 611         }
 612
 613         internal string Name
 614         {
 615             set;
 616             get;
 617         }
 618
 619         internal int VisualIndex
 620         {
 621             set;
 622             get;
 623         }
 624
 625         internal VisualView Parent
 626         {
 627             set;
 628             get;
 629         }
 630
 631         /// <summary>
 632         /// Suppress UpdateVisual() to update properties to Parent.
 633         /// If it is set to true, UpdateVisual() is ignored unless it is called with force.
 634         /// </summary>
 635         internal bool SuppressUpdateVisual { get; set; } = false;
 636
 637         internal void UpdateVisual(bool force = false)
 638         {
 639             if (VisualIndex > 0 && (!SuppressUpdateVisual || force))
 640             {
 641                 NUILog.Debug("UpdateVisual()! VisualIndex=" + VisualIndex);
 642                 Parent.UpdateVisual(VisualIndex, Name, this);
 643             }
 644             else
 645             {
 646                 NUILog.Debug("VisualIndex was not set");
 647             }
 648         }
 649
 650         /// <summary>
 651         /// Compose the out visual map.
 652         /// </summary>
 653         /// <since_tizen> 3 </since_tizen>
 654         protected virtual void ComposingPropertyMap()
 655         {
 656             if (null == _outputVisualMap)
 657             {
 658                 _outputVisualMap = new PropertyMap();
 659             }
 660
 661             if (_shader != null) { _outputVisualMap.Add(Visual.Property.Shader, new PropertyValue(_shader)); }
 662             if (_premultipliedAlpha != null) { _outputVisualMap.Add(Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
 663             if (_mixColor != null) { _outputVisualMap.Add(Visual.Property.MixColor, new PropertyValue(_mixColor)); }
 664             if (_opacity != null) { _outputVisualMap.Add(Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
 665             if (_visualFittingMode != null) { _outputVisualMap.Add(Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
 666             if (cornerRadius != null) { _outputVisualMap.Add(Visual.Property.CornerRadius, new PropertyValue((int)cornerRadius)); }
 667         }
 668
 669         private void ComposingTransformMap()
 670         {
 671             _visualTransformMap = new PropertyMap();
 672             if (_visualSize != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Size, new PropertyValue(_visualSize)); }
 673             if (_visualOffset != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Offset, new PropertyValue(_visualOffset)); }
 674             if (_visualOffsetPolicy != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.OffsetPolicy, new PropertyValue(_visualOffsetPolicy)); }
 675             if (_visualSizePolicy != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.SizePolicy, new PropertyValue(_visualSizePolicy)); }
 676             if (_visualOrigin != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Origin, new PropertyValue((int)_visualOrigin)); }
 677             if (_visualAnchorPoint != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.AnchorPoint, new PropertyValue((int)_visualAnchorPoint)); }
 678         }
 679     }
 680 }