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