src/Tizen.NUI/src/public/VisualConstants.cs

   1 // Copyright (c) 2019 Samsung Electronics Co., Ltd.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 // http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 using System.ComponentModel;
  16
  17 namespace Tizen.NUI
  18 {
  19     /// <summary>
  20     /// Specifies the release policy types.<br />
  21     /// Decides if the image should be cached in different conditions.
  22     /// </summary>
  23     /// <since_tizen> 5 </since_tizen>
  24     public enum ReleasePolicyType
  25     {
  26         /// <summary>
  27         /// Image is released when visual detached from scene.
  28         /// </summary>
  29         Detached = 0,
  30         /// <summary>
  31         /// Image is only released when visual is destroyed.
  32         /// </summary>
  33         Destroyed,
  34         /// <summary>
  35         /// Image is not released.
  36         /// </summary>
  37         Never
  38     }
  39
  40     /// <summary>
  41     /// Specifies the load policy types.<br />
  42     /// Decides when the image texture should be loaded.
  43     /// </summary>
  44     /// <since_tizen> 5 </since_tizen>
  45     public enum LoadPolicyType
  46     {
  47         /// <summary>
  48         /// Load texture once the image source has been provided. Even if not being used yet.
  49         /// </summary>
  50         Immediate = 0,
  51         /// <summary>
  52         /// Only load texture once the visual is attached, when the image needs to be shown.
  53         /// </summary>
  54         Attached
  55     }
  56
  57     /// <summary>
  58     /// Enumeration for the text horizontal aligning.
  59     /// </summary>
  60     /// <since_tizen> 3 </since_tizen>
  61     public enum HorizontalAlignment
  62     {
  63         /// <summary>
  64         /// Texts place at the begin of horizontal direction.
  65         /// </summary>
  66         [Description("BEGIN")]
  67         Begin,
  68         /// <summary>
  69         /// Texts place at the center of horizontal direction.
  70         /// </summary>
  71         [Description("CENTER")]
  72         Center,
  73         /// <summary>
  74         /// Texts place at the end of horizontal direction.
  75         /// </summary>
  76         [Description("END")]
  77         End
  78     }
  79
  80     /// <summary>
  81     /// Enumeration for the text horizontal aligning.
  82     /// </summary>
  83     /// <since_tizen> 3 </since_tizen>
  84     public enum VerticalAlignment
  85     {
  86         /// <summary>
  87         /// Texts place at the top of vertical direction.
  88         /// </summary>
  89         [Description("TOP")]
  90         Top,
  91         /// <summary>
  92         /// Texts place at the center of vertical direction.
  93         /// </summary>
  94         [Description("CENTER")]
  95         Center,
  96         /// <summary>
  97         /// Texts place at the bottom of vertical direction.
  98         /// </summary>
  99         [Description("BOTTOM")]
 100         Bottom
 101     }
 102
 103     /// <summary>
 104     /// This specifies wrap mode types.<br />
 105     /// WrapModeU and WrapModeV separately decide how the texture should be sampled when the u and v coordinate exceeds the range of 0.0 to 1.0.
 106     /// </summary>
 107     /// <since_tizen> 3 </since_tizen>
 108     public enum WrapModeType
 109     {
 110         /// <summary>
 111         /// The default value.
 112         /// </summary>
 113         Default = 0,
 114         /// <summary>
 115         /// Clamp to edge.
 116         /// </summary>
 117         ClampToEdge,
 118         /// <summary>
 119         /// Repeat.
 120         /// </summary>
 121         Repeat,
 122         /// <summary>
 123         /// Mirrored repeat.
 124         /// </summary>
 125         MirroredRepeat
 126     }
 127
 128     /// <summary>
 129     /// This specifies fitting mode types. Fitting options, used when resizing images to fit desired dimensions.<br />
 130     /// A fitting mode controls the region of a loaded image to be mapped to the desired image rectangle.<br />
 131     /// All fitting modes preserve the aspect ratio of the image contents.<br />
 132     /// </summary>
 133     /// <since_tizen> 3 </since_tizen>
 134     public enum FittingModeType
 135     {
 136         /// <summary>
 137         /// Full-screen image display: Limit loaded image resolution to device resolution using the ShrinkToFit mode.
 138         /// </summary>
 139         ShrinkToFit,
 140         /// <summary>
 141         /// Thumbnail gallery grid: Limit loaded image resolution to screen tile using the ScaleToFill mode.
 142         /// </summary>
 143         ScaleToFill,
 144         /// <summary>
 145         /// Image columns: Limit loaded image resolution to column width using the FitWidth mode.
 146         /// </summary>
 147         FitWidth,
 148         /// <summary>
 149         /// Image rows: Limit loaded image resolution to row height using the FitHeight mode.
 150         /// </summary>
 151         FitHeight
 152     }
 153
 154     /// <summary>
 155     /// This specifies sampling mode types. Filtering options are used when resizing images to sample original pixels.<br />
 156     /// A SamplingMode controls how pixels in an input image are sampled and combined to generate each pixel of a destination image during scaling.<br />
 157     /// NoFilter and Box modes do not guarantee that the output pixel array exactly matches the rectangle specified by the desired dimensions and the FittingMode,<br />
 158     /// but all other filter modes do if the desired dimensions are not more than the raw dimensions of the input image file.<br />
 159     /// </summary>
 160     /// <since_tizen> 3 </since_tizen>
 161     public enum SamplingModeType
 162     {
 163         /// <summary>
 164         /// Iteratively box filter to generate an image of 1/2, 1/4, 1/8, etc. width and height and approximately the desired size. <br />
 165         /// This is the default.
 166         /// </summary>
 167         Box,
 168         /// <summary>
 169         /// For each output pixel, read one input pixel.
 170         /// </summary>
 171         Nearest,
 172         /// <summary>
 173         /// For each output pixel, read a quad of four input pixels and write a weighted average of them.
 174         /// </summary>
 175         Linear,
 176         /// <summary>
 177         /// Iteratively box filter to generate an image of 1/2, 1/4, 1/8, etc. width and height and approximately the desired size, <br />
 178         /// then for each output pixel, read one pixel from the last level of box filtering.<br />
 179         /// </summary>
 180         BoxThenNearest,
 181         /// <summary>
 182         /// Iteratively box filter to almost the right size, then for each output pixel, read four pixels from the last level of box filtering and write their weighted average.
 183         /// </summary>
 184         BoxThenLinear,
 185         /// <summary>
 186         /// No filtering is performed. If the SCALE_TO_FILL scaling mode is enabled, the borders of the image may be trimmed to match the aspect ratio of the desired dimensions.
 187         /// </summary>
 188         NoFilter,
 189         /// <summary>
 190         /// For caching algorithms where a client strongly prefers a cache-hit to reuse a cached image.
 191         /// </summary>
 192         DontCare
 193     }
 194
 195     /// <summary>
 196     /// The type of coordinate system for certain attributes of the points in a gradient.
 197     /// </summary>
 198     /// <since_tizen> 3 </since_tizen>
 199     public enum GradientVisualUnitsType
 200     {
 201         /// <summary>
 202         /// Uses the normals for the start, end, and center points, i.e., top-left is (-0.5, -0.5) and bottom-right is (0.5, 0.5).
 203         /// </summary>
 204         ObjectBoundingBox,
 205         /// <summary>
 206         /// Uses the user coordinates for the start, end, and center points, i.e., in a 200 by 200 control, top-left is (0, 0) and bottom-right is (200, 200).
 207         /// </summary>
 208         UserSpace
 209     }
 210
 211     /// <summary>
 212     /// This specifies SpreadMethod types.<br />
 213     /// SpreadMethod defines what happens if the gradient starts or ends inside the bounds of the target rectangle.<br />
 214     /// </summary>
 215     /// <since_tizen> 3 </since_tizen>
 216     public enum GradientVisualSpreadMethodType
 217     {
 218         /// <summary>
 219         /// Uses the terminal colors of the gradient to fill the remainder of the quad.
 220         /// </summary>
 221         Pad,
 222         /// <summary>
 223         /// Reflects the gradient pattern start-to-end, end-to-start, start-to-end, etc. until the quad is filled.
 224         /// </summary>
 225         Reflect,
 226         /// <summary>
 227         /// Repeats the gradient pattern start-to-end, start-to-end, start-to-end, etc. until the quad is filled.
 228         /// </summary>
 229         Repeat
 230     }
 231
 232     /// <summary>
 233     /// The shading mode used by the mesh visual.
 234     /// </summary>
 235     /// <since_tizen> 3 </since_tizen>
 236     public enum MeshVisualShadingModeValue
 237     {
 238         /// <summary>
 239         /// *Simplest*. One color that is lit by ambient and diffuse lighting.
 240         /// </summary>
 241         TexturelessWithDiffuseLighting,
 242         /// <summary>
 243         /// Uses only the visual image textures provided with specular lighting in addition to ambient and diffuse lighting.
 244         /// </summary>
 245         TexturedWithSpecularLighting,
 246         /// <summary>
 247         /// Uses all textures provided including gloss, normal, and texture map along with specular, ambient, and diffuse lighting.
 248         /// </summary>
 249         TexturedWithDetailedSpecularLighting
 250     }
 251
 252     /// <summary>
 253     /// The primitive shape to render as a primitive visual.
 254     /// </summary>
 255     /// <since_tizen> 3 </since_tizen>
 256     public enum PrimitiveVisualShapeType
 257     {
 258         /// <summary>
 259         /// A perfectly round geometrical object in the three-dimensional space.
 260         /// </summary>
 261         Sphere,
 262         /// <summary>
 263         /// The area bound between two circles, i.e., a cone with the tip removed.
 264         /// </summary>
 265         ConicalFrustrum,
 266         /// <summary>
 267         /// Equivalent to a conical frustrum with the top radius of zero.
 268         /// </summary>Equivalent to a conical frustrum with the top radius of zero.
 269         Cone,
 270         /// <summary>
 271         /// Equivalent to a conical frustrum with the top radius of zero.
 272         /// </summary>
 273         Cylinder,
 274         /// <summary>
 275         /// Equivalent to a conical frustrum with equal radii for the top and bottom circles.
 276         /// </summary>
 277         Cube,
 278         /// <summary>
 279         /// Equivalent to a bevelled cube with a bevel percentage of zero.
 280         /// </summary>
 281         Octahedron,
 282         /// <summary>
 283         /// Equivalent to a bevelled cube with a bevel percentage of one.
 284         /// </summary>
 285         BevelledCube
 286     }
 287
 288     /// <summary>
 289     /// The values of this enum determine how the visual should fit into the view.
 290     /// </summary>
 291     /// <since_tizen> 5 </since_tizen>
 292     public enum VisualFittingModeType
 293     {
 294         /// <summary>
 295         /// The visual should be scaled to fit, preserving aspect ratio.
 296         /// </summary>
 297         FitKeepAspectRatio,
 298         /// <summary>
 299         /// The visual should be stretched to fill, not preserving aspect ratio.
 300         /// </summary>
 301         Fill
 302     }
 303
 304     /// <summary>
 305     /// This specifies policy types that could be used by the transform for the offset or size.
 306     /// </summary>
 307     /// <since_tizen> 3 </since_tizen>
 308     public enum VisualTransformPolicyType
 309     {
 310         /// <summary>
 311         /// Relative to the control (percentage [0.0f to 1.0f] of the control).
 312         /// </summary>
 313         Relative = 0,
 314         /// <summary>
 315         /// Absolute value in world units.
 316         /// </summary>
 317         Absolute = 1
 318     }
 319
 320     /// <summary>
 321     /// This specifies all the transform property types.
 322     /// </summary>
 323     /// <since_tizen> 3 </since_tizen>
 324     public enum VisualTransformPropertyType
 325     {
 326         /// <summary>
 327         /// Offset of the visual, which can be either relative (percentage [0.0f to 1.0f] of the parent) or absolute (in world units).
 328         /// </summary>
 329         Offset,
 330         /// <summary>
 331         /// Size of the visual, which can be either relative (percentage [0.0f to 1.0f] of the parent) or absolute (in world units).
 332         /// </summary>
 333         Size,
 334         /// <summary>
 335         /// The origin of the visual within its control area.
 336         /// </summary>
 337         Origin,
 338         /// <summary>
 339         /// The anchor-point of the visual.
 340         /// </summary>
 341         AnchorPoint,
 342         /// <summary>
 343         /// Whether the x or y offset values are relative (percentage [0.0f to 1.0f] of the control) or absolute (in world units).
 344         /// </summary>
 345         OffsetPolicy,
 346         /// <summary>
 347         /// Whether the width or the height size values are relative (percentage [0.0f to 1.0f] of the control) or absolute (in world units).
 348         /// </summary>
 349         SizePolicy
 350     }
 351
 352     /// <summary>
 353     /// This specifies visual types.
 354     /// </summary>
 355     /// <since_tizen> 3 </since_tizen>
 356     public struct Visual
 357     {
 358         /// <summary>
 359         /// The index for the visual type.
 360         /// </summary>
 361         /// <since_tizen> 3 </since_tizen>
 362         public enum Type
 363         {
 364             /// <summary>
 365             /// Renders a solid color as an internal border to the control's quad.
 366             /// </summary>
 367             Border,
 368             /// <summary>
 369             /// Renders a solid color to the control's quad.
 370             /// </summary>
 371             Color,
 372             /// <summary>
 373             /// Renders a smooth transition of colors to the control's quad.
 374             /// </summary>
 375             Gradient,
 376             /// <summary>
 377             /// Renders an image into the control's quad.
 378             /// </summary>
 379             Image,
 380             /// <summary>
 381             /// Renders a mesh using an "obj" file, optionally with textures provided by an "mtl" file.
 382             /// </summary>
 383             Mesh,
 384             /// <summary>
 385             /// Renders a simple 3D shape, such as a cube or a sphere.
 386             /// </summary>
 387             Primitive,
 388             /// <summary>
 389             /// Renders a simple wire-frame outlining a quad.
 390             /// </summary>
 391             Wireframe,
 392             /// <summary>
 393             /// Renders text.
 394             /// </summary>
 395             Text,
 396             /// <summary>
 397             /// Renders an NPatch image.
 398             /// </summary>
 399             NPatch,
 400             /// <summary>
 401             /// Renders an SVG image.
 402             /// </summary>
 403             SVG,
 404             /// <summary>
 405             /// Renders a animated image (animated GIF).
 406             /// </summary>
 407             AnimatedImage
 408         }
 409
 410         /// <summary>
 411         /// This specifies visual properties.
 412         /// </summary>
 413         /// <since_tizen> 3 </since_tizen>
 414         public struct Property
 415         {
 416             /// <summary>
 417             /// Type.
 418             /// </summary>
 419             /// <since_tizen> 3 </since_tizen>
 420             public static readonly int Type = NDalic.VISUAL_PROPERTY_TYPE;
 421             /// <summary>
 422             /// Shader.
 423             /// </summary>
 424             /// <since_tizen> 3 </since_tizen>
 425             public static readonly int Shader = NDalic.VISUAL_PROPERTY_SHADER;
 426             /// <summary>
 427             /// Transform.
 428             /// </summary>
 429             /// <since_tizen> 3 </since_tizen>
 430             public static readonly int Transform = NDalic.VISUAL_PROPERTY_TRANSFORM;
 431             /// <summary>
 432             /// PremultipliedAlpha.
 433             /// </summary>
 434             /// <since_tizen> 3 </since_tizen>
 435             public static readonly int PremultipliedAlpha = NDalic.VISUAL_PROPERTY_PREMULTIPLIED_ALPHA;
 436             /// <summary>
 437             /// MixColor.
 438             /// </summary>
 439             /// <since_tizen> 3 </since_tizen>
 440             public static readonly int MixColor = NDalic.VISUAL_PROPERTY_MIX_COLOR;
 441             /// <summary>
 442             /// Opacity.
 443             /// </summary>
 444             /// <since_tizen> 3 </since_tizen>
 445             public static readonly int Opacity = NDalic.VISUAL_PROPERTY_MIX_COLOR + 1;
 446             /// <summary>
 447             /// The fitting mode of the visual.
 448             /// </summary>
 449             /// <since_tizen> 5 </since_tizen>
 450             public static readonly int VisualFittingMode = NDalic.VISUAL_PROPERTY_MIX_COLOR + 2;
 451         }
 452
 453         /// <summary>
 454         /// This specifies shader properties.
 455         /// </summary>
 456         /// <since_tizen> 3 </since_tizen>
 457         public struct ShaderProperty
 458         {
 459             /// <summary>
 460             /// Vertex shader code
 461             /// </summary>
 462             /// <since_tizen> 3 </since_tizen>
 463             public static readonly int VertexShader = NDalic.VISUAL_SHADER_VERTEX;
 464             /// <summary>
 465             /// Fragment shader code
 466             /// </summary>
 467             /// <since_tizen> 3 </since_tizen>
 468             public static readonly int FragmentShader = NDalic.VISUAL_SHADER_FRAGMENT;
 469             /// <summary>
 470             /// How to subdivide the grid along X
 471             /// </summary>
 472             /// <since_tizen> 3 </since_tizen>
 473             public static readonly int ShaderSubdivideGridX = NDalic.VISUAL_SHADER_SUBDIVIDE_GRID_X;
 474             /// <summary>
 475             /// How to subdivide the grid along Y
 476             /// </summary>
 477             /// <since_tizen> 3 </since_tizen>
 478             public static readonly int ShaderSubdivideGridY = NDalic.VISUAL_SHADER_SUBDIVIDE_GRID_Y;
 479             /// <summary>
 480             /// Bitmask of hints
 481             /// </summary>
 482             /// <since_tizen> 3 </since_tizen>
 483             public static readonly int ShaderHints = NDalic.VISUAL_SHADER_HINTS;
 484         }
 485
 486         /// <summary>
 487         /// This specifies visaul align types.
 488         /// </summary>
 489         /// <since_tizen> 3 </since_tizen>
 490         public enum AlignType
 491         {
 492             /// <summary>
 493             /// TopBegin
 494             /// </summary>
 495             /// <since_tizen> 3 </since_tizen>
 496             TopBegin = 0,
 497             /// <summary>
 498             /// TopCenter
 499             /// </summary>
 500             /// <since_tizen> 3 </since_tizen>
 501             TopCenter,
 502             /// <summary>
 503             /// TopEnd
 504             /// </summary>
 505             /// <since_tizen> 3 </since_tizen>
 506             TopEnd,
 507             /// <summary>
 508             /// CenterBegin
 509             /// </summary>
 510             /// <since_tizen> 3 </since_tizen>
 511             CenterBegin,
 512             /// <summary>
 513             /// Center
 514             /// </summary>
 515             /// <since_tizen> 3 </since_tizen>
 516             Center,
 517             /// <summary>
 518             /// CenterEnd
 519             /// </summary>
 520             /// <since_tizen> 3 </since_tizen>
 521             CenterEnd,
 522             /// <summary>
 523             /// BottomBegin
 524             /// </summary>
 525             /// <since_tizen> 3 </since_tizen>
 526             BottomBegin,
 527             /// <summary>
 528             /// BottomCenter
 529             /// </summary>
 530             /// <since_tizen> 3 </since_tizen>
 531             BottomCenter,
 532             /// <summary>
 533             /// BottomEnd
 534             /// </summary>
 535             /// <since_tizen> 3 </since_tizen>
 536             BottomEnd
 537         }
 538     }
 539
 540     /// <summary>
 541     /// This specifies properties of the BorderVisual.
 542     /// </summary>
 543     /// <since_tizen> 3 </since_tizen>
 544     public struct BorderVisualProperty
 545     {
 546         /// <summary>
 547         /// The color of the border.
 548         /// </summary>
 549         /// <since_tizen> 3 </since_tizen>
 550         public static readonly int Color = NDalic.BORDER_VISUAL_COLOR;
 551         /// <summary>
 552         /// The width of the border (in pixels).
 553         /// </summary>
 554         /// <since_tizen> 3 </since_tizen>
 555         public static readonly int Size = NDalic.BORDER_VISUAL_SIZE;
 556         /// <summary>
 557         /// Whether anti-aliasing of the border is required.
 558         /// </summary>
 559         /// <since_tizen> 3 </since_tizen>
 560         public static readonly int AntiAliasing = NDalic.BORDER_VISUAL_ANTI_ALIASING;
 561     }
 562
 563     /// <summary>
 564     /// This specifies properties of the ColorVisual.
 565     /// </summary>
 566     /// <since_tizen> 3 </since_tizen>
 567     public struct ColorVisualProperty
 568     {
 569         /// <summary>
 570         /// The solid color required.
 571         /// </summary>
 572         /// <since_tizen> 3 </since_tizen>
 573         public static readonly int MixColor = NDalic.COLOR_VISUAL_MIX_COLOR;
 574         /// <summary>
 575         /// Whether to render if the MixColor is transparent.
 576         /// </summary>
 577         /// <since_tizen> 5 </since_tizen>
 578         public static readonly int RenderIfTransparent = NDalic.COLOR_VISUAL_MIX_COLOR + 1;
 579     }
 580
 581     /// <summary>
 582     /// This specifies properties of the GradientVisual.
 583     /// </summary>
 584     /// <since_tizen> 3 </since_tizen>
 585     public struct GradientVisualProperty
 586     {
 587         /// <summary>
 588         /// The start position of a linear gradient.
 589         /// </summary>
 590         /// <since_tizen> 3 </since_tizen>
 591         public static readonly int StartPosition = NDalic.GRADIENT_VISUAL_START_POSITION;
 592         /// <summary>
 593         /// The end position of a linear gradient.
 594         /// </summary>
 595         /// <since_tizen> 3 </since_tizen>
 596         public static readonly int EndPosition = NDalic.GRADIENT_VISUAL_END_POSITION;
 597         /// <summary>
 598         /// The center point of a radial gradient.
 599         /// </summary>
 600         /// <since_tizen> 3 </since_tizen>
 601         public static readonly int Center = NDalic.GRADIENT_VISUAL_CENTER;
 602         /// <summary>
 603         /// The size of the radius of a radial gradient.
 604         /// </summary>
 605         /// <since_tizen> 3 </since_tizen>
 606         public static readonly int Radius = NDalic.GRADIENT_VISUAL_RADIUS;
 607         /// <summary>
 608         /// All the stop offsets.
 609         /// </summary>
 610         /// <since_tizen> 3 </since_tizen>
 611         public static readonly int StopOffset = NDalic.GRADIENT_VISUAL_STOP_OFFSET;
 612         /// <summary>
 613         /// The color at the stop offsets.
 614         /// </summary>
 615         /// <since_tizen> 3 </since_tizen>
 616         public static readonly int StopColor = NDalic.GRADIENT_VISUAL_STOP_COLOR;
 617         /// <summary>
 618         /// Defines the coordinate system for certain attributes of the points in a gradient.
 619         /// </summary>
 620         /// <since_tizen> 3 </since_tizen>
 621         public static readonly int Units = NDalic.GRADIENT_VISUAL_UNITS;
 622         /// <summary>
 623         /// Indicates what happens if the gradient starts or ends inside the bounds of the target rectangle.
 624         /// </summary>
 625         /// <since_tizen> 3 </since_tizen>
 626         public static readonly int SpreadMethod = NDalic.GRADIENT_VISUAL_SPREAD_METHOD;
 627     }
 628
 629     /// <summary>
 630     /// This specifies properties of the ImageVisual.
 631     /// </summary>
 632     /// <since_tizen> 3 </since_tizen>
 633     public struct ImageVisualProperty
 634     {
 635         /// <summary>
 636         /// The URL of the image.
 637         /// </summary>
 638         /// <since_tizen> 3 </since_tizen>
 639         public static readonly int URL = NDalic.IMAGE_VISUAL_URL;
 640
 641         /// <summary>
 642         /// Fitting options, used when resizing images to fit desired dimensions.
 643         /// </summary>
 644         /// <since_tizen> 3 </since_tizen>
 645         public static readonly int FittingMode = NDalic.IMAGE_VISUAL_FITTING_MODE;
 646
 647         /// <summary>
 648         /// Filtering options, used when resizing images to sample original pixels.
 649         /// </summary>
 650         /// <since_tizen> 3 </since_tizen>
 651         public static readonly int SamplingMode = NDalic.IMAGE_VISUAL_SAMPLING_MODE;
 652
 653         /// <summary>
 654         /// The desired image width.
 655         /// </summary>
 656         /// <since_tizen> 3 </since_tizen>
 657         public static readonly int DesiredWidth = NDalic.IMAGE_VISUAL_DESIRED_WIDTH;
 658
 659         /// <summary>
 660         /// The desired image height.
 661         /// </summary>
 662         /// <since_tizen> 3 </since_tizen>
 663         public static readonly int DesiredHeight = NDalic.IMAGE_VISUAL_DESIRED_HEIGHT;
 664
 665         /// <summary>
 666         /// Whether to load the image synchronously.
 667         /// </summary>
 668         /// <since_tizen> 3 </since_tizen>
 669         public static readonly int SynchronousLoading = NDalic.IMAGE_VISUAL_SYNCHRONOUS_LOADING;
 670
 671         /// <summary>
 672         /// If true, only draws the borders.
 673         /// </summary>
 674         /// <since_tizen> 3 </since_tizen>
 675         public static readonly int BorderOnly = NDalic.IMAGE_VISUAL_BORDER_ONLY;
 676
 677         /// <summary>
 678         /// The image area to be displayed.
 679         /// </summary>
 680         /// <since_tizen> 3 </since_tizen>
 681         public static readonly int PixelArea = NDalic.IMAGE_VISUAL_PIXEL_AREA;
 682
 683         /// <summary>
 684         /// The wrap mode for u coordinate.
 685         /// </summary>
 686         /// <since_tizen> 3 </since_tizen>
 687         public static readonly int WrapModeU = NDalic.IMAGE_VISUAL_WRAP_MODE_U;
 688
 689         /// <summary>
 690         /// The wrap mode for v coordinate.
 691         /// </summary>
 692         /// <since_tizen> 3 </since_tizen>
 693         public static readonly int WrapModeV = NDalic.IMAGE_VISUAL_WRAP_MODE_V;
 694
 695         /// <summary>
 696         /// The border of the image.
 697         /// </summary>
 698         /// <since_tizen> 3 </since_tizen>
 699         public static readonly int Border = NDalic.IMAGE_VISUAL_BORDER;
 700
 701         /// <summary>
 702         /// Whether to use the texture atlas.
 703         /// </summary>
 704         /// <since_tizen> 5 </since_tizen>
 705         public static readonly int Atlasing = NDalic.IMAGE_VISUAL_BORDER + 1;
 706
 707         /// <summary>
 708         /// The URL of the alpha mask image.
 709         /// </summary>
 710         /// <since_tizen> 3 </since_tizen>
 711         public static readonly int AlphaMaskURL = NDalic.IMAGE_VISUAL_ALPHA_MASK_URL;
 712
 713         /// <summary>
 714         /// Defines the batch size for pre-loading images in the AnimatedImageVisual
 715         /// </summary>
 716         /// <since_tizen> 4 </since_tizen>
 717         public static readonly int BatchSize = NDalic.IMAGE_VISUAL_BATCH_SIZE;
 718
 719         /// <summary>
 720         /// Defines the cache size for loading images in the AnimatedImageVisual
 721         /// </summary>
 722         /// <since_tizen> 4 </since_tizen>
 723         public static readonly int CacheSize = NDalic.IMAGE_VISUAL_CACHE_SIZE;
 724
 725         /// <summary>
 726         /// The number of milliseconds between each frame in the AnimatedImageVisual
 727         /// </summary>
 728         /// <since_tizen> 4 </since_tizen>
 729         public static readonly int FrameDelay = NDalic.IMAGE_VISUAL_FRAME_DELAY;
 730
 731         /// <summary>
 732         /// The scale factor to apply to the content image before masking.
 733         /// </summary>
 734         /// <since_tizen> 4 </since_tizen>
 735         public static readonly int MaskContentScale = NDalic.IMAGE_VISUAL_MASK_CONTENT_SCALE;
 736
 737         /// <summary>
 738         /// Whether to crop image to mask or scale mask to fit image
 739         /// </summary>
 740         /// <since_tizen> 4 </since_tizen>
 741         public static readonly int CropToMask = NDalic.IMAGE_VISUAL_CROP_TO_MASK;
 742
 743         /// <summary>
 744         /// The policy to determine when an image should be loaded.
 745         /// </summary>
 746         /// <since_tizen> 5 </since_tizen>
 747         public static readonly int LoadPolicy = NDalic.IMAGE_VISUAL_LOAD_POLICY;
 748
 749         /// <summary>
 750         /// The policy to determine when an image should no longer be cached.
 751         /// </summary>
 752         /// <since_tizen> 5 </since_tizen>
 753         public static readonly int ReleasePolicy = NDalic.IMAGE_VISUAL_RELEASE_POLICY;
 754
 755         /// <summary>
 756         /// Determines if image orientation should be corrected so that the image displays as it was intended.
 757         /// </summary>
 758         /// <since_tizen> 5 </since_tizen>
 759         public static readonly int OrientationCorrection = NDalic.IMAGE_VISUAL_ORIENTATION_CORRECTION;
 760
 761         /// <summary>
 762         /// Overlays the auxiliary image on top of an NPatch image.
 763         /// </summary>
 764         /// <since_tizen> 5 </since_tizen>
 765         public static readonly int AuxiliaryImageURL = NDalic.IMAGE_VISUAL_AUXILIARY_IMAGE_URL;
 766
 767         /// <summary>
 768         /// Alpha value for the auxiliary image, without affecting the underlying NPatch image
 769         /// </summary>
 770         /// <since_tizen> 5 </since_tizen>
 771         public static readonly int AuxiliaryImageAlpha = NDalic.IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA;
 772
 773         /// <summary>
 774         /// The number of times the AnimatedImageVisual will be looped.
 775         /// The default is -1. If the value is less than 0, loop unlimited. Otherwise, loop loopCount times.
 776         /// </summary>
 777         /// <since_tizen> 5 </since_tizen>
 778         public static readonly int LoopCount = NDalic.IMAGE_VISUAL_LOOP_COUNT;
 779
 780         /// <summary>
 781         /// @brief The playing range the AnimatedVectorImageVisual will use.
 782         /// Animation will play between the values specified.The array can only have two values, and more will be ignored.
 783         /// Both values should be between 0 and the total frame number, otherwise they will be ignored.
 784         /// If the range provided is not in proper order (minimum, maximum), it will be reordered.
 785         /// @details Name "playRange", Type Property::ARRAY of Property::INTEGER
 786         /// @note Default 0 and the total frame number.
 787         /// </summary>
 788         /// <remarks>
 789         /// Hidden API (Inhouse API)
 790         /// </remarks>
 791         [EditorBrowsable(EditorBrowsableState.Never)]
 792         public static readonly int PlayRange = NDalic.IMAGE_VISUAL_ORIENTATION_CORRECTION + 4;
 793
 794         /// <summary>
 795         /// @brief The playing state the AnimatedVectorImageVisual will use.
 796         /// @details Name "playState", type PlayState (Property::INTEGER)
 797         /// @note This property is read-only.
 798         /// </summary>
 799         /// <remarks>
 800         /// Hidden API (Inhouse API)
 801         /// </remarks>
 802         [EditorBrowsable(EditorBrowsableState.Never)]
 803         public static readonly int PlayState = NDalic.IMAGE_VISUAL_ORIENTATION_CORRECTION + 5;
 804
 805         /// <summary>
 806         /// @brief The current frame number the AnimatedVectorImageVisual will use.
 807         /// @details Name "currentFrameNumber", Type Property::INTEGER, between[0, the maximum frame number] or between the play range if specified
 808         /// @note This property is read-only.
 809         /// </summary>
 810         /// <remarks>
 811         /// Inhouse API
 812         /// </remarks>
 813         [EditorBrowsable(EditorBrowsableState.Never)]
 814         public static readonly int CurrentFrameNumber = NDalic.IMAGE_VISUAL_ORIENTATION_CORRECTION + 6;
 815
 816         /// <summary>
 817         /// @brief The total frame number the AnimatedVectorImageVisual will use.
 818         /// @details Name "totalFrameNumber", Type Property::INTEGER.
 819         /// @note This property is read-only.
 820         /// </summary>
 821         /// <remarks>
 822         /// Inhouse API
 823         /// </remarks>
 824         [EditorBrowsable(EditorBrowsableState.Never)]
 825         public static readonly int TotalFrameNumber = NDalic.IMAGE_VISUAL_ORIENTATION_CORRECTION + 7;
 826
 827         /// <summary>
 828         /// @brief  The stop behavior the AnimatedVectorImageVisual will use.
 829         /// @details Name "stopBehavior", Type StopBehavior::Type (Property::INTEGER)
 830         /// @note Default value is StopBehavior::CURRENT_FRAME.
 831         /// </summary>
 832         /// <remarks>
 833         /// Inhouse API
 834         /// </remarks>
 835         [EditorBrowsable(EditorBrowsableState.Never)]
 836         public static readonly int StopBehavior = NDalic.IMAGE_VISUAL_ORIENTATION_CORRECTION + 8;
 837
 838         /// <summary>
 839         /// @brief  The looping mode the AnimatedVectorImageVisual will use.
 840         /// @details Name "loopingMode", Type LoopingMode::Type (Property::INTEGER)
 841         /// @note Default value is LoopingMode::RESTART.
 842         /// </summary>
 843         /// <remarks>
 844         /// Inhouse API
 845         /// </remarks>
 846         [EditorBrowsable(EditorBrowsableState.Never)]
 847         public static readonly int LoopingMode = NDalic.IMAGE_VISUAL_ORIENTATION_CORRECTION + 9;
 848
 849         /// <summary>
 850         /// @brief The content information the AnimatedVectorImageVisual will use.
 851         /// @details Name "contentInfo", Type Property::MAP.
 852         /// The map contains the layer name as a key and Property::Array as a value.
 853         /// And the array contains 2 integer values which are the frame numbers, the start frame number and the end frame number of the layer.
 854         /// @note This property is read-only.
 855         /// </summary>
 856         /// <remarks>
 857         /// Inhouse API
 858         /// </remarks>
 859         [EditorBrowsable(EditorBrowsableState.Never)]
 860         public static readonly int ContentInfo = NDalic.IMAGE_VISUAL_ORIENTATION_CORRECTION + 10;
 861     }
 862
 863     /// <summary>
 864     /// This specifies properties of the MeshVisual.
 865     /// </summary>
 866     /// <since_tizen> 3 </since_tizen>
 867     public struct MeshVisualProperty
 868     {
 869         /// <summary>
 870         /// The location of the ".obj" file.
 871         /// </summary>
 872         /// <since_tizen> 3 </since_tizen>
 873         public static readonly int ObjectURL = NDalic.MESH_VISUAL_OBJECT_URL;
 874         /// <summary>
 875         /// The location of the ".mtl" file.
 876         /// </summary>
 877         /// <since_tizen> 3 </since_tizen>
 878         public static readonly int MaterialtURL = NDalic.MESH_VISUAL_MATERIAL_URL;
 879         /// <summary>
 880         /// Path to the directory the textures (including gloss and normal) are stored in.
 881         /// </summary>
 882         /// <since_tizen> 3 </since_tizen>
 883         public static readonly int TexturesPath = NDalic.MESH_VISUAL_TEXTURES_PATH;
 884         /// <summary>
 885         /// Sets the type of shading mode that the mesh will use.
 886         /// </summary>
 887         /// <since_tizen> 3 </since_tizen>
 888         public static readonly int ShadingMode = NDalic.MESH_VISUAL_SHADING_MODE;
 889         /// <summary>
 890         /// Whether to use mipmaps for textures or not.
 891         /// </summary>
 892         /// <since_tizen> 3 </since_tizen>
 893         public static readonly int UseMipmapping = NDalic.MESH_VISUAL_USE_MIPMAPPING;
 894         /// <summary>
 895         /// Whether to average normals at each point to smooth textures or not.
 896         /// </summary>
 897         /// <since_tizen> 3 </since_tizen>
 898         public static readonly int UseSoftNormals = NDalic.MESH_VISUAL_USE_SOFT_NORMALS;
 899         /// <summary>
 900         /// The position, in stage space, of the point light that applies lighting to the model.
 901         /// </summary>
 902         /// <since_tizen> 3 </since_tizen>
 903         public static readonly int LightPosition = NDalic.MESH_VISUAL_LIGHT_POSITION;
 904     }
 905
 906     /// <summary>
 907     /// This specifies properties of the PrimitiveVisual.
 908     /// </summary>
 909     /// <since_tizen> 3 </since_tizen>
 910     public struct PrimitiveVisualProperty
 911     {
 912         /// <summary>
 913         /// The specific shape to render.
 914         /// </summary>
 915         /// <since_tizen> 3 </since_tizen>
 916         public static readonly int Shape = NDalic.PRIMITIVE_VISUAL_SHAPE;
 917         /// <summary>
 918         /// The color of the shape.
 919         /// </summary>
 920         /// <since_tizen> 3 </since_tizen>
 921         public static readonly int MixColor = NDalic.PRIMITIVE_VISUAL_MIX_COLOR;
 922         /// <summary>
 923         /// The number of slices as you go around the shape.
 924         /// </summary>
 925         /// <since_tizen> 3 </since_tizen>
 926         public static readonly int Slices = NDalic.PRIMITIVE_VISUAL_SLICES;
 927         /// <summary>
 928         /// The number of stacks as you go down the shape.
 929         /// </summary>
 930         /// <since_tizen> 3 </since_tizen>
 931         public static readonly int Stacks = NDalic.PRIMITIVE_VISUAL_STACKS;
 932         /// <summary>
 933         /// The scale of the radius of the top circle of a conical frustrum.
 934         /// </summary>
 935         /// <since_tizen> 3 </since_tizen>
 936         public static readonly int ScaleTopRadius = NDalic.PRIMITIVE_VISUAL_SCALE_TOP_RADIUS;
 937         /// <summary>
 938         /// The scale of the radius of the bottom circle of a conical frustrum.
 939         /// </summary>
 940         /// <since_tizen> 3 </since_tizen>
 941         public static readonly int ScaleBottomRadius = NDalic.PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS;
 942         /// <summary>
 943         /// The scale of the height of a conic.
 944         /// </summary>
 945         /// <since_tizen> 3 </since_tizen>
 946         public static readonly int ScaleHeight = NDalic.PRIMITIVE_VISUAL_SCALE_HEIGHT;
 947         /// <summary>
 948         /// The scale of the radius of a cylinder.
 949         /// </summary>
 950         /// <since_tizen> 3 </since_tizen>
 951         public static readonly int ScaleRadius = NDalic.PRIMITIVE_VISUAL_SCALE_RADIUS;
 952         /// <summary>
 953         /// The dimensions of a cuboid. Scales in the same fashion as a 9-patch image.
 954         /// </summary>
 955         /// <since_tizen> 3 </since_tizen>
 956         public static readonly int ScaleDimensions = NDalic.PRIMITIVE_VISUAL_SCALE_DIMENSIONS;
 957         /// <summary>
 958         /// Determines how bevelled the cuboid should be, based off the smallest dimension.
 959         /// </summary>
 960         /// <since_tizen> 3 </since_tizen>
 961         public static readonly int BevelPercentage = NDalic.PRIMITIVE_VISUAL_BEVEL_PERCENTAGE;
 962         /// <summary>
 963         /// Defines how smooth the bevelled edges should be.
 964         /// </summary>
 965         /// <since_tizen> 3 </since_tizen>
 966         public static readonly int BevelSmoothness = NDalic.PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS;
 967         /// <summary>
 968         /// The position, in stage space, of the point light that applies lighting to the model.
 969         /// </summary>
 970         /// <since_tizen> 3 </since_tizen>
 971         public static readonly int LightPosition = NDalic.PRIMITIVE_VISUAL_LIGHT_POSITION;
 972     }
 973
 974     /// <summary>
 975     /// This specifies properties of the TextVisual.
 976     /// </summary>
 977     /// <since_tizen> 3 </since_tizen>
 978     public struct TextVisualProperty
 979     {
 980         /// <summary>
 981         /// The text to display in UTF-8 format.
 982         /// </summary>
 983         /// <since_tizen> 3 </since_tizen>
 984         public static readonly int Text = NDalic.TEXT_VISUAL_TEXT;
 985         /// <summary>
 986         /// The requested font family to use.
 987         /// </summary>
 988         /// <since_tizen> 3 </since_tizen>
 989         public static readonly int FontFamily = NDalic.TEXT_VISUAL_FONT_FAMILY;
 990         /// <summary>
 991         /// The requested font style to use.
 992         /// </summary>
 993         /// <since_tizen> 3 </since_tizen>
 994         public static readonly int FontStyle = NDalic.TEXT_VISUAL_FONT_STYLE;
 995         /// <summary>
 996         /// The size of font in points.
 997         /// </summary>
 998         /// <since_tizen> 3 </since_tizen>
 999         public static readonly int PointSize = NDalic.TEXT_VISUAL_POINT_SIZE;
1000         /// <summary>
1001         /// The single-line or multi-line layout option.
1002         /// </summary>
1003         /// <since_tizen> 3 </since_tizen>
1004         public static readonly int MultiLine = NDalic.TEXT_VISUAL_MULTI_LINE;
1005         /// <summary>
1006         /// The line horizontal alignment.
1007         /// </summary>
1008         /// <since_tizen> 3 </since_tizen>
1009         public static readonly int HorizontalAlignment = NDalic.TEXT_VISUAL_HORIZONTAL_ALIGNMENT;
1010         /// <summary>
1011         /// The line vertical alignment.
1012         /// </summary>
1013         /// <since_tizen> 3 </since_tizen>
1014         public static readonly int VerticalAlignment = NDalic.TEXT_VISUAL_VERTICAL_ALIGNMENT;
1015         /// <summary>
1016         /// The color of the text.
1017         /// </summary>
1018         /// <since_tizen> 3 </since_tizen>
1019         public static readonly int TextColor = NDalic.TEXT_VISUAL_TEXT_COLOR;
1020         /// <summary>
1021         /// Whether the mark-up processing is enabled.
1022         /// </summary>
1023         /// <since_tizen> 3 </since_tizen>
1024         public static readonly int EnableMarkup = NDalic.TEXT_VISUAL_ENABLE_MARKUP;
1025         /// <summary>
1026         /// The shadow parameters.
1027         /// </summary>
1028         /// <since_tizen> 5 </since_tizen>
1029         public static readonly int Shadow = NDalic.TEXT_VISUAL_ENABLE_MARKUP + 1;
1030         /// <summary>
1031         /// The default underline parameters.
1032         /// </summary>
1033         /// <since_tizen> 5 </since_tizen>
1034         public static readonly int Underline = NDalic.TEXT_VISUAL_ENABLE_MARKUP + 2;
1035         /// <summary>
1036         /// The default outline parameters.
1037         /// </summary>
1038         /// <since_tizen> 5 </since_tizen>
1039         public static readonly int Outline = NDalic.TEXT_VISUAL_ENABLE_MARKUP + 3;
1040         /// <summary>
1041         /// The default text background parameters.
1042         /// </summary>
1043         /// <since_tizen> 5 </since_tizen>
1044         public static readonly int Background = NDalic.TEXT_VISUAL_ENABLE_MARKUP + 4;
1045     }
1046
1047     /// <summary>
1048     /// This specifies properties of the NpatchImageVisual.
1049     /// </summary>
1050     /// <since_tizen> 3 </since_tizen>
1051     public struct NpatchImageVisualProperty
1052     {
1053         /// <summary>
1054         /// The URL of the image.
1055         /// </summary>
1056         /// <since_tizen> 3 </since_tizen>
1057         public static readonly int URL = NDalic.IMAGE_VISUAL_URL;
1058         /// <summary>
1059         /// Fitting options, used when resizing images to fit desired dimensions.
1060         /// </summary>
1061         /// <since_tizen> 3 </since_tizen>
1062         public static readonly int FittingMode = NDalic.IMAGE_VISUAL_FITTING_MODE;
1063         /// <summary>
1064         /// Filtering options, used when resizing images to sample original pixels.
1065         /// </summary>
1066         /// <since_tizen> 3 </since_tizen>
1067         public static readonly int SamplingMode = NDalic.IMAGE_VISUAL_SAMPLING_MODE;
1068         /// <summary>
1069         /// The desired image width.
1070         /// </summary>
1071         /// <since_tizen> 3 </since_tizen>
1072         public static readonly int DesiredWidth = NDalic.IMAGE_VISUAL_DESIRED_WIDTH;
1073         /// <summary>
1074         /// The desired image height.
1075         /// </summary>
1076         /// <since_tizen> 3 </since_tizen>
1077         public static readonly int DesiredHeight = NDalic.IMAGE_VISUAL_DESIRED_HEIGHT;
1078         /// <summary>
1079         /// Whether to load the image synchronously.
1080         /// </summary>
1081         /// <since_tizen> 3 </since_tizen>
1082         public static readonly int SynchronousLoading = NDalic.IMAGE_VISUAL_SYNCHRONOUS_LOADING;
1083         /// <summary>
1084         /// If true, only draws the borders.
1085         /// </summary>
1086         /// <since_tizen> 3 </since_tizen>
1087         public static readonly int BorderOnly = NDalic.IMAGE_VISUAL_BORDER_ONLY;
1088         /// <summary>
1089         /// The image area to be displayed.
1090         /// </summary>
1091         /// <since_tizen> 3 </since_tizen>
1092         public static readonly int PixelArea = NDalic.IMAGE_VISUAL_PIXEL_AREA;
1093         /// <summary>
1094         /// The wrap mode for u coordinate.
1095         /// </summary>
1096         /// <since_tizen> 3 </since_tizen>
1097         public static readonly int WrapModeU = NDalic.IMAGE_VISUAL_WRAP_MODE_U;
1098         /// <summary>
1099         /// The wrap mode for v coordinate.
1100         /// </summary>
1101         /// <since_tizen> 3 </since_tizen>
1102         public static readonly int WrapModeV = NDalic.IMAGE_VISUAL_WRAP_MODE_V;
1103         /// <summary>
1104         /// The border of the image.
1105         /// </summary>
1106         /// <since_tizen> 3 </since_tizen>
1107         public static readonly int Border = NDalic.IMAGE_VISUAL_WRAP_MODE_V + 1;
1108     }
1109 }