inc/FUiContainer.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        FUiContainer.h
  20  * @brief       This is the header file for the %Container class.
  21  *
  22  * This header file contains the declarations of the %Container class.
  23  */
  24
  25 #ifndef _FUI_CONTAINER_H_
  26 #define _FUI_CONTAINER_H_
  27
  28 #include <FBaseTypes.h>
  29 #include <FBaseColLinkedList.h>
  30 #include <FUiControl.h>
  31
  32 namespace Tizen { namespace Ui {
  33
  34 class Layout;
  35 class _ContainerImpl;
  36
  37 /**
  38  * @class       Container
  39  * @brief       This class is an abstract base class of all the generic containers of %Controls.
  40  *
  41  * @since       2.0
  42  *
  43  * @remarks As the %Container is an abstract class, use the Tizen::Ui::Controls::Panel class or another class derived from
  44  * %Container to apply the container functionality.
  45  *
  46  * The %Container class is the abstract base class of all generic Control containers. A container is a UI element which can contain
  47  * other UI elements.
  48  *
  49  * For more information on the class features, see <a href="../org.tizen.native.appprogramming/html/guide/ui/containers.htm">Containers</a>.
  50  *
  51
  52  *
  53  */
  54 class _OSP_EXPORT_ Container
  55         : public Control
  56 {
  57
  58 public:
  59         /**
  60          * This destructor overrides Tizen::Base::Object::~Object().
  61          *
  62          * @since       2.0
  63          */
  64         virtual ~Container(void) = 0;
  65
  66 public:
  67         /**
  68          * Adds the control at the end of the list maintained by the container.
  69          *
  70          * @brief       <i> [Deprecated] </i>
  71          * @deprecated  This method is deprecated.
  72          * @since                       2.0
  73          *
  74          * @return              An error code
  75          * @param[in]   control         The control to add to the container
  76          * @exception   E_SUCCESS       The method is successful.
  77          * @exception   E_INVALID_ARG   The specified input parameter is invalid. @n
  78          *                              The specified @c control is an instance of Window, or this control's parent container.
  79          * @exception   E_MAX_EXCEEDED  The number of child controls has exceeded the maximum limit.
  80          * @exception   E_SYSTEM        A system error has occurred.
  81          * @remarks
  82          *                      - When the control is added, it is placed at the top of the drawing stack maintained by the container.@n
  83          *                      This means the last control added is drawn last
  84          *                      - A control becomes displayable only after it has been added to a displayable container. Some methods may not work normally if the methods
  85          *                      of the control are called before adding the control to a container. After the control is added to a %Container, the Control::OnInitializing()
  86          *                      method of the control are called before adding the control to a container. After the control is added to a %Container, the
  87          *                      %Control::OnInitializing() method of the control is invoked for the initialization of the control such as creating and adding child controls.
  88          * @see                 Tizen::Ui::Control::OnTerminating()
  89          * @code
  90          *      {
  91          *              // Uses Panel instead of Container, because Container is an abstract class.
  92          *              Panel* pPanel = new Panel();
  93          *              pPanel->Construct(Rectangle(100, 250, 300, 300));
  94          *
  95          *              Form* pForm = new Form();
  96          *              pForm->Construct(FORM_STYLE_NORMAL|FORM_STYLE_PORTRAIT_INDICATOR);
  97          *              pForm->AddControl(*pPanel);
  98          *
  99          *              //...
 100          *              pForm->Invalidate(true);
 101          *              //...
 102          *      }
 103          * @endcode
 104          */
 105         result AddControl(const Control& control);
 106
 107         /**
 108          * Adds a control at the end of the list maintained by a container.
 109          *
 110          * @since                              2.1
 111          *
 112          * @return        An error code
 113          * @param[in]    pControl         A pointer to the control to add to the container
 114          * @exception    E_SUCCESS       The method is successful.
 115          * @exception    E_INVALID_ARG   The specified @c pControl is @c null.
 116          *                              The specified @c control is an instance of Window or the control's parent container.
 117          * @exception    E_MAX_EXCEEDED          The number of child controls has exceeded the maximum limit.
 118          * @exception    E_INVALID_ARG
 119          * @exception    E_SYSTEM        A system error has occurred.
 120          * @remarks
 121          *                      - When a control is added, it is placed at the top of the drawing stack maintained by the container.@n
 122          *                      This means the control that is added last is drawn last.
 123          *                      - A control becomes displayable only after it has been added to a displayable container.
 124          *                      Some methods may not work normally if the methods of the control are called before adding the control to a container.
 125          *                      After the control is added to a %Container, the Control::OnInitializing()
 126          *                      method of the control are called before adding the control to a container. After the control is added to a %Container, the
 127          *                      %Control::OnInitializing() method of the control is invoked for the initialization of the control such as creating and adding child controls.
 128          * @see                      Tizen::Ui::Control::OnTerminating()
 129          * @code
 130          *        {
 131          *                   // Uses Panel instead of Container, because Container is an abstract class.
 132          *                   Panel* pPanel = new Panel();
 133          *                   pPanel->Construct(Rectangle(100, 250, 300, 300));
 134          *
 135          *                   Form* pForm = new Form();
 136          *                   pForm->Construct(FORM_STYLE_NORMAL|FORM_STYLE_PORTRAIT_INDICATOR);
 137          *                   pForm->AddControl(pPanel);
 138          *
 139          *                   //...
 140          *                   pForm->Invalidate(true);
 141          *                   //...
 142          *        }
 143          * @endcode
 144          */
 145         result AddControl(Control* pControl);
 146
 147         /**
 148          * Before the system calls OnDraw() method to allow the user to do custom drawing, this method is called to clear the canvas. @n
 149          * The user can override this method to change this default behavior.
 150          *
 151          * @since 2.0
 152          *
 153          * @see         GetCanvasN()
 154          */
 155         virtual void OnClearBackground(void);
 156
 157         /**
 158          * Called when the container needs to draw itself. @n
 159          * Users can override this method to display user-specific drawings. @n
 160          * This method is called after the container has drawn itself, but just before the container draws its child controls.
 161          *
 162          * @if OSPCOMPAT
 163          * @brief <i> [Compatibility] </i>
 164          * @endif
 165          * @since                              2.0
 166          *
 167          * @if OSPCOMPAT
 168          * @compatibility This method has compatibility issues with OSP compatible applications. @n
 169          *                       For more information, see @ref CompOnDrawPage "here".
 170          * @endif
 171          *
 172          * @return                  An error code
 173          * @exception    E_SUCCESS        The method is successful.
 174          * @exception    E_SYSTEM         A system error has occurred.
 175          */
 176         virtual result OnDraw(void);
 177
 178         /**
 179          * @if OSPCOMPAT
 180          * @page               CompOnDrawPage        Compatibility for OnDraw()
 181          * @section            CompOnDrawPageIssueSection          Issues
 182          * Implementing this method in OSP compatible applications has the following issues:   @n
 183          * -# The platform draws the control by calling the parent's OnDraw() callback before invoking the control's OnDraw() callback. So, the users can't control the control's drawing behavior by overriding the OnDraw() callback.
 184          *
 185          * @section            CompOnDrawPageSolutionSection               Resolutions
 186          * This issue has been resolved in Tizen.  @n
 187          * -# The platform does not call the parent's OnDraw() callback before invoking the control's OnDraw() callback. Therefore, you needs to call   the parent container's OnDraw() callback in the OnDraw() callback if you override this method.
 188          * @endif
 189          */
 190
 191         /**
 192          * Called to notify that the control's show state is changing.
 193          *
 194          * @since       2.0
 195          *
 196          * @param[in]   showState  The new show state of the control
 197          * @see         Tizen::Ui::Control::SetShowState()
 198          */
 199         virtual void OnShowStateChanging(bool showState);
 200
 201         /**
 202          * Called to notify that the control's show state is changed.
 203          *
 204          * @since       2.0
 205          *
 206          * @param[in]   showState  The new show state of the control
 207          * @see         Tizen::Ui::Control::SetShowState()
 208          */
 209         virtual void OnShowStateChanged(bool showState);
 210
 211         /**
 212          * Called to notify that the bounds of the control is changing.
 213          *
 214          * @since       2.0
 215          *
 216          * @return      An error code
 217          * @param[in]   oldRect  The old position and size values of the control
 218          * @param[in]   newRect  The new position and size values of the control
 219          * @remarks     If the method returns an exception, the resulting exception
 220          *              is propagated and the control's size is unchanged.@n
 221          *              Provide control specific exceptions.
 222          * @see         Tizen::Ui::Control::SetBounds()
 223          * @see         Tizen::Ui::Control::SetSize()
 224          */
 225         virtual result OnBoundsChanging(const Tizen::Graphics::Rectangle& oldRect, const Tizen::Graphics::Rectangle& newRect);
 226
 227         /**
 228          * Called to notify that the bounds of the control is changed.
 229          *
 230          * @since       2.0
 231          *
 232          * @return      An error code
 233          * @param[in]   oldRect  The old position and size values of the control
 234          * @param[in]   newRect  The new position and size values of the control
 235          * @see         Tizen::Ui::Control::SetBounds()
 236          * @see         Tizen::Ui::Control::SetSize()
 237          */
 238         virtual void OnBoundsChanged(const Tizen::Graphics::Rectangle& oldRect, const Tizen::Graphics::Rectangle& newRect);
 239
 240         /**
 241          * Overrides this method to indicate that the specified @c width and @c height
 242          * can be supported or a new @c width and @c height should be applied instead
 243          * of the specified values.
 244          *
 245          * @since           2.0
 246          *
 247          * @param[in, out]  evaluatedSize  The width and the height to evaluate
 248          */
 249         virtual void OnEvaluateSize(Tizen::Graphics::Dimension& evaluatedSize);
 250
 251         /**
 252          * Removes the specified control from the container.
 253          *
 254          * @brief       <i> [Deprecated] </i>
 255          * @deprecated  This method is deprecated.
 256          * @since                       2.0
 257          *
 258          * @return              An error code
 259          * @param[in]   control                 The child control to remove
 260          * @exception   E_SUCCESS               The method is successful.
 261          * @exception   E_OBJ_NOT_FOUND         The specified instance is not found within the indicated range (that is, the @c control is not found).
 262          * @exception   E_SYSTEM                A system error has occurred.
 263          * @remarks             The removed child control is deleted from the memory. Before deletion, Control::OnTerminating() of the child control is called.
 264          *                              If %Control::OnTerminating() method is overridden and returns an exception, that exception is propagated.
 265          */
 266         result RemoveControl(const Control& control);
 267
 268          /**
 269          * Removes a specified control from the container.
 270          *
 271          * @since                             2.1
 272          *
 273          * @return                 An error code
 274          * @param[in]   pControl                A pointer to the child control to remove
 275          * @exception   E_SUCCESS               The method is successful.
 276          * @exception   E_OBJ_NOT_FOUND The specified instance is not found within the indicated range (that is, the @c control is not found).
 277          * @exception   E_INVALID_ARG   The specified @c pControl is @c null.
 278          * @exception   E_SYSTEM                A system error has occurred.
 279          * @remarks             The removed child control is deleted from the memory. Before deletion, Control::OnTerminating() of the child control is called.
 280          *                              If %Control::OnTerminating() method is overridden and returns an exception, that exception is propagated.
 281          */
 282         result RemoveControl(Control* pControl);
 283
 284         /**
 285          * Removes the specified control from the container.
 286          *
 287          * @since                       2.0
 288          *
 289          * @return              An error code
 290          * @param[in]   index                   The index of the control to remove
 291          * @exception   E_SUCCESS                       The method is successful.
 292          * @exception   E_OUT_OF_RANGE          The specified @c index is out of range.
 293          * @exception   E_SYSTEM                A system error has occurred.
 294          * @remarks             The removed child control is deleted from the memory. Before deletion, Control::OnTerminating() of the child control is called.
 295          *                              If %Control::OnTerminating() method is overridden and returns an exception, that exception is propagated.
 296          */
 297         result RemoveControl(int index);
 298
 299         /**
 300          * Removes all the controls from the container.
 301          *
 302          * @since                       2.0
 303          *
 304          * @remarks             The removed child controls are deleted from the memory. Before deletion, Control::OnTerminating() of the child control is called.
 305          */
 306         void RemoveAllControls(void);
 307
 308         /**
 309          * Gets the control at the specified index of the list that is kept by the container.
 310          *
 311          * @since                       2.0
 312          *
 313          * @return              The control at the specified index of the list, @n
 314          *              else @c null if the index is not valid
 315          * @param[in]   index   The index of the control
 316          */
 317         Control* GetControl(int index) const;
 318
 319         /**
 320          * Gets the control with the specified name. @n
 321          * If there are multiple matches of the name, the first match is returned.
 322          *
 323          * @if OSPCOMPAT
 324          * @brief <i> [Compatibility] </i>
 325          * @endif
 326          * @since                       2.0
 327          *
 328          * @if OSPCOMPAT
 329          * @compatibility This method has compatibility issues with OSP compatible applications. @n
 330          *                       For more information, see @ref CompGetControlPage "here".
 331          * @endif
 332          *
 333          * @return              The control having the specified name, @n
 334          *                              else @c null if the name is not valid
 335          * @param[in]   name            The name of the control
 336          * @param[in]   recursive       Set to @c true to find a match recursively, @n
 337          *                                                      else @c false
 338          */
 339         Control* GetControl(const Tizen::Base::String& name, bool recursive = false) const;
 340
 341         /**
 342          * @if OSPCOMPAT
 343          * @page               CompGetControlPage        Compatibility for GetControl()
 344          * @section            CompGetControlPageIssueSection          Issues
 345          * Implementing this method in OSP compatible applications has the following issues: @n
 346          * -# GetControl() method searches for itself first and then child controls in API version 2.0, whereas only @n
 347          * child controls are searched for from 2.1.
 348          *
 349          * @section            CompGetControlPageSolutionSection               Resolutions
 350          * This issue has been resolved in Tizen.  @n
 351          * @endif
 352          */
 353
 354         /**
 355          * Gets the number of the controls in the container.
 356          *
 357          * @since                       2.0
 358          *
 359          * @return              The number of controls in the container
 360          */
 361         int GetControlCount(void) const;
 362
 363         /**
 364          * Gets a list of the controls of the container.
 365          *
 366          * @since               2.0
 367          *
 368          * @return              The list of the controls of the container
 369          */
 370         Tizen::Base::Collection::IList* GetControls(void) const;
 371
 372         /**
 373          * Gets the portrait layout of the container.
 374          *
 375          * @since                       2.0
 376          *
 377          * @return              The portrait layout of the container, @n
 378          *                              else @c null if the layout does not exist
 379          * @exception   E_SUCCESS               The method is successful.
 380          * @exception   E_OUT_OF_MEMORY     The memory is insufficient.
 381          */
 382         Layout* GetPortraitLayoutN(void) const;
 383
 384         /**
 385          * Gets the landscape layout of the container.
 386          *
 387          * @since                       2.0
 388          *
 389          * @return              The landscape layout of the container, @n
 390          *                              else @c null if the layout does not exist
 391          * @exception   E_SUCCESS               The method is successful.
 392          * @exception   E_OUT_OF_MEMORY     The memory is insufficient.
 393          */
 394         Layout* GetLandscapeLayoutN(void) const;
 395
 396         /**
 397          * Gets the layout of the current orientation.
 398          *
 399          * @since                       2.0
 400          *
 401          * @return              The layout of the current orientation, @n
 402          *                              else @c null if the layout does not exist
 403          * @exception   E_SUCCESS               The method is successful.
 404          * @exception   E_OUT_OF_MEMORY     The memory is insufficient.
 405          */
 406         Layout* GetLayoutN(void) const;
 407
 408         /**
 409          * Checks whether the specified control is a child or descendant of the container.
 410          *
 411          * @brief       <i> [Deprecated] </i>
 412          * @deprecated  This method is deprecated.
 413          * @since                               2.0
 414          *
 415          * @return      @c true if the specified control is within the containment hierarchy of the container, @n
 416          *              else @c false
 417          * @param[in]   control         The control
 418          */
 419         bool IsAncestorOf(const Control& control) const;
 420
 421          /**
 422          * Checks whether a specified control is a child or descendant of the container.
 423          *
 424          * @since                                       2.1
 425          *
 426          * @return      @c true if a specified control is within the containment hierarchy of the container, @n
 427          *              else @c false
 428          * @param[in] pControl                   A pointer to the control
 429          * @exception E_SUCCESS The method is successful.
 430          * @exception     E_INVALID_ARG  The specified @c pControl is null.
 431          * @remarks       The specific error code can be accessed using the GetLastResult() method.
 432          */
 433         bool IsAncestorOf(const Control* pControl) const;
 434
 435         /**
 436          * Sets whether the specified child control must always be above other children.
 437          *
 438          * @since        2.0
 439          *
 440          * @return       An error code
 441          * @param[in]    control          The child control
 442          * @param[in]    alwaysOnTop      The Boolean value indicating that @c control
 443          *                                must always be on the top
 444          * @exception    E_SUCCESS        The method is successful.
 445          * @exception    E_INVALID_ARG    A specified input parameter is invalid.@n
 446          *                                The specified control is not a child of this
 447          *                                container.
 448          * @remarks
 449          *                      - If multiple child control are set as "always on top", then
 450          *                      their relative order is not specified. If the specified child
 451          *                      control is a container, then all its children inherit this
 452          *                      property and they are "always on top" of other controls.
 453          *                      - If the method is called on a child control with a @c false
 454          *                      value, then it's state becomes normal. The relative order
 455          *                      of child controls in normal state is not specified.
 456          * @see          IsControlAlwaysOnTop()
 457          */
 458         result SetControlAlwaysOnTop(Tizen::Ui::Control& control, bool alwaysOnTop);
 459
 460         /**
 461          * Sets whether the specified child control must always be below other children.
 462          *
 463          * @since        2.0
 464          *
 465          * @return       An error code
 466          * @param[in]    control          The child control
 467          * @param[in]    alwaysAtBottom   The Boolean value indicating that @c control
 468          *                                must always be at the bottom.
 469          * @exception    E_SUCCESS        The method is successful.
 470          * @exception    E_INVALID_ARG    A specified input parameter is invalid.@n
 471          *                                The specified control is not a child of this
 472          *                                container.
 473          * @remarks
 474          *                      - If multiple child control are set as "always at bottom", then
 475          *                      their relative order is not specified. If the specified child
 476          *                      control is a container, then all its children inherit this
 477          *                      property and they become "always at bottom" as well.
 478          *                      - If the method is called on a child control with a @c false
 479          *                      value, then it's state becomes normal. The relative order
 480          *                      of child controls in normal state is not specified.
 481          * @see          IsControlAlwaysAtBottom()
 482          */
 483         result SetControlAlwaysAtBottom(Tizen::Ui::Control& control, bool alwaysAtBottom);
 484
 485         /**
 486          * Checks whether the specified child control is always at the bottom of
 487          * the drawing stack.
 488          *
 489          * @brief       <i> [Deprecated] </i>
 490          * @deprecated  This method is deprecated.
 491          * @since       2.0
 492          *
 493          * @return       @c true if the specified child control is set as always at the bottom, @n
 494          *                 else @c false
 495          * @param[in]    control          The child control
 496          * @exception    E_SUCCESS        The method is successful.
 497          * @exception    E_INVALID_ARG    A specified input parameter is invalid.@n
 498          *                                The specified control is not a child of this
 499          *                                container.
 500          * @remarks      The specific error code can be accessed using the GetLastResult() method.
 501          * @see          SetControlAlwaysAtBottom()
 502          */
 503         bool IsControlAlwaysAtBottom(const Tizen::Ui::Control& control) const;
 504
 505         /**
 506          * Checks whether a specified child control is always at the bottom of the drawing stack.
 507          *
 508          * @since       2.1
 509          *
 510          * @return       @c true if a specified child control is set as always at the bottom, @n
 511          *                 else @c false
 512          * @param[in]   pControl          A pointer to child control
 513          * @exception    E_SUCCESS        The method is successful.
 514          * @exception    E_INVALID_ARG    A specified input parameter is invalid.@n
 515          *                                The specified control is not a child of this
 516          *                                container or @c pControl is @c null .
 517          * @remarks      The specific error code can be accessed using the GetLastResult() method.
 518          * @see          SetControlAlwaysAtBottom()
 519          */
 520         bool IsControlAlwaysAtBottom(const Tizen::Ui::Control* pControl) const;
 521
 522         /**
 523          * Checks whether the specified child control is always on the top of
 524          * the drawing stack.
 525          *
 526          * @brief       <i> [Deprecated] </i>
 527          * @deprecated  This method is deprecated.
 528          * @since        2.0
 529          *
 530          * @return       @c true if the specified child control is set as always on the top, @n
 531          *               else @c false
 532          * @param[in]    control          The child control
 533          * @exception    E_SUCCESS        The method is successful.
 534          * @exception    E_INVALID_ARG    A specified input parameter is invalid. @n
 535          *                                The specified control is not a child of this
 536          *                                container.
 537          * @remarks      The specific error code can be accessed using the GetLastResult()
 538          *               method.
 539          * @see          SetControlAlwaysOnTop()
 540          */
 541         bool IsControlAlwaysOnTop(const Tizen::Ui::Control& control) const;
 542
 543         /**
 544          * Checks whether a specified child control is always at the top of the drawing stack.
 545          *
 546          * @since        2.1
 547          *
 548          * @return       @c true if a specified child control is set as always at the top, @n
 549          *               else @c false
 550          * @param[in]   pControl          A pointer to child control
 551          * @exception    E_SUCCESS        The method is successful.
 552          * @exception    E_INVALID_ARG    A specified input parameter is invalid. @n
 553          *                                The specified control is not a child of this
 554          *                                container. or @c pControl is @c null
 555          * @remarks      The specific error code can be accessed using the GetLastResult() method.
 556          * @see          SetControlAlwaysOnTop()
 557          */
 558         bool IsControlAlwaysOnTop(const Tizen::Ui::Control* pControl) const;
 559
 560 protected:
 561         /**
 562          * 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.
 563          *
 564          * @since       2.0
 565          */
 566         Container(void);
 567
 568         /**
 569          * Initializes this instance of %Container.
 570          *
 571          * @since                       2.0
 572          *
 573          * @return              An error code
 574          * @exception   E_SUCCESS                       The method is successful.
 575          * @exception   E_SYSTEM                        A system error has occurred.
 576          */
 577         result Construct(void);
 578
 579         /**
 580          * Initializes this instance of %Container.
 581          *
 582          * @since 2.0
 583          *
 584          * @return      An error code
 585          * @param[in]   rect                                      The rectangle bounds to set
 586          * @param[in]   resizable                                Set to @c true to make the container resizable, @n
 587          *                                  else @c false
 588          * @param[in]   movable                                          Set to @c true to make the container movable, @n
 589          *                                  else @c false
 590          * @exception   E_SUCCESS           The method is successful.
 591          * @exception   E_INVALID_ARG            A specified input parameter is invalid.
 592          * @remarks
 593          *                                      - This method must be called from the derived classes's construct methods.
 594          *                                      - If the @c resizable is @c false, IsResizable() returns @c false.
 595         */
 596         result Construct(const Tizen::Graphics::Rectangle& rect, bool resizable = true, bool movable = true);
 597
 598         /**
 599          * Initializes this instance of %Container.
 600          *
 601          * @since 2.1
 602          *
 603          * @return      An error code
 604          * @param[in]   rect                                      The rectangle bounds to set
 605          * @param[in]   resizable                                Set to @c true to make the container resizable, @n
 606          *                                  else @c false
 607          * @param[in]   movable                                          Set to @c true to make the container movable, @n
 608          *                                  else @c false
 609          * @exception   E_SUCCESS           The method is successful.
 610          * @exception   E_INVALID_ARG            A specified input parameter is invalid.
 611          * @remarks
 612          *                                      - This method must be called from the derived classes's construct methods.
 613          *                                      - If the @c resizable is @c false, IsResizable() returns @c false.
 614         */
 615         result Construct(const Tizen::Graphics::FloatRectangle& rect, bool resizable = true, bool movable = true);
 616
 617         /**
 618          * Initializes this instance of %Container with the specified layout and rectangular region.
 619          *
 620          * @since 2.0
 621          *
 622          * @return                  An error code
 623          * @param[in]   layout                                   The layout for both the portrait and landscape mode
 624          * @param[in]   rect                                      The location and size of the %Container
 625          * @param[in]   resizable                                Set to @c true to make the container resizable, @n
 626          *                                  else @c false
 627          * @param[in]   movable                                          Set to @c true to make the container movable, @n
 628          *                                  else @c false
 629          * @exception   E_SUCCESS                The method is successful.
 630          * @exception   E_INVALID_ARG            A specified input parameter is invalid.
 631          * @remarks
 632          *                                      - This method must be called from the derived classes's construct methods.
 633          *                                      - If the @c resizable is @c false, IsResizable() returns @c false.
 634          * @see Tizen::Ui::Container::GetLayoutN()
 635         */
 636         result Construct(const Tizen::Ui::Layout& layout, const Tizen::Graphics::Rectangle& rect, bool resizable = true, bool movable = true);
 637
 638         /**
 639          * Initializes this instance of %Container with the specified layout and rectangular region.
 640          *
 641          * @since 2.1
 642          *
 643          * @return                  An error code
 644          * @param[in]   layout                                   The layout for both the portrait and landscape mode
 645          * @param[in]   rect                                      The location and size of the %Container
 646          * @param[in]   resizable                                Set to @c true to make the container resizable, @n
 647          *                                  else @c false
 648          * @param[in]   movable                                          Set to @c true to make the container movable, @n
 649          *                                  else @c false
 650          * @exception   E_SUCCESS                The method is successful.
 651          * @exception   E_INVALID_ARG            A specified input parameter is invalid.
 652          * @remarks
 653          *                                      - This method must be called from the derived classes's construct methods.
 654          *                                      - If the @c resizable is @c false, IsResizable() returns @c false.
 655          * @see Tizen::Ui::Container::GetLayoutN()
 656         */
 657         result Construct(const Tizen::Ui::Layout& layout, const Tizen::Graphics::FloatRectangle& rect, bool resizable = true, bool movable = true);
 658
 659         /**
 660          * Initializes this instance of %Container with the specified layouts and rectangular region.
 661          *
 662          * @since 2.0
 663          *
 664          * @return                  An error code
 665          * @param[in]   portraitLayout              The layout for the portrait mode
 666          * @param[in]   landscapeLayout           The layout for the landscape mode
 667          * @param[in]   rect                                      The location and size of the %Container
 668          * @param[in]   resizable                                Set to @c true to make the container resizable, @n
 669          *                                  else @c false
 670          * @param[in]   movable                                          Set to @c true to make the container movable, @n
 671          *                                  else @c false
 672          * @exception   E_SUCCESS                The method is successful.
 673          * @exception   E_INVALID_ARG            A specified input parameter is invalid.
 674          * @remarks     If the @c resizable is @c false, IsResizable() returns @c false.
 675          * @see Tizen::Ui::Container::GetLayoutN()
 676          * @see Tizen::Ui::Container::GetPortraitLayoutN()
 677          * @see Tizen::Ui::Container::GetLandscapeLayoutN()
 678         */
 679         result Construct(const Tizen::Ui::Layout& portraitLayout, const Tizen::Ui::Layout& landscapeLayout, const Tizen::Graphics::Rectangle& rect, bool resizable = true, bool movable = true);
 680
 681         /**
 682          * Initializes this instance of %Container with the specified layouts and rectangular region.
 683          *
 684          * @since 2.1
 685          *
 686          * @return                  An error code
 687          * @param[in]   portraitLayout              The layout for the portrait mode
 688          * @param[in]   landscapeLayout           The layout for the landscape mode
 689          * @param[in]   rect                                      The location and size of the %Container
 690          * @param[in]   resizable                                Set to @c true to make the container resizable, @n
 691          *                                  else @c false
 692          * @param[in]   movable                                          Set to @c true to make the container movable, @n
 693          *                                  else @c false
 694          * @exception   E_SUCCESS                The method is successful.
 695          * @exception   E_INVALID_ARG            A specified input parameter is invalid.
 696          * @remarks     If the @c resizable is @c false, IsResizable() returns @c false.
 697          * @see Tizen::Ui::Container::GetLayoutN()
 698          * @see Tizen::Ui::Container::GetPortraitLayoutN()
 699          * @see Tizen::Ui::Container::GetLandscapeLayoutN()
 700         */
 701         result Construct(const Tizen::Ui::Layout& portraitLayout, const Tizen::Ui::Layout& landscapeLayout, const Tizen::Graphics::FloatRectangle& rect, bool resizable = true, bool movable = true);
 702
 703         /**
 704          * Gets the index of the specified control.
 705          *
 706          * @brief       <i> [Deprecated] </i>
 707          * @deprecated  This method is deprecated.
 708          * @since                       2.0
 709          * @return              An error code
 710          * @param[in]   control                 The control
 711          * @param[out]  index                   The index of the control
 712          * @exception   E_SUCCESS                       The method is successful.
 713          * @exception   E_OBJ_NOT_FOUND         The specified instance of Control is not found.
 714          * @see                 SetControlAt()
 715          *
 716          */
 717         result GetControlAt(const Control& control, int& index) const;
 718
 719         /**
 720          * Gets the index of a specified control.
 721          *
 722          * @since                             2.1
 723          * @return                 An error code
 724          * @param[in] pControl                   A pointer to the control
 725          * @param[out]          index                        The index of the control
 726          * @exception E_SUCCESS                           The method is successful.
 727          * @exception    E_INVALID_ARG   The specified @c pControl is @c null.
 728          * @exception E_OBJ_NOT_FOUND               The specified instance of Control is not found.
 729          * @see                               SetControlAt()
 730          *
 731          */
 732         result GetControlAt(const Control* pControl, int& index) const;
 733
 734         /**
 735          * Sets the control at the specified index.
 736          *
 737          * @brief       <i> [Deprecated] </i>
 738          * @deprecated  This method is deprecated.
 739          * @since                       2.0
 740          *
 741          * @return              An error code
 742          * @param[in]   control         The control
 743          * @param[in]   index           The index
 744          * @exception   E_SUCCESS       The method is successful.
 745          * @exception   E_OUT_OF_RANGE  The specified @c index is out of range.
 746          * @exception   E_SYSTEM        A system error has occurred.
 747          * @remarks         The @c control must be first added to this container. @n
 748          *                              Call the Invalidate() method after this, to apply the change to be shown.
 749          * @see         GetControlAt()
 750          *
 751          */
 752         result SetControlAt(const Control& control, int index);
 753
 754         /**
 755          * Sets the control at a specified index.
 756          *
 757          * @since                             2.1
 758          *
 759          * @return                    An error code
 760          * @param[in] pControl        A pointer to the control
 761          * @param[in] index           The index
 762          * @exception E_SUCCESS       The method is successful.
 763          * @exception E_OUT_OF_RANGE  The specified @c index is out of range.
 764          * @exception E_INVALID_ARG   The specified @c pControl is @c null.
 765          * @exception E_SYSTEM        A system error has occurred.
 766          * @remarks                                       The @c control must be first added to this container. @n
 767          *                            Then the Invalidate() method is called to show the applied changes.
 768          * @see                       GetControlAt()
 769          *
 770          */
 771         result SetControlAt(Control* pControl, int index);
 772
 773 protected:
 774         /**
 775          * Called to notify that the bounds of the control is changing.
 776          *
 777          * @since       2.1
 778          *
 779          * @return      An error code
 780          * @param[in]   oldRect  The old position and size values of the control
 781          * @param[in]   newRect  The new position and size values of the control
 782          * @remarks     If the method returns an exception, the resulting exception
 783          *              is propagated and the control's size is unchanged.@n
 784          *              Provide control specific exceptions.
 785          * @see         Tizen::Ui::Control::SetBounds()
 786          * @see         Tizen::Ui::Control::SetSize()
 787          */
 788         virtual result OnBoundsChanging(const Tizen::Graphics::FloatRectangle& oldRect, const Tizen::Graphics::FloatRectangle& newRect);
 789
 790         /**
 791          * Called to notify that the bounds of the control is changed.
 792          *
 793          * @since       2.1
 794          *
 795          * @return      An error code
 796          * @param[in]   oldRect  The old position and size values of the control
 797          * @param[in]   newRect  The new position and size values of the control
 798          * @see         Tizen::Ui::Control::SetBounds()
 799          * @see         Tizen::Ui::Control::SetSize()
 800          */
 801         virtual void OnBoundsChanged(const Tizen::Graphics::FloatRectangle& oldRect, const Tizen::Graphics::FloatRectangle& newRect);
 802
 803         /**
 804          * Overrides this method to indicate that the specified @c width and @c height
 805          * can be supported or a new @c width and @c height should be applied instead
 806          * of the specified values.
 807          *
 808          * @since           2.1
 809          *
 810          * @return          A Boolean flag that indicates whether the specified @c evaluatedSize
 811          *                  is modified.
 812          * @param[in, out]  evaluatedSize  The width and the height to evaluate
 813          */
 814         virtual bool OnEvaluateSize(Tizen::Graphics::FloatDimension& evaluatedSize);
 815
 816         //
 817         // This method is for internal use only.
 818         // Using this method can cause behavioral, security-related, and consistency-related issues in the application.
 819         //
 820         // This method is reserved and may change its name at any time without prior notice.
 821         //
 822         virtual void Container_Reserved4(void) {}
 823
 824         //
 825         // This method is for internal use only.
 826         // Using this method can cause behavioral, security-related, and consistency-related issues in the application.
 827         //
 828         // This method is reserved and may change its name at any time without prior notice.
 829         //
 830         virtual void Container_Reserved5(void) {}
 831
 832 private:
 833         //
 834         // The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying of objects.
 835         //
 836         Container(const Container& rhs);
 837
 838         //
 839         // The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit copying of objects.
 840         //
 841         Container& operator =(const Container& rhs);
 842
 843 private:
 844         friend class _ContainerImpl;
 845 }; // Container
 846
 847 }}  //Tizen::Ui
 848
 849 #endif //_FUI_CONTAINER_H_