src/Utils/MiscUI/Picture.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2012 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19 #include "stdafx.h"
  20 #include <olectl.h>
  21 #include <shlwapi.h>
  22 #include <locale>
  23 #include <algorithm>
  24 #include "Picture.h"
  25 #include "SmartHandle.h"
  26 #include <atlbase.h>
  27
  28 #pragma comment(lib, "shlwapi.lib")
  29 #pragma comment(lib, "gdiplus.lib")
  30
  31 #define HIMETRIC_INCH 2540
  32
  33 CPicture::CPicture()
  34         : m_IPicture(NULL)
  35         , m_Height(0)
  36         , m_Weight(0)
  37         , m_Width(0)
  38         , pBitmap(NULL)
  39         , bHaveGDIPlus(false)
  40         , m_ip(InterpolationModeDefault)
  41         , hIcons(NULL)
  42         , lpIcons(NULL)
  43         , nCurrentIcon(0)
  44         , bIsIcon(false)
  45         , bIsTiff(false)
  46         , m_nSize(0)
  47         , m_ColorDepth(0)
  48         , hGlobal(NULL)
  49         , gdiplusToken(NULL)
  50 {
  51 }
  52
  53 CPicture::~CPicture()
  54 {
  55         FreePictureData(); // Important - Avoid Leaks...
  56         delete pBitmap;
  57         if (bHaveGDIPlus)
  58                 GdiplusShutdown(gdiplusToken);
  59 }
  60
  61
  62 void CPicture::FreePictureData()
  63 {
  64         if (m_IPicture != NULL)
  65         {
  66                 m_IPicture->Release();
  67                 m_IPicture = NULL;
  68                 m_Height = 0;
  69                 m_Weight = 0;
  70                 m_Width = 0;
  71                 m_nSize = 0;
  72         }
  73         if (hIcons)
  74         {
  75                 LPICONDIR lpIconDir = (LPICONDIR)lpIcons;
  76                 if (lpIconDir)
  77                 {
  78                         for (int i=0; i<lpIconDir->idCount; ++i)
  79                         {
  80                                 DestroyIcon(hIcons[i]);
  81                         }
  82                 }
  83                 delete [] hIcons;
  84                 hIcons = NULL;
  85         }
  86         delete [] lpIcons;
  87 }
  88
  89 // Util function to ease loading of FreeImage library
  90 static FARPROC s_GetProcAddressEx(HMODULE hDll, const char* procName, bool& valid)
  91 {
  92         FARPROC proc = NULL;
  93
  94         if (valid)
  95         {
  96                 proc = GetProcAddress(hDll, procName);
  97
  98                 if (!proc)
  99                         valid = false;
 100         }
 101
 102         return proc;
 103 }
 104
 105 tstring CPicture::GetFileSizeAsText(bool bAbbrev /* = true */)
 106 {
 107         TCHAR buf[100] = {0};
 108         if (bAbbrev)
 109                 StrFormatByteSize(m_nSize, buf, _countof(buf));
 110         else
 111                 _stprintf_s(buf, _T("%ld Bytes"), m_nSize);
 112
 113         return tstring(buf);
 114 }
 115
 116 bool CPicture::Load(tstring sFilePathName)
 117 {
 118         bool bResult = false;
 119         bIsIcon = false;
 120         lpIcons = NULL;
 121         //CFile PictureFile;
 122         //CFileException e;
 123         FreePictureData(); // Important - Avoid Leaks...
 124
 125         // No-op if no file specified
 126         if (sFilePathName.empty())
 127                 return true;
 128
 129         // Load & initialize the GDI+ library if available
 130         HMODULE hGdiPlusLib = AtlLoadSystemLibraryUsingFullPath(_T("gdiplus.dll"));
 131         if (hGdiPlusLib && GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL) == Ok)
 132         {
 133                 bHaveGDIPlus = true;
 134         }
 135         // Since we loaded the gdiplus.dll only to check if it's available, we
 136         // can safely free the library here again - GdiplusStartup() loaded it too
 137         // and reference counting will make sure that it stays loaded until GdiplusShutdown()
 138         // is called.
 139         FreeLibrary(hGdiPlusLib);
 140
 141         // Attempt to load using GDI+ if available
 142         if (bHaveGDIPlus)
 143         {
 144                 pBitmap = new Bitmap(sFilePathName.c_str(), FALSE);
 145                 GUID guid;
 146                 pBitmap->GetRawFormat(&guid);
 147
 148                 if (pBitmap->GetLastStatus() != Ok)
 149                 {
 150                         delete pBitmap;
 151                         pBitmap = NULL;
 152                 }
 153
 154                 // gdiplus only loads the first icon found in an icon file
 155                 // so we have to handle icon files ourselves :(
 156
 157                 // Even though gdiplus can load icons, it can't load the new
 158                 // icons from Vista - in Vista, the icon format changed slightly.
 159                 // But the LoadIcon/LoadImage API still can load those icons,
 160                 // at least those dimensions which are also used on pre-Vista
 161                 // systems.
 162                 // For that reason, we don't rely on gdiplus telling us if
 163                 // the image format is "icon" or not, we also check the
 164                 // file extension for ".ico".
 165                 std::transform(sFilePathName.begin(), sFilePathName.end(), sFilePathName.begin(), ::tolower);
 166                 bIsIcon = (guid == ImageFormatIcon) || (_tcsstr(sFilePathName.c_str(), _T(".ico")) != NULL);
 167                 bIsTiff = (guid == ImageFormatTIFF) || (_tcsstr(sFilePathName.c_str(), _T(".tiff")) != NULL);
 168
 169                 if (bIsIcon)
 170                 {
 171                         // Icon file, get special treatment...
 172                         if (pBitmap)
 173                         {
 174                                 // Cleanup first...
 175                                 delete (pBitmap);
 176                                 pBitmap = NULL;
 177                                 bIsIcon = true;
 178                         }
 179
 180                         CAutoFile hFile = CreateFile(sFilePathName.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 181                         if (hFile)
 182                         {
 183                                 BY_HANDLE_FILE_INFORMATION fileinfo;
 184                                 if (GetFileInformationByHandle(hFile, &fileinfo))
 185                                 {
 186                                         lpIcons = new BYTE[fileinfo.nFileSizeLow];
 187                                         DWORD readbytes;
 188                                         if (ReadFile(hFile, lpIcons, fileinfo.nFileSizeLow, &readbytes, NULL))
 189                                         {
 190                                                 // we have the icon. Now gather the information we need later
 191                                                 if (readbytes >= sizeof(ICONDIR))
 192                                                 {
 193                                                         // we are going to open same file second time so we have to close the file now
 194                                                         hFile.CloseHandle();
 195
 196                                                         LPICONDIR lpIconDir = (LPICONDIR)lpIcons;
 197                                                         if ((lpIconDir->idCount)&&(lpIconDir->idCount * sizeof(ICONDIR) <= fileinfo.nFileIndexLow))
 198                                                         {
 199                                                                 try
 200                                                                 {
 201                                                                         nCurrentIcon = 0;
 202                                                                         hIcons = new HICON[lpIconDir->idCount];
 203                                                                         m_Width = lpIconDir->idEntries[0].bWidth;
 204                                                                         m_Height = lpIconDir->idEntries[0].bHeight;
 205                                                                         for (int i=0; i<lpIconDir->idCount; ++i)
 206                                                                         {
 207                                                                                 hIcons[i] = (HICON)LoadImage(NULL, sFilePathName.c_str(), IMAGE_ICON,
 208                                                                                         lpIconDir->idEntries[i].bWidth,
 209                                                                                         lpIconDir->idEntries[i].bHeight,
 210                                                                                         LR_LOADFROMFILE);
 211                                                                         }
 212                                                                         bResult = true;
 213                                                                 }
 214                                                                 catch (...)
 215                                                                 {
 216                                                                         delete [] lpIcons;
 217                                                                         lpIcons = NULL;
 218                                                                         bResult = false;
 219                                                                 }
 220                                                         }
 221                                                         else
 222                                                         {
 223                                                                 delete [] lpIcons;
 224                                                                 lpIcons = NULL;
 225                                                                 bResult = false;
 226                                                         }
 227                                                 }
 228                                                 else
 229                                                 {
 230                                                         delete [] lpIcons;
 231                                                         lpIcons = NULL;
 232                                                         bResult = false;
 233                                                 }
 234                                         }
 235                                         else
 236                                         {
 237                                                 delete [] lpIcons;
 238                                                 lpIcons = NULL;
 239                                         }
 240                                 }
 241                         }
 242                 }
 243                 else if (pBitmap)       // Image loaded successfully with GDI+
 244                 {
 245                         m_Height = pBitmap->GetHeight();
 246                         m_Width = pBitmap->GetWidth();
 247                         bResult = true;
 248                 }
 249
 250                 // If still failed to load the file...
 251                 if (!bResult)
 252                 {
 253                         // Attempt to load the FreeImage library as an optional DLL to support additional formats
 254
 255                         // NOTE: Currently just loading via FreeImage & using GDI+ for drawing.
 256                         // It might be nice to remove this dependency in the future.
 257                         HMODULE hFreeImageLib = LoadLibrary(_T("FreeImage.dll"));
 258
 259                         // FreeImage DLL functions
 260                         typedef const char* (__stdcall *FreeImage_GetVersion_t)(void);
 261                         typedef int                     (__stdcall *FreeImage_GetFileType_t)(const TCHAR *filename, int size);
 262                         typedef int                     (__stdcall *FreeImage_GetFIFFromFilename_t)(const TCHAR *filename);
 263                         typedef void*           (__stdcall *FreeImage_Load_t)(int format, const TCHAR *filename, int flags);
 264                         typedef void            (__stdcall *FreeImage_Unload_t)(void* dib);
 265                         typedef int                     (__stdcall *FreeImage_GetColorType_t)(void* dib);
 266                         typedef unsigned        (__stdcall *FreeImage_GetWidth_t)(void* dib);
 267                         typedef unsigned        (__stdcall *FreeImage_GetHeight_t)(void* dib);
 268                         typedef void            (__stdcall *FreeImage_ConvertToRawBits_t)(BYTE *bits, void *dib, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown);
 269
 270                         //FreeImage_GetVersion_t FreeImage_GetVersion = NULL;
 271                         FreeImage_GetFileType_t FreeImage_GetFileType = NULL;
 272                         FreeImage_GetFIFFromFilename_t FreeImage_GetFIFFromFilename = NULL;
 273                         FreeImage_Load_t FreeImage_Load = NULL;
 274                         FreeImage_Unload_t FreeImage_Unload = NULL;
 275                         //FreeImage_GetColorType_t FreeImage_GetColorType = NULL;
 276                         FreeImage_GetWidth_t FreeImage_GetWidth = NULL;
 277                         FreeImage_GetHeight_t FreeImage_GetHeight = NULL;
 278                         FreeImage_ConvertToRawBits_t  FreeImage_ConvertToRawBits = NULL;
 279
 280                         if (hFreeImageLib)
 281                         {
 282                                 bool exportsValid = true;
 283
 284                                 //FreeImage_GetVersion = (FreeImage_GetVersion_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetVersion@0", valid);
 285                                 FreeImage_GetWidth = (FreeImage_GetWidth_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetWidth@4", exportsValid);
 286                                 FreeImage_GetHeight = (FreeImage_GetHeight_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetHeight@4", exportsValid);
 287                                 FreeImage_Unload = (FreeImage_Unload_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_Unload@4", exportsValid);
 288                                 FreeImage_ConvertToRawBits = (FreeImage_ConvertToRawBits_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_ConvertToRawBits@32", exportsValid);
 289
 290 #ifdef UNICODE
 291                                 FreeImage_GetFileType = (FreeImage_GetFileType_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetFileTypeU@8", exportsValid);
 292                                 FreeImage_GetFIFFromFilename = (FreeImage_GetFIFFromFilename_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetFIFFromFilenameU@4", exportsValid);
 293                                 FreeImage_Load = (FreeImage_Load_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_LoadU@12", exportsValid);
 294 #else
 295                                 FreeImage_GetFileType = (FreeImage_GetFileType_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetFileType@8", exportsValid);
 296                                 FreeImage_GetFIFFromFilename = (FreeImage_GetFIFFromFilename_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetFIFFromFilename@4", exportsValid);
 297                                 FreeImage_Load = (FreeImage_Load_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_Load@12", exportsValid);
 298 #endif
 299
 300                                 //const char* version = FreeImage_GetVersion();
 301
 302                                 // Check the DLL is using compatible exports
 303                                 if (exportsValid)
 304                                 {
 305                                         // Derive file type from file header.
 306                                         int fileType = FreeImage_GetFileType(sFilePathName.c_str(), 0);
 307                                         if (fileType < 0)
 308                                         {
 309                                                 // No file header available, attempt to parse file name for extension.
 310                                                 fileType = FreeImage_GetFIFFromFilename(sFilePathName.c_str());
 311                                         }
 312
 313                                         // If we have a valid file type
 314                                         if (fileType >= 0)
 315                                         {
 316                                                 void* dib = FreeImage_Load(fileType, sFilePathName.c_str(), 0);
 317
 318                                                 if (dib)
 319                                                 {
 320                                                         unsigned width = FreeImage_GetWidth(dib);
 321                                                         unsigned height = FreeImage_GetHeight(dib);
 322
 323                                                         // Create a GDI+ bitmap to load into...
 324                                                         pBitmap = new Bitmap(width, height, PixelFormat32bppARGB);
 325
 326                                                         if (pBitmap && pBitmap->GetLastStatus() == Ok)
 327                                                         {
 328                                                                 // Write & convert the loaded data into the GDI+ Bitmap
 329                                                                 Rect rect(0, 0, width, height);
 330                                                                 BitmapData bitmapData;
 331                                                                 if (pBitmap->LockBits(&rect, ImageLockModeWrite, PixelFormat32bppARGB, &bitmapData) == Ok)
 332                                                                 {
 333                                                                         FreeImage_ConvertToRawBits((BYTE*)bitmapData.Scan0, dib, bitmapData.Stride, 32, 0xff << RED_SHIFT, 0xff << GREEN_SHIFT, 0xff << BLUE_SHIFT, FALSE);
 334
 335                                                                         pBitmap->UnlockBits(&bitmapData);
 336
 337                                                                         m_Width = width;
 338                                                                         m_Height = height;
 339                                                                         bResult = true;
 340                                                                 }
 341                                                                 else    // Failed to lock the destination Bitmap
 342                                                                 {
 343                                                                         delete pBitmap;
 344                                                                         pBitmap = NULL;
 345                                                                 }
 346                                                         }
 347                                                         else    // Bitmap allocation failed
 348                                                         {
 349                                                                 delete pBitmap;
 350                                                                 pBitmap = NULL;
 351                                                         }
 352
 353                                                         FreeImage_Unload(dib);
 354                                                         dib = NULL;
 355                                                 }
 356                                         }
 357                                 }
 358
 359                                 FreeLibrary(hFreeImageLib);
 360                                 hFreeImageLib = NULL;
 361                         }
 362                 }
 363         }
 364         else    // GDI+ Unavailable...
 365         {
 366                 int nSize = 0;
 367                 pBitmap = NULL;
 368                 CAutoFile hFile = CreateFile(sFilePathName.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_HIDDEN, NULL);
 369                 if (hFile)
 370                 {
 371                         BY_HANDLE_FILE_INFORMATION fileinfo;
 372                         if (GetFileInformationByHandle(hFile, &fileinfo))
 373                         {
 374                                 BYTE * buffer = new BYTE[fileinfo.nFileSizeLow];
 375                                 DWORD readbytes;
 376                                 if (ReadFile(hFile, buffer, fileinfo.nFileSizeLow, &readbytes, NULL))
 377                                 {
 378                                         if (LoadPictureData(buffer, readbytes))
 379                                         {
 380                                                 m_nSize = fileinfo.nFileSizeLow;
 381                                                 bResult = true;
 382                                         }
 383                                 }
 384                                 delete [] buffer;
 385                         }
 386                 }
 387                 else
 388                         return bResult;
 389
 390                 m_Name = sFilePathName;
 391                 m_Weight = nSize; // Update Picture Size Info...
 392
 393                 if(m_IPicture != NULL) // Do Not Try To Read From Memory That Does Not Exist...
 394                 {
 395                         m_IPicture->get_Height(&m_Height);
 396                         m_IPicture->get_Width(&m_Width);
 397                         // Calculate Its Size On a "Standard" (96 DPI) Device Context
 398                         m_Height = MulDiv(m_Height, 96, HIMETRIC_INCH);
 399                         m_Width  = MulDiv(m_Width,  96, HIMETRIC_INCH);
 400                 }
 401                 else // Picture Data Is Not a Known Picture Type
 402                 {
 403                         m_Height = 0;
 404                         m_Width = 0;
 405                         bResult = false;
 406                 }
 407         }
 408
 409         if ((bResult)&&(m_nSize == 0))
 410         {
 411                 CAutoFile hFile = CreateFile(sFilePathName.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_HIDDEN, NULL);
 412                 if (hFile)
 413                 {
 414                         BY_HANDLE_FILE_INFORMATION fileinfo;
 415                         if (GetFileInformationByHandle(hFile, &fileinfo))
 416                         {
 417                                 m_nSize = fileinfo.nFileSizeLow;
 418                         }
 419                 }
 420         }
 421
 422         m_ColorDepth = GetColorDepth();
 423
 424         return(bResult);
 425 }
 426
 427 bool CPicture::LoadPictureData(BYTE *pBuffer, int nSize)
 428 {
 429         bool bResult = false;
 430
 431         HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, nSize);
 432
 433         if(hGlobal == NULL)
 434         {
 435                 return(false);
 436         }
 437
 438         void* pData = GlobalLock(hGlobal);
 439         if (pData == NULL)
 440                 return false;
 441         memcpy(pData, pBuffer, nSize);
 442         GlobalUnlock(hGlobal);
 443
 444         IStream* pStream = NULL;
 445
 446         if ((CreateStreamOnHGlobal(hGlobal, true, &pStream) == S_OK)&&(pStream))
 447         {
 448                 HRESULT hr = OleLoadPicture(pStream, nSize, false, IID_IPicture, (LPVOID *)&m_IPicture);
 449                 pStream->Release();
 450                 pStream = NULL;
 451
 452                 bResult = hr == S_OK;
 453         }
 454
 455         FreeResource(hGlobal); // 16Bit Windows Needs This (32Bit - Automatic Release)
 456
 457         return(bResult);
 458 }
 459
 460 bool CPicture::Show(HDC hDC, RECT DrawRect)
 461 {
 462         if (hDC == NULL)
 463                 return false;
 464         if (bIsIcon && lpIcons)
 465         {
 466                 ::DrawIconEx(hDC, DrawRect.left, DrawRect.top, hIcons[nCurrentIcon], DrawRect.right-DrawRect.left, DrawRect.bottom-DrawRect.top, 0, NULL, DI_NORMAL);
 467                 return true;
 468         }
 469         if ((m_IPicture == NULL)&&(pBitmap == NULL))
 470                 return false;
 471
 472         if (m_IPicture)
 473         {
 474                 long Width  = 0;
 475                 long Height = 0;
 476                 m_IPicture->get_Width(&Width);
 477                 m_IPicture->get_Height(&Height);
 478
 479                 HRESULT hr = m_IPicture->Render(hDC,
 480                         DrawRect.left,                  // Left
 481                         DrawRect.top,                   // Top
 482                         DrawRect.right - DrawRect.left, // Right
 483                         DrawRect.bottom - DrawRect.top, // Bottom
 484                         0,
 485                         Height,
 486                         Width,
 487                         -Height,
 488                         &DrawRect);
 489
 490                 if (SUCCEEDED(hr))
 491                         return(true);
 492         }
 493         else if (pBitmap)
 494         {
 495                 Graphics graphics(hDC);
 496                 graphics.SetInterpolationMode(m_ip);
 497                 graphics.SetPixelOffsetMode(PixelOffsetModeHighQuality);
 498                 ImageAttributes attr;
 499                 attr.SetWrapMode(WrapModeTileFlipXY);
 500                 Rect rect(DrawRect.left, DrawRect.top, DrawRect.right-DrawRect.left, DrawRect.bottom-DrawRect.top);
 501                 graphics.DrawImage(pBitmap, rect, 0, 0, m_Width, m_Height, UnitPixel, &attr);
 502                 return true;
 503         }
 504
 505         return(false);
 506 }
 507
 508 bool CPicture::UpdateSizeOnDC(HDC hDC)
 509 {
 510         if(hDC == NULL || m_IPicture == NULL) { m_Height = 0; m_Width = 0; return(false); };
 511
 512         m_IPicture->get_Height(&m_Height);
 513         m_IPicture->get_Width(&m_Width);
 514
 515         // Get Current DPI - Dot Per Inch
 516         int CurrentDPI_X = GetDeviceCaps(hDC, LOGPIXELSX);
 517         int CurrentDPI_Y = GetDeviceCaps(hDC, LOGPIXELSY);
 518
 519         m_Height = MulDiv(m_Height, CurrentDPI_Y, HIMETRIC_INCH);
 520         m_Width  = MulDiv(m_Width,  CurrentDPI_X, HIMETRIC_INCH);
 521
 522         return(true);
 523 }
 524
 525 UINT CPicture::GetColorDepth() const
 526 {
 527         if (bIsIcon && lpIcons)
 528         {
 529                 LPICONDIR lpIconDir = (LPICONDIR)lpIcons;
 530                 return lpIconDir->idEntries[nCurrentIcon].wBitCount;
 531         }
 532         switch (GetPixelFormat())
 533         {
 534         case PixelFormat1bppIndexed:
 535                 return 1;
 536         case PixelFormat4bppIndexed:
 537                 return 4;
 538         case PixelFormat8bppIndexed:
 539                 return 8;
 540         case PixelFormat16bppARGB1555:
 541         case PixelFormat16bppGrayScale:
 542         case PixelFormat16bppRGB555:
 543         case PixelFormat16bppRGB565:
 544                 return 16;
 545         case PixelFormat24bppRGB:
 546                 return 24;
 547         case PixelFormat32bppARGB:
 548         case PixelFormat32bppPARGB:
 549         case PixelFormat32bppRGB:
 550                 return 32;
 551         case PixelFormat48bppRGB:
 552                 return 48;
 553         case PixelFormat64bppARGB:
 554         case PixelFormat64bppPARGB:
 555                 return 64;
 556         }
 557         return 0;
 558 }
 559
 560 UINT CPicture::GetNumberOfFrames(int dimension)
 561 {
 562         if (bIsIcon && lpIcons)
 563         {
 564                 return 1;
 565         }
 566         if (pBitmap == NULL)
 567                 return 0;
 568         UINT count = pBitmap->GetFrameDimensionsCount();
 569         GUID* pDimensionIDs = (GUID*)malloc(sizeof(GUID)*count);
 570
 571         pBitmap->GetFrameDimensionsList(pDimensionIDs, count);
 572
 573         UINT frameCount = pBitmap->GetFrameCount(&pDimensionIDs[dimension]);
 574
 575         free(pDimensionIDs);
 576         return frameCount;
 577 }
 578
 579 UINT CPicture::GetNumberOfDimensions()
 580 {
 581         if (bIsIcon && lpIcons)
 582         {
 583                 LPICONDIR lpIconDir = (LPICONDIR)lpIcons;
 584                 return lpIconDir->idCount;
 585         }
 586         return pBitmap ? pBitmap->GetFrameDimensionsCount() : 0;
 587 }
 588
 589 long CPicture::SetActiveFrame(UINT frame)
 590 {
 591         if (bIsIcon && lpIcons)
 592         {
 593                 nCurrentIcon = frame-1;
 594                 m_Height = GetHeight();
 595                 m_Width = GetWidth();
 596                 return 0;
 597         }
 598         if (pBitmap == NULL)
 599                 return 0;
 600         UINT count = 0;
 601         count = pBitmap->GetFrameDimensionsCount();
 602         GUID* pDimensionIDs = (GUID*)malloc(sizeof(GUID)*count);
 603
 604         pBitmap->GetFrameDimensionsList(pDimensionIDs, count);
 605
 606         UINT frameCount = pBitmap->GetFrameCount(&pDimensionIDs[0]);
 607
 608         free(pDimensionIDs);
 609
 610         if (frame > frameCount)
 611                 return 0;
 612
 613         GUID pageGuid = FrameDimensionTime;
 614         if (bIsTiff)
 615                 pageGuid = FrameDimensionPage;
 616         pBitmap->SelectActiveFrame(&pageGuid, frame);
 617
 618         // Assume that the image has a property item of type PropertyItemEquipMake.
 619         // Get the size of that property item.
 620         int nSize = pBitmap->GetPropertyItemSize(PropertyTagFrameDelay);
 621
 622         // Allocate a buffer to receive the property item.
 623         PropertyItem* pPropertyItem = (PropertyItem*) malloc(nSize);
 624
 625         Status s = pBitmap->GetPropertyItem(PropertyTagFrameDelay, nSize, pPropertyItem);
 626
 627         UINT prevframe = frame;
 628         if (prevframe > 0)
 629                 prevframe--;
 630         long delay = 0;
 631         if (s == Ok)
 632         {
 633                 delay = ((long*)pPropertyItem->value)[prevframe] * 10;
 634         }
 635         free(pPropertyItem);
 636         m_Height = GetHeight();
 637         m_Width = GetWidth();
 638         return delay;
 639 }
 640
 641 UINT CPicture::GetHeight() const
 642 {
 643         if ((bIsIcon)&&(lpIcons))
 644         {
 645                 LPICONDIR lpIconDir = (LPICONDIR)lpIcons;
 646                 return lpIconDir->idEntries[nCurrentIcon].bHeight;
 647         }
 648         return pBitmap ? pBitmap->GetHeight() : 0;
 649 }
 650
 651 UINT CPicture::GetWidth() const
 652 {
 653         if ((bIsIcon)&&(lpIcons))
 654         {
 655                 LPICONDIR lpIconDir = (LPICONDIR)lpIcons;
 656                 return lpIconDir->idEntries[nCurrentIcon].bWidth;
 657         }
 658         return pBitmap ? pBitmap->GetWidth() : 0;
 659 }
 660
 661 PixelFormat CPicture::GetPixelFormat() const
 662 {
 663         if ((bIsIcon)&&(lpIcons))
 664         {
 665                 LPICONDIR lpIconDir = (LPICONDIR)lpIcons;
 666                 if (lpIconDir->idEntries[nCurrentIcon].wPlanes == 1)
 667                 {
 668                         if (lpIconDir->idEntries[nCurrentIcon].wBitCount == 1)
 669                                 return PixelFormat1bppIndexed;
 670                         if (lpIconDir->idEntries[nCurrentIcon].wBitCount == 4)
 671                                 return PixelFormat4bppIndexed;
 672                         if (lpIconDir->idEntries[nCurrentIcon].wBitCount == 8)
 673                                 return PixelFormat8bppIndexed;
 674                 }
 675                 if (lpIconDir->idEntries[nCurrentIcon].wBitCount == 32)
 676                 {
 677                         return PixelFormat32bppARGB;
 678                 }
 679         }
 680         return pBitmap ? pBitmap->GetPixelFormat() : 0;
 681 }