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