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