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

   1 /*
   2  * Copyright(c) 2017 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 (_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 PLACEHOLDER_TEXT = NDalicManualPINVOKE.TextEditor_Property_PLACEHOLDER_TEXT_get();
 301             internal static readonly int PLACEHOLDER_TEXT_COLOR = NDalicManualPINVOKE.TextEditor_Property_PLACEHOLDER_TEXT_COLOR_get();
 302             internal static readonly int ENABLE_SELECTION = NDalicManualPINVOKE.TextEditor_Property_ENABLE_SELECTION_get();
 303             internal static readonly int PLACEHOLDER = NDalicManualPINVOKE.TextEditor_Property_PLACEHOLDER_get();
 304             internal static readonly int LINE_WRAP_MODE = NDalicManualPINVOKE.TextEditor_Property_LINE_WRAP_MODE_get();
 305         }
 306
 307         internal class InputStyle
 308         {
 309             internal enum Mask
 310             {
 311                 None = 0x0000,
 312                 Color = 0x0001,
 313                 FontFamily = 0x0002,
 314                 PointSize = 0x0004,
 315                 FontStyle = 0x0008,
 316                 LineSpacing = 0x0010,
 317                 Underline = 0x0020,
 318                 Shadow = 0x0040,
 319                 Emboss = 0x0080,
 320                 Outline = 0x0100
 321             }
 322         }
 323
 324         /// <summary>
 325         /// Creates the TextEditor control.
 326         /// </summary>
 327         /// <since_tizen> 3 </since_tizen>
 328         public TextEditor() : this(NDalicPINVOKE.TextEditor_New(), true)
 329         {
 330             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 331
 332         }
 333         internal TextEditor(TextEditor handle) : this(NDalicPINVOKE.new_TextEditor__SWIG_1(TextEditor.getCPtr(handle)), true)
 334         {
 335             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 336         }
 337
 338         /// <summary>
 339         /// Downcasts a handle to textEditor handle.
 340         /// </summary>
 341         /// <param name="handle"></param>
 342         /// <returns></returns>
 343         /// <since_tizen> 3 </since_tizen>
 344         /// Please do not use! this will be deprecated!
 345         /// Instead please use as keyword.
 346         [Obsolete("Please DO NOT use! This will be deprecated, instead please USE as keyword.")]
 347         [EditorBrowsable(EditorBrowsableState.Never)]
 348         public new static TextEditor DownCast(BaseHandle handle)
 349         {
 350             TextEditor ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as TextEditor;
 351             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 352             return ret;
 353         }
 354
 355         internal TextEditorSignal TextChangedSignal()
 356         {
 357             TextEditorSignal ret = new TextEditorSignal(NDalicPINVOKE.TextEditor_TextChangedSignal(swigCPtr), false);
 358             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 359             return ret;
 360         }
 361
 362         internal ScrollStateChangedSignal ScrollStateChangedSignal(TextEditor textEditor)
 363         {
 364             ScrollStateChangedSignal ret = new ScrollStateChangedSignal(NDalicManualPINVOKE.TextEditor_ScrollStateChangedSignal(TextEditor.getCPtr(textEditor)), false);
 365             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 366             return ret;
 367         }
 368
 369         internal SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__TextEditor_Dali__Toolkit__TextEditor__InputStyle__MaskF_t InputStyleChangedSignal()
 370         {
 371             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);
 372             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 373             return ret;
 374         }
 375
 376         /// <summary>
 377         /// The TranslatableText property.<br />
 378         /// The text can set the SID value.<br />
 379         /// </summary>
 380         /// <exception cref='ArgumentNullException'>
 381         /// ResourceManager about multilingual is null.
 382         /// </exception>
 383         /// <since_tizen> 4 </since_tizen>
 384         public string TranslatableText
 385         {
 386             get
 387             {
 388                 return textEditorTextSid;
 389             }
 390             set
 391             {
 392                 if (NUIApplication.MultilingualResourceManager == null)
 393                 {
 394                     throw new ArgumentNullException("ResourceManager about multilingual is null");
 395                 }
 396                 textEditorTextSid = value;
 397                 Text = SetTranslatable(textEditorTextSid);
 398             }
 399         }
 400         /// <summary>
 401         /// The TranslatablePlaceholderText property.<br />
 402         /// The text can set the SID value.<br />
 403         /// </summary>
 404         /// <exception cref='ArgumentNullException'>
 405         /// ResourceManager about multilingual is null.
 406         /// </exception>
 407         /// <since_tizen> 4 </since_tizen>
 408         public string TranslatablePlaceholderText
 409         {
 410             get
 411             {
 412                 return textEditorPlaceHolderTextSid;
 413             }
 414             set
 415             {
 416                 if (NUIApplication.MultilingualResourceManager == null)
 417                 {
 418                     throw new ArgumentNullException("ResourceManager about multilingual is null");
 419                 }
 420                 textEditorPlaceHolderTextSid = value;
 421                 PlaceholderText = SetTranslatable(textEditorPlaceHolderTextSid);
 422             }
 423         }
 424         private string SetTranslatable(string textEditorSid)
 425         {
 426             string translatableText = null;
 427             translatableText = NUIApplication.MultilingualResourceManager?.GetString(textEditorSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
 428             if (translatableText != null)
 429             {
 430                 if (systemlangTextFlag == false)
 431                 {
 432                     SystemSettings.LocaleLanguageChanged += new WeakEventHandler<LocaleLanguageChangedEventArgs>(SystemSettings_LocaleLanguageChanged).Handler;
 433                     systemlangTextFlag = true;
 434                 }
 435                 return translatableText;
 436             }
 437             else
 438             {
 439                 translatableText = "";
 440                 return translatableText;
 441             }
 442         }
 443         private void SystemSettings_LocaleLanguageChanged(object sender, LocaleLanguageChangedEventArgs e)
 444         {
 445             if (textEditorTextSid != null)
 446             {
 447                 Text = NUIApplication.MultilingualResourceManager?.GetString(textEditorTextSid, new CultureInfo(e.Value.Replace("_", "-")));
 448             }
 449             if (textEditorPlaceHolderTextSid != null)
 450             {
 451                 PlaceholderText = NUIApplication.MultilingualResourceManager?.GetString(textEditorPlaceHolderTextSid, new CultureInfo(e.Value.Replace("_", "-")));
 452             }
 453         }
 454         /// <summary>
 455         /// The Text property.
 456         /// </summary>
 457         /// <since_tizen> 3 </since_tizen>
 458         public string Text
 459         {
 460             get
 461             {
 462                 string temp;
 463                 GetProperty(TextEditor.Property.TEXT).Get(out temp);
 464                 return temp;
 465             }
 466             set
 467             {
 468                 SetProperty(TextEditor.Property.TEXT, new Tizen.NUI.PropertyValue(value));
 469             }
 470         }
 471
 472         /// <summary>
 473         /// The TextColor property.
 474         /// </summary>
 475         /// <since_tizen> 3 </since_tizen>
 476         public Vector4 TextColor
 477         {
 478             get
 479             {
 480                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 481                 GetProperty(TextEditor.Property.TEXT_COLOR).Get(temp);
 482                 return temp;
 483             }
 484             set
 485             {
 486                 SetProperty(TextEditor.Property.TEXT_COLOR, new Tizen.NUI.PropertyValue(value));
 487             }
 488         }
 489
 490         /// <summary>
 491         /// The FontFamily property.
 492         /// </summary>
 493         /// <since_tizen> 3 </since_tizen>
 494         public string FontFamily
 495         {
 496             get
 497             {
 498                 string temp;
 499                 GetProperty(TextEditor.Property.FONT_FAMILY).Get(out temp);
 500                 return temp;
 501             }
 502             set
 503             {
 504                 SetProperty(TextEditor.Property.FONT_FAMILY, new Tizen.NUI.PropertyValue(value));
 505             }
 506         }
 507
 508         /// <summary>
 509         /// The FontStyle property.
 510         /// </summary>
 511         /// <since_tizen> 3 </since_tizen>
 512         public PropertyMap FontStyle
 513         {
 514             get
 515             {
 516                 PropertyMap temp = new PropertyMap();
 517                 GetProperty(TextEditor.Property.FONT_STYLE).Get(temp);
 518                 return temp;
 519             }
 520             set
 521             {
 522                 SetProperty(TextEditor.Property.FONT_STYLE, new Tizen.NUI.PropertyValue(value));
 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             }
 542         }
 543
 544         /// <summary>
 545         /// The HorizontalAlignment property.
 546         /// </summary>
 547         /// <since_tizen> 3 </since_tizen>
 548         public HorizontalAlignment HorizontalAlignment
 549         {
 550             get
 551             {
 552                 string temp;
 553                 if (GetProperty(TextEditor.Property.HORIZONTAL_ALIGNMENT).Get(out temp) == false)
 554                 {
 555                     NUILog.Error("HorizontalAlignment get error!");
 556                 }
 557
 558                 switch (temp)
 559                 {
 560                     case "BEGIN":
 561                         return HorizontalAlignment.Begin;
 562                     case "CENTER":
 563                         return HorizontalAlignment.Center;
 564                     case "END":
 565                         return HorizontalAlignment.End;
 566                     default:
 567                         return HorizontalAlignment.Begin;
 568                 }
 569             }
 570             set
 571             {
 572                 string valueToString = "";
 573                 switch (value)
 574                 {
 575                     case HorizontalAlignment.Begin:
 576                     {
 577                         valueToString = "BEGIN";
 578                         break;
 579                     }
 580                     case HorizontalAlignment.Center:
 581                     {
 582                         valueToString = "CENTER";
 583                         break;
 584                     }
 585                     case HorizontalAlignment.End:
 586                     {
 587                         valueToString = "END";
 588                         break;
 589                     }
 590                     default:
 591                     {
 592                         valueToString = "BEGIN";
 593                         break;
 594                     }
 595                 }
 596                 SetProperty(TextEditor.Property.HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
 597             }
 598         }
 599
 600         /// <summary>
 601         /// The ScrollThreshold property.
 602         /// </summary>
 603         /// <since_tizen> 3 </since_tizen>
 604         public float ScrollThreshold
 605         {
 606             get
 607             {
 608                 float temp = 0.0f;
 609                 GetProperty(TextEditor.Property.SCROLL_THRESHOLD).Get(out temp);
 610                 return temp;
 611             }
 612             set
 613             {
 614                 SetProperty(TextEditor.Property.SCROLL_THRESHOLD, new Tizen.NUI.PropertyValue(value));
 615             }
 616         }
 617
 618         /// <summary>
 619         /// The ScrollSpeed property.
 620         /// </summary>
 621         /// <since_tizen> 3 </since_tizen>
 622         public float ScrollSpeed
 623         {
 624             get
 625             {
 626                 float temp = 0.0f;
 627                 GetProperty(TextEditor.Property.SCROLL_SPEED).Get(out temp);
 628                 return temp;
 629             }
 630             set
 631             {
 632                 SetProperty(TextEditor.Property.SCROLL_SPEED, new Tizen.NUI.PropertyValue(value));
 633             }
 634         }
 635
 636         /// <summary>
 637         /// The PrimaryCursorColor property.
 638         /// </summary>
 639         /// <since_tizen> 3 </since_tizen>
 640         public Vector4 PrimaryCursorColor
 641         {
 642             get
 643             {
 644                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 645                 GetProperty(TextEditor.Property.PRIMARY_CURSOR_COLOR).Get(temp);
 646                 return temp;
 647             }
 648             set
 649             {
 650                 SetProperty(TextEditor.Property.PRIMARY_CURSOR_COLOR, new Tizen.NUI.PropertyValue(value));
 651             }
 652         }
 653
 654         /// <summary>
 655         /// The SecondaryCursorColor property.
 656         /// </summary>
 657         /// <since_tizen> 3 </since_tizen>
 658         public Vector4 SecondaryCursorColor
 659         {
 660             get
 661             {
 662                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 663                 GetProperty(TextEditor.Property.SECONDARY_CURSOR_COLOR).Get(temp);
 664                 return temp;
 665             }
 666             set
 667             {
 668                 SetProperty(TextEditor.Property.SECONDARY_CURSOR_COLOR, new Tizen.NUI.PropertyValue(value));
 669             }
 670         }
 671
 672         /// <summary>
 673         /// The EnableCursorBlink property.
 674         /// </summary>
 675         /// <since_tizen> 3 </since_tizen>
 676         public bool EnableCursorBlink
 677         {
 678             get
 679             {
 680                 bool temp = false;
 681                 GetProperty(TextEditor.Property.ENABLE_CURSOR_BLINK).Get(out temp);
 682                 return temp;
 683             }
 684             set
 685             {
 686                 SetProperty(TextEditor.Property.ENABLE_CURSOR_BLINK, new Tizen.NUI.PropertyValue(value));
 687             }
 688         }
 689
 690         /// <summary>
 691         /// The CursorBlinkInterval property.
 692         /// </summary>
 693         /// <since_tizen> 3 </since_tizen>
 694         public float CursorBlinkInterval
 695         {
 696             get
 697             {
 698                 float temp = 0.0f;
 699                 GetProperty(TextEditor.Property.CURSOR_BLINK_INTERVAL).Get(out temp);
 700                 return temp;
 701             }
 702             set
 703             {
 704                 SetProperty(TextEditor.Property.CURSOR_BLINK_INTERVAL, new Tizen.NUI.PropertyValue(value));
 705             }
 706         }
 707
 708         /// <summary>
 709         /// The CursorBlinkDuration property.
 710         /// </summary>
 711         /// <since_tizen> 3 </since_tizen>
 712         public float CursorBlinkDuration
 713         {
 714             get
 715             {
 716                 float temp = 0.0f;
 717                 GetProperty(TextEditor.Property.CURSOR_BLINK_DURATION).Get(out temp);
 718                 return temp;
 719             }
 720             set
 721             {
 722                 SetProperty(TextEditor.Property.CURSOR_BLINK_DURATION, new Tizen.NUI.PropertyValue(value));
 723             }
 724         }
 725
 726         /// <summary>
 727         /// The CursorWidth property.
 728         /// </summary>
 729         /// <since_tizen> 3 </since_tizen>
 730         public int CursorWidth
 731         {
 732             get
 733             {
 734                 int temp = 0;
 735                 GetProperty(TextEditor.Property.CURSOR_WIDTH).Get(out temp);
 736                 return temp;
 737             }
 738             set
 739             {
 740                 SetProperty(TextEditor.Property.CURSOR_WIDTH, new Tizen.NUI.PropertyValue(value));
 741             }
 742         }
 743
 744         /// <summary>
 745         /// The GrabHandleImage property.
 746         /// </summary>
 747         /// <since_tizen> 3 </since_tizen>
 748         public string GrabHandleImage
 749         {
 750             get
 751             {
 752                 string temp;
 753                 GetProperty(TextEditor.Property.GRAB_HANDLE_IMAGE).Get(out temp);
 754                 return temp;
 755             }
 756             set
 757             {
 758                 SetProperty(TextEditor.Property.GRAB_HANDLE_IMAGE, new Tizen.NUI.PropertyValue(value));
 759             }
 760         }
 761
 762         /// <summary>
 763         /// The GrabHandlePressedImage property.
 764         /// </summary>
 765         /// <since_tizen> 3 </since_tizen>
 766         public string GrabHandlePressedImage
 767         {
 768             get
 769             {
 770                 string temp;
 771                 GetProperty(TextEditor.Property.GRAB_HANDLE_PRESSED_IMAGE).Get(out temp);
 772                 return temp;
 773             }
 774             set
 775             {
 776                 SetProperty(TextEditor.Property.GRAB_HANDLE_PRESSED_IMAGE, new Tizen.NUI.PropertyValue(value));
 777             }
 778         }
 779
 780         /// <summary>
 781         /// The SelectionHandleImageLeft property.
 782         /// </summary>
 783         /// <since_tizen> 3 </since_tizen>
 784         public PropertyMap SelectionHandleImageLeft
 785         {
 786             get
 787             {
 788                 PropertyMap temp = new PropertyMap();
 789                 GetProperty(TextEditor.Property.SELECTION_HANDLE_IMAGE_LEFT).Get(temp);
 790                 return temp;
 791             }
 792             set
 793             {
 794                 SetProperty(TextEditor.Property.SELECTION_HANDLE_IMAGE_LEFT, new Tizen.NUI.PropertyValue(value));
 795             }
 796         }
 797
 798         /// <summary>
 799         /// The SelectionHandleImageRight property.
 800         /// </summary>
 801         /// <since_tizen> 3 </since_tizen>
 802         public PropertyMap SelectionHandleImageRight
 803         {
 804             get
 805             {
 806                 PropertyMap temp = new PropertyMap();
 807                 GetProperty(TextEditor.Property.SELECTION_HANDLE_IMAGE_RIGHT).Get(temp);
 808                 return temp;
 809             }
 810             set
 811             {
 812                 SetProperty(TextEditor.Property.SELECTION_HANDLE_IMAGE_RIGHT, new Tizen.NUI.PropertyValue(value));
 813             }
 814         }
 815
 816         /// <summary>
 817         /// The SelectionHandlePressedImageLeft property.
 818         /// </summary>
 819         /// <since_tizen> 3 </since_tizen>
 820         public PropertyMap SelectionHandlePressedImageLeft
 821         {
 822             get
 823             {
 824                 PropertyMap temp = new PropertyMap();
 825                 GetProperty(TextEditor.Property.SELECTION_HANDLE_PRESSED_IMAGE_LEFT).Get(temp);
 826                 return temp;
 827             }
 828             set
 829             {
 830                 SetProperty(TextEditor.Property.SELECTION_HANDLE_PRESSED_IMAGE_LEFT, new Tizen.NUI.PropertyValue(value));
 831             }
 832         }
 833
 834         /// <summary>
 835         /// The SelectionHandlePressedImageRight property.
 836         /// </summary>
 837         /// <since_tizen> 3 </since_tizen>
 838         public PropertyMap SelectionHandlePressedImageRight
 839         {
 840             get
 841             {
 842                 PropertyMap temp = new PropertyMap();
 843                 GetProperty(TextEditor.Property.SELECTION_HANDLE_PRESSED_IMAGE_RIGHT).Get(temp);
 844                 return temp;
 845             }
 846             set
 847             {
 848                 SetProperty(TextEditor.Property.SELECTION_HANDLE_PRESSED_IMAGE_RIGHT, new Tizen.NUI.PropertyValue(value));
 849             }
 850         }
 851
 852         /// <summary>
 853         /// The SelectionHandleMarkerImageLeft property.
 854         /// </summary>
 855         /// <since_tizen> 3 </since_tizen>
 856         public PropertyMap SelectionHandleMarkerImageLeft
 857         {
 858             get
 859             {
 860                 PropertyMap temp = new PropertyMap();
 861                 GetProperty(TextEditor.Property.SELECTION_HANDLE_MARKER_IMAGE_LEFT).Get(temp);
 862                 return temp;
 863             }
 864             set
 865             {
 866                 SetProperty(TextEditor.Property.SELECTION_HANDLE_MARKER_IMAGE_LEFT, new Tizen.NUI.PropertyValue(value));
 867             }
 868         }
 869
 870         /// <summary>
 871         /// The SelectionHandleMarkerImageRight property.
 872         /// </summary>
 873         /// <since_tizen> 3 </since_tizen>
 874         public PropertyMap SelectionHandleMarkerImageRight
 875         {
 876             get
 877             {
 878                 PropertyMap temp = new PropertyMap();
 879                 GetProperty(TextEditor.Property.SELECTION_HANDLE_MARKER_IMAGE_RIGHT).Get(temp);
 880                 return temp;
 881             }
 882             set
 883             {
 884                 SetProperty(TextEditor.Property.SELECTION_HANDLE_MARKER_IMAGE_RIGHT, new Tizen.NUI.PropertyValue(value));
 885             }
 886         }
 887
 888         /// <summary>
 889         /// The SelectionHighlightColor property.
 890         /// </summary>
 891         /// <since_tizen> 3 </since_tizen>
 892         public Vector4 SelectionHighlightColor
 893         {
 894             get
 895             {
 896                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 897                 GetProperty(TextEditor.Property.SELECTION_HIGHLIGHT_COLOR).Get(temp);
 898                 return temp;
 899             }
 900             set
 901             {
 902                 SetProperty(TextEditor.Property.SELECTION_HIGHLIGHT_COLOR, new Tizen.NUI.PropertyValue(value));
 903             }
 904         }
 905
 906         /// <summary>
 907         /// The DecorationBoundingBox property.
 908         /// </summary>
 909         /// <since_tizen> 3 </since_tizen>
 910         public Rectangle DecorationBoundingBox
 911         {
 912             get
 913             {
 914                 Rectangle temp = new Rectangle(0, 0, 0, 0);
 915                 GetProperty(TextEditor.Property.DECORATION_BOUNDING_BOX).Get(temp);
 916                 return temp;
 917             }
 918             set
 919             {
 920                 SetProperty(TextEditor.Property.DECORATION_BOUNDING_BOX, new Tizen.NUI.PropertyValue(value));
 921             }
 922         }
 923
 924         /// <summary>
 925         /// The EnableMarkup property.
 926         /// </summary>
 927         /// <since_tizen> 3 </since_tizen>
 928         public bool EnableMarkup
 929         {
 930             get
 931             {
 932                 bool temp = false;
 933                 GetProperty(TextEditor.Property.ENABLE_MARKUP).Get(out temp);
 934                 return temp;
 935             }
 936             set
 937             {
 938                 SetProperty(TextEditor.Property.ENABLE_MARKUP, new Tizen.NUI.PropertyValue(value));
 939             }
 940         }
 941
 942         /// <summary>
 943         /// The InputColor property.
 944         /// </summary>
 945         /// <since_tizen> 3 </since_tizen>
 946         public Vector4 InputColor
 947         {
 948             get
 949             {
 950                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 951                 GetProperty(TextEditor.Property.INPUT_COLOR).Get(temp);
 952                 return temp;
 953             }
 954             set
 955             {
 956                 SetProperty(TextEditor.Property.INPUT_COLOR, new Tizen.NUI.PropertyValue(value));
 957             }
 958         }
 959
 960         /// <summary>
 961         /// The InputFontFamily property.
 962         /// </summary>
 963         /// <since_tizen> 3 </since_tizen>
 964         public string InputFontFamily
 965         {
 966             get
 967             {
 968                 string temp;
 969                 GetProperty(TextEditor.Property.INPUT_FONT_FAMILY).Get(out temp);
 970                 return temp;
 971             }
 972             set
 973             {
 974                 SetProperty(TextEditor.Property.INPUT_FONT_FAMILY, new Tizen.NUI.PropertyValue(value));
 975             }
 976         }
 977
 978         /// <summary>
 979         /// The InputFontStyle property.
 980         /// </summary>
 981         /// <since_tizen> 3 </since_tizen>
 982         public PropertyMap InputFontStyle
 983         {
 984             get
 985             {
 986                 PropertyMap temp = new PropertyMap();
 987                 GetProperty(TextEditor.Property.INPUT_FONT_STYLE).Get(temp);
 988                 return temp;
 989             }
 990             set
 991             {
 992                 SetProperty(TextEditor.Property.INPUT_FONT_STYLE, new Tizen.NUI.PropertyValue(value));
 993             }
 994         }
 995
 996         /// <summary>
 997         /// The InputPointSize property.
 998         /// </summary>
 999         /// <since_tizen> 3 </since_tizen>
1000         public float InputPointSize
1001         {
1002             get
1003             {
1004                 float temp = 0.0f;
1005                 GetProperty(TextEditor.Property.INPUT_POINT_SIZE).Get(out temp);
1006                 return temp;
1007             }
1008             set
1009             {
1010                 SetProperty(TextEditor.Property.INPUT_POINT_SIZE, new Tizen.NUI.PropertyValue(value));
1011             }
1012         }
1013
1014         /// <summary>
1015         /// The LineSpacing property.
1016         /// </summary>
1017         /// <since_tizen> 3 </since_tizen>
1018         public float LineSpacing
1019         {
1020             get
1021             {
1022                 float temp = 0.0f;
1023                 GetProperty(TextEditor.Property.LINE_SPACING).Get(out temp);
1024                 return temp;
1025             }
1026             set
1027             {
1028                 SetProperty(TextEditor.Property.LINE_SPACING, new Tizen.NUI.PropertyValue(value));
1029             }
1030         }
1031
1032         /// <summary>
1033         /// The InputLineSpacing property.
1034         /// </summary>
1035         /// <since_tizen> 3 </since_tizen>
1036         public float InputLineSpacing
1037         {
1038             get
1039             {
1040                 float temp = 0.0f;
1041                 GetProperty(TextEditor.Property.INPUT_LINE_SPACING).Get(out temp);
1042                 return temp;
1043             }
1044             set
1045             {
1046                 SetProperty(TextEditor.Property.INPUT_LINE_SPACING, new Tizen.NUI.PropertyValue(value));
1047             }
1048         }
1049
1050         /// <summary>
1051         /// The Underline property.
1052         /// </summary>
1053         /// <since_tizen> 3 </since_tizen>
1054         public PropertyMap Underline
1055         {
1056             get
1057             {
1058                 PropertyMap temp = new PropertyMap();
1059                 GetProperty(TextEditor.Property.UNDERLINE).Get(temp);
1060                 return temp;
1061             }
1062             set
1063             {
1064                 SetProperty(TextEditor.Property.UNDERLINE, new Tizen.NUI.PropertyValue(value));
1065             }
1066         }
1067
1068         /// <summary>
1069         /// The InputUnderline property.
1070         /// </summary>
1071         /// <since_tizen> 3 </since_tizen>
1072         public string InputUnderline
1073         {
1074             get
1075             {
1076                 string temp;
1077                 GetProperty(TextEditor.Property.INPUT_UNDERLINE).Get(out temp);
1078                 return temp;
1079             }
1080             set
1081             {
1082                 SetProperty(TextEditor.Property.INPUT_UNDERLINE, new Tizen.NUI.PropertyValue(value));
1083             }
1084         }
1085
1086         /// <summary>
1087         /// The Shadow property.
1088         /// </summary>
1089         /// <since_tizen> 3 </since_tizen>
1090         public PropertyMap Shadow
1091         {
1092             get
1093             {
1094                 PropertyMap temp = new PropertyMap();
1095                 GetProperty(TextEditor.Property.SHADOW).Get(temp);
1096                 return temp;
1097             }
1098             set
1099             {
1100                 SetProperty(TextEditor.Property.SHADOW, new Tizen.NUI.PropertyValue(value));
1101             }
1102         }
1103
1104         /// <summary>
1105         /// The InputShadow property.
1106         /// </summary>
1107         /// <since_tizen> 3 </since_tizen>
1108         public string InputShadow
1109         {
1110             get
1111             {
1112                 string temp;
1113                 GetProperty(TextEditor.Property.INPUT_SHADOW).Get(out temp);
1114                 return temp;
1115             }
1116             set
1117             {
1118                 SetProperty(TextEditor.Property.INPUT_SHADOW, new Tizen.NUI.PropertyValue(value));
1119             }
1120         }
1121
1122         /// <summary>
1123         /// The Emboss property.
1124         /// </summary>
1125         /// <since_tizen> 3 </since_tizen>
1126         public string Emboss
1127         {
1128             get
1129             {
1130                 string temp;
1131                 GetProperty(TextEditor.Property.EMBOSS).Get(out temp);
1132                 return temp;
1133             }
1134             set
1135             {
1136                 SetProperty(TextEditor.Property.EMBOSS, new Tizen.NUI.PropertyValue(value));
1137             }
1138         }
1139
1140         /// <summary>
1141         /// The InputEmboss property.
1142         /// </summary>
1143         /// <since_tizen> 3 </since_tizen>
1144         public string InputEmboss
1145         {
1146             get
1147             {
1148                 string temp;
1149                 GetProperty(TextEditor.Property.INPUT_EMBOSS).Get(out temp);
1150                 return temp;
1151             }
1152             set
1153             {
1154                 SetProperty(TextEditor.Property.INPUT_EMBOSS, new Tizen.NUI.PropertyValue(value));
1155             }
1156         }
1157
1158         /// <summary>
1159         /// The Outline property.
1160         /// </summary>
1161         /// <since_tizen> 3 </since_tizen>
1162         public PropertyMap Outline
1163         {
1164             get
1165             {
1166                 PropertyMap temp = new PropertyMap();
1167                 GetProperty(TextEditor.Property.OUTLINE).Get(temp);
1168                 return temp;
1169             }
1170             set
1171             {
1172                 SetProperty(TextEditor.Property.OUTLINE, new Tizen.NUI.PropertyValue(value));
1173             }
1174         }
1175
1176         /// <summary>
1177         /// The InputOutline property.
1178         /// </summary>
1179         /// <since_tizen> 3 </since_tizen>
1180         public string InputOutline
1181         {
1182             get
1183             {
1184                 string temp;
1185                 GetProperty(TextEditor.Property.INPUT_OUTLINE).Get(out temp);
1186                 return temp;
1187             }
1188             set
1189             {
1190                 SetProperty(TextEditor.Property.INPUT_OUTLINE, new Tizen.NUI.PropertyValue(value));
1191             }
1192         }
1193
1194         /// <summary>
1195         /// The SmoothScroll property.
1196         /// </summary>
1197         /// <since_tizen> 3 </since_tizen>
1198         public bool SmoothScroll
1199         {
1200             get
1201             {
1202                 bool temp = false;
1203                 GetProperty(TextEditor.Property.SMOOTH_SCROLL).Get(out temp);
1204                 return temp;
1205             }
1206             set
1207             {
1208                 SetProperty(TextEditor.Property.SMOOTH_SCROLL, new Tizen.NUI.PropertyValue(value));
1209             }
1210         }
1211
1212         /// <summary>
1213         /// The SmoothScrollDuration property.
1214         /// </summary>
1215         /// <since_tizen> 3 </since_tizen>
1216         public float SmoothScrollDuration
1217         {
1218             get
1219             {
1220                 float temp = 0.0f;
1221                 GetProperty(TextEditor.Property.SMOOTH_SCROLL_DURATION).Get(out temp);
1222                 return temp;
1223             }
1224             set
1225             {
1226                 SetProperty(TextEditor.Property.SMOOTH_SCROLL_DURATION, new Tizen.NUI.PropertyValue(value));
1227             }
1228         }
1229
1230         /// <summary>
1231         /// The EnableScrollBar property.
1232         /// </summary>
1233         /// <since_tizen> 3 </since_tizen>
1234         public bool EnableScrollBar
1235         {
1236             get
1237             {
1238                 bool temp = false;
1239                 GetProperty(TextEditor.Property.ENABLE_SCROLL_BAR).Get(out temp);
1240                 return temp;
1241             }
1242             set
1243             {
1244                 SetProperty(TextEditor.Property.ENABLE_SCROLL_BAR, new Tizen.NUI.PropertyValue(value));
1245             }
1246         }
1247
1248         /// <summary>
1249         /// The ScrollBarShowDuration property.
1250         /// </summary>
1251         /// <since_tizen> 3 </since_tizen>
1252         public float ScrollBarShowDuration
1253         {
1254             get
1255             {
1256                 float temp = 0.0f;
1257                 GetProperty(TextEditor.Property.SCROLL_BAR_SHOW_DURATION).Get(out temp);
1258                 return temp;
1259             }
1260             set
1261             {
1262                 SetProperty(TextEditor.Property.SCROLL_BAR_SHOW_DURATION, new Tizen.NUI.PropertyValue(value));
1263             }
1264         }
1265
1266         /// <summary>
1267         /// The ScrollBarFadeDuration property.
1268         /// </summary>
1269         /// <since_tizen> 3 </since_tizen>
1270         public float ScrollBarFadeDuration
1271         {
1272             get
1273             {
1274                 float temp = 0.0f;
1275                 GetProperty(TextEditor.Property.SCROLL_BAR_FADE_DURATION).Get(out temp);
1276                 return temp;
1277             }
1278             set
1279             {
1280                 SetProperty(TextEditor.Property.SCROLL_BAR_FADE_DURATION, new Tizen.NUI.PropertyValue(value));
1281             }
1282         }
1283
1284         /// <summary>
1285         /// The PixelSize property.
1286         /// </summary>
1287         /// <since_tizen> 3 </since_tizen>
1288         public float PixelSize
1289         {
1290             get
1291             {
1292                 float temp = 0.0f;
1293                 GetProperty(TextEditor.Property.PIXEL_SIZE).Get(out temp);
1294                 return temp;
1295             }
1296             set
1297             {
1298                 SetProperty(TextEditor.Property.PIXEL_SIZE, new Tizen.NUI.PropertyValue(value));
1299             }
1300         }
1301
1302         /// <summary>
1303         /// The line count of the text.
1304         /// </summary>
1305         /// <since_tizen> 3 </since_tizen>
1306         public int LineCount
1307         {
1308             get
1309             {
1310                 int temp = 0;
1311                 GetProperty(TextEditor.Property.LINE_COUNT).Get(out temp);
1312                 return temp;
1313             }
1314         }
1315
1316         /// <summary>
1317         /// The text to display when the TextEditor is empty and inactive.
1318         /// </summary>
1319         /// <since_tizen> 3 </since_tizen>
1320         public string PlaceholderText
1321         {
1322             get
1323             {
1324                 string temp;
1325                 GetProperty(TextEditor.Property.PLACEHOLDER_TEXT).Get(out temp);
1326                 return temp;
1327             }
1328             set
1329             {
1330                 SetProperty(TextEditor.Property.PLACEHOLDER_TEXT, new Tizen.NUI.PropertyValue(value));
1331             }
1332         }
1333
1334         /// <summary>
1335         /// The Placeholder text color.
1336         /// </summary>
1337         /// <since_tizen> 3 </since_tizen>
1338         public Color PlaceholderTextColor
1339         {
1340             get
1341             {
1342                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1343                 GetProperty(TextEditor.Property.PLACEHOLDER_TEXT_COLOR).Get(temp);
1344                 return temp;
1345             }
1346             set
1347             {
1348                 SetProperty(TextEditor.Property.PLACEHOLDER_TEXT_COLOR, new Tizen.NUI.PropertyValue(value));
1349             }
1350         }
1351
1352         /// <summary>
1353         /// The EnableSelection property.
1354         /// </summary>
1355         /// <since_tizen> 3 </since_tizen>
1356         public bool EnableSelection
1357         {
1358             get
1359             {
1360                 bool temp = false;
1361                 GetProperty(TextEditor.Property.ENABLE_SELECTION).Get(out temp);
1362                 return temp;
1363             }
1364             set
1365             {
1366                 SetProperty(TextEditor.Property.ENABLE_SELECTION, new Tizen.NUI.PropertyValue(value));
1367             }
1368         }
1369
1370         /// <summary>
1371         /// The Placeholder property.
1372         /// Gets or sets the placeholder: text, color, font family, font style, point size, and pixel size.
1373         /// </summary>
1374         /// <example>
1375         /// The following example demonstrates how to set the placeholder property.
1376         /// <code>
1377         /// PropertyMap propertyMap = new PropertyMap();
1378         /// propertyMap.Add("text", new PropertyValue("Setting Placeholder Text"));
1379         /// propertyMap.Add("textFocused", new PropertyValue("Setting Placeholder Text Focused"));
1380         /// propertyMap.Add("color", new PropertyValue(Color.Red));
1381         /// propertyMap.Add("fontFamily", new PropertyValue("Arial"));
1382         /// propertyMap.Add("pointSize", new PropertyValue(12.0f));
1383         ///
1384         /// PropertyMap fontStyleMap = new PropertyMap();
1385         /// fontStyleMap.Add("weight", new PropertyValue("bold"));
1386         /// fontStyleMap.Add("width", new PropertyValue("condensed"));
1387         /// fontStyleMap.Add("slant", new PropertyValue("italic"));
1388         /// propertyMap.Add("fontStyle", new PropertyValue(fontStyleMap));
1389         ///
1390         /// TextEditor editor = new TextEditor();
1391         /// editor.Placeholder = propertyMap;
1392         /// </code>
1393         /// </example>
1394         /// <since_tizen> 3 </since_tizen>
1395         public Tizen.NUI.PropertyMap Placeholder
1396         {
1397             get
1398             {
1399                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1400                 GetProperty(TextEditor.Property.PLACEHOLDER).Get(temp);
1401                 return temp;
1402             }
1403             set
1404             {
1405                 SetProperty(TextEditor.Property.PLACEHOLDER, new Tizen.NUI.PropertyValue(value));
1406             }
1407         }
1408
1409         /// <summary>
1410         /// The LineWrapMode property.<br />
1411         /// The line wrap mode when the text lines over the layout width.<br />
1412         /// </summary>
1413         /// <since_tizen> 4 </since_tizen>
1414         public LineWrapMode LineWrapMode
1415         {
1416             get
1417             {
1418                 int temp;
1419                 if(GetProperty(TextEditor.Property.LINE_WRAP_MODE).Get(out temp) == false)
1420                 {
1421                     NUILog.Error("LineWrapMode get error!");
1422                 }
1423                 return (LineWrapMode)temp;
1424             }
1425             set
1426             {
1427                 SetProperty(TextEditor.Property.LINE_WRAP_MODE, new Tizen.NUI.PropertyValue((int)value));
1428             }
1429         }
1430
1431     }
1432
1433 }