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