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("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("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 Placeholder text color.
 950         /// </summary>
 951         /// <remarks>
 952         /// The property cascade chaining set is possible. For example, this (textEditor.PlaceholderTextColor.X = 0.1f;) is possible.
 953         /// </remarks>
 954         /// <since_tizen> 3 </since_tizen>
 955         public Color PlaceholderTextColor
 956         {
 957             get
 958             {
 959                 Color temp = (Color)GetValue(PlaceholderTextColorProperty);
 960                 return new Color(OnPlaceholderTextColorChanged, temp.R, temp.G, temp.B, temp.A);
 961             }
 962             set
 963             {
 964                 SetValue(PlaceholderTextColorProperty, value);
 965                 NotifyPropertyChanged();
 966             }
 967         }
 968
 969         /// <summary>
 970         /// The EnableSelection property.
 971         /// </summary>
 972         /// <since_tizen> 3 </since_tizen>
 973         public bool EnableSelection
 974         {
 975             get
 976             {
 977                 return (bool)GetValue(EnableSelectionProperty);
 978             }
 979             set
 980             {
 981                 SetValue(EnableSelectionProperty, value);
 982                 NotifyPropertyChanged();
 983             }
 984         }
 985
 986         /// <summary>
 987         /// The Placeholder property.
 988         /// Gets or sets the placeholder: text, color, font family, font style, point size, and pixel size.
 989         /// </summary>
 990         /// <example>
 991         /// The following example demonstrates how to set the placeholder property.
 992         /// <code>
 993         /// PropertyMap propertyMap = new PropertyMap();
 994         /// propertyMap.Add("text", new PropertyValue("Setting Placeholder Text"));
 995         /// propertyMap.Add("textFocused", new PropertyValue("Setting Placeholder Text Focused"));
 996         /// propertyMap.Add("color", new PropertyValue(Color.Red));
 997         /// propertyMap.Add("fontFamily", new PropertyValue("Arial"));
 998         /// propertyMap.Add("pointSize", new PropertyValue(12.0f));
 999         ///
1000         /// PropertyMap fontStyleMap = new PropertyMap();
1001         /// fontStyleMap.Add("weight", new PropertyValue("bold"));
1002         /// fontStyleMap.Add("width", new PropertyValue("condensed"));
1003         /// fontStyleMap.Add("slant", new PropertyValue("italic"));
1004         /// propertyMap.Add("fontStyle", new PropertyValue(fontStyleMap));
1005         ///
1006         /// TextEditor editor = new TextEditor();
1007         /// editor.Placeholder = propertyMap;
1008         /// </code>
1009         /// </example>
1010         /// <since_tizen> 3 </since_tizen>
1011         public Tizen.NUI.PropertyMap Placeholder
1012         {
1013             get
1014             {
1015                 return (PropertyMap)GetValue(PlaceholderProperty);
1016             }
1017             set
1018             {
1019                 SetValue(PlaceholderProperty, value);
1020                 NotifyPropertyChanged();
1021             }
1022         }
1023
1024         /// <summary>
1025         /// The LineWrapMode property.<br />
1026         /// The line wrap mode when the text lines over the layout width.<br />
1027         /// </summary>
1028         /// <since_tizen> 4 </since_tizen>
1029         public LineWrapMode LineWrapMode
1030         {
1031             get
1032             {
1033                 return (LineWrapMode)GetValue(LineWrapModeProperty);
1034             }
1035             set
1036             {
1037                 SetValue(LineWrapModeProperty, value);
1038                 NotifyPropertyChanged();
1039             }
1040         }
1041
1042         /// <summary>
1043         /// Enables Text selection using Shift key.
1044         /// </summary>
1045         /// <since_tizen> 5 </since_tizen>
1046         /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
1047         [EditorBrowsable(EditorBrowsableState.Never)]
1048         public bool EnableShiftSelection
1049         {
1050             get
1051             {
1052                 return (bool)GetValue(EnableShiftSelectionProperty);
1053             }
1054             set
1055             {
1056                 SetValue(EnableShiftSelectionProperty, value);
1057                 NotifyPropertyChanged();
1058             }
1059         }
1060
1061         /// <summary>
1062         /// The text alignment to match the direction of the system language.
1063         /// </summary>
1064         /// <since_tizen> 6 </since_tizen>
1065         public bool MatchSystemLanguageDirection
1066         {
1067             get
1068             {
1069                 return (bool)GetValue(MatchSystemLanguageDirectionProperty);
1070             }
1071             set
1072             {
1073                 SetValue(MatchSystemLanguageDirectionProperty, value);
1074                 NotifyPropertyChanged();
1075             }
1076         }
1077
1078         /// Only used by the IL of xaml, will never changed to not hidden.
1079         [EditorBrowsable(EditorBrowsableState.Never)]
1080         public override bool IsCreateByXaml
1081         {
1082             get
1083             {
1084                 return base.IsCreateByXaml;
1085             }
1086             set
1087             {
1088                 base.IsCreateByXaml = value;
1089
1090                 if (value == true)
1091                 {
1092                     this.TextChanged += (obj, e) =>
1093                     {
1094                         this.Text = this.Text;
1095                     };
1096                 }
1097             }
1098         }
1099
1100         /// <summary>
1101         /// Get the InputMethodContext instance.
1102         /// </summary>
1103         /// <returns>The InputMethodContext instance.</returns>
1104         /// <since_tizen> 5 </since_tizen>
1105         public InputMethodContext GetInputMethodContext()
1106         {
1107             if (inputMethodContext == null)
1108             {
1109                 /*Avoid raising InputMethodContext reference count.*/
1110                 inputMethodContext = new InputMethodContext(Interop.TextEditor.TextEditor_GetInputMethodContext(swigCPtr), true);
1111                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1112             }
1113             return inputMethodContext;
1114         }
1115
1116         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TextEditor obj)
1117         {
1118             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
1119         }
1120
1121         internal SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__TextEditor_Dali__Toolkit__TextEditor__InputStyle__MaskF_t InputStyleChangedSignal()
1122         {
1123             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), false);
1124             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1125             return ret;
1126         }
1127
1128         /// <summary>
1129         /// Dispose.
1130         /// </summary>
1131         /// <since_tizen> 3 </since_tizen>
1132         protected override void Dispose(DisposeTypes type)
1133         {
1134             if (disposed)
1135             {
1136                 return;
1137             }
1138
1139             //Release your own unmanaged resources here.
1140             //You should not access any managed member here except static instance.
1141             //because the execution order of Finalizes is non-deterministic.
1142
1143             if (this.HasBody() && _textEditorTextChangedCallbackDelegate != null)
1144             {
1145                 TextChangedSignal().Disconnect(_textEditorTextChangedCallbackDelegate);
1146             }
1147
1148             base.Dispose(type);
1149         }
1150
1151         /// This will not be public opened.
1152         [EditorBrowsable(EditorBrowsableState.Never)]
1153         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
1154         {
1155             // In order to speed up IME hide, temporarily add
1156             GetInputMethodContext()?.DestroyContext();
1157             Interop.TextEditor.delete_TextEditor(swigCPtr);
1158         }
1159
1160         private string SetTranslatable(string textEditorSid)
1161         {
1162             string translatableText = null;
1163             translatableText = NUIApplication.MultilingualResourceManager?.GetString(textEditorSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
1164             if (translatableText != null)
1165             {
1166                 if (systemlangTextFlag == false)
1167                 {
1168                     SystemSettings.LocaleLanguageChanged += new WeakEventHandler<LocaleLanguageChangedEventArgs>(SystemSettings_LocaleLanguageChanged).Handler;
1169                     systemlangTextFlag = true;
1170                 }
1171                 return translatableText;
1172             }
1173             else
1174             {
1175                 translatableText = "";
1176                 return translatableText;
1177             }
1178         }
1179
1180         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
1181         {
1182             if (textEditorTextSid != null)
1183             {
1184                 Text = NUIApplication.MultilingualResourceManager?.GetString(textEditorTextSid, new CultureInfo(e.Value.Replace("_", "-")));
1185             }
1186             if (textEditorPlaceHolderTextSid != null)
1187             {
1188                 PlaceholderText = NUIApplication.MultilingualResourceManager?.GetString(textEditorPlaceHolderTextSid, new CultureInfo(e.Value.Replace("_", "-")));
1189             }
1190         }
1191
1192         internal new class Property
1193         {
1194             internal static readonly int TEXT = Interop.TextEditor.TextEditor_Property_TEXT_get();
1195             internal static readonly int TEXT_COLOR = Interop.TextEditor.TextEditor_Property_TEXT_COLOR_get();
1196             internal static readonly int FONT_FAMILY = Interop.TextEditor.TextEditor_Property_FONT_FAMILY_get();
1197             internal static readonly int FONT_STYLE = Interop.TextEditor.TextEditor_Property_FONT_STYLE_get();
1198             internal static readonly int POINT_SIZE = Interop.TextEditor.TextEditor_Property_POINT_SIZE_get();
1199             internal static readonly int HORIZONTAL_ALIGNMENT = Interop.TextEditor.TextEditor_Property_HORIZONTAL_ALIGNMENT_get();
1200             internal static readonly int SCROLL_THRESHOLD = Interop.TextEditor.TextEditor_Property_SCROLL_THRESHOLD_get();
1201             internal static readonly int SCROLL_SPEED = Interop.TextEditor.TextEditor_Property_SCROLL_SPEED_get();
1202             internal static readonly int PRIMARY_CURSOR_COLOR = Interop.TextEditor.TextEditor_Property_PRIMARY_CURSOR_COLOR_get();
1203             internal static readonly int SECONDARY_CURSOR_COLOR = Interop.TextEditor.TextEditor_Property_SECONDARY_CURSOR_COLOR_get();
1204             internal static readonly int ENABLE_CURSOR_BLINK = Interop.TextEditor.TextEditor_Property_ENABLE_CURSOR_BLINK_get();
1205             internal static readonly int CURSOR_BLINK_INTERVAL = Interop.TextEditor.TextEditor_Property_CURSOR_BLINK_INTERVAL_get();
1206             internal static readonly int CURSOR_BLINK_DURATION = Interop.TextEditor.TextEditor_Property_CURSOR_BLINK_DURATION_get();
1207             internal static readonly int CURSOR_WIDTH = Interop.TextEditor.TextEditor_Property_CURSOR_WIDTH_get();
1208             internal static readonly int GRAB_HANDLE_IMAGE = Interop.TextEditor.TextEditor_Property_GRAB_HANDLE_IMAGE_get();
1209             internal static readonly int GRAB_HANDLE_PRESSED_IMAGE = Interop.TextEditor.TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get();
1210             internal static readonly int SELECTION_HANDLE_IMAGE_LEFT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get();
1211             internal static readonly int SELECTION_HANDLE_IMAGE_RIGHT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get();
1212             internal static readonly int SELECTION_HANDLE_PRESSED_IMAGE_LEFT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get();
1213             internal static readonly int SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get();
1214             internal static readonly int SELECTION_HANDLE_MARKER_IMAGE_LEFT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get();
1215             internal static readonly int SELECTION_HANDLE_MARKER_IMAGE_RIGHT = Interop.TextEditor.TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get();
1216             internal static readonly int SELECTION_HIGHLIGHT_COLOR = Interop.TextEditor.TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get();
1217             internal static readonly int DECORATION_BOUNDING_BOX = Interop.TextEditor.TextEditor_Property_DECORATION_BOUNDING_BOX_get();
1218             internal static readonly int ENABLE_MARKUP = Interop.TextEditor.TextEditor_Property_ENABLE_MARKUP_get();
1219             internal static readonly int INPUT_COLOR = Interop.TextEditor.TextEditor_Property_INPUT_COLOR_get();
1220             internal static readonly int INPUT_FONT_FAMILY = Interop.TextEditor.TextEditor_Property_INPUT_FONT_FAMILY_get();
1221             internal static readonly int INPUT_FONT_STYLE = Interop.TextEditor.TextEditor_Property_INPUT_FONT_STYLE_get();
1222             internal static readonly int INPUT_POINT_SIZE = Interop.TextEditor.TextEditor_Property_INPUT_POINT_SIZE_get();
1223             internal static readonly int LINE_SPACING = Interop.TextEditor.TextEditor_Property_LINE_SPACING_get();
1224             internal static readonly int INPUT_LINE_SPACING = Interop.TextEditor.TextEditor_Property_INPUT_LINE_SPACING_get();
1225             internal static readonly int UNDERLINE = Interop.TextEditor.TextEditor_Property_UNDERLINE_get();
1226             internal static readonly int INPUT_UNDERLINE = Interop.TextEditor.TextEditor_Property_INPUT_UNDERLINE_get();
1227             internal static readonly int SHADOW = Interop.TextEditor.TextEditor_Property_SHADOW_get();
1228             internal static readonly int INPUT_SHADOW = Interop.TextEditor.TextEditor_Property_INPUT_SHADOW_get();
1229             internal static readonly int EMBOSS = Interop.TextEditor.TextEditor_Property_EMBOSS_get();
1230             internal static readonly int INPUT_EMBOSS = Interop.TextEditor.TextEditor_Property_INPUT_EMBOSS_get();
1231             internal static readonly int OUTLINE = Interop.TextEditor.TextEditor_Property_OUTLINE_get();
1232             internal static readonly int INPUT_OUTLINE = Interop.TextEditor.TextEditor_Property_INPUT_OUTLINE_get();
1233             internal static readonly int SMOOTH_SCROLL = Interop.TextEditor.TextEditor_Property_SMOOTH_SCROLL_get();
1234             internal static readonly int SMOOTH_SCROLL_DURATION = Interop.TextEditor.TextEditor_Property_SMOOTH_SCROLL_DURATION_get();
1235             internal static readonly int ENABLE_SCROLL_BAR = Interop.TextEditor.TextEditor_Property_ENABLE_SCROLL_BAR_get();
1236             internal static readonly int SCROLL_BAR_SHOW_DURATION = Interop.TextEditor.TextEditor_Property_SCROLL_BAR_SHOW_DURATION_get();
1237             internal static readonly int SCROLL_BAR_FADE_DURATION = Interop.TextEditor.TextEditor_Property_SCROLL_BAR_FADE_DURATION_get();
1238             internal static readonly int PIXEL_SIZE = Interop.TextEditor.TextEditor_Property_PIXEL_SIZE_get();
1239             internal static readonly int LINE_COUNT = Interop.TextEditor.TextEditor_Property_LINE_COUNT_get();
1240             internal static readonly int ENABLE_SELECTION = Interop.TextEditor.TextEditor_Property_ENABLE_SELECTION_get();
1241             internal static readonly int PLACEHOLDER = Interop.TextEditor.TextEditor_Property_PLACEHOLDER_get();
1242             internal static readonly int LINE_WRAP_MODE = Interop.TextEditor.TextEditor_Property_LINE_WRAP_MODE_get();
1243             internal static readonly int PLACEHOLDER_TEXT = Interop.TextEditor.TextEditor_Property_PLACEHOLDER_TEXT_get();
1244             internal static readonly int PLACEHOLDER_TEXT_COLOR = Interop.TextEditor.TextEditor_Property_PLACEHOLDER_TEXT_COLOR_get();
1245             internal static readonly int ENABLE_SHIFT_SELECTION = Interop.TextEditor.TextEditor_Property_ENABLE_SHIFT_SELECTION_get();
1246             internal static readonly int MATCH_SYSTEM_LANGUAGE_DIRECTION = Interop.TextEditor.TextEditor_Property_MATCH_SYSTEM_LANGUAGE_DIRECTION_get();
1247         }
1248
1249         internal class InputStyle
1250         {
1251             internal enum Mask
1252             {
1253                 None = 0x0000,
1254                 Color = 0x0001,
1255                 FontFamily = 0x0002,
1256                 PointSize = 0x0004,
1257                 FontStyle = 0x0008,
1258                 LineSpacing = 0x0010,
1259                 Underline = 0x0020,
1260                 Shadow = 0x0040,
1261                 Emboss = 0x0080,
1262                 Outline = 0x0100
1263             }
1264         }
1265
1266         private void OnDecorationBoundingBoxChanged(int x, int y, int width, int height)
1267         {
1268             DecorationBoundingBox = new Rectangle(x, y, width, height);
1269         }
1270         private void OnInputColorChanged(float x, float y, float z, float w)
1271         {
1272             InputColor = new Vector4(x, y, z, w);
1273         }
1274         private void OnPlaceholderTextColorChanged(float r, float g, float b, float a)
1275         {
1276             PlaceholderTextColor = new Color(r, g, b, a);
1277         }
1278         private void OnPrimaryCursorColorChanged(float x, float y, float z, float w)
1279         {
1280             PrimaryCursorColor = new Vector4(x, y, z, w);
1281         }
1282         private void OnSecondaryCursorColorChanged(float x, float y, float z, float w)
1283         {
1284             SecondaryCursorColor = new Vector4(x, y, z, w);
1285         }
1286         private void OnSelectionHighlightColorChanged(float x, float y, float z, float w)
1287         {
1288             SelectionHighlightColor = new Vector4(x, y, z, w);
1289         }
1290         private void OnTextColorChanged(float x, float y, float z, float w)
1291         {
1292             TextColor = new Vector4(x, y, z, w);
1293         }
1294
1295     }
1296 }