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

   1 /*
   2  * Copyright(c) 2021 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 extern alias TizenSystemSettings;
  18 using TizenSystemSettings.Tizen.System;
  19
  20 using System;
  21 using System.Globalization;
  22 using System.ComponentModel;
  23 using Tizen.NUI.Binding;
  24 using Tizen.NUI.Text;
  25
  26 namespace Tizen.NUI.BaseComponents
  27 {
  28     /// <summary>
  29     /// A control which provides a single line editable text field.
  30     /// </summary>
  31     /// <since_tizen> 3 </since_tizen>
  32     public partial class TextField : View
  33     {
  34         private string textFieldTextSid = null;
  35         private string textFieldPlaceHolderTextSid = null;
  36         private string textFieldPlaceHolderTextFocusedSid = null;
  37         private bool systemlangTextFlag = false;
  38         private InputMethodContext inputMethodCotext = null;
  39         private float fontSizeScale = 1.0f;
  40         private bool hasFontSizeChangedCallback = false;
  41
  42         static TextField() { }
  43
  44         /// <summary>
  45         /// Creates the TextField control.
  46         /// </summary>
  47         /// <since_tizen> 3 </since_tizen>
  48         public TextField() : this(Interop.TextField.New(), true)
  49         {
  50             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  51         }
  52
  53         /// <summary>
  54         /// Creates the TextField with setting the status of shown or hidden.
  55         /// </summary>
  56         /// <param name="shown">false : Not displayed (hidden), true : displayed (shown)</param>
  57         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
  58         [EditorBrowsable(EditorBrowsableState.Never)]
  59         public TextField(bool shown) : this(Interop.TextField.New(), true)
  60         {
  61             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  62             SetVisible(shown);
  63         }
  64
  65         /// <summary>
  66         /// Get attributes, it is abstract function and must be override.
  67         /// </summary>
  68         [EditorBrowsable(EditorBrowsableState.Never)]
  69         protected override ViewStyle CreateViewStyle()
  70         {
  71             return new TextFieldStyle();
  72         }
  73
  74         internal TextField(global::System.IntPtr cPtr, bool cMemoryOwn, ViewStyle viewStyle, bool shown = true) : base(cPtr, cMemoryOwn, viewStyle)
  75         {
  76             if (!shown)
  77             {
  78                 SetVisible(false);
  79             }
  80         }
  81
  82         internal TextField(global::System.IntPtr cPtr, bool cMemoryOwn, bool shown = true) : base(cPtr, cMemoryOwn, null)
  83         {
  84             if (!shown)
  85             {
  86                 SetVisible(false);
  87             }
  88         }
  89
  90         internal TextField(TextField handle, bool shown = true) : this(Interop.TextField.NewTextField(TextField.getCPtr(handle)), true)
  91         {
  92             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  93
  94             if (!shown)
  95             {
  96                 SetVisible(false);
  97             }
  98         }
  99
 100         internal enum ExceedPolicyType
 101         {
 102             ExceedPolicyOriginal,
 103             ExceedPolicyClip
 104         }
 105
 106         /// <summary>
 107         /// The TranslatableText property.<br />
 108         /// The text can set the SID value.<br />
 109         /// </summary>
 110         /// <exception cref='ArgumentNullException'>
 111         /// ResourceManager about multilingual is null.
 112         /// </exception>
 113         /// <since_tizen> 4 </since_tizen>
 114         public string TranslatableText
 115         {
 116             get
 117             {
 118                 return (string)GetValue(TranslatableTextProperty);
 119             }
 120             set
 121             {
 122                 SetValue(TranslatableTextProperty, value);
 123             }
 124         }
 125         private string translatableText
 126         {
 127             get
 128             {
 129                 return textFieldTextSid;
 130             }
 131             set
 132             {
 133                 if (NUIApplication.MultilingualResourceManager == null)
 134                 {
 135                     throw new ArgumentNullException(null, "ResourceManager about multilingual is null");
 136                 }
 137                 textFieldTextSid = value;
 138                 Text = SetTranslatable(textFieldTextSid);
 139                 NotifyPropertyChanged();
 140             }
 141         }
 142
 143         /// <summary>
 144         /// The TranslatablePlaceholderText property.<br />
 145         /// The text can set the SID value.<br />
 146         /// </summary>
 147         /// <exception cref='ArgumentNullException'>
 148         /// ResourceManager about multilingual is null.
 149         /// </exception>
 150         /// <since_tizen> 4 </since_tizen>
 151         public string TranslatablePlaceholderText
 152         {
 153             get
 154             {
 155                 return (string)GetValue(TranslatablePlaceholderTextProperty);
 156             }
 157             set
 158             {
 159                 SetValue(TranslatablePlaceholderTextProperty, value);
 160             }
 161         }
 162         private string translatablePlaceholderText
 163         {
 164             get
 165             {
 166                 return textFieldPlaceHolderTextSid;
 167             }
 168             set
 169             {
 170                 if (NUIApplication.MultilingualResourceManager == null)
 171                 {
 172                     throw new ArgumentNullException(null, "ResourceManager about multilingual is null");
 173                 }
 174                 textFieldPlaceHolderTextSid = value;
 175                 PlaceholderText = SetTranslatable(textFieldPlaceHolderTextSid);
 176                 NotifyPropertyChanged();
 177             }
 178         }
 179
 180         /// <summary>
 181         /// The TranslatablePlaceholderTextFocused property.<br />
 182         /// The text can set the SID value.<br />
 183         /// </summary>
 184         /// <exception cref='ArgumentNullException'>
 185         /// ResourceManager about multilingual is null.
 186         /// </exception>
 187         /// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 188         [EditorBrowsable(EditorBrowsableState.Never)]
 189         public string TranslatablePlaceholderTextFocused
 190         {
 191             get
 192             {
 193                 return (string)GetValue(TranslatablePlaceholderTextFocusedProperty);
 194             }
 195             set
 196             {
 197                 SetValue(TranslatablePlaceholderTextFocusedProperty, value);
 198             }
 199         }
 200         private string translatablePlaceholderTextFocused
 201         {
 202             get
 203             {
 204                 return textFieldPlaceHolderTextFocusedSid;
 205             }
 206             set
 207             {
 208                 if (NUIApplication.MultilingualResourceManager == null)
 209                 {
 210                     throw new ArgumentNullException(null, "ResourceManager about multilingual is null");
 211                 }
 212                 textFieldPlaceHolderTextFocusedSid = value;
 213                 PlaceholderTextFocused = SetTranslatable(textFieldPlaceHolderTextFocusedSid);
 214                 NotifyPropertyChanged();
 215             }
 216         }
 217
 218         /// <summary>
 219         /// The Text property.
 220         /// </summary>
 221         /// <since_tizen> 3 </since_tizen>
 222         public string Text
 223         {
 224             get
 225             {
 226                 return (string)GetValue(TextProperty);
 227             }
 228             set
 229             {
 230                 SetValueAndForceSendChangeSignal(TextProperty, value);
 231                 NotifyPropertyChanged();
 232             }
 233         }
 234
 235         /// <summary>
 236         /// The PlaceholderText property.
 237         /// </summary>
 238         /// <since_tizen> 3 </since_tizen>
 239         public string PlaceholderText
 240         {
 241             get
 242             {
 243                 return (string)GetValue(PlaceholderTextProperty);
 244             }
 245             set
 246             {
 247                 SetValue(PlaceholderTextProperty, value);
 248                 NotifyPropertyChanged();
 249             }
 250         }
 251
 252         /// <summary>
 253         /// The PlaceholderTextFocused property.
 254         /// </summary>
 255         /// <since_tizen> 3 </since_tizen>
 256         public string PlaceholderTextFocused
 257         {
 258             get
 259             {
 260                 return (string)GetValue(PlaceholderTextFocusedProperty);
 261             }
 262             set
 263             {
 264                 SetValue(PlaceholderTextFocusedProperty, value);
 265                 NotifyPropertyChanged();
 266             }
 267         }
 268
 269         /// <summary>
 270         /// The FontFamily property.
 271         /// </summary>
 272         /// <since_tizen> 3 </since_tizen>
 273         public string FontFamily
 274         {
 275             get
 276             {
 277                 return (string)GetValue(FontFamilyProperty);
 278             }
 279             set
 280             {
 281                 SetValue(FontFamilyProperty, value);
 282                 NotifyPropertyChanged();
 283             }
 284         }
 285
 286         /// <summary>
 287         /// The FontStyle property.
 288         /// The fontStyle map contains the following keys :<br />
 289         /// <list type="table">
 290         /// <item><term>width (string)</term><description>The width key defines occupied by each glyph. (values: ultraCondensed, extraCondensed, condensed, semiCondensed, normal, semiExpanded, expanded, extraExpanded, ultraExpanded)</description></item>
 291         /// <item><term>weight (string)</term><description>The weight key defines the thickness or darkness of the glyphs. (values: thin, ultraLight, extraLight, light, demiLight, semiLight, book, normal, regular, medium, demiBold, semiBold, bold, ultraBold, extraBold, black, heavy, extraBlack)</description></item>
 292         /// <item><term>slant (string)</term><description>The slant key defines whether to use italics. (values: normal, roman, italic, oblique)</description></item>
 293         /// </list>
 294         /// </summary>
 295         /// <since_tizen> 3 </since_tizen>
 296         public PropertyMap FontStyle
 297         {
 298             get
 299             {
 300                 return (PropertyMap)GetValue(FontStyleProperty);
 301             }
 302             set
 303             {
 304                 SetValue(FontStyleProperty, value);
 305                 NotifyPropertyChanged();
 306             }
 307         }
 308
 309         /// <summary>
 310         /// Set FontStyle to TextField. <br />
 311         /// </summary>
 312         /// <param name="fontStyle">The FontStyle</param>
 313         /// <remarks>
 314         /// SetFontStyle specifies the requested font style through <see cref="Tizen.NUI.Text.FontStyle"/>. <br />
 315         /// </remarks>
 316         /// <example>
 317         /// The following example demonstrates how to use the SetFontStyle method.
 318         /// <code>
 319         /// var fontStyle = new Tizen.NUI.Text.FontStyle();
 320         /// fontStyle.Width = FontWidthType.Expanded;
 321         /// fontStyle.Weight = FontWeightType.Bold;
 322         /// fontStyle.Slant = FontSlantType.Italic;
 323         /// field.SetFontStyle(fontStyle);
 324         /// </code>
 325         /// </example>
 326         [EditorBrowsable(EditorBrowsableState.Never)]
 327         public void SetFontStyle(FontStyle fontStyle)
 328         {
 329             SetProperty(TextField.Property.FontStyle, new PropertyValue(TextUtils.GetFontStyleMap(fontStyle)));
 330             NotifyPropertyChanged();
 331         }
 332
 333         /// <summary>
 334         /// Get FontStyle from TextField. <br />
 335         /// </summary>
 336         /// <returns>The FontStyle</returns>
 337         /// <remarks>
 338         /// <see cref="Tizen.NUI.Text.FontStyle"/>
 339         /// </remarks>
 340         [EditorBrowsable(EditorBrowsableState.Never)]
 341         public FontStyle GetFontStyle()
 342         {
 343             var map = new PropertyMap();
 344             GetProperty(TextField.Property.FontStyle).Get(map);
 345             return TextUtils.GetFontStyleStruct(map);
 346         }
 347
 348         /// <summary>
 349         /// The PointSize property.
 350         /// </summary>
 351         /// <since_tizen> 3 </since_tizen>
 352         public float PointSize
 353         {
 354             get
 355             {
 356                 return (float)GetValue(PointSizeProperty);
 357             }
 358             set
 359             {
 360                 SetValue(PointSizeProperty, value);
 361                 NotifyPropertyChanged();
 362             }
 363         }
 364
 365         /// <summary>
 366         /// The MaxLength property.
 367         /// </summary>
 368         /// <since_tizen> 3 </since_tizen>
 369         public int MaxLength
 370         {
 371             get
 372             {
 373                 return (int)GetValue(MaxLengthProperty);
 374             }
 375             set
 376             {
 377                 SetValue(MaxLengthProperty, value);
 378                 NotifyPropertyChanged();
 379             }
 380         }
 381
 382         /// <summary>
 383         /// The ExceedPolicy property.
 384         /// </summary>
 385         /// <since_tizen> 3 </since_tizen>
 386         public int ExceedPolicy
 387         {
 388             get
 389             {
 390                 return (int)GetValue(ExceedPolicyProperty);
 391             }
 392             set
 393             {
 394                 SetValue(ExceedPolicyProperty, value);
 395                 NotifyPropertyChanged();
 396             }
 397         }
 398
 399         /// <summary>
 400         /// The HorizontalAlignment property.
 401         /// </summary>
 402         /// <since_tizen> 3 </since_tizen>
 403         public HorizontalAlignment HorizontalAlignment
 404         {
 405             get
 406             {
 407                 return (HorizontalAlignment)GetValue(HorizontalAlignmentProperty);
 408             }
 409             set
 410             {
 411                 SetValue(HorizontalAlignmentProperty, value);
 412                 NotifyPropertyChanged();
 413             }
 414         }
 415
 416         /// <summary>
 417         /// The VerticalAlignment property.
 418         /// </summary>
 419         /// <since_tizen> 3 </since_tizen>
 420         public VerticalAlignment VerticalAlignment
 421         {
 422             get
 423             {
 424                 return (VerticalAlignment)GetValue(VerticalAlignmentProperty);
 425             }
 426             set
 427             {
 428                 SetValue(VerticalAlignmentProperty, value);
 429                 NotifyPropertyChanged();
 430                 NotifyPropertyChanged();
 431             }
 432         }
 433
 434         /// <summary>
 435         /// The TextColor property.
 436         /// </summary>
 437         /// <remarks>
 438         /// The property cascade chaining set is possible. For example, this (textField.TextColor.X = 0.1f;) is possible.
 439         /// </remarks>
 440         /// <since_tizen> 3 </since_tizen>
 441         public Color TextColor
 442         {
 443             get
 444             {
 445                 Color temp = (Color)GetValue(TextColorProperty);
 446                 return new Color(OnTextColorChanged, temp.R, temp.G, temp.B, temp.A);
 447             }
 448             set
 449             {
 450                 SetValue(TextColorProperty, value);
 451                 NotifyPropertyChanged();
 452             }
 453         }
 454
 455         /// <summary>
 456         /// The PlaceholderTextColor property.
 457         /// </summary>
 458         /// <remarks>
 459         /// The property cascade chaining set is possible. For example, this (textField.PlaceholderTextColor.X = 0.1f;) is possible.
 460         /// </remarks>
 461         /// <since_tizen> 3 </since_tizen>
 462         public Vector4 PlaceholderTextColor
 463         {
 464             get
 465             {
 466                 Vector4 temp = (Vector4)GetValue(PlaceholderTextColorProperty);
 467                 return new Vector4(OnPlaceholderTextColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 468             }
 469             set
 470             {
 471                 SetValue(PlaceholderTextColorProperty, value);
 472                 NotifyPropertyChanged();
 473             }
 474         }
 475
 476         /// <summary>
 477         /// The ShadowOffset property.
 478         /// </summary>
 479         /// <since_tizen> 3 </since_tizen>
 480         /// <remarks>
 481         /// Deprecated.(API Level 6) Use Shadow instead.
 482         /// The property cascade chaining set is possible. For example, this (textField.ShadowOffset.X = 0.1f;) is possible.
 483         /// </remarks>
 484         [Obsolete("Please do not use this ShadowOffset(Deprecated). Please use Shadow instead.")]
 485         public Vector2 ShadowOffset
 486         {
 487             get
 488             {
 489                 PropertyMap map = new PropertyMap();
 490                 GetProperty(TextField.Property.SHADOW).Get(map);
 491                 Vector2 shadowOffset = new Vector2();
 492                 map.Find(TextField.Property.SHADOW, "offset")?.Get(shadowOffset);
 493                 return new Vector2(OnShadowOffsetChanged, shadowOffset.X, shadowOffset.Y);
 494             }
 495             set
 496             {
 497                 PropertyMap temp = new PropertyMap();
 498                 temp.Insert("offset", new PropertyValue(value));
 499                 SetValue(ShadowProperty, temp);
 500                 NotifyPropertyChanged();
 501             }
 502         }
 503
 504         /// <summary>
 505         /// The ShadowColor property.
 506         /// </summary>
 507         /// <since_tizen> 3 </since_tizen>
 508         /// <remarks>
 509         /// Deprecated.(API Level 6) Use Shadow instead.
 510         /// The property cascade chaining set is possible. For example, this (textField.ShadowColor.X = 0.1f;) is possible.
 511         /// </remarks>
 512         [Obsolete("Please do not use this ShadowColor(Deprecated). Please use Shadow instead.")]
 513         public Vector4 ShadowColor
 514         {
 515             get
 516             {
 517                 PropertyMap map = new PropertyMap();
 518                 GetProperty(TextField.Property.SHADOW).Get(map);
 519                 Vector4 shadowColor = new Vector4();
 520                 map.Find(TextField.Property.SHADOW, "color")?.Get(shadowColor);
 521                 return new Vector4(OnShadowColorChanged, shadowColor.X, shadowColor.Y, shadowColor.Z, shadowColor.W);
 522             }
 523             set
 524             {
 525                 PropertyMap temp = new PropertyMap();
 526                 temp.Insert("color", new PropertyValue(value));
 527                 SetValue(ShadowProperty, temp);
 528                 NotifyPropertyChanged();
 529             }
 530         }
 531
 532         /// <summary>
 533         /// The PrimaryCursorColor property.
 534         /// </summary>
 535         /// <remarks>
 536         /// The property cascade chaining set is possible. For example, this (textField.PrimaryCursorColor.X = 0.1f;) is possible.
 537         /// </remarks>
 538         /// <since_tizen> 3 </since_tizen>
 539         public Vector4 PrimaryCursorColor
 540         {
 541             get
 542             {
 543                 Vector4 temp = (Vector4)GetValue(PrimaryCursorColorProperty);
 544                 return new Vector4(OnPrimaryCursorColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 545             }
 546             set
 547             {
 548                 SetValue(PrimaryCursorColorProperty, value);
 549                 NotifyPropertyChanged();
 550             }
 551         }
 552
 553         /// <summary>
 554         /// The SecondaryCursorColor property.
 555         /// </summary>
 556         /// <remarks>
 557         /// The property cascade chaining set is possible. For example, this (textField.SecondaryCursorColor.X = 0.1f;) is possible.
 558         /// </remarks>
 559         /// <since_tizen> 3 </since_tizen>
 560         public Vector4 SecondaryCursorColor
 561         {
 562             get
 563             {
 564                 Vector4 temp = (Vector4)GetValue(SecondaryCursorColorProperty);
 565                 return new Vector4(OnSecondaryCursorColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 566             }
 567             set
 568             {
 569                 SetValue(SecondaryCursorColorProperty, value);
 570                 NotifyPropertyChanged();
 571             }
 572         }
 573
 574         /// <summary>
 575         /// The EnableCursorBlink property.
 576         /// </summary>
 577         /// <since_tizen> 3 </since_tizen>
 578         public bool EnableCursorBlink
 579         {
 580             get
 581             {
 582                 return (bool)GetValue(EnableCursorBlinkProperty);
 583             }
 584             set
 585             {
 586                 SetValue(EnableCursorBlinkProperty, value);
 587                 NotifyPropertyChanged();
 588             }
 589         }
 590
 591         /// <summary>
 592         /// The CursorBlinkInterval property.
 593         /// </summary>
 594         /// <since_tizen> 3 </since_tizen>
 595         public float CursorBlinkInterval
 596         {
 597             get
 598             {
 599                 return (float)GetValue(CursorBlinkIntervalProperty);
 600             }
 601             set
 602             {
 603                 SetValue(CursorBlinkIntervalProperty, value);
 604                 NotifyPropertyChanged();
 605             }
 606         }
 607
 608         /// <summary>
 609         /// The CursorBlinkDuration property.
 610         /// </summary>
 611         /// <since_tizen> 3 </since_tizen>
 612         public float CursorBlinkDuration
 613         {
 614             get
 615             {
 616                 return (float)GetValue(CursorBlinkDurationProperty);
 617             }
 618             set
 619             {
 620                 SetValue(CursorBlinkDurationProperty, value);
 621                 NotifyPropertyChanged();
 622             }
 623         }
 624
 625         /// <summary>
 626         /// The CursorWidth property.
 627         /// </summary>
 628         /// <since_tizen> 3 </since_tizen>
 629         public int CursorWidth
 630         {
 631             get
 632             {
 633                 return (int)GetValue(CursorWidthProperty);
 634             }
 635             set
 636             {
 637                 SetValue(CursorWidthProperty, value);
 638                 NotifyPropertyChanged();
 639             }
 640         }
 641
 642         /// <summary>
 643         /// The GrabHandleImage property.
 644         /// </summary>
 645         /// <since_tizen> 3 </since_tizen>
 646         public string GrabHandleImage
 647         {
 648             get
 649             {
 650                 return (string)GetValue(GrabHandleImageProperty);
 651             }
 652             set
 653             {
 654                 SetValue(GrabHandleImageProperty, value);
 655                 NotifyPropertyChanged();
 656             }
 657         }
 658
 659         /// <summary>
 660         /// The GrabHandlePressedImage property.
 661         /// </summary>
 662         /// <since_tizen> 3 </since_tizen>
 663         public string GrabHandlePressedImage
 664         {
 665             get
 666             {
 667                 return (string)GetValue(GrabHandlePressedImageProperty);
 668             }
 669             set
 670             {
 671                 SetValue(GrabHandlePressedImageProperty, value);
 672                 NotifyPropertyChanged();
 673             }
 674         }
 675
 676         /// <summary>
 677         /// The ScrollThreshold property.
 678         /// </summary>
 679         /// <since_tizen> 3 </since_tizen>
 680         public float ScrollThreshold
 681         {
 682             get
 683             {
 684                 return (float)GetValue(ScrollThresholdProperty);
 685             }
 686             set
 687             {
 688                 SetValue(ScrollThresholdProperty, value);
 689                 NotifyPropertyChanged();
 690             }
 691         }
 692
 693         /// <summary>
 694         /// The ScrollSpeed property.
 695         /// </summary>
 696         /// <since_tizen> 3 </since_tizen>
 697         public float ScrollSpeed
 698         {
 699             get
 700             {
 701                 return (float)GetValue(ScrollSpeedProperty);
 702             }
 703             set
 704             {
 705                 SetValue(ScrollSpeedProperty, value);
 706                 NotifyPropertyChanged();
 707             }
 708         }
 709
 710         /// <summary>
 711         /// The SelectionHandleImageLeft property.
 712         /// The selectionHandleImageLeft map contains the following key :<br />
 713         /// <list type="table">
 714         /// <item><term>filename (string)</term><description>The path of image file</description></item>
 715         /// </list>
 716         /// </summary>
 717         /// <since_tizen> 3 </since_tizen>
 718         public PropertyMap SelectionHandleImageLeft
 719         {
 720             get
 721             {
 722                 return (PropertyMap)GetValue(SelectionHandleImageLeftProperty);
 723             }
 724             set
 725             {
 726                 SetValue(SelectionHandleImageLeftProperty, value);
 727                 NotifyPropertyChanged();
 728             }
 729         }
 730
 731         /// <summary>
 732         /// The SelectionHandleImageRight property.
 733         /// The selectionHandleImageRight map contains the following key :<br />
 734         /// <list type="table">
 735         /// <item><term>filename (string)</term><description>The path of image file</description></item>
 736         /// </list>
 737         /// </summary>
 738         /// <since_tizen> 3 </since_tizen>
 739         public PropertyMap SelectionHandleImageRight
 740         {
 741             get
 742             {
 743                 return (PropertyMap)GetValue(SelectionHandleImageRightProperty);
 744             }
 745             set
 746             {
 747                 SetValue(SelectionHandleImageRightProperty, value);
 748                 NotifyPropertyChanged();
 749             }
 750         }
 751
 752         /// <summary>
 753         /// The SelectionHandlePressedImageLeft property.
 754         /// The selectionHandlePressedImageLeft map contains the following key :<br />
 755         /// <list type="table">
 756         /// <item><term>filename (string)</term><description>The path of image file</description></item>
 757         /// </list>
 758         /// </summary>
 759         /// <since_tizen> 3 </since_tizen>
 760         public PropertyMap SelectionHandlePressedImageLeft
 761         {
 762             get
 763             {
 764                 return (PropertyMap)GetValue(SelectionHandlePressedImageLeftProperty);
 765             }
 766             set
 767             {
 768                 SetValue(SelectionHandlePressedImageLeftProperty, value);
 769                 NotifyPropertyChanged();
 770             }
 771         }
 772
 773         /// <summary>
 774         /// The SelectionHandlePressedImageRight property.
 775         /// The selectionHandlePressedImageRight map contains the following key :<br />
 776         /// <list type="table">
 777         /// <item><term>filename (string)</term><description>The path of image file</description></item>
 778         /// </list>
 779         /// </summary>
 780         /// <since_tizen> 3 </since_tizen>
 781         public PropertyMap SelectionHandlePressedImageRight
 782         {
 783             get
 784             {
 785                 return (PropertyMap)GetValue(SelectionHandlePressedImageRightProperty);
 786             }
 787             set
 788             {
 789                 SetValue(SelectionHandlePressedImageRightProperty, value);
 790                 NotifyPropertyChanged();
 791             }
 792         }
 793
 794         /// <summary>
 795         /// The SelectionHandleMarkerImageLeft property.
 796         /// The selectionHandleMarkerImageLeft map contains the following key :<br />
 797         /// <list type="table">
 798         /// <item><term>filename (string)</term><description>The path of image file</description></item>
 799         /// </list>
 800         /// </summary>
 801         /// <since_tizen> 3 </since_tizen>
 802         public PropertyMap SelectionHandleMarkerImageLeft
 803         {
 804             get
 805             {
 806                 return (PropertyMap)GetValue(SelectionHandleMarkerImageLeftProperty);
 807             }
 808             set
 809             {
 810                 SetValue(SelectionHandleMarkerImageLeftProperty, value);
 811                 NotifyPropertyChanged();
 812             }
 813         }
 814
 815         /// <summary>
 816         /// The SelectionHandleMarkerImageRight property.
 817         /// The selectionHandleMarkerImageRight map contains the following key :<br />
 818         /// <list type="table">
 819         /// <item><term>filename (string)</term><description>The path of image file</description></item>
 820         /// </list>
 821         /// </summary>
 822         /// <since_tizen> 3 </since_tizen>
 823         public PropertyMap SelectionHandleMarkerImageRight
 824         {
 825             get
 826             {
 827                 return (PropertyMap)GetValue(SelectionHandleMarkerImageRightProperty);
 828             }
 829             set
 830             {
 831                 SetValue(SelectionHandleMarkerImageRightProperty, value);
 832                 NotifyPropertyChanged();
 833             }
 834         }
 835
 836         /// <summary>
 837         /// The SelectionHighlightColor property.
 838         /// </summary>
 839         /// <remarks>
 840         /// The property cascade chaining set is possible. For example, this (textField.SelectionHighlightColor.X = 0.1f;) is possible.
 841         /// </remarks>
 842         /// <since_tizen> 3 </since_tizen>
 843         public Vector4 SelectionHighlightColor
 844         {
 845             get
 846             {
 847                 Vector4 temp = (Vector4)GetValue(SelectionHighlightColorProperty);
 848                 return new Vector4(OnSelectionHighlightColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 849             }
 850             set
 851             {
 852                 SetValue(SelectionHighlightColorProperty, value);
 853                 NotifyPropertyChanged();
 854             }
 855         }
 856
 857         /// <summary>
 858         /// The DecorationBoundingBox property.
 859         /// </summary>
 860         /// <remarks>
 861         /// The property cascade chaining set is possible. For example, this (textField.DecorationBoundingBox.X = 0.1f;) is possible.
 862         /// </remarks>
 863         /// <since_tizen> 3 </since_tizen>
 864         public Rectangle DecorationBoundingBox
 865         {
 866             get
 867             {
 868                 Rectangle temp = (Rectangle)GetValue(DecorationBoundingBoxProperty);
 869                 return new Rectangle(OnDecorationBoundingBoxChanged, temp.X, temp.Y, temp.Width, temp.Height);
 870             }
 871             set
 872             {
 873                 SetValue(DecorationBoundingBoxProperty, value);
 874                 NotifyPropertyChanged();
 875             }
 876         }
 877
 878         /// <summary>
 879         /// The InputMethodSettings property.
 880         /// </summary>
 881         /// <remarks>
 882         /// <see cref="InputMethod"/> is a class encapsulating the input method map. Please use the <see cref="InputMethod"/> class for this property.
 883         /// </remarks>
 884         /// <example>
 885         /// The following example demonstrates how to set the InputMethodSettings property.
 886         /// <code>
 887         /// InputMethod method = new InputMethod();
 888         /// method.PanelLayout = InputMethod.PanelLayoutType.Normal;
 889         /// method.ActionButton = InputMethod.ActionButtonTitleType.Default;
 890         /// method.AutoCapital = InputMethod.AutoCapitalType.Word;
 891         /// method.Variation = 1;
 892         /// textField.InputMethodSettings = method.OutputMap;
 893         /// </code>
 894         /// </example>
 895         /// <since_tizen> 3 </since_tizen>
 896         public PropertyMap InputMethodSettings
 897         {
 898             get
 899             {
 900                 return (PropertyMap)GetValue(InputMethodSettingsProperty);
 901             }
 902             set
 903             {
 904                 SetValue(InputMethodSettingsProperty, value);
 905                 NotifyPropertyChanged();
 906             }
 907         }
 908
 909         /// <summary>
 910         /// The InputColor property.
 911         /// </summary>
 912         /// <remarks>
 913         /// The property cascade chaining set is possible. For example, this (textField.InputColor.X = 0.1f;) is possible.
 914         /// </remarks>
 915         /// <since_tizen> 3 </since_tizen>
 916         public Vector4 InputColor
 917         {
 918             get
 919             {
 920                 Vector4 temp = (Vector4)GetValue(InputColorProperty);
 921                 return new Vector4(OnInputColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 922             }
 923             set
 924             {
 925                 SetValue(InputColorProperty, value);
 926                 NotifyPropertyChanged();
 927             }
 928         }
 929
 930         /// <summary>
 931         /// The EnableMarkup property.
 932         /// </summary>
 933         /// <since_tizen> 3 </since_tizen>
 934         public bool EnableMarkup
 935         {
 936             get
 937             {
 938                 return (bool)GetValue(EnableMarkupProperty);
 939             }
 940             set
 941             {
 942                 SetValue(EnableMarkupProperty, value);
 943                 NotifyPropertyChanged();
 944             }
 945         }
 946
 947         /// <summary>
 948         /// The InputFontFamily property.
 949         /// </summary>
 950         /// <since_tizen> 3 </since_tizen>
 951         public string InputFontFamily
 952         {
 953             get
 954             {
 955                 return (string)GetValue(InputFontFamilyProperty);
 956             }
 957             set
 958             {
 959                 SetValue(InputFontFamilyProperty, value);
 960                 NotifyPropertyChanged();
 961             }
 962         }
 963
 964         /// <summary>
 965         /// The InputFontStyle property.
 966         /// The inputFontStyle map contains the following keys :<br />
 967         /// <list type="table">
 968         /// <item><term>width (string)</term><description>The width key defines occupied by each glyph. (values: ultraCondensed, extraCondensed, condensed, semiCondensed, normal, semiExpanded, expanded, extraExpanded, ultraExpanded)</description></item>
 969         /// <item><term>weight (string)</term><description>The weight key defines the thickness or darkness of the glyphs. (values: thin, ultraLight, extraLight, light, demiLight, semiLight, book, normal, regular, medium, demiBold, semiBold, bold, ultraBold, extraBold, black, heavy, extraBlack)</description></item>
 970         /// <item><term>slant (string)</term><description>The slant key defines whether to use italics. (values: normal, roman, italic, oblique)</description></item>
 971         /// </list>
 972         /// </summary>
 973         /// <since_tizen> 3 </since_tizen>
 974         public PropertyMap InputFontStyle
 975         {
 976             get
 977             {
 978                 return (PropertyMap)GetValue(InputFontStyleProperty);
 979             }
 980             set
 981             {
 982                 SetValue(InputFontStyleProperty, value);
 983                 NotifyPropertyChanged();
 984             }
 985         }
 986
 987         /// <summary>
 988         /// Set InputFontStyle to TextField. <br />
 989         /// </summary>
 990         /// <param name="fontStyle">The FontStyle</param>
 991         /// <remarks>
 992         /// SetInputFontStyle specifies the requested font style for new input text through <see cref="Tizen.NUI.Text.FontStyle"/>. <br />
 993         /// </remarks>
 994         /// <example>
 995         /// The following example demonstrates how to use the SetInputFontStyle method.
 996         /// <code>
 997         /// var fontStyle = new Tizen.NUI.Text.FontStyle();
 998         /// fontStyle.Width = FontWidthType.Expanded;
 999         /// fontStyle.Weight = FontWeightType.Bold;
1000         /// fontStyle.Slant = FontSlantType.Italic;
1001         /// field.SetInputFontStyle(fontStyle);
1002         /// </code>
1003         /// </example>
1004         [EditorBrowsable(EditorBrowsableState.Never)]
1005         public void SetInputFontStyle(FontStyle fontStyle)
1006         {
1007             SetProperty(TextField.Property.InputFontStyle, new PropertyValue(TextUtils.GetFontStyleMap(fontStyle)));
1008             NotifyPropertyChanged();
1009         }
1010
1011         /// <summary>
1012         /// Get InputFontStyle from TextField. <br />
1013         /// </summary>
1014         /// <returns>The FontStyle</returns>
1015         /// <remarks>
1016         /// <see cref="Tizen.NUI.Text.FontStyle"/>
1017         /// </remarks>
1018         [EditorBrowsable(EditorBrowsableState.Never)]
1019         public FontStyle GetInputFontStyle()
1020         {
1021             var map = new PropertyMap();
1022             GetProperty(TextField.Property.InputFontStyle).Get(map);
1023             return TextUtils.GetFontStyleStruct(map);
1024         }
1025
1026         /// <summary>
1027         /// The InputPointSize property.
1028         /// </summary>
1029         /// <since_tizen> 3 </since_tizen>
1030         public float InputPointSize
1031         {
1032             get
1033             {
1034                 return (float)GetValue(InputPointSizeProperty);
1035             }
1036             set
1037             {
1038                 SetValue(InputPointSizeProperty, value);
1039                 NotifyPropertyChanged();
1040             }
1041         }
1042
1043         /// <summary>
1044         /// The Underline property.
1045         /// The underline map contains the following keys :<br />
1046         /// <list type="table">
1047         /// <item><term>enable (bool)</term><description>Whether the underline is enabled (the default value is false)</description></item>
1048         /// <item><term>color (Color)</term><description>The color of the underline (If not provided then the color of the text is used)</description></item>
1049         /// <item><term>height (float)</term><description>The height in pixels of the underline (the default value is 1.f)</description></item>
1050         /// </list>
1051         /// </summary>
1052         /// <since_tizen> 3 </since_tizen>
1053         public PropertyMap Underline
1054         {
1055             get
1056             {
1057                 return (PropertyMap)GetValue(UnderlineProperty);
1058             }
1059             set
1060             {
1061                 SetValue(UnderlineProperty, value);
1062                 NotifyPropertyChanged();
1063             }
1064         }
1065
1066         /// <summary>
1067         /// Set Underline to TextField. <br />
1068         /// </summary>
1069         /// <param name="underline">The Underline</param>
1070         /// <remarks>
1071         /// SetUnderline specifies the underline of the text through <see cref="Tizen.NUI.Text.Underline"/>. <br />
1072         /// </remarks>
1073         /// <example>
1074         /// The following example demonstrates how to use the SetUnderline method.
1075         /// <code>
1076         /// var underline = new Tizen.NUI.Text.Underline();
1077         /// underline.Enable = true;
1078         /// underline.Color = new Color("#3498DB");
1079         /// underline.Height = 2.0f;
1080         /// field.SetUnderline(underline);
1081         /// </code>
1082         /// </example>
1083         [EditorBrowsable(EditorBrowsableState.Never)]
1084         public void SetUnderline(Underline underline)
1085         {
1086             SetProperty(TextField.Property.UNDERLINE, new PropertyValue(TextUtils.GetUnderlineMap(underline)));
1087         }
1088
1089         /// <summary>
1090         /// Get Underline from TextField. <br />
1091         /// </summary>
1092         /// <returns>The Underline</returns>
1093         /// <remarks>
1094         /// <see cref="Tizen.NUI.Text.Underline"/>
1095         /// </remarks>
1096         [EditorBrowsable(EditorBrowsableState.Never)]
1097         public Underline GetUnderline()
1098         {
1099             var map = new PropertyMap();
1100             GetProperty(TextField.Property.UNDERLINE).Get(map);
1101             return TextUtils.GetUnderlineStruct(map);
1102         }
1103
1104         /// <summary>
1105         /// The InputUnderline property.
1106         /// </summary>
1107         /// <since_tizen> 3 </since_tizen>
1108         public string InputUnderline
1109         {
1110             get
1111             {
1112                 return (string)GetValue(InputUnderlineProperty);
1113             }
1114             set
1115             {
1116                 SetValue(InputUnderlineProperty, value);
1117                 NotifyPropertyChanged();
1118             }
1119         }
1120
1121         /// <summary>
1122         /// The Shadow property.
1123         /// The shadow map contains the following keys :<br />
1124         /// <list type="table">
1125         /// <item><term>color (Color)</term><description>The color of the shadow (the default color is Color.Black)</description></item>
1126         /// <item><term>offset (Vector2)</term><description>The offset in pixels of the shadow (If not provided then the shadow is not enabled)</description></item>
1127         /// <item><term>blurRadius (float)</term><description>The radius of the Gaussian blur for the soft shadow (If not provided then the soft shadow is not enabled)</description></item>
1128         /// </list>
1129         /// </summary>
1130         /// <since_tizen> 3 </since_tizen>
1131         public PropertyMap Shadow
1132         {
1133             get
1134             {
1135                 return (PropertyMap)GetValue(ShadowProperty);
1136             }
1137             set
1138             {
1139                 SetValue(ShadowProperty, value);
1140                 NotifyPropertyChanged();
1141             }
1142         }
1143
1144         /// <summary>
1145         /// The InputShadow property.
1146         /// </summary>
1147         /// <since_tizen> 3 </since_tizen>
1148         public string InputShadow
1149         {
1150             get
1151             {
1152                 return (string)GetValue(InputShadowProperty);
1153             }
1154             set
1155             {
1156                 SetValue(InputShadowProperty, value);
1157                 NotifyPropertyChanged();
1158             }
1159         }
1160
1161         /// <summary>
1162         /// The Emboss property.
1163         /// </summary>
1164         /// <since_tizen> 3 </since_tizen>
1165         public string Emboss
1166         {
1167             get
1168             {
1169                 return (string)GetValue(EmbossProperty);
1170             }
1171             set
1172             {
1173                 SetValue(EmbossProperty, value);
1174                 NotifyPropertyChanged();
1175             }
1176         }
1177
1178         /// <summary>
1179         /// The InputEmboss property.
1180         /// </summary>
1181         /// <since_tizen> 3 </since_tizen>
1182         public string InputEmboss
1183         {
1184             get
1185             {
1186                 return (string)GetValue(InputEmbossProperty);
1187             }
1188             set
1189             {
1190                 SetValue(InputEmbossProperty, value);
1191                 NotifyPropertyChanged();
1192             }
1193         }
1194
1195         /// <summary>
1196         /// The Outline property.
1197         /// The outline map contains the following keys :<br />
1198         /// <list type="table">
1199         /// <item><term>color (Color)</term><description>The color of the outline (the default color is Color.White)</description></item>
1200         /// <item><term>width (float)</term><description>The width in pixels of the outline (If not provided then the outline is not enabled)</description></item>
1201         /// </list>
1202         /// </summary>
1203         /// <since_tizen> 3 </since_tizen>
1204         public PropertyMap Outline
1205         {
1206             get
1207             {
1208                 return (PropertyMap)GetValue(OutlineProperty);
1209             }
1210             set
1211             {
1212                 SetValue(OutlineProperty, value);
1213                 NotifyPropertyChanged();
1214             }
1215         }
1216
1217         /// <summary>
1218         /// The InputOutline property.
1219         /// </summary>
1220         /// <since_tizen> 3 </since_tizen>
1221         public string InputOutline
1222         {
1223             get
1224             {
1225                 return (string)GetValue(InputOutlineProperty);
1226             }
1227             set
1228             {
1229                 SetValue(InputOutlineProperty, value);
1230                 NotifyPropertyChanged();
1231             }
1232         }
1233
1234         /// <summary>
1235         /// The HiddenInputSettings property.
1236         /// The hiddenInputSettings map contains the following keys :<br />
1237         /// <list type="table">
1238         /// <item><term>HiddenInputProperty.Mode (int)</term><description>The mode for input text display (Use HiddenInputModeType)</description></item>
1239         /// <item><term>HiddenInputProperty.SubstituteCharacter (int)</term><description>All input characters are substituted by this character</description></item>
1240         /// <item><term>HiddenInputProperty.SubstituteCount (int)</term><description>Length of text to show or hide, available when HideCount/ShowCount mode is used</description></item>
1241         /// <item><term>HiddenInputProperty.ShowLastCharacterDuration (int)</term><description>Hide last character after this duration, available when ShowLastCharacter mode</description></item>
1242         /// </list>
1243         /// </summary>
1244         /// <remarks>
1245         /// See <see cref="HiddenInputProperty"/> and <see cref="HiddenInputModeType"/> for a detailed description.
1246         /// </remarks>
1247         /// <example>
1248         /// The following example demonstrates how to set the HiddenInputSettings property.
1249         /// <code>
1250         /// PropertyMap map = new PropertyMap();
1251         /// map.Add(HiddenInputProperty.Mode, new PropertyValue((int)HiddenInputModeType.ShowLastCharacter));
1252         /// map.Add(HiddenInputProperty.ShowLastCharacterDuration, new PropertyValue(500));
1253         /// map.Add(HiddenInputProperty.SubstituteCharacter, new PropertyValue(0x2A));
1254         /// textField.HiddenInputSettings = map;
1255         /// </code>
1256         /// </example>
1257         /// <since_tizen> 3 </since_tizen>
1258         public Tizen.NUI.PropertyMap HiddenInputSettings
1259         {
1260             get
1261             {
1262                 return (PropertyMap)GetValue(HiddenInputSettingsProperty);
1263             }
1264             set
1265             {
1266                 SetValue(HiddenInputSettingsProperty, value);
1267                 NotifyPropertyChanged();
1268             }
1269         }
1270
1271         /// <summary>
1272         /// The PixelSize property.
1273         /// </summary>
1274         /// <since_tizen> 3 </since_tizen>
1275         public float PixelSize
1276         {
1277             get
1278             {
1279                 return (float)GetValue(PixelSizeProperty);
1280             }
1281             set
1282             {
1283                 SetValue(PixelSizeProperty, value);
1284                 NotifyPropertyChanged();
1285             }
1286         }
1287
1288         /// <summary>
1289         /// The Enable selection property.
1290         /// </summary>
1291         /// <since_tizen> 3 </since_tizen>
1292         public bool EnableSelection
1293         {
1294             get
1295             {
1296                 return (bool)GetValue(EnableSelectionProperty);
1297             }
1298             set
1299             {
1300                 SetValue(EnableSelectionProperty, value);
1301                 NotifyPropertyChanged();
1302             }
1303         }
1304
1305         /// <summary>
1306         /// The Enable selection property.
1307         /// </summary>
1308         /// <since_tizen> 6 </since_tizen>
1309         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1310         [EditorBrowsable(EditorBrowsableState.Never)]
1311         public bool EnableGrabHandle
1312         {
1313             get
1314             {
1315                 return (bool)GetValue(EnableGrabHandleProperty);
1316             }
1317             set
1318             {
1319                 SetValue(EnableGrabHandleProperty, value);
1320                 NotifyPropertyChanged();
1321             }
1322         }
1323
1324         /// <summary>
1325         /// The Enable selection property.
1326         /// </summary>
1327         /// <since_tizen> 6 </since_tizen>
1328         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1329         [EditorBrowsable(EditorBrowsableState.Never)]
1330         public bool EnableGrabHandlePopup
1331         {
1332             get
1333             {
1334                 return (bool)GetValue(EnableGrabHandlePopupProperty);
1335             }
1336             set
1337             {
1338                 SetValue(EnableGrabHandlePopupProperty, value);
1339                 NotifyPropertyChanged();
1340             }
1341         }
1342
1343         /// <summary>
1344         /// The Selected Text property.
1345         /// </summary>
1346         /// <since_tizen> 8 </since_tizen>
1347         /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
1348         [EditorBrowsable(EditorBrowsableState.Never)]
1349         public string SelectedText
1350         {
1351             get
1352             {
1353                 string temp;
1354                 GetProperty(TextField.Property.SelectedText).Get(out temp);
1355                 return temp;
1356             }
1357         }
1358
1359         /// <summary>
1360         /// The start index for selection.
1361         /// </summary>
1362         /// <since_tizen> 8 </since_tizen>
1363         /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
1364         [EditorBrowsable(EditorBrowsableState.Never)]
1365         public int SelectedTextStart
1366         {
1367             get
1368             {
1369                 int temp;
1370                 GetProperty(TextField.Property.SelectedTextStart).Get(out temp);
1371                 return temp;
1372             }
1373             set
1374             {
1375                 SetProperty(TextField.Property.SelectedTextStart, new PropertyValue(value));
1376                 NotifyPropertyChanged();
1377             }
1378         }
1379
1380         /// <summary>
1381         /// The end index for selection.
1382         /// </summary>
1383         /// <since_tizen> 8 </since_tizen>
1384         /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
1385         [EditorBrowsable(EditorBrowsableState.Never)]
1386         public int SelectedTextEnd
1387         {
1388             get
1389             {
1390                 int temp;
1391                 GetProperty(TextField.Property.SelectedTextEnd).Get(out temp);
1392                 return temp;
1393             }
1394             set
1395             {
1396                 SetProperty(TextField.Property.SelectedTextEnd, new PropertyValue(value));
1397                 NotifyPropertyChanged();
1398             }
1399         }
1400
1401         /// <summary>
1402         /// Enable editing in text control.
1403         /// </summary>
1404         /// <since_tizen> 8 </since_tizen>
1405         /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
1406         [EditorBrowsable(EditorBrowsableState.Never)]
1407         public bool EnableEditing
1408         {
1409             get
1410             {
1411                 bool temp;
1412                 GetProperty(TextField.Property.EnableEditing).Get(out temp);
1413                 return temp;
1414             }
1415             set
1416             {
1417                 SetProperty(TextField.Property.EnableEditing, new PropertyValue(value));
1418                 NotifyPropertyChanged();
1419             }
1420         }
1421
1422         /// <summary>
1423         /// Specify primary cursor (caret) position in text control.
1424         /// </summary>
1425         [EditorBrowsable(EditorBrowsableState.Never)]
1426         public int PrimaryCursorPosition
1427         {
1428             get
1429             {
1430                 int temp;
1431                 using (PropertyValue propertyValue = GetProperty(TextField.Property.PrimaryCursorPosition))
1432                 {
1433                     propertyValue.Get(out temp);
1434                 }
1435                 return temp;
1436             }
1437             set
1438             {
1439                 using (PropertyValue propertyValue = new PropertyValue(value))
1440                 {
1441                     SetProperty(TextField.Property.PrimaryCursorPosition, propertyValue);
1442                     NotifyPropertyChanged();
1443                 }
1444             }
1445         }
1446
1447         /// <summary>
1448         /// The GrabHandleColor property.
1449         /// </summary>
1450         /// <remarks>
1451         /// The property cascade chaining set is possible. For example, this (textField.GrabHandleColor.X = 0.1f;) is possible.
1452         /// </remarks>
1453         [EditorBrowsable(EditorBrowsableState.Never)]
1454         public Color GrabHandleColor
1455         {
1456             get
1457             {
1458                 Color temp = (Color)GetValue(GrabHandleColorProperty);
1459                 return new Color(OnGrabHandleColorChanged, temp.R, temp.G, temp.B, temp.A);
1460             }
1461             set
1462             {
1463                 SetValue(GrabHandleColorProperty, value);
1464                 NotifyPropertyChanged();
1465             }
1466         }
1467
1468         /// <summary>
1469         /// The ellipsis position of the text.
1470         /// The ellipsis position type when the text size over the layout size.<br />
1471         /// The ellipsis position: End, Start or Middle.<br />
1472         /// </summary>
1473         [EditorBrowsable(EditorBrowsableState.Never)]
1474         public EllipsisPosition EllipsisPosition
1475         {
1476             get
1477             {
1478                 return (EllipsisPosition)GetValue(EllipsisPositionProperty);
1479             }
1480             set
1481             {
1482                 SetValue(EllipsisPositionProperty, value);
1483                 NotifyPropertyChanged();
1484             }
1485         }
1486
1487         /// <summary>
1488         /// Set InputFilter to TextField. <br />
1489         /// </summary>
1490         /// <param name="inputFilter">The InputFilter</param>
1491         /// <remarks>
1492         /// <see cref="Tizen.NUI.Text.InputFilter"/> filters input based on regular expressions. <br />
1493         /// Users can set the Accepted or Rejected regular expression set, or both. <br />
1494         /// If both are used, Rejected has higher priority. <br />
1495         /// InputFiltered signal is emitted when the input is filtered by InputFilter <br />
1496         /// See <see cref="InputFiltered"/>, <see cref="InputFilterType"/> and <see cref="InputFilteredEventArgs"/> for a detailed description. <br />
1497         /// </remarks>
1498         /// <example>
1499         /// The following example demonstrates how to use the SetInputFilter method.
1500         /// <code>
1501         /// Tizen.NUI.Text.InputFilter inputFilter;
1502         /// inputFilter.Accepted = new Regex(@"[\d]"); // accept whole digits
1503         /// inputFilter.Rejected = new Regex("[0-3]"); // reject 0, 1, 2, 3
1504         /// field.SetInputFilter(inputFilter); // acceptable inputs are 4, 5, 6, 7, 8, 9
1505         /// </code>
1506         /// </example>
1507         [EditorBrowsable(EditorBrowsableState.Never)]
1508         public void SetInputFilter(InputFilter inputFilter)
1509         {
1510             SetProperty(TextField.Property.InputFilter, new PropertyValue(TextUtils.GetInputFilterMap(inputFilter)));
1511         }
1512
1513         /// <summary>
1514         /// Get InputFilter from TextField. <br />
1515         /// </summary>
1516         /// <returns>The InputFilter</returns>
1517         /// <remarks>
1518         /// <see cref="Tizen.NUI.Text.InputFilter"/>
1519         /// </remarks>
1520         [EditorBrowsable(EditorBrowsableState.Never)]
1521         public InputFilter GetInputFilter()
1522         {
1523             var map = new PropertyMap();
1524             GetProperty(TextField.Property.InputFilter).Get(map);
1525             return TextUtils.GetInputFilterStruct(map);
1526         }
1527
1528         /// <summary>
1529         /// The Placeholder property.
1530         /// The placeholder map contains the following keys :<br />
1531         /// <list type="table">
1532         /// <item><term>text (string)</term><description>The text to display when the TextField is empty and inactive</description></item>
1533         /// <item><term>textFocused (string)</term><description>The text to display when the placeholder has focus</description></item>
1534         /// <item><term>color (Color)</term><description>The color of the placeholder text</description></item>
1535         /// <item><term>fontFamily (string)</term><description>The fontFamily of the placeholder text</description></item>
1536         /// <item><term>fontStyle (PropertyMap)</term><description>The fontStyle of the placeholder text</description></item>
1537         /// <item><term>pointSize (float)</term><description>The pointSize of the placeholder text</description></item>
1538         /// <item><term>pixelSize (float)</term><description>The pixelSize of the placeholder text</description></item>
1539         /// <item><term>ellipsis (bool)</term><description>The ellipsis of the placeholder text</description></item>
1540         /// </list>
1541         /// </summary>
1542         /// <example>
1543         /// The following example demonstrates how to set the Placeholder property.
1544         /// <code>
1545         /// PropertyMap propertyMap = new PropertyMap();
1546         /// propertyMap.Add("text", new PropertyValue("Setting Placeholder Text"));
1547         /// propertyMap.Add("textFocused", new PropertyValue("Setting Placeholder Text Focused"));
1548         /// propertyMap.Add("color", new PropertyValue(Color.Red));
1549         /// propertyMap.Add("fontFamily", new PropertyValue("Arial"));
1550         /// propertyMap.Add("pointSize", new PropertyValue(12.0f));
1551         ///
1552         /// PropertyMap fontStyleMap = new PropertyMap();
1553         /// fontStyleMap.Add("weight", new PropertyValue("bold"));
1554         /// fontStyleMap.Add("width", new PropertyValue("condensed"));
1555         /// fontStyleMap.Add("slant", new PropertyValue("italic"));
1556         /// propertyMap.Add("fontStyle", new PropertyValue(fontStyleMap));
1557         ///
1558         /// TextField field = new TextField();
1559         /// field.Placeholder = propertyMap;
1560         /// </code>
1561         /// </example>
1562         /// <since_tizen> 3 </since_tizen>
1563         public Tizen.NUI.PropertyMap Placeholder
1564         {
1565             get
1566             {
1567                 PropertyMap map = (PropertyMap)GetValue(PlaceholderProperty);
1568                 PropertyValue value = null;
1569
1570                 // text
1571                 value = map.Find(0);
1572                 if (null != value)
1573                 {
1574                     value.Get(out string text);
1575                     map.Add("text", new PropertyValue(text));
1576                 }
1577
1578                 // textFocused
1579                 value = map.Find(1);
1580                 if (null != value)
1581                 {
1582                     value.Get(out string textFocused);
1583                     map.Add("textFocused", new PropertyValue(textFocused));
1584                 }
1585
1586                 // color
1587                 value = map.Find(2);
1588                 if (null != value)
1589                 {
1590                     Color color = new Color();
1591                     value.Get(color);
1592                     map.Add("color", new PropertyValue(color));
1593                 }
1594
1595                 // fontFamily
1596                 value = map.Find(3);
1597                 if (null != value)
1598                 {
1599                     value.Get(out string fontFamily);
1600                     map.Add("fontFamily", new PropertyValue(fontFamily));
1601                 }
1602
1603                 // fontStyle
1604                 value = map.Find(4);
1605                 if (null != value)
1606                 {
1607                     PropertyMap fontStyle = new PropertyMap();
1608                     value.Get(fontStyle);
1609                     map.Add("fontStyle", new PropertyValue(fontStyle));
1610                 }
1611
1612                 // pointSize
1613                 value = map.Find(5);
1614                 if (null != value)
1615                 {
1616                     value.Get(out float pointSize);
1617                     map.Add("pointSize", new PropertyValue(pointSize));
1618                 }
1619
1620                 // pixelSize
1621                 value = map.Find(6);
1622                 if (null != value)
1623                 {
1624                     value.Get(out float pixelSize);
1625                     map.Add("pixelSize", new PropertyValue(pixelSize));
1626                 }
1627
1628                 // ellipsis
1629                 value = map.Find(7);
1630                 if (null != value)
1631                 {
1632                     value.Get(out bool ellipsis);
1633                     map.Add("ellipsis", new PropertyValue(ellipsis));
1634                 }
1635
1636                 return map;
1637             }
1638             set
1639             {
1640                 SetValue(PlaceholderProperty, value);
1641                 NotifyPropertyChanged();
1642             }
1643         }
1644
1645         /// <summary>
1646         /// The Ellipsis property.<br />
1647         /// Enable or disable the ellipsis.<br />
1648         /// Placeholder PropertyMap is used to add ellipsis to placeholder text.
1649         /// </summary>
1650         /// <since_tizen> 4 </since_tizen>
1651         public bool Ellipsis
1652         {
1653             get
1654             {
1655                 return (bool)GetValue(EllipsisProperty);
1656             }
1657             set
1658             {
1659                 SetValue(EllipsisProperty, value);
1660                 NotifyPropertyChanged();
1661             }
1662         }
1663
1664         /// <summary>
1665         /// Enables selection of the text using the Shift key.
1666         /// </summary>
1667         /// <since_tizen> 5 </since_tizen>
1668         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1669         [EditorBrowsable(EditorBrowsableState.Never)]
1670         public bool EnableShiftSelection
1671         {
1672             get
1673             {
1674                 return (bool)GetValue(EnableShiftSelectionProperty);
1675             }
1676             set
1677             {
1678                 SetValue(EnableShiftSelectionProperty, value);
1679                 NotifyPropertyChanged();
1680             }
1681         }
1682
1683         /// <summary>
1684         /// The text alignment to match the direction of the system language.
1685         /// </summary>
1686         /// <since_tizen> 6 </since_tizen>
1687         public bool MatchSystemLanguageDirection
1688         {
1689             get
1690             {
1691                 return (bool)GetValue(MatchSystemLanguageDirectionProperty);
1692             }
1693             set
1694             {
1695                 SetValue(MatchSystemLanguageDirectionProperty, value);
1696                 NotifyPropertyChanged();
1697             }
1698         }
1699
1700         /// <summary>
1701         /// The FontSizeScale property. <br />
1702         /// The default value is 1.0. <br />
1703         /// If FontSizeScale.UseSystemSetting, will use the SystemSettings.FontSize internally. <br />
1704         /// </summary>
1705         /// <since_tizen> 9 </since_tizen>
1706         public float FontSizeScale
1707         {
1708             get
1709             {
1710                 return fontSizeScale;
1711             }
1712             set
1713             {
1714                 float newFontSizeScale;
1715
1716                 if (fontSizeScale == value) return;
1717
1718                 fontSizeScale = value;
1719                 if (fontSizeScale == Tizen.NUI.FontSizeScale.UseSystemSetting)
1720                 {
1721                     SystemSettingsFontSize systemSettingsFontSize;
1722
1723                     try
1724                     {
1725                         systemSettingsFontSize = SystemSettings.FontSize;
1726                     }
1727                     catch (Exception e)
1728                     {
1729                         Console.WriteLine("{0} Exception caught.", e);
1730                         systemSettingsFontSize = SystemSettingsFontSize.Normal;
1731                     }
1732                     newFontSizeScale = TextUtils.GetFontSizeScale(systemSettingsFontSize);
1733                     addFontSizeChangedCallback();
1734                 }
1735                 else
1736                 {
1737                     newFontSizeScale = fontSizeScale;
1738                     removeFontSizeChangedCallback();
1739                 }
1740
1741                 SetValue(FontSizeScaleProperty, newFontSizeScale);
1742                 NotifyPropertyChanged();
1743             }
1744         }
1745
1746         /// Only used by the IL of xaml, will never changed to not hidden.
1747         [EditorBrowsable(EditorBrowsableState.Never)]
1748         public override bool IsCreateByXaml
1749         {
1750             get
1751             {
1752                 return base.IsCreateByXaml;
1753             }
1754             set
1755             {
1756                 base.IsCreateByXaml = value;
1757
1758                 if (value == true)
1759                 {
1760                     this.TextChanged += (obj, e) =>
1761                     {
1762                         this.Text = e.TextField.Text;
1763                     };
1764                 }
1765             }
1766         }
1767
1768         /// <summary>
1769         /// Get the InputMethodContext instance.
1770         /// </summary>
1771         /// <returns>The InputMethodContext instance.</returns>
1772         /// <since_tizen> 5 </since_tizen>
1773         public InputMethodContext GetInputMethodContext()
1774         {
1775             if (inputMethodCotext == null)
1776             {
1777                 /*Avoid raising InputMethodContext reference count.*/
1778                 inputMethodCotext = new InputMethodContext(Interop.TextField.GetInputMethodContext(SwigCPtr), true);
1779                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1780             }
1781             return inputMethodCotext;
1782         }
1783
1784         /// <summary>
1785         /// Select the whole text.
1786         /// </summary>
1787         /// <since_tizen> 6 </since_tizen>
1788         /// This will be released at Tizen.NET API Level 5.5, so currently this would be used as inhouse API.
1789         [EditorBrowsable(EditorBrowsableState.Never)]
1790         public void SelectWholeText()
1791         {
1792             Interop.TextField.SelectWholeText(SwigCPtr);
1793             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1794         }
1795
1796         /// <summary>
1797         /// Select text from start to end index.
1798         /// </summary>
1799         /// <param name="start">The start index for selection.</param>
1800         /// <param name="end">The end index for selection.</param>
1801         [EditorBrowsable(EditorBrowsableState.Never)]
1802         public void SelectText(uint start, uint end)
1803         {
1804             Interop.TextField.SelectText(SwigCPtr, start, end);
1805             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1806         }
1807
1808         /// <summary>
1809         /// Clear selection of the text.
1810         /// </summary>
1811         /// <since_tizen> 8 </since_tizen>
1812         /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
1813         [EditorBrowsable(EditorBrowsableState.Never)]
1814         public void SelectNone()
1815         {
1816             _ = Interop.TextField.SelectNone(SwigCPtr);
1817             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1818         }
1819
1820         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TextField obj)
1821         {
1822             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
1823         }
1824
1825         internal SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__TextField_Dali__Toolkit__TextField__InputStyle__MaskF_t InputStyleChangedSignal()
1826         {
1827             SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__TextField_Dali__Toolkit__TextField__InputStyle__MaskF_t ret = new SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__TextField_Dali__Toolkit__TextField__InputStyle__MaskF_t(Interop.TextField.InputStyleChangedSignal(SwigCPtr));
1828             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1829             return ret;
1830         }
1831
1832         /// <summary>
1833         /// Dispose.
1834         /// </summary>
1835         /// <since_tizen> 3 </since_tizen>
1836         protected override void Dispose(DisposeTypes type)
1837         {
1838             if (disposed)
1839             {
1840                 DisposeQueue.Instance.Add(this);
1841                 return;
1842             }
1843
1844             if (systemlangTextFlag)
1845             {
1846                 SystemSettings.LocaleLanguageChanged -= SystemSettings_LocaleLanguageChanged;
1847             }
1848
1849             removeFontSizeChangedCallback();
1850
1851             if (type == DisposeTypes.Explicit)
1852             {
1853                 //Called by User
1854                 //Release your own managed resources here.
1855                 //You should release all of your own disposable objects here.
1856             }
1857
1858             //Release your own unmanaged resources here.
1859             //You should not access any managed member here except static instance.
1860             //because the execution order of Finalizes is non-deterministic.
1861             if (this.HasBody())
1862             {
1863                 if (textFieldMaxLengthReachedCallbackDelegate != null)
1864                 {
1865                     this.MaxLengthReachedSignal().Disconnect(textFieldMaxLengthReachedCallbackDelegate);
1866                 }
1867
1868                 if (textFieldTextChangedCallbackDelegate != null)
1869                 {
1870                     TextChangedSignal().Disconnect(textFieldTextChangedCallbackDelegate);
1871                 }
1872             }
1873
1874             base.Dispose(type);
1875         }
1876
1877         /// This will not be public opened.
1878         [EditorBrowsable(EditorBrowsableState.Never)]
1879         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
1880         {
1881             // In order to speed up IME hide, temporarily add
1882             GetInputMethodContext()?.DestroyContext();
1883             Interop.TextField.DeleteTextField(swigCPtr);
1884         }
1885
1886         private string SetTranslatable(string textFieldSid)
1887         {
1888             string translatableText = null;
1889             translatableText = NUIApplication.MultilingualResourceManager?.GetString(textFieldSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
1890             if (translatableText != null)
1891             {
1892                 if (systemlangTextFlag == false)
1893                 {
1894                     SystemSettings.LocaleLanguageChanged += SystemSettings_LocaleLanguageChanged;
1895                     systemlangTextFlag = true;
1896                 }
1897                 return translatableText;
1898             }
1899             else
1900             {
1901                 translatableText = "";
1902                 return translatableText;
1903             }
1904         }
1905
1906         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
1907         {
1908             if (textFieldTextSid != null)
1909             {
1910                 Text = NUIApplication.MultilingualResourceManager?.GetString(textFieldTextSid, new CultureInfo(e.Value.Replace("_", "-")));
1911             }
1912             if (textFieldPlaceHolderTextSid != null)
1913             {
1914                 PlaceholderText = NUIApplication.MultilingualResourceManager?.GetString(textFieldPlaceHolderTextSid, new CultureInfo(e.Value.Replace("_", "-")));
1915             }
1916             if (textFieldPlaceHolderTextFocusedSid != null)
1917             {
1918                 PlaceholderTextFocused = NUIApplication.MultilingualResourceManager?.GetString(textFieldPlaceHolderTextFocusedSid, new CultureInfo(e.Value.Replace("_", "-")));
1919             }
1920         }
1921
1922         private void SystemSettingsFontSizeChanged(object sender, FontSizeChangedEventArgs e)
1923         {
1924             float newFontSizeScale = TextUtils.GetFontSizeScale(e.Value);
1925             SetValue(FontSizeScaleProperty, newFontSizeScale);
1926             NotifyPropertyChanged();
1927         }
1928
1929         private void addFontSizeChangedCallback()
1930         {
1931             if (hasFontSizeChangedCallback != true)
1932             {
1933                 try
1934                 {
1935                     SystemSettings.FontSizeChanged += SystemSettingsFontSizeChanged;
1936                     hasFontSizeChangedCallback = true;
1937                 }
1938                 catch (Exception e)
1939                 {
1940                     Console.WriteLine("{0} Exception caught.", e);
1941                     hasFontSizeChangedCallback = false;
1942                 }
1943             }
1944         }
1945
1946         private void removeFontSizeChangedCallback()
1947         {
1948             if (hasFontSizeChangedCallback == true)
1949             {
1950                 try
1951                 {
1952                     SystemSettings.FontSizeChanged -= SystemSettingsFontSizeChanged;
1953                     hasFontSizeChangedCallback = false;
1954                 }
1955                 catch (Exception e)
1956                 {
1957                     Console.WriteLine("{0} Exception caught.", e);
1958                     hasFontSizeChangedCallback = true;
1959                 }
1960             }
1961         }
1962
1963         internal new class Property
1964         {
1965             internal static readonly int TEXT = Interop.TextField.TextGet();
1966             internal static readonly int PlaceholderText = Interop.TextField.PlaceholderTextGet();
1967             internal static readonly int PlaceholderTextFocused = Interop.TextField.PlaceholderTextFocusedGet();
1968             internal static readonly int FontFamily = Interop.TextField.FontFamilyGet();
1969             internal static readonly int FontStyle = Interop.TextField.FontStyleGet();
1970             internal static readonly int PointSize = Interop.TextField.PointSizeGet();
1971             internal static readonly int MaxLength = Interop.TextField.MaxLengthGet();
1972             internal static readonly int ExceedPolicy = Interop.TextField.ExceedPolicyGet();
1973             internal static readonly int HorizontalAlignment = Interop.TextField.HorizontalAlignmentGet();
1974             internal static readonly int VerticalAlignment = Interop.TextField.VerticalAlignmentGet();
1975             internal static readonly int TextColor = Interop.TextField.TextColorGet();
1976             internal static readonly int PlaceholderTextColor = Interop.TextField.PlaceholderTextColorGet();
1977             internal static readonly int PrimaryCursorColor = Interop.TextField.PrimaryCursorColorGet();
1978             internal static readonly int SecondaryCursorColor = Interop.TextField.SecondaryCursorColorGet();
1979             internal static readonly int EnableCursorBlink = Interop.TextField.EnableCursorBlinkGet();
1980             internal static readonly int CursorBlinkInterval = Interop.TextField.CursorBlinkIntervalGet();
1981             internal static readonly int CursorBlinkDuration = Interop.TextField.CursorBlinkDurationGet();
1982             internal static readonly int CursorWidth = Interop.TextField.CursorWidthGet();
1983             internal static readonly int GrabHandleImage = Interop.TextField.GrabHandleImageGet();
1984             internal static readonly int GrabHandlePressedImage = Interop.TextField.GrabHandlePressedImageGet();
1985             internal static readonly int ScrollThreshold = Interop.TextField.ScrollThresholdGet();
1986             internal static readonly int ScrollSpeed = Interop.TextField.ScrollSpeedGet();
1987             internal static readonly int SelectionHandleImageLeft = Interop.TextField.SelectionHandleImageLeftGet();
1988             internal static readonly int SelectionHandleImageRight = Interop.TextField.SelectionHandleImageRightGet();
1989             internal static readonly int SelectionHandlePressedImageLeft = Interop.TextField.SelectionHandlePressedImageLeftGet();
1990             internal static readonly int SelectionHandlePressedImageRight = Interop.TextField.SelectionHandlePressedImageRightGet();
1991             internal static readonly int SelectionHandleMarkerImageLeft = Interop.TextField.SelectionHandleMarkerImageLeftGet();
1992             internal static readonly int SelectionHandleMarkerImageRight = Interop.TextField.SelectionHandleMarkerImageRightGet();
1993             internal static readonly int SelectionHighlightColor = Interop.TextField.SelectionHighlightColorGet();
1994             internal static readonly int DecorationBoundingBox = Interop.TextField.DecorationBoundingBoxGet();
1995             internal static readonly int InputMethodSettings = Interop.TextField.InputMethodSettingsGet();
1996             internal static readonly int InputColor = Interop.TextField.InputColorGet();
1997             internal static readonly int EnableMarkup = Interop.TextField.EnableMarkupGet();
1998             internal static readonly int InputFontFamily = Interop.TextField.InputFontFamilyGet();
1999             internal static readonly int InputFontStyle = Interop.TextField.InputFontStyleGet();
2000             internal static readonly int InputPointSize = Interop.TextField.InputPointSizeGet();
2001             internal static readonly int UNDERLINE = Interop.TextField.UnderlineGet();
2002             internal static readonly int InputUnderline = Interop.TextField.InputUnderlineGet();
2003             internal static readonly int SHADOW = Interop.TextField.ShadowGet();
2004             internal static readonly int InputShadow = Interop.TextField.InputShadowGet();
2005             internal static readonly int EMBOSS = Interop.TextField.EmbossGet();
2006             internal static readonly int InputEmboss = Interop.TextField.InputEmbossGet();
2007             internal static readonly int OUTLINE = Interop.TextField.OutlineGet();
2008             internal static readonly int InputOutline = Interop.TextField.InputOutlineGet();
2009             internal static readonly int HiddenInputSettings = Interop.TextField.HiddenInputSettingsGet();
2010             internal static readonly int PixelSize = Interop.TextField.PixelSizeGet();
2011             internal static readonly int EnableSelection = Interop.TextField.EnableSelectionGet();
2012             internal static readonly int PLACEHOLDER = Interop.TextField.PlaceholderGet();
2013             internal static readonly int ELLIPSIS = Interop.TextField.EllipsisGet();
2014             internal static readonly int EnableShiftSelection = Interop.TextField.EnableShiftSelectionGet();
2015             internal static readonly int MatchSystemLanguageDirection = Interop.TextField.MatchSystemLanguageDirectionGet();
2016             internal static readonly int EnableGrabHandle = Interop.TextField.EnableGrabHandleGet();
2017             internal static readonly int EnableGrabHandlePopup = Interop.TextField.EnableGrabHandlePopupGet();
2018             internal static readonly int SelectedText = Interop.TextField.SelectedTextGet();
2019             internal static readonly int SelectedTextStart = Interop.TextField.SelectedTextStartGet();
2020             internal static readonly int SelectedTextEnd = Interop.TextField.SelectedTextEndGet();
2021             internal static readonly int EnableEditing = Interop.TextField.EnableEditingGet();
2022             internal static readonly int PrimaryCursorPosition = Interop.TextField.PrimaryCursorPositionGet();
2023             internal static readonly int FontSizeScale = Interop.TextField.FontSizeScaleGet();
2024             internal static readonly int GrabHandleColor = Interop.TextField.GrabHandleColorGet();
2025             internal static readonly int EllipsisPosition = Interop.TextField.EllipsisPositionGet();
2026             internal static readonly int InputFilter = Interop.TextField.InputFilterGet();
2027         }
2028
2029         internal class InputStyle
2030         {
2031             internal enum Mask
2032             {
2033                 None = 0x0000,
2034                 Color = 0x0001,
2035                 FontFamily = 0x0002,
2036                 PointSize = 0x0004,
2037                 FontStyle = 0x0008,
2038                 Underline = 0x0010,
2039                 Shadow = 0x0020,
2040                 Emboss = 0x0040,
2041                 Outline = 0x0080
2042             }
2043         }
2044
2045         private void OnDecorationBoundingBoxChanged(int x, int y, int width, int height)
2046         {
2047             DecorationBoundingBox = new Rectangle(x, y, width, height);
2048         }
2049         private void OnInputColorChanged(float x, float y, float z, float w)
2050         {
2051             InputColor = new Vector4(x, y, z, w);
2052         }
2053         private void OnPlaceholderTextColorChanged(float r, float g, float b, float a)
2054         {
2055             PlaceholderTextColor = new Vector4(r, g, b, a);
2056         }
2057         private void OnPrimaryCursorColorChanged(float x, float y, float z, float w)
2058         {
2059             PrimaryCursorColor = new Vector4(x, y, z, w);
2060         }
2061         private void OnSecondaryCursorColorChanged(float x, float y, float z, float w)
2062         {
2063             SecondaryCursorColor = new Vector4(x, y, z, w);
2064         }
2065         private void OnSelectionHighlightColorChanged(float x, float y, float z, float w)
2066         {
2067             SelectionHighlightColor = new Vector4(x, y, z, w);
2068         }
2069         private void OnShadowColorChanged(float x, float y, float z, float w)
2070         {
2071             ShadowColor = new Vector4(x, y, z, w);
2072         }
2073         private void OnShadowOffsetChanged(float x, float y)
2074         {
2075             ShadowOffset = new Vector2(x, y);
2076         }
2077         private void OnTextColorChanged(float r, float g, float b, float a)
2078         {
2079             TextColor = new Color(r, g, b, a);
2080         }
2081         private void OnGrabHandleColorChanged(float r, float g, float b, float a)
2082         {
2083             GrabHandleColor = new Color(r, g, b, a);
2084         }
2085     }
2086 }