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         protected 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                 if (_visualOffsetPolicy == null)
 240                 {
 241                     _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 242                 }
 243
 244                 switch (value)
 245                 {
 246                     case VisualTransformPolicyType.Relative:
 247                         _visualOffsetPolicy.X = 0.0f;
 248                         break;
 249                     case VisualTransformPolicyType.Absolute:
 250                         _visualOffsetPolicy.X = 1.0f;
 251                         break;
 252                     default:
 253                         _visualOffsetPolicy.X = 0.0f;
 254                         break;
 255                 }
 256
 257                 UpdateVisual();
 258             }
 259         }
 260
 261         /// <summary>
 262         /// Gets or sets whether the y offset values are relative<br />
 263         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 264         /// By default, the y offset is relative.<br />
 265         /// Optional.
 266         /// </summary>
 267         /// <since_tizen> 3 </since_tizen>
 268         public VisualTransformPolicyType PositionPolicyY
 269         {
 270             get
 271             {
 272                 if (_visualOffsetPolicy != null && _visualOffsetPolicy.Y == 1.0f)
 273                 {
 274                     return VisualTransformPolicyType.Absolute;
 275                 }
 276                 return VisualTransformPolicyType.Relative;
 277             }
 278             set
 279             {
 280                 if (_visualOffsetPolicy == null)
 281                 {
 282                     _visualOffsetPolicy = new Vector2(0.0f, 0.0f);
 283                 }
 284
 285                 switch (value)
 286                 {
 287                     case VisualTransformPolicyType.Relative:
 288                         _visualOffsetPolicy.Y = 0.0f;
 289                         break;
 290                     case VisualTransformPolicyType.Absolute:
 291                         _visualOffsetPolicy.Y = 1.0f;
 292                         break;
 293                     default:
 294                         _visualOffsetPolicy.Y = 0.0f;
 295                         break;
 296                 }
 297                 UpdateVisual();
 298             }
 299         }
 300
 301         /// <summary>
 302         /// Gets or sets whether the size values of the width or the height are relative<br />
 303         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 304         /// By default, offsets of both the width and the height are relative to the control's size.<br />
 305         /// Optional.
 306         /// </summary>
 307         /// <since_tizen> 3 </since_tizen>
 308         public VisualTransformPolicyType SizePolicy
 309         {
 310             get
 311             {
 312                 if (_visualSizePolicy != null && _visualSizePolicy.X == 1.0f
 313                     && _visualSizePolicy.Y == 1.0f)
 314                 {
 315                     return VisualTransformPolicyType.Absolute;
 316                 }
 317                 return VisualTransformPolicyType.Relative;
 318             }
 319             set
 320             {
 321                 switch (value)
 322                 {
 323                     case VisualTransformPolicyType.Relative:
 324                         _visualSizePolicy = new Vector2(0.0f, 0.0f);
 325                         break;
 326                     case VisualTransformPolicyType.Absolute:
 327                         _visualSizePolicy = new Vector2(1.0f, 1.0f);
 328                         break;
 329                     default:
 330                         _visualSizePolicy = new Vector2(0.0f, 0.0f);
 331                         break;
 332                 }
 333                 UpdateVisual();
 334             }
 335         }
 336
 337         /// <summary>
 338         /// Gets or sets whether size values of the width are relative.<br />
 339         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 340         /// By default, the value of the width is relative to the control's width.<br />
 341         /// Optional.
 342         /// </summary>
 343         /// <since_tizen> 3 </since_tizen>
 344         public VisualTransformPolicyType SizePolicyWidth
 345         {
 346             get
 347             {
 348                 if (_visualSizePolicy != null && _visualSizePolicy.Width == 1.0f)
 349                 {
 350                     return VisualTransformPolicyType.Absolute;
 351                 }
 352                 return VisualTransformPolicyType.Relative;
 353             }
 354             set
 355             {
 356                 if (_visualSizePolicy == null)
 357                 {
 358                     _visualSizePolicy = new Vector2(0.0f, 0.0f);
 359                 }
 360
 361                 switch (value)
 362                 {
 363                     case VisualTransformPolicyType.Relative:
 364                         _visualSizePolicy.Width = 0.0f;
 365                         break;
 366                     case VisualTransformPolicyType.Absolute:
 367                         _visualSizePolicy.Width = 1.0f;
 368                         break;
 369                     default:
 370                         _visualSizePolicy.Width = 0.0f;
 371                         break;
 372                 }
 373                 UpdateVisual();
 374             }
 375         }
 376
 377         /// <summary>
 378         /// Gets or sets whether size values of the height are relative<br />
 379         /// (percentage [0.0f to 1.0f] of the control) or absolute (in world units).<br />
 380         /// By default, the height value is relative to the control's height.<br />
 381         /// Optional.
 382         /// </summary>
 383         /// <since_tizen> 3 </since_tizen>
 384         public VisualTransformPolicyType SizePolicyHeight
 385         {
 386             get
 387             {
 388                 if (_visualSizePolicy != null && _visualSizePolicy.Height == 1.0f)
 389                 {
 390                     return VisualTransformPolicyType.Absolute;
 391                 }
 392                 return VisualTransformPolicyType.Relative;
 393             }
 394             set
 395             {
 396                 if (_visualSizePolicy == null)
 397                 {
 398                     _visualSizePolicy = new Vector2(0.0f, 0.0f);
 399                 }
 400
 401                 switch (value)
 402                 {
 403                     case VisualTransformPolicyType.Relative:
 404                         _visualSizePolicy.Height = 0.0f;
 405                         break;
 406                     case VisualTransformPolicyType.Absolute:
 407                         _visualSizePolicy.Height = 1.0f;
 408                         break;
 409                     default:
 410                         _visualSizePolicy.Height = 0.0f;
 411                         break;
 412                 }
 413                 UpdateVisual();
 414             }
 415         }
 416
 417         /// <summary>
 418         /// Gets or sets the origin of the visual within its control area.<br />
 419         /// By default, the origin is center.<br />
 420         /// Optional.
 421         /// </summary>
 422         /// <since_tizen> 3 </since_tizen>
 423         public Visual.AlignType Origin
 424         {
 425             get
 426             {
 427                 return _visualOrigin ?? (Visual.AlignType.Center);
 428             }
 429             set
 430             {
 431                 _visualOrigin = value;
 432                 UpdateVisual();
 433             }
 434         }
 435
 436         /// <summary>
 437         /// Gets or sets the anchor point of the visual.<br />
 438         /// By default, the anchor point is center.<br />
 439         /// Optional.
 440         /// </summary>
 441         /// <since_tizen> 3 </since_tizen>
 442         public Visual.AlignType AnchorPoint
 443         {
 444             get
 445             {
 446                 return _visualAnchorPoint ?? (Visual.AlignType.Center);
 447             }
 448             set
 449             {
 450                 _visualAnchorPoint = value;
 451                 UpdateVisual();
 452             }
 453         }
 454
 455         /// <summary>
 456         /// Gets or sets the depth index of the visual.<br />
 457         /// By default, the depth index is 0.<br />
 458         /// Optional.
 459         /// </summary>
 460         /// <since_tizen> 3 </since_tizen>
 461         public int DepthIndex
 462         {
 463             get
 464             {
 465                 return _depthIndex ?? (0);
 466             }
 467             set
 468             {
 469                 _depthIndex = value;
 470             }
 471         }
 472
 473         /// <summary>
 474         /// Gets the transform map used by the visual.
 475         /// </summary>
 476         /// <since_tizen> 3 </since_tizen>
 477         public PropertyMap OutputTransformMap
 478         {
 479             get
 480             {
 481                 ComposingTransformMap();
 482                 return _visualTransformMap;
 483             }
 484         }
 485
 486         /// <summary>
 487         /// Gets the property map to create the visual.
 488         /// </summary>
 489         /// <since_tizen> 3 </since_tizen>
 490         public PropertyMap OutputVisualMap
 491         {
 492             get
 493             {
 494                 ComposingPropertyMap();
 495                 return _outputVisualMap;
 496             }
 497         }
 498
 499
 500         /// <summary>
 501         /// The shader to use in the visual.
 502         /// </summary>
 503         /// <since_tizen> 3 </since_tizen>
 504         public PropertyMap Shader
 505         {
 506             get
 507             {
 508                 return _shader;
 509             }
 510             set
 511             {
 512                 _shader = value;
 513                 UpdateVisual();
 514             }
 515         }
 516
 517         /// <summary>
 518         /// Enables or disables the premultiplied alpha. <br />
 519         /// The premultiplied alpha is false by default unless this behavior is modified by the derived visual type.
 520         /// </summary>
 521         /// <since_tizen> 3 </since_tizen>
 522         public bool PremultipliedAlpha
 523         {
 524             get
 525             {
 526                 return _premultipliedAlpha ?? (false);
 527             }
 528             set
 529             {
 530                 _premultipliedAlpha = value;
 531                 UpdateVisual();
 532             }
 533         }
 534
 535         /// <summary>
 536         /// Mix color is a blend color for any visual.
 537         /// </summary>
 538         /// <since_tizen> 3 </since_tizen>
 539         public Color MixColor
 540         {
 541             get
 542             {
 543                 return _mixColor;
 544             }
 545             set
 546             {
 547                 _mixColor = value;
 548                 UpdateVisual();
 549             }
 550         }
 551
 552         /// <summary>
 553         /// Opacity is the alpha component of the mix color discussed above.
 554         /// </summary>
 555         /// <since_tizen> 3 </since_tizen>
 556         public float Opacity
 557         {
 558             get
 559             {
 560                 return _opacity ?? (1.0f);
 561             }
 562             set
 563             {
 564                 _opacity = value;
 565                 UpdateVisual();
 566             }
 567         }
 568
 569         /// <summary>
 570         /// The fitting mode of the visual.
 571         /// The default is defined by the type of visual (if it is suitable to be stretched or not).
 572         /// </summary>
 573         /// <since_tizen> 5 </since_tizen>
 574         public VisualFittingModeType VisualFittingMode
 575         {
 576             get
 577             {
 578                 if (_visualFittingMode == null)
 579                 {
 580                     if (this is AnimatedImageVisual ||
 581                         this is MeshVisual ||
 582                         this is PrimitiveVisual ||
 583                         this is TextVisual)
 584                     {
 585                         return VisualFittingModeType.FitKeepAspectRatio;
 586                     }
 587                     else
 588                     {
 589                         return VisualFittingModeType.Fill;
 590                     }
 591                 }
 592                 else
 593                 {
 594                     return (VisualFittingModeType)_visualFittingMode;
 595                 }
 596             }
 597             set
 598             {
 599                 _visualFittingMode = value;
 600                 UpdateVisual();
 601             }
 602         }
 603
 604         /// <summary>
 605         /// The corner radius of the visual.
 606         /// </summary>
 607         [EditorBrowsable(EditorBrowsableState.Never)]
 608         public float CornerRadius
 609         {
 610             get
 611             {
 612                 return _cornerRadius ?? (0.0f);
 613             }
 614             set
 615             {
 616                 _cornerRadius = value;
 617                 UpdateVisual();
 618             }
 619         }
 620
 621         internal string Name
 622         {
 623             set;
 624             get;
 625         }
 626
 627         internal int VisualIndex
 628         {
 629             set;
 630             get;
 631         }
 632
 633         internal VisualView Parent
 634         {
 635             set;
 636             get;
 637         }
 638
 639         /// <summary>
 640         /// Suppress UpdateVisual() to update properties to Parent.
 641         /// If it is set to true, UpdateVisual() is ignored unless it is called with force.
 642         /// </summary>
 643         internal bool SuppressUpdateVisual { get; set; } = false;
 644
 645         internal void UpdateVisual(bool force = false)
 646         {
 647             if (VisualIndex > 0 && (!SuppressUpdateVisual || force))
 648             {
 649                 NUILog.Debug("UpdateVisual()! VisualIndex=" + VisualIndex);
 650                 Parent.UpdateVisual(VisualIndex, Name, this);
 651             }
 652             else
 653             {
 654                 NUILog.Debug("VisualIndex was not set");
 655             }
 656         }
 657
 658         /// <summary>
 659         /// Compose the out visual map.
 660         /// </summary>
 661         /// <since_tizen> 3 </since_tizen>
 662         protected virtual void ComposingPropertyMap()
 663         {
 664             if (null == _outputVisualMap)
 665             {
 666                 _outputVisualMap = new PropertyMap();
 667             }
 668
 669             if (_shader != null) { _outputVisualMap.Add(Visual.Property.Shader, new PropertyValue(_shader)); }
 670             if (_premultipliedAlpha != null) { _outputVisualMap.Add(Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
 671             if (_mixColor != null) { _outputVisualMap.Add(Visual.Property.MixColor, new PropertyValue(_mixColor)); }
 672             if (_opacity != null) { _outputVisualMap.Add(Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
 673             if (_visualFittingMode != null) { _outputVisualMap.Add(Visual.Property.VisualFittingMode, new PropertyValue((int)_visualFittingMode)); }
 674             if (_cornerRadius != null) { _outputVisualMap.Add(Visual.Property.CornerRadius, new PropertyValue((int)_cornerRadius)); }
 675         }
 676
 677         private void ComposingTransformMap()
 678         {
 679             _visualTransformMap = new PropertyMap();
 680             if (_visualSize != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Size, new PropertyValue(_visualSize)); }
 681             if (_visualOffset != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Offset, new PropertyValue(_visualOffset)); }
 682             if (_visualOffsetPolicy != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.OffsetPolicy, new PropertyValue(_visualOffsetPolicy)); }
 683             if (_visualSizePolicy != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.SizePolicy, new PropertyValue(_visualSizePolicy)); }
 684             if (_visualOrigin != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.Origin, new PropertyValue((int)_visualOrigin)); }
 685             if (_visualAnchorPoint != null) { _visualTransformMap.Add((int)VisualTransformPropertyType.AnchorPoint, new PropertyValue((int)_visualAnchorPoint)); }
 686         }
 687     }
 688 }