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