src/graphics/FGrp_CoordinateSystemImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /*
  19  * @file        FGrp_CoordinateSystemImpl.cpp
  20  * @brief       This is the implementation file for _CoordinateSystemImpl class.
  21  *
  22  */
  23
  24 #include <new>
  25
  26 #include <FBaseResult.h>
  27 #include <FBaseString.h>
  28
  29 #include <FBaseInternalTypes.h>
  30 #include <FApp_AppInfo.h>
  31 #include <FBaseSysLog.h>
  32 #include <FSys_SystemInfoImpl.h>
  33
  34 #include "FGrp_Screen.h"
  35 #include "FGrp_CoordinateSystemImpl.h"
  36
  37
  38 using namespace Tizen::Base;
  39
  40 ////////////////////////////////////////////////////////////////////////////////
  41
  42 namespace Tizen { namespace Graphics
  43 {
  44 result _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, const Dimension& srcDim, const Dimension& trgDim);
  45 result _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, _LogicalResolution sourceLogicalResolution, _BaseScreenSize sourceLogicalBaseScreenSize, _PhysicalResolution destPhysicalResolution, _BaseScreenSize destPhysicalBaseScreenSize);
  46 result _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, _PhysicalResolution sourcePhysicalResolution, _BaseScreenSize sourcePhysicalBaseScreenSize, _LogicalResolution destLogicalResolution, _BaseScreenSize destLogicalBaseScreenSize);
  47 result _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, _LogicalResolution sourceLogicalResolution, _BaseScreenSize sourceLogicalBaseScreenSize, _LogicalResolution destLogicalResolution, _BaseScreenSize destLogicalBaseScreenSize);
  48 result _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize);
  49
  50 bool _WillNotTransform(_LogicalResolution logicalResolution, _BaseScreenSize logicalBaseScreenSize, _PhysicalResolution physicalResolution, _BaseScreenSize physicalBaseScreenSize);
  51 bool _WillNotTransform(int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize);
  52 const char* _GetStringResolution(_LogicalResolution res);
  53 const char* _GetStringResolution(_PhysicalResolution res);
  54
  55 }} // Tizen::Graphics
  56
  57 ////////////////////////////////////////////////////////////////////////////////
  58
  59 namespace Tizen { namespace Graphics
  60 {
  61
  62 class _CoordinateSystem::_CoordinateSystemImpl::__CoordinateTransformer
  63         : public _ICoordinateSystemTransformer
  64 {
  65 public:
  66         __CoordinateTransformer(_ICoordinateSystemTransformer* pXformer)
  67                 : __enabled(true)
  68                 , __pXformer(pXformer)
  69                 , __defaultTransformer()
  70                 , __usingDefault(false)
  71         {
  72                 if (__pXformer == null)
  73                 {
  74                         __pXformer = &__defaultTransformer;
  75                         __usingDefault = true;
  76                 }
  77         }
  78
  79         virtual ~__CoordinateTransformer()
  80         {
  81                 if (!__usingDefault)
  82                 {
  83                         delete __pXformer;
  84                 }
  85         }
  86
  87         void SetEnabled(bool enabled)
  88         {
  89                 __enabled = enabled;
  90         }
  91
  92         bool IsEnabled(void) const
  93         {
  94                 return __enabled;
  95         }
  96
  97         virtual Rectangle Transform(const Rectangle& rect) const
  98         {
  99                 return IsEnabled() ? __pXformer->Transform(rect) : rect;
 100         }
 101
 102         virtual Dimension Transform(const Dimension& dim) const
 103         {
 104                 return IsEnabled() ? __pXformer->Transform(dim) : dim;
 105         }
 106
 107         virtual Point Transform(const Point& point) const
 108         {
 109                 return IsEnabled() ? __pXformer->Transform(point) : point;
 110         }
 111
 112         virtual int Transform(int scalar) const
 113         {
 114                 return IsEnabled() ? __pXformer->Transform(scalar) : scalar;
 115         }
 116
 117         virtual int TransformHorizontal(int scalar) const
 118         {
 119                 return IsEnabled() ? __pXformer->TransformHorizontal(scalar) : scalar;
 120         }
 121
 122         virtual int TransformVertical(int scalar) const
 123         {
 124                 return IsEnabled() ? __pXformer->TransformVertical(scalar) : scalar;
 125         }
 126
 127         virtual float Transform(float scalar) const
 128         {
 129                 return IsEnabled() ? __pXformer->Transform(scalar) : scalar;
 130         }
 131
 132         virtual float TransformHorizontal(float scalar) const
 133         {
 134                 return IsEnabled() ? __pXformer->TransformHorizontal(scalar) : scalar;
 135         }
 136
 137         virtual float TransformVertical(float scalar) const
 138         {
 139                 return IsEnabled() ? __pXformer->TransformVertical(scalar) : scalar;
 140         }
 141
 142         virtual int TransformFloatToInt(float scalar) const
 143         {
 144                 return IsEnabled() ? __pXformer->Transform(static_cast<int>(scalar)) : static_cast<int>(scalar);
 145         }
 146
 147         virtual int TransformHorizontalFloatToInt(float scalar) const
 148         {
 149                 return IsEnabled() ? __pXformer->TransformHorizontal(static_cast<int>(scalar)) : static_cast<int>(scalar);
 150         }
 151
 152         virtual int TransformVerticalFloatToInt(float scalar) const
 153         {
 154                 return IsEnabled() ? __pXformer->TransformVertical(static_cast<int>(scalar)) : static_cast<int>(scalar);
 155         }
 156
 157         virtual float GetHorizontalScaleFactor(void) const
 158         {
 159                 return IsEnabled() ? __pXformer->GetHorizontalScaleFactor() : 1.0f;
 160         }
 161
 162         virtual float GetVerticalScaleFactor(void) const
 163         {
 164                 return IsEnabled() ? __pXformer->GetVerticalScaleFactor() : 1.0f;
 165         }
 166
 167 private:
 168         __CoordinateTransformer(const __CoordinateTransformer&);
 169         __CoordinateTransformer& operator =(const __CoordinateTransformer&);
 170
 171 private:
 172         bool __enabled;
 173         _ICoordinateSystemTransformer* __pXformer;
 174         _NullCoordinateSystemTransformer __defaultTransformer;
 175         bool __usingDefault;
 176 }; // _CoordinateSystem
 177
 178 _LogicalResolution
 179 _CoordinateSystem::_CoordinateSystemImpl::GetNativeLogicalResolution(void) const
 180 {
 181         return __nativeLogicalResolution;
 182 }
 183
 184 _BaseScreenSize
 185 _CoordinateSystem::_CoordinateSystemImpl::GetNativeLogicalBaseScreenSize(void) const
 186 {
 187         return __nativeLogicalBaseScreenSize;
 188 }
 189
 190 _BaseScreenSize
 191 _CoordinateSystem::_CoordinateSystemImpl::GetLogicalBaseScreenSize(void) const
 192 {
 193         return __logicalBaseScreenSize;
 194 }
 195
 196 int
 197 _CoordinateSystem::_CoordinateSystemImpl::GetLogicalResolutionInt(void) const
 198 {
 199         return __logicalResolutionInt;
 200 }
 201
 202 _LogicalResolution
 203 _CoordinateSystem::_CoordinateSystemImpl::GetLogicalResolution(void) const
 204 {
 205         return __logicalResolution;
 206 }
 207
 208 _PhysicalResolution
 209 _CoordinateSystem::_CoordinateSystemImpl::GetPhysicalResolution(void) const
 210 {
 211         if (__physicalResolution == RESOLUTION_PHYSICAL_NONE)
 212         {
 213                 static Tizen::Graphics::_PhysicalResolution cachedResolution = RESOLUTION_PHYSICAL_NONE;
 214
 215                 if (cachedResolution == RESOLUTION_PHYSICAL_NONE)
 216                 {
 217                         int screenWidth = _Screen::GetWidth();
 218                         int screenHeight = _Screen::GetHeight();
 219
 220                         if ((screenWidth == 480 && screenHeight == 800) || (screenWidth == 800 && screenHeight == 480))
 221                         {
 222                                 cachedResolution = RESOLUTION_PHYSICAL_WVGA;
 223                         }
 224                         else if ((screenWidth == 240 && screenHeight == 400) || (screenWidth == 400 && screenHeight == 240))
 225                         {
 226                                 cachedResolution = RESOLUTION_PHYSICAL_WQVGA;
 227                         }
 228                         else if ((screenWidth == 320 && screenHeight == 480) || (screenWidth == 480 && screenHeight == 320))
 229                         {
 230                                 cachedResolution = RESOLUTION_PHYSICAL_HVGA;
 231                         }
 232                         else if ((screenWidth == 720 && screenHeight == 1280) || (screenWidth == 1280 && screenHeight == 720))
 233                         {
 234                                 cachedResolution = RESOLUTION_PHYSICAL_HD;
 235                         }
 236                         else if ((screenWidth == 1280 && screenHeight == 800) || (screenWidth == 800 && screenHeight == 1280))
 237                         {
 238                                 cachedResolution = RESOLUTION_PHYSICAL_WXGA;
 239                         }
 240                         else if ((screenWidth == 1080 && screenHeight == 1920) || (screenWidth == 1920 && screenHeight == 1080))
 241                         {
 242                                 cachedResolution = RESOLUTION_PHYSICAL_HD1080;
 243                         }
 244                         else if ((screenWidth == 1600 && screenHeight == 2560) || (screenWidth == 2560 && screenHeight == 1600))
 245                         {
 246                                 cachedResolution = RESOLUTION_PHYSICAL_WQXGA;
 247                         }
 248                         else
 249                         {
 250                                 cachedResolution = RESOLUTION_PHYSICAL_NONE;
 251                         }
 252                 }
 253
 254                 return cachedResolution;
 255         }
 256
 257         return __physicalResolution;
 258 }
 259
 260 Dimension
 261 _CoordinateSystem::_CoordinateSystemImpl::GetPhysicalResolutionDim(void) const
 262 {
 263         return __physicalResolutionDim;
 264 }
 265
 266 _BaseScreenSize
 267 _CoordinateSystem::_CoordinateSystemImpl::GetPhysicalBaseScreenSize(void) const
 268 {
 269         if (__physicalBaseScreenSize == BASE_SCREEN_SIZE_NONE || __physicalBaseScreenSize == BASE_SCREEN_SIZE_DEFAULT)
 270         {
 271                 static Tizen::Graphics::_BaseScreenSize physicalBaseScreenSize = BASE_SCREEN_SIZE_NONE;
 272
 273                 bool isLargeDeviceScreenSize = false;
 274
 275                 Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/screen.size.large", isLargeDeviceScreenSize);
 276
 277                 if (isLargeDeviceScreenSize)
 278                 {
 279                         physicalBaseScreenSize = BASE_SCREEN_SIZE_LARGE;
 280                 }
 281                 else
 282                 {
 283                         physicalBaseScreenSize = BASE_SCREEN_SIZE_NORMAL;
 284                 }
 285
 286                 return physicalBaseScreenSize;
 287         }
 288
 289         return __physicalBaseScreenSize;
 290 }
 291
 292 void
 293 _CoordinateSystem::_CoordinateSystemImpl::SetTransformEnabled(bool enabled)
 294 {
 295         __pTransformer->SetEnabled(enabled);
 296         __pInverseTransformer->SetEnabled(enabled);
 297 }
 298
 299 bool
 300 _CoordinateSystem::_CoordinateSystemImpl::IsTransformEnabled(void) const
 301 {
 302         return __pTransformer->IsEnabled();
 303 }
 304
 305
 306 _ICoordinateSystemTransformer*
 307 _CoordinateSystem::_CoordinateSystemImpl::GetTransformer(void)
 308 {
 309         return __pTransformer;
 310 }
 311
 312 _ICoordinateSystemTransformer*
 313 _CoordinateSystem::_CoordinateSystemImpl::GetInverseTransformer(void)
 314 {
 315         return __pInverseTransformer;
 316 }
 317
 318 _ICoordinateSystemTransformer*
 319 _CoordinateSystem::_CoordinateSystemImpl::GetTransformerN(const Dimension& srcDim, const Dimension& trgDim)
 320 {
 321         ClearLastResult();
 322
 323         _ICoordinateSystemTransformer* pXFormer = null;
 324
 325         result r = _CreateCoordinateTransformer(pXFormer, srcDim, trgDim);
 326
 327         if (IsFailed(r))
 328         {
 329                 SysLog(NID_GRP, "[%s] Propagating.", GetErrorMessage(r));
 330
 331                 SetLastResult(r);
 332         }
 333
 334         return pXFormer;
 335 }
 336
 337 _ICoordinateSystemTransformer*
 338 _CoordinateSystem::_CoordinateSystemImpl::GetTransformerN(_LogicalResolution logicalResolution, _BaseScreenSize logicalBaseScreenSize, _PhysicalResolution physicalResolution, _BaseScreenSize physicalBaseScreenSize)
 339 {
 340         ClearLastResult();
 341
 342         _ICoordinateSystemTransformer* pXFormer = null;
 343
 344         result r = _CreateCoordinateTransformer(pXFormer, logicalResolution, logicalBaseScreenSize, physicalResolution, physicalBaseScreenSize);
 345
 346         if (IsFailed(r))
 347         {
 348                 SysLog(NID_GRP, "[%s] Propagating.", GetErrorMessage(r));
 349
 350                 SetLastResult(r);
 351         }
 352
 353         return pXFormer;
 354 }
 355
 356 _ICoordinateSystemTransformer*
 357 _CoordinateSystem::_CoordinateSystemImpl::GetTransformerN(int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize)
 358 {
 359         ClearLastResult();
 360
 361         _ICoordinateSystemTransformer* pXFormer = null;
 362
 363         result r = _CreateCoordinateTransformer(pXFormer, srcResolution, srcBaseScreenSize, destResolution, destBaseScreenSize);
 364
 365         if (IsFailed(r))
 366         {
 367                 SysLog(NID_GRP, "[%s] Propagating.", GetErrorMessage(r));
 368
 369                 SetLastResult(r);
 370         }
 371
 372         return pXFormer;
 373 }
 374
 375 result
 376 _CoordinateSystem::_CoordinateSystemImpl::Initialize(_LogicalResolution logicalResolution, _BaseScreenSize logicalBaseScreenSize)
 377 {
 378         SysAssert(__pTransformer == null && __pInverseTransformer == null);
 379
 380         result r = E_SUCCESS;
 381
 382         __physicalBaseScreenSize = GetPhysicalBaseScreenSize();
 383
 384         SysAssert(__physicalBaseScreenSize != BASE_SCREEN_SIZE_DEFAULT);
 385
 386         __physicalResolution = GetPhysicalResolution();
 387
 388         SysAssert(__physicalResolution != RESOLUTION_PHYSICAL_DEFAULT);
 389
 390         if (logicalResolution == RESOLUTION_LOGICAL_DEFAULT)
 391         {
 392                 switch (__physicalResolution)
 393                 {
 394                 case RESOLUTION_PHYSICAL_WVGA:
 395                         logicalResolution = RESOLUTION_LOGICAL_480;
 396                         break;
 397                 case RESOLUTION_PHYSICAL_WQVGA:
 398                         logicalResolution = RESOLUTION_LOGICAL_240;
 399                         break;
 400                 case RESOLUTION_PHYSICAL_HVGA:
 401                         logicalResolution = RESOLUTION_LOGICAL_320;
 402                         break;
 403                 case RESOLUTION_PHYSICAL_HD:
 404                         logicalResolution = RESOLUTION_LOGICAL_720;
 405                         break;
 406                 case RESOLUTION_PHYSICAL_WXGA:
 407                         logicalResolution = RESOLUTION_LOGICAL_800;
 408                         break;
 409                 case RESOLUTION_PHYSICAL_HD1080:
 410                         logicalResolution = RESOLUTION_LOGICAL_1080;
 411                         break;
 412                 case RESOLUTION_PHYSICAL_WQXGA:
 413                         logicalResolution = RESOLUTION_LOGICAL_1600;
 414                         break;
 415                 default:
 416                         ;
 417                         break;
 418                 }
 419         }
 420
 421         __logicalResolution = logicalResolution;
 422
 423         if (logicalBaseScreenSize == BASE_SCREEN_SIZE_DEFAULT)
 424         {
 425                 logicalBaseScreenSize = BASE_SCREEN_SIZE_NORMAL;
 426         }
 427
 428         __logicalBaseScreenSize = logicalBaseScreenSize;
 429
 430         _ICoordinateSystemTransformer* pXformer = null;
 431         _ICoordinateSystemTransformer* pInvXFormer = null;
 432
 433         r = _CreateCoordinateTransformer(pXformer, __logicalResolution, __logicalBaseScreenSize, __physicalResolution, __physicalBaseScreenSize);
 434
 435         if (IsFailed(r))
 436         {
 437                 SysLog(NID_GRP, "[%s] Propagating.", GetErrorMessage(r));
 438
 439                 return r;
 440         }
 441
 442         __pTransformer = new (std::nothrow) __CoordinateTransformer(pXformer);
 443
 444         if (__pTransformer == null)
 445         {
 446                 delete pXformer;
 447                 r = E_OUT_OF_MEMORY;
 448                 SysLog(NID_GRP, "[%s] Failed to create a coordinate transformer.", GetErrorMessage(r));
 449
 450                 goto CATCH;
 451         }
 452
 453         r = _CreateCoordinateTransformer(pInvXFormer, __physicalResolution, __physicalBaseScreenSize, __logicalResolution, __logicalBaseScreenSize);
 454
 455         if (IsFailed(r))
 456         {
 457                 SysLog(NID_GRP, "[%s] Propagating.", GetErrorMessage(r));
 458
 459                 return r;
 460         }
 461
 462         __pInverseTransformer = new (std::nothrow) __CoordinateTransformer(pInvXFormer);
 463
 464         if (__pInverseTransformer == null)
 465         {
 466                 delete pInvXFormer;
 467                 r = E_OUT_OF_MEMORY;
 468                 SysLog(NID_GRP, "[%s] Failed to create an inverse coordinate transformer.", GetErrorMessage(r));
 469
 470                 goto CATCH;
 471         }
 472
 473         SysAssert(__pTransformer && __pInverseTransformer);
 474         SetTransformEnabled(!_WillNotTransform(__logicalResolution, __logicalBaseScreenSize, __physicalResolution, __physicalBaseScreenSize));
 475
 476 //temporary code
 477         __nativeLogicalResolution = logicalResolution;
 478         __nativeLogicalBaseScreenSize = logicalBaseScreenSize;
 479
 480         if (__nativeLogicalBaseScreenSize != __physicalBaseScreenSize)
 481         {
 482                 __nativeLogicalBaseScreenSize = __physicalBaseScreenSize;
 483
 484                 if (__nativeLogicalBaseScreenSize == BASE_SCREEN_SIZE_NORMAL)
 485                 {
 486                         switch (__nativeLogicalResolution)
 487                         {
 488                         case RESOLUTION_LOGICAL_1600:
 489                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_800;
 490                                 break;
 491                         case RESOLUTION_LOGICAL_1440:
 492                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_720;
 493                                 break;
 494                         case RESOLUTION_LOGICAL_960:
 495                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_480;
 496                                 break;
 497                         case RESOLUTION_LOGICAL_720:
 498                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_360;
 499                                 break;
 500                         case RESOLUTION_LOGICAL_480:
 501                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_240;
 502                                 break;
 503                         default:
 504                                 ;
 505                                 break;
 506                         }
 507                 }
 508                 else if (__nativeLogicalBaseScreenSize == BASE_SCREEN_SIZE_LARGE)
 509                 {
 510                         switch (__nativeLogicalResolution)
 511                         {
 512                         case RESOLUTION_LOGICAL_800:
 513                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_1600;
 514                                 break;
 515                         case RESOLUTION_LOGICAL_720:
 516                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_1440;
 517                                 break;
 518                         case RESOLUTION_LOGICAL_480:
 519                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_960;
 520                                 break;
 521                         case RESOLUTION_LOGICAL_360:
 522                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_720;
 523                                 break;
 524                         case RESOLUTION_LOGICAL_240:
 525                                 __nativeLogicalResolution = RESOLUTION_LOGICAL_480;
 526                                 break;
 527                         default:
 528                                 ;
 529                                 break;
 530                         }
 531                 }
 532         }
 533
 534         return r;
 535
 536 CATCH:
 537         delete __pTransformer;
 538         __pTransformer = null;
 539         delete __pInverseTransformer;
 540         __pInverseTransformer = null;
 541
 542         return r;
 543 }
 544
 545 result
 546 _CoordinateSystem::_CoordinateSystemImpl::Initialize(int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize)
 547 {
 548         SysAssert(__pTransformer == null && __pInverseTransformer == null);
 549
 550         result r = E_SUCCESS;
 551
 552         if (srcBaseScreenSize == BASE_SCREEN_SIZE_DEFAULT)
 553         {
 554                 srcBaseScreenSize = GetPhysicalBaseScreenSize();
 555         }
 556
 557         __logicalBaseScreenSize = srcBaseScreenSize;
 558
 559         __physicalResolutionDim = destResolution;
 560
 561         if (srcResolution != 0)
 562         {
 563                 __logicalResolutionInt = srcResolution;
 564         }
 565         else
 566         {
 567                 __logicalResolutionInt = __physicalResolutionDim.width < __physicalResolutionDim.height ? __physicalResolutionDim.width : __physicalResolutionDim.height;
 568         }
 569
 570         SysAssert(__logicalResolutionInt > 0);
 571
 572         if (destBaseScreenSize == BASE_SCREEN_SIZE_DEFAULT)
 573         {
 574                 destBaseScreenSize = GetPhysicalBaseScreenSize();
 575         }
 576
 577         __physicalBaseScreenSize = destBaseScreenSize;
 578
 579         if (srcResolution == 480 || srcResolution == 720)
 580         {
 581                 _LogicalResolution logicalResolution = RESOLUTION_LOGICAL_NONE;
 582
 583                 if (srcResolution == 480)
 584                 {
 585                         logicalResolution = RESOLUTION_LOGICAL_480;
 586                 }
 587                 else
 588                 {
 589                         logicalResolution = RESOLUTION_LOGICAL_720;
 590                 }
 591
 592                 Dimension wvgaDim1 = Dimension(480, 800);
 593                 Dimension wvgaDim2 = Dimension(800, 480);
 594                 Dimension hdDim1 = Dimension(720, 1280);
 595                 Dimension hdDim2 = Dimension(1280, 720);
 596
 597                 _PhysicalResolution physicalResolution = RESOLUTION_PHYSICAL_NONE;
 598
 599                 if (destResolution == wvgaDim1 || destResolution == wvgaDim2 || destResolution == hdDim1 || destResolution == hdDim2)
 600                 {
 601                         if (destResolution == wvgaDim1 || destResolution == wvgaDim2)
 602                         {
 603                                 physicalResolution = RESOLUTION_PHYSICAL_WVGA;
 604                         }
 605                         else
 606                         {
 607                                 physicalResolution = RESOLUTION_PHYSICAL_HD;
 608                         }
 609                 }
 610
 611                 if (physicalResolution == GetPhysicalResolution() && physicalResolution != RESOLUTION_PHYSICAL_NONE)
 612                 {
 613                         result r = Initialize(logicalResolution, srcBaseScreenSize);
 614
 615                         SysTryReturn(NID_GRP, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 616
 617                         return r;
 618                 }
 619         }
 620
 621         _ICoordinateSystemTransformer* pXformer = null;
 622         _ICoordinateSystemTransformer* pInvXFormer = null;
 623
 624         r = _CreateCoordinateTransformer(pXformer, __logicalResolutionInt, __logicalBaseScreenSize, __physicalResolutionDim, __physicalBaseScreenSize);
 625
 626         if (IsFailed(r))
 627         {
 628                 SysLog(NID_GRP, "[%s] Propagating.", GetErrorMessage(r));
 629
 630                 return r;
 631         }
 632
 633         __pTransformer = new (std::nothrow) __CoordinateTransformer(pXformer);
 634
 635         if (__pTransformer == null)
 636         {
 637                 delete pXformer;
 638                 r = E_OUT_OF_MEMORY;
 639                 SysLog(NID_GRP, "[%s] Failed to create a coordinate transformer.", GetErrorMessage(r));
 640
 641                 goto CATCH;
 642         }
 643
 644         r = _CreateCoordinateTransformer(pInvXFormer, (__physicalResolutionDim.width < __physicalResolutionDim.height ? __physicalResolutionDim.width : __physicalResolutionDim.height), __physicalBaseScreenSize, Dimension(__logicalResolutionInt, __logicalResolutionInt), __logicalBaseScreenSize);
 645
 646         if (IsFailed(r))
 647         {
 648                 SysLog(NID_GRP, "[%s] Propagating.", GetErrorMessage(r));
 649
 650                 return r;
 651         }
 652
 653         __pInverseTransformer = new (std::nothrow) __CoordinateTransformer(pInvXFormer);
 654
 655         if (__pInverseTransformer == null)
 656         {
 657                 delete pInvXFormer;
 658                 r = E_OUT_OF_MEMORY;
 659                 SysLog(NID_GRP, "[%s] Failed to create an inverse coordinate transformer.", GetErrorMessage(r));
 660
 661                 goto CATCH;
 662         }
 663
 664         SysAssert(__pTransformer && __pInverseTransformer);
 665         SetTransformEnabled(!_WillNotTransform(srcResolution, srcBaseScreenSize, destResolution, destBaseScreenSize));
 666
 667         return r;
 668
 669 CATCH:
 670         delete __pTransformer;
 671         __pTransformer = null;
 672         delete __pInverseTransformer;
 673         __pInverseTransformer = null;
 674
 675         return r;
 676 }
 677
 678 _CoordinateSystem::_CoordinateSystemImpl::_CoordinateSystemImpl(void)
 679         : __pTransformer(null)
 680         , __pInverseTransformer(null)
 681         , __nativeLogicalResolution(RESOLUTION_LOGICAL_NONE)
 682         , __nativeLogicalBaseScreenSize(BASE_SCREEN_SIZE_NONE)
 683         , __logicalResolution(RESOLUTION_LOGICAL_NONE)
 684         , __logicalBaseScreenSize(BASE_SCREEN_SIZE_NONE)
 685         , __physicalResolution(RESOLUTION_PHYSICAL_NONE)
 686         , __physicalBaseScreenSize(BASE_SCREEN_SIZE_NONE)
 687         , __logicalResolutionInt(0)
 688         , __physicalResolutionDim(0, 0)
 689 {
 690 }
 691
 692 _CoordinateSystem::_CoordinateSystemImpl::~_CoordinateSystemImpl(void)
 693 {
 694         delete __pTransformer;
 695         delete __pInverseTransformer;
 696 }
 697
 698 }} // Tizen::Graphics