src/ui/controls/FUiCtrl_TabBar.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  * @file                FUiCtrl_TabBar.cpp
  19  * @brief               This is the implementation file for the _TabBar class.
  20  */
  21
  22
  23 #include <FBaseErrorDefine.h>
  24 #include <FBaseSysLog.h>
  25 #include "FUi_UiTouchEvent.h"
  26 #include "FUi_ResourceManager.h"
  27 #include "FUi_AccessibilityContainer.h"
  28 #include "FUi_AccessibilityElement.h"
  29 #include "FUiCtrl_TabBar.h"
  30
  31 using namespace Tizen::Base;
  32 using namespace Tizen::Graphics;
  33 using namespace Tizen::Base::Runtime;
  34
  35 namespace Tizen { namespace Ui { namespace Controls
  36 {
  37
  38 IMPLEMENT_PROPERTY(_TabBar);
  39
  40 _TabBar::_TabBar()
  41         : __pTabBarPresenter(null)
  42         , __pActionEvent(null)
  43 {
  44         GET_COLOR_CONFIG(TABBAR::BG_NORMAL, __color);
  45
  46         GET_COLOR_CONFIG(TABBAR::ITEM_BG_NORMAL, __itemColor[ITEM_STATUS_NORMAL]);
  47         GET_COLOR_CONFIG(TABBAR::ITEM_BG_PRESSED, __itemColor[ITEM_STATUS_SELECTED]);
  48         GET_COLOR_CONFIG(TABBAR::ITEM_BG_HIGHLIGHTED, __itemColor[ITEM_STATUS_HIGHLIGHTED]);
  49
  50         GET_COLOR_CONFIG(TABBAR::ITEM_TEXT_NORMAL, __itemTextColor[ITEM_STATUS_NORMAL]);
  51         GET_COLOR_CONFIG(TABBAR::ITEM_TEXT_PRESSED, __itemTextColor[ITEM_STATUS_SELECTED]);
  52         GET_COLOR_CONFIG(TABBAR::ITEM_TEXT_HIGHLIGHTED, __itemTextColor[ITEM_STATUS_HIGHLIGHTED]);
  53 }
  54
  55 _TabBar::~_TabBar(void)
  56 {
  57         delete __pTabBarPresenter;
  58         __pTabBarPresenter = null;
  59
  60         if (__pActionEvent)
  61         {
  62                 delete __pActionEvent;
  63                 __pActionEvent = null;
  64         }
  65
  66         RemoveAllAccessibilityElement();
  67 }
  68
  69 _TabBar*
  70 _TabBar::CreateTabBarN(void)
  71 {
  72         _TabBar* pTabBar = new (std::nothrow) _TabBar();
  73         SysTryReturn(NID_UI_CTRL, pTabBar != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  74
  75         result r = pTabBar->Initialize();
  76         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Failed to Initialize.", GetErrorMessage(r));
  77
  78         pTabBar->AcquireHandle();
  79         pTabBar->SetTouchMoveAllowance(TOUCH_MOVE_ALLOWANCE_NORMAL);
  80
  81         if (pTabBar->GetAccessibilityContainer() != null)
  82         {
  83                 pTabBar->GetAccessibilityContainer()->Activate(true);
  84         }
  85
  86         return pTabBar;
  87
  88 CATCH:
  89         delete pTabBar;
  90
  91         return null;
  92 }
  93
  94 result
  95 _TabBar::Initialize(void)
  96 {
  97         result r;
  98
  99         _TabBarPresenter* pTabBarPresenter = new (std::nothrow) _TabBarPresenter(*this);
 100         SysTryReturn(NID_UI_CTRL, pTabBarPresenter != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 101
 102         r = pTabBarPresenter->Construct();
 103         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 104
 105         r = SetPresenter(*pTabBarPresenter);
 106         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 107
 108         r = pTabBarPresenter->InitializeFont();
 109         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 110
 111         return r;
 112
 113 CATCH:
 114         __pTabBarPresenter = null;
 115
 116         delete pTabBarPresenter;
 117
 118         return r;
 119 }
 120
 121 result
 122 _TabBar::SetPresenter(const _TabBarPresenter& tabBarPresenter)
 123 {
 124         __pTabBarPresenter = const_cast<_TabBarPresenter*>(&tabBarPresenter);
 125
 126         return E_SUCCESS;
 127 }
 128
 129 result
 130 _TabBar::AddItem(const Tizen::Base::String& text, int actionId)
 131 {
 132         return __pTabBarPresenter->AddItem(text, actionId);
 133 }
 134
 135 result
 136 _TabBar::InsertItemAt(int index, const Tizen::Base::String& text, int actionId)
 137 {
 138         return __pTabBarPresenter->InsertItemAt(index, text, actionId);
 139 }
 140
 141 result
 142 _TabBar::SetItemAt(int index, const Tizen::Base::String& text, int actionId)
 143 {
 144         return __pTabBarPresenter->SetItemAt(index, text, actionId);
 145 }
 146
 147 result
 148 _TabBar::RemoveItemAt(int index)
 149 {
 150         return __pTabBarPresenter->RemoveItemAt(index);
 151 }
 152
 153 result
 154 _TabBar::RemoveAllItems(void)
 155 {
 156         return __pTabBarPresenter->RemoveAllItems();
 157 }
 158
 159 result
 160 _TabBar::SetPropertyColor(const Variant& color)
 161 {
 162         result r = E_SUCCESS;
 163
 164         r = __pTabBarPresenter->SetReplacementColor(color.ToColor());
 165
 166         if (r == E_SUCCESS)
 167         {
 168                 __color = color.ToColor();
 169         }
 170
 171         return r;
 172 }
 173
 174 Variant
 175 _TabBar::GetPropertyColor(void) const
 176 {
 177         return Tizen::Ui::Variant(__color);
 178 }
 179
 180 result
 181 _TabBar::SetColor(Tizen::Graphics::Color color)
 182 {
 183         return SetProperty("color", Variant(color));
 184 }
 185
 186 Tizen::Graphics::Color
 187 _TabBar::GetColor(void) const
 188 {
 189         Variant color = GetProperty("color");
 190
 191         return color.ToColor();
 192 }
 193
 194 result
 195 _TabBar::SetPropertyNormalItemColor(const Variant& color)
 196 {
 197         result r = E_SUCCESS;
 198
 199         r = __pTabBarPresenter->SetItemReplacementColor(ITEM_STATUS_NORMAL, color.ToColor());
 200         if (r == E_SUCCESS)
 201         {
 202                 __itemColor[ITEM_STATUS_NORMAL] = color.ToColor();
 203         }
 204
 205         return r;
 206 }
 207
 208 Variant
 209 _TabBar::GetPropertyNormalItemColor(void) const
 210 {
 211         return Tizen::Ui::Variant(__itemColor[ITEM_STATUS_NORMAL]);
 212 }
 213
 214 result
 215 _TabBar::SetPropertySelectedItemColor(const Variant& color)
 216 {
 217         result r = E_SUCCESS;
 218
 219         r = __pTabBarPresenter->SetItemReplacementColor(ITEM_STATUS_SELECTED, color.ToColor());
 220         if (r == E_SUCCESS)
 221         {
 222                 __itemColor[ITEM_STATUS_SELECTED] = color.ToColor();
 223         }
 224
 225         return r;
 226 }
 227
 228 Variant
 229 _TabBar::GetPropertySelectedItemColor(void) const
 230 {
 231         return Tizen::Ui::Variant(__itemColor[ITEM_STATUS_SELECTED]);
 232 }
 233
 234 result
 235 _TabBar::SetPropertyHighlightedItemColor(const Variant& color)
 236 {
 237         result r = E_SUCCESS;
 238
 239         r = __pTabBarPresenter->SetItemReplacementColor(ITEM_STATUS_HIGHLIGHTED, color.ToColor());
 240         if (r == E_SUCCESS)
 241         {
 242                 __itemColor[ITEM_STATUS_HIGHLIGHTED] = color.ToColor();
 243         }
 244
 245         return r;
 246 }
 247
 248 Variant
 249 _TabBar::GetPropertyHighlightedItemColor(void) const
 250 {
 251         return Tizen::Ui::Variant(__itemColor[ITEM_STATUS_HIGHLIGHTED]);
 252 }
 253
 254 result
 255 _TabBar::SetItemColor(_TabBarItemStatus itemStatus, Tizen::Graphics::Color color)
 256 {
 257         result r = E_SUCCESS;
 258
 259         if (itemStatus == ITEM_STATUS_NORMAL)
 260         {
 261                 r = SetProperty("normalItemColor", Variant(color));
 262         }
 263         else if (itemStatus == ITEM_STATUS_SELECTED)
 264         {
 265                 r = SetProperty("selectedItemColor", Variant(color));
 266         }
 267         else
 268         {
 269                 r = SetProperty("highlightedItemColor", Variant(color));
 270         }
 271
 272         return r;
 273 }
 274
 275 Tizen::Graphics::Color
 276 _TabBar::GetItemColor(_TabBarItemStatus itemStatus) const
 277 {
 278         Color itemColor;
 279
 280         if (itemStatus == ITEM_STATUS_NORMAL)
 281         {
 282                 Variant color = GetProperty("normalItemColor");
 283                 itemColor = color.ToColor();
 284         }
 285         else if (itemStatus == ITEM_STATUS_SELECTED)
 286         {
 287                 Variant color = GetProperty("selectedItemColor");
 288                 itemColor = color.ToColor();
 289         }
 290         else
 291         {
 292                 Variant color = GetProperty("highlightedItemColor");
 293                 itemColor = color.ToColor();
 294         }
 295
 296         return itemColor;
 297 }
 298
 299 result
 300 _TabBar::SetPropertyNormalItemTextColor(const Variant & color)
 301 {
 302         __itemTextColor[ITEM_STATUS_NORMAL] = color.ToColor();
 303
 304         return E_SUCCESS;
 305 }
 306
 307 Variant
 308 _TabBar::GetPropertyNormalItemTextColor(void) const
 309 {
 310         return Tizen::Ui::Variant(__itemTextColor[ITEM_STATUS_NORMAL]);
 311 }
 312
 313 result
 314 _TabBar::SetPropertySelectedItemTextColor(const Variant & color)
 315 {
 316         __itemTextColor[ITEM_STATUS_SELECTED] = color.ToColor();
 317
 318         return E_SUCCESS;
 319 }
 320
 321 Variant
 322 _TabBar::GetPropertySelectedItemTextColor(void) const
 323 {
 324         return Tizen::Ui::Variant(__itemTextColor[ITEM_STATUS_SELECTED]);
 325 }
 326
 327 result
 328 _TabBar::SetPropertyHighlightedItemTextColor(const Variant & color)
 329 {
 330         __itemTextColor[ITEM_STATUS_HIGHLIGHTED] = color.ToColor();
 331
 332         return E_SUCCESS;
 333 }
 334
 335 Variant
 336 _TabBar::GetPropertyHighlightedItemTextColor(void) const
 337 {
 338         return Tizen::Ui::Variant(__itemTextColor[ITEM_STATUS_HIGHLIGHTED]);
 339 }
 340
 341
 342 void
 343 _TabBar::SetItemTextColor(_TabBarItemStatus status, Tizen::Graphics::Color color)
 344 {
 345         Color itemTextColor;
 346         result r = E_SUCCESS;
 347
 348         if (status == ITEM_STATUS_NORMAL)
 349         {
 350                 r = SetProperty("normalItemTextColor", Variant(color));
 351         }
 352         else if (status == ITEM_STATUS_SELECTED)
 353         {
 354                 r = SetProperty("selectedItemTextColor", Variant(color));
 355         }
 356         else
 357         {
 358                 r = SetProperty("highlightedItemTextColor", Variant(color));
 359         }
 360
 361         if (r != E_SUCCESS)
 362         {
 363                 SysLogException(NID_UI_CTRL, E_INVALID_STATE, "Color is invalid.");
 364         }
 365
 366 }
 367
 368 Tizen::Graphics::Color
 369 _TabBar::GetItemTextColor(_TabBarItemStatus status) const
 370 {
 371         Color itemTextColor;
 372
 373         if (status == ITEM_STATUS_NORMAL)
 374         {
 375                 Variant color = GetProperty("normalItemTextColor");
 376                 itemTextColor = color.ToColor();
 377         }
 378         else if (status == ITEM_STATUS_SELECTED)
 379         {
 380                 Variant color = GetProperty("selectedItemTextColor");
 381                 itemTextColor = color.ToColor();
 382         }
 383         else
 384         {
 385                 Variant color = GetProperty("highlightedItemTextColor");
 386                 itemTextColor = color.ToColor();
 387         }
 388
 389         return itemTextColor;
 390 }
 391
 392 result
 393 _TabBar::SetItemSelected(int index)
 394 {
 395         return __pTabBarPresenter->SetItemSelected(index);
 396 }
 397
 398 int
 399 _TabBar::GetSelectedItemIndex(void) const
 400 {
 401         return __pTabBarPresenter->GetSelectedItemIndex();
 402 }
 403
 404 int
 405 _TabBar::GetItemCount(void) const
 406 {
 407         return __pTabBarPresenter->GetItemCount();
 408 }
 409
 410 _TabBarItem*
 411 _TabBar::GetItemFromPosition(const Tizen::Graphics::Point& position) const
 412 {
 413         return __pTabBarPresenter->GetItemFromPosition(position);
 414 }
 415
 416 result
 417 _TabBar::SetTopDrawnItemIndex(int index)
 418 {
 419         return __pTabBarPresenter->SetTopDrawnItemIndex(index);
 420 }
 421
 422 result
 423 _TabBar::SetWidth(int width)
 424 {
 425         result r;
 426         int height = 0;
 427
 428         GET_SHAPE_CONFIG(TABBAR::HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, height);
 429         r = SetSize(Dimension(width, height));
 430         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 431         __pTabBarPresenter->InitItemPositionX();
 432
 433         return r;
 434 }
 435
 436 void
 437 _TabBar::AddActionEventListener(const Tizen::Ui::Controls::_IActionEventListener& listener)
 438 {
 439         ClearLastResult();
 440
 441         if (__pActionEvent == null)
 442         {
 443                 __pActionEvent = _ActionEvent::CreateInstanceN(*this);
 444
 445                 if (__pActionEvent == null || IsFailed(GetLastResult()))
 446                 {
 447                         SysLog(NID_UI_CTRL, "[E_INVALID_STATE] System error occured.");
 448                         SetLastResult(E_INVALID_STATE);
 449                         delete __pActionEvent;
 450                         return;
 451                 }
 452         }
 453
 454         SetLastResult(E_SUCCESS);
 455         __pActionEvent->AddListener(listener);
 456 }
 457
 458 void
 459 _TabBar::RemoveActionEventListener(const Tizen::Ui::Controls::_IActionEventListener& listener)
 460 {
 461         SysTryReturnVoidResult(NID_UI_CTRL, __pActionEvent != null, E_INVALID_STATE, "[E_INVALID_STATE] This instance isn't constructed.")
 462         // Todo : check fail case of RemoveListener
 463         __pActionEvent->RemoveListener(listener);
 464 }
 465
 466 bool
 467 _TabBar::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 468 {
 469         return __pTabBarPresenter->OnTouchPressed(source, touchinfo);
 470 }
 471
 472 bool
 473 _TabBar::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 474 {
 475         bool eventFire = __pTabBarPresenter->OnTouchReleased(source, touchinfo);
 476         if (eventFire == true)
 477         {
 478                 int index = __pTabBarPresenter->GetItemIndexFromPosition(touchinfo.GetCurrentPosition());
 479                 _TabBarItem* pItem = __pTabBarPresenter->GetItemAt(index);
 480                 if (pItem != null)
 481                 {
 482                         if (__pActionEvent)
 483                         {
 484                                 IEventArg* pEventArg = _ActionEvent::CreateActionEventArgN(pItem->GetActionId());
 485                                 SysTryReturn(NID_UI_CTRL, pEventArg != null, E_INVALID_STATE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 486
 487                                 __pActionEvent->Fire(*pEventArg);
 488                         }
 489                 }
 490         }
 491
 492         return true;
 493 }
 494
 495 bool
 496 _TabBar::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 497 {
 498         return __pTabBarPresenter->OnTouchMoved(source, touchinfo);
 499 }
 500
 501 void
 502 _TabBar::OnFontChanged(Font * pFont)
 503 {
 504         __pTabBarPresenter->OnFontChanged(pFont);
 505 }
 506
 507 void
 508 _TabBar::OnFontInfoRequested(unsigned long& style, int& size)
 509 {
 510         __pTabBarPresenter->OnFontInfoRequested(style, size);
 511 }
 512
 513 void
 514 _TabBar::OnDraw(void)
 515 {
 516         __pTabBarPresenter->Draw();
 517         _Control::Show();
 518         SetAllAccessibilityElement();
 519 }
 520
 521 void
 522 _TabBar::OnBoundsChanged(void)
 523 {
 524         __pTabBarPresenter->OnBoundsChanged();
 525 }
 526
 527 _AccessibilityElement*
 528 _TabBar::GetAccessibilityElement(const int mainIndex) const
 529 {
 530         _AccessibilityElement* pElement = null;
 531         result r = __accessibilityElements.GetAt(mainIndex, pElement);
 532         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Failed at AccessibiltyElement.", GetErrorMessage(r));
 533
 534         return pElement;
 535
 536 CATCH:
 537         delete pElement;
 538
 539         return null;
 540 }
 541
 542 void
 543 _TabBar::AddAccessibilityElement(const _AccessibilityElement& element)
 544 {
 545         __accessibilityElements.Add(const_cast<_AccessibilityElement*>(&element));
 546 }
 547
 548 void
 549 _TabBar::SetAllAccessibilityElement(void)
 550 {
 551         RemoveAllAccessibilityElement();
 552         __pTabBarPresenter->SetAllAccessibilityElement();
 553 }
 554
 555 void
 556 _TabBar::RemoveAllAccessibilityElement(void)
 557 {
 558         while (__accessibilityElements.GetCount() > 0)
 559         {
 560                 _AccessibilityElement* pElement = null;
 561                 if (__accessibilityElements.GetAt(0, pElement) == E_SUCCESS)
 562                 {
 563                         pElement->GetParent()->RemoveElement(*pElement);
 564                         __accessibilityElements.RemoveAt(0);
 565                 }
 566         }
 567 }
 568
 569 }}} // Tizen::Ui::Controls