src/ui/inc/FUi_Control.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        FUi_Control.h
  19  * @brief       This is the header file for the _Control class.
  20  *
  21  * This header file contains the declarations of the %_Control class.
  22  */
  23
  24 #ifndef _FUI_INTERNAL_CONTROL_H_
  25 #define _FUI_INTERNAL_CONTROL_H_
  26
  27 #include <FBaseObject.h>
  28 #include <FUiAnimIVisualElementContentProvider.h>
  29 #include "FUi_Types.h"
  30 #include "FUi_UiEventTypes.h"
  31 #include "FUi_IUiEventListener.h"
  32 #include "FUi_IKeyEventPreviewer.h"
  33 #include "FUi_IKeyEventListener.h"
  34 #include "FUi_ITouchEventPreviewer.h"
  35 #include "FUi_ITouchEventListener.h"
  36 #include "FUi_IFocusEventListener.h"
  37 #include "FUi_INotificationEventPreviewer.h"
  38 #include "FUi_INotificationEventListener.h"
  39 #include "FUi_PropertyBase.h"
  40 #include "FUi_TouchGestureDetector.h"
  41 #include "FGrp_FontImpl.h"
  42
  43 namespace Tizen { namespace Base { namespace Collection {
  44 template<class T> class ArrayListT;
  45 template<class KeyType, class ValueType> class HashMapT;
  46 }}}
  47
  48 namespace Tizen { namespace Ui { namespace Animations
  49 {
  50 class _VisualElement;
  51 class _ControlVisualElement;
  52 class _IVisualElementDelegate;
  53 }}}
  54
  55 namespace Tizen { namespace Ui { namespace _Layout
  56 {
  57 class LayoutContainer;
  58 class Layout;
  59 }}}
  60
  61 namespace Tizen { namespace Ui {
  62
  63 class _Window;
  64 class _DataBindingContext;
  65 class _AccessibilityContainer;
  66
  67 class _IControlDelegate
  68 {
  69 public:
  70         virtual ~_IControlDelegate(void){}
  71
  72         // Queries
  73         virtual Tizen::Graphics::Dimension GetContentSize(void) const = 0;
  74         virtual Tizen::Ui::Animations::HitTestResult HitTest(const Tizen::Graphics::FloatPoint& point) = 0;
  75         virtual Tizen::Base::String GetDescription(void) const = 0;
  76
  77         // Invoked by operations
  78         virtual void OnDraw(void) = 0;
  79         virtual Tizen::Graphics::Canvas* OnCanvasRequestedN(const Tizen::Graphics::Dimension& size) = 0;
  80         virtual Tizen::Graphics::Bitmap* OnCapturedBitmapRequestedN(void) = 0;
  81         virtual result OnAttaching(const _Control* pParent) = 0;
  82         virtual result OnAttached(void) = 0;
  83         virtual void OnAttachingFailed(const _Control& parent) = 0; // [ToDo] Is this callback still necessary?
  84         virtual result OnAttachingToMainTree(const _Control* pParent) = 0;
  85         virtual result OnAttachedToMainTree(void) = 0;
  86         virtual result OnDetachingFromMainTree(void) = 0;
  87         virtual result OnDetaching(void) = 0;
  88         virtual result OnBoundsChanging(const Tizen::Graphics::Rectangle& bounds) = 0;
  89         virtual void OnBoundsChanged(void) = 0;
  90         virtual void OnEvaluateSize(Tizen::Graphics::Dimension& evaluatedSize) = 0;
  91         virtual void OnParentBoundsChanged(const _Control& parent) = 0;
  92         virtual void OnChildAttached(const _Control& child) = 0;
  93         virtual void OnChildDetaching(const _Control& child) = 0;
  94         virtual void OnChildDetached(const _Control& child) = 0;
  95         virtual void OnChildBoundsChanged(const _Control& child) = 0;
  96         virtual void OnChildVisibleStateChanged(const _Control& child) = 0;
  97         virtual void OnChangeLayout(_ControlOrientation orientation) = 0; // [ToDo] Generalize orientation to screen.
  98         virtual void OnZOrderChanging(_ControlZOrderUpdate zOrderUpdate) = 0;
  99         virtual void OnVisibleStateChanging(void) = 0;
 100         virtual void OnVisibleStateChanged(void) = 0;
 101         virtual void OnAncestorVisibleStateChanged(const _Control& control) = 0;
 102         virtual void OnAncestorEnableStateChanged(const _Control& control) = 0;
 103         virtual void OnFontChanged(Tizen::Graphics::Font* pFont) = 0;
 104         virtual void OnFontInfoRequested(unsigned long& style, int& size) =0;
 105 };
 106
 107 class _IPropagatedTouchEventListener
 108         : public _ITouchEventListener
 109 {
 110 public:
 111         virtual ~_IPropagatedTouchEventListener(void){}
 112
 113         virtual void OnTouchPressHandled(const _Control& control) = 0;
 114         virtual void OnTouchReleaseHandled(const _Control& control) = 0;
 115         virtual void OnTouchMoveHandled(const _Control& control) = 0;
 116         virtual void OnTouchCancelHandled(const _Control& control) = 0;
 117 };
 118
 119 class _IPropagatedKeyEventListener
 120         : public _IKeyEventListener
 121 {
 122 public:
 123         virtual ~_IPropagatedKeyEventListener(void){}
 124 };
 125
 126 class _OSP_EXPORT_ _Control // Temp: export only for test
 127         : public _IControlDelegate
 128         , public _ITouchEventPreviewer
 129         , public _IKeyEventPreviewer
 130         , public _IFocusEventListener
 131         , public _INotificationEventPreviewer
 132         , public _INotificationEventListener
 133         , public _PropertyBase
 134         , virtual public Tizen::Base::Runtime::IEventListener
 135         , virtual public _IUiEventListener
 136         , virtual public _IUiEventPreviewer
 137         , public _IPropagatedTouchEventListener
 138         , public _IPropagatedKeyEventListener
 139 {
 140 // Declare Properties
 141         DECLARE_CLASS_BEGIN(_Control, _PropertyBase);
 142         DECLARE_PROPERTY("Name", GetPropertyName, SetPropertyName);
 143         DECLARE_CLASS_END();
 144
 145 // Property Getters/Setters
 146         result SetPropertyName(const Variant& name);
 147         Variant GetPropertyName(void) const;
 148
 149 public:
 150 // Constants
 151         enum
 152         {
 153                 MAX_LENGTH = 0xFFFF
 154         };
 155
 156         enum VisitType
 157         {
 158                 VISIT_UPWARD,
 159                 VISIT_DOWNWARD,
 160                 VISIT_STOP
 161         };
 162
 163 // Type definitions
 164         class Visitor
 165         {
 166         public:
 167                 virtual ~Visitor(void){}
 168                 virtual VisitType Visit(_Control& control) = 0;
 169         };
 170
 171         typedef Tizen::Base::Collection::ArrayListT<_Control*> ControlList;
 172         typedef Tizen::Base::Collection::ArrayListT<_Window*> WindowList;
 173         typedef Tizen::Base::Collection::HashMapT<_TouchGestureDetector*, _TouchGestureDetectorState> GestureMap;
 174
 175 public:
 176 // Life Cycle
 177         static _Control* CreateControlN(void);
 178         virtual ~_Control(void);
 179
 180 // Event Callbacks
 181         virtual bool OnPreviewKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
 182         virtual bool OnPreviewKeyReleased(const _Control& source, const _KeyInfo& keyInfo);
 183         virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
 184         virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo);
 185         virtual bool TranslateKeyEventInfo(const _Control& source, _KeyInfo& keyInfo);
 186         virtual _UiTouchEventDelivery OnPreviewTouchPressed(const _Control& source, const _TouchInfo& touchinfo);
 187         virtual _UiTouchEventDelivery OnPreviewTouchReleased(const _Control& source, const _TouchInfo& touchinfo);
 188         virtual _UiTouchEventDelivery OnPreviewTouchMoved(const _Control& source, const _TouchInfo& touchinfo);
 189         virtual _UiTouchEventDelivery OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchinfo);
 190         virtual bool OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo);
 191         virtual bool OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo);
 192         virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo);
 193         virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo);
 194         virtual bool OnFocusGained(const _Control& source);
 195         virtual bool OnFocusLost(const _Control& source);
 196         virtual bool OnPreviewNotifiedN(const _Control& source, Tizen::Base::Collection::IList* pArgs); // [ToDo] Make the notification id as enumeration.
 197         virtual bool OnNotifiedN(const _Control& source, Tizen::Base::Collection::IList* pArgs);
 198
 199 // Virtual Queries: Do not use directly. Use through delegate (GetControlDelegate())
 200         virtual Tizen::Graphics::Dimension GetContentSize(void) const;
 201         virtual Tizen::Ui::Animations::HitTestResult HitTest(const Tizen::Graphics::FloatPoint& point);
 202         virtual Tizen::Base::String GetDescription(void) const;
 203         virtual int GetVerticalScrollPosition(void) const;
 204         virtual int GetHorizontalScrollPosition(void) const;
 205
 206 // Callbacks // [ToDo] Make these callbacks protected.
 207         virtual void OnDraw(void);
 208         virtual Tizen::Graphics::Canvas* OnCanvasRequestedN(const Tizen::Graphics::Dimension& size);
 209         virtual Tizen::Graphics::Bitmap* OnCapturedBitmapRequestedN(void);
 210         virtual result OnAttaching(const _Control* pParent);
 211         virtual result OnAttached(void);
 212         virtual result OnAttachingToMainTree(const _Control* pParent);
 213         virtual result OnAttachedToMainTree(void);
 214         virtual result OnDetachingFromMainTree(void);
 215         virtual void OnAttachingFailed(const _Control& parent);
 216         virtual result OnDetaching(void);
 217         virtual result OnBoundsChanging(const Tizen::Graphics::Rectangle& bounds);
 218         virtual void OnBoundsChanged(void);
 219         virtual void OnEvaluateSize(Tizen::Graphics::Dimension& evaluatedSize);
 220         virtual void OnParentBoundsChanged(const _Control& parent);
 221         virtual void OnChildAttached(const _Control& child);
 222         virtual void OnChildDetaching(const _Control& child);
 223         virtual void OnChildDetached(const _Control& child);
 224         virtual void OnChildBoundsChanged(const _Control& child);
 225         virtual void OnChildVisibleStateChanged(const _Control& child);
 226         virtual void OnChangeLayout(_ControlOrientation orientation);
 227         virtual void OnZOrderChanging(_ControlZOrderUpdate zOrderUpdate);
 228         virtual void OnVisibleStateChanging(void);
 229         virtual void OnVisibleStateChanged(void);
 230         virtual void OnAncestorVisibleStateChanged(const _Control& control);
 231         virtual void OnAncestorEnableStateChanged(const _Control& control);
 232         virtual void OnTouchPressHandled(const _Control& control);
 233         virtual void OnTouchReleaseHandled(const _Control& control);
 234         virtual void OnTouchMoveHandled(const _Control& control);
 235         virtual void OnTouchCancelHandled(const _Control& control);
 236         virtual void OnFontChanged(Tizen::Graphics::Font* pFont);
 237         virtual void OnFontInfoRequested(unsigned long& style, int& size);
 238
 239 // Control Hierarchy - Common
 240         bool HasParent(void) const;
 241         _Control* GetParent(void) const;
 242         _ControlArea GetArea(void) const;
 243         _ControlLayer GetLayer(void) const;
 244
 245         bool IsAncestorOf(const _Control& control) const;
 246         bool IsAttachedToMainTree(void) const;
 247         _Window* GetRootWindow(void) const;
 248
 249         void Accept(Visitor& visitor);
 250         void Accept(Visitor& visitor) const;
 251
 252 // Control Hierarchy
 253         int GetChildIndex(const _Control& child) const;
 254         _Control* GetChild(int index) const;
 255         int GetChildCount(void) const;
 256
 257         result AttachChild(_Control& child);
 258         result InsertChildToBottom(_Control& child);
 259         result InsertChildAfter(const _Control& targetChild, _Control& child);
 260         result InsertChildBefore(const _Control& targetChild, _Control& child);
 261         result DetachChild(_Control& child);
 262         void DetachAllChildren(bool detachSystemChild = true);
 263         result MoveChildToTop(const _Control& child);
 264         result MoveChildToBottom(const _Control& child);
 265         result MoveChildAfter(const _Control& targetChild, const _Control& child);
 266         result MoveChildBefore(const _Control& targetChild, const _Control& child);
 267
 268         result SetChildAlwaysOnTop(_Control& child);
 269         result SetChildAlwaysAtBottom(_Control& child);
 270         result ResetChildLayer(_Control& child);
 271
 272 // Control Hierarchy - System area: For system children, layout is not applyed.
 273         result AttachSystemChild(_Control& child);
 274         result DetachSystemChild(_Control& child);
 275
 276 // Ownership
 277         int GetOwneeCount(void) const;
 278         _Window* GetOwnee(int index) const;
 279
 280 // Handle
 281         _ControlHandle GetHandle(void) const;
 282
 283 // Name
 284         Tizen::Base::String GetName(void) const;
 285         void SetName(const Tizen::Base::String& name);
 286
 287 // Event previewer/listener
 288         template <int type, typename T>
 289         T GetEventPreviewer(void) const
 290         {
 291                 return GetEventPreviewer(_IntToType<type>());
 292         }
 293
 294         template <int type, typename T>
 295         T GetEventListener(void) const
 296         {
 297                 return GetEventListener(_IntToType<type>());
 298         }
 299
 300         template <int type, typename T>
 301         void SetEventPreviewer(const T& t)
 302         {
 303                 SetEventPreviewer(_IntToType<type>(), t);
 304         }
 305
 306         template <int type, typename T>
 307         void SetEventListener(const T& t)
 308         {
 309                 SetEventListener(_IntToType<type>(), t);
 310         }
 311
 312         void ResetEventListeners(void);
 313
 314 // Drawing
 315         void Draw(bool recursive = true);
 316         void Show(void);
 317         void Invalidate(void);
 318         void Invalidate(bool recursive);
 319         void Invalidate(const Tizen::Graphics::Rectangle& rect);
 320         Tizen::Graphics::Canvas* GetCanvasN(void) const;
 321         Tizen::Graphics::Canvas* GetCanvasN(const Tizen::Graphics::Rectangle& bounds) const;
 322         bool IsCalledGetCanvasN(void) const;
 323         Tizen::Graphics::Canvas* GetClientCanvasN(void) const;
 324         Tizen::Graphics::Color GetBackgroundColor(void) const;
 325         void SetBackgroundColor(const Tizen::Graphics::Color& color);
 326         Tizen::Graphics::Bitmap* GetCapturedBitmapN(bool includeChildren) const;
 327         Tizen::Graphics::Rectangle GetInvalidatedBounds(void) const;
 328         void SetDrawWhenVisible(bool draw);
 329         bool IsDrawWhenVisible(void);
 330         void SetTerminatingOrder(bool postOrderTraversal);
 331
 332 // Font
 333         result SetFont(const Tizen::Base::String& fontName);
 334         Tizen::Graphics::Font* GetFallbackFont(void);
 335         Tizen::Base::String GetFont(void) const;
 336
 337 // Enable
 338         bool IsEnabled(void) const;
 339         bool GetEnableState(void) const;
 340         void SetEnableState(bool enableState);
 341
 342         bool IsInputEnabled(void) const;
 343         bool GetInputEnableState(void) const;
 344         void SetInputEnableState(bool inputEnableState);
 345
 346 // Visible
 347         bool IsVisible(void) const;
 348         bool GetVisibleState(void) const;
 349         void SetVisibleState(bool visibleState);
 350
 351 // Focus
 352         bool IsFocusable(void) const;
 353         void SetFocusable(bool focusable);
 354         bool IsFocused(void) const;
 355         _Control* GetFocused(void) const;
 356         result SetFocused(void);
 357         bool IsNativeObjectFocusable(void) const;
 358         void SetNativeObjectFocusable(bool focusable);
 359
 360 // Clipping
 361         bool IsClipToParent(void) const;
 362         result SetClipToParent(bool clipToParent);
 363         result SetClipChildrenEnabled(bool clipChildren);
 364
 365 // Geometry
 366         bool IsMovable(void) const;
 367         bool IsResizable(void) const;
 368         void SetMovable(bool movable);
 369         void SetResizable(bool resizable);
 370
 371         Tizen::Graphics::Rectangle GetBounds(void) const;
 372         Tizen::Graphics::Point GetPosition(void) const;
 373         Tizen::Graphics::Dimension GetSize(void) const;
 374         result SetBounds(const Tizen::Graphics::Rectangle& bounds, bool callBoundsChangeCallbacks = true);
 375         result SetBounds(const Tizen::Graphics::FloatRectangle& bounds, bool callBoundsChangeCallbacks = true);
 376         result SetPosition(const Tizen::Graphics::Point& position);
 377         result SetSize(const Tizen::Graphics::Dimension& size);
 378
 379         Tizen::Graphics::Dimension GetMinimumSize(void) const;
 380         Tizen::Graphics::Dimension GetMaximumSize(void) const;
 381         result SetMinimumSize(const Tizen::Graphics::Dimension& newMinSize);
 382         result SetMaximumSize(const Tizen::Graphics::Dimension& newMaxSize);
 383         Tizen::Graphics::Point ConvertToControlPosition(const Tizen::Graphics::Point& screenPosition) const;
 384         Tizen::Graphics::Point ConvertToScreenPosition(const Tizen::Graphics::Point& controlPosition) const;
 385
 386         Tizen::Graphics::Rectangle GetClientBounds(void) const;
 387         Tizen::Graphics::Rectangle GetClientBounds(const Tizen::Graphics::Dimension& size) const;
 388         Tizen::Graphics::Rectangle GetAbsoluteBounds(void) const;
 389         result SetClientBounds(const Tizen::Graphics::Rectangle& bounds);
 390         bool IsCalledSetClientBounds(void);
 391
 392         bool Contains(const Tizen::Graphics::Point& point) const;
 393         _Control* GetTopmostChildAt(const Tizen::Graphics::Point& point) const;
 394
 395 // Layout
 396         void PartialUpdateLayout(void);
 397         void UpdateLayout(void);
 398         bool IsLayoutable(void) const;
 399         _Layout::LayoutContainer& GetLayoutContainer(void) const;
 400         _Layout::Layout* GetLayout(void) const;
 401         result AddLayout(_Layout::Layout& layout);
 402         result SetCurrentLayout(_Layout::Layout& layout);
 403         void SetUpdateLayoutState(bool state);
 404
 405 // Orientation
 406         void ChangeLayout(_ControlOrientation orientation);
 407         _ControlOrientation GetOrientation(void) const;
 408         virtual bool IsLayoutChangable(void) const;
 409         virtual bool IsOrientationRoot(void) const;
 410
 411 // Touch, Gesture
 412         result AddGestureDetector(const _TouchGestureDetector& gestureDetector);
 413         result RemoveGestureDetector(const _TouchGestureDetector& gestureDetector);
 414         Tizen::Base::Collection::IListT<_TouchGestureDetector*>* GetGestureDetectorList(void) const;
 415         bool IsDelayedTouchEventEnabled(void) const;
 416         bool IsCancelOnGestureSuccess(void) const;
 417         bool IsPossibleToSendDelayedTouchEvent(void) const;
 418         bool IsSentDelayedEvent(void) const;
 419         void SetSentDelayedEvent(bool sent);
 420         void SetSendingDelayedEvent(bool sending);
 421         bool IsSendingDelayedEvent(void) const;
 422         void AddTouchInfo(const _TouchInfo& touchInfo);
 423         Tizen::Base::Collection::IListT<_TouchInfo*>* GetTouchInfoList(void);
 424         result AddStartedGestureDetector(const _TouchGestureDetector& gestureDetector, _TouchGestureDetectorState state);
 425         result ClearStartedGestureDetectorList(void);
 426         result SetStartedGestureDetector(const _TouchGestureDetector& gestureDetector, _TouchGestureDetectorState state);
 427         Tizen::Base::Collection::IMapEnumeratorT <_TouchGestureDetector*, _TouchGestureDetectorState>* GetStartedGestureDetectorEnumeratorN(void) const;
 428
 429         void SetMultiTouchEnabled(bool enabled);
 430         bool IsMultiTouchEnabled(void) const;
 431         void SetTouchCapture(bool allowOutOfBounds = false);
 432         void ReleaseTouchCapture(void);
 433
 434         bool IsDragEnabled(void) const;
 435         bool IsDropEnabled(void) const;
 436         void SetDragEnabled(bool enabled);
 437         void SetDropEnabled(bool enabled);
 438
 439         void SetTouchMoveAllowance(_TouchMoveAllowance touchMoveAllowanceType);
 440         _TouchMoveAllowance GetTouchMoveAllowance(void) const;
 441
 442         void SetChangingEventTarget(bool isChangingEventTarget);
 443         bool GetChangingEventTarget(void) const;
 444
 445 // Data binding
 446         _DataBindingContext* GetDataBindingContext(void);
 447     _AccessibilityContainer* GetAccessibilityContainer(void);
 448
 449 // User data: Already used by impl.
 450         void* GetUserData(void) const;
 451         void SetUserData(void* pUserData);
 452
 453 // Delegate Already used by impl.
 454         void SetControlDelegate(_IControlDelegate& delegate);
 455         void ResetControlDelegate(void);
 456         _IControlDelegate& GetControlDelegate(void) const;
 457
 458         void SetPropagatedTouchEventListener(_IPropagatedTouchEventListener* pListener);
 459         _IPropagatedTouchEventListener* GetPropagatedTouchEventListener(void) const;
 460
 461         void SetPropagatedKeyEventListener(_IPropagatedKeyEventListener* pListener);
 462         _IPropagatedKeyEventListener* GetPropagatedKeyEventListener(void) const;
 463
 464 // Visual element: Do not use visual element directly.
 465         Animations::_VisualElement* GetVisualElement(void) const;
 466
 467         void PrintDescription(bool printChildren = true);
 468
 469         void SetEventReceivable(bool receivable);
 470         bool IsEventReceivable(void) const;
 471
 472 protected:
 473         _Control(void);
 474         void DisposeControl(void);
 475         void AcquireHandle(void);
 476         void SetDataBindingContext(_DataBindingContext* pDataBindingContext);
 477
 478 private:
 479         _Control(const _Control& rhs);
 480         _Control& operator =(const _Control& rhs);
 481
 482         void ReleaseHandle(void);
 483
 484         bool IsInSizeRange(const Tizen::Graphics::Dimension& size);
 485         result AdjustSizeToRange(void);
 486         result SetBoundsInternal(const Tizen::Graphics::FloatRectangle& bounds, bool callBoundsChangeCallbacks);
 487         result SetBoundsFinal(const Tizen::Graphics::FloatRectangle& newBounds, bool changeLayoutBaseRect, bool callBoundsChangeCallbacks);
 488         result UpdateBoundsOfVisualElement(const Tizen::Graphics::FloatRectangle& controlBounds);
 489
 490         const ControlList& GetChildList(void) const;
 491         ControlList& GetChildList(void);
 492         result StartAttaching(_Control& child, _ControlArea area);
 493         result EndAttaching(_Control& child);
 494         void SetParent(_Control* pParent);
 495
 496         bool IsCalledCallAttachingToMainTree(void);
 497         void SetCalledCallAttachingToMainTree(bool isAttaching);
 498         bool IsCalledCallAttachedToMainTree(void);
 499         void SetCalledCallAttachedToMainTree(bool isAttached);
 500
 501         result CallOnAttachingToMainTree(_Control& control);
 502         result CallOnAttachedToMainTree(_Control& control);
 503         result CallOnDetachingFromMainTree(_Control& control);
 504         void CallOnAncestorVisibleStateChanged(void);
 505         void CallOnAncestorEnableStateChanged(void);
 506
 507         result AttachOwnee(_Window& window);
 508         void DetachOwnee(_Window& window);
 509         void DetachAllOwnees(void);
 510
 511         void SetLayer(_ControlLayer layer);
 512
 513         int PrintDescription(bool printChildren, int depth);
 514
 515         _ITouchEventPreviewer* GetEventPreviewer(_IntToType<_UI_EVENT_TOUCH>) const;
 516         _IKeyEventPreviewer* GetEventPreviewer(_IntToType<_UI_EVENT_KEY>) const;
 517         _INotificationEventPreviewer* GetEventPreviewer(_IntToType<_UI_EVENT_NOTIFICAITON>) const;
 518
 519         _IKeyEventListener* GetEventListener(_IntToType<_UI_EVENT_KEY>) const;
 520         _IFocusEventListener* GetEventListener(_IntToType<_UI_EVENT_FOCUS>) const;
 521         _INotificationEventListener* GetEventListener(_IntToType<_UI_EVENT_NOTIFICAITON>) const;
 522
 523         void SetEventPreviewer(_IntToType<_UI_EVENT_TOUCH>, _ITouchEventPreviewer* pPreviewer);
 524         void SetEventPreviewer(_IntToType<_UI_EVENT_KEY>, _IKeyEventPreviewer* pPreviewer);
 525         void SetEventPreviewer(_IntToType<_UI_EVENT_NOTIFICAITON>, _INotificationEventPreviewer* pPreviewer);
 526
 527         void SetEventListener(_IntToType<_UI_EVENT_FOCUS>, _IFocusEventListener* pListener);
 528         void SetEventListener(_IntToType<_UI_EVENT_NOTIFICAITON>, _INotificationEventListener* pListener);
 529
 530
 531 //--[ToDo] To be removed---------------------------------------------------------------------------------------------//
 532 private:
 533         void SetFocusOn(void);
 534 public:
 535         virtual void SetFocusOff(_Control* pFocus);
 536 //-------------------------------------------------------------------------------------------------------------------//
 537
 538 private:
 539         _ControlHandle __controlHandle;
 540         Tizen::Base::String __name;
 541
 542         _Control* __pParent;
 543         ControlList* __pChildren;
 544         WindowList* __pOwnees;
 545
 546         Tizen::Graphics::Rectangle __bounds;
 547         Tizen::Graphics::Rectangle __clientBounds;
 548         Tizen::Graphics::Rectangle __absoluteBounds;
 549         Tizen::Graphics::Rectangle __invalidatedBounds;
 550         Tizen::Graphics::Dimension __minSize;
 551         Tizen::Graphics::Dimension __maxSize;
 552         Tizen::Graphics::Color __backgroundColor;
 553
 554         bool __movable;
 555         bool __resizable;
 556         bool __focusable;
 557         bool __nativeObjectFocusable;
 558         bool __enabledState;
 559         bool __inputEnabledState;
 560         bool __visibleState;
 561         bool __initVisibleState;
 562         bool __clipToParent;
 563         bool __focusSet;
 564         bool __multiTouchEnabled;
 565         bool __dragEnabled;
 566         bool __dropEnabled;
 567         bool __drawWhenVisible;
 568         bool __isPostOrderTraversal;
 569         bool __isCalledCallOnAttachingToMainTree;
 570         bool __isCalledCallOnAttachedToMainTree;
 571         bool __isSetClientBounds;
 572         bool __isCalledGetCanvasN;
 573
 574         class ControlVisualElementContentProvider;
 575         ControlVisualElementContentProvider* __pVisualElementContentProvider;
 576         Animations::_ControlVisualElement* __pVisualElement;
 577
 578         class ControlVisualElementEventListener;
 579         ControlVisualElementEventListener* __pVisualElementEventListener;
 580
 581         class LayoutItemHandler;
 582         LayoutItemHandler* __pLayoutItemHandler;
 583         _Layout::Layout* __pPortraitLayout;
 584         _Layout::Layout* __pLandscapeLayout;
 585         _Layout::LayoutContainer* __pLayoutContainer;
 586
 587         _ControlArea __area;
 588         _ControlLayer __layer;
 589         _ControlOrientation __orientation;
 590
 591         _ITouchEventPreviewer* __pTouchEventPreviewer;
 592         _IKeyEventPreviewer* __pKeyEventPreviewer;
 593         _INotificationEventPreviewer* __pNotificationEventPreviewer;
 594
 595         _IKeyEventListener* __pKeyEventListener;
 596         _IFocusEventListener* __pFocusEventListener;
 597         _INotificationEventListener* __pNotificationEventListener;
 598
 599         Tizen::Base::Collection::IListT<_TouchGestureDetector*>* __pCoreGestureDetectors;
 600         GestureMap* __pDetectStartedGestureMap;
 601         Tizen::Base::Collection::IListT<_TouchInfo*>* __pDelayedTouchInfoList;
 602         _TouchMoveAllowance __touchMoveAllowance;
 603         bool __isSentDelayedEvent;
 604         bool __isSendingDelayedEvent;
 605         bool __isChangingEventTarget;
 606
 607         _DataBindingContext* __pDataBindingContext;
 608         _IControlDelegate* __pControlDelegate;
 609         _IPropagatedTouchEventListener* __pPropagatedTouchEventListener;
 610         _IPropagatedKeyEventListener* __pPropagatedKeyEventListener;
 611         void* __pUserData;
 612         _AccessibilityContainer* __pAccessibilityContainer;
 613
 614         bool __destroying;
 615         bool __isEventReceivable;
 616
 617         bool __isControlFontChanged;
 618         Tizen::Graphics::Font* __pFont;
 619         Tizen::Base::String __fontName;
 620
 621         friend class _Window;
 622         friend class _ControlManager;
 623         friend class LayoutItemHandler;
 624 }; // _Control
 625
 626 }} // Tizen::Ui
 627
 628 #endif // _FUI_INTERNAL_CONTROL_H_