inc/FUiCtrlEditArea.h

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