src/ui/FUi_ResourceManager.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 #include <dlfcn.h>
  18 #include <pthread.h>
  19 #include <feedback/feedback.h>
  20 #include <FBaseInteger.h>
  21 #include <FBaseByteBuffer.h>
  22 #include <FBaseColIMap.h>
  23 #include <FBaseColArrayListT.h>
  24 #include <FBaseSysLog.h>
  25 #include <FIoDirectory.h>
  26 #include <FIoFile.h>
  27 #include <FGrpBitmap.h>
  28 #include <FGrpDimension.h>
  29 #include <FGrpColor.h>
  30 #include <FMediaImageTypes.h>
  31 #include <FUiCtrlAnimationFrame.h>
  32 #include <FApp_AppInfo.h>
  33 #include <FAppPkg_PackageAppInfoImpl.h>
  34 #include <FIo_DirectoryImpl.h>
  35 #include <FGrp_BitmapImpl.h>
  36 #include <FGrp_CanvasImpl.h>
  37 #include <FGrp_CoordinateSystem.h>
  38 #include <FGrp_Screen.h>
  39 #include <FMedia_ImageDecoder.h>
  40 #include <FSys_SystemInfoImpl.h>
  41 #include "FUi_Control.h"
  42 #include "FUi_ControlManager.h"
  43 #include "FUi_CoordinateSystemUtils.h"
  44 #include "FUi_ResourceManager.h"
  45 #include "FUi_ResourceStringLoader.h"
  46 #include "FUi_ResourceConfigLoader.h"
  47 #include "FUi_ResourceConfigParser.h"
  48 #include "FUi_ResourceMapContainer.h"
  49
  50 using namespace Tizen::App;
  51 using namespace Tizen::App::Package;
  52 using namespace Tizen::Base;
  53 using namespace Tizen::Base::Collection;
  54 using namespace Tizen::Io;
  55 using namespace Tizen::Graphics;
  56 using namespace Tizen::Media;
  57 using namespace Tizen::Ui::Controls;
  58 using namespace Tizen::Ui::_Resource;
  59
  60 namespace
  61 {
  62 const int DEFAULT_SCREEN_WIDTH = 720;
  63 const int DEFAULT_SCREEN_HEIGHT = 1280;
  64
  65 const int DPI_FOR_XHIGH = 290;
  66 const int DPI_FOR_HIGH = 200;
  67 const int DPI_FOR_MIDDLE = 150;
  68 const int DPI_FOR_LOW = 0;
  69
  70 template<typename T> class ResourceFallbackItemComparer
  71         : public IComparerT <T>
  72 {
  73 public:
  74         ResourceFallbackItemComparer(void) {}
  75         virtual ~ResourceFallbackItemComparer(void) {}
  76         virtual result Compare(const T& obj1, const T& obj2, int& cmp) const
  77         {
  78                 if (obj1->scaleFactor > obj2->scaleFactor)
  79                 {
  80                         cmp = 1;
  81                         return E_SUCCESS;
  82                 }
  83                 else if (obj1->scaleFactor < obj2->scaleFactor)
  84                 {
  85                         cmp = -1;
  86                         return E_SUCCESS;
  87                 }
  88                 else
  89                 {
  90                         cmp = 0;
  91                         return E_SUCCESS;
  92                 }
  93         }
  94 };
  95
  96 MediaPixelFormat ConvertBitmapPixelFormatToMediaPixelFormat(BitmapPixelFormat format)
  97 {
  98         MediaPixelFormat out = MEDIA_PIXEL_FORMAT_NONE;
  99         switch(format)
 100         {
 101                 case BITMAP_PIXEL_FORMAT_RGB565:
 102                         out = MEDIA_PIXEL_FORMAT_RGB565LE;
 103                         break;
 104                 case BITMAP_PIXEL_FORMAT_ARGB8888:
 105                         out = MEDIA_PIXEL_FORMAT_BGRA8888;
 106                         break;
 107                 case BITMAP_PIXEL_FORMAT_R8G8B8A8:
 108                         out = MEDIA_PIXEL_FORMAT_RGBA8888;
 109                         break;
 110                 default:
 111                         break;
 112         }
 113         return out;
 114 }
 115
 116 feedback_pattern_e Convert_ResourceFeedbackPatternTofeedback_pattern_e(Tizen::Ui::_ResourceFeedbackPattern pattern)
 117 {
 118         feedback_pattern_e outPattern = FEEDBACK_PATTERN_TAP;
 119         switch (pattern)
 120         {
 121                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_TAP:
 122                         outPattern = FEEDBACK_PATTERN_TAP;
 123                         break;
 124                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SIP:
 125                         outPattern = FEEDBACK_PATTERN_SIP;
 126                         break;
 127                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SIP_BACKSPACE:
 128                         outPattern = FEEDBACK_PATTERN_SIP_BACKSPACE;
 129                         break;
 130                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MAX_CHARACTER:
 131                         outPattern = FEEDBACK_PATTERN_MAX_CHARACTER;
 132                         break;
 133                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY0:
 134                         outPattern = FEEDBACK_PATTERN_KEY0;
 135                         break;
 136                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY1:
 137                         outPattern = FEEDBACK_PATTERN_KEY1;
 138                         break;
 139                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY2:
 140                         outPattern = FEEDBACK_PATTERN_KEY2;
 141                         break;
 142                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY3:
 143                         outPattern = FEEDBACK_PATTERN_KEY3;
 144                         break;
 145                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY4:
 146                         outPattern = FEEDBACK_PATTERN_KEY4;
 147                         break;
 148                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY5:
 149                         outPattern = FEEDBACK_PATTERN_KEY5;
 150                         break;
 151                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY6:
 152                         outPattern = FEEDBACK_PATTERN_KEY6;
 153                         break;
 154                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY7:
 155                         outPattern = FEEDBACK_PATTERN_KEY7;
 156                         break;
 157                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY8:
 158                         outPattern = FEEDBACK_PATTERN_KEY8;
 159                         break;
 160                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY9:
 161                         outPattern = FEEDBACK_PATTERN_KEY9;
 162                         break;
 163                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY_STAR:
 164                         outPattern = FEEDBACK_PATTERN_KEY_STAR;
 165                         break;
 166                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_KEY_SHARP:
 167                         outPattern = FEEDBACK_PATTERN_KEY_SHARP;
 168                         break;
 169                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_HOLD:
 170                         outPattern = FEEDBACK_PATTERN_HOLD;
 171                         break;
 172                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MULTI_TAP:
 173                         outPattern = FEEDBACK_PATTERN_MULTI_TAP;
 174                         break;
 175                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_HW_TAP:
 176                         outPattern = FEEDBACK_PATTERN_HW_TAP;
 177                         break;
 178                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_HW_HOLD:
 179                         outPattern = FEEDBACK_PATTERN_HW_HOLD;
 180                         break;
 181                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MESSAGE:
 182                         outPattern = FEEDBACK_PATTERN_MESSAGE;
 183                         break;
 184                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MESSAGE_ON_CALL:
 185                         outPattern = FEEDBACK_PATTERN_MESSAGE_ON_CALL;
 186                         break;
 187                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_EMAIL:
 188                         outPattern = FEEDBACK_PATTERN_EMAIL;
 189                         break;
 190                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_EMAIL_ON_CALL:
 191                         outPattern = FEEDBACK_PATTERN_EMAIL_ON_CALL;
 192                         break;
 193                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_WAKEUP:
 194                         outPattern = FEEDBACK_PATTERN_WAKEUP;
 195                         break;
 196                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 197                         outPattern = FEEDBACK_PATTERN_WAKEUP_ON_CALL;
 198                         break;
 199                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SCHEDULE:
 200                         outPattern = FEEDBACK_PATTERN_SCHEDULE;
 201                         break;
 202                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SCHEDULE_ON_CALL:
 203                         outPattern = FEEDBACK_PATTERN_SCHEDULE_ON_CALL;
 204                         break;
 205                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_TIMER:
 206                         outPattern = FEEDBACK_PATTERN_TIMER;
 207                         break;
 208                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_TIMER_ON_CALL:
 209                         outPattern = FEEDBACK_PATTERN_TIMER_ON_CALL;
 210                         break;
 211                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_GENERAL:
 212                         outPattern = FEEDBACK_PATTERN_GENERAL;
 213                         break;
 214                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_GENERAL_ON_CALL:
 215                         outPattern = FEEDBACK_PATTERN_GENERAL_ON_CALL;
 216                         break;
 217                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_POWERON:
 218                         outPattern = FEEDBACK_PATTERN_POWERON;
 219                         break;
 220                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_POWEROFF:
 221                         outPattern = FEEDBACK_PATTERN_POWEROFF;
 222                         break;
 223                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_CHARGERCONN:
 224                         outPattern = FEEDBACK_PATTERN_CHARGERCONN;
 225                         break;
 226                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_CHARGERCONN_ON_CALL:
 227                         outPattern = FEEDBACK_PATTERN_CHARGERCONN_ON_CALL;
 228                         break;
 229                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_FULLCHARGED:
 230                         outPattern = FEEDBACK_PATTERN_FULLCHARGED;
 231                         break;
 232                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_FULLCHARGED_ON_CALL:
 233                         outPattern = FEEDBACK_PATTERN_FULLCHARGED_ON_CALL;
 234                         break;
 235                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_LOWBATT:
 236                         outPattern = FEEDBACK_PATTERN_LOWBATT;
 237                         break;
 238                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_LOWBATT_ON_CALL:
 239                         outPattern = FEEDBACK_PATTERN_LOWBATT_ON_CALL;
 240                         break;
 241                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_LOCK:
 242                         outPattern = FEEDBACK_PATTERN_LOCK;
 243                         break;
 244                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_UNLOCK:
 245                         outPattern = FEEDBACK_PATTERN_UNLOCK;
 246                         break;
 247                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_CALLCONNECT:
 248                         outPattern = FEEDBACK_PATTERN_CALLCONNECT;
 249                         break;
 250                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_DISCALLCONNECT:
 251                         outPattern = FEEDBACK_PATTERN_DISCALLCONNECT;
 252                         break;
 253                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_MINUTEMINDER:
 254                         outPattern = FEEDBACK_PATTERN_MINUTEMINDER;
 255                         break;
 256                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_VIBRATION:
 257                         outPattern = FEEDBACK_PATTERN_VIBRATION;
 258                         break;
 259                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SHUTTER:
 260                         outPattern = FEEDBACK_PATTERN_SHUTTER;
 261                         break;
 262                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_LIST_REORDER:
 263                         outPattern = FEEDBACK_PATTERN_LIST_REORDER;
 264                         break;
 265                 case Tizen::Ui::_RESOURCE_FEEDBACK_PATTERN_SLIDER_SWEEP:
 266                         outPattern = FEEDBACK_PATTERN_SLIDER_SWEEP;
 267                         break;
 268                 default:
 269                         break;
 270         }
 271         return outPattern;
 272 }
 273 }
 274
 275 namespace Tizen { namespace Graphics
 276 {
 277 result
 278 _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize);
 279 }}
 280
 281 namespace Tizen { namespace Ui
 282 {
 283
 284 int _SCREEN_HEIGHT_ = 0;
 285
 286 Color _GetDefaultBackgroundColor(void)
 287 {
 288         Color color;
 289         GET_COLOR_CONFIG(BASIC::background, color);
 290         return color;
 291 }
 292 Color _GetDefaultForegroundColor(void)
 293 {
 294         Color color;
 295         GET_COLOR_CONFIG(BASIC::foreground, color);
 296         return color;
 297 }
 298
 299 _ResourceManager* pRsrcMgr = null;
 300
 301 _ResourceManager*
 302 _ResourceManager::GetInstance(void)
 303 {
 304         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 305
 306         if (pRsrcMgr == null)
 307         {
 308                 pthread_once(&onceBlock, CreateInstance);
 309                 pRsrcMgr->DoPostInitialization();
 310         }
 311         return pRsrcMgr;
 312 }
 313
 314 void
 315 _ResourceManager::CreateInstance(void)
 316 {
 317         static _ResourceManager pManager;
 318         pRsrcMgr = &pManager;
 319         _CanvasImpl::SetThemeInfoCallback(_GetDefaultForegroundColor, _GetDefaultBackgroundColor);
 320 }
 321
 322 _ResourceManager::_ResourceManager(void)
 323         : __pStringLoader(null)
 324         , __pTransformer(null)
 325         , __appBasePortraitMode("")
 326         , __appBaseLandscapeMode("")
 327         , __targetPortraitMode("")
 328         , __targetLandscapeMode("")
 329         , __defaultPortraitMode(L"720x1280")
 330         , __defaultLandscapeMode(L"1280x720")
 331         , __systemTheme(L"")
 332         , __userTheme(L"")
 333         , __appliedUserTheme(false)
 334         , __initializeFeedback(false)
 335         , __appBaseWidth(-1)
 336         , __appBaseHeight(-1)
 337         , __targetWidth(0)
 338         , __targetHeight(0)
 339         , __deviceDPI(0)
 340         , __feedbackStatus(_RESOURCE_FEEDBACK_STATUS_INIT)
 341         , __feedbackAcquireCount(0)
 342         , __pFallbackList(null)
 343 {
 344         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT] = null;
 345         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE] = null;
 346         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = null;
 347         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = null;
 348
 349         int appBaseWidth = DEFAULT_SCREEN_WIDTH;
 350         int appBaseHeight = DEFAULT_SCREEN_HEIGHT;
 351
 352         result r = E_SUCCESS;
 353
 354         int appLogicalResolution = _CoordinateSystem::GetInstance()->GetLogicalResolutionInt();
 355
 356         if (_CreateCoordinateTransformer(__pTransformer,DEFAULT_SCREEN_WIDTH, _CoordinateSystem::GetInstance()->GetLogicalBaseScreenSize(),
 357                         Dimension(appLogicalResolution, appLogicalResolution), _CoordinateSystem::GetInstance()->GetPhysicalBaseScreenSize()) != E_SUCCESS)
 358         {
 359
 360                 SysAssert(0);
 361         }
 362         r = Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/screen.dpi", __deviceDPI);
 363         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 364
 365         _ControlManager::GetInstance()->SetScreenDpi(__deviceDPI);
 366
 367         switch(appLogicalResolution)
 368         {
 369                 case 240:
 370                         appBaseWidth = 240;
 371                         appBaseHeight = 400;
 372                         break;
 373                 case 320:
 374                         appBaseWidth = 320;
 375                         appBaseHeight = 480;
 376                         break;
 377                 case 480:
 378                         appBaseWidth = 480;
 379                         appBaseHeight = 800;
 380                         break;
 381                 case 720:
 382                         appBaseWidth = 720;
 383                         appBaseHeight = 1280;
 384                         break;
 385                 default:
 386                         r = Tizen::System::_SystemInfoImpl::GetSysInfo("http://tizen.org/feature/screen.width", appBaseWidth);
 387                         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 388                         r = Tizen::System::_SystemInfoImpl::GetSysInfo("http://tizen.org/feature/screen.height", appBaseHeight);
 389                         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 390                         break;
 391         }
 392         __appBaseWidth = appBaseWidth;
 393         __appBaseHeight = appBaseHeight;
 394
 395         __appBasePortraitMode.Append(appBaseWidth);
 396         __appBasePortraitMode.Append(L"x");
 397         __appBasePortraitMode.Append(appBaseHeight);
 398
 399         __appBaseLandscapeMode.Append(appBaseHeight);
 400         __appBaseLandscapeMode.Append(L"x");
 401         __appBaseLandscapeMode.Append(appBaseWidth);
 402         int _width = 0;
 403         int _height = 0;
 404         r = Tizen::System::_SystemInfoImpl::GetSysInfo("http://tizen.org/feature/screen.width", _width);
 405         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 406         r = Tizen::System::_SystemInfoImpl::GetSysInfo("http://tizen.org/feature/screen.height", _height);
 407         SysTryReturn(NID_UI, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] system error occurred");
 408
 409         __targetWidth = _width;
 410         __targetHeight = _height;
 411         __targetPortraitMode.Append(_width);
 412         __targetPortraitMode.Append(L"x");
 413         __targetPortraitMode.Append(_height);
 414
 415         __targetLandscapeMode.Append(_height);
 416         __targetLandscapeMode.Append(L"x");
 417         __targetLandscapeMode.Append(_width);
 418
 419         Dimension dim = _CoordinateSystemUtils::InverseTransform(Dimension(_Screen::GetWidth(), _Screen::GetHeight()));
 420         __logicalWidth = dim.width;
 421         __logicalHeight = dim.height;
 422         LoadThemeInformation(__systemTheme, __userTheme);
 423
 424         // theme 2.0
 425         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT] = new (std::nothrow) MapContainer();
 426         SysTryReturnVoidResult(NID_UI, __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT], E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 427         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->SetResolution(__appBasePortraitMode);
 428         if (!(InitializeTheme(*__pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT])))
 429         {
 430                 SysAssert(0);
 431         }
 432         __pStringLoader = new (std::nothrow) StringLoader();
 433         SysTryReturnVoidResult(NID_UI, __pStringLoader, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 434 }
 435
 436 bool
 437 _ResourceManager::InitializeTheme(MapContainer& mapContainer)
 438 {
 439         bool r = true;
 440         String themeFile(L"");
 441         mapContainer.CreateMap(RESOURCE_TYPE_SHAPE);
 442         mapContainer.CreateMap(RESOURCE_TYPE_FIXED_VALUE);
 443         mapContainer.CreateMap(RESOURCE_TYPE_DIMENSION);
 444         mapContainer.CreateMap(RESOURCE_TYPE_IMAGE);
 445         mapContainer.CreateMap(RESOURCE_TYPE_COLOR);
 446         mapContainer.CreateMap(RESOURCE_TYPE_ANIMATION);
 447         mapContainer.SetResolution(__appBasePortraitMode);
 448
 449         themeFile = String(L"/usr/share/osp/themes/"+__systemTheme + ".xml");
 450
 451         LoadPaletteInformation(__systemTheme);
 452         LoadConfig(__appBasePortraitMode, mapContainer, __appBaseWidth, __appBaseHeight);
 453         if (__userTheme.GetLength() > 0)
 454         {
 455                 themeFile = String(_AppInfo::GetAppRootPath()+L"res/themes/" +__userTheme + L"/" +__userTheme + ".xml");
 456                 if(File::IsFileExist(themeFile))
 457                 {
 458                         ConfigParser* pParser = new (std::nothrow) ConfigParser();
 459                         SysTryReturn(NID_UI, pParser, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 460                         r = pParser->Parse(themeFile, mapContainer);
 461                         delete pParser;
 462                 }
 463         }
 464
 465         return r;
 466 }
 467
 468 void
 469 _ResourceManager::LoadConfig(const String& resolution, MapContainer& mapContainer, int width, int height)
 470 {
 471         _ICoordinateSystemTransformer* pTransformer = _CoordinateSystem::GetTransformerN(__appBaseWidth, _CoordinateSystem::GetInstance()->GetLogicalBaseScreenSize(),
 472         Dimension(width, height), BASE_SCREEN_SIZE_NORMAL);
 473
 474         if (pTransformer)
 475         {
 476                 _SCREEN_HEIGHT_ = pTransformer->Transform(__logicalHeight);
 477         }
 478         else
 479         {
 480                 _SCREEN_HEIGHT_ = __logicalHeight;
 481         }
 482
 483         SysLog(NID_UI, "_SCREEN_HEIGHT_ : %d, resolution : %ls", _SCREEN_HEIGHT_, resolution.GetPointer());
 484         int count = ConfigLoader::GetInstance()->GetInitFuncCount();
 485         for (int i = 0; i < count; i++)
 486         {
 487                 _Init_Func func = null;
 488                 ConfigLoader::GetInstance()->GetInitFunc(i, func);
 489                 if (func)
 490                 {
 491                         func(mapContainer, resolution);
 492                 }
 493         }
 494         delete pTransformer;
 495 }
 496
 497 void
 498 _ResourceManager::DoPostInitialization(void)
 499 {
 500         if (_AppInfo::IsOspCompat())
 501         {
 502                 SysLog(NID_UI, "Compatibility symbols are loaded.");
 503                 SetSystemColor();
 504         }
 505 }
 506
 507 MapContainer*
 508 _ResourceManager::GetMapContainer(MapContainerType type)
 509 {
 510         MapContainer* pContainer = null;
 511         switch (type)
 512         {
 513                 case MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT:
 514                         pContainer = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT];
 515                         break;
 516                 case MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE:
 517                         if (__pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE])
 518                         {
 519                                 pContainer = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE];
 520                         }
 521                         else
 522                         {
 523                                 pContainer = new (std::nothrow) MapContainer();
 524                                 SysTryReturn(NID_UI, pContainer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 525                                 pContainer->SetResolution(__appBaseLandscapeMode);
 526                                 pContainer->CreateMap(RESOURCE_TYPE_SHAPE);
 527                                 pContainer->CreateMap(RESOURCE_TYPE_DIMENSION);
 528                                 pContainer->CreateMap(RESOURCE_TYPE_FIXED_VALUE);
 529                                 LoadConfig(__appBaseLandscapeMode, *pContainer, __appBaseWidth, __appBaseHeight);
 530                                 __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE] = pContainer;
 531                         }
 532                         break;
 533                 case MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT:
 534                         if (__pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT])
 535                         {
 536                                 pContainer = __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT];
 537                         }
 538                         else
 539                         {
 540                                 if(__defaultPortraitMode == __appBasePortraitMode)
 541                                 {
 542                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT];
 543                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE];
 544                                         pContainer = __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT];
 545                                 }
 546                                 else
 547                                 {
 548                                         pContainer = new (std::nothrow) MapContainer();
 549                                         SysTryReturn(NID_UI, pContainer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 550                                         pContainer->SetResolution(__defaultPortraitMode);
 551                                         pContainer->CreateMap(RESOURCE_TYPE_SHAPE);
 552                                         pContainer->CreateMap(RESOURCE_TYPE_DIMENSION);
 553                                         pContainer->CreateMap(RESOURCE_TYPE_FIXED_VALUE);
 554                                         LoadConfig(__defaultPortraitMode, *pContainer, DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT);
 555                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = pContainer;
 556                                 }
 557                         }
 558                         break;
 559                 case MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE:
 560                         if (__pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE])
 561                         {
 562                                 pContainer = __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE];
 563                         }
 564                         else
 565                         {
 566                                 if(__defaultPortraitMode == __appBasePortraitMode)
 567                                 {
 568                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT];
 569                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE];
 570                                         pContainer = __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE];
 571                                 }
 572                                 else
 573                                 {
 574                                         pContainer = new (std::nothrow) MapContainer();
 575                                         SysTryReturn(NID_UI, pContainer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 576                                         pContainer->SetResolution(__defaultLandscapeMode);
 577                                         pContainer->CreateMap(RESOURCE_TYPE_SHAPE);
 578                                         pContainer->CreateMap(RESOURCE_TYPE_DIMENSION);
 579                                         pContainer->CreateMap(RESOURCE_TYPE_FIXED_VALUE);
 580                                         LoadConfig(__defaultLandscapeMode, *pContainer, DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT);
 581                                         __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = pContainer;
 582                                 }
 583                         }
 584                         break;
 585                 default:
 586                         break;
 587         }
 588         return pContainer;
 589 }
 590
 591 _ResourceManager::~_ResourceManager(void)
 592 {
 593         delete __pStringLoader;
 594         __pStringLoader = null;
 595         delete __pTransformer;
 596         __pTransformer = null;
 597
 598         if(__pFallbackList)
 599         {
 600                 ResourceFallbackItem* pItem = null;
 601                 int count = __pFallbackList->GetCount();
 602                 for (int i = 0; i < count; i++)
 603                 {
 604                         __pFallbackList->GetAt(i, pItem);
 605                         delete pItem;
 606                 }
 607                 __pFallbackList->RemoveAll();
 608                 delete __pFallbackList;
 609                 __pFallbackList = null;
 610         }
 611
 612         bool deleteDefaultMap = true;
 613         if (__pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT] == __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT])
 614         {
 615                 deleteDefaultMap = false;
 616         }
 617         delete __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT];
 618         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT] = null;
 619         delete __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE];
 620         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE] = null;
 621
 622         if (deleteDefaultMap)
 623         {
 624                 delete __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT];
 625                 __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT] = null;
 626                 delete __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE];
 627                 __pMapContainer[MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE] = null;
 628         }
 629
 630         feedback_deinitialize();
 631 }
 632 void
 633 _ResourceManager::ReloadTheme(Tizen::Base::String& themeName, bool userdefine)
 634 {
 635         if(userdefine)
 636         {
 637                 __userTheme = themeName;
 638         }
 639         else
 640         {
 641                 __systemTheme = themeName;
 642         }
 643 }
 644
 645 result
 646 _ResourceManager::GetBitmapInternalN(const String& fileName, BitmapPixelFormat pixelFormat, _ControlOrientation orientation, bool isCustom, Bitmap*& pBitmap)
 647 {
 648         result r = E_SYSTEM;
 649         Bitmap* pTempBitmap = null;
 650         int foundFolderWidth = 0;
 651         String fullName = FindImagePath(fileName, foundFolderWidth, isCustom);
 652         if(foundFolderWidth == __targetWidth)
 653         {
 654                 pTempBitmap = new (std::nothrow) Bitmap;
 655                 SysTryReturn(NID_UI, pTempBitmap, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Propagating.", GetErrorMessage(r));
 656                 r = _BitmapImpl::GetInstance(*pTempBitmap)->Construct(fullName, pixelFormat);
 657                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 658                 pBitmap = pTempBitmap;
 659                 return r;
 660         }
 661         else
 662         {
 663                 if (_BitmapImpl::HasNinePatchedBitmapTag(fileName))
 664                 {
 665                         pTempBitmap = new (std::nothrow) Bitmap;
 666                         SysTryReturn(NID_UI, pTempBitmap, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Propagating.", GetErrorMessage(r));
 667                         r = _BitmapImpl::GetInstance(*pTempBitmap)->Construct(fullName, pixelFormat);
 668                         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 669                         pBitmap = pTempBitmap;
 670                         return r;
 671                 }
 672                 else
 673                 {
 674                         ByteBuffer* pImageBuffer = null;
 675                         int imageWidth = 0;
 676                         int imageHeight = 0;
 677                         MediaPixelFormat format = ConvertBitmapPixelFormatToMediaPixelFormat(pixelFormat);
 678                         pImageBuffer = _ImageDecoder::DecodeToBufferN(fullName, format, imageWidth, imageHeight);
 679                         if (pImageBuffer)
 680                         {
 681                                 pTempBitmap = _BitmapImpl::GetNonScaledBitmapN(*pImageBuffer, Dimension(imageWidth, imageHeight), pixelFormat);
 682                                 delete pImageBuffer;
 683                         }
 684                         if(pTempBitmap != null)
 685                         {
 686                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pTempBitmap))
 687                                 {
 688                                         pBitmap = pTempBitmap;
 689                                         r = E_SUCCESS;
 690                                 }
 691                                 else
 692                                 {
 693                                         float scaleFactor = (float)((float)__targetWidth/(float)foundFolderWidth);
 694                                         r = pTempBitmap->Scale(Dimension(pTempBitmap->GetWidth()*scaleFactor, pTempBitmap->GetHeight()*scaleFactor));
 695                                         if (r == E_SUCCESS)
 696                                         {
 697                                                 pBitmap = pTempBitmap;
 698                                         }
 699                                         else
 700                                         {
 701                                                 delete pTempBitmap;
 702                                         }
 703                                 }
 704                         }
 705                 }
 706         }
 707         return r;
 708 CATCH:
 709         delete pTempBitmap;
 710         return r;
 711 }
 712
 713 result
 714 _ResourceManager::GetBitmapN(int bitmapId, BitmapPixelFormat pixelFormat, _ControlOrientation orientation, Bitmap*& pBitmap)
 715 {
 716         result r = E_SYSTEM;
 717         ResourceItem* pItem = null;
 718         String fileName;
 719         r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetImageMap()->GetValue(bitmapId, pItem);
 720         if (r == E_SUCCESS)
 721         {
 722                 fileName = pItem->GetImageName();
 723                 if (fileName.IsEmpty())
 724                 {
 725                         r = E_OBJ_NOT_FOUND;
 726                 }
 727                 else
 728                 {
 729                         r = GetBitmapInternalN(fileName, pixelFormat, orientation, IsCustomBitmap(bitmapId), pBitmap);
 730                 }
 731         }
 732         return r;
 733 }
 734
 735 result
 736 _ResourceManager::GetString(const char* stringId, String& string)
 737 {
 738         return __pStringLoader->GetString(stringId, string);
 739 }
 740
 741 result
 742 _ResourceManager::GetColor(int colorId, Color& color)
 743 {
 744         result r = E_SYSTEM;
 745         ResourceItem* pItem = null;
 746         r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetColorMap()->GetValue(colorId, pItem);
 747         if(r == E_SUCCESS)
 748         {
 749                 if(pItem->isInitialized())
 750                 {
 751                         color.SetRGB32(pItem->GetColor(), true);
 752                 }
 753                 else
 754                 {
 755                         unsigned int value = 0;
 756                         ResourceItem* pPaletteItem = null;
 757                         const char* key = pItem->GetRawString();
 758                         ResourceKey resourceKey(key);
 759                         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetPalette()->GetValue(resourceKey, pPaletteItem);
 760                         if(pPaletteItem)
 761                         {
 762                                 value = pPaletteItem->GetColor();
 763                                 pItem->SetRawDataColor(value);
 764                                 color.SetRGB32(value, true);
 765                         }
 766                         else
 767                         {
 768                                 color.SetRGB32(0,true);
 769                         }
 770                 }
 771         }
 772         return r;
 773 }
 774
 775 result
 776 _ResourceManager::GetDimension(int dimensionId, _ControlOrientation orientation, Dimension& dimension)
 777 {
 778         result r = E_SUCCESS;
 779         ResourceItem* pItem = null;
 780
 781         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 782         {
 783                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetDimensionMap()->GetValue(dimensionId, pItem);
 784                 if (r != E_SUCCESS)
 785                 {
 786                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetDimensionMap()->GetValue(dimensionId, pItem);
 787                 }
 788         }
 789         else
 790         {
 791                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetDimensionMap()->GetValue(dimensionId, pItem);
 792                 if (r != E_SUCCESS)
 793                 {
 794                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetDimensionMap()->GetValue(dimensionId, pItem);
 795                 }
 796         }
 797
 798         if (r == E_SUCCESS)
 799         {
 800                 dimension.SetSize(pItem->GetDimension().width, pItem->GetDimension().height);
 801         }
 802         else
 803         {
 804                 r = GetDefaultShapeWithScaling(dimensionId, orientation, dimension);
 805         }
 806
 807         return r;
 808 }
 809
 810 result
 811 _ResourceManager::GetDimension(int dimensionId, _ControlOrientation orientation, Tizen::Graphics::FloatDimension& dimension)
 812 {
 813         result r = E_SUCCESS;
 814         ResourceItem* pItem = null;
 815
 816         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 817         {
 818                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetDimensionMap()->GetValue(dimensionId, pItem);
 819                 if (r != E_SUCCESS)
 820                 {
 821                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetDimensionMap()->GetValue(dimensionId, pItem);
 822                 }
 823         }
 824         else
 825         {
 826                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetDimensionMap()->GetValue(dimensionId, pItem);
 827                 if (r != E_SUCCESS)
 828                 {
 829                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetDimensionMap()->GetValue(dimensionId, pItem);
 830                 }
 831         }
 832
 833         if (r == E_SUCCESS)
 834         {
 835                 dimension = pItem->GetDimension();
 836         }
 837         else
 838         {
 839                 r = GetDefaultShapeWithScaling(dimensionId, orientation, dimension);
 840         }
 841
 842         return r;
 843 }
 844
 845 result
 846 _ResourceManager::GetAnimationN(int animationId, ArrayList*& pList)
 847 {
 848         ResourceAnimationFrameList* pFrameList = null;
 849         AnimationFrame* pFrame = null;
 850         Bitmap* pBitmap = null;
 851         ResourceItem* pItem = null;
 852
 853         bool isCustom = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetAnimationMap()->IsUserThemeItem(animationId);
 854         result r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetAnimationMap()->GetValue(animationId, pItem);
 855         SysTryReturnResult(NID_UI, r == E_SUCCESS, E_SYSTEM,"System error is occured.");
 856
 857         pFrameList = pItem->GetAnimationFrameList();
 858         Tizen::Base::Collection::LinkedListT<ResourceAnimationFrame>* pAnimationList = static_cast<Tizen::Base::Collection::LinkedListT<ResourceAnimationFrame>* >(pFrameList->GetAnimationList());
 859         if (pAnimationList == null)
 860         {
 861                 return E_SYSTEM;
 862         }
 863         int count = pAnimationList->GetCount();
 864         if (count == 0)
 865         {
 866                 return E_SYSTEM;
 867         }
 868         pList = new (std::nothrow) ArrayList();
 869         int i = 0;
 870         for (; i < count ; i++)
 871         {
 872                 ResourceAnimationFrame frame;
 873                 r = pAnimationList->GetAt(i, frame);
 874                 SysTryCatch(NID_UI, r == E_SUCCESS, , E_SYSTEM,"System error is occured.");
 875                 r = GetBitmapInternalN(frame.__fileName, BITMAP_PIXEL_FORMAT_ARGB8888, _CONTROL_ORIENTATION_PORTRAIT, isCustom, pBitmap);
 876                 SysTryCatch(NID_UI, r == E_SUCCESS, , E_SYSTEM,"System error is occured.");
 877                 pFrame = new (std::nothrow) AnimationFrame(*pBitmap, frame.__duration);
 878                 SysTryCatch(NID_UI, pFrame, , E_SYSTEM,"System error is occured.");
 879                 pList->Add(pFrame);
 880                 delete pBitmap;
 881         }
 882         return E_SUCCESS;
 883
 884 CATCH:
 885         delete pBitmap;
 886         delete pFrame;
 887         delete pList;
 888         pList = null;
 889         return E_SYSTEM;
 890 }
 891 result
 892 _ResourceManager::GetShape(int shapeId, _ControlOrientation orientation, int& value)
 893 {
 894         result r = E_SUCCESS;
 895         ResourceItem* pItem = null;
 896
 897         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 898         {
 899                 r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetShapeMap()->GetValue(shapeId, pItem);
 900                 if (r != E_SUCCESS)
 901                 {
 902                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
 903                 }
 904         }
 905         else
 906         {
 907                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
 908                 if (r != E_SUCCESS)
 909                 {
 910                         r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetShapeMap()->GetValue(shapeId, pItem);
 911                 }
 912         }
 913
 914         if (r == E_SUCCESS)
 915         {
 916                 value = (int)pItem->GetFloat();
 917         }
 918         else
 919         {
 920                 r = GetDefaultShapeWithScaling(shapeId, orientation, value);
 921         }
 922         return r;
 923 }
 924
 925 result
 926 _ResourceManager::GetShape(int shapeId, _ControlOrientation orientation, float& value)
 927 {
 928         result r = E_SUCCESS;
 929         ResourceItem* pItem = null;
 930
 931         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 932         {
 933                 r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetShapeMap()->GetValue(shapeId, pItem);
 934                 if (r != E_SUCCESS)
 935                 {
 936                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
 937                 }
 938         }
 939         else
 940         {
 941                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
 942                 if (r != E_SUCCESS)
 943                 {
 944                         r = __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetShapeMap()->GetValue(shapeId, pItem);
 945                 }
 946         }
 947
 948         if (r == E_SUCCESS)
 949         {
 950                 value = pItem->GetFloat();
 951         }
 952         else
 953         {
 954                 r = GetDefaultShapeWithScaling(shapeId, orientation, value);
 955         }
 956
 957         return r;
 958 }
 959
 960 result
 961 _ResourceManager::GetFixedValue(int fixedValueId, _ControlOrientation orientation, int& value)
 962 {
 963         result r = E_SUCCESS;
 964         ResourceItem* pItem = null;
 965
 966         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 967         {
 968                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 969                 if (r != E_SUCCESS)
 970                 {
 971
 972                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 973                 }
 974         }
 975         else
 976         {
 977                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 978                 if (r != E_SUCCESS)
 979                 {
 980                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 981                 }
 982         }
 983
 984         if (r != E_SUCCESS)
 985         {
 986                 if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 987                 {
 988                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 989                         if (r != E_SUCCESS)
 990                         {
 991                                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 992                         }
 993                 }
 994                 else
 995                 {
 996                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
 997                         if (r != E_SUCCESS)
 998                         {
 999                                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1000                         }
1001                 }
1002         }
1003
1004         if (r == E_SUCCESS)
1005         {
1006                 value = (int)(pItem->GetFloat());
1007         }
1008
1009         return r;
1010 }
1011
1012 result
1013 _ResourceManager::GetFixedValue(int fixedValueId, _ControlOrientation orientation, float& value)
1014 {
1015         result r = E_SUCCESS;
1016         ResourceItem* pItem = null;
1017
1018         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1019         {
1020                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1021                 if (r != E_SUCCESS)
1022                 {
1023
1024                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1025                 }
1026         }
1027         else
1028         {
1029                 r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1030                 if (r != E_SUCCESS)
1031                 {
1032                         r = GetMapContainer(MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1033                 }
1034         }
1035
1036         if (r != E_SUCCESS)
1037         {
1038                 if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1039                 {
1040                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1041                         if (r != E_SUCCESS)
1042                         {
1043                                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1044                         }
1045                 }
1046                 else
1047                 {
1048                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1049                         if (r != E_SUCCESS)
1050                         {
1051                                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetFixedValueMap()->GetValue(fixedValueId, pItem);
1052                         }
1053                 }
1054         }
1055
1056         if (r == E_SUCCESS)
1057         {
1058                 value = pItem->GetFloat();
1059         }
1060
1061         return r;
1062 }
1063
1064 bool
1065 _ResourceManager::IsCustomColor(int colorId)
1066 {
1067         return __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetColorMap()->IsUserThemeItem(colorId);
1068 }
1069 bool
1070 _ResourceManager::IsCustomBitmap(int bitmapId)
1071 {
1072         return __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetImageMap()->IsUserThemeItem(bitmapId);
1073 }
1074
1075 result
1076 _ResourceManager::PlayFeedback(_ResourceFeedbackPattern pattern, const _Control* pControl)
1077 {
1078         if (unlikely(__initializeFeedback == false))
1079         {
1080                 feedback_error_e error = (feedback_error_e)feedback_initialize();
1081                 if(error != FEEDBACK_ERROR_NONE)
1082                 {
1083                         SysLog(NID_UI, "It failed to initialize feedback module.");
1084                 }
1085                 __initializeFeedback = true;
1086         }
1087         if (__feedbackStatus == _RESOURCE_FEEDBACK_STATUS_PLAYED)
1088         {
1089                 SysLog(NID_UI, "feedback is already played.");
1090                 return E_SUCCESS;
1091         }
1092
1093         bool play = true;
1094         _Control* pTempControl = const_cast<_Control*>(pControl);
1095
1096         while(pTempControl)
1097         {
1098                 if (pTempControl->IsEffectSoundEnabled() == false)
1099                 {
1100                         play = false;
1101                         break;
1102                 }
1103                 pTempControl = pTempControl->GetParent();
1104         }
1105
1106         if (!play)
1107         {
1108                 SysLog(NID_UI, "feedback is disabled for this control");
1109                 return E_SUCCESS;
1110         }
1111
1112         feedback_pattern_e playPattern = Convert_ResourceFeedbackPatternTofeedback_pattern_e(pattern);
1113         __feedbackStatus = _RESOURCE_FEEDBACK_STATUS_PLAYED;
1114         int r = feedback_play(playPattern);
1115         if (r == FEEDBACK_ERROR_NONE)
1116         {
1117                 SysLog(NID_UI, "It succeeded to play feedback.");
1118                 return E_SUCCESS;
1119         }
1120         else
1121         {
1122                 SysLog(NID_UI, "It failed to play feedback.");
1123                 return E_SYSTEM;
1124         }
1125         return E_SUCCESS;
1126 }
1127
1128 result
1129 _ResourceManager::GetDefaultShapeWithScaling(int shapeId, _ControlOrientation orientation, int& value)
1130 {
1131         result r = E_SUCCESS;
1132         ResourceItem* pItem = null;
1133
1134         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1135         {
1136                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetShapeMap()->GetValue(shapeId, pItem);
1137                 if (r != E_SUCCESS)
1138                 {
1139                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
1140                 }
1141         }
1142         else
1143         {
1144                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
1145                 if (r != E_SUCCESS)
1146                 {
1147                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetShapeMap()->GetValue(shapeId, pItem);
1148                 }
1149         }
1150
1151         if (r == E_SUCCESS)
1152         {
1153                 value = (int)pItem->GetFloat();
1154         }
1155
1156         if (r == E_SUCCESS)
1157         {
1158                 int temp = __pTransformer->Transform(value);
1159                 if (temp == 0 && value > 0)
1160                 {
1161                         value = 1;
1162                 }
1163                 else
1164                 {
1165                         value = temp;
1166                 }
1167         }
1168         return r;
1169 }
1170
1171 result
1172 _ResourceManager::GetDefaultShapeWithScaling(int shapeId, _ControlOrientation orientation, Tizen::Graphics::FloatDimension& dimension)
1173 {
1174         result r = E_SUCCESS;
1175         ResourceItem* pItem = null;
1176
1177         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1178         {
1179                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetDimensionMap()->GetValue(shapeId, pItem);
1180                 if (r != E_SUCCESS)
1181                 {
1182                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetDimensionMap()->GetValue(shapeId, pItem);
1183                 }
1184         }
1185         else
1186         {
1187                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetDimensionMap()->GetValue(shapeId, pItem);
1188                 if (r != E_SUCCESS)
1189                 {
1190                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetDimensionMap()->GetValue(shapeId, pItem);
1191                 }
1192         }
1193
1194         if (r == E_SUCCESS)
1195         {
1196                 dimension = __pTransformer->Transform(pItem->GetDimension());
1197         }
1198
1199         return r;
1200 }
1201
1202 result
1203 _ResourceManager::GetDefaultShapeWithScaling(int shapeId, _ControlOrientation orientation, float& outValue)
1204 {
1205         result r = E_SUCCESS;
1206         ResourceItem* pItem = null;
1207
1208         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1209         {
1210                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetShapeMap()->GetValue(shapeId, pItem);
1211                 if (r != E_SUCCESS)
1212                 {
1213                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
1214                 }
1215         }
1216         else
1217         {
1218                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetShapeMap()->GetValue(shapeId, pItem);
1219                 if (r != E_SUCCESS)
1220                 {
1221                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetShapeMap()->GetValue(shapeId, pItem);
1222                 }
1223         }
1224
1225         if (r == E_SUCCESS)
1226         {
1227                 outValue = __pTransformer->Transform(pItem->GetFloat());
1228         }
1229
1230         return r;
1231 }
1232
1233 result
1234 _ResourceManager::GetDefaultShapeWithScaling(int shapeId, _ControlOrientation orientation, Dimension& dimension)
1235 {
1236         result r = E_SUCCESS;
1237         ResourceItem* pItem = null;
1238
1239         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1240         {
1241                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetDimensionMap()->GetValue(shapeId, pItem);
1242                 if (r != E_SUCCESS)
1243                 {
1244                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetDimensionMap()->GetValue(shapeId, pItem);
1245                 }
1246         }
1247         else
1248         {
1249                 r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_LANDSCAPE)->GetDimensionMap()->GetValue(shapeId, pItem);
1250                 if (r != E_SUCCESS)
1251                 {
1252                         r = GetMapContainer(MAP_CONTAINER_TYPE_DEFAULT_PORTRAIT)->GetDimensionMap()->GetValue(shapeId, pItem);
1253                 }
1254         }
1255
1256         if (r == E_SUCCESS)
1257         {
1258                 Dimension dim((int)pItem->GetDimension().width, (int)pItem->GetDimension().height);
1259                 Dimension temp = __pTransformer->Transform(dim);
1260                 if (temp.width == 0 && dim.width > 0)
1261                 {
1262                         temp.width = 1;
1263                 }
1264                 if (temp.height == 0 && dim.height > 0)
1265                 {
1266                         temp.height = 1;
1267                 }
1268                 dimension = temp;
1269         }
1270         return r;
1271 }
1272
1273 #define ADD_PALETTE(id, value)\
1274                 {\
1275                         ResourceKey resourceKey(#id);\
1276                         ResourceItem* pItem = new (std::nothrow) ResourceItem(RESOURCE_TYPE_COLOR); \
1277                         pItem->SetRawDataColor(value);\
1278                         __pMapContainer[MAP_CONTAINER_TYPE_APP_BASE_PORTRAIT]->GetPalette()->Add(resourceKey, pItem);\
1279                 }
1280
1281 void
1282 _ResourceManager::LoadBlackPalette(void)
1283 {
1284         ADD_PALETTE(BASIC::foreground, 0xFFFFFFFF);
1285         ADD_PALETTE(BASIC::background, 0xFF000000);
1286         ADD_PALETTE(BASIC::B011, 0xFF000000);
1287         ADD_PALETTE(BASIC::B012, 0xFF000000);
1288         ADD_PALETTE(BASIC::B013, 0xFF000000);
1289         ADD_PALETTE(BASIC::B014, 0xFFFFFFFF);
1290         ADD_PALETTE(BASIC::B015, 0xFFF8F6EF);
1291         ADD_PALETTE(BASIC::B016, 0xFF000000);
1292         ADD_PALETTE(BASIC::B017, 0xFF000000);
1293         ADD_PALETTE(BASIC::B018, 0xFF6590FF);
1294         ADD_PALETTE(BASIC::B0211, 0xFF000000);
1295         ADD_PALETTE(BASIC::B0211D, 0xFF000000);
1296         ADD_PALETTE(BASIC::B0212, 0xFF1C1E28);
1297         ADD_PALETTE(BASIC::B0213, 0xFF404040);
1298         ADD_PALETTE(BASIC::B0214, 0xFF222C47);
1299         ADD_PALETTE(BASIC::B0215, 0xFF1D263C);
1300         ADD_PALETTE(BASIC::B0216, 0xFF222C47);
1301         ADD_PALETTE(BASIC::B0217, 0xFF11131B);
1302         ADD_PALETTE(BASIC::B0217D, 0x7F11131B);
1303         ADD_PALETTE(BASIC::B0221, 0xFFFFFFFF);
1304         ADD_PALETTE(BASIC::B0221L1, 0xFF838CA3);
1305         ADD_PALETTE(BASIC::B0221L2, 0xFF697082);
1306         ADD_PALETTE(BASIC::B0221L3, 0xFF6B707E);
1307         ADD_PALETTE(BASIC::B0221L4, 0xFF525252);
1308         ADD_PALETTE(BASIC::B0222, 0x3FFFFFFF);
1309         ADD_PALETTE(BASIC::B0223, 0x00000000);
1310         ADD_PALETTE(BASIC::B0224, 0xFF27282B);
1311         ADD_PALETTE(BASIC::B0225, 0xFF2A5181);
1312         ADD_PALETTE(BASIC::B0226, 0xFF4B73A3);
1313         ADD_PALETTE(BASIC::B0227, 0xFF000000);
1314         ADD_PALETTE(BASIC::B0228, 0xFF1A5274);
1315         ADD_PALETTE(BASIC::B0232, 0x00000000);
1316         ADD_PALETTE(BASIC::B0233, 0x00000000);
1317         ADD_PALETTE(BASIC::B031, 0x00000000);
1318         ADD_PALETTE(BASIC::B041, 0xFF2B3AAF);
1319         ADD_PALETTE(BASIC::B041P, 0xFFFAFAFA);
1320         ADD_PALETTE(BASIC::B042, 0xFF2A39AC);
1321         ADD_PALETTE(BASIC::B043, 0x00001BEA);
1322         ADD_PALETTE(BASIC::B044, 0xFF2B3AAF);
1323         ADD_PALETTE(BASIC::B0511, 0xFF313F66);
1324         ADD_PALETTE(BASIC::B0511P, 0xFF2A39AC);
1325         ADD_PALETTE(BASIC::B0512, 0x00000000);
1326         ADD_PALETTE(BASIC::B0513, 0xFFF8F6EF);
1327         ADD_PALETTE(BASIC::B0514, 0xFF313F66);
1328         ADD_PALETTE(BASIC::B0514P1, 0xFF303FB2);
1329         ADD_PALETTE(BASIC::B0514P2, 0xFF5163E9);
1330         ADD_PALETTE(BASIC::B0514L3, 0xFF6590FF);
1331         ADD_PALETTE(BASIC::B0515L1, 0xFF464C5E);
1332         ADD_PALETTE(BASIC::B0515L2, 0x7F454442);
1333         ADD_PALETTE(BASIC::B0516, 0x00000000);
1334         ADD_PALETTE(BASIC::B0517, 0x00000000);
1335         ADD_PALETTE(BASIC::B0517P1, 0x00000000);
1336         ADD_PALETTE(BASIC::B0517P2, 0x00000000);
1337         ADD_PALETTE(BASIC::B0518, 0xFF2E4468);
1338         ADD_PALETTE(BASIC::B0518P, 0x00000000);
1339         ADD_PALETTE(BASIC::B0519, 0xFFF25D28);
1340         ADD_PALETTE(BASIC::B0520, 0xFF2E4468);
1341         ADD_PALETTE(BASIC::B0520P, 0xFF3C649B);
1342         ADD_PALETTE(BASIC::B052L1, 0xFFFAFAFA);
1343         ADD_PALETTE(BASIC::B052L1P, 0xFF5D83FF);
1344         ADD_PALETTE(BASIC::B052L1D, 0xFFFAFAFA);
1345         ADD_PALETTE(BASIC::B052L2, 0x00000000);
1346         ADD_PALETTE(BASIC::B052L2P, 0x005787B8);
1347         ADD_PALETTE(BASIC::B052L3, 0x00000000);
1348         ADD_PALETTE(BASIC::B052L3P, 0x00000000);
1349         ADD_PALETTE(BASIC::B052L4, 0xFFFAFAFA);
1350         ADD_PALETTE(BASIC::B052L4P, 0xFFFAFAFA);
1351         ADD_PALETTE(BASIC::B052L4D, 0x66FAFAFA);
1352         ADD_PALETTE(BASIC::B052L5, 0xFFFAFAFA);
1353         ADD_PALETTE(BASIC::B052L5D, 0x66FAFAFA);
1354         ADD_PALETTE(BASIC::B052L5P, 0xFF5D83FF);
1355         ADD_PALETTE(BASIC::B052L6, 0xFFFAFAFA);
1356         ADD_PALETTE(BASIC::B052L6D, 0x99FAFAFA);
1357         ADD_PALETTE(BASIC::B052L6P1, 0xFFFAFAFA);
1358         ADD_PALETTE(BASIC::B052L6P2, 0xFFFAFAFA);
1359         ADD_PALETTE(BASIC::B052L7, 0xFFFAFAFA);
1360         ADD_PALETTE(BASIC::B052L8, 0xFFFAFAFA);
1361         ADD_PALETTE(BASIC::B052L8P, 0xFF5D83FF);
1362         ADD_PALETTE(BASIC::B052L8D, 0x66FAFAFA);
1363         ADD_PALETTE(BASIC::B052L9, 0xFFFAFAFA);
1364         ADD_PALETTE(BASIC::B052L9P, 0xFFFAFAFA);
1365         ADD_PALETTE(BASIC::B052L9D, 0x66FAFAFA);
1366         ADD_PALETTE(BASIC::B052L10, 0x00000000);
1367         ADD_PALETTE(BASIC::B0531, 0xFFF8F6EF);
1368         ADD_PALETTE(BASIC::B0532, 0x00000000);
1369         ADD_PALETTE(BASIC::B0533, 0x00000000);
1370         ADD_PALETTE(BASIC::B0534, 0x00000000);
1371         ADD_PALETTE(BASIC::B0535, 0x00000000);
1372         ADD_PALETTE(BASIC::B0536, 0x00000000);
1373         ADD_PALETTE(BASIC::B0537, 0x00000000);
1374         ADD_PALETTE(BASIC::B0541, 0xFF6B728A);
1375         ADD_PALETTE(BASIC::B0541P, 0xFF0D1D96);
1376         ADD_PALETTE(BASIC::B0541D, 0x996B728A);
1377         ADD_PALETTE(BASIC::B0542, 0x00000000);
1378         ADD_PALETTE(BASIC::B0542P, 0x00000000);
1379         ADD_PALETTE(BASIC::B0543, 0x00000000);
1380         ADD_PALETTE(BASIC::B0544, 0x00000000);
1381         ADD_PALETTE(BASIC::B0545, 0x00000000);
1382         ADD_PALETTE(BASIC::B0551, 0x00000000);
1383         ADD_PALETTE(BASIC::B0552, 0x00000000);
1384         ADD_PALETTE(BASIC::B0553, 0xFFA5A5A5);
1385         ADD_PALETTE(BASIC::B0554, 0xFFFFFFFF);
1386         ADD_PALETTE(BASIC::B0555, 0x00000000);
1387         ADD_PALETTE(BASIC::B0556, 0x00000000);
1388         ADD_PALETTE(BASIC::B0557, 0x00000000);
1389         ADD_PALETTE(BASIC::B0558, 0x00000000);
1390         ADD_PALETTE(BASIC::B061L1, 0xFF1D263C);
1391         ADD_PALETTE(BASIC::B061L2, 0xFF49577B);
1392         ADD_PALETTE(BASIC::B061L3, 0xFF969A9C);
1393         ADD_PALETTE(BASIC::B061L4, 0xFF1D263C);
1394         ADD_PALETTE(BASIC::B061L5, 0xFF000000);
1395         ADD_PALETTE(BASIC::B061L6, 0xFF333537);
1396         ADD_PALETTE(BASIC::B0621L1, 0x00000000);
1397         ADD_PALETTE(BASIC::B0621L2, 0x00000000);
1398         ADD_PALETTE(BASIC::B0622L1, 0x001D263C);
1399         ADD_PALETTE(BASIC::B0622L2, 0x3FFFFFFF);
1400         ADD_PALETTE(BASIC::B0623L1, 0xFF1D263C);
1401         ADD_PALETTE(BASIC::B0623L2, 0xFF626675);
1402         ADD_PALETTE(BASIC::B0624L1, 0xFF1D263C);
1403         ADD_PALETTE(BASIC::B0624L2, 0xFF626675);
1404         ADD_PALETTE(BASIC::B0624L3, 0xFF313F66);
1405         ADD_PALETTE(BASIC::B0624L4, 0xFF000000);
1406         ADD_PALETTE(BASIC::B0624L5, 0xFF5783FF);
1407         ADD_PALETTE(BASIC::B0624L6, 0xFF5783FF);
1408         ADD_PALETTE(BASIC::B063L1, 0xFFFAFAFA);
1409         ADD_PALETTE(BASIC::B063L1P, 0xFFFAFAFA);
1410         ADD_PALETTE(BASIC::B063L1D, 0x99FAFAFA);
1411         ADD_PALETTE(BASIC::B063L2, 0xFFFAFAFA);
1412         ADD_PALETTE(BASIC::B063L3, 0xFF6E6F76);
1413         ADD_PALETTE(BASIC::B063L4, 0xFFFAFAFA);
1414         ADD_PALETTE(BASIC::B063L5, 0xFFFAFAFA);
1415         ADD_PALETTE(BASIC::B063L5D, 0x99FAFAFA);
1416         ADD_PALETTE(BASIC::B063L6, 0xFFFAFAFA);
1417         ADD_PALETTE(BASIC::B063L6P, 0xFFFAFAFA);
1418         ADD_PALETTE(BASIC::B063L6D, 0x99FAFAFA);
1419         ADD_PALETTE(BASIC::B063L7, 0xFF656565);
1420         ADD_PALETTE(BASIC::B063L8, 0xFF6E6F76);
1421         ADD_PALETTE(BASIC::B063L8P, 0x00000000);
1422         ADD_PALETTE(BASIC::B063L8D, 0x996E6F76);
1423         ADD_PALETTE(BASIC::B063L9, 0xFFFAFAFA);
1424         ADD_PALETTE(BASIC::B064L1, 0xFF6890FF);
1425         ADD_PALETTE(BASIC::B064L2, 0xFFD7D7D7);
1426         ADD_PALETTE(BASIC::B064L2P, 0xFFD7D7D7);
1427         ADD_PALETTE(BASIC::B064L2D, 0xFFD7D7D7);
1428         ADD_PALETTE(BASIC::B064L3, 0xFF000000);
1429         ADD_PALETTE(BASIC::B064L3P, 0xFFFAFAFA);
1430         ADD_PALETTE(BASIC::B064L3D, 0x7F000000);
1431         ADD_PALETTE(BASIC::B065L1, 0x00000000);
1432         ADD_PALETTE(BASIC::B065L2, 0x00000000);
1433         ADD_PALETTE(BASIC::B065L3, 0x00000000);
1434         ADD_PALETTE(BASIC::B065L3P, 0x00000000);
1435         ADD_PALETTE(BASIC::B065L4, 0xFFEEEEEE);
1436         ADD_PALETTE(BASIC::B065L4D, 0x99EEEEEE);
1437         ADD_PALETTE(BASIC::B065L4P, 0xFF2A39AC);
1438         ADD_PALETTE(BASIC::B065L5, 0x00000000);
1439         ADD_PALETTE(BASIC::B071, 0xFF393B41);
1440         ADD_PALETTE(BASIC::B0721, 0xFFA09F9A);
1441         ADD_PALETTE(BASIC::B0722, 0xFF5D83FF);
1442         ADD_PALETTE(BASIC::B0723, 0xFF212428);
1443         ADD_PALETTE(BASIC::B0724, 0xFF404040);
1444         ADD_PALETTE(BASIC::B0725, 0xFF4F66A7);
1445         ADD_PALETTE(BASIC::B0726, 0xFF404040);
1446         ADD_PALETTE(BASIC::B0731, 0xFF2B3AAF);
1447         ADD_PALETTE(BASIC::B0732, 0xFFFAFAFA);
1448         ADD_PALETTE(BASIC::B0741, 0xFFA09F9A);
1449         ADD_PALETTE(BASIC::B0742, 0xFF5D83FF);
1450         ADD_PALETTE(BASIC::B0743, 0xFF212428);
1451         ADD_PALETTE(BASIC::B0744, 0xFF404040);
1452         ADD_PALETTE(BASIC::B0745, 0x00000000);
1453         ADD_PALETTE(BASIC::B0751, 0xFF3B73B6);
1454         ADD_PALETTE(BASIC::F011L1, 0xFFFAFAFA);
1455         ADD_PALETTE(BASIC::F011L1P, 0xFFFAFAFA);
1456         ADD_PALETTE(BASIC::F011L1D, 0x7FFAFAFA);
1457         ADD_PALETTE(BASIC::F011L2, 0xFF6890FF);
1458         ADD_PALETTE(BASIC::F011L2D, 0x996890FF);
1459         ADD_PALETTE(BASIC::F011L3, 0xFF6E6F76);
1460         ADD_PALETTE(BASIC::F011L3D, 0x996E6F76);
1461         ADD_PALETTE(BASIC::F011L4, 0xFF6E6F76);
1462         ADD_PALETTE(BASIC::F011L4D, 0x996E6F76);
1463         ADD_PALETTE(BASIC::F011L5, 0xFF5D83FF);
1464         ADD_PALETTE(BASIC::F011L6, 0xFFFAFAFA);
1465         ADD_PALETTE(BASIC::F011L7, 0xFF6E6F76);
1466         ADD_PALETTE(BASIC::F011L7D, 0x996E6F76);
1467         ADD_PALETTE(BASIC::F011L8, 0xFFD10000);
1468         ADD_PALETTE(BASIC::F011L9, 0xFFFFFFFF);
1469         ADD_PALETTE(BASIC::F011L10, 0xFFF9F9F9);
1470         ADD_PALETTE(BASIC::F011L11, 0xFF808080);
1471         ADD_PALETTE(BASIC::F011L12, 0xFF4093F7);
1472         ADD_PALETTE(BASIC::F011L13, 0x00000000);
1473         ADD_PALETTE(BASIC::F011L14, 0x00000000);
1474         ADD_PALETTE(BASIC::F011L15, 0xFFD10000);
1475         ADD_PALETTE(BASIC::F011L16, 0xFF6E6F76);
1476         ADD_PALETTE(BASIC::F011L17, 0xFF8B8B8B);
1477         ADD_PALETTE(BASIC::F011L18, 0xFF686868);
1478         ADD_PALETTE(BASIC::F011L19, 0xFF6E6F76);
1479         ADD_PALETTE(BASIC::F011L20, 0x00000000);
1480         ADD_PALETTE(BASIC::F011L21, 0xFF6E6F76);
1481         ADD_PALETTE(BASIC::F011L22, 0xFF6E6F76);
1482         ADD_PALETTE(BASIC::F011L23, 0xFF1382FF);
1483         ADD_PALETTE(BASIC::F021L1i, 0xFFFAFAFA);
1484         ADD_PALETTE(BASIC::F021L1iP, 0xFFFAFAFA);
1485         ADD_PALETTE(BASIC::F021L1iD, 0x99FAFAFA);
1486         ADD_PALETTE(BASIC::F022L1i, 0xFF6C6E77);
1487         ADD_PALETTE(BASIC::F022L2i, 0xFF2B3AAF);
1488         ADD_PALETTE(BASIC::F022L2iD, 0x992B3AAF);
1489         ADD_PALETTE(BASIC::F031L1, 0xFFFAFAFA);
1490         ADD_PALETTE(BASIC::F031L1P, 0xFFFAFAFA);
1491         ADD_PALETTE(BASIC::F031L1D, 0x99FAFAFA);
1492         ADD_PALETTE(BASIC::F031L2, 0x00000000);
1493         ADD_PALETTE(BASIC::F031L2P, 0x00000000);
1494         ADD_PALETTE(BASIC::F031L2D, 0x00000000);
1495         ADD_PALETTE(BASIC::F031L3, 0xFFFAFAFA);
1496         ADD_PALETTE(BASIC::F031L3P, 0xFFFAFAFA);
1497         ADD_PALETTE(BASIC::F031L3D, 0x99FAFAFA);
1498         ADD_PALETTE(BASIC::F032L1, 0xFFFAFAFA);
1499         ADD_PALETTE(BASIC::F032L1P, 0xFFFAFAFA);
1500         ADD_PALETTE(BASIC::F032L1D, 0x99FAFAFA);
1501         ADD_PALETTE(BASIC::F032L2, 0xFFFAFAFA);
1502         ADD_PALETTE(BASIC::F032L2P, 0xFFFAFAFA);
1503         ADD_PALETTE(BASIC::F032L2D, 0x99FAFAFA);
1504         ADD_PALETTE(BASIC::F032L3, 0xFFF9F9F9);
1505         ADD_PALETTE(BASIC::F032L3P, 0xFFF9F9F9);
1506         ADD_PALETTE(BASIC::F041i, 0xFF5D6176);
1507         ADD_PALETTE(BASIC::F041iD, 0x995D6176);
1508         ADD_PALETTE(BASIC::F051, 0xFF485D93);
1509         ADD_PALETTE(BASIC::F052, 0xFF3A72FF);
1510         ADD_PALETTE(BASIC::F053, 0xFF485D93);
1511         ADD_PALETTE(BASIC::F053P, 0xFFFAFAFA);
1512         ADD_PALETTE(BASIC::F053D, 0x99485D93);
1513         ADD_PALETTE(BASIC::F054, 0xFF202432);
1514         ADD_PALETTE(BASIC::F055, 0xFF3A72FF);
1515         ADD_PALETTE(BASIC::W011, 0xFF4B4D56);
1516         ADD_PALETTE(BASIC::W011D, 0x994B4D56);
1517         ADD_PALETTE(BASIC::W012, 0xFF095FD4);
1518         ADD_PALETTE(BASIC::W012D, 0x99095FD4);
1519         ADD_PALETTE(BASIC::W012P, 0xFF232F91);
1520         ADD_PALETTE(BASIC::W013, 0x00000000);
1521         ADD_PALETTE(BASIC::W0141, 0xFFDB0000);
1522         ADD_PALETTE(BASIC::W0141P, 0xFFA10808);
1523         ADD_PALETTE(BASIC::W0141D, 0x99DB0000);
1524         ADD_PALETTE(BASIC::W015, 0xFF343432);
1525         ADD_PALETTE(BASIC::W021L1, 0xFF000000);
1526         ADD_PALETTE(BASIC::W021L1P, 0xFF2B3AAF);
1527         ADD_PALETTE(BASIC::W021L2, 0xFF425790);
1528         ADD_PALETTE(BASIC::W021L2P, 0xFFFAFAFA);
1529         ADD_PALETTE(BASIC::W021L3, 0xFF425790);
1530         ADD_PALETTE(BASIC::W021L3P, 0xFFFAFAFA);
1531         ADD_PALETTE(BASIC::W021L4, 0xFFF0F0F0);
1532         ADD_PALETTE(BASIC::W031L1, 0xFF000000);
1533         ADD_PALETTE(BASIC::W031L1D, 0x99000000);
1534         ADD_PALETTE(BASIC::W031L2, 0xFF000000);
1535         ADD_PALETTE(BASIC::W031L2D, 0x99000000);
1536         ADD_PALETTE(BASIC::W032, 0xFF5D6176);
1537         ADD_PALETTE(BASIC::W032P, 0xFFFAFAFA);
1538         ADD_PALETTE(BASIC::W032D, 0x99FAFAFA);
1539         ADD_PALETTE(BASIC::W041, 0xFFE1DDD1);
1540         ADD_PALETTE(BASIC::W051, 0xFF000000);
1541         ADD_PALETTE(BASIC::W0611, 0xFFFAFAFA);
1542         ADD_PALETTE(BASIC::W0611P, 0xFFFAFAFA);
1543         ADD_PALETTE(BASIC::W0611D, 0x99FAFAFA);
1544         ADD_PALETTE(BASIC::W062L1, 0xFF555861);
1545         ADD_PALETTE(BASIC::W062L1D, 0x99555861);
1546         ADD_PALETTE(BASIC::W062L2, 0xFF415BFE);
1547         ADD_PALETTE(BASIC::W062L2D, 0x7F415BFE);
1548         ADD_PALETTE(BASIC::W062L3, 0xFFD8D7D2);
1549         ADD_PALETTE(BASIC::W062L3D, 0x4CD8D7D2);
1550         ADD_PALETTE(BASIC::W062L4, 0xFF3677C3);
1551         ADD_PALETTE(BASIC::W062L4D, 0x4C3677C3);
1552         ADD_PALETTE(BASIC::W062L5, 0xFFC7D3E3);
1553         ADD_PALETTE(BASIC::W0631, 0xFFEEEEEE);
1554         ADD_PALETTE(BASIC::W0632, 0xFF4C5158);
1555         ADD_PALETTE(BASIC::W0641, 0xFF6B6D79);
1556         ADD_PALETTE(BASIC::W0641P, 0xFF2A39AC);
1557         ADD_PALETTE(BASIC::W0641D, 0x996B6D79);
1558         ADD_PALETTE(BASIC::W0651, 0xFF3A3A3A);
1559         ADD_PALETTE(BASIC::W0711, 0xFF525767);
1560         ADD_PALETTE(BASIC::W0711P, 0xFF2B3AAF);
1561         ADD_PALETTE(BASIC::W0711D, 0xFF3E414E);
1562         ADD_PALETTE(BASIC::W0712, 0xFF4267A9);
1563         ADD_PALETTE(BASIC::W0713, 0xFF2B3AAF);
1564         ADD_PALETTE(BASIC::W0714, 0xFF263E5F);
1565         ADD_PALETTE(BASIC::W0715, 0xFF2B3AAF);
1566         ADD_PALETTE(BASIC::W0721, 0xFFFAFAFA);
1567         ADD_PALETTE(BASIC::W0721P, 0xFFFAFAFA);
1568         ADD_PALETTE(BASIC::W0721D, 0x99FAFAFA);
1569         ADD_PALETTE(BASIC::W0811, 0xFF253296);
1570         ADD_PALETTE(BASIC::W0812, 0x00000000);
1571         ADD_PALETTE(BASIC::W0813, 0xFF595959);
1572         ADD_PALETTE(BASIC::W082, 0x00000000);
1573         ADD_PALETTE(BASIC::W083, 0x00000000);
1574         ADD_PALETTE(BASIC::W084, 0xB2FAFAFA);
1575         ADD_PALETTE(BASIC::W084P, 0xFFFAFAFA);
1576         ADD_PALETTE(BASIC::W085, 0x00000000);
1577         ADD_PALETTE(BASIC::W091, 0xFF2B3AAF);
1578         ADD_PALETTE(BASIC::W092, 0xFFFAFAFA);
1579         ADD_PALETTE(BASIC::W101, 0xFF4884D6);
1580         ADD_PALETTE(BASIC::W111, 0xFFC8CEDB);
1581         ADD_PALETTE(BASIC::W112L1, 0xFF8995AE);
1582         ADD_PALETTE(BASIC::W112L2, 0xFFFAFAFA);
1583         ADD_PALETTE(BASIC::W1121, 0xFFFAFAFA);
1584         ADD_PALETTE(BASIC::W1122, 0xFFFAFAFA);
1585         ADD_PALETTE(BASIC::W1123, 0x4C000000);
1586         ADD_PALETTE(BASIC::W1211, 0x00000000);
1587         ADD_PALETTE(BASIC::W1212, 0x00000000);
1588         ADD_PALETTE(BASIC::W1221, 0xFF000000);
1589         ADD_PALETTE(BASIC::W1222, 0xFF878580);
1590         ADD_PALETTE(BASIC::W1223, 0xFFFFFFFF);
1591         ADD_PALETTE(BASIC::W131, 0xFF343739);
1592         ADD_PALETTE(BASIC::W132, 0xFF2B3AAF);
1593         ADD_PALETTE(BASIC::W141, 0xFFFAFAFA);
1594         ADD_PALETTE(BASIC::W151, 0x66000000);
1595         ADD_PALETTE(BASIC::W152, 0xFF42434B);
1596         ADD_PALETTE(BASIC::W153, 0xFF2B3AAF);
1597         ADD_PALETTE(BASIC::W154, 0xFF1C1E28);
1598         ADD_PALETTE(BASIC::W161, 0xFF001BEA);
1599 }
1600
1601 void
1602 _ResourceManager::LoadWhitePalette(void)
1603 {
1604         ADD_PALETTE(BASIC::foreground, 0xFF000000);
1605         ADD_PALETTE(BASIC::background, 0xFFF8F6EF);
1606         ADD_PALETTE(BASIC::B011, 0xFFF8F6EF);
1607         ADD_PALETTE(BASIC::B012, 0xFFF8F6EF);
1608         ADD_PALETTE(BASIC::B013, 0xFF000000);
1609         ADD_PALETTE(BASIC::B014, 0xFFFFFFFF);
1610         ADD_PALETTE(BASIC::B015, 0xFF202327);
1611         ADD_PALETTE(BASIC::B016, 0xFF000000);
1612         ADD_PALETTE(BASIC::B017, 0xFFFAFAFA);
1613         ADD_PALETTE(BASIC::B018, 0xFF6590FF);
1614         ADD_PALETTE(BASIC::B0211, 0xFFF8F6EF);
1615         ADD_PALETTE(BASIC::B0211D, 0xFFF8F6EF);
1616         ADD_PALETTE(BASIC::B0212, 0xFFEDEBE4);
1617         ADD_PALETTE(BASIC::B0213, 0xFF5B5656);
1618         ADD_PALETTE(BASIC::B0214, 0xFFDCDAD3);
1619         ADD_PALETTE(BASIC::B0215, 0xFFDEDCD5);
1620         ADD_PALETTE(BASIC::B0216, 0xFFBDBBB5);
1621         ADD_PALETTE(BASIC::B0217, 0xFFEFEDE5);
1622         ADD_PALETTE(BASIC::B0217D, 0x7FEFEDE5);
1623         ADD_PALETTE(BASIC::B0221, 0xFF8A8A8A);
1624         ADD_PALETTE(BASIC::B0221L1, 0xFF8A8A8A);
1625         ADD_PALETTE(BASIC::B0221L2, 0xFF808080);
1626         ADD_PALETTE(BASIC::B0221L3, 0xFF8C8C8C);
1627         ADD_PALETTE(BASIC::B0221L4, 0xFFCCCBC7);
1628         ADD_PALETTE(BASIC::B0222, 0xFFFFFFFF);
1629         ADD_PALETTE(BASIC::B0223, 0xFFD3D1CB);
1630         ADD_PALETTE(BASIC::B0224, 0xFFB9B8B2);
1631         ADD_PALETTE(BASIC::B0225, 0xFF2A5181);
1632         ADD_PALETTE(BASIC::B0226, 0xFF4B73A3);
1633         ADD_PALETTE(BASIC::B0227, 0xFF000000);
1634         ADD_PALETTE(BASIC::B0228, 0xFF1A5274);
1635         ADD_PALETTE(BASIC::B0232, 0x00000000);
1636         ADD_PALETTE(BASIC::B0233, 0x00000000);
1637         ADD_PALETTE(BASIC::B031, 0x00000000);
1638         ADD_PALETTE(BASIC::B041, 0xFF5787C2);
1639         ADD_PALETTE(BASIC::B041P, 0xFFFAFAFA);
1640         ADD_PALETTE(BASIC::B042, 0xFF0079D4);
1641         ADD_PALETTE(BASIC::B043, 0xFF5787C2);
1642         ADD_PALETTE(BASIC::B044, 0xFF2A89C2);
1643         ADD_PALETTE(BASIC::B0511, 0xFFEDEBE4);
1644         ADD_PALETTE(BASIC::B0511P, 0xFF0E66AA);
1645         ADD_PALETTE(BASIC::B0512, 0x00000000);
1646         ADD_PALETTE(BASIC::B0513, 0xFF202327);
1647         ADD_PALETTE(BASIC::B0514, 0xFFEDEBE4);
1648         ADD_PALETTE(BASIC::B0514P1, 0xFF0E66AA);
1649         ADD_PALETTE(BASIC::B0514P2, 0xFF007BDA);
1650         ADD_PALETTE(BASIC::B0514L3, 0xFF6590FF);
1651         ADD_PALETTE(BASIC::B0515L1, 0xFFDEDCD5);
1652         ADD_PALETTE(BASIC::B0515L2, 0x7F626262);
1653         ADD_PALETTE(BASIC::B0516, 0x00000000);
1654         ADD_PALETTE(BASIC::B0517, 0x00000000);
1655         ADD_PALETTE(BASIC::B0517P1, 0x00000000);
1656         ADD_PALETTE(BASIC::B0517P2, 0x00000000);
1657         ADD_PALETTE(BASIC::B0518, 0x003567A3);
1658         ADD_PALETTE(BASIC::B0518P, 0x00000000);
1659         ADD_PALETTE(BASIC::B0519, 0xFFF25D28);
1660         ADD_PALETTE(BASIC::B0520, 0xFF3567A3);
1661         ADD_PALETTE(BASIC::B0520P, 0xFF2A89C2);
1662         ADD_PALETTE(BASIC::B052L1, 0xFF656565);
1663         ADD_PALETTE(BASIC::B052L1P, 0xFF007BDA);
1664         ADD_PALETTE(BASIC::B052L1D, 0x7F656565);
1665         ADD_PALETTE(BASIC::B052L2, 0xFF525252);
1666         ADD_PALETTE(BASIC::B052L2P, 0xFF4093F7);
1667         ADD_PALETTE(BASIC::B052L3, 0x00000000);
1668         ADD_PALETTE(BASIC::B052L3P, 0x00000000);
1669         ADD_PALETTE(BASIC::B052L4, 0xFF282828);
1670         ADD_PALETTE(BASIC::B052L4P, 0xFFFAFAFA);
1671         ADD_PALETTE(BASIC::B052L4D, 0x7F282828);
1672         ADD_PALETTE(BASIC::B052L5, 0xFF282828);
1673         ADD_PALETTE(BASIC::B052L5D, 0x7F282828);
1674         ADD_PALETTE(BASIC::B052L5P, 0xFF007BDA);
1675         ADD_PALETTE(BASIC::B052L6, 0xFF282828);
1676         ADD_PALETTE(BASIC::B052L6D, 0x7F282828);
1677         ADD_PALETTE(BASIC::B052L6P1, 0xFF0E68AD);
1678         ADD_PALETTE(BASIC::B052L6P2, 0xFFFAFAFA);
1679         ADD_PALETTE(BASIC::B052L7, 0xFFFAFAFA);
1680         ADD_PALETTE(BASIC::B052L8, 0xFFFAFAFA);
1681         ADD_PALETTE(BASIC::B052L8P, 0xFF4093F7);
1682         ADD_PALETTE(BASIC::B052L8D, 0x7FFAFAFA);
1683         ADD_PALETTE(BASIC::B052L9, 0xFFFAFAFA);
1684         ADD_PALETTE(BASIC::B052L9P, 0xFFFAFAFA);
1685         ADD_PALETTE(BASIC::B052L9D, 0x7FFAFAFA);
1686         ADD_PALETTE(BASIC::B052L10, 0x00000000);
1687         ADD_PALETTE(BASIC::B0531, 0xFF202327);
1688         ADD_PALETTE(BASIC::B0532, 0x00000000);
1689         ADD_PALETTE(BASIC::B0533, 0x00000000);
1690         ADD_PALETTE(BASIC::B0534, 0x00000000);
1691         ADD_PALETTE(BASIC::B0535, 0x00000000);
1692         ADD_PALETTE(BASIC::B0536, 0x00000000);
1693         ADD_PALETTE(BASIC::B0537, 0x00000000);
1694         ADD_PALETTE(BASIC::B0541, 0xFFF7F5ED);
1695         ADD_PALETTE(BASIC::B0541P, 0xFF007AD8);
1696         ADD_PALETTE(BASIC::B0541D, 0x7FF7F5ED);
1697         ADD_PALETTE(BASIC::B0542, 0x00000000);
1698         ADD_PALETTE(BASIC::B0542P, 0x00000000);
1699         ADD_PALETTE(BASIC::B0543, 0x00000000);
1700         ADD_PALETTE(BASIC::B0544, 0x00000000);
1701         ADD_PALETTE(BASIC::B0545, 0x00000000);
1702         ADD_PALETTE(BASIC::B0551, 0x00000000);
1703         ADD_PALETTE(BASIC::B0552, 0x00000000);
1704         ADD_PALETTE(BASIC::B0553, 0xFF0C0F14);
1705         ADD_PALETTE(BASIC::B0554, 0xFF414447);
1706         ADD_PALETTE(BASIC::B0555, 0x00000000);
1707         ADD_PALETTE(BASIC::B0556, 0x00000000);
1708         ADD_PALETTE(BASIC::B0557, 0x00000000);
1709         ADD_PALETTE(BASIC::B0558, 0x00000000);
1710         ADD_PALETTE(BASIC::B061L1, 0xFFF8F6EF);
1711         ADD_PALETTE(BASIC::B061L2, 0xFFDBD9CE);
1712         ADD_PALETTE(BASIC::B061L3, 0xFFD6D3C9);
1713         ADD_PALETTE(BASIC::B061L4, 0xFF444444);
1714         ADD_PALETTE(BASIC::B061L5, 0xFF000000);
1715         ADD_PALETTE(BASIC::B061L6, 0xFF17191C);
1716         ADD_PALETTE(BASIC::B0621L1, 0x00000000);
1717         ADD_PALETTE(BASIC::B0621L2, 0x00000000);
1718         ADD_PALETTE(BASIC::B0622L1, 0x00444444);
1719         ADD_PALETTE(BASIC::B0622L2, 0x3FFFFFFF);
1720         ADD_PALETTE(BASIC::B0623L1, 0xFF2D2D2D);
1721         ADD_PALETTE(BASIC::B0623L2, 0xFF5B5B5B);
1722         ADD_PALETTE(BASIC::B0624L1, 0xFFCDCDCD);
1723         ADD_PALETTE(BASIC::B0624L2, 0xFFFAFAFA);
1724         ADD_PALETTE(BASIC::B0624L3, 0xFF303337);
1725         ADD_PALETTE(BASIC::B0624L4, 0xFF000000);
1726         ADD_PALETTE(BASIC::B0624L5, 0xFF007BDA);
1727         ADD_PALETTE(BASIC::B0624L6, 0xFFFAFAFA);
1728         ADD_PALETTE(BASIC::B063L1, 0xFF000000);
1729         ADD_PALETTE(BASIC::B063L1P, 0xFFFAFAFA);
1730         ADD_PALETTE(BASIC::B063L1D, 0x7F000000);
1731         ADD_PALETTE(BASIC::B063L2, 0xFFFAFAFA);
1732         ADD_PALETTE(BASIC::B063L3, 0xFF808080);
1733         ADD_PALETTE(BASIC::B063L4, 0xFFFAFAFA);
1734         ADD_PALETTE(BASIC::B063L5, 0xFFFAFAFA);
1735         ADD_PALETTE(BASIC::B063L5D, 0x7FFAFAFA);
1736         ADD_PALETTE(BASIC::B063L6, 0xFF454545);
1737         ADD_PALETTE(BASIC::B063L6P, 0xFF454545);
1738         ADD_PALETTE(BASIC::B063L6D, 0x7F454545);
1739         ADD_PALETTE(BASIC::B063L7, 0xFFBABABA);
1740         ADD_PALETTE(BASIC::B063L8, 0xFF808080);
1741         ADD_PALETTE(BASIC::B063L8P, 0x00000000);
1742         ADD_PALETTE(BASIC::B063L8D, 0x7F808080);
1743         ADD_PALETTE(BASIC::B063L9, 0xFF252525);
1744         ADD_PALETTE(BASIC::B064L1, 0xFF3B73B6);
1745         ADD_PALETTE(BASIC::B064L2, 0xFF808080);
1746         ADD_PALETTE(BASIC::B064L2P, 0xFF808080);
1747         ADD_PALETTE(BASIC::B064L2D, 0xFF808080);
1748         ADD_PALETTE(BASIC::B064L3, 0xFF3A3A3A);
1749         ADD_PALETTE(BASIC::B064L3P, 0xFFFAFAFA);
1750         ADD_PALETTE(BASIC::B064L3D, 0x7F3A3A3A);
1751         ADD_PALETTE(BASIC::B065L1, 0x00000000);
1752         ADD_PALETTE(BASIC::B065L2, 0x00000000);
1753         ADD_PALETTE(BASIC::B065L3, 0x00000000);
1754         ADD_PALETTE(BASIC::B065L3P, 0x00000000);
1755         ADD_PALETTE(BASIC::B065L4, 0xFFF7F5ED);
1756         ADD_PALETTE(BASIC::B065L4D, 0x7FF7F5ED);
1757         ADD_PALETTE(BASIC::B065L4P, 0xFF007AD8);
1758         ADD_PALETTE(BASIC::B065L5, 0x00000000);
1759         ADD_PALETTE(BASIC::B071, 0xFFC6C4BE);
1760         ADD_PALETTE(BASIC::B0721, 0xFFA09F9A);
1761         ADD_PALETTE(BASIC::B0722, 0xFF3B73B6);
1762         ADD_PALETTE(BASIC::B0723, 0xFFF8F6EF);
1763         ADD_PALETTE(BASIC::B0724, 0xFFD1CFC9);
1764         ADD_PALETTE(BASIC::B0725, 0xFF3B73B6);
1765         ADD_PALETTE(BASIC::B0726, 0xFFE2DFD5);
1766         ADD_PALETTE(BASIC::B0731, 0xFF3B73B6);
1767         ADD_PALETTE(BASIC::B0732, 0xFFFAFAFA);
1768         ADD_PALETTE(BASIC::B0741, 0xFFA09F9A);
1769         ADD_PALETTE(BASIC::B0742, 0xFF3B73B6);
1770         ADD_PALETTE(BASIC::B0743, 0xFFE6E3D8);
1771         ADD_PALETTE(BASIC::B0744, 0xFFC5C2B7);
1772         ADD_PALETTE(BASIC::B0745, 0x00000000);
1773         ADD_PALETTE(BASIC::B0751, 0xFF3B73B6);
1774         ADD_PALETTE(BASIC::F011L1, 0xFF000000);
1775         ADD_PALETTE(BASIC::F011L1P, 0xFFFAFAFA);
1776         ADD_PALETTE(BASIC::F011L1D, 0x7F000000);
1777         ADD_PALETTE(BASIC::F011L2, 0xFF3B73B6);
1778         ADD_PALETTE(BASIC::F011L2D, 0x7F3B73B6);
1779         ADD_PALETTE(BASIC::F011L3, 0xFF4F4F4F);
1780         ADD_PALETTE(BASIC::F011L3D, 0xFF4F4F4F);
1781         ADD_PALETTE(BASIC::F011L4, 0xFF4F4F4F);
1782         ADD_PALETTE(BASIC::F011L4D, 0x7F4F4F4F);
1783         ADD_PALETTE(BASIC::F011L5, 0xFF3B73B6);
1784         ADD_PALETTE(BASIC::F011L6, 0xFF808080);
1785         ADD_PALETTE(BASIC::F011L7, 0xFF686866);
1786         ADD_PALETTE(BASIC::F011L7D, 0xCC686866);
1787         ADD_PALETTE(BASIC::F011L8, 0xFFC24747);
1788         ADD_PALETTE(BASIC::F011L9, 0xFFFFFFFF);
1789         ADD_PALETTE(BASIC::F011L10, 0xFFFAFAFA);
1790         ADD_PALETTE(BASIC::F011L11, 0xFF808080);
1791         ADD_PALETTE(BASIC::F011L12, 0xFF4093F7);
1792         ADD_PALETTE(BASIC::F011L13, 0x00000000);
1793         ADD_PALETTE(BASIC::F011L14, 0x00000000);
1794         ADD_PALETTE(BASIC::F011L15, 0xFFE94949);
1795         ADD_PALETTE(BASIC::F011L16, 0xFF8B8B8B);
1796         ADD_PALETTE(BASIC::F011L17, 0xFF8B8B8B);
1797         ADD_PALETTE(BASIC::F011L18, 0xFF686868);
1798         ADD_PALETTE(BASIC::F011L19, 0xFF8B8B8B);
1799         ADD_PALETTE(BASIC::F011L20, 0x00000000);
1800         ADD_PALETTE(BASIC::F011L21, 0xFF808080);
1801         ADD_PALETTE(BASIC::F011L22, 0xFF9A9A9A);
1802         ADD_PALETTE(BASIC::F011L23, 0xFF1382FF);
1803         ADD_PALETTE(BASIC::F021L1i, 0xFF808080);
1804         ADD_PALETTE(BASIC::F021L1iP, 0xFFFAFAFA);
1805         ADD_PALETTE(BASIC::F021L1iD, 0x7F808080);
1806         ADD_PALETTE(BASIC::F022L1i, 0xFFB8B8B8);
1807         ADD_PALETTE(BASIC::F022L2i, 0xFF4C85C9);
1808         ADD_PALETTE(BASIC::F022L2iD, 0x4C4C85C9);
1809         ADD_PALETTE(BASIC::F031L1, 0xFF282828);
1810         ADD_PALETTE(BASIC::F031L1P, 0xFFFAFAFA);
1811         ADD_PALETTE(BASIC::F031L1D, 0x7F282828);
1812         ADD_PALETTE(BASIC::F031L2, 0x00000000);
1813         ADD_PALETTE(BASIC::F031L2P, 0x00000000);
1814         ADD_PALETTE(BASIC::F031L2D, 0x00000000);
1815         ADD_PALETTE(BASIC::F031L3, 0xFFFAFAFA);
1816         ADD_PALETTE(BASIC::F031L3P, 0xFFFAFAFA);
1817         ADD_PALETTE(BASIC::F031L3D, 0x7FFAFAFA);
1818         ADD_PALETTE(BASIC::F032L1, 0xFF282828);
1819         ADD_PALETTE(BASIC::F032L1P, 0xFFFAFAFA);
1820         ADD_PALETTE(BASIC::F032L1D, 0x7F282828);
1821         ADD_PALETTE(BASIC::F032L2, 0xFFFAFAFA);
1822         ADD_PALETTE(BASIC::F032L2P, 0xFFFAFAFA);
1823         ADD_PALETTE(BASIC::F032L2D, 0x7FFAFAFA);
1824         ADD_PALETTE(BASIC::F032L3, 0xFFF9F9F9);
1825         ADD_PALETTE(BASIC::F032L3P, 0xFFF9F9F9);
1826         ADD_PALETTE(BASIC::F041i, 0xFF808080);
1827         ADD_PALETTE(BASIC::F041iD, 0x7F808080);
1828         ADD_PALETTE(BASIC::F051, 0xFF90A9C7);
1829         ADD_PALETTE(BASIC::F052, 0xFF007BDB);
1830         ADD_PALETTE(BASIC::F053, 0xFF808080);
1831         ADD_PALETTE(BASIC::F053P, 0xFF000000);
1832         ADD_PALETTE(BASIC::F053D, 0x7F808080);
1833         ADD_PALETTE(BASIC::F054, 0xFFE3E1D9);
1834         ADD_PALETTE(BASIC::F055, 0xFF007BDA);
1835         ADD_PALETTE(BASIC::W011, 0xFFF7F5ED);
1836         ADD_PALETTE(BASIC::W011D, 0x7FF7F5ED);
1837         ADD_PALETTE(BASIC::W012, 0xFF0058D0);
1838         ADD_PALETTE(BASIC::W012D, 0x7F0058D0);
1839         ADD_PALETTE(BASIC::W012P, 0xFF0051BF);
1840         ADD_PALETTE(BASIC::W013, 0x00000000);
1841         ADD_PALETTE(BASIC::W0141, 0xFFC12C21);
1842         ADD_PALETTE(BASIC::W0141P, 0xFFC12C21);
1843         ADD_PALETTE(BASIC::W0141D, 0x7FC12C21);
1844         ADD_PALETTE(BASIC::W015, 0xFF343432);
1845         ADD_PALETTE(BASIC::W021L1, 0xFFF8F6EF);
1846         ADD_PALETTE(BASIC::W021L1P, 0xFF5787C2);
1847         ADD_PALETTE(BASIC::W021L2, 0xFF0E68AD);
1848         ADD_PALETTE(BASIC::W021L2P, 0xFFFAFAFA);
1849         ADD_PALETTE(BASIC::W021L3, 0xFF0E68AD);
1850         ADD_PALETTE(BASIC::W021L3P, 0xFFFAFAFA);
1851         ADD_PALETTE(BASIC::W021L4, 0xFF000000);
1852         ADD_PALETTE(BASIC::W031L1, 0xFFFAFAFA);
1853         ADD_PALETTE(BASIC::W031L1D, 0x7FFAFAFA);
1854         ADD_PALETTE(BASIC::W031L2, 0xFFFAFAFA);
1855         ADD_PALETTE(BASIC::W031L2D, 0x7FFAFAFA);
1856         ADD_PALETTE(BASIC::W032, 0xFF878580);
1857         ADD_PALETTE(BASIC::W032P, 0xFF000000);
1858         ADD_PALETTE(BASIC::W032D, 0x7F878580);
1859         ADD_PALETTE(BASIC::W041, 0xFF17191C);
1860         ADD_PALETTE(BASIC::W051, 0xFF000000);
1861         ADD_PALETTE(BASIC::W0611, 0xFF3B73B6);
1862         ADD_PALETTE(BASIC::W0611P, 0xFFFAFAFA);
1863         ADD_PALETTE(BASIC::W0611D, 0x7F3B73B6);
1864         ADD_PALETTE(BASIC::W062L1, 0xFFC5C5C5);
1865         ADD_PALETTE(BASIC::W062L1D, 0x4CC5C5C5);
1866         ADD_PALETTE(BASIC::W062L2, 0xFF007DDE);
1867         ADD_PALETTE(BASIC::W062L2D, 0x7F007DDE);
1868         ADD_PALETTE(BASIC::W062L3, 0xFF615F5B);
1869         ADD_PALETTE(BASIC::W062L3D, 0x4C615F5B);
1870         ADD_PALETTE(BASIC::W062L4, 0xFF70A9EE);
1871         ADD_PALETTE(BASIC::W062L4D, 0x4C70A9EE);
1872         ADD_PALETTE(BASIC::W062L5, 0xFF223148);
1873         ADD_PALETTE(BASIC::W0631, 0xFF656565);
1874         ADD_PALETTE(BASIC::W0632, 0xFFFAFAFA);
1875         ADD_PALETTE(BASIC::W0641, 0xFFF7F5ED);
1876         ADD_PALETTE(BASIC::W0641P, 0xFF0079D4);
1877         ADD_PALETTE(BASIC::W0641D, 0x7FF7F5ED);
1878         ADD_PALETTE(BASIC::W0651, 0xFFBFBFBF);
1879         ADD_PALETTE(BASIC::W0711, 0xFF6C90BC);
1880         ADD_PALETTE(BASIC::W0711P, 0xFF007AD8);
1881         ADD_PALETTE(BASIC::W0711D, 0xFF607DA1);
1882         ADD_PALETTE(BASIC::W0712, 0x00000000);
1883         ADD_PALETTE(BASIC::W0713, 0xFF4093F7);
1884         ADD_PALETTE(BASIC::W0714, 0x00000000);
1885         ADD_PALETTE(BASIC::W0715, 0xFF2889FF);
1886         ADD_PALETTE(BASIC::W0721, 0xFFFAFAFA);
1887         ADD_PALETTE(BASIC::W0721P, 0xFFFAFAFA);
1888         ADD_PALETTE(BASIC::W0721D, 0x99FAFAFA);
1889         ADD_PALETTE(BASIC::W0811, 0xFF5787C2);
1890         ADD_PALETTE(BASIC::W0812, 0x00000000);
1891         ADD_PALETTE(BASIC::W0813, 0xFF494949);
1892         ADD_PALETTE(BASIC::W082, 0x00000000);
1893         ADD_PALETTE(BASIC::W083, 0x00000000);
1894         ADD_PALETTE(BASIC::W084, 0xB2FAFAFA);
1895         ADD_PALETTE(BASIC::W084P, 0xFFFAFAFA);
1896         ADD_PALETTE(BASIC::W085, 0x00000000);
1897         ADD_PALETTE(BASIC::W091, 0xFF444444);
1898         ADD_PALETTE(BASIC::W092, 0xFFFFFFFF);
1899         ADD_PALETTE(BASIC::W101, 0xFF5893E4);
1900         ADD_PALETTE(BASIC::W111, 0xFFE7E5DE);
1901         ADD_PALETTE(BASIC::W112L1, 0xFFB4B4B4);
1902         ADD_PALETTE(BASIC::W112L2, 0xFFFFFFFF);
1903         ADD_PALETTE(BASIC::W1121, 0xFF000000);
1904         ADD_PALETTE(BASIC::W1122, 0xFF000000);
1905         ADD_PALETTE(BASIC::W1123, 0x4C000000);
1906         ADD_PALETTE(BASIC::W1211, 0x00000000);
1907         ADD_PALETTE(BASIC::W1212, 0x00000000);
1908         ADD_PALETTE(BASIC::W1221, 0x00000000);
1909         ADD_PALETTE(BASIC::W1222, 0x00000000);
1910         ADD_PALETTE(BASIC::W1223, 0x00000000);
1911         ADD_PALETTE(BASIC::W131, 0xFF959595);
1912         ADD_PALETTE(BASIC::W132, 0xFF5787C2);
1913         ADD_PALETTE(BASIC::W141, 0xFF808080);
1914         ADD_PALETTE(BASIC::W151, 0xFF95948F);
1915         ADD_PALETTE(BASIC::W152, 0xFF878787);
1916         ADD_PALETTE(BASIC::W153, 0xFF5787C2);
1917         ADD_PALETTE(BASIC::W154, 0xFFEFECE0);
1918         ADD_PALETTE(BASIC::W161, 0xFF007BDA);
1919 }
1920
1921 #undef ADD_PALETTE
1922
1923 void
1924 _ResourceManager::LoadDefaultPalette(void)
1925 {
1926 }
1927 void
1928 _ResourceManager::LoadPaletteInformation(const Tizen::Base::String& systemTheme)
1929 {
1930         if(systemTheme == L"black")
1931         {
1932                 LoadBlackPalette();
1933         }
1934         else if (systemTheme == L"white")
1935         {
1936                 LoadWhitePalette();
1937         }
1938         else if (systemTheme == L"default")
1939         {
1940                 LoadBlackPalette();
1941         }
1942         else
1943         {
1944                 SysAssert(0);
1945         }
1946 }
1947
1948 result
1949 _ResourceManager::LoadThemeInformation(String& systemTheme, String& userTheme)
1950 {
1951         AppId appId = _AppInfo::GetApplicationId();
1952         SysLog(NID_UI, "%ls" , appId.GetPointer());
1953         _PackageAppInfoImpl packageManager;
1954         packageManager.Construct(appId);
1955         String key = packageManager.GetAppFeature(L"UserDefinedTheme");
1956         if (!(key.IsEmpty()))
1957         {
1958                 SysLog(NID_UI, "custem theme %ls" , key.GetPointer());
1959                 userTheme = key;
1960         }
1961         key = packageManager.GetAppFeature(L"SystemTheme");
1962         if (key.IsEmpty())
1963         {
1964                 systemTheme = L"black";
1965         }
1966         else
1967         {
1968                 SysLog(NID_UI, "System  theme %ls" , key.GetPointer());
1969                 systemTheme = key;
1970                 systemTheme.ToLowerCase();
1971         }
1972         return E_SUCCESS;
1973 }
1974
1975 void
1976 _ResourceManager::GetThemeName(String& systemTheme, String& userTheme) const
1977 {
1978         systemTheme = __systemTheme;
1979         userTheme = __userTheme;
1980 }
1981
1982 void
1983 _ResourceManager::SetSystemColor(void)
1984 {
1985         void* handle =null;
1986         Color* pColor = null;
1987         Color* (*GetSystemColor)(const String&) = null;
1988
1989         handle = dlopen ("libosp-compat.so", RTLD_LAZY);
1990         if (!handle)
1991         {
1992                 return;
1993         }
1994         GetSystemColor = reinterpret_cast<Color*(*)(const String&)>(dlsym(handle, "_GetSystemColor"));
1995         if (dlerror() != NULL)
1996         {
1997                 goto CATCH;
1998         }
1999
2000         pColor = GetSystemColor(L"TITLE_TEXT");
2001         if (pColor != null)
2002         {
2003                 GET_COLOR_CONFIG(HEADER::TITLE_TEXT_NORMAL, *pColor);
2004         }
2005
2006         pColor = GetSystemColor(L"BODY_TEXT");
2007         if (pColor != null)
2008         {
2009                 GET_COLOR_CONFIG(BUTTON::TEXT_NORMAL, *pColor);
2010         }
2011
2012         pColor = GetSystemColor(L"FOREGROUND");
2013         if (pColor != null)
2014         {
2015                 GET_COLOR_CONFIG(BASIC::foreground, *pColor);
2016         }
2017
2018         pColor = GetSystemColor(L"BACKGROUND");
2019         if (pColor != null)
2020         {
2021                 GET_COLOR_CONFIG(BASIC::background, *pColor);
2022         }
2023
2024         pColor = GetSystemColor(L"LIST_BACKGROUND");
2025         if (pColor != null)
2026         {
2027                 GET_COLOR_CONFIG(FORM::BG_NORMAL, *pColor);
2028         }
2029
2030         pColor = GetSystemColor(L"FORM_BACKGROUND");
2031         if (pColor != null)
2032         {
2033                 GET_COLOR_CONFIG(FORM::BG_NORMAL, *pColor);
2034         }
2035
2036         pColor = GetSystemColor(L"FORM_GROUP_BACKGROUND");
2037         if (pColor != null)
2038         {
2039                 GET_COLOR_CONFIG(PANEL::GROUPED_STYLE_BG_NORMAL, *pColor);
2040         }
2041
2042         pColor = GetSystemColor(L"POPUP_BACKGROUND");
2043         if (pColor != null)
2044         {
2045                 GET_COLOR_CONFIG(POPUP::BG_NORMAL, *pColor);
2046         }
2047
2048         pColor = GetSystemColor(L"GROUP_ITEM_TEXT");
2049         if (pColor != null)
2050         {
2051                 GET_COLOR_CONFIG(CHECKBUTTON::TEXT_NORMAL, *pColor);
2052         }
2053
2054         pColor = GetSystemColor(L"LIST_ITEM_TEXT");
2055         if (pColor != null)
2056         {
2057                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_NORMAL, *pColor);
2058         }
2059
2060         pColor = GetSystemColor(L"LIST_ITEM_PRESSED_TEXT");
2061         if (pColor != null)
2062         {
2063                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_PRESSED, *pColor);
2064         }
2065
2066         pColor = GetSystemColor(L"LIST_ITEM_HIGHLIGHTED_TEXT");
2067         if (pColor != null)
2068         {
2069                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_HIGHLIGHTED, *pColor);
2070         }
2071
2072         //fall through
2073 CATCH:
2074         dlclose(handle);
2075         return;
2076 }
2077 bool
2078 _ResourceManager::GetDensityDirectory(const String& directoryName, float& scaleFactor)
2079 {
2080         float denominator = 0.0;
2081         float numerator = 0.0;
2082         if(!(directoryName.StartsWith(L"screen-density",0)))
2083         {
2084                 return false;
2085         }
2086
2087         if (__deviceDPI >= DPI_FOR_XHIGH)
2088         {
2089                 numerator = 9.0;
2090         }
2091         else if (__deviceDPI >= DPI_FOR_HIGH)
2092         {
2093                 numerator = 6.0;
2094         }
2095         else if (__deviceDPI >= DPI_FOR_MIDDLE)
2096         {
2097                 numerator = 4.0;
2098         }
2099         else if (__deviceDPI < DPI_FOR_MIDDLE && __deviceDPI > DPI_FOR_LOW)
2100         {
2101                 numerator = 3.0;
2102         }
2103         else
2104         {
2105                 return false;
2106         }
2107
2108         if(directoryName.Contains(L"xhigh"))
2109         {
2110                 denominator = 9.0;
2111         }
2112         else if(directoryName.Contains(L"high"))
2113         {
2114                 denominator = 6.0;
2115         }
2116         else if(directoryName.Contains(L"middle"))
2117         {
2118                 denominator = 4.0;
2119         }
2120         else if(directoryName.Contains(L"low"))
2121         {
2122                 denominator = 3.0;
2123         }
2124         else
2125         {
2126                 return false;
2127         }
2128
2129         scaleFactor = numerator / denominator;
2130         return true;
2131 }
2132
2133 bool
2134 _ResourceManager::GetResolutionDirectory(const String& directoryName, float& scaleFactor)
2135 {
2136         if(!(directoryName.Contains(L"0")))
2137         {
2138                 return false;
2139         }
2140
2141         int index = 0;
2142         if(directoryName.IndexOf(L"x", 0, index) != E_SUCCESS)
2143         {
2144                 return false;
2145         }
2146         String width = 0;
2147
2148         if(directoryName.SubString(0, index - 1, width))
2149         {
2150                 int denominatorInt = 0;
2151                 float denominator = 0;
2152                 float numerator = 0;
2153                 if(Integer::Parse(width, denominatorInt) == E_SUCCESS)
2154                 {
2155                         denominator = (float)denominatorInt;
2156                         numerator = __targetWidth;
2157                         scaleFactor = numerator / denominator;
2158                         return true;
2159                 }
2160         }
2161         return false;
2162 }
2163
2164 String
2165 _ResourceManager::FindImagePath(const String& fileName, int& foundFolderWidth, bool isCustom)
2166 {
2167         bool find = false;
2168         String fullName(L"");
2169         ResourceFallbackItem* pItem = null;
2170
2171         if(isCustom)
2172         {
2173                 String resDirectory = _AppInfo::GetAppRootPath() + L"res/themes/"+__userTheme;
2174                 if(__pFallbackList == null)
2175                 {
2176                         __pFallbackList = new (std::nothrow) ArrayListT<ResourceFallbackItem*>;
2177                         SysTryReturn(NID_UI, __pFallbackList, L"", E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
2178                         Directory dir;
2179                         result r = dir.Construct(resDirectory);
2180                         if (r == E_SUCCESS)
2181                         {
2182                                 DirEnumerator* pDirEnum = dir.ReadN();
2183                                 if (pDirEnum != null)
2184                                 {
2185                                         while (pDirEnum->MoveNext() == E_SUCCESS)
2186                                         {
2187                                                 DirEntry entry = pDirEnum->GetCurrentDirEntry();
2188                                                 if(entry.IsDirectory())
2189                                                 {
2190                                                         float scaleFactor = 0;
2191                                                         String directoryName = entry.GetName();
2192                                                         if(GetDensityDirectory(directoryName, scaleFactor))
2193                                                         {
2194                                                                 pItem = new (std::nothrow) ResourceFallbackItem;
2195                                                                 SysTryCatch(NID_UI, pItem, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
2196                                                                 pItem->scaleFactor = scaleFactor;
2197                                                                 pItem->directoryName = directoryName;
2198                                                                 __pFallbackList->Add(pItem);
2199                                                         }
2200                                                         else if(GetResolutionDirectory(directoryName, scaleFactor))
2201                                                         {
2202                                                                 pItem = new (std::nothrow) ResourceFallbackItem;
2203                                                                 SysTryCatch(NID_UI, pItem, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
2204                                                                 pItem->scaleFactor = scaleFactor;
2205                                                                 pItem->directoryName = directoryName;
2206                                                                 __pFallbackList->Add(pItem);
2207                                                         }
2208                                                 }
2209                                         }
2210                                         ResourceFallbackItemComparer<ResourceFallbackItem*> comparer;
2211                                         __pFallbackList->Sort(comparer);
2212                                         delete pDirEnum;
2213                                 }
2214                                 for(int i = 0 ; i < __pFallbackList->GetCount() ; i++)
2215                                 {
2216                                         ResourceFallbackItem* pItem;
2217                                         if(__pFallbackList->GetAt(i,pItem) == E_SUCCESS)
2218                                         {
2219                                                 if(pItem->scaleFactor < 1.001 && pItem->scaleFactor > 0.999)
2220                                                 {
2221                                                         __pFallbackList->RemoveAt(i);
2222                                                         __pFallbackList->InsertAt(pItem,0);
2223                                                         if(pItem->directoryName.Contains(L"0"))
2224                                                         {
2225                                                                 break;
2226                                                         }
2227                                                 }
2228                                         }
2229                                 }
2230                         }
2231                 }
2232                 for(int i = 0 ; i <__pFallbackList->GetCount() ; i++)
2233                 {
2234                         ResourceFallbackItem* pItem;
2235                         __pFallbackList->GetAt(i,pItem);
2236                         fullName = resDirectory + L"/" + pItem->directoryName + L"/" + fileName;
2237                         if (File::IsFileExist(fullName))
2238                         {
2239                                 find = true;
2240                                 foundFolderWidth = __targetWidth / pItem->scaleFactor;
2241                                 if(foundFolderWidth > __targetWidth)
2242                                 {
2243                                         if( foundFolderWidth < __targetWidth + 3)
2244                                         {
2245                                                 foundFolderWidth = __targetWidth;
2246                                         }
2247                                 }
2248                                 else
2249                                 {
2250                                         if( foundFolderWidth >__targetWidth - 3)
2251                                         {
2252                                                 foundFolderWidth = __targetWidth;
2253                                         }
2254                                 }
2255                                 break;
2256                         }
2257                 }
2258         }
2259         if(!find)
2260         {
2261                 fullName = String(L"/usr/share/osp/bitmaps/" + __targetPortraitMode+ "/" + __systemTheme + L"/" + fileName);
2262                 if (File::IsFileExist(fullName))
2263                 {
2264                         find = true;
2265                         foundFolderWidth = __targetWidth;
2266                 }
2267                 else
2268                 {
2269                         fullName = String(L"/usr/share/osp/bitmaps/" + __defaultPortraitMode+ "/" + __systemTheme + L"/" + fileName);
2270                         if (File::IsFileExist(fullName))
2271                         {
2272                                 find = true;
2273                                 foundFolderWidth = DEFAULT_SCREEN_WIDTH;
2274                         }
2275                 }
2276         }
2277
2278         if(!find)
2279         {
2280                 fullName = String(L"/usr/share/osp/bitmaps/" + __targetPortraitMode + "/" + fileName);
2281                 if (File::IsFileExist(fullName))
2282                 {
2283                         find = true;
2284                         foundFolderWidth = __targetWidth;
2285                 }
2286                 else
2287                 {
2288                         fullName = String(L"/usr/share/osp/bitmaps/" + __defaultPortraitMode+ "/" + fileName);
2289                         if (File::IsFileExist(fullName))
2290                         {
2291                                 find = true;
2292                                 foundFolderWidth = DEFAULT_SCREEN_WIDTH;
2293                         }
2294                 }
2295         }
2296
2297         if(!find)
2298         {
2299                 return L"";
2300         }
2301         else
2302         {
2303                 return fullName;
2304         }
2305 CATCH:
2306         if(__pFallbackList)
2307         {
2308                 ResourceFallbackItem* pItem = null;
2309                 int count = __pFallbackList->GetCount();
2310                 for (int i = 0; i < count; i++)
2311                 {
2312                         __pFallbackList->GetAt(i, pItem);
2313                         delete pItem;
2314                 }
2315                 __pFallbackList->RemoveAll();
2316                 delete __pFallbackList;
2317                 __pFallbackList = null;
2318         }
2319         return L"";
2320 }
2321
2322 bool
2323 _ResourceManager::IsFeedbackPlayed(void)
2324 {
2325         if (__feedbackStatus == _RESOURCE_FEEDBACK_STATUS_INIT)
2326         {
2327                 return false;
2328         }
2329         return true;
2330 }
2331
2332 void
2333 _ResourceManager::AcquireFeedback(void)
2334 {
2335         ++__feedbackAcquireCount;
2336 }
2337
2338 void
2339 _ResourceManager::ReleaseFeedback(void)
2340 {
2341         __feedbackAcquireCount >0 ? --__feedbackAcquireCount : __feedbackAcquireCount = 0;
2342         if(__feedbackAcquireCount == 0)
2343         {
2344                 __feedbackStatus = _RESOURCE_FEEDBACK_STATUS_INIT;
2345         }
2346 }
2347 void
2348 _ResourceManager::ResetFeedback(void)
2349 {
2350         __feedbackAcquireCount = 0;
2351         __feedbackStatus = _RESOURCE_FEEDBACK_STATUS_INIT;
2352 }
2353 Dimension
2354 _ResourceManager::GetLogicalScreenSizen(void)
2355 {
2356         return Dimension(__logicalWidth, __logicalHeight);
2357 }
2358 }}//Tizen::Ui