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