src/graphics/FGrp_CoordinateSystemDeviceSpec.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_CoordinateSystemDeviceSpec.cpp
  20  * @brief       This is the implementation file for the internal class.
  21  *
  22  */
  23
  24 #include <new>
  25
  26 #include <FBaseErrors.h>
  27
  28 #include <FBaseInternalTypes.h>
  29 #include <FApp_AppInfo.h>
  30 #include <FBaseSysLog.h>
  31
  32 #include "FGrp_CoordinateSystem.h"
  33
  34
  35 using namespace Tizen::Base;
  36 using namespace Tizen::Graphics;
  37
  38
  39 namespace Tizen { namespace Graphics
  40 {
  41
  42 namespace _Internal
  43 {
  44
  45 template<int m, int n>
  46 struct Gcd
  47 {
  48         enum
  49         {
  50                 value = Gcd <n, m % n>::value
  51         };
  52 };
  53
  54 template<int m>
  55 struct Gcd <m, 0>
  56 {
  57         enum
  58         {
  59                 value = m
  60         };
  61 };
  62
  63 template<int simplSrc, int simplTrg>
  64 struct SimpleScaler
  65 {
  66         static int ScaleDisplacement(int srcVal);
  67         static int ScaleLength(int srcVal);
  68 };
  69
  70 template<int src, int trg>
  71 struct Scaler
  72 {
  73         enum
  74         {
  75                 gcd = Gcd <src, trg>::value,
  76                 simpleSrc = src / gcd,
  77                 simpleTrg = trg / gcd,
  78         };
  79
  80         static int ScaleDisplacement(int srcVal)
  81         {
  82                 return SimpleScaler <simpleSrc, simpleTrg>::ScaleDisplacement(srcVal);
  83         }
  84
  85         static int ScaleLength(int srcVal)
  86         {
  87                 return SimpleScaler <simpleSrc, simpleTrg>::ScaleLength(srcVal);
  88         }
  89 };
  90
  91 template<typename HScale, typename VScale>
  92 struct Transformer
  93         : public _ICoordinateSystemTransformer
  94 {
  95         Transformer()
  96         {
  97         }
  98
  99         virtual int TransformHorizontal(int width) const
 100         {
 101                 return HScale::ScaleLength(width);
 102         }
 103
 104         virtual int TransformVertical(int height) const
 105         {
 106                 return VScale::ScaleLength(height);
 107         }
 108
 109         virtual int Transform(int scalar) const
 110         {
 111                 return VScale::ScaleLength(scalar);
 112         }
 113
 114         virtual float TransformHorizontal(float width) const
 115         {
 116                 return GetHorizontalScaleFactor() * width;
 117         }
 118
 119         virtual float TransformVertical(float height) const
 120         {
 121                 return GetVerticalScaleFactor() * height;
 122         }
 123
 124         virtual float Transform(float scalar) const
 125         {
 126                 return GetVerticalScaleFactor() * scalar;
 127         }
 128
 129         virtual Point Transform(const Point& point) const
 130         {
 131                 return Point(HScale::ScaleDisplacement(point.x), VScale::ScaleDisplacement(point.y));
 132         }
 133
 134         virtual Dimension Transform(const Dimension& dim) const
 135         {
 136                 return Dimension(HScale::ScaleLength(dim.width), VScale::ScaleLength(dim.height));
 137         }
 138
 139         virtual Rectangle Transform(const Rectangle& rect) const
 140         {
 141                 int x = HScale::ScaleDisplacement(rect.x);
 142                 int y = VScale::ScaleDisplacement(rect.y);
 143                 int w = HScale::ScaleLength(rect.width);
 144                 int h = VScale::ScaleLength(rect.height);
 145
 146                 if (Tizen::App::_AppInfo::GetApiVersion() <= _API_VERSION_1_2)
 147                 {
 148                         // From Osp API 2.0, 'Adjacent Algorithm' is not used any more.
 149                         w = HScale::ScaleDisplacement(rect.x + rect.width) - x;
 150                         h = VScale::ScaleDisplacement(rect.y + rect.height) - y;
 151                 }
 152
 153                 return Rectangle(x, y, w, h);
 154         }
 155
 156         virtual int TransformFloatToInt(float scalar) const
 157         {
 158                 return VScale::ScaleLength(static_cast<int>(scalar));
 159         }
 160
 161         virtual int TransformHorizontalFloatToInt(float width) const
 162         {
 163                 return HScale::ScaleLength(static_cast<int>(width));
 164         }
 165
 166         virtual int TransformVerticalFloatToInt(float height) const
 167         {
 168                 return VScale::ScaleLength(static_cast<int>(height));
 169         }
 170
 171         virtual float GetHorizontalScaleFactor(void) const
 172         {
 173                 const int TEST_VALUE = 1000000;
 174                 return float(HScale::ScaleLength(TEST_VALUE)) / float(TEST_VALUE);
 175         }
 176
 177         virtual float GetVerticalScaleFactor(void) const
 178         {
 179                 const int TEST_VALUE = 1000000;
 180                 return float(VScale::ScaleLength(TEST_VALUE)) / float(TEST_VALUE);
 181         }
 182 };
 183
 184 template<>
 185 struct SimpleScaler <1, 2>
 186 {
 187         static int ScaleDisplacement(int srcVal)
 188         {
 189                 return srcVal << 1;
 190         }
 191
 192         static int ScaleLength(int srcVal)
 193         {
 194                 return srcVal << 1;
 195         }
 196 };
 197
 198 template<>
 199 struct SimpleScaler <2, 1>
 200 {
 201         static int ScaleDisplacement(int srcVal)
 202         {
 203                 return srcVal >> 1;
 204         }
 205
 206         static int ScaleLength(int srcVal)
 207         {
 208                 int isNotMinus = (srcVal >= 0);
 209
 210                 return (srcVal + 1 * isNotMinus) >> 1;
 211         }
 212 };
 213
 214 namespace // unnamed
 215 {
 216         const long long MAX_INT = 0x7FFFFFFF;
 217         const long long MIN_INT = -MAX_INT - 1;
 218 }
 219
 220 template<>
 221 struct SimpleScaler <2, 3>
 222 {
 223         static int ScaleDisplacement(int srcVal)
 224         {
 225                 long long tempSrc = srcVal;
 226
 227                 if (tempSrc >= 0)
 228                 {
 229                         tempSrc = tempSrc * 3 / 2;
 230
 231                         return (tempSrc > MAX_INT) ? MAX_INT : int(tempSrc);
 232                 }
 233                 else
 234                 {
 235                         tempSrc = (tempSrc * 3 - 1) / 2;
 236
 237                         return (tempSrc < MIN_INT) ? MIN_INT : int(tempSrc);
 238                 }
 239         }
 240
 241         static int ScaleLength(int srcVal)
 242         {
 243                 long long tempSrc = srcVal;
 244
 245                 if (tempSrc >= 0)
 246                 {
 247                         tempSrc = tempSrc * 3 / 2;
 248
 249                         return (tempSrc > MAX_INT) ? MAX_INT : int(tempSrc);
 250                 }
 251                 else
 252                 {
 253                         tempSrc = (tempSrc * 3 - 1) / 2;
 254
 255                         return (tempSrc < MIN_INT) ? MIN_INT : int(tempSrc);
 256                 }
 257         }
 258 };
 259
 260 template<>
 261 struct SimpleScaler <3, 2>
 262 {
 263         static int ScaleDisplacement(int srcVal)
 264         {
 265                 long long tempSrc = srcVal;
 266
 267                 if (tempSrc > 0)
 268                 {
 269                         tempSrc = (tempSrc + 1) * 2 / 3;
 270
 271                         return (tempSrc > MAX_INT) ? MAX_INT : int(tempSrc);
 272                 }
 273                 else
 274                 {
 275                         tempSrc = tempSrc * 2 / 3;
 276
 277                         return (tempSrc < MIN_INT) ? MIN_INT : int(tempSrc);
 278                 }
 279         }
 280
 281         static int ScaleLength(int srcVal)
 282         {
 283                 long long tempSrc = srcVal;
 284
 285                 if (tempSrc > 0)
 286                 {
 287                         tempSrc = (tempSrc + 1) * 2 / 3;
 288
 289                         return (tempSrc > 0x7FFFFFFF) ? 0x7FFFFFFF : int(tempSrc);
 290                 }
 291                 else
 292                 {
 293                         tempSrc = tempSrc * 2 / 3;
 294
 295                         return (tempSrc < MIN_INT) ? MIN_INT : int(tempSrc);
 296                 }
 297         }
 298 };
 299
 300 template<>
 301 struct SimpleScaler <3, 4>
 302 {
 303         static int ScaleDisplacement(int srcVal)
 304         {
 305                 return (srcVal >= 0) ? (srcVal * 4 / 3) : ((srcVal * 4 - 1) / 3);
 306         }
 307
 308         static int ScaleLength(int srcVal)
 309         {
 310                 return (srcVal >= 0) ? (srcVal * 4 / 3) : ((srcVal * 4 - 1) / 3);
 311         }
 312 };
 313
 314 template<>
 315 struct SimpleScaler <4, 3>
 316 {
 317         static int ScaleDisplacement(int srcVal)
 318         {
 319                 return (srcVal > 0) ? ((srcVal + 1) * 3 / 4) : (srcVal * 3 / 4);
 320         }
 321
 322         static int ScaleLength(int srcVal)
 323         {
 324                 return (srcVal > 0) ? ((srcVal + 1) * 3 / 4) : (srcVal * 3 / 4);
 325         }
 326 };
 327
 328 template<>
 329 struct SimpleScaler <5, 6>
 330 {
 331         static int ScaleDisplacement(int srcVal)
 332         {
 333                 return (srcVal >= 0) ? (srcVal * 6 / 5) : ((srcVal * 6 - 1) / 5);
 334         }
 335
 336         static int ScaleLength(int srcVal)
 337         {
 338                 return (srcVal >= 0) ? (srcVal * 6 / 5) : ((srcVal * 6 - 1) / 5);
 339         }
 340 };
 341
 342 template<>
 343 struct SimpleScaler <6, 5>
 344 {
 345         static int ScaleDisplacement(int srcVal)
 346         {
 347                 return (srcVal > 0) ? ((srcVal + 1) * 5 / 6) : (srcVal * 5 / 6);
 348         }
 349
 350         static int ScaleLength(int srcVal)
 351         {
 352                 return (srcVal > 0) ? ((srcVal + 1) * 5 / 6) : (srcVal * 5 / 6);
 353         }
 354 };
 355
 356 template<>
 357 struct SimpleScaler <3, 5>
 358 {
 359         static int ScaleDisplacement(int srcVal)
 360         {
 361                 return (srcVal >= 0) ? (srcVal * 5 / 3) : ((srcVal * 5 - 1) / 3);
 362         }
 363
 364         static int ScaleLength(int srcVal)
 365         {
 366                 return (srcVal >= 0) ? (srcVal * 5 / 3) : ((srcVal * 5 - 1) / 3);
 367         }
 368 };
 369
 370 template<>
 371 struct SimpleScaler <5, 3>
 372 {
 373         static int ScaleDisplacement(int srcVal)
 374         {
 375                 return (srcVal > 0) ? ((srcVal + 1) * 3 / 5) : (srcVal * 3 / 5);
 376         }
 377
 378         static int ScaleLength(int srcVal)
 379         {
 380                 return (srcVal > 0) ? ((srcVal + 1) * 3 / 5) : (srcVal * 3 / 5);
 381         }
 382 };
 383
 384 template<>
 385 struct SimpleScaler <8, 9>
 386 {
 387         static int ScaleDisplacement(int srcVal)
 388         {
 389                 return (srcVal >= 0) ? (srcVal * 9 / 8) : ((srcVal * 9 - 1) / 8);
 390         }
 391
 392         static int ScaleLength(int srcVal)
 393         {
 394                 return (srcVal >= 0) ? (srcVal * 9 / 8) : ((srcVal * 9 - 1) / 8);
 395         }
 396 };
 397
 398 template<>
 399 struct SimpleScaler <9, 8>
 400 {
 401         static int ScaleDisplacement(int srcVal)
 402         {
 403                 return (srcVal > 0) ? ((srcVal + 1) * 8 / 9) : (srcVal * 8 / 9);
 404         }
 405
 406         static int ScaleLength(int srcVal)
 407         {
 408                 return (srcVal > 0) ? ((srcVal + 1) * 8 / 9) : (srcVal * 8 / 9);
 409         }
 410 };
 411
 412 template<>
 413 struct SimpleScaler <1, 3>
 414 {
 415         static int ScaleDisplacement(int srcVal)
 416         {
 417                 return (srcVal >= 0) ? (srcVal * 3 / 1) : ((srcVal * 3 - 1) / 1);
 418         }
 419
 420         static int ScaleLength(int srcVal)
 421         {
 422                 return (srcVal >= 0) ? (srcVal * 3 / 1) : ((srcVal * 3 - 1) / 1);
 423         }
 424 };
 425
 426 template<>
 427 struct SimpleScaler <3, 1>
 428 {
 429         static int ScaleDisplacement(int srcVal)
 430         {
 431                 return (srcVal > 0) ? ((srcVal + 1) * 1 / 3) : (srcVal * 1 / 3);
 432         }
 433
 434         static int ScaleLength(int srcVal)
 435         {
 436                 return (srcVal > 0) ? ((srcVal + 1) * 1 / 3) : (srcVal * 1 / 3);
 437         }
 438 };
 439
 440 template<>
 441 struct SimpleScaler <4, 9>
 442 {
 443         static int ScaleDisplacement(int srcVal)
 444         {
 445                 return (srcVal >= 0) ? (srcVal * 9 / 4) : ((srcVal * 9 - 1) / 4);
 446         }
 447
 448         static int ScaleLength(int srcVal)
 449         {
 450                 return (srcVal >= 0) ? (srcVal * 9 / 4) : ((srcVal * 9 - 1) / 4);
 451         }
 452 };
 453
 454 template<>
 455 struct SimpleScaler <9, 4>
 456 {
 457         static int ScaleDisplacement(int srcVal)
 458         {
 459                 return (srcVal > 0) ? ((srcVal + 1) * 4 / 9) : (srcVal * 4 / 9);
 460         }
 461
 462         static int ScaleLength(int srcVal)
 463         {
 464                 return (srcVal > 0) ? ((srcVal + 1) * 4 / 9) : (srcVal * 4 / 9);
 465         }
 466 };
 467
 468 } // _Internal
 469
 470
 471 result
 472 _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, const Dimension& srcDim, const Dimension& trgDim)
 473 {
 474         if (srcDim.width == 0 || srcDim.height == 0)
 475         {
 476                 return E_SYSTEM;
 477         }
 478
 479         struct _Scaler
 480         {
 481                 _Scaler(int src_, int trg_)
 482                         : src(src_)
 483                         , trg(trg_)
 484                 {
 485                 }
 486
 487                 int ScaleDisplacement(int srcVal) const
 488                 {
 489                         if (src > trg)
 490                         {
 491                                 return (srcVal > 0) ? ((srcVal + 1) * trg / src) : (srcVal * trg / src);
 492                         }
 493                         else if (src < trg)
 494                         {
 495                                 return (srcVal >= 0) ? (srcVal * trg / src) : ((srcVal * trg - 1) / src);
 496                         }
 497
 498                         return srcVal;
 499                 }
 500
 501                 int ScaleLength(int srcVal) const
 502                 {
 503                         return ScaleDisplacement(srcVal);
 504                 }
 505
 506                 int src;
 507                 int trg;
 508         };
 509
 510         class _Xformer
 511                 : public _ICoordinateSystemTransformer
 512         {
 513         public:
 514                 _Xformer(const Dimension& srcDim, const Dimension& trgDim)
 515                         : __scalerH(srcDim.width, trgDim.width)
 516                         , __scalerV(srcDim.height, trgDim.height)
 517                         , __scaleFactorH(trgDim.width * 1.0f / srcDim.width)
 518                         , __scaleFactorV(trgDim.height * 1.0f / srcDim.height)
 519                 {
 520                 }
 521
 522                 virtual int TransformHorizontal(int width) const
 523                 {
 524                         return __scalerH.ScaleLength(width);
 525                 }
 526
 527                 virtual int TransformVertical(int height) const
 528                 {
 529                         return __scalerV.ScaleLength(height);
 530                 }
 531
 532                 virtual int Transform(int scalar) const
 533                 {
 534                         return __scalerV.ScaleLength(scalar);
 535                 }
 536
 537                 virtual float TransformHorizontal(float width) const
 538                 {
 539                         return width * __scaleFactorH;
 540                 }
 541
 542                 virtual float TransformVertical(float height) const
 543                 {
 544                         return height * __scaleFactorV;
 545                 }
 546
 547                 virtual float Transform(float scalar) const
 548                 {
 549                         return scalar * __scaleFactorV;;
 550                 }
 551
 552                 virtual Point Transform(const Point& point) const
 553                 {
 554                         return Point(__scalerH.ScaleDisplacement(point.x), __scalerV.ScaleDisplacement(point.y));
 555                 }
 556
 557                 virtual Dimension Transform(const Dimension& dim) const
 558                 {
 559                         return Dimension(__scalerH.ScaleLength(dim.width), __scalerV.ScaleLength(dim.height));
 560                 }
 561
 562                 virtual Rectangle Transform(const Rectangle& rect) const
 563                 {
 564                         int x = __scalerH.ScaleDisplacement(rect.x);
 565                         int y = __scalerV.ScaleDisplacement(rect.y);
 566                         int w = __scalerH.ScaleLength(rect.width);
 567                         int h = __scalerV.ScaleLength(rect.height);
 568
 569                         return Rectangle(x, y, w, h);
 570                 }
 571
 572                 virtual int TransformFloatToInt(float scalar) const
 573                 {
 574                         return __scalerV.ScaleLength(static_cast<int>(scalar));
 575                 }
 576
 577                 virtual int TransformHorizontalFloatToInt(float width) const
 578                 {
 579                         return __scalerH.ScaleLength(static_cast<int>(width));
 580                 }
 581
 582                 virtual int TransformVerticalFloatToInt(float height) const
 583                 {
 584                         return __scalerV.ScaleLength(static_cast<int>(height));
 585                 }
 586
 587                 virtual float GetHorizontalScaleFactor(void) const
 588                 {
 589                         return __scaleFactorH;
 590                 }
 591
 592                 virtual float GetVerticalScaleFactor(void) const
 593                 {
 594                         return __scaleFactorV;
 595                 }
 596
 597         private:
 598                 _Scaler __scalerH;
 599                 _Scaler __scalerV;
 600
 601                 float __scaleFactorH;
 602                 float __scaleFactorV;
 603
 604         }; // _Xformer
 605
 606         pTransformer = new (std::nothrow) _Xformer(srcDim, trgDim);
 607
 608         return (pTransformer) ? E_SUCCESS : E_SYSTEM;
 609 }
 610
 611 }} // Tizen::Graphics
 612
 613
 614 namespace Tizen { namespace Graphics
 615 {
 616
 617 template<_LogicalResolution LogRes>
 618 struct LogResTraits
 619 {
 620 };
 621
 622 template<_PhysicalResolution PhyRes>
 623 struct PhyResTraits
 624 {
 625 };
 626
 627 template<_BaseScreenSize ScrRes>
 628 struct ScrResTraits
 629 {
 630 };
 631
 632 //_LogicalResolution
 633 template<>
 634 struct LogResTraits <RESOLUTION_LOGICAL_240>
 635 {
 636         enum { WIDTH = 240 };
 637 };
 638
 639 template<>
 640 struct LogResTraits <RESOLUTION_LOGICAL_320>
 641 {
 642         enum { WIDTH = 320 };
 643 };
 644
 645 template<>
 646 struct LogResTraits <RESOLUTION_LOGICAL_480>
 647 {
 648         enum { WIDTH = 480 };
 649 };
 650
 651 template<>
 652 struct LogResTraits <RESOLUTION_LOGICAL_720>
 653 {
 654         enum { WIDTH = 720 };
 655 };
 656
 657 template<>
 658 struct LogResTraits <RESOLUTION_LOGICAL_800>
 659 {
 660         enum { WIDTH = 800 };
 661 };
 662
 663 template<>
 664 struct LogResTraits <RESOLUTION_LOGICAL_1080>
 665 {
 666         enum { WIDTH = 1080 };
 667 };
 668
 669 template<>
 670 struct LogResTraits <RESOLUTION_LOGICAL_1600>
 671 {
 672         enum { WIDTH = 1600 };
 673 };
 674
 675 //_PhysicalResolution
 676 template<>
 677 struct PhyResTraits <RESOLUTION_PHYSICAL_WVGA>
 678 {
 679         enum { WIDTH = 480, HEIGHT = 800 };
 680 };
 681
 682 template<>
 683 struct PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>
 684 {
 685         enum { WIDTH = 240, HEIGHT = 400 };
 686 };
 687
 688 template<>
 689 struct PhyResTraits <RESOLUTION_PHYSICAL_HVGA>
 690 {
 691         enum { WIDTH = 320, HEIGHT = 480 };
 692 };
 693
 694 template<>
 695 struct PhyResTraits <RESOLUTION_PHYSICAL_HD>
 696 {
 697         enum { WIDTH = 720, HEIGHT = 1280 };
 698 };
 699
 700 //_BaseScreenSize
 701 template<>
 702 struct ScrResTraits <BASE_SCREEN_SIZE_NORMAL>
 703 {
 704         enum { WIDTH = 720 };
 705 };
 706
 707 template<>
 708 struct ScrResTraits <BASE_SCREEN_SIZE_LARGE>
 709 {
 710         enum { WIDTH = 1440 };
 711 };
 712
 713
 714 const char*
 715 _GetStringResolution(_LogicalResolution res)
 716 {
 717         switch (res)
 718         {
 719         case RESOLUTION_LOGICAL_DEFAULT:
 720                 return "DEFAULT";
 721         case RESOLUTION_LOGICAL_240:
 722                 return "240";
 723         case RESOLUTION_LOGICAL_320:
 724                 return "320";
 725         case RESOLUTION_LOGICAL_360:
 726                 return "360";
 727         case RESOLUTION_LOGICAL_480:
 728                 return "480";
 729         case RESOLUTION_LOGICAL_720:
 730                 return "720";
 731         case RESOLUTION_LOGICAL_800:
 732                 return "800";
 733         case RESOLUTION_LOGICAL_960:
 734                 return "960";
 735         case RESOLUTION_LOGICAL_1080:
 736                 return "1080";
 737         case RESOLUTION_LOGICAL_1440:
 738                 return "1440";
 739         case RESOLUTION_LOGICAL_1600:
 740                 return "1600";
 741         default:
 742                 return "Unknown resolution";
 743         }
 744 }
 745
 746 const char*
 747 _GetStringResolution(_PhysicalResolution res)
 748 {
 749         switch (res)
 750         {
 751         case RESOLUTION_PHYSICAL_DEFAULT:
 752                 return "DEFAULT";
 753         case RESOLUTION_PHYSICAL_WVGA:
 754                 return "WVGA";
 755         case RESOLUTION_PHYSICAL_WQVGA:
 756                 return "WQVGA";
 757         case RESOLUTION_PHYSICAL_HVGA:
 758                 return "HVGA";
 759         case RESOLUTION_PHYSICAL_HD:
 760                 return "HD";
 761         case RESOLUTION_PHYSICAL_HD1080:
 762                 return "HD1080";
 763         case RESOLUTION_PHYSICAL_WXGA:
 764                 return "WXGA";
 765         case RESOLUTION_PHYSICAL_WQXGA:
 766                 return "WQXGA";
 767         default:
 768                 return "Unknown resolution";
 769         }
 770 }
 771
 772
 773 const int
 774 _GetIntegerResolution(_LogicalResolution res)
 775 {
 776         switch (res)
 777         {
 778         case RESOLUTION_LOGICAL_240:
 779                 return 240;
 780         case RESOLUTION_LOGICAL_320:
 781                 return 320;
 782         case RESOLUTION_LOGICAL_360:
 783                 return 360;
 784         case RESOLUTION_LOGICAL_480:
 785                 return 480;
 786         case RESOLUTION_LOGICAL_720:
 787                 return 720;
 788         case RESOLUTION_LOGICAL_800:
 789                 return 800;
 790         case RESOLUTION_LOGICAL_960:
 791                 return 960;
 792         case RESOLUTION_LOGICAL_1080:
 793                 return 1080;
 794         case RESOLUTION_LOGICAL_1440:
 795                 return 1440;
 796         case RESOLUTION_LOGICAL_1600:
 797                 return 1600;
 798         default:
 799                 return -1;
 800         }
 801 }
 802
 803 const int
 804 _GetIntegerResolution(_PhysicalResolution res)
 805 {
 806         switch (res)
 807         {
 808         case RESOLUTION_PHYSICAL_WVGA:
 809                 return 480;
 810         case RESOLUTION_PHYSICAL_WQVGA:
 811                 return 240;
 812         case RESOLUTION_PHYSICAL_HVGA:
 813                 return 320;
 814         case RESOLUTION_PHYSICAL_HD:
 815                 return 720;
 816         case RESOLUTION_PHYSICAL_HD1080:
 817                 return 1080;
 818         case RESOLUTION_PHYSICAL_WXGA:
 819                 return 800;
 820         case RESOLUTION_PHYSICAL_WQXGA:
 821                 return 1600;
 822         default:
 823                 return -1;
 824         }
 825 }
 826
 827 const int
 828 _GetIntegerResolution(_BaseScreenSize res)
 829 {
 830         switch (res)
 831         {
 832         case BASE_SCREEN_SIZE_NORMAL:
 833                 return 720;
 834         case BASE_SCREEN_SIZE_LARGE:
 835                 return 1440;
 836         default:
 837                 return -1;
 838         }
 839 }
 840
 841 /*****************************************************************************************
 842  * Supported transformations
 843
 844   *  -  Normal_480 to Large_WQVGA       Large * 480 : Normal * WQVGA
 845
 846 **************************Normal to Normal(48)**************************
 847  *  -  Normal_240 to Normal_WVGA        480 * 240 (1) : 480 * 480 (2)
 848  *  -  Normal_WVGA to Normal_240        480 * 480 (2) : 480 * 240 (1)
 849  *  -  Normal_240 to Normal_HVGA        480 * 240 (3) : 480 * 320 (4)
 850  *  -  Normal_HVGA to Normal_240        480 * 320 (4) : 480 * 240 (3)
 851  *  -  Normal_240 to Normal_HD          480 * 240 (1) : 480 * 720 (3)
 852  *  -  Normal_HD to Normal_240          480 * 720 (3) : 480 * 240 (1)
 853
 854  *  -  Normal_320 to Normal_WQVGA       480 * 320 (4) : 480 * 240 (3)
 855  *  -  Normal_WQVGA to Normal_320       480 * 240 (3) : 480 * 320 (4)
 856  *  -  Normal_320 to Normal_WVGA        480 * 320 (2) : 480 * 480 (3)
 857  *  -  Normal_WVGA to Normal_320        480 * 480 (3) : 480 * 320 (2)
 858  *  -  Normal_320 to Normal_HD          480 * 320 (4) : 480 * 720 (9)
 859  *  -  Normal_HD to Normal_320          480 * 720 (9) : 480 * 320 (4)
 860
 861  *  -  Normal_480 to Normal_WQVGA       480 * 480 (2) : 480 * 240 (1)
 862  *  -  Normal_WQVGA to Normal_480       480 * 240 (1) : 480 * 480 (2)
 863  *  -  Normal_480 to Normal_HVGA        480 * 480 (3) : 480 * 320 (2)
 864  *  -  Normal_HVGA to Normal_480        480 * 320 (2) : 480 * 480 (3)
 865  *  -  Normal_480 to Normal_HD          480 * 480 (2) : 480 * 720 (3)
 866  *  -  Normal_HD to Normal_480          480 * 720 (3) : 480 * 480 (2)
 867
 868  *  -  Normal_720 to Normal_WQVGA       480 * 720 (3) : 480 * 240 (1)
 869  *  -  Normal_WQVGA to Normal_720       480 * 240 (1) : 480 * 720 (3)
 870  *  -  Normal_720 to Normal_WVGA        480 * 720 (3) : 480 * 480 (2)
 871  *  -  Normal_WVGA to Normal_720        480 * 480 (2) : 480 * 720 (3)
 872  *  -  Normal_720 to Normal_HVGA        480 * 720 (9) : 480 * 320 (4)
 873  *  -  Normal_HVGA to Normal_720        480 * 320 (4) : 480 * 720 (9)
 874
 875  *  -  Normal_800 to Normal_WQVGA       480 * 800 (10) : 480 * 240 (3)
 876  *  -  Normal_WQVGA to Normal_800       480 * 240 (3) : 480 * 800 (10)
 877  *  -  Normal_800 to Normal_WVGA        480 * 800 (5) : 480 * 480 (3)
 878  *  -  Normal_WVGA to Normal_800        480 * 480 (3) : 480 * 800 (5)
 879  *  -  Normal_800 to Normal_HVGA        480 * 800 (5) : 480 * 320 (2)
 880  *  -  Normal_HVGA to Normal_800        480 * 320 (2) : 480 * 800 (5)
 881  *  -  Normal_800 to Normal_HD          480 * 800 (10) : 480 * 720 (9)
 882  *  -  Normal_HD to Normal_800          480 * 720 (9) : 480 * 800 (10)
 883
 884  *  -  Normal_1080 to Normal_WQVGA      480 * 1080 (27) : 480 * 240 (6)
 885  *  -  Normal_WQVGA to Normal_1080      480 * 240 (6) : 480 * 1080 (27)
 886  *  -  Normal_1080 to Normal_WVGA       480 * 1080 (27) : 480 * 480 (12)
 887  *  -  Normal_WVGA to Normal_1080       480 * 480 (12) : 480 * 1080 (27)
 888  *  -  Normal_1080 to Normal_HVGA       480 * 1080 (27) : 480 * 320 (8)
 889  *  -  Normal_HVGA to Normal_1080       480 * 320 (8) : 480 * 1080 (27)
 890  *  -  Normal_1080 to Normal_HD         480 * 1080 (27) : 480 * 720 (18)
 891  *  -  Normal_HD to Normal_1080         480 * 720 (18) : 480 * 1080 (27)
 892
 893  *  -  Normal_1600 to Normal_WQVGA      480 * 1600 (20) : 480 * 240 (3)
 894  *  -  Normal_WQVGA to Normal_1600      480 * 240 (3) : 480 * 1600 (20)
 895  *  -  Normal_1600 to Normal_WVGA       480 * 1600 (10) : 480 * 480 (3)
 896  *  -  Normal_WVGA to Normal_1600       480 * 480 (3) : 480 * 1600 (10)
 897  *  -  Normal_1600 to Normal_HVGA       480 * 1600 (5) : 480 * 320 (1)
 898  *  -  Normal_HVGA to Normal_1600       480 * 320 (1) : 480 * 1600 (5)
 899  *  -  Normal_1600 to Normal_HD         480 * 1600 (20) : 480 * 720 (9)
 900  *  -  Normal_HD to Normal_1600         480 * 720 (9) : 480 * 1600 (20)
 901
 902 **************************Large to Large(48)**************************
 903  *  -  Large_240 to Large_WVGA          720 * 240 (1) : 720 * 480 (2)
 904  *  -  Large_WVGA to Large_240          720 * 480 (2) : 720 * 240 (1)
 905  *  -  Large_240 to Large_HVGA          720 * 240 (3) : 720 * 320 (4)
 906  *  -  Large_HVGA to Large_240          720 * 320 (4) : 720 * 240 (3)
 907  *  -  Large_240 to Large_HD            720 * 240 (1) : 720 * 720 (3)
 908  *  -  Large_HD to Large_240            720 * 720 (3) : 720 * 240 (1)
 909
 910  *  -  Large_320 to Large_WQVGA         720 * 320 (4) : 720 * 240 (3)
 911  *  -  Large_WQVGA to Large_320         720 * 240 (3) : 720 * 320 (4)
 912  *  -  Large_320 to Large_WVGA          720 * 320 (2) : 720 * 480 (3)
 913  *  -  Large_WVGA to Large_320          720 * 480 (3) : 720 * 320 (2)
 914  *  -  Large_320 to Large_HD            720 * 320 (4) : 720 * 720 (9)
 915  *  -  Large_HD to Large_320            720 * 720 (9) : 720 * 320 (4)
 916
 917  *  -  Large_480 to Large_WQVGA         720 * 480 (2) : 720 * 240 (1)
 918  *  -  Large_WQVGA to Large_480         720 * 240 (1) : 720 * 480 (2)
 919  *  -  Large_480 to Large_HVGA          720 * 480 (3) : 720 * 320 (2)
 920  *  -  Large_HVGA to Large_480          720 * 320 (2) : 720 * 480 (3)
 921  *  -  Large_480 to Large_HD            720 * 480 (2) : 720 * 720 (3)
 922  *  -  Large_HD to Large_480            720 * 720 (3) : 720 * 480 (2)
 923
 924  *  -  Large_720 to Large_WQVGA         720 * 720 (3) : 720 * 240 (1)
 925  *  -  Large_WQVGA to Large_720         720 * 240 (1) : 720 * 720 (3)
 926  *  -  Large_720 to Large_WVGA          720 * 720 (3) : 720 * 480 (2)
 927  *  -  Large_WVGA to Large_720          720 * 480 (2) : 720 * 720 (3)
 928  *  -  Large_720 to Large_HVGA          720 * 720 (9) : 720 * 320 (4)
 929  *  -  Large_HVGA to Large_720          720 * 320 (4) : 720 * 720 (9)
 930
 931  *  -  Large_800 to Large_WQVGA         720 * 800 (10) : 720 * 240 (3)
 932  *  -  Large_WQVGA to Large_800         720 * 240 (3) : 720 * 800 (10)
 933  *  -  Large_800 to Large_WVGA          720 * 800 (5) : 720 * 480 (3)
 934  *  -  Large_WVGA to Large_800          720 * 480 (3) : 720 * 800 (5)
 935  *  -  Large_800 to Large_HVGA          720 * 800 (5) : 720 * 320 (2)
 936  *  -  Large_HVGA to Large_800          720 * 320 (2) : 720 * 800 (5)
 937  *  -  Large_800 to Large_HD            720 * 800 (10) : 720 * 720 (9)
 938  *  -  Large_HD to Large_800            720 * 720 (9) : 720 * 800 (10)
 939
 940  *  -  Large_1080 to Large_WQVGA        720 * 1080 (27) : 720 * 240 (6)
 941  *  -  Large_WQVGA to Large_1080        720 * 240 (6) : 720 * 1080 (27)
 942  *  -  Large_1080 to Large_WVGA         720 * 1080 (27) : 720 * 480 (12)
 943  *  -  Large_WVGA to Large_1080         720 * 480 (12) : 720 * 1080 (27)
 944  *  -  Large_1080 to Large_HVGA         720 * 1080 (27) : 720 * 320 (8)
 945  *  -  Large_HVGA to Large_1080         720 * 320 (8) : 720 * 1080 (27)
 946  *  -  Large_1080 to Large_HD           720 * 1080 (27) : 720 * 720 (18)
 947  *  -  Large_HD to Large_1080           720 * 720 (18) : 720 * 1080 (27)
 948
 949  *  -  Large_1600 to Large_WQVGA        720 * 1600 (20) : 720 * 240 (3)
 950  *  -  Large_WQVGA to Large_1600        720 * 240 (3) : 720 * 1600 (20)
 951  *  -  Large_1600 to Large_WVGA         720 * 1600 (10) : 720 * 480 (3)
 952  *  -  Large_WVGA to Large_1600         720 * 480 (3) : 720 * 1600 (10)
 953  *  -  Large_1600 to Large_HVGA         720 * 1600 (5) : 720 * 320 (1)
 954  *  -  Large_HVGA to Large_1600         720 * 320 (1) : 720 * 1600 (5)
 955  *  -  Large_1600 to Large_HD           720 * 1600 (20) : 720 * 720 (9)
 956  *  -  Large_HD to Large_1600           720 * 720 (9) : 720 * 1600 (20)
 957
 958  **************************Normal to Large(48)**************************
 959  *  -  Normal_240 to Large_WVGA         720 * 240 (3) : 480 * 480 (4)
 960  *  -  Large_WVGA to Normal_240         480 * 480 (4) : 720 * 240 (3)
 961  *  -  Normal_240 to Large_HVGA         720 * 240 (9) : 480 * 320 (8)
 962  *  -  Large_HVGA to Normal_240         480 * 320 (8) : 720 * 240 (9)
 963  *  -  Normal_240 to Large_HD           720 * 240 (1) : 480 * 720 (2)
 964  *  -  Large_HD to Normal_240           480 * 720 (2) : 720 * 240 (1)
 965
 966  *  -  Normal_320 to Large_WQVGA        720 * 320 (3) : 480 * 240 (1)
 967  *  -  Large_WQVGA to Normal_320        480 * 240 (1) : 720 * 320 (3)
 968  *  -  Normal_320 to Large_WVGA         720 * 320 (1) : 480 * 480 (1)
 969  *  -  Large_WVGA to Normal_320         480 * 480 (1) : 720 * 320 (1)
 970  *  -  Normal_320 to Large_HD           720 * 320 (2) : 480 * 720 (3)
 971  *  -  Large_HD to Normal_320           480 * 720 (3) : 720 * 320 (2)
 972
 973  *  -  Normal_480 to Large_WQVGA        720 * 480 (4) : 480 * 240 (3)
 974  *  -  Large_WQVGA to Normal_480        480 * 240 (3) : 720 * 480 (4)
 975  *  -  Normal_480 to Large_HVGA         720 * 480 (9) : 480 * 320 (4)
 976  *  -  Large_HVGA to Normal_480         480 * 320 (4) : 720 * 480 (9)
 977  *  -  Normal_480 to Large_HD           720 * 480 (1) : 480 * 720 (1)
 978  *  -  Large_HD to Normal_480           480 * 720 (1) : 720 * 480 (1)
 979
 980  *  -  Normal_720 to Large_WQVGA        720 * 720 (9) : 480 * 240 (2)
 981  *  -  Large_WQVGA to Normal_720        480 * 240 (2) : 720 * 720 (9)
 982  *  -  Normal_720 to Large_WVGA         720 * 720 (9) : 480 * 480 (4)
 983  *  -  Large_WVGA to Normal_720         480 * 480 (4) : 720 * 720 (9)
 984  *  -  Normal_720 to Large_HVGA         720 * 720 (27) : 480 * 320 (8)
 985  *  -  Large_HVGA to Normal_720         480 * 320 (8) : 720 * 720 (27)
 986
 987  *  -  Normal_800 to Large_WQVGA        720 * 800 (5) : 480 * 240 (1)
 988  *  -  Large_WQVGA to Normal_800        480 * 240 (1) : 720 * 800 (5)
 989  *  -  Normal_800 to Large_WVGA         720 * 800 (5) : 480 * 480 (2)
 990  *  -  Large_WVGA to Normal_800         480 * 480 (2) : 720 * 800 (5)
 991  *  -  Normal_800 to Large_HVGA         720 * 800 (15) : 480 * 320 (4)
 992  *  -  Large_HVGA to Normal_800         480 * 320 (4) : 720 * 800 (15)
 993  *  -  Normal_800 to Large_HD           720 * 800 (5) : 480 * 720 (3)
 994  *  -  Large_HD to Normal_800           480 * 720 (3) : 720 * 800 (5)
 995
 996  *  -  Normal_1080 to Large_WQVGA       720 * 1080 (27) : 480 * 240 (4)
 997  *  -  Large_WQVGA to Normal_1080       480 * 240 (4) : 720 * 1080 (27)
 998  *  -  Normal_1080 to Large_WVGA        720 * 1080 (27) : 480 * 480 (8)
 999  *  -  Large_WVGA to Normal_1080        480 * 480 (8) : 720 * 1080 (27)
1000  *  -  Normal_1080 to Large_HVGA        720 * 1080 (81) : 480 * 320 (16)
1001  *  -  Large_HVGA to Normal_1080        480 * 320 (16) : 720 * 1080 (81)
1002  *  -  Normal_1080 to Large_HD          720 * 1080 (9) : 480 * 720 (4)
1003  *  -  Large_HD to Normal_1080          480 * 720 (4) : 720 * 1080 (9)
1004
1005  *  -  Normal_1600 to Large_WQVGA       720 * 1600 (10) : 480 * 240 (1)
1006  *  -  Large_WQVGA to Normal_1600       480 * 240 (1) : 720 * 1600 (10)
1007  *  -  Normal_1600 to Large_WVGA        720 * 1600 (5) : 480 * 480 (1)
1008  *  -  Large_WVGA to Normal_1600        480 * 480 (1) : 720 * 1600 (5)
1009  *  -  Normal_1600 to Large_HVGA        720 * 1600 (15) : 480 * 320 (2)
1010  *  -  Large_HVGA to Normal_1600        480 * 320 (2) : 720 * 1600 (15)
1011  *  -  Normal_1600 to Large_HD          720 * 1600 (10) : 480 * 720 (3)
1012  *  -  Large_HD to Normal_1600          480 * 720 (3) : 720 * 1600 (10)
1013
1014  **************************Large to Normal(48)**************************
1015  *  -  Large_240 to Normal_WVGA         480 * 240 (1) : 720 * 480 (3)
1016  *  -  Normal_WVGA to Large_240         720 * 480 (3) : 480 * 240 (1)
1017  *  -  Large_240 to Normal_HVGA         480 * 240 (1) : 720 * 320 (2)
1018  *  -  Normal_HVGA to Large_240         720 * 320 (2) : 480 * 240 (1)
1019  *  -  Large_240 to Normal_HD           480 * 240 (2) : 720 * 720 (9)
1020  *  -  Normal_HD to Large_240           720 * 720 (9) : 480 * 240 (2)
1021
1022  *  -  Large_320 to Normal_WQVGA        480 * 320 (8) : 720 * 240 (9)
1023  *  -  Normal_WQVGA to Large_320        720 * 240 (9) : 480 * 320 (8)
1024  *  -  Large_320 to Normal_WVGA         480 * 320 (4) : 720 * 480 (9)
1025  *  -  Normal_WVGA to Large_320         720 * 480 (9) : 480 * 320 (4)
1026  *  -  Large_320 to Normal_HD           480 * 320 (8) : 720 * 720 (27)
1027  *  -  Normal_HD to Large_320           720 * 720 (27) : 480 * 320 (8)
1028
1029  *  -  Large_480 to Normal_WQVGA        480 * 480 (4) : 720 * 240 (3)
1030  *  -  Normal_WQVGA to Large_480        720 * 240 (3) : 480 * 480 (4)
1031  *  -  Large_480 to Normal_HVGA         480 * 480 (1) : 720 * 320 (1)
1032  *  -  Normal_HVGA to Large_480         720 * 320 (1) : 480 * 480 (1)
1033  *  -  Large_480 to Normal_HD           480 * 480 (2) : 720 * 720 (3)
1034  *  -  Normal_HD to Large_480           720 * 720 (3) : 480 * 480 (2)
1035
1036  *  -  Large_720 to Normal_WQVGA        480 * 720 (2) : 720 * 240 (1)
1037  *  -  Normal_WQVGA to Large_720        720 * 240 (1) : 480 * 720 (2)
1038  *  -  Large_720 to Normal_WVGA         480 * 720 (1) : 720 * 480 (1)
1039  *  -  Normal_WVGA to Large_720         720 * 480 (1) : 480 * 720 (1)
1040  *  -  Large_720 to Normal_HVGA         480 * 720 (3) : 720 * 320 (2)
1041  *  -  Normal_HVGA to Large_720         720 * 320 (2) : 480 * 720 (3)
1042
1043  *  -  Large_800 to Normal_WQVGA        480 * 800 (20) : 720 * 240 (9)
1044  *  -  Normal_WQVGA to Large_800        720 * 240 (9) : 480 * 800 (20)
1045  *  -  Large_800 to Normal_WVGA         480 * 800 (10) : 720 * 480 (9)
1046  *  -  Normal_WVGA to Large_800         720 * 480 (9) : 480 * 800 (10)
1047  *  -  Large_800 to Normal_HVGA         480 * 800 (5) : 720 * 320 (3)
1048  *  -  Normal_HVGA to Large_800         720 * 320 (3) : 480 * 800 (5)
1049  *  -  Large_800 to Normal_HD           480 * 800 (9) : 720 * 720 (20)
1050  *  -  Normal_HD to Large_800           720 * 720 (20) : 480 * 800 (9)
1051
1052  *  -  Large_1080 to Normal_WQVGA       480 * 1080 (3) : 720 * 240 (1)
1053  *  -  Normal_WQVGA to Large_1080       720 * 240 (1) : 480 * 1080 (3)
1054  *  -  Large_1080 to Normal_WVGA        480 * 1080 (3) : 720 * 480 (2)
1055  *  -  Normal_WVGA to Large_1080        720 * 480 (2) : 480 * 1080 (3)
1056  *  -  Large_1080 to Normal_HVGA        480 * 1080 (9) : 720 * 320 (4)
1057  *  -  Normal_HVGA to Large_1080        720 * 320 (4) : 480 * 1080 (9)
1058  *  -  Large_1080 to Normal_HD          480 * 1080 (1) : 720 * 720 (10)
1059  *  -  Normal_HD to Large_1080          720 * 720 (10) : 480 * 1080 (1)
1060
1061  *  -  Large_1600 to Normal_WQVGA       480 * 1600 (40) : 720 * 240 (9)
1062  *  -  Normal_WQVGA to Large_1600       720 * 240 (9) : 480 * 1600 (40)
1063  *  -  Large_1600 to Normal_WVGA        480 * 1600 (20) : 720 * 480 (9)
1064  *  -  Normal_WVGA to Large_1600        720 * 480 (9) : 480 * 1600 (20)
1065  *  -  Large_1600 to Normal_HVGA        480 * 1600 (10) : 720 * 320 (3)
1066  *  -  Normal_HVGA to Large_1600        720 * 320 (3) : 480 * 1600 (10)
1067  *  -  Large_1600 to Normal_HD          480 * 1600 (40) : 720 * 720 (27)
1068  *  -  Normal_HD to Large_1600          720 * 720 (27) : 480 * 1600 (40)
1069
1070  *****************************************************************************************/
1071
1072 class TransformerNormal240ToNormalHvga
1073         : public _Internal::Transformer
1074         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1075         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1076 {
1077 }; // TransformerNormal240ToNormalHvga
1078
1079 class TransformerNormalHvgaToNormal240
1080         : public _Internal::Transformer
1081         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1082         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1083 {
1084 }; // TransformerNormalHvgaToNormal240
1085
1086 class TransformerNormal240ToNormalWvga
1087         : public _Internal::Transformer
1088         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1089         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1090 {
1091 }; // TransformerNormal240ToNormalWvga
1092
1093 class TransformerNormalWvgaToNormal240
1094         : public _Internal::Transformer
1095         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1096         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1097 {
1098 }; // TransformerNormalWvgaToNormal240
1099
1100 class TransformerNormal240ToNormalHd
1101         : public _Internal::Transformer
1102         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1103         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1104 {
1105 }; // TransformerNormal240ToNormalHd
1106
1107 class TransformerNormalHdToNormal240
1108         : public _Internal::Transformer
1109         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1110         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_240>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1111 {
1112 }; // TransformerNormalHdToNormal240
1113
1114 class TransformerNormal320ToNormalWqvga
1115         : public _Internal::Transformer
1116         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1117         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1118 {
1119 }; // TransformerNormal320ToNormalWqvga
1120
1121 class TransformerNormalWqvgaToNormal320
1122         : public _Internal::Transformer
1123         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1124         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1125 {
1126 }; // TransformerNormalWqvgaToNormal320
1127
1128 class TransformerNormal320ToNormalWvga
1129         : public _Internal::Transformer
1130         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1131         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1132 {
1133 }; // TransformerNormal320ToNormalWvga
1134
1135 class TransformerNormalWvgaToNormal320
1136         : public _Internal::Transformer
1137         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1138         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1139 {
1140 }; // TransformerNormalWvgaToNormal320
1141
1142 class TransformerNormal320ToNormalHd
1143         : public _Internal::Transformer
1144         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1145         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1146 {
1147 }; // TransformerNormal320ToNormalHd
1148
1149 class TransformerNormalHdToNormal320
1150         : public _Internal::Transformer
1151         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1152         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_320>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1153 {
1154 }; // TransformerNormalHdToNormal320
1155
1156 class TransformerNormal480ToNormalWqvga
1157         : public _Internal::Transformer
1158         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1159         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1160 {
1161 }; // TransformerNormal480ToNormalWqvga
1162
1163 class TransformerNormalWqvgaToNormal480
1164         : public _Internal::Transformer
1165         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1166         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1167 {
1168 }; // TransformerNormalWqvgaToNormal480
1169
1170 class TransformerNormal480ToNormalHvga
1171         : public _Internal::Transformer
1172         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1173         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1174 {
1175 }; // TransformerNormal480ToNormalHvga
1176
1177 class TransformerNormalHvgaToNormal480
1178         : public _Internal::Transformer
1179         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1180         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1181 {
1182 }; // TransformerNormalHvgaToNormal480
1183
1184 class TransformerNormal480ToNormalHd
1185         : public _Internal::Transformer
1186         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1187         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1188 {
1189 }; // TransformerNormal480ToNormalHd
1190
1191 class TransformerNormalHdToNormal480
1192         : public _Internal::Transformer
1193         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1194         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HD>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_480>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1195 {
1196 }; // TransformerNormalHdToNormal480
1197
1198 class TransformerNormal720ToNormalWqvga
1199         : public _Internal::Transformer
1200         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1201         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1202 {
1203 }; // TransformerNormal720ToNormalWqvga
1204
1205 class TransformerNormalWqvgaToNormal720
1206         : public _Internal::Transformer
1207         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1208         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WQVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1209 {
1210 }; // TransformerNormalWqvgaToNormal720
1211
1212 class TransformerNormal720ToNormalWvga
1213         : public _Internal::Transformer
1214         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1215         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1216 {
1217 }; // TransformerNormal720ToNormalWvga
1218
1219 class TransformerNormalWvgaToNormal720
1220         : public _Internal::Transformer
1221         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1222         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_WVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1223 {
1224 }; // TransformerNormalWvgaToNormalWvga
1225
1226 class TransformerNormal720ToNormalHvga
1227         : public _Internal::Transformer
1228         <_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1229         ,_Internal::Scaler <LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1230 {
1231 }; // TransformerNormal720ToNormalHvga
1232
1233 class TransformerNormalHvgaToNormal720
1234         : public _Internal::Transformer
1235         <_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH>
1236         ,_Internal::Scaler <PhyResTraits <RESOLUTION_PHYSICAL_HVGA>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH , LogResTraits <RESOLUTION_LOGICAL_720>::WIDTH * ScrResTraits <BASE_SCREEN_SIZE_NORMAL>::WIDTH> >
1237 {
1238 }; // TransformerNormalHvgaToNormal720
1239
1240
1241 class TransformerGeneral
1242                 : public _ICoordinateSystemTransformer
1243         {
1244         public:
1245                 TransformerGeneral(const int srcScalar, const int dstScalar)
1246                         : __srcScalar(srcScalar)
1247                         , __dstScalar(dstScalar)
1248                         , __scaleFactor(dstScalar * 1.0f / srcScalar)
1249                 {
1250                 }
1251
1252                 virtual int TransformHorizontal(int width) const
1253                 {
1254                         return ScaleLength(width);
1255                 }
1256
1257                 virtual int TransformVertical(int height) const
1258                 {
1259                         return ScaleLength(height);
1260                 }
1261
1262                 virtual int Transform(int scalar) const
1263                 {
1264                         return ScaleLength(scalar);
1265                 }
1266
1267                 virtual float TransformHorizontal(float width) const
1268                 {
1269                         return ScaleLength(width);
1270                 }
1271
1272                 virtual float TransformVertical(float height) const
1273                 {
1274                         return ScaleLength(height);
1275                 }
1276
1277                 virtual float Transform(float scalar) const
1278                 {
1279                         return ScaleLength(scalar);
1280                 }
1281
1282                 virtual Point Transform(const Point& point) const
1283                 {
1284                         return Point(ScaleDisplacement(point.x), ScaleDisplacement(point.y));
1285                 }
1286
1287                 virtual Dimension Transform(const Dimension& dim) const
1288                 {
1289                         return Dimension(ScaleLength(dim.width), ScaleLength(dim.height));
1290                 }
1291
1292                 virtual Rectangle Transform(const Rectangle& rect) const
1293                 {
1294                         int x = ScaleDisplacement(rect.x);
1295                         int y = ScaleDisplacement(rect.y);
1296                         int w = ScaleLength(rect.width);
1297                         int h = ScaleLength(rect.height);
1298
1299                         return Rectangle(x, y, w, h);
1300                 }
1301
1302                 virtual int TransformFloatToInt(float scalar) const
1303                 {
1304                         return ScaleLength(static_cast<int>(scalar));
1305                 }
1306
1307                 virtual int TransformHorizontalFloatToInt(float width) const
1308                 {
1309                         return ScaleLength(static_cast<int>(width));
1310                 }
1311
1312                 virtual int TransformVerticalFloatToInt(float height) const
1313                 {
1314                         return ScaleLength(static_cast<int>(height));
1315                 }
1316
1317                 virtual float GetHorizontalScaleFactor(void) const
1318                 {
1319                         return __scaleFactor;
1320                 }
1321
1322                 virtual float GetVerticalScaleFactor(void) const
1323                 {
1324                         return __scaleFactor;
1325                 }
1326
1327 private:
1328                 int ScaleDisplacement(int srcVal) const
1329                 {
1330                         long long tmpVal = srcVal;
1331                         tmpVal *= __dstScalar;
1332                         tmpVal /= __srcScalar;
1333
1334                         return static_cast<int>(tmpVal);
1335                 }
1336
1337                 int ScaleLength(int srcVal) const
1338                 {
1339                         long long tmpVal = srcVal;
1340                         tmpVal *= __dstScalar;
1341                         tmpVal /= __srcScalar;
1342
1343                         return static_cast<int>(tmpVal);
1344                 }
1345
1346                 float ScaleDisplacement(float srcVal) const
1347                 {
1348                         return srcVal * __scaleFactor;
1349                 }
1350
1351                 float ScaleLength(float srcVal) const
1352                 {
1353                         return srcVal * __scaleFactor;
1354                 }
1355
1356 private:
1357                 int __srcScalar;
1358                 int __dstScalar;
1359
1360                 float __scaleFactor;
1361
1362 }; // TransformerGeneral
1363
1364 bool
1365 _WillNotTransform(_LogicalResolution logicalResolution, _BaseScreenSize logicalBaseScreenSize, _PhysicalResolution physicalResolution, _BaseScreenSize physicalBaseScreenSize)
1366 {
1367         return ((logicalResolution == RESOLUTION_LOGICAL_240 && physicalResolution == RESOLUTION_PHYSICAL_WQVGA) ||
1368                 (logicalResolution == RESOLUTION_LOGICAL_320 && physicalResolution == RESOLUTION_PHYSICAL_HVGA) ||
1369                 (logicalResolution == RESOLUTION_LOGICAL_480 && physicalResolution == RESOLUTION_PHYSICAL_WVGA) ||
1370                 (logicalResolution == RESOLUTION_LOGICAL_720 && physicalResolution == RESOLUTION_PHYSICAL_HD) ||
1371                 (logicalResolution == RESOLUTION_LOGICAL_800 && physicalResolution == RESOLUTION_PHYSICAL_WXGA) ||
1372                 (logicalResolution == RESOLUTION_LOGICAL_1080 && physicalResolution == RESOLUTION_PHYSICAL_HD1080) ||
1373                 (logicalResolution == RESOLUTION_LOGICAL_1600 && physicalResolution == RESOLUTION_PHYSICAL_WQXGA)) &&
1374                (logicalBaseScreenSize == physicalBaseScreenSize);
1375 }
1376
1377 bool
1378 _WillNotTransform(int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize)
1379 {
1380         return ((srcResolution == destResolution.width) && (srcBaseScreenSize == destBaseScreenSize));
1381 }
1382
1383 result
1384 _CoordinateTransformerCore(_ICoordinateSystemTransformer*& pTransformer, _LogicalResolution logicalResolution, _BaseScreenSize logicalBaseScreenSize, _PhysicalResolution physicalResolution, _BaseScreenSize physicalBaseScreenSize, bool isInverse = false)
1385 {
1386         SysAssert(logicalResolution != RESOLUTION_LOGICAL_DEFAULT);
1387         SysAssert(physicalResolution != RESOLUTION_PHYSICAL_DEFAULT);
1388         SysAssert(logicalBaseScreenSize != BASE_SCREEN_SIZE_DEFAULT);
1389         SysAssert(physicalBaseScreenSize != BASE_SCREEN_SIZE_DEFAULT);
1390
1391         result r = E_SUCCESS;
1392         pTransformer = null;
1393
1394         if (_WillNotTransform(logicalResolution,logicalBaseScreenSize, physicalResolution,physicalBaseScreenSize))
1395         {
1396                 pTransformer = new (std::nothrow) _NullCoordinateSystemTransformer();
1397
1398                 if (pTransformer == null)
1399                 {
1400                         SysLog(NID_GRP, "[E_OUT_OF_MEMORY] Fail to create a coordinate transformer.");
1401
1402                         return E_OUT_OF_MEMORY;
1403                 }
1404
1405                 return E_SUCCESS;
1406         }
1407
1408 #if 1
1409         if (isInverse)
1410         {
1411                 if (logicalBaseScreenSize == physicalBaseScreenSize)
1412                 {
1413                         if (logicalResolution == RESOLUTION_LOGICAL_240 && physicalResolution == RESOLUTION_PHYSICAL_WVGA)
1414                         {
1415                                 pTransformer = new (std::nothrow) TransformerNormalWvgaToNormal240;
1416                         }
1417                         else if (logicalResolution == RESOLUTION_LOGICAL_240 && physicalResolution == RESOLUTION_PHYSICAL_HVGA)
1418                         {
1419                                 pTransformer = new (std::nothrow) TransformerNormalHvgaToNormal240;
1420                         }
1421                         else if (logicalResolution == RESOLUTION_LOGICAL_240 && physicalResolution == RESOLUTION_PHYSICAL_HD)
1422                         {
1423                                 pTransformer = new (std::nothrow) TransformerNormalHdToNormal240;
1424                         }
1425                         else if (logicalResolution == RESOLUTION_LOGICAL_320 && physicalResolution == RESOLUTION_PHYSICAL_WQVGA)
1426                         {
1427                                 pTransformer = new (std::nothrow) TransformerNormalWqvgaToNormal320;
1428                         }
1429                         else if (logicalResolution == RESOLUTION_LOGICAL_320 && physicalResolution == RESOLUTION_PHYSICAL_WVGA)
1430                         {
1431                                 pTransformer = new (std::nothrow) TransformerNormalWvgaToNormal320;
1432                         }
1433                         else if (logicalResolution == RESOLUTION_LOGICAL_320 && physicalResolution == RESOLUTION_PHYSICAL_HD)
1434                         {
1435                                 pTransformer = new (std::nothrow) TransformerNormalHdToNormal320;
1436                         }
1437                         else if (logicalResolution == RESOLUTION_LOGICAL_480 && physicalResolution == RESOLUTION_PHYSICAL_WQVGA)
1438                         {
1439                                 pTransformer = new (std::nothrow) TransformerNormalWqvgaToNormal480;
1440                         }
1441                         else if (logicalResolution == RESOLUTION_LOGICAL_480 && physicalResolution == RESOLUTION_PHYSICAL_HVGA)
1442                         {
1443                                 pTransformer = new (std::nothrow) TransformerNormalHvgaToNormal480;
1444                         }
1445                         else if (logicalResolution == RESOLUTION_LOGICAL_480 && physicalResolution == RESOLUTION_PHYSICAL_HD)
1446                         {
1447                                 pTransformer = new (std::nothrow) TransformerNormalHdToNormal480;
1448                         }
1449                         else if (logicalResolution == RESOLUTION_LOGICAL_720 && physicalResolution == RESOLUTION_PHYSICAL_WQVGA)
1450                         {
1451                                 pTransformer = new (std::nothrow) TransformerNormalWqvgaToNormal720;
1452                         }
1453                         else if (logicalResolution == RESOLUTION_LOGICAL_720 && physicalResolution == RESOLUTION_PHYSICAL_WVGA)
1454                         {
1455                                 pTransformer = new (std::nothrow) TransformerNormalWvgaToNormal720;
1456                         }
1457                         else if (logicalResolution == RESOLUTION_LOGICAL_720 && physicalResolution == RESOLUTION_PHYSICAL_HVGA)
1458                         {
1459                                 pTransformer = new (std::nothrow) TransformerNormalHvgaToNormal720;
1460                         }
1461                         else
1462                         {
1463                                 //r = E_INVALID_ARG;
1464                                 pTransformer = new (std::nothrow) TransformerGeneral(_GetIntegerResolution(physicalResolution), _GetIntegerResolution(logicalResolution));
1465                         }
1466                 }
1467                 else
1468                 {
1469                         //r = E_INVALID_ARG;
1470                         pTransformer = new (std::nothrow) TransformerGeneral(_GetIntegerResolution(physicalResolution) * _GetIntegerResolution(logicalBaseScreenSize), _GetIntegerResolution(logicalResolution) * _GetIntegerResolution(physicalBaseScreenSize));
1471                 }
1472         }
1473         else
1474         {
1475                 if (logicalBaseScreenSize == physicalBaseScreenSize)
1476                 {
1477                         if (logicalResolution == RESOLUTION_LOGICAL_240 && physicalResolution == RESOLUTION_PHYSICAL_WVGA)
1478                         {
1479                                 pTransformer = new (std::nothrow) TransformerNormal240ToNormalWvga;
1480                         }
1481                         else if (logicalResolution == RESOLUTION_LOGICAL_240 && physicalResolution == RESOLUTION_PHYSICAL_HVGA)
1482                         {
1483                                 pTransformer = new (std::nothrow) TransformerNormal240ToNormalHvga;
1484                         }
1485                         else if (logicalResolution == RESOLUTION_LOGICAL_240 && physicalResolution == RESOLUTION_PHYSICAL_HD)
1486                         {
1487                                 pTransformer = new (std::nothrow) TransformerNormal240ToNormalHd;
1488                         }
1489                         else if (logicalResolution == RESOLUTION_LOGICAL_320 && physicalResolution == RESOLUTION_PHYSICAL_WQVGA)
1490                         {
1491                                 pTransformer = new (std::nothrow) TransformerNormal320ToNormalWqvga;
1492                         }
1493                         else if (logicalResolution == RESOLUTION_LOGICAL_320 && physicalResolution == RESOLUTION_PHYSICAL_WVGA)
1494                         {
1495                                 pTransformer = new (std::nothrow) TransformerNormal320ToNormalWvga;
1496                         }
1497                         else if (logicalResolution == RESOLUTION_LOGICAL_320 && physicalResolution == RESOLUTION_PHYSICAL_HD)
1498                         {
1499                                 pTransformer = new (std::nothrow) TransformerNormal320ToNormalHd;
1500                         }
1501                         else if (logicalResolution == RESOLUTION_LOGICAL_480 && physicalResolution == RESOLUTION_PHYSICAL_WQVGA)
1502                         {
1503                                 pTransformer = new (std::nothrow) TransformerNormal480ToNormalWqvga;
1504                         }
1505                         else if (logicalResolution == RESOLUTION_LOGICAL_480 && physicalResolution == RESOLUTION_PHYSICAL_HVGA)
1506                         {
1507                                 pTransformer = new (std::nothrow) TransformerNormal480ToNormalHvga;
1508                         }
1509                         else if (logicalResolution == RESOLUTION_LOGICAL_480 && physicalResolution == RESOLUTION_PHYSICAL_HD)
1510                         {
1511                                 pTransformer = new (std::nothrow) TransformerNormal480ToNormalHd;
1512                         }
1513                         else if (logicalResolution == RESOLUTION_LOGICAL_720 && physicalResolution == RESOLUTION_PHYSICAL_WQVGA)
1514                         {
1515                                 pTransformer = new (std::nothrow) TransformerNormal720ToNormalWqvga;
1516                         }
1517                         else if (logicalResolution == RESOLUTION_LOGICAL_720 && physicalResolution == RESOLUTION_PHYSICAL_WVGA)
1518                         {
1519                                 pTransformer = new (std::nothrow) TransformerNormal720ToNormalWvga;
1520                         }
1521                         else if (logicalResolution == RESOLUTION_LOGICAL_720 && physicalResolution == RESOLUTION_PHYSICAL_HVGA)
1522                         {
1523                                 pTransformer = new (std::nothrow) TransformerNormal720ToNormalHvga;
1524                         }
1525                         else
1526                         {
1527                                 //r = E_INVALID_ARG;
1528                                 pTransformer = new (std::nothrow) TransformerGeneral(_GetIntegerResolution(logicalResolution), _GetIntegerResolution(physicalResolution));
1529                         }
1530                 }
1531                 else
1532                 {
1533                         //r = E_INVALID_ARG;
1534                         pTransformer = new (std::nothrow) TransformerGeneral(_GetIntegerResolution(logicalResolution) * _GetIntegerResolution(physicalBaseScreenSize), _GetIntegerResolution(physicalResolution) * _GetIntegerResolution(logicalBaseScreenSize));
1535                 }
1536
1537         }
1538 #else
1539         if (isInverse)
1540         {
1541                 if (logicalBaseScreenSize == physicalBaseScreenSize)
1542                 {
1543                         pTransformer = new (std::nothrow) TransformerGeneral(_GetIntegerResolution(physicalResolution), _GetIntegerResolution(logicalResolution));
1544                 }
1545                 else
1546                 {
1547                         pTransformer = new (std::nothrow) TransformerGeneral(_GetIntegerResolution(physicalResolution) * _GetIntegerResolution(logicalBaseScreenSize), _GetIntegerResolution(logicalResolution) * _GetIntegerResolution(physicalBaseScreenSize));
1548                 }
1549         }
1550         else
1551         {
1552                 if (logicalBaseScreenSize == physicalBaseScreenSize)
1553                 {
1554                         pTransformer = new (std::nothrow) TransformerGeneral(_GetIntegerResolution(logicalResolution), _GetIntegerResolution(physicalResolution));
1555                 }
1556                 else
1557                 {
1558                         pTransformer = new (std::nothrow) TransformerGeneral(_GetIntegerResolution(logicalResolution) * _GetIntegerResolution(physicalBaseScreenSize), _GetIntegerResolution(physicalResolution) * _GetIntegerResolution(logicalBaseScreenSize));
1559                 }
1560         }
1561 #endif
1562         // Print the log message and return
1563         if (pTransformer)
1564         {
1565                 return E_SUCCESS;
1566         }
1567         else if (r == E_INVALID_ARG)
1568         {
1569                 SysLog(NID_GRP, "[E_INVALID_ARG] The specified resolutions are invalid.");
1570
1571                 return E_INVALID_ARG;
1572         }
1573         else
1574         {
1575                 SysLog(NID_GRP, "[E_OUT_OF_MEMORY] Fail to create a coordinate transformer.");
1576
1577                 return E_OUT_OF_MEMORY;
1578         }
1579 }
1580
1581
1582 result
1583 _CoordinateTransformerCore(_ICoordinateSystemTransformer*& pTransformer, int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize)
1584 {
1585         SysAssert(srcResolution > 0);
1586         SysAssert(destResolution.width > 0);
1587         SysAssert(srcBaseScreenSize != BASE_SCREEN_SIZE_DEFAULT);
1588         SysAssert(destBaseScreenSize != BASE_SCREEN_SIZE_DEFAULT);
1589
1590         result r = E_SUCCESS;
1591         pTransformer = null;
1592
1593         if (_WillNotTransform(srcResolution, srcBaseScreenSize, destResolution, destBaseScreenSize))
1594         {
1595                 pTransformer = new (std::nothrow) _NullCoordinateSystemTransformer();
1596
1597                 if (pTransformer == null)
1598                 {
1599                         SysLog(NID_GRP, "[E_OUT_OF_MEMORY] Fail to create a coordinate transformer.");
1600
1601                         return E_OUT_OF_MEMORY;
1602                 }
1603
1604                 return E_SUCCESS;
1605         }
1606
1607         pTransformer = new (std::nothrow) TransformerGeneral(srcResolution * _GetIntegerResolution(destBaseScreenSize), (destResolution.width < destResolution.height ? destResolution.width : destResolution.height) * _GetIntegerResolution(srcBaseScreenSize));
1608
1609         if (pTransformer)
1610         {
1611                 return E_SUCCESS;
1612         }
1613         else if (r == E_INVALID_ARG)
1614         {
1615                 SysLog(NID_GRP, "[E_INVALID_ARG] The specified resolutions are invalid.");
1616
1617                 return E_INVALID_ARG;
1618         }
1619         else
1620         {
1621                 SysLog(NID_GRP, "[E_OUT_OF_MEMORY] Fail to create a coordinate transformer.");
1622
1623                 return E_OUT_OF_MEMORY;
1624         }
1625 }
1626
1627
1628 result
1629 _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, int srcResolution, _BaseScreenSize srcBaseScreenSize, Dimension destResolution, _BaseScreenSize destBaseScreenSize)
1630 {
1631         return _CoordinateTransformerCore(pTransformer, srcResolution, srcBaseScreenSize, destResolution, destBaseScreenSize);
1632 }
1633
1634 result
1635 _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, _LogicalResolution sourceLogicalResolution, _BaseScreenSize sourceLogicalBaseScreenSize, _PhysicalResolution destPhysicalResolution, _BaseScreenSize destPhysicalBaseScreenSize)
1636 {
1637         return _CoordinateTransformerCore(pTransformer, sourceLogicalResolution, sourceLogicalBaseScreenSize, destPhysicalResolution, destPhysicalBaseScreenSize, false);
1638 }
1639
1640 result
1641 _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, _PhysicalResolution sourcePhysicalResolution, _BaseScreenSize sourcePhysicalBaseScreenSize,_LogicalResolution destLogicalResolution, _BaseScreenSize destLogicalBaseScreenSize)
1642 {
1643         return _CoordinateTransformerCore(pTransformer, destLogicalResolution, destLogicalBaseScreenSize, sourcePhysicalResolution, sourcePhysicalBaseScreenSize, true);
1644 }
1645
1646 result
1647 _CreateCoordinateTransformer(_ICoordinateSystemTransformer*& pTransformer, _LogicalResolution sourceLogicalResolution, _BaseScreenSize sourceLogicalBaseScreenSize, _LogicalResolution destLogicalResolution, _BaseScreenSize destLogicalBaseScreenSize)
1648 {
1649         _PhysicalResolution physicalResolution = RESOLUTION_PHYSICAL_DEFAULT;
1650
1651         switch (destLogicalResolution)
1652         {
1653         case RESOLUTION_LOGICAL_240:
1654                 physicalResolution = RESOLUTION_PHYSICAL_WQVGA;
1655                 break;
1656         case RESOLUTION_LOGICAL_320:
1657                 physicalResolution = RESOLUTION_PHYSICAL_HVGA;
1658                 break;
1659         case RESOLUTION_LOGICAL_480:
1660                 physicalResolution = RESOLUTION_PHYSICAL_WVGA;
1661                 break;
1662         case RESOLUTION_LOGICAL_720:
1663                 physicalResolution = RESOLUTION_PHYSICAL_HD;
1664                 break;
1665         case RESOLUTION_LOGICAL_800:
1666                 physicalResolution = RESOLUTION_PHYSICAL_WXGA;
1667                 break;
1668         case RESOLUTION_LOGICAL_1080:
1669                 physicalResolution = RESOLUTION_PHYSICAL_HD1080;
1670                 break;
1671         case RESOLUTION_LOGICAL_1600:
1672                 physicalResolution = RESOLUTION_PHYSICAL_WQXGA;
1673                 break;
1674         default:
1675                 physicalResolution = RESOLUTION_PHYSICAL_NONE;
1676                 break;
1677         }
1678
1679         return _CoordinateTransformerCore(pTransformer, sourceLogicalResolution, sourceLogicalBaseScreenSize, physicalResolution, destLogicalBaseScreenSize, false);
1680 }
1681
1682 }} // Tizen::Graphics
1683