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

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