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

   1 /*
   2  * Copyright(c) 2018 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
  25 namespace Tizen.NUI.BaseComponents
  26 {
  27     /// <summary>
  28     /// A control which provides a multi-line editable text editor.
  29     /// </summary>
  30     /// <since_tizen> 3 </since_tizen>
  31     public partial class TextEditor : View
  32     {
  33         private string textEditorTextSid = null;
  34         private string textEditorPlaceHolderTextSid = null;
  35         private bool systemlangTextFlag = false;
  36         private InputMethodContext inputMethodContext = null;
  37
  38         /// <summary>
  39         /// Creates the TextEditor control.
  40         /// </summary>
  41         /// <since_tizen> 3 </since_tizen>
  42         public TextEditor() : this(Interop.TextEditor.TextEditor_New(), true)
  43         {
  44             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  45         }
  46
  47         /// <summary>
  48         /// Creates the TextEditor with setting the status of shown or hidden.
  49         /// </summary>
  50         /// <param name="shown">false : Not displayed (hidden), true : displayed (shown)</param>
  51         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
  52         [EditorBrowsable(EditorBrowsableState.Never)]
  53         public TextEditor(bool shown) : this(Interop.TextEditor.TextEditor_New(), true)
  54         {
  55             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  56             SetVisible(shown);
  57         }
  58
  59         internal TextEditor(TextEditor handle, bool shown = true) : this(Interop.TextEditor.new_TextEditor__SWIG_1(TextEditor.getCPtr(handle)), true)
  60         {
  61             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  62
  63             if (!shown)
  64             {
  65                 SetVisible(false);
  66             }
  67         }
  68
  69         internal TextEditor(global::System.IntPtr cPtr, bool cMemoryOwn, bool shown = true) : base(Interop.TextEditor.TextEditor_SWIGUpcast(cPtr), cMemoryOwn)
  70         {
  71             if (!shown)
  72             {
  73                 SetVisible(false);
  74             }
  75         }
  76
  77         /// <summary>
  78         /// The TranslatableText property.<br />
  79         /// The text can set the SID value.<br />
  80         /// </summary>
  81         /// <exception cref='ArgumentNullException'>
  82         /// ResourceManager about multilingual is null.
  83         /// </exception>
  84         /// <since_tizen> 4 </since_tizen>
  85         public string TranslatableText
  86         {
  87             get
  88             {
  89                 return textEditorTextSid;
  90             }
  91             set
  92             {
  93                 if (NUIApplication.MultilingualResourceManager == null)
  94                 {
  95                     throw new ArgumentNullException(null, "ResourceManager about multilingual is null");
  96                 }
  97                 textEditorTextSid = value;
  98                 Text = SetTranslatable(textEditorTextSid);
  99                 NotifyPropertyChanged();
 100             }
 101         }
 102         /// <summary>
 103         /// The TranslatablePlaceholderText property.<br />
 104         /// The text can set the SID value.<br />
 105         /// </summary>
 106         /// <exception cref='ArgumentNullException'>
 107         /// ResourceManager about multilingual is null.
 108         /// </exception>
 109         /// <since_tizen> 4 </since_tizen>
 110         public string TranslatablePlaceholderText
 111         {
 112             get
 113             {
 114                 return textEditorPlaceHolderTextSid;
 115             }
 116             set
 117             {
 118                 if (NUIApplication.MultilingualResourceManager == null)
 119                 {
 120                     throw new ArgumentNullException(null, "ResourceManager about multilingual is null");
 121                 }
 122                 textEditorPlaceHolderTextSid = value;
 123                 PlaceholderText = SetTranslatable(textEditorPlaceHolderTextSid);
 124                 NotifyPropertyChanged();
 125             }
 126         }
 127
 128         /// <summary>
 129         /// The Text property.
 130         /// </summary>
 131         /// <since_tizen> 3 </since_tizen>
 132         public string Text
 133         {
 134             get
 135             {
 136                 return (string)GetValue(TextProperty);
 137             }
 138             set
 139             {
 140                 SetValueAndForceSendChangeSignal(TextProperty, value);
 141                 NotifyPropertyChanged();
 142             }
 143         }
 144
 145         /// <summary>
 146         /// The TextColor property.
 147         /// </summary>
 148         /// <remarks>
 149         /// The property cascade chaining set is possible. For example, this (textEditor.TextColor.X = 0.1f;) is possible.
 150         /// </remarks>
 151         /// <since_tizen> 3 </since_tizen>
 152         public Vector4 TextColor
 153         {
 154             get
 155             {
 156                 Vector4 temp = (Vector4)GetValue(TextColorProperty);
 157                 return new Vector4(OnTextColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 158             }
 159             set
 160             {
 161                 SetValue(TextColorProperty, value);
 162                 NotifyPropertyChanged();
 163             }
 164         }
 165
 166         /// <summary>
 167         /// The FontFamily property.
 168         /// </summary>
 169         /// <since_tizen> 3 </since_tizen>
 170         public string FontFamily
 171         {
 172             get
 173             {
 174                 return (string)GetValue(FontFamilyProperty);
 175             }
 176             set
 177             {
 178                 SetValue(FontFamilyProperty, value);
 179                 NotifyPropertyChanged();
 180             }
 181         }
 182
 183         /// <summary>
 184         /// The FontStyle property.
 185         /// </summary>
 186         /// <since_tizen> 3 </since_tizen>
 187         public PropertyMap FontStyle
 188         {
 189             get
 190             {
 191                 return (PropertyMap)GetValue(FontStyleProperty);
 192             }
 193             set
 194             {
 195                 SetValue(FontStyleProperty, value);
 196                 NotifyPropertyChanged();
 197             }
 198         }
 199
 200         /// <summary>
 201         /// The PointSize property.
 202         /// </summary>
 203         /// <since_tizen> 3 </since_tizen>
 204         public float PointSize
 205         {
 206             get
 207             {
 208                 return (float)GetValue(PointSizeProperty);
 209             }
 210             set
 211             {
 212                 SetValue(PointSizeProperty, value);
 213                 NotifyPropertyChanged();
 214             }
 215         }
 216
 217         /// <summary>
 218         /// The HorizontalAlignment property.
 219         /// </summary>
 220         /// <since_tizen> 3 </since_tizen>
 221         public HorizontalAlignment HorizontalAlignment
 222         {
 223             get
 224             {
 225                 return (HorizontalAlignment)GetValue(HorizontalAlignmentProperty);
 226             }
 227             set
 228             {
 229                 SetValue(HorizontalAlignmentProperty, value);
 230                 NotifyPropertyChanged();
 231             }
 232         }
 233
 234         /// <summary>
 235         /// The ScrollThreshold property.
 236         /// </summary>
 237         /// <since_tizen> 3 </since_tizen>
 238         public float ScrollThreshold
 239         {
 240             get
 241             {
 242                 return (float)GetValue(ScrollThresholdProperty);
 243             }
 244             set
 245             {
 246                 SetValue(ScrollThresholdProperty, value);
 247                 NotifyPropertyChanged();
 248             }
 249         }
 250
 251         /// <summary>
 252         /// The ScrollSpeed property.
 253         /// </summary>
 254         /// <since_tizen> 3 </since_tizen>
 255         public float ScrollSpeed
 256         {
 257             get
 258             {
 259                 return (float)GetValue(ScrollSpeedProperty);
 260             }
 261             set
 262             {
 263                 SetValue(ScrollSpeedProperty, value);
 264                 NotifyPropertyChanged();
 265             }
 266         }
 267
 268         /// <summary>
 269         /// The PrimaryCursorColor property.
 270         /// </summary>
 271         /// <remarks>
 272         /// The property cascade chaining set is possible. For example, this (textEditor.PrimaryCursorColor.X = 0.1f;) is possible.
 273         /// </remarks>
 274         /// <since_tizen> 3 </since_tizen>
 275         public Vector4 PrimaryCursorColor
 276         {
 277             get
 278             {
 279                 Vector4 temp = (Vector4)GetValue(PrimaryCursorColorProperty);
 280                 return new Vector4(OnPrimaryCursorColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 281             }
 282             set
 283             {
 284                 SetValue(PrimaryCursorColorProperty, value);
 285                 NotifyPropertyChanged();
 286             }
 287         }
 288
 289         /// <summary>
 290         /// The SecondaryCursorColor property.
 291         /// </summary>
 292         /// <remarks>
 293         /// The property cascade chaining set is possible. For example, this (textEditor.SecondaryCursorColor.X = 0.1f;) is possible.
 294         /// </remarks>
 295         /// <since_tizen> 3 </since_tizen>
 296         public Vector4 SecondaryCursorColor
 297         {
 298             get
 299             {
 300                 Vector4 temp = (Vector4)GetValue(SecondaryCursorColorProperty);
 301                 return new Vector4(OnSecondaryCursorColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 302             }
 303             set
 304             {
 305                 SetValue(SecondaryCursorColorProperty, value);
 306                 NotifyPropertyChanged();
 307             }
 308         }
 309
 310         /// <summary>
 311         /// The EnableCursorBlink property.
 312         /// </summary>
 313         /// <since_tizen> 3 </since_tizen>
 314         public bool EnableCursorBlink
 315         {
 316             get
 317             {
 318                 return (bool)GetValue(EnableCursorBlinkProperty);
 319             }
 320             set
 321             {
 322                 SetValue(EnableCursorBlinkProperty, value);
 323                 NotifyPropertyChanged();
 324             }
 325         }
 326
 327         /// <summary>
 328         /// The CursorBlinkInterval property.
 329         /// </summary>
 330         /// <since_tizen> 3 </since_tizen>
 331         public float CursorBlinkInterval
 332         {
 333             get
 334             {
 335                 return (float)GetValue(CursorBlinkIntervalProperty);
 336             }
 337             set
 338             {
 339                 SetValue(CursorBlinkIntervalProperty, value);
 340                 NotifyPropertyChanged();
 341             }
 342         }
 343
 344         /// <summary>
 345         /// The CursorBlinkDuration property.
 346         /// </summary>
 347         /// <since_tizen> 3 </since_tizen>
 348         public float CursorBlinkDuration
 349         {
 350             get
 351             {
 352                 return (float)GetValue(CursorBlinkDurationProperty);
 353             }
 354             set
 355             {
 356                 SetValue(CursorBlinkDurationProperty, value);
 357                 NotifyPropertyChanged();
 358             }
 359         }
 360
 361         /// <summary>
 362         /// The CursorWidth property.
 363         /// </summary>
 364         /// <since_tizen> 3 </since_tizen>
 365         public int CursorWidth
 366         {
 367             get
 368             {
 369                 return (int)GetValue(CursorWidthProperty);
 370             }
 371             set
 372             {
 373                 SetValue(CursorWidthProperty, value);
 374                 NotifyPropertyChanged();
 375             }
 376         }
 377
 378         /// <summary>
 379         /// The GrabHandleImage property.
 380         /// </summary>
 381         /// <since_tizen> 3 </since_tizen>
 382         public string GrabHandleImage
 383         {
 384             get
 385             {
 386                 return (string)GetValue(GrabHandleImageProperty);
 387             }
 388             set
 389             {
 390                 SetValue(GrabHandleImageProperty, value);
 391                 NotifyPropertyChanged();
 392             }
 393         }
 394
 395         /// <summary>
 396         /// The GrabHandlePressedImage property.
 397         /// </summary>
 398         /// <since_tizen> 3 </since_tizen>
 399         public string GrabHandlePressedImage
 400         {
 401             get
 402             {
 403                 return (string)GetValue(GrabHandlePressedImageProperty);
 404             }
 405             set
 406             {
 407                 SetValue(GrabHandlePressedImageProperty, value);
 408                 NotifyPropertyChanged();
 409             }
 410         }
 411
 412         /// <summary>
 413         /// The SelectionHandleImageLeft property.
 414         /// </summary>
 415         /// <since_tizen> 3 </since_tizen>
 416         public PropertyMap SelectionHandleImageLeft
 417         {
 418             get
 419             {
 420                 return (PropertyMap)GetValue(SelectionHandleImageLeftProperty);
 421             }
 422             set
 423             {
 424                 SetValue(SelectionHandleImageLeftProperty, value);
 425                 NotifyPropertyChanged();
 426             }
 427         }
 428
 429         /// <summary>
 430         /// The SelectionHandleImageRight property.
 431         /// </summary>
 432         /// <since_tizen> 3 </since_tizen>
 433         public PropertyMap SelectionHandleImageRight
 434         {
 435             get
 436             {
 437                 return (PropertyMap)GetValue(SelectionHandleImageRightProperty);
 438             }
 439             set
 440             {
 441                 SetValue(SelectionHandleImageRightProperty, value);
 442                 NotifyPropertyChanged();
 443             }
 444         }
 445
 446         /// <summary>
 447         /// The SelectionHandlePressedImageLeft property.
 448         /// </summary>
 449         /// <since_tizen> 3 </since_tizen>
 450         public PropertyMap SelectionHandlePressedImageLeft
 451         {
 452             get
 453             {
 454                 return (PropertyMap)GetValue(SelectionHandlePressedImageLeftProperty);
 455             }
 456             set
 457             {
 458                 SetValue(SelectionHandlePressedImageLeftProperty, value);
 459                 NotifyPropertyChanged();
 460             }
 461         }
 462
 463         /// <summary>
 464         /// The SelectionHandlePressedImageRight property.
 465         /// </summary>
 466         /// <since_tizen> 3 </since_tizen>
 467         public PropertyMap SelectionHandlePressedImageRight
 468         {
 469             get
 470             {
 471                 return (PropertyMap)GetValue(SelectionHandlePressedImageRightProperty);
 472             }
 473             set
 474             {
 475                 SetValue(SelectionHandlePressedImageRightProperty, value);
 476                 NotifyPropertyChanged();
 477             }
 478         }
 479
 480         /// <summary>
 481         /// The SelectionHandleMarkerImageLeft property.
 482         /// </summary>
 483         /// <since_tizen> 3 </since_tizen>
 484         public PropertyMap SelectionHandleMarkerImageLeft
 485         {
 486             get
 487             {
 488                 return (PropertyMap)GetValue(SelectionHandleMarkerImageLeftProperty);
 489             }
 490             set
 491             {
 492                 SetValue(SelectionHandleMarkerImageLeftProperty, value);
 493                 NotifyPropertyChanged();
 494             }
 495         }
 496
 497         /// <summary>
 498         /// The SelectionHandleMarkerImageRight property.
 499         /// </summary>
 500         /// <since_tizen> 3 </since_tizen>
 501         public PropertyMap SelectionHandleMarkerImageRight
 502         {
 503             get
 504             {
 505                 return (PropertyMap)GetValue(SelectionHandleMarkerImageRightProperty);
 506             }
 507             set
 508             {
 509                 SetValue(SelectionHandleMarkerImageRightProperty, value);
 510                 NotifyPropertyChanged();
 511             }
 512         }
 513
 514         /// <summary>
 515         /// The SelectionHighlightColor property.
 516         /// </summary>
 517         /// <remarks>
 518         /// The property cascade chaining set is possible. For example, this (textEditor.SelectionHighlightColor.X = 0.1f;) is possible.
 519         /// </remarks>
 520         /// <since_tizen> 3 </since_tizen>
 521         public Vector4 SelectionHighlightColor
 522         {
 523             get
 524             {
 525                 Vector4 temp = (Vector4)GetValue(SelectionHighlightColorProperty);
 526                 return new Vector4(OnSelectionHighlightColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 527             }
 528             set
 529             {
 530                 SetValue(SelectionHighlightColorProperty, value);
 531                 NotifyPropertyChanged();
 532             }
 533         }
 534
 535         /// <summary>
 536         /// The DecorationBoundingBox property.
 537         /// </summary>
 538         /// <remarks>
 539         /// The property cascade chaining set is possible. For example, this (textEditor.DecorationBoundingBox.X = 1;) is possible.
 540         /// </remarks>
 541         /// <since_tizen> 3 </since_tizen>
 542         public Rectangle DecorationBoundingBox
 543         {
 544             get
 545             {
 546                 Rectangle temp = (Rectangle)GetValue(DecorationBoundingBoxProperty);
 547                 return new Rectangle(OnDecorationBoundingBoxChanged, temp.X, temp.Y, temp.Width, temp.Height);
 548             }
 549             set
 550             {
 551                 SetValue(DecorationBoundingBoxProperty, value);
 552                 NotifyPropertyChanged();
 553             }
 554         }
 555
 556         /// <summary>
 557         /// The EnableMarkup property.
 558         /// </summary>
 559         /// <since_tizen> 3 </since_tizen>
 560         public bool EnableMarkup
 561         {
 562             get
 563             {
 564                 return (bool)GetValue(EnableMarkupProperty);
 565             }
 566             set
 567             {
 568                 SetValue(EnableMarkupProperty, value);
 569                 NotifyPropertyChanged();
 570             }
 571         }
 572
 573         /// <summary>
 574         /// The InputColor property.
 575         /// </summary>
 576         /// <remarks>
 577         /// The property cascade chaining set is possible. For example, this (textEditor.InputColor.X = 0.1f;) is possible.
 578         /// </remarks>
 579         /// <since_tizen> 3 </since_tizen>
 580         public Vector4 InputColor
 581         {
 582             get
 583             {
 584                 Vector4 temp = (Vector4)GetValue(InputColorProperty);
 585                 return new Vector4(OnInputColorChanged, temp.X, temp.Y, temp.Z, temp.W);
 586             }
 587             set
 588             {
 589                 SetValue(InputColorProperty, value);
 590                 NotifyPropertyChanged();
 591             }
 592         }
 593
 594         /// <summary>
 595         /// The InputFontFamily property.
 596         /// </summary>
 597         /// <since_tizen> 3 </since_tizen>
 598         public string InputFontFamily
 599         {
 600             get
 601             {
 602                 return (string)GetValue(InputFontFamilyProperty);
 603             }
 604             set
 605             {
 606                 SetValue(InputFontFamilyProperty, value);
 607                 NotifyPropertyChanged();
 608             }
 609         }
 610
 611         /// <summary>
 612         /// The InputFontStyle property.
 613         /// </summary>
 614         /// <since_tizen> 3 </since_tizen>
 615         public PropertyMap InputFontStyle
 616         {
 617             get
 618             {
 619                 return (PropertyMap)GetValue(InputFontStyleProperty);
 620             }
 621             set
 622             {
 623                 SetValue(InputFontStyleProperty, value);
 624                 NotifyPropertyChanged();
 625             }
 626         }
 627
 628         /// <summary>
 629         /// The InputPointSize property.
 630         /// </summary>
 631         /// <since_tizen> 3 </since_tizen>
 632         public float InputPointSize
 633         {
 634             get
 635             {
 636                 return (float)GetValue(InputPointSizeProperty);
 637             }
 638             set
 639             {
 640                 SetValue(InputPointSizeProperty, value);
 641                 NotifyPropertyChanged();
 642             }
 643         }
 644
 645         /// <summary>
 646         /// The LineSpacing property.
 647         /// </summary>
 648         /// <since_tizen> 3 </since_tizen>
 649         public float LineSpacing
 650         {
 651             get
 652             {
 653                 return (float)GetValue(LineSpacingProperty);
 654             }
 655             set
 656             {
 657                 SetValue(LineSpacingProperty, value);
 658                 NotifyPropertyChanged();
 659             }
 660         }
 661
 662         /// <summary>
 663         /// The InputLineSpacing property.
 664         /// </summary>
 665         /// <since_tizen> 3 </since_tizen>
 666         public float InputLineSpacing
 667         {
 668             get
 669             {
 670                 return (float)GetValue(InputLineSpacingProperty);
 671             }
 672             set
 673             {
 674                 SetValue(InputLineSpacingProperty, value);
 675                 NotifyPropertyChanged();
 676             }
 677         }
 678
 679         /// <summary>
 680         /// The Underline property.
 681         /// </summary>
 682         /// <since_tizen> 3 </since_tizen>
 683         public PropertyMap Underline
 684         {
 685             get
 686             {
 687                 return (PropertyMap)GetValue(UnderlineProperty);
 688             }
 689             set
 690             {
 691                 SetValue(UnderlineProperty, value);
 692                 NotifyPropertyChanged();
 693             }
 694         }
 695
 696         /// <summary>
 697         /// The InputUnderline property.
 698         /// </summary>
 699         /// <since_tizen> 3 </since_tizen>
 700         public string InputUnderline
 701         {
 702             get
 703             {
 704                 return (string)GetValue(InputUnderlineProperty);
 705             }
 706             set
 707             {
 708                 SetValue(InputUnderlineProperty, value);
 709                 NotifyPropertyChanged();
 710             }
 711         }
 712
 713         /// <summary>
 714         /// The Shadow property.
 715         /// </summary>
 716         /// <since_tizen> 3 </since_tizen>
 717         public PropertyMap Shadow
 718         {
 719             get
 720             {
 721                 return (PropertyMap)GetValue(ShadowProperty);
 722             }
 723             set
 724             {
 725                 SetValue(ShadowProperty, value);
 726                 NotifyPropertyChanged();
 727             }
 728         }
 729
 730         /// <summary>
 731         /// The InputShadow property.
 732         /// </summary>
 733         /// <since_tizen> 3 </since_tizen>
 734         public string InputShadow
 735         {
 736             get
 737             {
 738                 return (string)GetValue(InputShadowProperty);
 739             }
 740             set
 741             {
 742                 SetValue(InputShadowProperty, value);
 743                 NotifyPropertyChanged();
 744             }
 745         }
 746
 747         /// <summary>
 748         /// The Emboss property.
 749         /// </summary>
 750         /// <since_tizen> 3 </since_tizen>
 751         public string Emboss
 752         {
 753             get
 754             {
 755                 return (string)GetValue(EmbossProperty);
 756             }
 757             set
 758             {
 759                 SetValue(EmbossProperty, value);
 760                 NotifyPropertyChanged();
 761             }
 762         }
 763
 764         /// <summary>
 765         /// The InputEmboss property.
 766         /// </summary>
 767         /// <since_tizen> 3 </since_tizen>
 768         public string InputEmboss
 769         {
 770             get
 771             {
 772                 return (string)GetValue(InputEmbossProperty);
 773             }
 774             set
 775             {
 776                 SetValue(InputEmbossProperty, value);
 777                 NotifyPropertyChanged();
 778             }
 779         }
 780
 781         /// <summary>
 782         /// The Outline property.
 783         /// </summary>
 784         /// <since_tizen> 3 </since_tizen>
 785         public PropertyMap Outline
 786         {
 787             get
 788             {
 789                 return (PropertyMap)GetValue(OutlineProperty);
 790             }
 791             set
 792             {
 793                 SetValue(OutlineProperty, value);
 794                 NotifyPropertyChanged();
 795             }
 796         }
 797
 798         /// <summary>
 799         /// The InputOutline property.
 800         /// </summary>
 801         /// <since_tizen> 3 </since_tizen>
 802         public string InputOutline
 803         {
 804             get
 805             {
 806                 return (string)GetValue(InputOutlineProperty);
 807             }
 808             set
 809             {
 810                 SetValue(InputOutlineProperty, value);
 811                 NotifyPropertyChanged();
 812             }
 813         }
 814
 815         /// <summary>
 816         /// The SmoothScroll property.
 817         /// </summary>
 818         /// <since_tizen> 3 </since_tizen>
 819         public bool SmoothScroll
 820         {
 821             get
 822             {
 823                 return (bool)GetValue(SmoothScrollProperty);
 824             }
 825             set
 826             {
 827                 SetValue(SmoothScrollProperty, value);
 828                 NotifyPropertyChanged();
 829             }
 830         }
 831
 832         /// <summary>
 833         /// The SmoothScrollDuration property.
 834         /// </summary>
 835         /// <since_tizen> 3 </since_tizen>
 836         public float SmoothScrollDuration
 837         {
 838             get
 839             {
 840                 return (float)GetValue(SmoothScrollDurationProperty);
 841             }
 842             set
 843             {
 844                 SetValue(SmoothScrollDurationProperty, value);
 845                 NotifyPropertyChanged();
 846             }
 847         }
 848
 849         /// <summary>
 850         /// The EnableScrollBar property.
 851         /// </summary>
 852         /// <since_tizen> 3 </since_tizen>
 853         public bool EnableScrollBar
 854         {
 855             get
 856             {
 857                 return (bool)GetValue(EnableScrollBarProperty);
 858             }
 859             set
 860             {
 861                 SetValue(EnableScrollBarProperty, value);
 862                 NotifyPropertyChanged();
 863             }
 864         }
 865
 866         /// <summary>
 867         /// The ScrollBarShowDuration property.
 868         /// </summary>
 869         /// <since_tizen> 3 </since_tizen>
 870         public float ScrollBarShowDuration
 871         {
 872             get
 873             {
 874                 return (float)GetValue(ScrollBarShowDurationProperty);
 875             }
 876             set
 877             {
 878                 SetValue(ScrollBarShowDurationProperty, value);
 879                 NotifyPropertyChanged();
 880             }
 881         }
 882
 883         /// <summary>
 884         /// The ScrollBarFadeDuration property.
 885         /// </summary>
 886         /// <since_tizen> 3 </since_tizen>
 887         public float ScrollBarFadeDuration
 888         {
 889             get
 890             {
 891                 return (float)GetValue(ScrollBarFadeDurationProperty);
 892             }
 893             set
 894             {
 895                 SetValue(ScrollBarFadeDurationProperty, value);
 896                 NotifyPropertyChanged();
 897             }
 898         }
 899
 900         /// <summary>
 901         /// The PixelSize property.
 902         /// </summary>
 903         /// <since_tizen> 3 </since_tizen>
 904         public float PixelSize
 905         {
 906             get
 907             {
 908                 return (float)GetValue(PixelSizeProperty);
 909             }
 910             set
 911             {
 912                 SetValue(PixelSizeProperty, value);
 913                 NotifyPropertyChanged();
 914             }
 915         }
 916
 917         /// <summary>
 918         /// The line count of the text.
 919         /// </summary>
 920         /// <since_tizen> 3 </since_tizen>
 921         public int LineCount
 922         {
 923             get
 924             {
 925                 int temp = 0;
 926                 GetProperty(TextEditor.Property.LINE_COUNT).Get(out temp);
 927                 return temp;
 928             }
 929         }
 930
 931         /// <summary>
 932         /// The text to display when the TextEditor is empty and inactive.
 933         /// </summary>
 934         /// <since_tizen> 3 </since_tizen>
 935         public string PlaceholderText
 936         {
 937             get
 938             {
 939                 return (string)GetValue(PlaceholderTextProperty);
 940             }
 941             set
 942             {
 943                 SetValue(PlaceholderTextProperty, value);
 944                 NotifyPropertyChanged();
 945             }
 946         }
 947
 948         /// <summary>
 949         /// The Selected Text property (read-only).
 950         /// </summary>
 951         [EditorBrowsable(EditorBrowsableState.Never)]
 952         public string SelectedText
 953         {
 954             get
 955             {
 956                 string temp;
 957                 GetProperty(TextEditor.Property.SELECTED_TEXT).Get(out temp);
 958                 return temp;
 959             }
 960         }
 961
 962         /// <summary>
 963         /// The Placeholder text color.
 964         /// </summary>
 965         /// <remarks>
 966         /// The property cascade chaining set is possible. For example, this (textEditor.PlaceholderTextColor.X = 0.1f;) is possible.
 967         /// </remarks>
 968         /// <since_tizen> 3 </since_tizen>
 969         public Color PlaceholderTextColor
 970         {
 971             get
 972             {
 973                 Color temp = (Color)GetValue(PlaceholderTextColorProperty);
 974                 return new Color(OnPlaceholderTextColorChanged, temp.R, temp.G, temp.B, temp.A);
 975             }
 976             set
 977             {
 978                 SetValue(PlaceholderTextColorProperty, value);
 979                 NotifyPropertyChanged();
 980             }
 981         }
 982
 983         /// <summary>
 984         /// The EnableSelection property.
 985         /// </summary>
 986         /// <since_tizen> 3 </since_tizen>
 987         public bool EnableSelection
 988         {
 989             get
 990             {
 991                 return (bool)GetValue(EnableSelectionProperty);
 992             }
 993             set
 994             {
 995                 SetValue(EnableSelectionProperty, value);
 996                 NotifyPropertyChanged();
 997             }
 998         }
 999
1000         /// <summary>
1001         /// The start index for selection.
1002         /// </summary>
1003         /// <since_tizen> 8 </since_tizen>
1004         /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
1005         [EditorBrowsable(EditorBrowsableState.Never)]
1006         public int SelectedTextStart
1007         {
1008             get
1009             {
1010                 int temp;
1011                 GetProperty(TextEditor.Property.SELECTED_TEXT_START).Get(out temp);
1012                 return temp;
1013             }
1014             set
1015             {
1016                 SetProperty(TextEditor.Property.SELECTED_TEXT_START, new PropertyValue(value));
1017                 NotifyPropertyChanged();
1018             }
1019         }
1020
1021         /// <summary>
1022         /// The end index for selection.
1023         /// </summary>
1024         /// <since_tizen> 8 </since_tizen>
1025         /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
1026         [EditorBrowsable(EditorBrowsableState.Never)]
1027         public int SelectedTextEnd
1028         {
1029             get
1030             {
1031                 int temp;
1032                 GetProperty(TextEditor.Property.SELECTED_TEXT_END).Get(out temp);
1033                 return temp;
1034             }
1035             set
1036             {
1037                 SetProperty(TextEditor.Property.SELECTED_TEXT_END, new PropertyValue(value));
1038                 NotifyPropertyChanged();
1039             }
1040         }
1041
1042         /// Enable editing in text control.
1043         /// </summary>
1044         /// <since_tizen> 8 </since_tizen>
1045         /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
1046         [EditorBrowsable(EditorBrowsableState.Never)]
1047         public bool EnableEditing
1048         {
1049             get
1050             {
1051                 bool temp;
1052                 GetProperty(TextEditor.Property.ENABLE_EDITING).Get(out temp);
1053                 return temp;
1054             }
1055             set
1056             {
1057                 SetProperty(TextEditor.Property.ENABLE_EDITING, new PropertyValue(value));
1058                 NotifyPropertyChanged();
1059             }
1060         }
1061
1062         /// <summary>
1063         /// The Placeholder property.
1064         /// Gets or sets the placeholder: text, color, font family, font style, point size, and pixel size.
1065         /// </summary>
1066         /// <example>
1067         /// The following example demonstrates how to set the placeholder property.
1068         /// <code>
1069         /// PropertyMap propertyMap = new PropertyMap();
1070         /// propertyMap.Add("text", new PropertyValue("Setting Placeholder Text"));
1071         /// propertyMap.Add("textFocused", new PropertyValue("Setting Placeholder Text Focused"));
1072         /// propertyMap.Add("color", new PropertyValue(Color.Red));
1073         /// propertyMap.Add("fontFamily", new PropertyValue("Arial"));
1074         /// propertyMap.Add("pointSize", new PropertyValue(12.0f));
1075         ///
1076         /// PropertyMap fontStyleMap = new PropertyMap();
1077         /// fontStyleMap.Add("weight", new PropertyValue("bold"));
1078         /// fontStyleMap.Add("width", new PropertyValue("condensed"));
1079         /// fontStyleMap.Add("slant", new PropertyValue("italic"));
1080         /// propertyMap.Add("fontStyle", new PropertyValue(fontStyleMap));
1081         ///
1082         /// TextEditor editor = new TextEditor();
1083         /// editor.Placeholder = propertyMap;
1084         /// </code>
1085         /// </example>
1086         /// <since_tizen> 3 </since_tizen>
1087         public Tizen.NUI.PropertyMap Placeholder
1088         {
1089             get
1090             {
1091                 return (PropertyMap)GetValue(PlaceholderProperty);
1092             }
1093             set
1094             {
1095                 SetValue(PlaceholderProperty, value);
1096                 NotifyPropertyChanged();
1097             }
1098         }
1099
1100         /// <summary>
1101         /// The LineWrapMode property.<br />
1102         /// The line wrap mode when the text lines over the layout width.<br />
1103         /// </summary>
1104         /// <since_tizen> 4 </since_tizen>
1105         public LineWrapMode LineWrapMode
1106         {
1107             get
1108             {
1109                 return (LineWrapMode)GetValue(LineWrapModeProperty);
1110             }
1111             set
1112             {
1113                 SetValue(LineWrapModeProperty, value);
1114                 NotifyPropertyChanged();
1115             }
1116         }
1117
1118         /// <summary>
1119         /// Enables Text selection using Shift key.
1120         /// </summary>
1121         /// <since_tizen> 5 </since_tizen>
1122         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1123         [EditorBrowsable(EditorBrowsableState.Never)]
1124         public bool EnableShiftSelection
1125         {
1126             get
1127             {
1128                 return (bool)GetValue(EnableShiftSelectionProperty);
1129             }
1130             set
1131             {
1132                 SetValue(EnableShiftSelectionProperty, value);
1133                 NotifyPropertyChanged();
1134             }
1135         }
1136
1137         /// <summary>
1138         /// The text alignment to match the direction of the system language.
1139         /// </summary>
1140         /// <since_tizen> 6 </since_tizen>
1141         public bool MatchSystemLanguageDirection
1142         {
1143             get
1144             {
1145                 return (bool)GetValue(MatchSystemLanguageDirectionProperty);
1146             }
1147             set
1148             {
1149                 SetValue(MatchSystemLanguageDirectionProperty, value);
1150                 NotifyPropertyChanged();
1151             }
1152         }
1153
1154         /// <summary>
1155         /// The MaxLength property.
1156         /// </summary>
1157         /// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
1158         [EditorBrowsable(EditorBrowsableState.Never)]
1159         public int MaxLength
1160         {
1161             get
1162             {
1163                 return (int)GetValue(MaxLengthProperty);
1164             }
1165             set
1166             {
1167                 SetValue(MaxLengthProperty, value);
1168                 NotifyPropertyChanged();
1169             }
1170         }
1171
1172         /// Only used by the IL of xaml, will never changed to not hidden.
1173         [EditorBrowsable(EditorBrowsableState.Never)]
1174         public override bool IsCreateByXaml
1175         {
1176             get
1177             {
1178                 return base.IsCreateByXaml;
1179             }
1180             set
1181             {
1182                 base.IsCreateByXaml = value;
1183
1184                 if (value == true)
1185                 {
1186                     this.TextChanged += (obj, e) =>
1187                     {
1188                         this.Text = e.TextEditor.Text;
1189                     };
1190                 }
1191             }
1192         }
1193
1194         /// <summary>
1195         /// Get the InputMethodContext instance.
1196         /// </summary>
1197         /// <returns>The InputMethodContext instance.</returns>
1198         /// <since_tizen> 5 </since_tizen>
1199         public InputMethodContext GetInputMethodContext()
1200         {
1201             if (inputMethodContext == null)
1202             {
1203                 /*Avoid raising InputMethodContext reference count.*/
1204                 inputMethodContext = new InputMethodContext(Interop.TextEditor.TextEditor_GetInputMethodContext(swigCPtr), true);
1205                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1206             }
1207             return inputMethodContext;
1208         }
1209
1210         /// <summary>
1211         /// Select the whole text.
1212         /// </summary>
1213         [EditorBrowsable(EditorBrowsableState.Never)]
1214         public void SelectWholeText()
1215         {
1216             Interop.TextEditor.TextEditor_SelectWholeText(swigCPtr);
1217             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1218         }
1219
1220         /// <summary>
1221         /// Clear selection of the text.
1222         /// </summary>
1223         [EditorBrowsable(EditorBrowsableState.Never)]
1224         public void SelectNone()
1225         {
1226             Interop.TextEditor.TextEditor_SelectNone(swigCPtr);
1227             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1228         }
1229
1230         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TextEditor obj)
1231         {
1232             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
1233         }
1234
1235         internal SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__TextEditor_Dali__Toolkit__TextEditor__InputStyle__MaskF_t InputStyleChangedSignal()
1236         {
1237             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.TextEditor_InputStyleChangedSignal(swigCPtr));
1238             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1239             return ret;
1240         }
1241
1242         /// <summary>
1243         /// Dispose.
1244         /// </summary>
1245         /// <since_tizen> 3 </since_tizen>
1246         protected override void Dispose(DisposeTypes type)
1247         {
1248             if (disposed)
1249             {
1250                 return;
1251             }
1252
1253             if (systemlangTextFlag)
1254             {
1255                 SystemSettings.LocaleLanguageChanged -= SystemSettings_LocaleLanguageChanged;
1256             }
1257
1258             //Release your own unmanaged resources here.
1259             //You should not access any managed member here except static instance.
1260             //because the execution order of Finalizes is non-deterministic.
1261
1262             if (this.HasBody())
1263             {
1264                 if (_textEditorTextChangedCallbackDelegate != null)
1265                 {
1266                     TextChangedSignal().Disconnect(_textEditorTextChangedCallbackDelegate);
1267                 }
1268
1269                 if (_textEditorMaxLengthReachedCallbackDelegate != null)
1270                 {
1271                     this.MaxLengthReachedSignal().Disconnect(_textEditorMaxLengthReachedCallbackDelegate);
1272                 }
1273             }
1274
1275             base.Dispose(type);
1276         }
1277
1278         /// This will not be public opened.
1279         [EditorBrowsable(EditorBrowsableState.Never)]
1280         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
1281         {
1282             // In order to speed up IME hide, temporarily add
1283             GetInputMethodContext()?.DestroyContext();
1284             Interop.TextEditor.delete_TextEditor(swigCPtr);
1285         }
1286
1287         private string SetTranslatable(string textEditorSid)
1288         {
1289             string translatableText = null;
1290             translatableText = NUIApplication.MultilingualResourceManager?.GetString(textEditorSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
1291             if (translatableText != null)
1292             {
1293                 if (systemlangTextFlag == false)
1294                 {
1295                     SystemSettings.LocaleLanguageChanged += SystemSettings_LocaleLanguageChanged;
1296                     systemlangTextFlag = true;
1297                 }
1298                 return translatableText;
1299             }
1300             else
1301             {
1302                 translatableText = "";
1303                 return translatableText;
1304             }
1305         }
1306
1307         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
1308         {
1309             if (textEditorTextSid != null)
1310             {
1311                 Text = NUIApplication.MultilingualResourceManager?.GetString(textEditorTextSid, new CultureInfo(e.Value.Replace("_", "-")));
1312             }
1313             if (textEditorPlaceHolderTextSid != null)
1314             {
1315                 PlaceholderText = NUIApplication.MultilingualResourceManager?.GetString(textEditorPlaceHolderTextSid, new CultureInfo(e.Value.Replace("_", "-")));
1316             }
1317         }
1318
1319         internal new class Property
1320         {
1321             internal static readonly int TEXT = Interop.TextEditor.TextEditor_Property_TEXT_get();
1322             internal static readonly int TEXT_COLOR = Interop.TextEditor.TextEditor_Property_TEXT_COLOR_get();
1323             internal static readonly int FONT_FAMILY = Interop.TextEditor.TextEditor_Property_FONT_FAMILY_get();
1324             internal static readonly int FONT_STYLE = Interop.TextEditor.TextEditor_Property_FONT_STYLE_get();
1325             internal static readonly int POINT_SIZE = Interop.TextEditor.TextEditor_Property_POINT_SIZE_get();
1326             internal static readonly int HORIZONTAL_ALIGNMENT = Interop.TextEditor.TextEditor_Property_HORIZONTAL_ALIGNMENT_get();
1327             internal static readonly int SCROLL_THRESHOLD = Interop.TextEditor.TextEditor_Property_SCROLL_THRESHOLD_get();
1328             internal static readonly int SCROLL_SPEED = Interop.TextEditor.TextEditor_Property_SCROLL_SPEED_get();
1329             internal static readonly int PRIMARY_CURSOR_COLOR = Interop.TextEditor.TextEditor_Property_PRIMARY_CURSOR_COLOR_get();
1330             internal static readonly int SECONDARY_CURSOR_COLOR = Interop.TextEditor.TextEditor_Property_SECONDARY_CURSOR_COLOR_get();
1331             internal static readonly int ENABLE_CURSOR_BLINK = Interop.TextEditor.TextEditor_Property_ENABLE_CURSOR_BLINK_get();
1332             internal static readonly int CURSOR_BLINK_INTERVAL = Interop.TextEditor.TextEditor_Property_CURSOR_BLINK_INTERVAL_get();
1333             internal static readonly int CURSOR_BLINK_DURATION = Interop.TextEditor.TextEditor_Property_CURSOR_BLINK_DURATION_get();
1334             internal static readonly int CURSOR_WIDTH = Interop.TextEditor.TextEditor_Property_CURSOR_WIDTH_get();
1335             internal static readonly int GRAB_HANDLE_IMAGE = Interop.TextEditor.TextEditor_Property_GRAB_HANDLE_IMAGE_get();
1336             internal static readonly int GRAB_HANDLE_PRESSED_IMAGE = Interop.TextEditor.TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get();
1337             internal static readonly int SELECTION_HANDLE_IMAGE_LEFT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get();
1338             internal static readonly int SELECTION_HANDLE_IMAGE_RIGHT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get();
1339             internal static readonly int SELECTION_HANDLE_PRESSED_IMAGE_LEFT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get();
1340             internal static readonly int SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get();
1341             internal static readonly int SELECTION_HANDLE_MARKER_IMAGE_LEFT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get();
1342             internal static readonly int SELECTION_HANDLE_MARKER_IMAGE_RIGHT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get();
1343             internal static readonly int SELECTION_HIGHLIGHT_COLOR = Interop.TextEditor.TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get();
1344             internal static readonly int DECORATION_BOUNDING_BOX = Interop.TextEditor.TextEditor_Property_DECORATION_BOUNDING_BOX_get();
1345             internal static readonly int ENABLE_MARKUP = Interop.TextEditor.TextEditor_Property_ENABLE_MARKUP_get();
1346             internal static readonly int INPUT_COLOR = Interop.TextEditor.TextEditor_Property_INPUT_COLOR_get();
1347             internal static readonly int INPUT_FONT_FAMILY = Interop.TextEditor.TextEditor_Property_INPUT_FONT_FAMILY_get();
1348             internal static readonly int INPUT_FONT_STYLE = Interop.TextEditor.TextEditor_Property_INPUT_FONT_STYLE_get();
1349             internal static readonly int INPUT_POINT_SIZE = Interop.TextEditor.TextEditor_Property_INPUT_POINT_SIZE_get();
1350             internal static readonly int LINE_SPACING = Interop.TextEditor.TextEditor_Property_LINE_SPACING_get();
1351             internal static readonly int INPUT_LINE_SPACING = Interop.TextEditor.TextEditor_Property_INPUT_LINE_SPACING_get();
1352             internal static readonly int UNDERLINE = Interop.TextEditor.TextEditor_Property_UNDERLINE_get();
1353             internal static readonly int INPUT_UNDERLINE = Interop.TextEditor.TextEditor_Property_INPUT_UNDERLINE_get();
1354             internal static readonly int SHADOW = Interop.TextEditor.TextEditor_Property_SHADOW_get();
1355             internal static readonly int INPUT_SHADOW = Interop.TextEditor.TextEditor_Property_INPUT_SHADOW_get();
1356             internal static readonly int EMBOSS = Interop.TextEditor.TextEditor_Property_EMBOSS_get();
1357             internal static readonly int INPUT_EMBOSS = Interop.TextEditor.TextEditor_Property_INPUT_EMBOSS_get();
1358             internal static readonly int OUTLINE = Interop.TextEditor.TextEditor_Property_OUTLINE_get();
1359             internal static readonly int INPUT_OUTLINE = Interop.TextEditor.TextEditor_Property_INPUT_OUTLINE_get();
1360             internal static readonly int SMOOTH_SCROLL = Interop.TextEditor.TextEditor_Property_SMOOTH_SCROLL_get();
1361             internal static readonly int SMOOTH_SCROLL_DURATION = Interop.TextEditor.TextEditor_Property_SMOOTH_SCROLL_DURATION_get();
1362             internal static readonly int ENABLE_SCROLL_BAR = Interop.TextEditor.TextEditor_Property_ENABLE_SCROLL_BAR_get();
1363             internal static readonly int SCROLL_BAR_SHOW_DURATION = Interop.TextEditor.TextEditor_Property_SCROLL_BAR_SHOW_DURATION_get();
1364             internal static readonly int SCROLL_BAR_FADE_DURATION = Interop.TextEditor.TextEditor_Property_SCROLL_BAR_FADE_DURATION_get();
1365             internal static readonly int PIXEL_SIZE = Interop.TextEditor.TextEditor_Property_PIXEL_SIZE_get();
1366             internal static readonly int LINE_COUNT = Interop.TextEditor.TextEditor_Property_LINE_COUNT_get();
1367             internal static readonly int ENABLE_SELECTION = Interop.TextEditor.TextEditor_Property_ENABLE_SELECTION_get();
1368             internal static readonly int PLACEHOLDER = Interop.TextEditor.TextEditor_Property_PLACEHOLDER_get();
1369             internal static readonly int LINE_WRAP_MODE = Interop.TextEditor.TextEditor_Property_LINE_WRAP_MODE_get();
1370             internal static readonly int PLACEHOLDER_TEXT = Interop.TextEditor.TextEditor_Property_PLACEHOLDER_TEXT_get();
1371             internal static readonly int PLACEHOLDER_TEXT_COLOR = Interop.TextEditor.TextEditor_Property_PLACEHOLDER_TEXT_COLOR_get();
1372             internal static readonly int ENABLE_SHIFT_SELECTION = Interop.TextEditor.TextEditor_Property_ENABLE_SHIFT_SELECTION_get();
1373             internal static readonly int MATCH_SYSTEM_LANGUAGE_DIRECTION = Interop.TextEditor.TextEditor_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get();
1374             internal static readonly int MAX_LENGTH = Interop.TextEditor.TextEditor_Property_MAX_LENGTH_get();
1375             internal static readonly int SELECTED_TEXT_START = Interop.TextEditor.TextEditor_Property_SELECTED_TEXT_START_get();
1376             internal static readonly int SELECTED_TEXT_END = Interop.TextEditor.TextEditor_Property_SELECTED_TEXT_END_get();
1377             internal static readonly int ENABLE_EDITING = Interop.TextEditor.TextEditor_Property_ENABLE_EDITING_get();
1378             internal static readonly int SELECTED_TEXT = Interop.TextEditor.TextEditor_Property_SELECTED_TEXT_get();
1379         }
1380
1381         internal class InputStyle
1382         {
1383             internal enum Mask
1384             {
1385                 None = 0x0000,
1386                 Color = 0x0001,
1387                 FontFamily = 0x0002,
1388                 PointSize = 0x0004,
1389                 FontStyle = 0x0008,
1390                 LineSpacing = 0x0010,
1391                 Underline = 0x0020,
1392                 Shadow = 0x0040,
1393                 Emboss = 0x0080,
1394                 Outline = 0x0100
1395             }
1396         }
1397
1398         private void OnDecorationBoundingBoxChanged(int x, int y, int width, int height)
1399         {
1400             DecorationBoundingBox = new Rectangle(x, y, width, height);
1401         }
1402         private void OnInputColorChanged(float x, float y, float z, float w)
1403         {
1404             InputColor = new Vector4(x, y, z, w);
1405         }
1406         private void OnPlaceholderTextColorChanged(float r, float g, float b, float a)
1407         {
1408             PlaceholderTextColor = new Color(r, g, b, a);
1409         }
1410         private void OnPrimaryCursorColorChanged(float x, float y, float z, float w)
1411         {
1412             PrimaryCursorColor = new Vector4(x, y, z, w);
1413         }
1414         private void OnSecondaryCursorColorChanged(float x, float y, float z, float w)
1415         {
1416             SecondaryCursorColor = new Vector4(x, y, z, w);
1417         }
1418         private void OnSelectionHighlightColorChanged(float x, float y, float z, float w)
1419         {
1420             SelectionHighlightColor = new Vector4(x, y, z, w);
1421         }
1422         private void OnTextColorChanged(float x, float y, float z, float w)
1423         {
1424             TextColor = new Vector4(x, y, z, w);
1425         }
1426
1427     }
1428 }