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.Text.RegularExpressions;
  23 using Tizen.NUI.Text;
  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         {
1134             float ret = FontSizeScaleNormal;
1135
1136             switch (systemSettingsFontSize)
1137             {
1138                 case SystemSettingsFontSize.Small:
1139                     ret = FontSizeScaleSmall;
1140                     break;
1141                 case SystemSettingsFontSize.Normal:
1142                     ret = FontSizeScaleNormal;
1143                     break;
1144                 case SystemSettingsFontSize.Large:
1145                     ret = FontSizeScaleLarge;
1146                     break;
1147                 case SystemSettingsFontSize.Huge:
1148                     ret = FontSizeScaleHuge;
1149                     break;
1150                 case SystemSettingsFontSize.Giant:
1151                     ret = FontSizeScaleGiant;
1152                     break;
1153             }
1154
1155             return ret;
1156         }
1157
1158         /// <summary>
1159         /// It returns a string value according to FontWidthType.
1160         /// The returned value can be used for FontStyle PropertyMap.
1161         /// <param name="fontWidthType">The FontWidthType enum value.</param>
1162         /// <returns> A string value for FontStyle.Width property. </returns>
1163         /// </summary>
1164         [EditorBrowsable(EditorBrowsableState.Never)]
1165         public static string GetFontWidthString(FontWidthType fontWidthType)
1166         {
1167             string value = fontWidthType.ToString();
1168             if (!string.IsNullOrEmpty(value))
1169             {
1170                 char[] charArray = value.ToCharArray();
1171                 charArray[0] = Char.ToLower(charArray[0]);
1172                 value = new string(charArray);
1173             }
1174             else
1175             {
1176                 value = "none"; // The default value.
1177             }
1178
1179             return value;
1180         }
1181
1182         /// <summary>
1183         /// It returns a string value according to FontWeightType.
1184         /// The returned value can be used for FontStyle PropertyMap.
1185         /// <param name="fontWeightType">The FontWeightType enum value.</param>
1186         /// <returns> A string value for FontStyle.Weight property. </returns>
1187         /// </summary>
1188         [EditorBrowsable(EditorBrowsableState.Never)]
1189         public static string GetFontWeightString(FontWeightType fontWeightType)
1190         {
1191             string value = fontWeightType.ToString();
1192             if (!string.IsNullOrEmpty(value))
1193             {
1194                 char[] charArray = value.ToCharArray();
1195                 charArray[0] = Char.ToLower(charArray[0]);
1196                 value = new string(charArray);
1197             }
1198             else
1199             {
1200                 value = "none"; // The default value.
1201             }
1202
1203             return value;
1204         }
1205
1206         /// <summary>
1207         /// It returns a string value according to FontSlantType.
1208         /// The returned value can be used for FontStyle PropertyMap.
1209         /// <param name="fontSlantType">The FontSlantType enum value.</param>
1210         /// <returns> A string value for FontStyle.Slant property. </returns>
1211         /// </summary>
1212         [EditorBrowsable(EditorBrowsableState.Never)]
1213         public static string GetFontSlantString(FontSlantType fontSlantType)
1214         {
1215             string value = fontSlantType.ToString();
1216             if (!string.IsNullOrEmpty(value))
1217             {
1218                 char[] charArray = value.ToCharArray();
1219                 charArray[0] = Char.ToLower(charArray[0]);
1220                 value = new string(charArray);
1221             }
1222             else
1223             {
1224                 value = "none"; // The default value.
1225             }
1226
1227             return value;
1228         }
1229
1230         /// <summary>
1231         /// It returns a FontWidthType value according to fontWidthString.
1232         /// The returned value can be used for FontStyle PropertyMap.
1233         /// <param name="fontWidthString">The FontWidth string value.</param>
1234         /// <returns> A FontWidthType value for FontStyle.Width property. </returns>
1235         /// </summary>
1236         [EditorBrowsable(EditorBrowsableState.Never)]
1237         public static FontWidthType GetFontWidthType(string fontWidthString)
1238         {
1239             FontWidthType value;
1240
1241             if (!(Enum.TryParse(fontWidthString, true, out value) && Enum.IsDefined(typeof(FontWidthType), value)))
1242             {
1243                 value = FontWidthType.None; // If parsing fails, set a default value.
1244             }
1245
1246             return value;
1247         }
1248
1249         /// <summary>
1250         /// It returns a FontWeightType value according to fontWeightString.
1251         /// The returned value can be used for FontStyle PropertyMap.
1252         /// <param name="fontWeightString">The FontWeight string value.</param>
1253         /// <returns> A FontWeightType value for FontStyle.Weight property. </returns>
1254         /// </summary>
1255         [EditorBrowsable(EditorBrowsableState.Never)]
1256         public static FontWeightType GetFontWeightType(string fontWeightString)
1257         {
1258             FontWeightType value;
1259
1260             if (!(Enum.TryParse(fontWeightString, true, out value) && Enum.IsDefined(typeof(FontWeightType), value)))
1261             {
1262                 value = FontWeightType.None; // If parsing fails, set a default value.
1263             }
1264
1265             return value;
1266         }
1267
1268         /// <summary>
1269         /// It returns a FontSlantType value according to fontSlantString.
1270         /// The returned value can be used for FontStyle PropertyMap.
1271         /// <param name="fontSlantString">The FontSlant string value.</param>
1272         /// <returns> A FontSlantType value for FontStyle.Slant property. </returns>
1273         /// </summary>
1274         [EditorBrowsable(EditorBrowsableState.Never)]
1275         public static FontSlantType GetFontSlantType(string fontSlantString)
1276         {
1277             FontSlantType value;
1278
1279             if (!(Enum.TryParse(fontSlantString, true, out value) && Enum.IsDefined(typeof(FontSlantType), value)))
1280             {
1281                 value = FontSlantType.None; // If parsing fails, set a default value.
1282             }
1283
1284             return value;
1285         }
1286
1287         /// <summary>
1288         /// This method converts a FontStyle struct to a PropertyMap and returns it.
1289         /// The returned map can be used for set FontStyle PropertyMap in the SetFontStyle method.
1290         /// <param name="fontStyle">The FontStyle struct value.</param>
1291         /// <returns> A PropertyMap for FontStyle property. </returns>
1292         /// </summary>
1293         [EditorBrowsable(EditorBrowsableState.Never)]
1294         public static PropertyMap GetFontStyleMap(FontStyle fontStyle)
1295         {
1296             var map = new PropertyMap();
1297             var width = new PropertyValue(GetFontWidthString(fontStyle.Width));
1298             var weight = new PropertyValue(GetFontWeightString(fontStyle.Weight));
1299             var slant = new PropertyValue(GetFontSlantString(fontStyle.Slant));
1300
1301             map.Add("width", width);
1302             map.Add("weight", weight);
1303             map.Add("slant", slant);
1304
1305             return map;
1306         }
1307
1308         /// <summary>
1309         /// This method converts a FontStyle map to a struct and returns it.
1310         /// The returned struct can be returned to the user as a FontStyle in the GetFontStyle method.
1311         /// <param name="map">The FontStyle PropertyMap.</param>
1312         /// <returns> A FontStyle struct. </returns>
1313         /// </summary>
1314         [EditorBrowsable(EditorBrowsableState.Never)]
1315         public static FontStyle GetFontStyleStruct(PropertyMap map)
1316         {
1317             string width = "none";
1318             string weight = "none";
1319             string slant = "none";
1320             map.Find(0, "width")?.Get(out width);
1321             map.Find(0, "weight")?.Get(out weight);
1322             map.Find(0, "slant")?.Get(out slant);
1323
1324             var fontStyle = new FontStyle();
1325             fontStyle.Width = GetFontWidthType(width);
1326             fontStyle.Weight = GetFontWeightType(weight);
1327             fontStyle.Slant = GetFontSlantType(slant);
1328
1329             return fontStyle;
1330         }
1331
1332         /// <summary>
1333         /// This method converts a InputFilter struct to a PropertyMap and returns it.
1334         /// The returned map can be used for set InputFilter PropertyMap in the SetInputFilter method.
1335         /// <param name="inputFilter">The InputFilter struct value.</param>
1336         /// <returns> A PropertyMap for InputFilter property. </returns>
1337         /// </summary>
1338         [EditorBrowsable(EditorBrowsableState.Never)]
1339         public static PropertyMap GetInputFilterMap(InputFilter inputFilter)
1340         {
1341             var map = new PropertyMap();
1342             var accepted = inputFilter.Accepted != null ? new PropertyValue(inputFilter.Accepted.ToString()) : new PropertyValue("");
1343             var rejected = inputFilter.Rejected != null ? new PropertyValue(inputFilter.Rejected.ToString()) : new PropertyValue("");
1344             map.Add(0, accepted);
1345             map.Add(1, rejected);
1346
1347             return map;
1348         }
1349
1350         /// <summary>
1351         /// This method converts a InputFilter map to a struct and returns it.
1352         /// The returned struct can be returned to the user as a InputFilter in the GetInputFilter method.
1353         /// <param name="map">The InputFilter PropertyMap.</param>
1354         /// <returns> A InputFilter struct. </returns>
1355         /// </summary>
1356         [EditorBrowsable(EditorBrowsableState.Never)]
1357         public static InputFilter GetInputFilterStruct(PropertyMap map)
1358         {
1359             string accepted = "";
1360             string rejected = "";
1361             map.Find(0)?.Get(out accepted);
1362             map.Find(1)?.Get(out rejected);
1363
1364             var inputFilter = new InputFilter();
1365             inputFilter.Accepted = new Regex(accepted);
1366             inputFilter.Rejected = new Regex(rejected);
1367
1368             return inputFilter;
1369
1370         }
1371
1372         /// <summary>
1373         /// This method converts a Underline struct to a PropertyMap and returns it.
1374         /// The returned map can be used for set Underline PropertyMap in the SetUnderline method.
1375         /// <param name="underline">The Underline struct value.</param>
1376         /// <returns> A PropertyMap for Underline property. </returns>
1377         /// </summary>
1378         [EditorBrowsable(EditorBrowsableState.Never)]
1379         public static PropertyMap GetUnderlineMap(Underline underline)
1380         {
1381             var map = new PropertyMap();
1382
1383             if (underline.Color != null)
1384                 map.Add("color", new PropertyValue(underline.Color));
1385
1386             map.Add("enable", new PropertyValue(underline.Enable));
1387             map.Add("height", new PropertyValue(underline.Height));
1388
1389             return map;
1390         }
1391
1392         /// <summary>
1393         /// This method converts a Underline map to a struct and returns it.
1394         /// The returned struct can be returned to the user as a Underline in the GetUnderline method.
1395         /// <param name="map">The Underline PropertyMap.</param>
1396         /// <returns> A Underline struct. </returns>
1397         /// </summary>
1398         [EditorBrowsable(EditorBrowsableState.Never)]
1399         public static Underline GetUnderlineStruct(PropertyMap map)
1400         {
1401             Color color = new Color();
1402             map.Find(0, "enable").Get(out bool enable);
1403             map.Find(0, "color").Get(color);
1404             map.Find(0, "height").Get(out float height);
1405
1406             var underline = new Underline();
1407             underline.Enable = enable;
1408             underline.Color = color;
1409             underline.Height = height;
1410
1411             return underline;
1412         }
1413
1414         /// <summary>
1415         /// This method converts a Shadow struct to a PropertyMap and returns it.
1416         /// The returned map can be used for set Shadow PropertyMap in the SetShadow method.
1417         /// <param name="shadow">The Shadow struct value.</param>
1418         /// <returns> A PropertyMap for Shadow property. </returns>
1419         /// </summary>
1420         [EditorBrowsable(EditorBrowsableState.Never)]
1421         public static PropertyMap GetShadowMap(Tizen.NUI.Text.Shadow shadow)
1422         {
1423             var map = new PropertyMap();
1424
1425             if (shadow.Offset != null)
1426                 map.Add("offset", new PropertyValue(shadow.Offset));
1427
1428             if (shadow.Color != null)
1429                 map.Add("color", new PropertyValue(shadow.Color));
1430
1431             map.Add("blurRadius", new PropertyValue(shadow.BlurRadius));
1432
1433             return map;
1434         }
1435
1436         /// <summary>
1437         /// This method converts a Shadow map to a struct and returns it.
1438         /// The returned struct can be returned to the user as a Shadow in the GetShadow method.
1439         /// <param name="map">The Shadow PropertyMap.</param>
1440         /// <returns> A Shadow struct. </returns>
1441         /// </summary>
1442         [EditorBrowsable(EditorBrowsableState.Never)]
1443         public static Tizen.NUI.Text.Shadow GetShadowStruct(PropertyMap map)
1444         {
1445             Vector2 offset = new Vector2();
1446             Color color = new Color();
1447             map.Find(0, "offset").Get(offset);
1448             map.Find(0, "color").Get(color);
1449             map.Find(0, "blurRadius").Get(out float blurRadius);
1450
1451             var shadow = new Tizen.NUI.Text.Shadow();
1452             shadow.Offset = offset;
1453             shadow.Color = color;
1454             shadow.BlurRadius = blurRadius;
1455
1456             return shadow;
1457         }
1458
1459         /// <summary>
1460         /// This method converts a Outline struct to a PropertyMap and returns it.
1461         /// The returned map can be used for set Outline PropertyMap in the SetOutline method.
1462         /// <param name="outline">The Outline struct value.</param>
1463         /// <returns> A PropertyMap for Outline property. </returns>
1464         /// </summary>
1465         [EditorBrowsable(EditorBrowsableState.Never)]
1466         public static PropertyMap GetOutlineMap(Outline outline)
1467         {
1468             var map = new PropertyMap();
1469
1470             if (outline.Color != null)
1471                 map.Add("color", new PropertyValue(outline.Color));
1472
1473             map.Add("width", new PropertyValue(outline.Width));
1474
1475             return map;
1476         }
1477
1478         /// <summary>
1479         /// This method converts a Outline map to a struct and returns it.
1480         /// The returned struct can be returned to the user as a Outline in the GetOutline method.
1481         /// <param name="map">The Outline PropertyMap.</param>
1482         /// <returns> A Outline struct. </returns>
1483         /// </summary>
1484         [EditorBrowsable(EditorBrowsableState.Never)]
1485         public static Outline GetOutlineStruct(PropertyMap map)
1486         {
1487             Color color = new Color();
1488             map.Find(0, "color").Get(color);
1489             map.Find(0, "width").Get(out float width);
1490
1491             var outline = new Outline();
1492             outline.Color = color;
1493             outline.Width = width;
1494
1495             return outline;
1496         }
1497
1498         /// <summary>
1499         /// It returns a string value according to FontSizeType.
1500         /// The returned value can be used for TextFit PropertyMap.
1501         /// <param name="fontSizeType">The FontSizeType enum value.</param>
1502         /// <returns> A string value for TextFit.FontSizeType property. </returns>
1503         /// </summary>
1504         [EditorBrowsable(EditorBrowsableState.Never)]
1505         public static string GetFontSizeString(FontSizeType fontSizeType)
1506         {
1507             string value = fontSizeType.ToString();
1508             if (!string.IsNullOrEmpty(value))
1509             {
1510                 char[] charArray = value.ToCharArray();
1511                 charArray[0] = Char.ToLower(charArray[0]);
1512                 value = new string(charArray);
1513             }
1514             else
1515             {
1516                 value = "pointSize"; // The default value.
1517             }
1518
1519             return value;
1520         }
1521
1522         /// <summary>
1523         /// It returns a FontSizeType value according to fontSizeString.
1524         /// The returned value can be used for FontStyle PropertyMap.
1525         /// <param name="fontSizeString">The FontSizeType string value.</param>
1526         /// <returns> A FontSizeType value for TextFit.FontSizeType property. </returns>
1527         /// </summary>
1528         [EditorBrowsable(EditorBrowsableState.Never)]
1529         public static FontSizeType GetFontSizeType(string fontSizeString)
1530         {
1531             FontSizeType value;
1532
1533             if (!(Enum.TryParse(fontSizeString, true, out value) && Enum.IsDefined(typeof(FontSizeType), value)))
1534             {
1535                 value = FontSizeType.PointSize; // If parsing fails, set a default value.
1536             }
1537
1538             return value;
1539         }
1540
1541         /// <summary>
1542         /// This method converts a TextFit struct to a PropertyMap and returns it.
1543         /// The returned map can be used for set TextFit PropertyMap in the SetTextFit method.
1544         /// <param name="textFit">The TextFit struct value.</param>
1545         /// <returns> A PropertyMap for TextFit property. </returns>
1546         /// </summary>
1547         [EditorBrowsable(EditorBrowsableState.Never)]
1548         public static PropertyMap GetTextFitMap(TextFit textFit)
1549         {
1550             var map = new PropertyMap();
1551             map.Add("enable", new PropertyValue(textFit.Enable));
1552             map.Add("minSize", new PropertyValue(textFit.MinSize));
1553             map.Add("maxSize", new PropertyValue(textFit.MaxSize));
1554             map.Add("stepSize", new PropertyValue(textFit.StepSize));
1555             map.Add("fontSizeType", new PropertyValue(GetFontSizeString(textFit.FontSizeType)));
1556
1557             return map;
1558         }
1559
1560         /// <summary>
1561         /// This method converts a TextFit map to a struct and returns it.
1562         /// The returned struct can be returned to the user as a TextFit in the GetTextFit method.
1563         /// <param name="map">The TextFit PropertyMap.</param>
1564         /// <returns> A TextFit struct. </returns>
1565         /// </summary>
1566         [EditorBrowsable(EditorBrowsableState.Never)]
1567         public static TextFit GetTextFitStruct(PropertyMap map)
1568         {
1569             map.Find(0, "enable").Get(out bool enable);
1570             map.Find(0, "minSize").Get(out float minSize);
1571             map.Find(0, "maxSize").Get(out float maxSize);
1572             map.Find(0, "stepSize").Get(out float stepSize);
1573             map.Find(0, "fontSizeType").Get(out string fontSizeType);
1574
1575             var textFit = new TextFit();
1576             textFit.Enable = enable;
1577             textFit.MinSize = minSize;
1578             textFit.MaxSize = maxSize;
1579             textFit.StepSize = stepSize;
1580             textFit.FontSizeType = GetFontSizeType(fontSizeType);
1581
1582             return textFit;
1583         }
1584     }
1585 }