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