src/Tizen.NUI/src/public/BaseComponents/TextUtils.cs

   1 /*
   2  * Copyright(c) 2020 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
  18 extern alias TizenSystemSettings;
  19 using TizenSystemSettings.Tizen.System;
  20 using System;
  21 using System.ComponentModel;
  22 using System.Collections.Generic;
  23 using Tizen.NUI.Binding;
  24
  25 namespace Tizen.NUI.BaseComponents
  26 {
  27     /// <summary>
  28     /// Class with the text and style parameters to be rendered into a pixel buffer.
  29     /// </summary>
  30     // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
  31     [EditorBrowsable(EditorBrowsableState.Never)]
  32     public class RendererParameters : Disposable
  33     {
  34         internal RendererParameters(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  35         {
  36         }
  37
  38         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(RendererParameters obj)
  39         {
  40             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
  41         }
  42
  43         /// <summary>
  44         /// Dispose
  45         /// </summary>
  46         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
  47         {
  48             Interop.RendererParameters.DeleteRendererParameters(swigCPtr);
  49         }
  50
  51         /// <summary>
  52         /// Construct RendererParameters
  53         /// </summary>
  54         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
  55         [EditorBrowsable(EditorBrowsableState.Never)]
  56         public RendererParameters() : this(Interop.RendererParameters.NewRendererParameters(), true)
  57         {
  58             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  59         }
  60
  61         /// <summary>
  62         /// The text to be rendered
  63         /// </summary>
  64         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
  65         [EditorBrowsable(EditorBrowsableState.Never)]
  66         public string Text
  67         {
  68             set
  69             {
  70                 Interop.RendererParameters.TextSet(SwigCPtr, value);
  71                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  72             }
  73             get
  74             {
  75                 string ret = Interop.RendererParameters.TextGet(SwigCPtr);
  76                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
  77                 return ret;
  78             }
  79         }
  80
  81         /// <summary>
  82         /// The horizontal alignment: one of HorizontalAlignment.
  83         /// </summary>
  84         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
  85         [EditorBrowsable(EditorBrowsableState.Never)]
  86         public HorizontalAlignment HorizontalAlignment
  87         {
  88             set
  89             {
  90                 string alignment = "begin";
  91                 switch (value)
  92                 {
  93                     case HorizontalAlignment.Begin:
  94                         {
  95                             alignment = "begin";
  96                             break;
  97                         }
  98                     case HorizontalAlignment.Center:
  99                         {
 100                             alignment = "center";
 101                             break;
 102                         }
 103                     case HorizontalAlignment.End:
 104                         {
 105                             alignment = "end";
 106                             break;
 107                         }
 108                     default:
 109                         {
 110                             break;
 111                         }
 112                 }
 113                 Interop.RendererParameters.HorizontalAlignmentSet(SwigCPtr, alignment);
 114                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 115             }
 116             get
 117             {
 118                 string ret = Interop.RendererParameters.HorizontalAlignmentGet(SwigCPtr);
 119                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 120                 HorizontalAlignment alignment = HorizontalAlignment.Begin;
 121                 switch (ret)
 122                 {
 123                     case "begin":
 124                         {
 125                             alignment = HorizontalAlignment.Begin;
 126                             break;
 127                         }
 128                     case "center":
 129                         {
 130                             alignment = HorizontalAlignment.Center;
 131                             break;
 132                         }
 133                     case "end":
 134                         {
 135                             alignment = HorizontalAlignment.End;
 136                             break;
 137                         }
 138                     default:
 139                         {
 140                             break;
 141                         }
 142                 }
 143                 return alignment;
 144             }
 145         }
 146
 147         /// <summary>
 148         /// The vertical alignment: one of VerticalAlignment.
 149         /// </summary>
 150         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 151         [EditorBrowsable(EditorBrowsableState.Never)]
 152         public VerticalAlignment VerticalAlignment
 153         {
 154             set
 155             {
 156                 string alignment = "top";
 157                 switch (value)
 158                 {
 159                     case VerticalAlignment.Top:
 160                         {
 161                             alignment = "top";
 162                             break;
 163                         }
 164                     case VerticalAlignment.Center:
 165                         {
 166                             alignment = "center";
 167                             break;
 168                         }
 169                     case VerticalAlignment.Bottom:
 170                         {
 171                             alignment = "bottom";
 172                             break;
 173                         }
 174                     default:
 175                         {
 176                             break;
 177                         }
 178                 }
 179                 Interop.RendererParameters.VerticalAlignmentSet(SwigCPtr, alignment);
 180                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 181             }
 182             get
 183             {
 184                 string ret = Interop.RendererParameters.VerticalAlignmentGet(SwigCPtr);
 185                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 186                 VerticalAlignment alignment = VerticalAlignment.Top;
 187                 switch (ret)
 188                 {
 189                     case "top":
 190                         {
 191                             alignment = VerticalAlignment.Top;
 192                             break;
 193                         }
 194                     case "center":
 195                         {
 196                             alignment = VerticalAlignment.Center;
 197                             break;
 198                         }
 199                     case "bottom":
 200                         {
 201                             alignment = VerticalAlignment.Bottom;
 202                             break;
 203                         }
 204                     default:
 205                         {
 206                             break;
 207                         }
 208                 }
 209                 return alignment;
 210             }
 211         }
 212
 213         /// <summary>
 214         /// The font's family.
 215         /// </summary>
 216         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 217         [EditorBrowsable(EditorBrowsableState.Never)]
 218         public string FontFamily
 219         {
 220             set
 221             {
 222                 Interop.RendererParameters.FontFamilySet(SwigCPtr, value);
 223                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 224             }
 225             get
 226             {
 227                 string ret = Interop.RendererParameters.FontFamilyGet(SwigCPtr);
 228                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 229                 return ret;
 230             }
 231         }
 232
 233         /// <summary>
 234         /// The font's weight: one of {"thin", "ultraLight", "extraLight", "light", "demiLight", "semiLight", "book", "normal", "regular", "medium", "demiBold", "semiBold", "bold", "ultraBold", "extraBold", "black", "heavy", "extraBlack"}.
 235         /// </summary>
 236         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 237         [EditorBrowsable(EditorBrowsableState.Never)]
 238         public string FontWeight
 239         {
 240             set
 241             {
 242                 Interop.RendererParameters.FontWeightSet(SwigCPtr, value);
 243                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 244             }
 245             get
 246             {
 247                 string ret = Interop.RendererParameters.FontWeightGet(SwigCPtr);
 248                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 249                 return ret;
 250             }
 251         }
 252
 253         /// <summary>
 254         /// The font's width: one of {"ultraCondensed", "extraCondensed", "condensed", "semiCondensed", "normal", "semiExpanded", "expanded", "extraExpanded", "ultraExpanded"}.
 255         /// </summary>
 256         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 257         [EditorBrowsable(EditorBrowsableState.Never)]
 258         public string FontWidth
 259         {
 260             set
 261             {
 262                 Interop.RendererParameters.FontWidthSet(SwigCPtr, value);
 263                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 264             }
 265             get
 266             {
 267                 string ret = Interop.RendererParameters.FontWidthGet(SwigCPtr);
 268                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 269                 return ret;
 270             }
 271         }
 272
 273         /// <summary>
 274         /// The font's slant. one of {"normal", "roman", "italic", "oblique"}
 275         /// </summary>
 276         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 277         [EditorBrowsable(EditorBrowsableState.Never)]
 278         public string FontSlant
 279         {
 280             set
 281             {
 282                 Interop.RendererParameters.FontSlantSet(SwigCPtr, value);
 283                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 284             }
 285             get
 286             {
 287                 string ret = Interop.RendererParameters.FontSlantGet(SwigCPtr);
 288                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 289                 return ret;
 290             }
 291         }
 292
 293         /// <summary>
 294         /// The type of layout: one of TextLayout {"singleLine", "multiLine", "circular"}
 295         /// </summary>
 296         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 297         [EditorBrowsable(EditorBrowsableState.Never)]
 298         public TextLayout Layout
 299         {
 300             set
 301             {
 302                 string textLayout = "singleLine";
 303                 switch (value)
 304                 {
 305                     case TextLayout.SingleLine:
 306                         {
 307                             textLayout = "singleLine";
 308                             break;
 309                         }
 310                     case TextLayout.MultiLine:
 311                         {
 312                             textLayout = "multiLine";
 313                             break;
 314                         }
 315                     case TextLayout.Circular:
 316                         {
 317                             textLayout = "circular";
 318                             break;
 319                         }
 320                     default:
 321                         {
 322                             break;
 323                         }
 324                 }
 325                 Interop.RendererParameters.LayoutSet(SwigCPtr, textLayout);
 326                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 327             }
 328             get
 329             {
 330                 string ret = Interop.RendererParameters.LayoutGet(SwigCPtr);
 331                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 332                 TextLayout textLayout = TextLayout.SingleLine;
 333                 switch (ret)
 334                 {
 335                     case "singleLine":
 336                         {
 337                             textLayout = TextLayout.SingleLine;
 338                             break;
 339                         }
 340                     case "multiLine":
 341                         {
 342                             textLayout = TextLayout.MultiLine;
 343                             break;
 344                         }
 345                     case "circular":
 346                         {
 347                             textLayout = TextLayout.Circular;
 348                             break;
 349                         }
 350                     default:
 351                         {
 352                             break;
 353                         }
 354                 }
 355                 return textLayout;
 356             }
 357         }
 358
 359         /// <summary>
 360         /// The text alignment within the arc: one of CircularAlignment. The @p horizontalAlignment and @p verticalAlignment can be used to align the text within the text area.
 361         /// </summary>
 362         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 363         [EditorBrowsable(EditorBrowsableState.Never)]
 364         public CircularAlignment CircularAlignment
 365         {
 366             set
 367             {
 368                 string alignment = "begin";
 369                 switch (value)
 370                 {
 371                     case CircularAlignment.Begin:
 372                         {
 373                             alignment = "begin";
 374                             break;
 375                         }
 376                     case CircularAlignment.Center:
 377                         {
 378                             alignment = "center";
 379                             break;
 380                         }
 381                     case CircularAlignment.End:
 382                         {
 383                             alignment = "end";
 384                             break;
 385                         }
 386                     default:
 387                         {
 388                             break;
 389                         }
 390                 }
 391                 Interop.RendererParameters.CircularAlignmentSet(SwigCPtr, alignment);
 392                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 393             }
 394             get
 395             {
 396                 string ret = Interop.RendererParameters.CircularAlignmentGet(SwigCPtr);
 397                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 398                 CircularAlignment alignment = CircularAlignment.Begin;
 399                 switch (ret)
 400                 {
 401                     case "begin":
 402                         {
 403                             alignment = CircularAlignment.Begin;
 404                             break;
 405                         }
 406                     case "center":
 407                         {
 408                             alignment = CircularAlignment.Center;
 409                             break;
 410                         }
 411                     case "end":
 412                         {
 413                             alignment = CircularAlignment.End;
 414                             break;
 415                         }
 416                     default:
 417                         {
 418                             break;
 419                         }
 420                 }
 421                 return alignment;
 422             }
 423         }
 424
 425         /// <summary>
 426         /// The default text's color. Default is white.
 427         /// </summary>
 428         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 429         [EditorBrowsable(EditorBrowsableState.Never)]
 430         public Vector4 TextColor
 431         {
 432             set
 433             {
 434                 Interop.RendererParameters.TextColorSet(SwigCPtr, Vector4.getCPtr(value));
 435                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 436             }
 437             get
 438             {
 439                 Vector4 ret = new Vector4(Interop.RendererParameters.TextColorGet(SwigCPtr), true);
 440                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 441                 return ret;
 442             }
 443         }
 444
 445         /// <summary>
 446         /// The font's size (in points).
 447         /// </summary>
 448         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 449         [EditorBrowsable(EditorBrowsableState.Never)]
 450         public float FontSize
 451         {
 452             set
 453             {
 454                 Interop.RendererParameters.FontSizeSet(SwigCPtr, value);
 455                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 456             }
 457             get
 458             {
 459                 float ret = Interop.RendererParameters.FontSizeGet(SwigCPtr);
 460                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 461                 return ret;
 462             }
 463         }
 464
 465         /// <summary>
 466         /// The width in pixels of the boundaries where the text is going to be laid-out.
 467         /// </summary>
 468         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 469         [EditorBrowsable(EditorBrowsableState.Never)]
 470         public uint TextWidth
 471         {
 472             set
 473             {
 474                 Interop.RendererParameters.TextWidthSet(SwigCPtr, value);
 475                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 476             }
 477             get
 478             {
 479                 uint ret = Interop.RendererParameters.TextWidthGet(SwigCPtr);
 480                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 481                 return ret;
 482             }
 483         }
 484
 485         /// <summary>
 486         /// The height in pixels of the boundaries where the text is going to be laid-out.
 487         /// </summary>
 488         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 489         [EditorBrowsable(EditorBrowsableState.Never)]
 490         public uint TextHeight
 491         {
 492             set
 493             {
 494                 Interop.RendererParameters.TextHeightSet(SwigCPtr, value);
 495                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 496             }
 497             get
 498             {
 499                 uint ret = Interop.RendererParameters.TextHeightGet(SwigCPtr);
 500                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 501                 return ret;
 502             }
 503         }
 504
 505         /// <summary>
 506         /// The radius in pixels of the circular text.
 507         /// </summary>
 508         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 509         [EditorBrowsable(EditorBrowsableState.Never)]
 510         public uint Radius
 511         {
 512             set
 513             {
 514                 Interop.RendererParameters.RadiusSet(SwigCPtr, value);
 515                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 516             }
 517             get
 518             {
 519                 uint ret = Interop.RendererParameters.RadiusGet(SwigCPtr);
 520                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 521                 return ret;
 522             }
 523         }
 524
 525         /// <summary>
 526         /// The begin angle in degrees of the text area on the circle. The top of the circle is 0°, the right side 90°, the bottom 180° and the left 270°.
 527         /// </summary>
 528         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 529         [EditorBrowsable(EditorBrowsableState.Never)]
 530         public float BeginAngle
 531         {
 532             set
 533             {
 534                 Interop.RendererParameters.BeginAngleSet(SwigCPtr, value);
 535                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 536             }
 537             get
 538             {
 539                 float ret = Interop.RendererParameters.BeginAngleGet(SwigCPtr);
 540                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 541                 return ret;
 542             }
 543         }
 544
 545         /// <summary>
 546         /// The increment angle in degrees of the text area on the circle. The @p incrementAngle defines a direction. If positive, the text will be laid out clockwise.
 547         /// </summary>
 548         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 549         [EditorBrowsable(EditorBrowsableState.Never)]
 550         public float IncrementAngle
 551         {
 552             set
 553             {
 554                 Interop.RendererParameters.IncrementAngleSet(SwigCPtr, value);
 555                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 556             }
 557             get
 558             {
 559                 float ret = Interop.RendererParameters.IncrementAngleGet(SwigCPtr);
 560                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 561                 return ret;
 562             }
 563         }
 564
 565         /// <summary>
 566         /// Whether the ellipsis layout option is enabled.
 567         /// </summary>
 568         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 569         [EditorBrowsable(EditorBrowsableState.Never)]
 570         public bool EllipsisEnabled
 571         {
 572             set
 573             {
 574                 Interop.RendererParameters.EllipsisEnabledSet(SwigCPtr, value);
 575                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 576             }
 577             get
 578             {
 579                 bool ret = Interop.RendererParameters.EllipsisEnabledGet(SwigCPtr);
 580                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 581                 return ret;
 582             }
 583         }
 584
 585         /// <summary>
 586         /// Whether the mark-up processor is enabled.
 587         /// </summary>
 588         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 589         [EditorBrowsable(EditorBrowsableState.Never)]
 590         public bool MarkupEnabled
 591         {
 592             set
 593             {
 594                 Interop.RendererParameters.MarkupEnabledSet(SwigCPtr, value);
 595                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 596             }
 597             get
 598             {
 599                 bool ret = Interop.RendererParameters.MarkupEnabledGet(SwigCPtr);
 600                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 601                 return ret;
 602             }
 603         }
 604
 605         /// <summary>
 606         /// Whether a default color has been set.
 607         /// </summary>
 608         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 609         [EditorBrowsable(EditorBrowsableState.Never)]
 610         public bool IsTextColorSet
 611         {
 612             set
 613             {
 614                 Interop.RendererParameters.IsTextColorSetSet(SwigCPtr, value);
 615                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 616             }
 617             get
 618             {
 619                 bool ret = Interop.RendererParameters.IsTextColorSetGet(SwigCPtr);
 620                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 621                 return ret;
 622             }
 623         }
 624
 625         /// <summary>
 626         /// Minimum size of line.
 627         /// </summary>
 628         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 629         [EditorBrowsable(EditorBrowsableState.Never)]
 630         public float MinLineSize
 631         {
 632             set
 633             {
 634                 Interop.RendererParameters.MinLineSizeSet(SwigCPtr, value);
 635                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 636             }
 637             get
 638             {
 639                 float ret = Interop.RendererParameters.MinLineSizeGet(SwigCPtr);
 640                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 641                 return ret;
 642             }
 643         }
 644
 645         /// <summary>
 646         /// Padding of TextLabel.
 647         /// </summary>
 648         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 649         [EditorBrowsable(EditorBrowsableState.Never)]
 650         public Extents Padding
 651         {
 652             set
 653             {
 654                 Interop.RendererParameters.PaddingSet(SwigCPtr, Extents.getCPtr(value));
 655                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 656             }
 657             get
 658             {
 659                 Extents ret = new Extents(Interop.RendererParameters.PaddingGet(SwigCPtr), true);
 660                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 661                 return ret;
 662             }
 663         }
 664
 665     }
 666
 667     /// <summary>
 668     /// Class with info of the embedded items layout.
 669     /// </summary>
 670     // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 671     [EditorBrowsable(EditorBrowsableState.Never)]
 672     public class EmbeddedItemInfo : Disposable
 673     {
 674
 675         internal EmbeddedItemInfo(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
 676         {
 677         }
 678
 679         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmbeddedItemInfo obj)
 680         {
 681             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
 682         }
 683
 684         /// <summary>
 685         /// Dispose
 686         /// </summary>
 687         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
 688         {
 689             Interop.EmbeddedItemInfo.DeleteEmbeddedItemInfo(swigCPtr);
 690         }
 691
 692         /// <summary>
 693         /// Construct EmbeddedItemInfo
 694         /// </summary>
 695         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 696         [EditorBrowsable(EditorBrowsableState.Never)]
 697         public EmbeddedItemInfo() : this(Interop.EmbeddedItemInfo.NewEmbeddedItemInfo(), true)
 698         {
 699             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 700         }
 701
 702         /// <summary>
 703         /// Index to the character within the string.
 704         /// </summary>
 705         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 706         [EditorBrowsable(EditorBrowsableState.Never)]
 707         public uint CharacterIndex
 708         {
 709             set
 710             {
 711                 Interop.EmbeddedItemInfo.CharacterIndexSet(SwigCPtr, value);
 712                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 713             }
 714             get
 715             {
 716                 uint ret = Interop.EmbeddedItemInfo.CharacterIndexGet(SwigCPtr);
 717                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 718                 return ret;
 719             }
 720         }
 721
 722         /// <summary>
 723         /// Index to the glyph
 724         /// </summary>
 725         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 726         [EditorBrowsable(EditorBrowsableState.Never)]
 727         public uint GlyphIndex
 728         {
 729             set
 730             {
 731                 Interop.EmbeddedItemInfo.GlyphIndexSet(SwigCPtr, value);
 732                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 733             }
 734             get
 735             {
 736                 uint ret = Interop.EmbeddedItemInfo.GlyphIndexGet(SwigCPtr);
 737                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 738                 return ret;
 739             }
 740         }
 741
 742         /// <summary>
 743         /// The layout position within the buffer (top, left corner).
 744         /// </summary>
 745         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 746         [EditorBrowsable(EditorBrowsableState.Never)]
 747         public Vector2 Position
 748         {
 749             set
 750             {
 751                 Interop.EmbeddedItemInfo.PositionSet(SwigCPtr, Vector2.getCPtr(value));
 752                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 753             }
 754             get
 755             {
 756                 Vector2 ret = new Vector2(Interop.EmbeddedItemInfo.PositionGet(SwigCPtr), SwigCMemOwn);
 757                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 758                 return ret;
 759             }
 760         }
 761
 762         /// <summary>
 763         /// The size within the buffer of the embedded item.
 764         /// </summary>
 765         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 766         [EditorBrowsable(EditorBrowsableState.Never)]
 767         public Size Size
 768         {
 769             set
 770             {
 771                 Interop.EmbeddedItemInfo.SizeSet(SwigCPtr, Size.getCPtr(value));
 772                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 773             }
 774             get
 775             {
 776                 Size ret = new Size(Interop.EmbeddedItemInfo.SizeGet(SwigCPtr), SwigCMemOwn);
 777                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 778                 return ret;
 779             }
 780         }
 781
 782         /// <summary>
 783         /// The rotated size within the buffer of the embedded item.
 784         /// </summary>
 785         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 786         [EditorBrowsable(EditorBrowsableState.Never)]
 787         public Size RotatedSize
 788         {
 789             set
 790             {
 791                 Interop.EmbeddedItemInfo.RotatedSizeSet(SwigCPtr, Size.getCPtr(value));
 792                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 793             }
 794             get
 795             {
 796                 Size ret = new Size(Interop.EmbeddedItemInfo.RotatedSizeGet(SwigCPtr), SwigCMemOwn);
 797                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 798                 return ret;
 799             }
 800         }
 801
 802         /// <summary>
 803         /// Rotation angle of the pixel buffer in degrees.
 804         /// </summary>
 805         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 806         [EditorBrowsable(EditorBrowsableState.Never)]
 807         public Degree Angle
 808         {
 809             set
 810             {
 811                 Interop.EmbeddedItemInfo.AngleSet(SwigCPtr, Degree.getCPtr(value));
 812                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 813             }
 814             get
 815             {
 816                 Degree ret = new Degree(Interop.EmbeddedItemInfo.AngleGet(SwigCPtr), SwigCMemOwn);
 817                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 818                 return ret;
 819             }
 820         }
 821
 822         /// <summary>
 823         /// Whether the color of the image is multiplied by the color of the text.
 824         /// </summary>
 825         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 826         [EditorBrowsable(EditorBrowsableState.Never)]
 827         public Tizen.NUI.ColorBlendingMode ColorBlendingMode
 828         {
 829             set
 830             {
 831                 Interop.EmbeddedItemInfo.ColorBlendingModeSet(SwigCPtr, value);
 832                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 833             }
 834             get
 835             {
 836                 Tizen.NUI.ColorBlendingMode ret = Interop.EmbeddedItemInfo.ColorBlendingModeGet(SwigCPtr);
 837                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 838                 return ret;
 839             }
 840         }
 841     }
 842
 843     /// <summary>
 844     /// Class with the parameters needed to build a shadow for the given pixel buffer.
 845     /// </summary>
 846     // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 847     [EditorBrowsable(EditorBrowsableState.Never)]
 848     public class ShadowParameters : Disposable
 849     {
 850
 851         internal ShadowParameters(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
 852         {
 853         }
 854
 855         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ShadowParameters obj)
 856         {
 857             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
 858         }
 859
 860         /// <summary>
 861         /// Dispose
 862         /// </summary>
 863         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
 864         {
 865             Interop.ShadowParameters.DeleteShadowParameters(swigCPtr);
 866         }
 867
 868         /// <summary>
 869         /// Construct ShadowParameters
 870         /// </summary>
 871         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 872         [EditorBrowsable(EditorBrowsableState.Never)]
 873         public ShadowParameters() : this(Interop.ShadowParameters.NewShadowParameters(), true)
 874         {
 875             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 876         }
 877
 878         /// <summary>
 879         /// The input pixel buffer used to create the shadow.
 880         /// </summary>
 881         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 882         [EditorBrowsable(EditorBrowsableState.Never)]
 883         public PixelBuffer Input
 884         {
 885             set
 886             {
 887                 Interop.ShadowParameters.InputSet(SwigCPtr, PixelBuffer.getCPtr(value));
 888                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 889             }
 890             get
 891             {
 892                 PixelBuffer ret = new PixelBuffer(Interop.ShadowParameters.InputGet(SwigCPtr), true);
 893                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 894                 return ret;
 895             }
 896         }
 897
 898         /// <summary>
 899         /// The color of the text.
 900         /// </summary>
 901         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 902         [EditorBrowsable(EditorBrowsableState.Never)]
 903         public Vector4 TextColor
 904         {
 905             set
 906             {
 907                 Interop.ShadowParameters.TextColorSet(SwigCPtr, Vector4.getCPtr(value));
 908                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 909             }
 910             get
 911             {
 912                 Vector4 ret = new Vector4(Interop.ShadowParameters.TextColorGet(SwigCPtr), true);
 913                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 914                 return ret;
 915             }
 916         }
 917
 918         /// <summary>
 919         /// The color of the shadow.
 920         /// </summary>
 921         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 922         [EditorBrowsable(EditorBrowsableState.Never)]
 923         public Vector4 Color
 924         {
 925             set
 926             {
 927                 Interop.ShadowParameters.ColorSet(SwigCPtr, Vector4.getCPtr(value));
 928                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 929             }
 930             get
 931             {
 932                 Vector4 ret = new Vector4(Interop.ShadowParameters.ColorGet(SwigCPtr), true);
 933                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 934                 return ret;
 935             }
 936         }
 937
 938         /// <summary>
 939         /// The offset of the shadow.
 940         /// </summary>
 941         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 942         [EditorBrowsable(EditorBrowsableState.Never)]
 943         public Vector2 Offset
 944         {
 945             set
 946             {
 947                 Interop.ShadowParameters.OffsetSet(SwigCPtr, Vector2.getCPtr(value));
 948                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 949             }
 950             get
 951             {
 952                 Vector2 ret = new Vector2(Interop.ShadowParameters.OffsetGet(SwigCPtr), true);
 953                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 954                 return ret;
 955             }
 956         }
 957
 958         /// <summary>
 959         /// Whether to blend the shadow.
 960         /// </summary>
 961         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 962         [EditorBrowsable(EditorBrowsableState.Never)]
 963         public bool blendShadow
 964         {
 965             set
 966             {
 967                 Interop.ShadowParameters.BlendShadowSet(SwigCPtr, value);
 968                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 969             }
 970             get
 971             {
 972                 bool ret = Interop.ShadowParameters.BlendShadowGet(SwigCPtr);
 973                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 974                 return ret;
 975             }
 976         }
 977     }
 978
 979     /// <summary>
 980     /// </summary>
 981     // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
 982     [EditorBrowsable(EditorBrowsableState.Never)]
 983     public static partial class TextUtils
 984     {
 985         /// <summary>
 986         /// Renders text into a pixel buffer.
 987         /// @note: Can process a mark-up string.
 988         /// @note: It does the font selection, RTL reordering, shaping and layouting.
 989         /// @note: The width of the pixel buffer may be different to the given @e textWidth
 990         ///        due to some padding pixels added.
 991         ///
 992         ///  The text is laid-out for the given size @e (textWidth,textHeight).
 993         ///  If the @e multiLineEnabled option is enabled, the text will wrap in lines.
 994         ///  If the @e ellipsisEnabled option is enabled, the text will be ellided if
 995         ///  there is no more space for new lines.
 996         ///
 997         ///  It won't be rendered the parts of the text exceeding the boundaries of
 998         ///  the given width and height.
 999         ///
1000         ///  If the given @e textHeight is zero, a big enough pixel buffer will be created
1001         ///  to render the full text.
1002         ///
1003         ///  If the given @e textWidth is zero, the 'natural size' of the text will be
1004         ///  used to create the pixel buffer to render the full text.
1005         ///
1006         ///  If the radius is not zero, the text will be laid-out following a circular path.
1007         ///  In that case the text is laid-out in a single line.
1008         ///
1009         /// If the mark-up string contains embedded items, the @p embeddedItemLayout vector
1010         /// contains the layout info of each embedded item.
1011         /// </summary>
1012         /// <param name="textParameters">The text and style options.</param>
1013         /// <param name="embeddedItemLayout">The layout info of the embedded items</param>
1014         /// <returns>A pixel buffer with the text rendered on it.</returns>
1015         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
1016         [EditorBrowsable(EditorBrowsableState.Never)]
1017         public static PixelBuffer Render(RendererParameters textParameters, ref EmbeddedItemInfo[] embeddedItemLayout)
1018         {
1019             int count = 0;
1020             int length = 0;
1021             global::System.IntPtr returnItem = IntPtr.Zero;
1022             PixelBuffer ret = new PixelBuffer(Interop.TextUtils.Render(RendererParameters.getCPtr(textParameters), ref returnItem, ref count, ref length), true);
1023
1024             embeddedItemLayout = new EmbeddedItemInfo[count];
1025             for (int i = 0; i < count; i++)
1026             {
1027                 IntPtr p = new IntPtr((returnItem.ToInt32() + i * length));
1028                 embeddedItemLayout[i] = new EmbeddedItemInfo(p, false);
1029             }
1030             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1031             return ret;
1032         }
1033
1034         /// <summary>
1035         /// Creates a shadow for the text given in the input pixel buffer.
1036         /// The function returns a RGBA8888 pixel buffer with the text and its shadow rendered on it.
1037         ///
1038         /// The pixel format of the @e input pixel buffer could be an A8 or an RGBA8888. If it's
1039         /// an A8 pixel buffer, it uses the given @e textColor to give color to the text. Otherwise
1040         /// it uses the color of the @e input pixel buffer.
1041         /// </summary>
1042         /// <param name="shadowParameters">The parameters needed to create the text's shadow.</param>
1043         /// <returns>A pixel buffer with the text and the shadow rendered on it.</returns>
1044         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
1045         [EditorBrowsable(EditorBrowsableState.Never)]
1046         public static PixelBuffer CreateShadow(ShadowParameters shadowParameters)
1047         {
1048             PixelBuffer ret = new PixelBuffer(Interop.TextUtils.CreateShadow(ShadowParameters.getCPtr(shadowParameters)), true);
1049             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1050             return ret;
1051         }
1052
1053         /// <summary>
1054         /// Converts a @p pixelBuffer with pixel format A8 to RGBA8888 using the given @p color.
1055         /// @note Does nothing if the @p pixelBuffer is not A8.
1056         /// </summary>
1057         /// <param name="pixelBuffer">The pixel buffer with pixel format A8</param>
1058         /// <param name="color">The color used to convert to RGBA8888</param>
1059         /// <param name="multiplyByAlpha">multiplyByAlpha Whether to multiply the @p color with the alpha value of the @p pixel @p buffer.</param>
1060         /// <returns>The pixel buffer converted to RGBA8888.</returns>
1061         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
1062         [EditorBrowsable(EditorBrowsableState.Never)]
1063         public static PixelBuffer ConvertToRgba8888(PixelBuffer pixelBuffer, Vector4 color, bool multiplyByAlpha)
1064         {
1065             PixelBuffer ret = new PixelBuffer(Interop.TextUtils.ConvertToRgba8888(PixelBuffer.getCPtr(pixelBuffer), Vector4.getCPtr(color), multiplyByAlpha), true);
1066             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1067             return ret;
1068         }
1069
1070         /// <summary>
1071         /// Updates the @p dst pixel buffer with the data from @p src pixel buffer.
1072         /// @note Both pixel buffers must have the same pixel format. Does nothing if both pixel format are different.
1073         /// @note The function does nothing if the @p src pixel buffer doesn't fit into the @p dst pixel buffer.
1074         ///
1075         /// The @p src pixel buffer could be blended with the @p dst pixel buffer if @p blend is set to @e true.
1076         /// </summary>
1077         /// <param name="src">The pixel buffer from where the data is read.</param>
1078         /// <param name="dst">The pixel buffer where the data is written.</param>
1079         /// <param name="x">The top left corner's X within the destination pixel buffer.</param>
1080         /// <param name="y">The top left corner's y within the destination pixel buffer.</param>
1081         /// <param name="blend">Whether to blend the source pixel buffer with the destination pixel buffer as background.</param>
1082         // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
1083         [EditorBrowsable(EditorBrowsableState.Never)]
1084         public static void UpdateBuffer(PixelBuffer src, PixelBuffer dst, uint x, uint y, bool blend)
1085         {
1086             Interop.TextUtils.UpdateBuffer(PixelBuffer.getCPtr(src), PixelBuffer.getCPtr(dst), x, y, blend);
1087             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1088         }
1089
1090         /// <summary>
1091         /// Splits the text in pages of the size given in @p textParameters
1092         /// @note The returned indices are indices to utf32 characters. The input text is encoded in utf8.
1093         /// <returns> An array with the indices of the last character of each page </returns>
1094         /// </summary>
1095         [EditorBrowsable(EditorBrowsableState.Never)]
1096         public static Tizen.NUI.PropertyArray GetLastCharacterIndex(RendererParameters textParameters)
1097         {
1098             Tizen.NUI.PropertyArray ret = new Tizen.NUI.PropertyArray(Interop.TextUtils.GetLastCharacterIndex(RendererParameters.getCPtr(textParameters)), true);
1099             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1100             return ret;
1101         }
1102
1103 #if PROFILE_TV
1104         private const float FontSizeScaleSmall = 0.8f;
1105         private const float FontSizeScaleNormal = 1.0f;
1106         private const float FontSizeScaleLarge = 1.5f;
1107         private const float FontSizeScaleHuge = 1.9f;
1108         private const float FontSizeScaleGiant = 2.5f;
1109 #elif PROFILE_WEARABLE
1110         // The following values from 'system-settings/libutil/sstu.c'
1111         private const float FontSizeScaleSmall = 0.9f;
1112         private const float FontSizeScaleNormal = 1.0f;
1113         private const float FontSizeScaleLarge = 1.1f;
1114         private const float FontSizeScaleHuge = 1.9f;
1115         private const float FontSizeScaleGiant = 2.5f;
1116 #else   // PROFILE_MOBILE and etc
1117         // The following values from 'system-settings/libutil/sstu.c'
1118         private const float FontSizeScaleSmall = 0.8f;
1119         private const float FontSizeScaleNormal = 1.0f;
1120         private const float FontSizeScaleLarge = 1.5f;
1121         private const float FontSizeScaleHuge = 1.9f;
1122         private const float FontSizeScaleGiant = 2.5f;
1123 #endif
1124
1125         /// <summary>
1126         /// It returns a float value according to SystemSettingsFontSize.
1127         /// The returned value can be used for FontSizeScale property.
1128         /// <param name="systemSettingsFontSize">The SystemSettingsFontSize enum value.</param>
1129         /// <returns> A float value for FontSizeScale property. </returns>
1130         /// </summary>
1131         [EditorBrowsable(EditorBrowsableState.Never)]
1132         public static float GetFontSizeScale(SystemSettingsFontSize systemSettingsFontSize) {
1133             float ret = FontSizeScaleNormal;
1134
1135             switch (systemSettingsFontSize) {
1136                 case SystemSettingsFontSize.Small:
1137                     ret = FontSizeScaleSmall;
1138                     break;
1139                 case SystemSettingsFontSize.Normal:
1140                     ret = FontSizeScaleNormal;
1141                     break;
1142                 case SystemSettingsFontSize.Large:
1143                     ret = FontSizeScaleLarge;
1144                     break;
1145                 case SystemSettingsFontSize.Huge:
1146                     ret = FontSizeScaleHuge;
1147                     break;
1148                 case SystemSettingsFontSize.Giant:
1149                     ret = FontSizeScaleGiant;
1150                     break;
1151             }
1152
1153             return ret;
1154         }
1155     }
1156 }