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