inc/FUiCtrlEditField.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        FUiCtrlEditField.h
  20  * @brief       This is the header file for the %EditField class.
  21  *
  22  * This header file contains the declarations of the %EditField class and its helper classes.
  23  */
  24
  25 #ifndef _FUI_CTRL_EDIT_FIELD_H_
  26 #define _FUI_CTRL_EDIT_FIELD_H_
  27
  28 #include <FBaseCharacter.h>
  29 #include <FBaseString.h>
  30 #include <FGrpBitmap.h>
  31 #include <FGrpPoint.h>
  32 #include <FGrpRectangle.h>
  33 #include <FLclLocale.h>
  34 #include <FUiControl.h>
  35 #include <FUiContainer.h>
  36 #include <FUiCtrlControlsTypes.h>
  37 #include <FUiCtrlEditTypes.h>
  38 #include <FUiCtrlIEditTextFilter.h>
  39 #include <FUiCtrlInputTypes.h>
  40 #include <FUiIActionEventListener.h>
  41 #include <FUiIKeypadEventListener.h>
  42 #include <FUiILanguageEventListener.h>
  43 #include <FUiIScrollPanelEventListener.h>
  44 #include <FUiITextBlockEventListener.h>
  45 #include <FUiITextEventListener.h>
  46 #include <FUiIUiLinkEventListener.h>
  47
  48 namespace Tizen { namespace Locales
  49 {
  50 class Locale;
  51 }}
  52
  53 namespace Tizen { namespace Ui { namespace Controls
  54 {
  55
  56 /**
  57  * @class       EditField
  58  * @brief   This class defines a common behavior for an %EditField control.
  59  *
  60  * @since               2.0
  61  *
  62  * The %EditField class displays a single-line text editor.
  63  *
  64  * For more information on the class features, see <a href="../org.tizen.native.appprogramming/html/guide/ui/implementing_editfield_editarea.htm">EditArea and EditField</a>.
  65  *
  66  * The following example demonstrates how to use the %EditField class.
  67  *
  68  * @code
  69 // Sample code for EditFieldSample.h
  70 #include <FUi.h>
  71
  72 class EditFieldSample
  73         : public Tizen::Ui::Controls::Form
  74         , public Tizen::Ui::ITextEventListener
  75 {
  76 public:
  77         EditFieldSample(void)
  78         : __pEditField(null){}
  79
  80         bool Initialize(void);
  81         virtual result OnInitializing(void);
  82
  83         // ITextEventListener
  84         virtual void OnTextValueChanged(const Tizen::Ui::Control& source);
  85         virtual void OnTextValueChangeCanceled(const Tizen::Ui::Control& source);
  86
  87 private:
  88         Tizen::Ui::Controls::EditField* __pEditField;
  89 };
  90  * @endcode
  91  *
  92  * @code
  93 // Sample code for EditFieldSample.cpp
  94 #include <FGraphics.h>
  95
  96 #include "EditFieldSample.h"
  97
  98 using namespace Tizen::Graphics;
  99 using namespace Tizen::Ui::Controls;
 100
 101 bool
 102 EditFieldSample::Initialize(void)
 103 {
 104         Construct(FORM_STYLE_NORMAL);
 105         return true;
 106 }
 107
 108 result
 109 EditFieldSample::OnInitializing(void)
 110 {
 111         result r = E_SUCCESS;
 112
 113         // Creates an instance of EditField
 114         __pEditField = new EditField();
 115         __pEditField->Construct(Rectangle(50, 100, 400, 150));
 116         __pEditField->AddTextEventListener(*this);
 117
 118         //Adds the edit field to the Form
 119         AddControl(*__pEditField);
 120
 121         return r;
 122 }
 123
 124 // ITextEventListener implementation
 125 void
 126 EditFieldSample::OnTextValueChanged(const Tizen::Ui::Control& source)
 127 {
 128     // ....
 129 }
 130
 131 void
 132 EditFieldSample::OnTextValueChangeCanceled(const Tizen::Ui::Control& source)
 133 {
 134     // ....
 135 }
 136  * @endcode
 137  *
 138  */
 139
 140 class _OSP_EXPORT_ EditField
 141         : public Tizen::Ui::Control
 142 {
 143 public:
 144         /**
 145          * The object is not fully constructed after this constructor is called. For full construction, the Construct() method must be called right after calling this constructor.
 146          *
 147          * @since               2.0
 148          */
 149         EditField(void);
 150
 151         /**
 152         * This polymorphic destructor should be overridden if required. This way, the destructors of the derived classes are called when the destructor of this interface is called.
 153         *
 154         * @since                2.0
 155         */
 156         virtual ~EditField(void);
 157
 158         /**
 159          * Initializes this instance of the %EditField control with the specified parameters.
 160          *
 161          * @since                       2.0
 162          *
 163          * @return                      An error code
 164          * @param[in]           rect            An instance of the Graphics::Rectangle class @n
 165          *                                                                              This instance represents the x and y coordinates of the top-left corner of the created window along with
 166          *                                                                              the width and height of the control.
 167          * @param[in]   style                   The style of the %EditField control
 168          * @param[in]   inputStyle              The input style of the %EditField control
 169          * @param[in]   showTitle                               Set to @c true to display the title, @n
 170          *                                                              else @c false
 171          * @param[in]   limitLength             The limit for the length of the text in the %EditField control
 172          * @param[in]   groupStyle              The table view style of the %EditField control
 173          * @exception   E_SUCCESS                               The method is successful.
 174          * @exception   E_INVALID_ARG                   The specified @c limitLength is less than or equal to @c 0, or @n
 175          *                                                                              either the @c rect.width or the @c rect.height is less than @c 0.
 176          * @exception   E_UNSUPPORTED_OPTION    The specified option is not supported. @n
 177          *                                                                              The title is not supported by small style %EditField.
 178          * @exception   E_SYSTEM                                A system error has occurred.
 179          * @remarks             A control is fully usable only after it has been added to a container. Therefore, some methods may fail if the control has been used
 180          *                              earlier. The %EditField style of SMALL property cannot be used together with group styles. @n
 181          *                              If the specified size is less than the minimum size, %EditField is constructed with the minimum size.
 182          * @remarks             Following are the input styles used for creating the different orientations of a keypad: @n
 183          *              -       INPUT_STYLE_FULLSCREEN: The orientation is decided by the G-sensor value. @n
 184          *              -       INPUT_STYLE_OVERLAY: The orientation is the same as that of a parent form.
 185          */
 186         result Construct(const Tizen::Graphics::Rectangle& rect, EditFieldStyle style = EDIT_FIELD_STYLE_NORMAL, InputStyle inputStyle = INPUT_STYLE_FULLSCREEN, bool showTitle = false, int limitLength = 100, GroupStyle groupStyle = GROUP_STYLE_NONE);
 187
 188         /**
 189          * Initializes this instance of the %EditField control with the specified parameters.
 190          *
 191          * @since                       2.1
 192          *
 193          * @return                      An error code
 194          * @param[in]           rect            An instance of the Graphics::FloatRectangle class @n
 195          *                                                                              This instance represents the x and y coordinates of the top-left corner of the created window along with
 196          *                                                                              the width and height of the control.
 197          * @param[in]   style                   The style of the %EditField control
 198          * @param[in]   inputStyle              The input style of the %EditField control
 199          * @param[in]   showTitle                               Set to @c true to display the title, @n
 200          *                                                              else @c false
 201          * @param[in]   limitLength     The limit for the length of the text in the %EditField control
 202          * @param[in]   groupStyle              The table view style of the %EditField control
 203          * @exception   E_SUCCESS                               The method is successful.
 204          * @exception   E_INVALID_ARG                   The specified @c limitLength is less than or equal to @c 0, or @n
 205          *                                                                              either the @c rect.width or the @c rect.height is less than @c 0.
 206          * @exception   E_UNSUPPORTED_OPTION    The specified option is not supported. @n
 207          *                                                                              The title is not supported by small style %EditField.
 208          * @exception   E_SYSTEM                                A system error has occurred.
 209          * @remarks     A control is fully usable only after it has been added to a container. Therefore, some methods may fail if the control has been used
 210          *                              earlier. The %EditField style of SMALL property cannot be used together with group styles. @n
 211          *                              If the specified size is less than the minimum size, %EditField is constructed with the minimum size.
 212          * @remarks     Following are the input styles used for creating the different orientations of a keypad: @n
 213          *                              -       INPUT_STYLE_FULLSCREEN: The orientation is decided by the G-sensor value. @n
 214          *                              -       INPUT_STYLE_OVERLAY: The orientation is the same as that of a parent form.
 215          */
 216         result Construct(const Tizen::Graphics::FloatRectangle& rect, EditFieldStyle style = EDIT_FIELD_STYLE_NORMAL, InputStyle inputStyle = INPUT_STYLE_FULLSCREEN, bool showTitle = false, int limitLength = 100, GroupStyle groupStyle = GROUP_STYLE_NONE);
 217
 218         /**
 219          * Initializes this instance of the %EditField control.
 220          *
 221          * @since        2.0
 222          *
 223          * @return       An error code
 224          * @param[in]   rect                    The bounds of %EditField
 225          * @param[in]    style           The style of the %EditField control
 226          * @param[in]    inputStyle      The input style of the %EditField control
 227          * @param[in]    titleStyle      The title style
 228          * @param[in]   enableClear                 Set to @c true to enable the clear button, @n
 229          *                                                                              else @c false
 230          * @param[in]    limitLength     The limit of the length of text in the %EditField control
 231          * @param[in]    groupStyle      The table view style of the %EditField control
 232          * @exception   E_SUCCESS               The method is successful.
 233          * @exception   E_INVALID_ARG           A specified input parameter is invalid. @n
 234          *                                      The specified @c limitLength is less than or equal to @c 0. @n
 235          *                                                                      The specified @c rect.width or the @c rect.height is less than @c 0.
 236          * @exception   E_UNSUPPORTED_OPTION    The specified option is not supported. @n
 237          *                                                                              Title is not supported in small style %EditField.
 238          * @exception   E_SYSTEM                                A system error has occurred.
 239          * @remarks              A control is fully usable only after it has been added to a container. Therefore, some methods may fail if the control is used earlier.
 240          *                              The %EditField style of SMALL property cannot be used together with group styles. @n
 241          *               If the specified size is less than the minimum size, EditFied() is constructed with the minimum size.
 242          * @remarks      Following are the input styles used for creating different orientations of a keypad: @n
 243          *                                                                              -   INPUT_STYLE_FULLSCREEN: The orientation is decided by the G-sensor value.@n
 244          *                                                                              -   INPUT_STYLE_OVERLAY: The orientation is similar to the parent Form.
 245          */
 246         result Construct(const Tizen::Graphics::Rectangle& rect, EditFieldStyle style, InputStyle inputStyle, EditFieldTitleStyle titleStyle, bool enableClear = false, int limitLength = 100, GroupStyle groupStyle = GROUP_STYLE_NONE);
 247
 248         /**
 249          * Initializes this instance of the %EditField control.
 250          *
 251          * @since                2.1
 252          *
 253          * @return               An error code
 254          * @param[in]   rect                                    The bounds of %EditField
 255          * @param[in]    style                   The style of the %EditField control
 256          * @param[in]    inputStyle      The input style of the %EditField control
 257          * @param[in]    titleStyle      The title style
 258          * @param[in]   enableClear                     Set to @c true to enable the clear button, @n
 259          *                                                                              else @c false
 260          * @param[in]    limitLength     The limit of the length of text in the %EditField control
 261          * @param[in]    groupStyle      The table view style of the %EditField control
 262          * @exception   E_SUCCESS                               The method is successful.
 263          * @exception   E_INVALID_ARG                   A specified input parameter is invalid. @n
 264          *                                                                              The specified @c limitLength is less than or equal to @c 0. @n
 265          *                                                                              The specified @c rect.width or the @c rect.height is less than @c 0.
 266          * @exception   E_UNSUPPORTED_OPTION    The specified option is not supported. @n
 267          *                                                                              Title is not supported in small style %EditField.
 268          * @exception   E_SYSTEM                                A system error has occurred.
 269          * @remarks      A control is fully usable only after it has been added to a container. Therefore, some methods may fail if the control is used earlier.
 270          *                              The %EditField style of SMALL property cannot be used together with group styles. @n
 271          *                               If the specified size is less than the minimum size, EditFied() is constructed with the minimum size.
 272          * @remarks      Following are the input styles used for creating different orientations of a keypad: @n
 273          *                                                                              -       INPUT_STYLE_FULLSCREEN: The orientation is decided by the G-sensor value.@n
 274          *                                                                              -       INPUT_STYLE_OVERLAY: The orientation is similar to the parent Form.
 275          */
 276         result Construct(const Tizen::Graphics::FloatRectangle& rect, EditFieldStyle style, InputStyle inputStyle, EditFieldTitleStyle titleStyle, bool enableClear = false, int limitLength = 100, GroupStyle groupStyle = GROUP_STYLE_NONE);
 277
 278 public:
 279         /**
 280          * Gets the horizontal text alignment of the %EditField control.
 281          *
 282          * @since               2.0
 283          *
 284          * @return              The horizontal text alignment
 285          * @exception   E_SUCCESS                       The method is successful.
 286          * @exception   E_SYSTEM                        A system error has occurred.
 287          * @remarks         The specific error code can be accessed using the GetLastResult() method.
 288          * @see                 SetTextAlignment()
 289          */
 290         HorizontalAlignment GetTextAlignment(void) const;
 291
 292         /**
 293          * Sets the horizontal text alignment of the %EditField control.
 294          *
 295          * @since       2.0
 296          *
 297          * @return              An error code
 298          * @exception   E_SUCCESS                       The method is successful.
 299          * @exception   E_SYSTEM                        A system error has occurred.
 300          * @see                 GetTextAlignment()
 301          */
 302         result SetTextAlignment(HorizontalAlignment alignment);
 303
 304         /**
 305          * Checks whether the view mode is enabled.
 306          *
 307          * @since       2.0
 308          *
 309          * @return              @c true if the view mode is enabled, @n
 310          *              else @c false
 311          * @exception   E_SUCCESS                       The method is successful.
 312          * @exception   E_SYSTEM                        A system error has occurred.
 313          * @remarks     The specific error code can be accessed using the GetLastResult() method. @n
 314          *                              In the view mode, the auto-detected links are displayed as linked text.
 315          * @see   SetViewModeEnabled()
 316          */
 317         bool IsViewModeEnabled(void) const;
 318
 319         /**
 320          * Enables or disables the view mode.
 321          *
 322          * @since       2.0
 323          *
 324          * @return              An error code
 325          * @param[in]   enable              Set to @c true to enable the view mode, @n
 326          *                                                                      else @c false
 327          * @exception   E_SUCCESS                       The method is successful.
 328          * @exception   E_SYSTEM                        A system error has occurred.
 329          * @remarks             In the view mode, the auto-detected links are displayed as linked text.
 330          * @see         IsViewModeEnabled()
 331          */
 332         result SetViewModeEnabled(bool enable);
 333
 334         /**
 335          * Sets the auto-link mask.
 336          *
 337          * @since               2.0
 338          *
 339          * @return              An error code
 340          * @param[in]   autoLinks                               The auto-link mask @n
 341          *                                                                              Multiple link types can be combined using bitwise OR operator (see Tizen::Base::Utility::LinkType). @n
 342          *                                                                              For more information, see <a href="../org.tizen.native.appprogramming/html/guide/ui/auto_link_detection.htm">AutoLink Detection</a>.
 343          * @exception   E_SUCCESS                               The method is successful.
 344          * @exception   E_UNSUPPORTED_OPERATION The current state of the instance prohibits the execution of the specified operation @n
 345          *                                                                              The input style is not @c INPUT_STYLE_OVERLAY.
 346          * @exception   E_SYSTEM                                A system error has occurred.
 347          * @remarks             When @c autoLinks is set to @c 0, the auto-link detection is disabled.
 348          * @see                 Tizen::Base::Utility::LinkType
 349          * @see                 GetAutoLinkMask()
 350          * @see                 IsViewModeEnabled()
 351          * @see                 SetViewModeEnabled()
 352          */
 353         result SetAutoLinkMask(unsigned long autoLinks);
 354
 355         /**
 356          * Gets the auto-link mask.
 357          *
 358          * @since               2.0
 359          *
 360          * @return              The auto-link mask
 361          * @exception   E_SUCCESS                               The method is successful.
 362          * @exception   E_UNSUPPORTED_OPERATION The current state of the instance prohibits the execution of the specified operation @n
 363          *                                                                              The input style is not @c INPUT_STYLE_OVERLAY.
 364          * @exception   E_SYSTEM                                A system error has occurred.
 365          * @remarks             The specific error code can be accessed using the GetLastResult() method.
 366          * @see                 SetAutoLinkMask()
 367          */
 368         unsigned long GetAutoLinkMask(void) const;
 369
 370         /**
 371          * Adds a link event listener.
 372          *
 373          * @since               2.0
 374          *
 375          * @param[in]   listener        The event listener to add
 376          * @remarks             This method is supported when the input style is @c INPUT_STYLE_OVERLAY. @n
 377          *                              The added listener is notified when the links are selected by the user.
 378          * @see                 RemoveUiLinkEventListener()
 379          */
 380         void AddUiLinkEventListener(Tizen::Ui::IUiLinkEventListener& listener);
 381
 382         /**
 383          * Removes the specified link event listener. @n
 384          * The removed listener cannot listen to events when they are fired.
 385          *
 386          * @since               2.0
 387          *
 388          * @param[in]   listener        The event listener to remove
 389          * @remarks             This method is supported when the input style is @c INPUT_STYLE_OVERLAY.
 390          * @see                 AddUiLinkEventListener()
 391          */
 392         void RemoveUiLinkEventListener(Tizen::Ui::IUiLinkEventListener& listener);
 393
 394         /**
 395          * Gets the margin value of the specified margin type.
 396          *
 397          * @since       2.0
 398          *
 399          * @return          The margin value of the specified margin type, @n
 400          *                              else @c -1 if an error occurs
 401          * @param[in]   marginType              The margin type
 402          * @exception   E_SUCCESS               The method is successful.
 403          * @exception   E_SYSTEM                A system error has occurred.
 404          * @remarks     The specific error code can be accessed using the GetLastResult() method.
 405          * @see         SetMargin()
 406          */
 407         int GetMargin(EditMarginType marginType) const;
 408
 409         /**
 410          * Gets the margin value of the specified margin type.
 411          *
 412          * @since       2.1
 413          *
 414          * @return          The margin value of the specified margin type, @n
 415          *                              else @c -1 if an error occurs
 416          * @param[in]   marginType              The margin type
 417          * @exception   E_SUCCESS               The method is successful.
 418          * @exception   E_SYSTEM                A system error has occurred.
 419          * @remarks     The specific error code can be accessed using the GetLastResult() method.
 420          * @see         SetMargin()
 421          */
 422         float GetMarginF(EditMarginType marginType) const;
 423
 424         /**
 425          * Sets the margin for the specified margin type.
 426          *
 427          * @since       2.0
 428          *
 429          * @return          An error code
 430          * @param[in]   marginType              The margin type
 431          * @param[in]   margin                  The margin to set
 432          * @exception   E_SUCCESS               The method is successful.
 433          * @exception   E_INVALID_ARG   A specified input parameter is invalid. @n
 434          *                                                              The specified @c margin cannot be a negative integer.
 435          * @exception   E_SYSTEM                A system error has occurred.
 436          * @see         GetMargin()
 437          */
 438         result SetMargin(EditMarginType marginType, int margin);
 439
 440         /**
 441          * Sets the margin for the specified margin type.
 442          *
 443          * @since       2.1
 444          *
 445          * @return          An error code
 446          * @param[in]   marginType              The margin type
 447          * @param[in]   margin                  The margin to set
 448          * @exception   E_SUCCESS               The method is successful.
 449          * @exception   E_INVALID_ARG   A specified input parameter is invalid. @n
 450          *                                                              The specified @c margin cannot be a negative integer.
 451          * @exception   E_SYSTEM                A system error has occurred.
 452          * @see         GetMarginF()
 453          */
 454         result SetMargin(EditMarginType marginType, float margin);
 455
 456         /**
 457          * Enables or disables the keypad action.
 458          *
 459          * @since 2.0
 460          * @return      An error code
 461          * @param[in]   enable  Set to @c true to enable the keypad action, @n
 462          *                                              else @c false
 463          * @exception   E_SUCCESS                               The method is successful.
 464          * @exception   E_UNSUPPORTED_OPERATION  The underlying input method does not support this operation.
 465          * @remarks     Depending on the value of input param, the enter key have a enable or disable look accordingly.
 466          */
 467         result SetKeypadActionEnabled(bool enable);
 468
 469         /**
 470          * Checks whether the keypad action is enabled.
 471          *
 472          * @since 2.0
 473          * @return              @c true if the keypad action is enabled, @n
 474          *                              else @c false
 475          */
 476         bool IsKeypadActionEnabled(void) const;
 477
 478         /**
 479          * Gets the keypad action type.
 480          *
 481          * @since               2.0
 482          *
 483          * @return      The keypad action
 484          * @exception   E_SUCCESS                               The method is successful.
 485          * @exception   E_UNSUPPORTED_OPERATION The current state of the instance prohibits the execution of the specified operation. @n
 486          *                                                                              The input style is not @c INPUT_STYLE_OVERLAY.
 487          * @exception   E_SYSTEM                A system error has occurred.
 488          * @remarks     The specific error code can be accessed using the GetLastResult() method.
 489          * @see         SetKeypadAction()
 490          */
 491         Tizen::Ui::KeypadAction GetKeypadAction(void) const;
 492
 493         /**
 494          * Sets the keypad action type.
 495          *
 496          * @since               2.0
 497          *
 498          * @return      An error code
 499          * @param[in]   keypadAction                    The keypad action
 500          * @exception   E_SUCCESS                               The method is successful.
 501          * @exception   E_UNSUPPORTED_OPERATION The current state of the instance prohibits the execution of the specified operation. @n
 502          *                                                                              The input style is not @c INPUT_STYLE_OVERLAY.
 503          * @exception   E_SYSTEM                                A system error has occurred.
 504          * @remarks             Based on the specified value of @c keypadAction, the enter key label of the keypad changes accordingly.
 505          * @see         GetKeypadAction()
 506          */
 507         result SetKeypadAction(Tizen::Ui::KeypadAction keypadAction);
 508
 509         /**
 510          * Sets the visibility of the command buttons of the overlay style keypad.
 511          *
 512          * @since               2.0
 513          *
 514          * @return              An error code
 515          * @param[in]   visible                                 Set to @c true to set the visibility of the overlay keypad command buttons, @n
 516          *                                      else @c false
 517          * @exception   E_SUCCESS                               The method is successful.
 518          * @exception   E_UNSUPPORTED_OPERATION The current state of the instance prohibits the execution of the specified operation. @n
 519          *                                                                              The input style is not @c INPUT_STYLE_OVERLAY.
 520          * @exception   E_SYSTEM                                A system error has occurred.
 521          */
 522         result SetOverlayKeypadCommandButtonVisible(bool visible);
 523
 524         /**
 525          * Checks whether the command buttons of the overlay style keypad are visible.
 526          *
 527          * @since       2.0
 528          *
 529          * @return      @c true if the overlay command buttons are visible, @n
 530          *              else @c false
 531          * @exception   E_SUCCESS                   The method is successful.
 532          * @exception   E_UNSUPPORTED_OPERATION         The current state of the instance prohibits the execution of the specified operation. @n
 533          *                                                                                      The input style is not @c INPUT_STYLE_OVERLAY.
 534          * @exception   E_SYSTEM                    A system error has occurred.
 535          * @remarks     The specific error code can be accessed using the GetLastResult() method.
 536          */
 537         bool IsOverlayCommandButtonVisible(void) const;
 538
 539         /**
 540          * Hides the keypad.
 541          *
 542          * @since       2.0
 543          *
 544          * @return      An error code
 545          * @exception   E_SUCCESS                               The method is successful.
 546          * @exception   E_UNSUPPORTED_OPERATION The current state of the instance prohibits the execution of the specified operation. @n
 547          *                                                                              The input style is not @c INPUT_STYLE_OVERLAY.
 548          * @exception   E_SYSTEM                                A system error has occurred.
 549          * @see         ShowKeypad()
 550          */
 551         result HideKeypad(void);
 552
 553         /**
 554          * Gets the position of the ellipsis.
 555          *
 556          * @since       2.0
 557          *
 558          * @return      The ellipsis position
 559          * @exception   E_SUCCESS                       The method is successful.
 560          * @exception   E_SYSTEM                        A system error has occurred.
 561          * @remarks     The specific error code can be accessed using the GetLastResult() method.
 562          * @see         SetEllipsisPosition()
 563          */
 564         EllipsisPosition GetEllipsisPosition(void) const;
 565
 566         /**
 567          * Sets the position of the ellipsis.
 568          *
 569          * @since       2.0
 570          *
 571          * @return      An error code
 572          * @param[in]   position        The ellipsis position
 573          * @exception   E_SUCCESS                       The method is successful.
 574          * @exception   E_SYSTEM                        A system error has occurred.
 575          * @see         GetEllipsisPosition()
 576          */
 577         result SetEllipsisPosition(EllipsisPosition position);
 578
 579         /**
 580          * Gets the text size.
 581          *
 582          * @since       2.0
 583          *
 584          * @return      The size of the text, @n
 585          *              else @c -1 if an error occurs
 586          * @exception   E_SUCCESS                       The method is successful.
 587          * @exception   E_SYSTEM                        A system error has occurred.
 588          * @remarks     The specific error code can be accessed using the GetLastResult() method.
 589          * @see         SetTextSize()
 590          */
 591         int GetTextSize(void) const;
 592
 593         /**
 594          * Gets the text size.
 595          *
 596          * @since       2.1
 597          *
 598          * @return      The size of the text, @n
 599          *              else @c -1 if an error occurs
 600          * @exception   E_SUCCESS                       The method is successful.
 601          * @exception   E_SYSTEM                        A system error has occurred.
 602          * @remarks     The specific error code can be accessed using the GetLastResult() method.
 603          * @see         SetTextSize()
 604          */
 605         float GetTextSizeF(void) const;
 606
 607         /**
 608          * Sets the text size.
 609          *
 610          * @since               2.0
 611          *
 612          * @return              An error code
 613          * @param[in]   size                    The text size
 614          * @exception   E_SUCCESS               The method is successful.
 615          * @exception   E_INVALID_ARG   The specified input parameter is invalid. @n
 616          *                                                              The @c size cannot be a negative integer.
 617          * @exception   E_SYSTEM                A system error has occurred.
 618          * @see                 GetTextSize()
 619          */
 620         result SetTextSize(int size);
 621
 622         /**
 623          * Sets the text size.
 624          *
 625          * @since               2.1
 626          *
 627          * @return              An error code
 628          * @param[in]   size                    The text size
 629          * @exception   E_SUCCESS               The method is successful.
 630          * @exception   E_INVALID_ARG   The specified input parameter is invalid. @n
 631          *                                                              The @c size cannot be a negative integer.
 632          * @exception   E_SYSTEM                A system error has occurred.
 633          * @see                 GetTextSizeF()
 634          */
 635         result SetTextSize(float size);
 636
 637         /**
 638          * Gets the color of the %EditField control for the specified status.
 639          *
 640          * @since        2.0
 641          *
 642          * @return       The color, @n
 643          *                               else RGBA(0,0,0,0) if an error occurs
 644          * @param[in]    status                         The status
 645          * @exception   E_SUCCESS                       The method is successful.
 646          * @exception   E_SYSTEM                        A system error has occurred.
 647          * @remarks      The specific error code can be accessed using the GetLastResult() method.
 648          */
 649         Tizen::Graphics::Color GetColor(EditStatus status) const;
 650
 651         /**
 652          * Gets the text color of the specified text color type.
 653          *
 654          * @since               2.0
 655          *
 656          * @return              The color, @n
 657          *                              else RGBA(0,0,0,0) if an error occurs
 658          * @param[in]   type                    The text color type
 659          * @exception   E_SUCCESS               The method is successful.
 660          * @exception   E_SYSTEM                A system error has occurred.
 661          * @remarks             The specific error code can be accessed using the GetLastResult() method.
 662          * @see                 SetTextColor()
 663          */
 664         Tizen::Graphics::Color GetTextColor(EditTextColor type) const;
 665
 666         /**
 667          * Sets the background bitmap of the %EditField control for the specified status.
 668          *
 669          * @since               2.0
 670          *
 671          * @return              An error code
 672          * @param[in]   status                  The status
 673          * @param[in]   bitmap                  The background bitmap
 674          * @exception   E_SUCCESS               The method is successful.
 675          * @exception   E_SYSTEM                A system error has occurred.
 676          */
 677         result SetBackgroundBitmap(EditStatus status, const Tizen::Graphics::Bitmap& bitmap);
 678
 679         /**
 680          * Sets the color of the %EditField control for the specified status.
 681          *
 682          * @since               2.0
 683          *
 684          * @return              An error code
 685          * @param[in]   status                  The status
 686          * @param[in]   color                   The color
 687          * @exception   E_SUCCESS               The method is successful.
 688          * @exception   E_SYSTEM                A system error has occurred.
 689          * @see                 GetColor()
 690          */
 691         result SetColor(EditStatus status, const Tizen::Graphics::Color& color);
 692
 693         /**
 694          * Sets the text color of the %EditField control for the specified text color type.
 695          *
 696          * @since               2.0
 697          *
 698          * @return              An error code
 699          * @param[in]   type                    The text color type
 700          * @param[in]   color                   The text color
 701          * @exception   E_SUCCESS               The method is successful.
 702          * @exception   E_SYSTEM                A system error has occurred.
 703          * @see                 GetTextColor()
 704          */
 705         result SetTextColor(EditTextColor type, const Tizen::Graphics::Color& color);
 706
 707         /**
 708          * Gets a portion of text that is displayed by the %EditField control.
 709          *
 710          * @since               2.0
 711          *
 712          * @return      The specified portion of the text, @n
 713          *                              else an empty string if an error occurs
 714          * @param[in]   start                   The starting index of the range
 715          * @param[in]   end                             The last index of the range
 716          * @exception   E_SUCCESS               The method is successful.
 717          * @exception   E_OUT_OF_RANGE  The specified index is outside the bounds of the data structure, or @n
 718          *                                                              the index is greater than the number of elements or less than @c 0.
 719          * @exception   E_SYSTEM                A system error has occurred.
 720          * @remarks     The specific error code can be accessed using the GetLastResult() method.
 721          * @see         SetText()
 722          */
 723         Tizen::Base::String GetText(int start, int end) const;
 724
 725         /**
 726          * Adds a keypad event listener. @n
 727          * The added listener is notified when the keypad associated with the %EditField control is opened or closed.
 728          *
 729          * @since       2.0
 730          *
 731          * @param[in]   listener        The event listener to add
 732          * @see         RemoveKeypadEventListener()
 733          */
 734         void AddKeypadEventListener(IKeypadEventListener& listener);
 735
 736         /**
 737          * Removes the specified keypad event listener. @n
 738          * The removed listener cannot listen to events when they are fired.
 739          *
 740          * @since       2.0
 741          *
 742          * @param[in]   listener        The event listener to remove
 743          * @see         AddKeypadEventListener()
 744          */
 745         void RemoveKeypadEventListener(IKeypadEventListener& listener);
 746
 747         /**
 748          * Adds a text block event listener. @n
 749          * The added listener is notified when the text block is selected.
 750          *
 751          * @since               2.0
 752          *
 753          * @param[in]   listener        The event listener to add
 754          * @remarks             Programmatically modifying the text block does not cause the text block selection event to fire.
 755          * @see                 RemoveTextBlockEventListener()
 756          */
 757         void AddTextBlockEventListener(Tizen::Ui::ITextBlockEventListener& listener);
 758
 759         /**
 760          * Removes the specified text block event listener. @n
 761          * The removed listener cannot listen to events when they are fired.
 762          *
 763          * @since       2.0
 764          *
 765          * @param[in]   listener        The event listener to remove
 766          * @see                 AddTextBlockEventListener()
 767          */
 768         void RemoveTextBlockEventListener(Tizen::Ui::ITextBlockEventListener& listener);
 769
 770         /**
 771          * Adds the ITextEventListener instance. @n
 772          * The added listener listens to events on the context of the specified event dispatcher when they are fired.
 773          *
 774          * @since               2.0
 775          *
 776          * @param[in]   listener    The listener to add
 777          */
 778         void AddTextEventListener(Tizen::Ui::ITextEventListener& listener);
 779
 780         /**
 781         * Removes the ITextEventListener instance. @n
 782         * The removed listener cannot listen to events when they are fired.
 783         *
 784         * @since                2.0
 785         *
 786         * @param[in]    listener    The listener to remove
 787         */
 788         void RemoveTextEventListener(Tizen::Ui::ITextEventListener& listener);
 789
 790         /**
 791          * Adds the specified listener instance to listen to the scroll panel events.
 792          *
 793          * @since               2.0
 794          *
 795          * @param[in]   listener        The listener to add
 796          * @remarks     To listen to the scroll panel events, the parent of EditArea must be an instance of ScrollPanel. @n
 797          *              When OnOverlayControlCreated() or OnOvelayControlClosed() is called, the application resets the bounds of the controls placed
 798          *              within the ScrollPanel control. ScrollPanel is automatically drawn again after this method is called.
 799          * @see                 RemoveScrollPanelEventListener()
 800          */
 801         void AddScrollPanelEventListener(Tizen::Ui::IScrollPanelEventListener& listener);
 802
 803         /**
 804         * Removes the specified scroll panel event listener instance. @n
 805         * The removed listener cannot listen to events when they are fired.
 806         *
 807         * @since                2.0
 808         *
 809         * @param[in]    listener        The listener to remove
 810         */
 811         void RemoveScrollPanelEventListener(Tizen::Ui::IScrollPanelEventListener& listener);
 812
 813         /**
 814          * Adds the specified listener instance. @n
 815          * The added listener can listen to events on the context of the given event dispatcher when they are fired.
 816          *
 817          * @since               2.0
 818          *
 819          * @param[in]   listener        The event listener to add
 820          */
 821         void AddActionEventListener(Tizen::Ui::IActionEventListener& listener);
 822
 823         /**
 824          * Removes a listener instance. @n
 825          * The removed listener cannot listen to events when they are fired.
 826          *
 827          * @since                       2.0
 828          *
 829          * @param[in]   listener        The event listener to remove
 830          */
 831         void RemoveActionEventListener(Tizen::Ui::IActionEventListener& listener);
 832
 833         /**
 834          * Adds the specified listener instance for language events. @n
 835          * The added listener is notified when the input language is changed.
 836          *
 837          * @since      2.0
 838          *
 839          * @param[in]  listener                         The listener to add
 840          * @remarks    The application can recognize when the language is changed from the keypad by adding Tizen::Ui::ILanguageEventListener.
 841          * @see            RemoveLanguageEventListener()
 842          */
 843         void AddLanguageEventListener(Tizen::Ui::ILanguageEventListener& listener);
 844
 845         /**
 846          * Removes the specified listener instance. @n
 847          * The removed listener cannot listen to events when they are fired.
 848          *
 849          * @since      2.0
 850          *
 851          * @param[in]  listener                         The listener to remove
 852          * @see            AddLanguageEventListener()
 853          */
 854         void RemoveLanguageEventListener(Tizen::Ui::ILanguageEventListener& listener);
 855
 856         /**
 857          * Gets the remaining length of the %EditField control.
 858          *
 859          * @since       2.0
 860          *
 861          * @return      The remaining length of the %EditField control, @n
 862          *                      else @c -1 if an error occurs
 863          */
 864         int GetRemainingLength(void) const;
 865
 866         /**
 867          * Enables or disables the lowercase mode.
 868          *
 869          * @since               2.0
 870          *
 871          * @param[in]   enable  Set to @c true to enable the lowercase mode, @n
 872          *                      else @c false
 873          */
 874         void SetLowerCaseModeEnabled(bool enable);
 875
 876         /**
 877          * Checks whether the lowercase mode is enabled.
 878          *
 879          * @since       2.0
 880          *
 881          * @return      @c true if the lowercase mode is enabled, @n
 882          *                      else @c false
 883          */
 884         bool IsLowerCaseModeEnabled(void) const;
 885
 886         /**
 887          * @if OSPDEPREC
 888          * Sets the input mode category.
 889          *
 890          * @brief <i> [Deprecated]  </i>
 891          * @deprecated We no longer provide a method to specify the list of styles which the user can set the keypad to, @n
 892          *                         or the current mode to initially set the keypad to, from this list. It is recommended to use EditFieldStyle in the Construct() method instead.
 893          * @since        2.0
 894          *
 895          * @return       An error code
 896          * @param[in]    categories             The categories to set @n
 897          *                              Multiple input categories can be combined using bitwise OR operator (see Tizen::Ui::Controls::EditInputModeCategory).
 898          * @param[in]    enable                 The category value to set
 899          * @exception    E_SUCCESS                              The method is successful.
 900          * @exception    E_INVALID_ARG                  A specified input mode category is invalid.
 901          * @exception    E_INVALID_OPERATION    The current state of the instance prohibits the execution of the specified operation @n
 902          *                                                                              The specified @c categories cannot be supported with the current keypad style.
 903          * @exception    E_SYSTEM                               A system error has occurred.
 904          * @endif
 905          */
 906         result SetInputModeCategory(unsigned long categories, bool enable);
 907
 908         /**
 909          * @if OSPDEPREC
 910          * Sets the current input mode category.
 911          *
 912          * @brief <i> [Deprecated]  </i>
 913          * @deprecated We no longer provide a method to specify the list of styles which the user can set the keypad to, @n
 914          *                         or the current mode to initially set the keypad to, from this list. It is recommended to use EditFieldStyle in the Construct() method instead.
 915          * @since               2.0
 916          *
 917          * @return              An error code
 918          * @param[in]   inputModeCategory   An item of input category
 919          * @exception   E_SUCCESS                       The method is successful.
 920          * @exception   E_SYSTEM                        A system error has occurred.
 921          * @endif
 922          */
 923         result SetCurrentInputModeCategory(EditInputModeCategory inputModeCategory);
 924
 925         /**
 926          * @if OSPDEPREC
 927          * Gets the input mode category.
 928          *
 929          * @brief <i> [Deprecated]  </i>
 930          * @deprecated This method is deprecated because we no longer provide a method to specify the list of styles which the user can set the keypad to.
 931          * @since       2.0
 932          *
 933          * @return  A bitwise combination of Tizen::Ui::Controls::EditInputModeCategory, @n
 934          *                      else EDIT_INPUTMODE_ALPHA if an error occurs
 935          * @endif
 936          */
 937         unsigned long GetInputModeCategory(void) const;
 938
 939         /**
 940          * @if OSPDEPREC
 941          * Gets the current input mode category.
 942          *
 943          * @brief <i> [Deprecated]  </i>
 944          * @deprecated This method is deprecated because we no longer provide a method to specify the list of styles which the user can set the keypad to.
 945          * @since    2.0
 946          *
 947          * @return   The current input mode category
 948          * @endif
 949          */
 950         EditInputModeCategory GetCurrentInputModeCategory(void) const;
 951
 952         /**
 953          * Sets the cursor in the %EditField control at the specified position.
 954          *
 955          * @since               2.0
 956          *
 957          * @return              An error code
 958          * @param[in]   position                The cursor position to set
 959          * @exception   E_SUCCESS               The method is successful.
 960          * @exception   E_OUT_OF_RANGE  The specified @c position is less than @c 0 or greater than the maximum length.
 961          * @exception   E_SYSTEM                A system error has occurred.
 962          */
 963         result SetCursorPosition(int position);
 964
 965         /**
 966          * Gets the cursor position.
 967          *
 968          * @since                       2.0
 969          *
 970          * @return                      The current cursor position, @n
 971          *                  else @c -1 if an error occurs
 972          */
 973         int GetCursorPosition(void) const;
 974
 975         /**
 976          * Gets the text that is displayed by the %EditField control.
 977          *
 978          * @since       2.0
 979          *
 980          * @return      The text of the %EditField control, @n
 981          *          else an empty string if an error occurs
 982          */
 983         Tizen::Base::String GetText(void) const;
 984
 985         /**
 986          * Gets the length of the text that is displayed by the %EditField control.
 987          *
 988          * @since       2.0
 989          *
 990          * @return      The length of the text, @n
 991          *          else @c -1 if an error occurs
 992          */
 993         int GetTextLength(void) const;
 994
 995         /**
 996          * Sets the text of the %EditField control.
 997          *
 998          * @since               2.0
 999          *
1000          * @param[in]   text                    The text to display by the %EditField control
1001          * @exception   E_SUCCESS               The method is successful.
1002          * @exception   E_INVALID_ARG   The specified input parameter is invalid. @n
1003          *                                                              The length of the specified @c text exceeds the system limitation or the limit length.
1004          * @exception   E_SYSTEM                A system error has occurred.
1005          * @remarks     Use @htmlonly '\n' @endhtmlonly to denote the end of the line.
1006          */
1007         result SetText(const Tizen::Base::String& text);
1008
1009         /**
1010          * Inserts the specified text at the current cursor position.
1011          *
1012          * @since               2.0
1013          *
1014          * @return              An error code
1015          * @param[in]   text        The text to insert
1016          * @exception   E_SUCCESS   The method is successful.
1017          * @exception   E_SYSTEM    A system error has occurred.
1018          * @remarks     Use @htmlonly '\n' @endhtmlonly to denote the end of the line.
1019          */
1020         result InsertTextAtCursorPosition(const Tizen::Base::String& text);
1021
1022         /**
1023          * Appends the specified text at the end of the existing text.
1024          *
1025          * @since               2.0
1026          *
1027          * @return              An error code
1028          * @param[in]   text        The text to append
1029          * @exception   E_SUCCESS   The method is successful.
1030          * @exception   E_SYSTEM    A system error has occurred.
1031          * @remarks     Use @htmlonly '\n' @endhtmlonly to denote the end of the line.
1032          */
1033         result AppendText(const Tizen::Base::String& text);
1034
1035         /**
1036          * Appends the specified character at the end of the existing text.
1037          *
1038          * @since               2.0
1039          *
1040          * @return      An error code
1041          * @param[in]   character               The character to append
1042          * @exception   E_SUCCESS               The method is successful.
1043          * @exception   E_SYSTEM                A system error has occurred.
1044          * @remarks             The method modifies the text buffer that is managed by the %EditField control. To display the
1045          *              changes, the control must be drawn again.
1046          */
1047         result AppendCharacter(const Tizen::Base::Character& character);
1048
1049         /**
1050          * Clears the text that is displayed by the %EditField control.
1051          *
1052          * @since               2.0
1053          *
1054          * @return              An error code
1055          * @exception   E_SUCCESS               The method is successful.
1056          * @exception   E_SYSTEM                A system error has occurred.
1057          * @remarks             The method modifies the text buffer that is managed by the %EditField control. To display the
1058          *              changes, the control must be drawn again.
1059          */
1060         result Clear(void);
1061
1062         /**
1063          * Deletes a character at the current cursor position.
1064          *
1065          * @since               2.0
1066          *
1067          * @return              An error code
1068          * @exception   E_SUCCESS               The method is successful.
1069          * @exception   E_SYSTEM                A system error has occurred.
1070          * @remarks             The method modifies the text buffer that is managed by the %EditField control. To display the
1071          *              changes, the control must be drawn again.
1072          */
1073         result DeleteCharacterAtCursorPosition(void);
1074
1075         /**
1076          * Gets the range of the current text block.
1077          *
1078          * @since        2.0
1079          *
1080          * @param[out]   start   The first index of the current text block
1081          * @param[out]   end     The last index of the current text block
1082          */
1083         void GetCurrentTextRange(int& start, int& end) const;
1084
1085         /**
1086          * Sets the guide text.
1087          *
1088          * @since               2.0
1089          *
1090          * @param[in]   guideText    The guide text
1091          * @remarks             This is the default text that is displayed in the %EditField
1092          *              control when the focus is given to it and no text is entered.
1093          */
1094         void SetGuideText(const Tizen::Base::String& guideText);
1095
1096         /**
1097          * Gets the guide text.
1098          *
1099          * @since       2.0
1100          *
1101          * @return      The guide text, @n
1102          *              else an empty string if an error occurs
1103          * @exception   E_SUCCESS                       The method is successful.
1104          * @exception   E_SYSTEM                        A system error has occurred.
1105          * @remarks     The specific error code can be accessed using the GetLastResult() method.
1106          * @see         SetGuideText()
1107          */
1108         Tizen::Base::String GetGuideText(void) const;
1109
1110         /**
1111          * Gets the text color of the guide text.
1112          *
1113          * @since       2.0
1114          *
1115          * @return      The guide text color
1116          * @exception   E_SUCCESS                       The method is successful.
1117          * @exception   E_SYSTEM                        A system error has occurred.
1118          * @remarks     The specific error code can be accessed using the GetLastResult() method.
1119          * @see         SetGuideTextColor()
1120          */
1121         Tizen::Graphics::Color GetGuideTextColor(void) const;
1122
1123         /**
1124          * Sets the text color of the guide text.
1125          *
1126          * @since       2.0
1127          *
1128          * @return      An error code
1129          * @param[in]   color            The guide text color
1130          * @exception   E_SUCCESS                       The method is successful.
1131          * @exception   E_SYSTEM                        A system error has occurred.
1132          * @see         GetGuideTextColor()
1133          */
1134         result SetGuideTextColor(const Tizen::Graphics::Color& color);
1135
1136         /**
1137          * Gets the text color of the title for the specified status.
1138          *
1139          * @since               2.0
1140          *
1141          * @return              The title text color, @n
1142          *                              else RGBA(0,0,0,0) if an error occurs
1143          * @param[in]   status                  The state of the %EditField control
1144          * @exception   E_SUCCESS               The method is successful.
1145          * @exception   E_SYSTEM                A system error has occurred.
1146          * @remarks             The specific error code can be accessed using the GetLastResult() method.
1147          * @see                 SetTitleTextColor()
1148          */
1149         Tizen::Graphics::Color GetTitleTextColor(EditStatus status) const;
1150
1151         /**
1152          * Sets the text color of the title for the specified status.
1153          *
1154          * @since       2.0
1155          *
1156          * @return          An error code
1157          * @param[in]   status                  The state of the %EditField control
1158          * @param[in]   color                   The title text color
1159          * @exception   E_SUCCESS               The method is successful.
1160          * @exception   E_SYSTEM                A system error has occurred.
1161          * @see         GetTitleTextColor()
1162          */
1163         result SetTitleTextColor(EditStatus status, const Tizen::Graphics::Color& color);
1164
1165         /**
1166          * Enables or disables the keypad.
1167          *
1168          * @since               2.0
1169          *
1170          * @param[in]   enable  Set to @c true to enable the keypad,
1171          *                      else @c false
1172          */
1173         void SetKeypadEnabled(bool enable);
1174
1175         /**
1176          * Checks whether the keypad is enabled.
1177          *
1178          * @since        2.0
1179          *
1180          * @return       @c true if the keypad is enabled, @n
1181          *               else @c false
1182          */
1183         bool IsKeypadEnabled(void) const;
1184
1185         /**
1186         * Checks whether the text prediction is enabled.
1187         *
1188         * @since 2.0
1189         * @return                @c true if the text prediction is enabled, @n
1190         *                                 else @c false
1191         * @see                      SetTextPredictionEnabled()
1192         */
1193         bool IsTextPredictionEnabled(void) const;
1194
1195         /**
1196         * Enables or disables the text prediction.
1197         *
1198         * @since 2.0
1199         * @param[in]           enable                       Set to @c true to enable the text prediction, @n
1200         *                                                                    else @c false
1201         * @return                An error code
1202         * @exception           E_SUCCESS                The method is successful.
1203         * @exception            E_UNSUPPORTED_OPERATION     This operation is not supported.
1204         * @see                      IsTextPredictionEnabled()
1205         */
1206         result SetTextPredictionEnabled(bool enable);
1207
1208         /**
1209          * Displays the keypad.
1210          *
1211          * @since               2.0
1212          *
1213          * @return              An error code
1214          * @exception   E_SUCCESS       The method is successful.
1215          * @exception   E_INVALID_STATE This instance is in an invalid state.
1216          * @exception   E_SYSTEM                A system error has occurred.
1217          * @remarks             This method is supported only when the input style is INPUT_STYLE_OVERLAY.
1218          */
1219         result ShowKeypad(void);
1220
1221         /**
1222          * Gets the range of the current text block that is selected.
1223          *
1224          * @since               2.0
1225          *
1226          * @param[out]  start   The starting index of the current block
1227          * @param[out]  end     The end index of the current block
1228          */
1229         void GetBlockRange(int& start, int& end) const;
1230
1231         /**
1232          * Begins the text block from the current cursor position.
1233          *
1234          * @since               2.0
1235          *
1236          * @return              An error code
1237          * @exception   E_SUCCESS               The method is successful.
1238          * @exception   E_SYSTEM                A system error has occurred.
1239          * @remarks             Move the cursor position to the end of the text block.
1240          * @see         SetCursorPosition()
1241          * @see         ReleaseBlock()
1242          * @see                 IsBlocked()
1243          */
1244         result BeginBlock(void);
1245
1246         /**
1247          * Releases the selection of the current text block.
1248          *
1249          * @since               2.0
1250          *
1251          * @return              An error code
1252          * @exception   E_SUCCESS               The method is successful.
1253          * @exception   E_SYSTEM                A system error has occurred.
1254          * @see         BeginBlock()
1255          * @see                 IsBlocked()
1256          */
1257         result ReleaseBlock(void);
1258
1259         /**
1260          * Checks whether a portion of the text is blocked.
1261          *
1262          * @since       2.0
1263          *
1264          * @return      @c true if the text is blocked, @n
1265          *                      else @c false
1266          * @see     BeginBlock()
1267          * @see         ReleaseBlock()
1268          */
1269         bool IsBlocked(void) const;
1270
1271         /**
1272          * Copies the text block to the clipboard.
1273          *
1274          * @since               2.0
1275          *
1276          * @return              An error code
1277          * @exception   E_SUCCESS       The method is successful.
1278          * @exception   E_SYSTEM        A system error has occurred.
1279          * @see         Cut(), Paste(), Remove()
1280          */
1281         result Copy(void);
1282
1283         /**
1284          * Cuts the text block and copies it to the clipboard.
1285          *
1286          * @since               2.0
1287          *
1288          * @return              An error code
1289          * @exception   E_SUCCESS               The method is successful.
1290          * @exception   E_SYSTEM                A system error has occurred.
1291          * @see                 Copy(), Remove(), Paste()
1292          */
1293         result Cut(void);
1294
1295         /**
1296          * Pastes the copied text at the cursor position.
1297          *
1298          * @since               2.0
1299          *
1300          * @return              An error code
1301          * @exception   E_SUCCESS       The method is successful.
1302          * @exception   E_SYSTEM        A system error has occurred.
1303          * @see                 Copy(), Cut(), Remove()
1304          */
1305         result Paste(void);
1306
1307         /**
1308          * Removes the text that is marked by the text block.
1309          *
1310          * @since               2.0
1311          *
1312          * @return              An error code
1313          * @exception   E_SUCCESS               The method is successful.
1314          * @exception   E_SYSTEM                A system error has occurred.
1315          * @see                 Copy(), Cut(), Paste()
1316          */
1317         result Remove(void);
1318
1319         /**
1320          * Checks whether the text in the %EditField control is clipped.
1321          *
1322          * @since       2.0
1323          *
1324          * @return      @c true if the text is clipped, @n
1325          *                      else @c false
1326          * @remarks     'clipped' means that the text is copied to the clipboard.
1327          * @see         Copy(), Cut(), Paste(), Remove()
1328          */
1329         bool IsClipped(void) const;
1330
1331         /**
1332          * Sets the title of the %EditField control.
1333          *
1334          * @since               2.0
1335          *
1336          * @return              An error code
1337          * @param[in]   title                   The title to set
1338          * @exception   E_SUCCESS               The method is successful.
1339          * @exception   E_SYSTEM                A system error has occurred.
1340          */
1341         result SetTitleText(const Tizen::Base::String& title);
1342
1343         /**
1344          * Gets the title text of the %EditField control.
1345          *
1346          * @since               2.0
1347          *
1348          * @return              The title text, @n
1349          *                              else an empty string if an error occurs
1350          */
1351         Tizen::Base::String GetTitleText(void) const;
1352
1353         /**
1354          * Sets the command button properties of the keypad.
1355          *
1356          * @since       2.0
1357          *
1358          * @return              An error code
1359          * @param[in]   position                        The position of the command button
1360          * @param[in]   text                            The label of the command button
1361          * @param[in]   actionId                        The action ID
1362          * @exception   E_SUCCESS           The method is successful.
1363          * @exception   E_SYSTEM            A system error has occurred.
1364          * @remarks             This method is supported only when the input style is INPUT_STYLE_OVERLAY.
1365          */
1366         result SetOverlayKeypadCommandButton(CommandButtonPosition position, const Tizen::Base::String& text, int actionId);
1367
1368         /**
1369          * Gets the text of the specified command button.
1370          *
1371          * @since               2.0
1372          *
1373          * @return              The text of the specified command button
1374          * @param[in]   position    The position of the command button
1375          * @remarks             This method is supported only when the input style is INPUT_STYLE_OVERLAY.
1376          */
1377         Tizen::Base::String GetOverlayKeypadCommandButtonText(CommandButtonPosition position) const;
1378
1379         /**
1380          * Gets the action ID of the specified command button.
1381          *
1382          * @since               2.0
1383          *
1384          * @return              The action ID of the specified command button
1385          * @param[in]   position    The position of the command button
1386          * @remarks             This method is supported only when the input style is INPUT_STYLE_OVERLAY.
1387          */
1388         int GetOverlayKeypadCommandButtonActionId(CommandButtonPosition position) const;
1389
1390         /**
1391           * Sets the input language.
1392           *
1393           * @since      2.0
1394           *
1395           * @return     An error code
1396           * @param[in]  languageCode                            The language to set
1397           * @exception  E_SUCCESS                               The method is successful.
1398           * @exception  E_OUT_OF_MEMORY                   The memory is insufficient.
1399           * @remarks     The application can set the language of the current keypad that is associated with the current %EditField. @n
1400           *             This method only works if the language to set is supported by the current preloaded keypad.
1401           */
1402         result SetCurrentLanguage(Tizen::Locales::LanguageCode languageCode);
1403
1404         /**
1405           * Gets the current input language.
1406           *
1407           * @since      2.0
1408           *
1409           * @return     An error code
1410           * @param[out] language               The current input language
1411           * @exception  E_SUCCESS                               The method is successful.
1412           * @remarks     The application can get the current language of the keypad that is associated with the current %EditField.
1413           */
1414         result GetCurrentLanguage(Tizen::Locales::LanguageCode& language) const;
1415
1416         /**
1417          * Sets the text filter.
1418          *
1419          * @since               2.1
1420          *
1421          * @param[in]           pFilter The filter
1422          * @remarks             The %EditField control checks with the registered filter to decide whether the user-entered text should be replaced.
1423          */
1424         void  SetEditTextFilter(IEditTextFilter* pFilter);
1425
1426         /**
1427         * Sends opaque command to the input method.
1428         *
1429         * @since     2.1
1430         *
1431         * @param[in] command            The opaque command
1432         * @remarks   This method can be used to provide domain-specific features that are only known between certain input methods and their clients.
1433         *                   This method may not work, depending on the active Input Method.
1434         */
1435         void SendOpaqueCommand (const Tizen::Base::String& command);
1436
1437 protected:
1438         friend class _EditFieldImpl;
1439
1440 private:
1441         EditField(const EditField&);
1442         EditField& operator =(const EditField&);
1443
1444 }; // EditField
1445
1446 }}} // Tizen::Ui::Controls
1447
1448 #endif // _FUI_CTRL_EDIT_FIELD_H_