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