src/ui/controls/FUiCtrl_ScrollPanelImpl.cpp

   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        FUiCtrl_ScrollPanelImpl.cpp
  20  * @brief       This is the implementation file for the %_ScrollPanelImpl class.
  21  *
  22  */
  23
  24 #include <FBaseSysLog.h>
  25 #include <FGrpRectangle.h>
  26 #include <FUiCtrlScrollPanel.h>
  27 #include <FBase_LocalizedNumParser.h>
  28 #include <FUiLayout.h>
  29 #include "FApp_AppInfo.h"
  30 #include "FUi_LayoutImpl.h"
  31 #include "FUi_LayoutLayoutMaker.h"
  32 #include "FUi_UiBuilder.h"
  33 #include "FUiCtrl_Edit.h"
  34 #include "FUiCtrl_ScrollEvent.h"
  35 #include "FUiCtrl_ScrollEventArg.h"
  36 #include "FUiCtrl_ScrollPanelImpl.h"
  37 #include "FUi_CoordinateSystemUtils.h"
  38
  39 using namespace Tizen::App;
  40 using namespace Tizen::Graphics;
  41
  42 namespace Tizen { namespace Ui { namespace Controls
  43 {
  44
  45 _ScrollPanelImpl::_ScrollPanelImpl(Control* pPublic, _Control* pCore, Layout* pPublicPortraitLayout, Layout* pPublicLandscapeLayout)
  46         : _PanelImpl(pPublic, pCore, pPublicPortraitLayout, pPublicLandscapeLayout)
  47         , __pScrollEvent(null)
  48         , __detached(false)
  49 {
  50         // nothing
  51 }
  52
  53 _ScrollPanelImpl::~_ScrollPanelImpl(void)
  54 {
  55         GetCore().RemoveScrollEventListener(*this);
  56
  57         delete __pScrollEvent;
  58         __pScrollEvent = null;
  59 }
  60
  61 _ScrollPanelImpl*
  62 _ScrollPanelImpl::CreateScrollPanelImplN(ScrollPanel* pControl, const FloatRectangle& rect, ScrollPanelScrollDirection scrollDirection, bool autoResizingEnable, Layout* pPublicPortraitLayout, Layout* pPublicLandscapeLayout)
  63 {
  64         ClearLastResult();
  65
  66         _ScrollPanelImpl* pImpl = null;
  67         _ScrollPanel* pCore = null;
  68
  69         if (pPublicPortraitLayout != null)
  70         {
  71                 _LayoutImpl* pPortraitLayoutImpl = _LayoutImpl::GetInstance(*pPublicPortraitLayout);
  72                 SysTryReturn(NID_UI_CTRL, pPortraitLayoutImpl != null, null, E_INVALID_ARG, "[%s] Portrait layout is invalid object", GetErrorMessage(E_INVALID_ARG));
  73         }
  74         if (pPublicLandscapeLayout != null)
  75         {
  76                 _LayoutImpl* pLandscapeLayoutImpl = _LayoutImpl::GetInstance(*pPublicLandscapeLayout);
  77                 SysTryReturn(NID_UI_CTRL, pLandscapeLayoutImpl != null, null, E_INVALID_ARG, "[%s] Landscape layout is invalid object", GetErrorMessage(E_INVALID_ARG));
  78         }
  79
  80         pCore = _ScrollPanel::CreateScrollPanelN(rect, scrollDirection, autoResizingEnable);
  81         result r = GetLastResult();
  82         SysTryReturn(NID_UI_CTRL, pCore != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
  83
  84         pImpl = new (std::nothrow) _ScrollPanelImpl(pControl, pCore, pPublicPortraitLayout, pPublicLandscapeLayout);
  85         r = CheckConstruction(pCore, pImpl);
  86         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  87
  88         pCore->SetFixingClientBoundsEnabled(!_AppInfo::IsOspCompat());
  89
  90         return pImpl;
  91 }
  92
  93 const _ScrollPanelImpl*
  94 _ScrollPanelImpl::GetInstance(const ScrollPanel& scrollPanel)
  95 {
  96         return static_cast<const _ScrollPanelImpl*>(_ControlImpl::GetInstance(scrollPanel));
  97 }
  98
  99 _ScrollPanelImpl*
 100 _ScrollPanelImpl::GetInstance(ScrollPanel& scrollPanel)
 101 {
 102         return static_cast<_ScrollPanelImpl*>(_ControlImpl::GetInstance(scrollPanel));
 103 }
 104
 105 const char*
 106 _ScrollPanelImpl::GetPublicClassName(void) const
 107 {
 108         return "Tizen::Ui::Controls::ScrollPanel";
 109 }
 110
 111 const ScrollPanel&
 112 _ScrollPanelImpl::GetPublic(void) const
 113 {
 114         return static_cast <const ScrollPanel&>(_ControlImpl::GetPublic());
 115 }
 116
 117 ScrollPanel&
 118 _ScrollPanelImpl::GetPublic(void)
 119 {
 120         return static_cast <ScrollPanel&>(_ControlImpl::GetPublic());
 121 }
 122
 123 const _ScrollPanel&
 124 _ScrollPanelImpl::GetCore(void) const
 125 {
 126         return static_cast <const _ScrollPanel&>(_ControlImpl::GetCore());
 127 }
 128
 129 _ScrollPanel&
 130 _ScrollPanelImpl::GetCore(void)
 131 {
 132         return static_cast <_ScrollPanel&>(_ControlImpl::GetCore());
 133 }
 134
 135 result
 136 _ScrollPanelImpl::OnDetachingFromMainTree(void)
 137 {
 138         __detached = true;
 139
 140         return _PanelImpl::OnDetachingFromMainTree();
 141 }
 142
 143 void
 144 _ScrollPanelImpl::AddScrollEventListener(IScrollEventListener& listener)
 145 {
 146         ClearLastResult();
 147
 148         result r = E_SUCCESS;
 149
 150         if (__pScrollEvent == null)
 151         {
 152                 __pScrollEvent = new (std::nothrow) _ScrollEvent();
 153                 SysTryReturnVoidResult(NID_UI_CTRL, __pScrollEvent != null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient", GetErrorMessage(E_OUT_OF_MEMORY));
 154
 155                 r = __pScrollEvent->Construct(GetPublic());
 156                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 157         }
 158
 159         r = __pScrollEvent->AddListener(listener);
 160         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 161
 162         GetCore().AddScrollEventListener(*this);
 163         r = GetLastResult();
 164         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 165 }
 166
 167 void
 168 _ScrollPanelImpl::AddScrollEventListener(IScrollEventListenerF& listener)
 169 {
 170         ClearLastResult();
 171
 172         result r = E_SUCCESS;
 173
 174         if (__pScrollEvent == null)
 175         {
 176                 __pScrollEvent = new (std::nothrow) _ScrollEvent();
 177                 SysTryReturnVoidResult(NID_UI_CTRL, __pScrollEvent != null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient", GetErrorMessage(E_OUT_OF_MEMORY));
 178
 179                 r = __pScrollEvent->Construct(GetPublic());
 180                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 181         }
 182
 183         r = __pScrollEvent->AddListener(listener);
 184         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 185
 186         GetCore().AddScrollEventListener(*this);
 187         r = GetLastResult();
 188         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 189 }
 190
 191 void
 192 _ScrollPanelImpl::RemoveScrollEventListener(IScrollEventListener& listener)
 193 {
 194         ClearLastResult();
 195
 196         if (__pScrollEvent != null)
 197         {
 198                 result r = __pScrollEvent->RemoveListener(listener);
 199                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 200         }
 201 }
 202
 203 void
 204 _ScrollPanelImpl::RemoveScrollEventListener(IScrollEventListenerF& listener)
 205 {
 206         ClearLastResult();
 207
 208         if (__pScrollEvent != null)
 209         {
 210                 result r = __pScrollEvent->RemoveListener(listener);
 211                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 212         }
 213 }
 214
 215 void
 216 _ScrollPanelImpl::OnScrollEndReached(_Control& source, ScrollEndEvent type)
 217 {
 218         if (__detached)
 219         {
 220                 return;
 221         }
 222
 223         if (__pScrollEvent == null)
 224         {
 225                 return;
 226         }
 227
 228         _ScrollEventArg* pEventArg = _ScrollEventArg::GetScrollEventArgN(GetPublic(), type);
 229         result r = GetLastResult();
 230         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 231
 232         __pScrollEvent->Fire(*pEventArg);
 233
 234         return;
 235 CATCH:
 236         delete pEventArg;
 237 }
 238
 239 void
 240 _ScrollPanelImpl::OnScrollPositionChanged(_Control& source, float scrollPosition)
 241 {
 242         if (__detached)
 243         {
 244                 return;
 245         }
 246
 247         if (__pScrollEvent == null)
 248         {
 249                 return;
 250         }
 251
 252         _ScrollEventArg* pEventArg = _ScrollEventArg::GetScrollEventArgN(GetPublic(), scrollPosition);
 253         result r = GetLastResult();
 254         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 255
 256         __pScrollEvent->Fire(*pEventArg);
 257
 258         return;
 259 CATCH:
 260         delete pEventArg;
 261 }
 262
 263 void
 264 _ScrollPanelImpl::OnScrollStopped(_Control& source)
 265 {
 266         if (__detached)
 267         {
 268                 return;
 269         }
 270
 271         if (__pScrollEvent == null)
 272         {
 273                 return;
 274         }
 275
 276         _ScrollEventArg* pEventArg = _ScrollEventArg::GetScrollEventArgN(GetPublic());
 277         result r = GetLastResult();
 278         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 279
 280         __pScrollEvent->Fire(*pEventArg);
 281
 282         return;
 283 CATCH:
 284         delete pEventArg;
 285 }
 286
 287 float
 288 _ScrollPanelImpl::GetScrollPosition(void) const
 289 {
 290         return GetCore().GetScrollPosition();
 291 }
 292
 293 void
 294 _ScrollPanelImpl::SetScrollPosition(float position, bool withAnimation)
 295 {
 296         GetCore().SetScrollPosition(position, withAnimation);
 297 }
 298
 299 void
 300 _ScrollPanelImpl::ScrollToBottom(void) const
 301 {
 302         const _ScrollPanel& scrollPanel = GetCore();
 303         if (scrollPanel.GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 304         {
 305                 scrollPanel.ScrollToRight();
 306         }
 307         else
 308         {
 309                 scrollPanel.ScrollToBottom();
 310         }
 311 }
 312
 313 void
 314 _ScrollPanelImpl::ScrollToTop(void) const
 315 {
 316         const _ScrollPanel& scrollPanel = GetCore();
 317         if (scrollPanel.GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 318         {
 319                 scrollPanel.ScrollToLeft();
 320         }
 321         else
 322         {
 323                 scrollPanel.ScrollToTop();
 324         }
 325 }
 326
 327 result
 328 _ScrollPanelImpl::CloseOverlayWindow(void)
 329 {
 330         ClearLastResult();
 331
 332         const _Control* pControl = GetCore().GetControlKeypadBinding();
 333
 334         _Edit* pKeypadBindingEdit = dynamic_cast <_Edit*>(const_cast <_Control*>(pControl));
 335
 336         if (pKeypadBindingEdit == null)
 337         {
 338                 return E_SUCCESS;
 339         }
 340
 341         result r = pKeypadBindingEdit->HideKeypad();
 342         SysTryReturn(NID_UI_CTRL, r != E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 343
 344         return E_SUCCESS;
 345 }
 346
 347 FloatRectangle
 348 _ScrollPanelImpl::GetClientAreaBounds(void) const
 349 {
 350         return GetCore().GetScrollAreaBounds();
 351 }
 352
 353 result
 354 _ScrollPanelImpl::SetClientAreaHeight(float height)
 355 {
 356         return GetCore().SetClientAreaHeight(height);
 357 }
 358
 359 result
 360 _ScrollPanelImpl::SetClientAreaWidth(float width)
 361 {
 362         return GetCore().SetClientAreaWidth(width);
 363 }
 364
 365 ScrollPanelScrollDirection
 366 _ScrollPanelImpl::GetScrollDirection(void) const
 367 {
 368         return GetCore().GetScrollDirection();
 369 }
 370
 371 bool
 372 _ScrollPanelImpl::IsScrollAreaAutoResizingEnabled(void) const
 373 {
 374         return GetCore().IsScrollAreaAutoResizingEnabled();
 375 }
 376
 377 void
 378 _ScrollPanelImpl::SetPageScrollEnabled(bool enable)
 379 {
 380         return GetCore().SetPageScrollEnabled(enable);
 381 }
 382
 383 bool
 384 _ScrollPanelImpl::IsPageScrollEnabled(void) const
 385 {
 386         return GetCore().IsPageScrollEnabled();
 387 }
 388
 389 void
 390 _ScrollPanelImpl::SetScrollBarVisible(bool visible)
 391 {
 392         GetCore().SetScrollBarVisible(visible);
 393 }
 394
 395 bool
 396 _ScrollPanelImpl::IsScrollBarVisible(void) const
 397 {
 398         return GetCore().IsScrollBarVisible();
 399 }
 400
 401 void
 402 _ScrollPanelImpl::SetScrollInputMode(ScrollInputMode mode)
 403 {
 404         GetCore().SetScrollInputMode(mode);
 405 }
 406
 407 ScrollInputMode
 408 _ScrollPanelImpl::GetScrollInputMode(void) const
 409 {
 410         return GetCore().GetScrollInputMode();
 411 }
 412
 413 class _ScrollPanelMaker
 414         : public _UiBuilderControlMaker
 415 {
 416 public:
 417         _ScrollPanelMaker(_UiBuilder* pUibuilder)
 418                 : _UiBuilderControlMaker(pUibuilder) {};
 419         virtual ~_ScrollPanelMaker(void) {};
 420
 421         static _UiBuilderControlMaker*
 422         GetInstance(_UiBuilder* pUibuilder)
 423         {
 424                 _ScrollPanelMaker* pScrollPanelMaker = new (std::nothrow) _ScrollPanelMaker(pUibuilder);
 425                 SysTryReturn(NID_UI_CTRL, pScrollPanelMaker != null, null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 426
 427                 return pScrollPanelMaker;
 428         };
 429
 430 protected:
 431         virtual Control*
 432         Make(_UiBuilderControl* pControl)
 433         {
 434                 result r = E_SYSTEM;
 435
 436                 ScrollPanel* pScrollPanel = null;
 437                 FloatRectangle rect;
 438
 439                 _UiBuilderControlLayout* pControlProperty = null;
 440                 _UiBuilderLayoutType layoutType = UIBUILDER_LAYOUT_NONE;
 441
 442                 Color color;
 443
 444                 int opacity = 100;
 445                 ScrollPanelScrollDirection scrollDirection = SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL;
 446                 bool autoResizingEnabled = true;
 447
 448                 Tizen::Base::String elementString;
 449                 GetProperty(pControl, &pControlProperty);
 450                 SysTryReturn(NID_UI_CTRL, pControlProperty != null, null, E_SYSTEM, "[%s] pControlProperty is invalid pointer.", GetErrorMessage(E_SYSTEM));
 451
 452                 if(pControl->GetParentWin().IsEmpty())
 453                 {
 454                         pScrollPanel = static_cast<ScrollPanel*> (GetContainer());
 455                 }
 456                 else
 457                 {
 458                         pScrollPanel = new (std::nothrow) ScrollPanel;
 459                 }
 460                 SysTryReturn(NID_UI_CTRL, pScrollPanel != null, null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 461                 rect = pControlProperty->GetRectF();
 462
 463                 // Construct
 464                 __pLayoutMaker->GetLayoutType(pControlProperty, layoutType);
 465
 466                 // ScrollDirection
 467                 if (pControl->GetElement(L"scrollDirection", elementString) || pControl->GetElement(L"ScrollDirection", elementString))
 468                 {
 469                         if (elementString.Equals(L"SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL", false))
 470                         {
 471                                 scrollDirection = SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL;
 472                         }
 473                         else if (elementString.Equals(L"SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL", false))
 474                         {
 475                                 scrollDirection = SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL;
 476                         }
 477                 }
 478
 479                 // AutoResizingEnabled
 480                 if (pControl->GetElement(L"autoResizingEnabled", elementString) || pControl->GetElement(L"AutoResizingEnabled", elementString))
 481                 {
 482                         if (elementString.Equals(L"false", false))
 483                         {
 484                                 autoResizingEnabled = false;
 485                         }
 486                         else if (elementString.Equals(L"true", false))
 487                         {
 488                                 autoResizingEnabled = true;
 489                         }
 490                 }
 491
 492                 if (layoutType == UIBUILDER_LAYOUT_NONE)
 493                 {
 494                         r = pScrollPanel->Construct(rect, scrollDirection, autoResizingEnabled);
 495                 }
 496                 else
 497                 {
 498                         Layout* pPortraitLayout = null;
 499                         Layout* pLandscapeLayout = null;
 500                         result tempResult = E_SUCCESS;
 501                         tempResult = __pLayoutMaker->GetLayoutN(pControl, pPortraitLayout, pLandscapeLayout);
 502                         if (E_SUCCESS == tempResult)
 503                         {
 504                                 //CONSTRUCT_WITH_LAYOUT_ARG1(pScrollPanel, rect);
 505                                 r = pScrollPanel->Construct(*pPortraitLayout, *pLandscapeLayout, rect, scrollDirection, autoResizingEnabled);
 506                         }
 507                         else
 508                         {
 509                                 r = tempResult;
 510                         }
 511                         delete pPortraitLayout;
 512                         if (pPortraitLayout != pLandscapeLayout)
 513                         {
 514                                 delete pLandscapeLayout;
 515                         }
 516                 }
 517                 if (r != E_SUCCESS)
 518                 {
 519                         delete pScrollPanel;
 520                         return null;
 521                 }
 522
 523                 if (pControl->GetElement("backgroundColorOpacity", elementString) || pControl->GetElement("BGColorOpacity", elementString) || pControl->GetElement("backgroundOpacity", elementString))
 524                 {
 525                         Base::Integer::Parse(elementString, opacity);
 526                 }
 527
 528                 if (pControl->GetElement("backgroundColor", elementString) || pControl->GetElement("BGColor", elementString))
 529                 {
 530                         ConvertStringToColor32(elementString, opacity, color);
 531                         pScrollPanel->SetBackgroundColor(color);
 532                 }
 533                 else
 534                 {
 535                         color = pScrollPanel->GetBackgroundColor();
 536                         color.SetAlpha(ConvertOpacity100to255(opacity));
 537                         pScrollPanel->SetBackgroundColor(color);
 538                 }
 539
 540                 if (!autoResizingEnabled)
 541                 {
 542                         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 543                         {
 544                                 // ClientAreaWidth
 545                                 if (pControl->GetElement(L"clientAreaWidth", elementString) || pControl->GetElement(L"ClientAreaWidth", elementString))
 546                                 {
 547                                         float width = 0.0f;
 548                                         width = _LocalizedNumParser::ToDouble(elementString, "C");
 549                                         pScrollPanel->SetClientAreaWidth(width);
 550                                 }
 551                         }
 552                         else if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL)
 553                         {
 554                                 // ClientAreaHeight
 555                                 if (pControl->GetElement(L"clientAreaHeight", elementString) || pControl->GetElement(L"ClientAreaHeight", elementString))
 556                                 {
 557                                         float height = 0.0f;
 558                                         height = _LocalizedNumParser::ToDouble(elementString, "C");
 559                                         pScrollPanel->SetClientAreaWidth(height);
 560                                 }
 561                         }
 562                 }
 563
 564                 // PageScrollEnabled
 565                 if (pControl->GetElement(L"pageScrollEnabled", elementString) || pControl->GetElement(L"PageScrollEnabled", elementString))
 566                 {
 567                         if (elementString.Equals(L"false", false))
 568                         {
 569                                 pScrollPanel->SetPageScrollEnabled(false);
 570                         }
 571                         else if (elementString.Equals(L"true", false))
 572                         {
 573                                 pScrollPanel->SetPageScrollEnabled(true);
 574                         }
 575                 }
 576
 577                 // ScrollBarVisible
 578                 if (pControl->GetElement(L"scrollBarVisible", elementString) || pControl->GetElement(L"ScrollBarVisible", elementString))
 579                 {
 580                         if (elementString.Equals(L"false", false))
 581                         {
 582                                 pScrollPanel->SetScrollBarVisible(false);
 583                         }
 584                         else if (elementString.Equals(L"true", false))
 585                         {
 586                                 pScrollPanel->SetScrollBarVisible(true);
 587                         }
 588                 }
 589
 590                 // ScrollInputMode
 591                 if (pControl->GetElement(L"scrollInputMode", elementString) || pControl->GetElement(L"ScrollInputMode", elementString))
 592                 {
 593                         if (elementString.Equals(L"SCROLL_INPUT_MODE_ALLOW_ANY_DIRECTION", false))
 594                         {
 595                                 pScrollPanel->SetScrollInputMode(SCROLL_INPUT_MODE_ALLOW_ANY_DIRECTION);
 596                         }
 597                         else if (elementString.Equals(L"SCROLL_INPUT_MODE_RESTRICT_TO_INITIAL_DIRECTION", false))
 598                         {
 599                                 pScrollPanel->SetScrollInputMode(SCROLL_INPUT_MODE_RESTRICT_TO_INITIAL_DIRECTION);
 600                         }
 601                 }
 602
 603                 return pScrollPanel;
 604         }
 605
 606 private:
 607 };      // _ScrollPanelMaker
 608
 609 _ScrollPanelRegister::_ScrollPanelRegister(void)
 610 {
 611         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 612         pUiBuilderControlTableManager->RegisterControl(L"ScrollPanel", _ScrollPanelMaker::GetInstance);
 613 }
 614 _ScrollPanelRegister::~_ScrollPanelRegister(void)
 615 {
 616         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 617         pUiBuilderControlTableManager->UnregisterControl(L"ScrollPanel");
 618 }
 619 static _ScrollPanelRegister ScrollPanelRegisterToUiBuilder;
 620 }}} // Tizen::Ui::Controls
 621