src/ui/controls/FUiCtrl_TabBarImpl.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 #include "FUiCtrl_TabBarImpl.h"
  19 #include "FUiCtrl_TabBarItem.h"
  20 #include "FUi_ResourceSizeInfo.h"
  21 #include "FUi_ResourceManager.h"
  22
  23 //UiBuilder
  24 #include <FUiCtrlTabBarItem.h>
  25 #include "FUi_UiBuilder.h"
  26
  27 using namespace Tizen::Ui;
  28 using namespace Tizen::Graphics;
  29 using namespace Tizen::Base::Runtime;
  30
  31 namespace Tizen { namespace Ui { namespace Controls
  32 {
  33
  34 Tizen::Graphics::Dimension
  35 _TabBarImpl::TabBarSizeInfo::GetDefaultMinimumSize(_ControlOrientation orientation) const
  36 {
  37         result r = E_SUCCESS;
  38
  39         Tizen::Graphics::Dimension dimension(0, 0);
  40
  41         GET_SHAPE_CONFIG(TABBAR::MIN_WIDTH, orientation, dimension.width);
  42
  43         SysTryReturn(NID_UI, r == E_SUCCESS, dimension, r, "[%s] System Error.", GetErrorMessage(r));
  44         return dimension;
  45 }
  46
  47 _TabBarImpl*
  48 _TabBarImpl::GetInstance(TabBar& tabBar)
  49 {
  50         return static_cast<_TabBarImpl*> (tabBar._pControlImpl);
  51 }
  52
  53 const _TabBarImpl*
  54 _TabBarImpl::GetInstance(const TabBar& tabBar)
  55 {
  56         return static_cast<const _TabBarImpl*> (tabBar._pControlImpl);
  57 }
  58
  59 _TabBarImpl::_TabBarImpl(TabBar* pTabBar, _TabBar* pCore)
  60         : _ControlImpl(pTabBar, pCore)
  61         , __pPublicActionEvent(null)
  62 {
  63 }
  64
  65 _TabBarImpl::~_TabBarImpl(void)
  66 {
  67         if (__pPublicActionEvent)
  68         {
  69                 delete __pPublicActionEvent;
  70                 __pPublicActionEvent = null;
  71         }
  72 }
  73
  74 _TabBarImpl*
  75 _TabBarImpl::CreateTabBarImplN(TabBar* pTabBar, const Tizen::Graphics::Rectangle& bounds)
  76 {
  77         ClearLastResult();
  78         SysTryReturn(NID_UI_CTRL, bounds.width >= 0 && bounds.height >= 0, null, E_INVALID_ARG, "[E_INVALID_ARG] The specified width is smaller than minimum size.");
  79
  80         int minWidth = 0;
  81         int maxWidth = 0;
  82         int height = 0;
  83         GET_SHAPE_CONFIG(TABBAR::MIN_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, minWidth);
  84         GET_SHAPE_CONFIG(TABBAR::MAX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, maxWidth);
  85         GET_SHAPE_CONFIG(TABBAR::HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, height);
  86
  87         result r = E_SUCCESS;
  88         //r = GET_SIZE_INFO(TabBar).CheckInitialSizeValid(Dimension(bounds.width, bounds.height), _CONTROL_ORIENTATION_PORTRAIT);
  89         //SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_INVALID_ARG, "[E_INVALID_ARG] The specified width is smaller than minimum size.");
  90
  91         _TabBar* pCore = _TabBar::CreateTabBarN();
  92         SysTryReturn(NID_UI_CTRL, pCore != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] _TabBar is not constructed.");
  93
  94         _TabBarImpl* pImpl = new (std::nothrow) _TabBarImpl(pTabBar, pCore);
  95         r = CheckConstruction(pCore, pImpl);
  96         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  97
  98         r = pImpl->SetBounds(Rectangle(bounds.x, bounds.y, bounds.width, height));
  99         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] SetBounds is failed.", GetErrorMessage(r));
 100
 101         r = pImpl->SetMinimumSize(Dimension(minWidth, height));
 102         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] SetMinimumSize is failed.", GetErrorMessage(r));
 103
 104         r = pImpl->SetMaximumSize(Dimension(maxWidth, height));
 105         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] SetMaximumSize is failed.", GetErrorMessage(r));
 106
 107         return pImpl;
 108
 109 CATCH:
 110         delete pImpl;
 111
 112         return null;
 113 }
 114
 115 result
 116 _TabBarImpl::AddItem(const Tizen::Base::String& text, int actionId)
 117 {
 118         int itemMaxCnt = 0;
 119         GET_SHAPE_CONFIG(TABBAR::ITEM_COUNT_MAX, GetCore().GetOrientation(), itemMaxCnt);
 120         SysTryReturn(NID_UI_CTRL, GetCore().GetItemCount() < itemMaxCnt, E_MAX_EXCEEDED, E_MAX_EXCEEDED, "[E_MAX_EXCEEDED] The item is not added more than %d.", itemMaxCnt);
 121
 122         return GetCore().AddItem(text, actionId);
 123 }
 124
 125 result
 126 _TabBarImpl::InsertItemAt(int index, const Tizen::Base::String& text, int actionId)
 127 {
 128         int itemMaxCnt = 0;
 129         GET_SHAPE_CONFIG(TABBAR::ITEM_COUNT_MAX, GetCore().GetOrientation(), itemMaxCnt);
 130         SysTryReturn(NID_UI_CTRL, GetCore().GetItemCount() < itemMaxCnt, E_MAX_EXCEEDED, E_MAX_EXCEEDED, "[E_MAX_EXCEEDED] The item is not added more than %d.", itemMaxCnt);
 131         SysTryReturn(NID_UI_CTRL, index >= 0 && index <= GetCore().GetItemCount(), E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] This index(%d) is invalid.", index);
 132
 133         return GetCore().InsertItemAt(index, text, actionId);
 134 }
 135
 136 Tizen::Graphics::Color
 137 _TabBarImpl::GetColor(void) const
 138 {
 139         return GetCore().GetColor();
 140 }
 141
 142 int
 143 _TabBarImpl::GetItemCount(void) const
 144 {
 145         return GetCore().GetItemCount();
 146 }
 147
 148 Tizen::Graphics::Color
 149 _TabBarImpl::GetSelectedItemColor(void) const
 150 {
 151         return GetCore().GetItemColor(ITEM_STATUS_SELECTED);
 152 }
 153
 154 Tizen::Graphics::Color
 155 _TabBarImpl::GetItemTextColor(TabBarItemStatus status) const
 156 {
 157         if (status == TAB_BAR_ITEM_STATUS_NORMAL)
 158         {
 159                 return GetCore().GetItemTextColor(ITEM_STATUS_NORMAL);
 160         }
 161         else if (status == TAB_BAR_ITEM_STATUS_SELECTED)
 162         {
 163                 return GetCore().GetItemTextColor(ITEM_STATUS_SELECTED);
 164         }
 165
 166         return Tizen::Graphics::Color(0);
 167 }
 168
 169 int
 170 _TabBarImpl::GetSelectedItemIndex(void) const
 171 {
 172         return GetCore().GetSelectedItemIndex();
 173 }
 174
 175 result
 176 _TabBarImpl::RemoveItemAt(int index)
 177 {
 178         SysTryReturn(NID_UI_CTRL, index >= 0 && index < GetCore().GetItemCount(), E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] This index(%d) is invalid.", index);
 179
 180         return GetCore().RemoveItemAt(index);
 181 }
 182
 183 result
 184 _TabBarImpl::RemoveAllItems(void)
 185 {
 186         return GetCore().RemoveAllItems();
 187 }
 188
 189 result
 190 _TabBarImpl::SetColor(const Tizen::Graphics::Color& color)
 191 {
 192         return GetCore().SetColor(color);
 193 }
 194
 195 result
 196 _TabBarImpl::SetItemAt(int index, const Tizen::Base::String& text, int actionId)
 197 {
 198         SysTryReturn(NID_UI_CTRL, index >= 0 && index < GetCore().GetItemCount(), E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] This index(%d) is invalid.", index);
 199
 200         return GetCore().SetItemAt(index, text, actionId);
 201 }
 202
 203 result
 204 _TabBarImpl::SetItemSelected(int index)
 205 {
 206         SysTryReturn(NID_UI_CTRL, index >= 0 && index < GetCore().GetItemCount(), E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] This index(%d) is invalid.", index);
 207
 208         return GetCore().SetItemSelected(index);
 209 }
 210
 211 result
 212 _TabBarImpl::SetItemTextColor(TabBarItemStatus status, const Tizen::Graphics::Color& color)
 213 {
 214         if (status == TAB_BAR_ITEM_STATUS_NORMAL)
 215         {
 216                 GetCore().SetItemTextColor(ITEM_STATUS_NORMAL, color);
 217         }
 218         else if (status == TAB_BAR_ITEM_STATUS_SELECTED)
 219         {
 220                 GetCore().SetItemTextColor(ITEM_STATUS_SELECTED, color);
 221         }
 222
 223         return E_SUCCESS;
 224 }
 225
 226 result
 227 _TabBarImpl::SetSelectedItemColor(const Tizen::Graphics::Color& color)
 228 {
 229         return GetCore().SetItemColor(ITEM_STATUS_SELECTED, color);
 230 }
 231
 232 result
 233 _TabBarImpl::SetWidth(int width)
 234 {
 235         return GetCore().SetWidth(width);
 236 }
 237
 238 void
 239 _TabBarImpl::AddActionEventListener(Tizen::Ui::IActionEventListener& listener)
 240 {
 241         ClearLastResult();
 242
 243         if (__pPublicActionEvent == null)
 244         {
 245                 __pPublicActionEvent = _PublicActionEvent::CreateInstanceN(GetPublic());
 246
 247                 if (__pPublicActionEvent == null || IsFailed(GetLastResult()))
 248                 {
 249                         SysLogException(NID_UI_CTRL, E_INVALID_STATE, "[E_INVALID_STATE] System error occurred.");
 250                         SetLastResult(E_INVALID_STATE);
 251                         delete __pPublicActionEvent;
 252                         return;
 253                 }
 254         }
 255
 256         SetLastResult(E_SUCCESS);
 257
 258         __pPublicActionEvent->AddListener(listener);
 259
 260         GetCore().AddActionEventListener(*this);
 261 }
 262
 263 void
 264 _TabBarImpl::RemoveActionEventListener(Tizen::Ui::IActionEventListener& listener)
 265 {
 266         SysTryReturnVoidResult(NID_UI_CTRL, __pPublicActionEvent, E_INVALID_STATE, "[E_INVALID_STATE] This instance isn't constructed.")
 267
 268         // Todo : check fail case of RemoveListener
 269         __pPublicActionEvent->RemoveListener(listener);
 270
 271         GetCore().RemoveActionEventListener(*this);
 272 }
 273
 274 TabBar&
 275 _TabBarImpl::GetPublic(void)
 276 {
 277         return static_cast <TabBar&>(_ControlImpl::GetPublic());
 278 }
 279
 280 const TabBar&
 281 _TabBarImpl::GetPublic(void) const
 282 {
 283         return static_cast <const TabBar&>(_ControlImpl::GetPublic());
 284 }
 285
 286 const char*
 287 _TabBarImpl::GetPublicClassName(void) const
 288 {
 289         return "Tizen::Ui::Controls::TabBar";
 290 }
 291
 292 const _TabBar&
 293 _TabBarImpl::GetCore(void) const
 294 {
 295         return static_cast <const _TabBar&>(_ControlImpl::GetCore());
 296 }
 297
 298 _TabBar&
 299 _TabBarImpl::GetCore(void)
 300 {
 301         return static_cast <_TabBar&>(_ControlImpl::GetCore());
 302 }
 303
 304 void
 305 _TabBarImpl::OnActionPerformed(const Tizen::Ui::_Control& source, int actionId)
 306 {
 307         if (__pPublicActionEvent != null)
 308         {
 309                 __pPublicActionEvent->Fire(*_PublicActionEvent::CreateActionEventArgN(actionId));
 310         }
 311 }
 312
 313 class _TabBarMaker
 314         : public _UiBuilderControlMaker
 315 {
 316 public:
 317         _TabBarMaker(_UiBuilder* uibuilder)
 318                 : _UiBuilderControlMaker(uibuilder){};
 319         virtual ~_TabBarMaker(){};
 320
 321         static _UiBuilderControlMaker*
 322         GetInstance(_UiBuilder* uibuilder)
 323         {
 324                 _TabBarMaker* pTabBarMaker = new (std::nothrow) _TabBarMaker(uibuilder);
 325                 SysTryReturn(NID_UI_CTRL, pTabBarMaker != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 326                 return pTabBarMaker;
 327         };
 328 protected:
 329         virtual Tizen::Ui::Control*
 330         Make(_UiBuilderControl* pControl)
 331         {
 332                 result r = E_SUCCESS;
 333                 _UiBuilderControlLayout* pControlProperty = null;
 334                 TabBar* pTabBar = null;
 335                 Tizen::Graphics::Rectangle rect;
 336                 Tizen::Base::String elementString;
 337                 int opacity = 0;
 338                 Color color;
 339
 340                 GetProperty(pControl, &pControlProperty);
 341                 if (pControlProperty == null)
 342                 {
 343                         return null;
 344                 }
 345
 346                 rect = pControlProperty->GetRect();
 347
 348                 //Construct
 349                 pTabBar = new (std::nothrow) TabBar();
 350                 SysTryReturn(NID_UI_CTRL, pTabBar != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 351
 352                 r = pTabBar->Construct(rect.x, rect.y, rect.width);
 353                 if (r != E_SUCCESS)
 354                 {
 355                         delete pTabBar;
 356                         return null;
 357                 }
 358                 //tabBar item..
 359                 rect = pTabBar->GetBounds();
 360
 361                 if (pControl->GetElement(L"BGColorOpacity", elementString) == true)
 362                 {
 363                         Base::Integer::Parse(elementString, opacity);
 364                 }
 365
 366                 if (pControl->GetElement(L"BGColor", elementString) == true)
 367                 {
 368                         ConvertStringToColor32(elementString, opacity, color);
 369                         pTabBar->SetColor(color);
 370                 }
 371
 372                 if (pControl->GetElement(L"backgroundColorOpacity", elementString) == true)
 373                 {
 374                         Base::Integer::Parse(elementString, opacity);
 375                 }
 376
 377                 if (pControl->GetElement(L"backgroundColor", elementString) == true)
 378                 {
 379                         ConvertStringToColor32(elementString, opacity, color);
 380                         pTabBar->SetColor(color);
 381                 }
 382
 383                 if (pControl->GetElement(L"normalItemTextColor", elementString) == true)
 384                 {
 385                         ConvertStringToColor(elementString, color);
 386                         pTabBar->SetItemTextColor(TAB_BAR_ITEM_STATUS_NORMAL, color);
 387                 }
 388
 389                 if (pControl->GetElement(L"selectedItemTextColor", elementString) == true)
 390                 {
 391                         ConvertStringToColor(elementString, color);
 392                         pTabBar->SetItemTextColor(TAB_BAR_ITEM_STATUS_SELECTED, color);
 393                 }
 394
 395                 if (pControl->GetElement(L"selectedItemColor", elementString) == true)
 396                 {
 397                         ConvertStringToColor(elementString, color);
 398                         pTabBar->SetSelectedItemColor(color);
 399                 }
 400
 401                 int itemCnt = pControl->GetItemCount();
 402                 for (int i = 0; i < itemCnt; i++)
 403                 {
 404                         TabBarItem tabBarItem;
 405                         int actionId = 0;
 406                         if (pControl->GetItemElement(i, "actionId", elementString))
 407                         {
 408                                 Base::Integer::Parse(elementString, actionId);
 409                         }
 410
 411                         if (pControl->GetItemElement(i, "text", elementString))
 412                         {
 413                                 tabBarItem.Construct(elementString, actionId);
 414                         }
 415                         pTabBar->AddItem(tabBarItem);
 416                 }
 417
 418                 rect = (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT))->GetRect();
 419                 (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT))->SetRect(rect.x, rect.y, rect.width, rect.height);
 420
 421                 rect = (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE))->GetRect();
 422                 (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE))->SetRect(rect.x, rect.y, rect.width, rect.height);
 423
 424                 /*r = AddControl(pControl, pTabBar);
 425                 if (r != E_SUCCESS)
 426                 {
 427                         delete pTabBar;
 428                         return null;
 429                 }
 430 */
 431                 return pTabBar;
 432         }
 433 };
 434
 435 _TabBarRegister::_TabBarRegister()
 436 {
 437         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 438         pUiBuilderControlTableManager->RegisterControl(L"TabBar", _TabBarMaker::GetInstance);
 439 }
 440 _TabBarRegister::~_TabBarRegister()
 441 {
 442         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 443         pUiBuilderControlTableManager->UnregisterControl(L"TabBar");
 444 }
 445 static _TabBarRegister TabBarRegisterToUiBuilder;
 446 }}} // Tizen::Ui::Controls