src/ui/controls/FUiCtrl_OptionMenuModel.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_OptionMenuModel.cpp
  20  * @brief               This is the implementation file for the _OptionMenuModel class.
  21  */
  22
  23 #include <FBaseErrorDefine.h>
  24 #include <FBaseSysLog.h>
  25 #include "FUi_Control.h"
  26 #include "FUiCtrl_OptionMenuModel.h"
  27
  28 using namespace Tizen::Graphics;
  29 using namespace Tizen::Base;
  30
  31 namespace Tizen { namespace Ui { namespace Controls
  32 {
  33
  34 _OptionMenuModel::_OptionMenuModel(void)
  35 {
  36
  37 }
  38
  39 _OptionMenuModel::~_OptionMenuModel(void)
  40 {
  41         __items.RemoveAll(true);
  42 }
  43
  44
  45 result
  46 _OptionMenuModel::Construct(void)
  47 {
  48         result r = __items.Construct();
  49         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Failed to construct ArrayList.");
  50
  51         return r;
  52 }
  53
  54 bool
  55 _OptionMenuModel::IsValidItem(_OptionMenuItem *pItem)
  56 {
  57         if (pItem == null)
  58         {
  59                 return false;
  60         }
  61
  62         int actionId = pItem->GetActionId();
  63         int itemCount = __items.GetCount();
  64
  65         for (int i = 0; i < itemCount; i++)
  66         {
  67                 _OptionMenuItem* pTargetItem = GetItem(i);
  68
  69                 if (pTargetItem == null)
  70                         return false;
  71
  72                 if (pTargetItem->GetActionId() == actionId)
  73                 {
  74                         return false;
  75                 }
  76         }
  77
  78         return true;
  79 }
  80
  81 int
  82 _OptionMenuModel::GetItemCount(void) const
  83 {
  84         return __items.GetCount();
  85 }
  86
  87 result
  88 _OptionMenuModel::AddItem(_OptionMenuItem* pItem, int mainIndex)
  89 {
  90         result r = E_SUCCESS;
  91
  92         if (mainIndex == INVALID_INDEX)
  93         {
  94                 r = __items.Add(*pItem);
  95         }
  96         else
  97         {
  98                 _OptionMenuItem* pMainItem = GetItem(mainIndex);
  99                 r = GetLastResult();
 100                 SysTryReturnResult(NID_UI_CTRL, pItem != null, r, "Propagating.");
 101
 102                 r = pMainItem->InsertSubItemAt(*pItem, pMainItem->GetSubItemCount());
 103         }
 104
 105         return r;
 106 }
 107
 108 result
 109 _OptionMenuModel::InsertItemAt(_OptionMenuItem* pItem, int mainIndex, int subIndex)
 110 {
 111         result r = E_SUCCESS;
 112
 113         if (subIndex == INVALID_INDEX)
 114         {
 115                 r = __items.InsertAt(*pItem, mainIndex);
 116         }
 117         else
 118         {
 119                 _OptionMenuItem* pMainItem = GetItem(mainIndex);
 120                 r = GetLastResult();
 121                 SysTryReturnResult(NID_UI_CTRL, pItem != null, r, "Propagating.");
 122
 123                 r = pMainItem->InsertSubItemAt(*pItem, subIndex);
 124
 125         }
 126
 127         return r;
 128 }
 129
 130 result
 131 _OptionMenuModel::SetItemAt(int mainIndex, const String& text, int actionId, const Bitmap* pNormalBitmap,
 132                 const Bitmap* pPressedBitmap, const Bitmap* pHighlightedBitmap, float fontSize, int subIndex)
 133 {
 134         _OptionMenuItem* pItem = GetItem(mainIndex, subIndex);
 135         result r = GetLastResult();
 136         SysTryReturnResult(NID_UI_CTRL, pItem != null, r, "Propagating.");
 137
 138         OptionMenuItemDrawingType itemType = OPTION_MENU_ITEM_DRAWING_TYPE_TEXT;
 139
 140         if (subIndex == INVALID_INDEX)
 141         {
 142                 int index = GetItemIndexFromActionId(actionId);
 143                 SysTryReturnResult(NID_UI_CTRL, (index < 0 || mainIndex == index), E_SYSTEM,
 144                                 "A system error has occurred. The specified actionId (%d) is not valid", actionId);
 145         }
 146         else
 147         {
 148                 _OptionMenuItem* pMainItem = GetItem(mainIndex);
 149                 SysTryReturnResult(NID_UI_CTRL, pMainItem != null, E_SYSTEM,
 150                                 "A system error has occurred. The specified main index (%d) does not exists.", mainIndex);
 151                 int index = pMainItem->GetSubItemIndexFromActionId(actionId);
 152                 SysTryReturnResult(NID_UI_CTRL, (index < 0 || subIndex == index), E_SYSTEM,
 153                                 "A system error has occurred. The specified actionId (%d) is not valid", actionId);
 154         }
 155
 156         _Label* pLabel = null;
 157
 158         if (pNormalBitmap != null)
 159         {
 160                 itemType = OPTION_MENU_ITEM_DRAWING_TYPE_BITMAP;
 161         }
 162
 163         pItem->SetBitmap(OPTION_MENU_ITEM_DRAWING_STATUS_NORMAL, pNormalBitmap);
 164
 165         pLabel = pItem->GetBitmapLabel();
 166
 167         if (pLabel != null)
 168         {
 169                 pLabel->SetBackgroundBitmap(*pNormalBitmap);
 170         }
 171
 172         pItem->SetBitmap(OPTION_MENU_ITEM_DRAWING_STATUS_PRESSED, pPressedBitmap);
 173
 174         pItem->SetBitmap(OPTION_MENU_ITEM_DRAWING_STATUS_HIGHLIGHTED, pHighlightedBitmap);
 175
 176         pLabel = pItem->GetTextLabel();
 177
 178         if (pLabel != null)
 179         {
 180                 pLabel->SetText(text);
 181                 pLabel->SetTextConfig(fontSize, LABEL_TEXT_STYLE_NORMAL);
 182         }
 183
 184         pItem->SetType(itemType);
 185         pItem->SetText(text);
 186         pItem->SetActionId(actionId);
 187         pItem->SetTextSize(fontSize);
 188
 189         return E_SUCCESS;
 190 }
 191
 192 result
 193 _OptionMenuModel::RemoveItem(int mainIndex, int subIndex)
 194 {
 195         if (subIndex == INVALID_INDEX)
 196         {
 197                 return __items.RemoveAt(mainIndex, true);
 198         }
 199
 200         _OptionMenuItem* pMainItem = GetItem(mainIndex);
 201         result r = GetLastResult();
 202         SysTryReturnResult(NID_UI_CTRL, pMainItem != null, r, "Propagating.");
 203
 204         SysTryReturnResult(NID_UI_CTRL,
 205                         (subIndex > INVALID_INDEX && subIndex < pMainItem->GetSubItemCount()), E_INVALID_ARG,
 206                         "Invalid argument is used. The specified sub index (%d) is out of range.", subIndex);
 207
 208         return pMainItem->RemoveSubItemAt(subIndex);
 209 }
 210
 211 result
 212 _OptionMenuModel::RemoveAllItem(void)
 213 {
 214         __items.RemoveAll(true);
 215
 216         return E_SUCCESS;
 217 }
 218
 219 void
 220 _OptionMenuModel::ResetAllItem(void)
 221 {
 222         int count = __items.GetCount();
 223
 224         _OptionMenuItem* pItem;
 225         for(int index = 0; index < count; index++)
 226         {
 227                 pItem = static_cast <_OptionMenuItem*>(__items.GetAt(index));
 228                 pItem->SetAndInvalidate(false);
 229         }
 230 }
 231
 232 void
 233 _OptionMenuModel::ResetSelectedItem(int selectedIndex)
 234 {
 235         if (selectedIndex == -1)
 236         {
 237                 return;
 238         }
 239
 240         _OptionMenuItem* pItem = null;
 241         pItem = static_cast <_OptionMenuItem*>(__items.GetAt(selectedIndex));
 242         SysTryReturnVoidResult(NID_UI_CTRL, pItem != null, E_SYSTEM, "[%s] A system error has occurred. pItem must not be null.", GetErrorMessage(E_SYSTEM));
 243         pItem->SetAndInvalidate(false);
 244
 245 }
 246
 247 int
 248 _OptionMenuModel::GetItemIndexFromActionId(int actionId) const
 249 {
 250         const _OptionMenuItem* pItem = null;
 251         for (int mainIndex = 0; mainIndex < __items.GetCount(); mainIndex++)
 252         {
 253                 pItem = static_cast<const _OptionMenuItem*>(__items.GetAt(mainIndex));
 254                 if (pItem != null)
 255                 {
 256                         if (pItem->GetActionId() == actionId)
 257                         {
 258                                 return mainIndex;
 259                         }
 260                 }
 261         }
 262
 263         return -1;
 264 }
 265
 266 int
 267 _OptionMenuModel::GetSubItemCount(int mainIndex) const
 268 {
 269         const _OptionMenuItem* pItem = GetItem(mainIndex);
 270         if (pItem == null)
 271         {
 272                 return -1;
 273         }
 274
 275         return pItem->GetSubItemCount();
 276 }
 277
 278 int
 279 _OptionMenuModel::GetSubItemIndexFromActionId(int actionId, int& mainIndex) const
 280 {
 281         const _OptionMenuItem* pMainItem = null;
 282         int mainItemCount = __items.GetCount();
 283         for (int index = 0; index < mainItemCount; index++)
 284         {
 285                 pMainItem = static_cast<const _OptionMenuItem*>(__items.GetAt(index));
 286                 if (pMainItem != null)
 287                 {
 288                         int subItemIndex = pMainItem->GetSubItemIndexFromActionId(actionId);
 289                         if (subItemIndex >= 0)
 290                         {
 291                                 return subItemIndex;
 292                         }
 293                 }
 294         }
 295
 296         return -1;
 297 }
 298
 299 _OptionMenuItem*
 300 _OptionMenuModel::GetItem(int mainIndex, int subIndex) const
 301 {
 302         int count = __items.GetCount();
 303
 304         if (mainIndex < 0 || mainIndex >= count)
 305         {
 306                 return null;
 307         }
 308
 309         const _OptionMenuItem* pItem = static_cast <const _OptionMenuItem*>(__items.GetAt(mainIndex));
 310
 311         if (subIndex == INVALID_INDEX)
 312         {
 313                 return const_cast<_OptionMenuItem*>(pItem);
 314         }
 315         else
 316         {
 317                 return const_cast<_OptionMenuItem*>(pItem)->GetSubItem(subIndex);
 318         }
 319 }
 320
 321 }}} // Tizen::Ui::Controls