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