workbench/libs/png/contrib/visupng/VisualPng.c

   1 /*------------------------------------
   2  *  VisualPng.C -- Shows a PNG image
   3  *------------------------------------
   4  *
   5  * Copyright 2000,2017 Willem van Schaik.
   6  *
   7  * This code is released under the libpng license.
   8  * For conditions of distribution and use, see the disclaimer
   9  * and license in png.h
  10  */
  11
  12 /* switches */
  13
  14 /* defines */
  15
  16 #define PROGNAME  "VisualPng"
  17 #define LONGNAME  "Win32 Viewer for PNG-files"
  18 #define VERSION   "1.0 of 2000 June 07"
  19
  20 /* constants */
  21
  22 #define MARGIN 8
  23
  24 /* standard includes */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <windows.h>
  30 #include <zlib.h>
  31
  32 /* application includes */
  33
  34 #include "png.h"
  35 #include "pngfile.h"
  36 #include "resource.h"
  37
  38 /* macros */
  39
  40 /* function prototypes */
  41
  42 LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
  43 BOOL    CALLBACK AboutDlgProc (HWND, UINT, WPARAM, LPARAM) ;
  44
  45 BOOL CenterAbout (HWND hwndChild, HWND hwndParent);
  46
  47 BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
  48         int *pFileIndex);
  49
  50 BOOL SearchPngList (TCHAR *pFileList, int FileCount, int *pFileIndex,
  51         PTSTR pstrPrevName, PTSTR pstrNextName);
  52
  53 BOOL LoadImageFile(HWND hwnd, PTSTR pstrPathName,
  54         png_byte **ppbImage, int *pxImgSize, int *pyImgSize, int *piChannels,
  55         png_color *pBkgColor);
  56
  57 BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
  58         BYTE **ppDiData, int cxWinSize, int cyWinSize,
  59         BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
  60         BOOL bStretched);
  61
  62 BOOL InitBitmap (
  63         BYTE *pDiData, int cxWinSize, int cyWinSize);
  64
  65 BOOL FillBitmap (
  66         BYTE *pDiData, int cxWinSize, int cyWinSize,
  67         BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
  68         BOOL bStretched);
  69
  70 /* a few global variables */
  71
  72 static char *szProgName = PROGNAME;
  73 static char *szAppName = LONGNAME;
  74 static char *szIconName = PROGNAME;
  75 static char szCmdFileName [MAX_PATH];
  76
  77 /* MAIN routine */
  78
  79 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
  80                     PSTR szCmdLine, int iCmdShow)
  81 {
  82     HACCEL   hAccel;
  83     HWND     hwnd;
  84     MSG      msg;
  85     WNDCLASS wndclass;
  86     int ixBorders, iyBorders;
  87
  88     wndclass.style         = CS_HREDRAW | CS_VREDRAW;
  89     wndclass.lpfnWndProc   = WndProc;
  90     wndclass.cbClsExtra    = 0;
  91     wndclass.cbWndExtra    = 0;
  92     wndclass.hInstance     = hInstance;
  93     wndclass.hIcon         = LoadIcon (hInstance, szIconName) ;
  94     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
  95     wndclass.hbrBackground = NULL; /* (HBRUSH) GetStockObject (GRAY_BRUSH); */
  96     wndclass.lpszMenuName  = szProgName;
  97     wndclass.lpszClassName = szProgName;
  98
  99     if (!RegisterClass (&wndclass))
 100     {
 101         MessageBox (NULL, TEXT ("Error: this program requires Windows NT!"),
 102             szProgName, MB_ICONERROR);
 103         return 0;
 104     }
 105
 106     /* if filename given on commandline, store it */
 107     if ((szCmdLine != NULL) && (*szCmdLine != '\0'))
 108         if (szCmdLine[0] == '"')
 109             strncpy (szCmdFileName, szCmdLine + 1, strlen(szCmdLine) - 2);
 110         else
 111             strcpy (szCmdFileName, szCmdLine);
 112     else
 113         strcpy (szCmdFileName, "");
 114
 115     /* calculate size of window-borders */
 116     ixBorders = 2 * (GetSystemMetrics (SM_CXBORDER) +
 117                      GetSystemMetrics (SM_CXDLGFRAME));
 118     iyBorders = 2 * (GetSystemMetrics (SM_CYBORDER) +
 119                      GetSystemMetrics (SM_CYDLGFRAME)) +
 120                      GetSystemMetrics (SM_CYCAPTION) +
 121                      GetSystemMetrics (SM_CYMENUSIZE) +
 122                      1; /* WvS: don't ask me why?  */
 123
 124     hwnd = CreateWindow (szProgName, szAppName,
 125         WS_OVERLAPPEDWINDOW,
 126         CW_USEDEFAULT, CW_USEDEFAULT,
 127         512 + 2 * MARGIN + ixBorders, 384 + 2 * MARGIN + iyBorders,
 128 /*      CW_USEDEFAULT, CW_USEDEFAULT, */
 129         NULL, NULL, hInstance, NULL);
 130
 131     ShowWindow (hwnd, iCmdShow);
 132     UpdateWindow (hwnd);
 133
 134     hAccel = LoadAccelerators (hInstance, szProgName);
 135
 136     while (GetMessage (&msg, NULL, 0, 0))
 137     {
 138         if (!TranslateAccelerator (hwnd, hAccel, &msg))
 139         {
 140             TranslateMessage (&msg);
 141             DispatchMessage (&msg);
 142         }
 143     }
 144     return msg.wParam;
 145 }
 146
 147 LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
 148         LPARAM lParam)
 149 {
 150     static HINSTANCE          hInstance ;
 151     static HDC                hdc;
 152     static PAINTSTRUCT        ps;
 153     static HMENU              hMenu;
 154
 155     static BITMAPFILEHEADER  *pbmfh;
 156     static BITMAPINFOHEADER  *pbmih;
 157     static BYTE              *pbImage;
 158     static int                cxWinSize, cyWinSize;
 159     static int                cxImgSize, cyImgSize;
 160     static int                cImgChannels;
 161     static png_color          bkgColor = {127, 127, 127};
 162
 163     static BOOL               bStretched = TRUE;
 164
 165     static BYTE              *pDib = NULL;
 166     static BYTE              *pDiData = NULL;
 167
 168     static TCHAR              szImgPathName [MAX_PATH];
 169     static TCHAR              szTitleName [MAX_PATH];
 170
 171     static TCHAR             *pPngFileList = NULL;
 172     static int                iPngFileCount;
 173     static int                iPngFileIndex;
 174
 175     BOOL                      bOk;
 176
 177     switch (message)
 178     {
 179     case WM_CREATE:
 180         hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;
 181         PngFileInitialize (hwnd);
 182
 183         strcpy (szImgPathName, "");
 184
 185         /* in case we process file given on command-line */
 186
 187         if (szCmdFileName[0] != '\0')
 188         {
 189             strcpy (szImgPathName, szCmdFileName);
 190
 191             /* read the other png-files in the directory for later */
 192             /* next/previous commands */
 193
 194             BuildPngList (szImgPathName, &pPngFileList, &iPngFileCount,
 195                           &iPngFileIndex);
 196
 197             /* load the image from file */
 198
 199             if (!LoadImageFile (hwnd, szImgPathName,
 200                 &pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
 201                 return 0;
 202
 203             /* invalidate the client area for later update */
 204
 205             InvalidateRect (hwnd, NULL, TRUE);
 206
 207             /* display the PNG into the DIBitmap */
 208
 209             DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
 210                 pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
 211         }
 212
 213         return 0;
 214
 215     case WM_SIZE:
 216         cxWinSize = LOWORD (lParam);
 217         cyWinSize = HIWORD (lParam);
 218
 219         /* invalidate the client area for later update */
 220
 221         InvalidateRect (hwnd, NULL, TRUE);
 222
 223         /* display the PNG into the DIBitmap */
 224
 225         DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
 226             pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
 227
 228         return 0;
 229
 230     case WM_INITMENUPOPUP:
 231         hMenu = GetMenu (hwnd);
 232
 233         if (pbImage)
 234             EnableMenuItem (hMenu, IDM_FILE_SAVE, MF_ENABLED);
 235         else
 236             EnableMenuItem (hMenu, IDM_FILE_SAVE, MF_GRAYED);
 237
 238         return 0;
 239
 240     case WM_COMMAND:
 241         hMenu = GetMenu (hwnd);
 242
 243         switch (LOWORD (wParam))
 244         {
 245         case IDM_FILE_OPEN:
 246
 247             /* show the File Open dialog box */
 248
 249             if (!PngFileOpenDlg (hwnd, szImgPathName, szTitleName))
 250                 return 0;
 251
 252             /* read the other png-files in the directory for later */
 253             /* next/previous commands */
 254
 255             BuildPngList (szImgPathName, &pPngFileList, &iPngFileCount,
 256                           &iPngFileIndex);
 257
 258             /* load the image from file */
 259
 260             if (!LoadImageFile (hwnd, szImgPathName,
 261                 &pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
 262                 return 0;
 263
 264             /* invalidate the client area for later update */
 265
 266             InvalidateRect (hwnd, NULL, TRUE);
 267
 268             /* display the PNG into the DIBitmap */
 269
 270             DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
 271                 pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
 272
 273             return 0;
 274
 275         case IDM_FILE_SAVE:
 276
 277             /* show the File Save dialog box */
 278
 279             if (!PngFileSaveDlg (hwnd, szImgPathName, szTitleName))
 280                 return 0;
 281
 282             /* save the PNG to a disk file */
 283
 284             SetCursor (LoadCursor (NULL, IDC_WAIT));
 285             ShowCursor (TRUE);
 286
 287             bOk = PngSaveImage (szImgPathName, pDiData, cxWinSize, cyWinSize,
 288                   bkgColor);
 289
 290             ShowCursor (FALSE);
 291             SetCursor (LoadCursor (NULL, IDC_ARROW));
 292
 293             if (!bOk)
 294                 MessageBox (hwnd, TEXT ("Error in saving the PNG image"),
 295                 szProgName, MB_ICONEXCLAMATION | MB_OK);
 296             return 0;
 297
 298         case IDM_FILE_NEXT:
 299
 300             /* read next entry in the directory */
 301
 302             if (SearchPngList (pPngFileList, iPngFileCount, &iPngFileIndex,
 303                 NULL, szImgPathName))
 304             {
 305                 if (strcmp (szImgPathName, "") == 0)
 306                     return 0;
 307
 308                 /* load the image from file */
 309
 310                 if (!LoadImageFile (hwnd, szImgPathName, &pbImage,
 311                         &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
 312                     return 0;
 313
 314                 /* invalidate the client area for later update */
 315
 316                 InvalidateRect (hwnd, NULL, TRUE);
 317
 318                 /* display the PNG into the DIBitmap */
 319
 320                 DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
 321                     pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
 322             }
 323
 324             return 0;
 325
 326         case IDM_FILE_PREVIOUS:
 327
 328             /* read previous entry in the directory */
 329
 330             if (SearchPngList (pPngFileList, iPngFileCount, &iPngFileIndex,
 331                 szImgPathName, NULL))
 332             {
 333
 334                 if (strcmp (szImgPathName, "") == 0)
 335                     return 0;
 336
 337                 /* load the image from file */
 338
 339                 if (!LoadImageFile (hwnd, szImgPathName, &pbImage, &cxImgSize,
 340                     &cyImgSize, &cImgChannels, &bkgColor))
 341                     return 0;
 342
 343                 /* invalidate the client area for later update */
 344
 345                 InvalidateRect (hwnd, NULL, TRUE);
 346
 347                 /* display the PNG into the DIBitmap */
 348
 349                 DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
 350                     pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
 351             }
 352
 353             return 0;
 354
 355         case IDM_FILE_EXIT:
 356
 357             /* more cleanup needed... */
 358
 359             /* free image buffer */
 360
 361             if (pDib != NULL)
 362             {
 363                 free (pDib);
 364                 pDib = NULL;
 365             }
 366
 367             /* free file-list */
 368
 369             if (pPngFileList != NULL)
 370             {
 371                 free (pPngFileList);
 372                 pPngFileList = NULL;
 373             }
 374
 375             /* let's go ... */
 376
 377             exit (0);
 378
 379             return 0;
 380
 381         case IDM_OPTIONS_STRETCH:
 382             bStretched = !bStretched;
 383             if (bStretched)
 384                 CheckMenuItem (hMenu, IDM_OPTIONS_STRETCH, MF_CHECKED);
 385             else
 386                 CheckMenuItem (hMenu, IDM_OPTIONS_STRETCH, MF_UNCHECKED);
 387
 388             /* invalidate the client area for later update */
 389
 390             InvalidateRect (hwnd, NULL, TRUE);
 391
 392             /* display the PNG into the DIBitmap */
 393
 394             DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
 395                 pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
 396
 397             return 0;
 398
 399         case IDM_HELP_ABOUT:
 400             DialogBox (hInstance, TEXT ("AboutBox"), hwnd, AboutDlgProc) ;
 401             return 0;
 402
 403         } /* end switch */
 404
 405         break;
 406
 407     case WM_PAINT:
 408         hdc = BeginPaint (hwnd, &ps);
 409
 410         if (pDib)
 411             SetDIBitsToDevice (hdc, 0, 0, cxWinSize, cyWinSize, 0, 0,
 412                 0, cyWinSize, pDiData, (BITMAPINFO *) pDib, DIB_RGB_COLORS);
 413
 414         EndPaint (hwnd, &ps);
 415         return 0;
 416
 417     case WM_DESTROY:
 418         if (pbmfh)
 419         {
 420             free (pbmfh);
 421             pbmfh = NULL;
 422         }
 423
 424         PostQuitMessage (0);
 425         return 0;
 426     }
 427
 428     return DefWindowProc (hwnd, message, wParam, lParam);
 429 }
 430
 431 BOOL CALLBACK AboutDlgProc (HWND hDlg, UINT message,
 432                             WPARAM wParam, LPARAM lParam)
 433 {
 434      switch (message)
 435      {
 436      case WM_INITDIALOG :
 437           ShowWindow (hDlg, SW_HIDE);
 438           CenterAbout (hDlg, GetWindow (hDlg, GW_OWNER));
 439           ShowWindow (hDlg, SW_SHOW);
 440           return TRUE ;
 441
 442      case WM_COMMAND :
 443           switch (LOWORD (wParam))
 444           {
 445           case IDOK :
 446           case IDCANCEL :
 447                EndDialog (hDlg, 0) ;
 448                return TRUE ;
 449           }
 450           break ;
 451      }
 452      return FALSE ;
 453 }
 454
 455 /*---------------
 456  *  CenterAbout
 457  *---------------
 458  */
 459 BOOL CenterAbout (HWND hwndChild, HWND hwndParent)
 460 {
 461    RECT    rChild, rParent, rWorkArea;
 462    int     wChild, hChild, wParent, hParent;
 463    int     xNew, yNew;
 464    BOOL  bResult;
 465
 466    /* Get the Height and Width of the child window */
 467    GetWindowRect (hwndChild, &rChild);
 468    wChild = rChild.right - rChild.left;
 469    hChild = rChild.bottom - rChild.top;
 470
 471    /* Get the Height and Width of the parent window */
 472    GetWindowRect (hwndParent, &rParent);
 473    wParent = rParent.right - rParent.left;
 474    hParent = rParent.bottom - rParent.top;
 475
 476    /* Get the limits of the 'workarea' */
 477    bResult = SystemParametersInfo(
 478       SPI_GETWORKAREA,  /* system parameter to query or set */
 479       sizeof(RECT),
 480       &rWorkArea,
 481       0);
 482    if (!bResult) {
 483       rWorkArea.left = rWorkArea.top = 0;
 484       rWorkArea.right = GetSystemMetrics(SM_CXSCREEN);
 485       rWorkArea.bottom = GetSystemMetrics(SM_CYSCREEN);
 486    }
 487
 488    /* Calculate new X position, then adjust for workarea */
 489    xNew = rParent.left + ((wParent - wChild) /2);
 490    if (xNew < rWorkArea.left) {
 491       xNew = rWorkArea.left;
 492    } else if ((xNew+wChild) > rWorkArea.right) {
 493       xNew = rWorkArea.right - wChild;
 494    }
 495
 496    /* Calculate new Y position, then adjust for workarea */
 497    yNew = rParent.top  + ((hParent - hChild) /2);
 498    if (yNew < rWorkArea.top) {
 499       yNew = rWorkArea.top;
 500    } else if ((yNew+hChild) > rWorkArea.bottom) {
 501       yNew = rWorkArea.bottom - hChild;
 502    }
 503
 504    /* Set it, and return */
 505    return SetWindowPos (hwndChild, NULL, xNew, yNew, 0, 0, SWP_NOSIZE |
 506           SWP_NOZORDER);
 507 }
 508
 509 /*----------------
 510  *  BuildPngList
 511  *----------------
 512  */
 513 BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
 514      int *pFileIndex)
 515 {
 516     static TCHAR              szImgPathName [MAX_PATH];
 517     static TCHAR              szImgFileName [MAX_PATH];
 518     static TCHAR              szImgFindName [MAX_PATH];
 519
 520     WIN32_FIND_DATA           finddata;
 521     HANDLE                    hFind;
 522
 523     static TCHAR              szTmp [MAX_PATH];
 524     BOOL                      bOk;
 525     int                       i, ii;
 526     int                       j, jj;
 527
 528     /* free previous file-list */
 529
 530     if (*ppFileList != NULL)
 531     {
 532         free (*ppFileList);
 533         *ppFileList = NULL;
 534     }
 535
 536     /* extract foldername, filename and search-name */
 537
 538     strcpy (szImgPathName, pstrPathName);
 539     strcpy (szImgFileName, strrchr (pstrPathName, '\\') + 1);
 540
 541     strcpy (szImgFindName, szImgPathName);
 542     *(strrchr (szImgFindName, '\\') + 1) = '\0';
 543     strcat (szImgFindName, "*.png");
 544
 545     /* first cycle: count number of files in directory for memory allocation */
 546
 547     *pFileCount = 0;
 548
 549     hFind = FindFirstFile(szImgFindName, &finddata);
 550     bOk = (hFind != (HANDLE) -1);
 551
 552     while (bOk)
 553     {
 554         *pFileCount += 1;
 555         bOk = FindNextFile(hFind, &finddata);
 556     }
 557     FindClose(hFind);
 558
 559     /* allocation memory for file-list */
 560
 561     *ppFileList = (TCHAR *) malloc (*pFileCount * MAX_PATH);
 562
 563     /* second cycle: read directory and store filenames in file-list */
 564
 565     hFind = FindFirstFile(szImgFindName, &finddata);
 566     bOk = (hFind != (HANDLE) -1);
 567
 568     i = 0;
 569     ii = 0;
 570     while (bOk)
 571     {
 572         strcpy (*ppFileList + ii, szImgPathName);
 573         strcpy (strrchr(*ppFileList + ii, '\\') + 1, finddata.cFileName);
 574
 575         if (strcmp(pstrPathName, *ppFileList + ii) == 0)
 576             *pFileIndex = i;
 577
 578         ii += MAX_PATH;
 579         i++;
 580
 581         bOk = FindNextFile(hFind, &finddata);
 582     }
 583     FindClose(hFind);
 584
 585     /* finally we must sort the file-list */
 586
 587     for (i = 0; i < *pFileCount - 1; i++)
 588     {
 589         ii = i * MAX_PATH;
 590         for (j = i+1; j < *pFileCount; j++)
 591         {
 592             jj = j * MAX_PATH;
 593             if (strcmp (*ppFileList + ii, *ppFileList + jj) > 0)
 594             {
 595                 strcpy (szTmp, *ppFileList + jj);
 596                 strcpy (*ppFileList + jj, *ppFileList + ii);
 597                 strcpy (*ppFileList + ii, szTmp);
 598
 599                 /* check if this was the current image that we moved */
 600
 601                 if (*pFileIndex == i)
 602                     *pFileIndex = j;
 603                 else
 604                     if (*pFileIndex == j)
 605                         *pFileIndex = i;
 606             }
 607         }
 608     }
 609
 610     return TRUE;
 611 }
 612
 613 /*----------------
 614  *  SearchPngList
 615  *----------------
 616  */
 617
 618 BOOL SearchPngList (
 619         TCHAR *pFileList, int FileCount, int *pFileIndex,
 620         PTSTR pstrPrevName, PTSTR pstrNextName)
 621 {
 622     if (FileCount > 0)
 623     {
 624         /* get previous entry */
 625
 626         if (pstrPrevName != NULL)
 627         {
 628             if (*pFileIndex > 0)
 629                 *pFileIndex -= 1;
 630             else
 631                 *pFileIndex = FileCount - 1;
 632
 633             strcpy (pstrPrevName, pFileList + (*pFileIndex * MAX_PATH));
 634         }
 635
 636         /* get next entry */
 637
 638         if (pstrNextName != NULL)
 639         {
 640             if (*pFileIndex < FileCount - 1)
 641                 *pFileIndex += 1;
 642             else
 643                 *pFileIndex = 0;
 644
 645             strcpy (pstrNextName, pFileList + (*pFileIndex * MAX_PATH));
 646         }
 647
 648         return TRUE;
 649     }
 650     else
 651     {
 652         return FALSE;
 653     }
 654 }
 655
 656 /*-----------------
 657  *  LoadImageFile
 658  *-----------------
 659  */
 660
 661 BOOL LoadImageFile (HWND hwnd, PTSTR pstrPathName,
 662                 png_byte **ppbImage, int *pxImgSize, int *pyImgSize,
 663                 int *piChannels, png_color *pBkgColor)
 664 {
 665     static TCHAR szTmp [MAX_PATH];
 666
 667     /* if there's an existing PNG, free the memory */
 668
 669     if (*ppbImage)
 670     {
 671         free (*ppbImage);
 672         *ppbImage = NULL;
 673     }
 674
 675     /* Load the entire PNG into memory */
 676
 677     SetCursor (LoadCursor (NULL, IDC_WAIT));
 678     ShowCursor (TRUE);
 679
 680     PngLoadImage (pstrPathName, ppbImage, pxImgSize, pyImgSize, piChannels,
 681                   pBkgColor);
 682
 683     ShowCursor (FALSE);
 684     SetCursor (LoadCursor (NULL, IDC_ARROW));
 685
 686     if (*ppbImage != NULL)
 687     {
 688         sprintf (szTmp, "VisualPng - %s", strrchr(pstrPathName, '\\') + 1);
 689         SetWindowText (hwnd, szTmp);
 690     }
 691     else
 692     {
 693         MessageBox (hwnd, TEXT ("Error in loading the PNG image"),
 694             szProgName, MB_ICONEXCLAMATION | MB_OK);
 695         return FALSE;
 696     }
 697
 698     return TRUE;
 699 }
 700
 701 /*----------------
 702  *  DisplayImage
 703  *----------------
 704  */
 705 BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
 706         BYTE **ppDiData, int cxWinSize, int cyWinSize,
 707         BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
 708         BOOL bStretched)
 709 {
 710     BYTE                       *pDib = *ppDib;
 711     BYTE                       *pDiData = *ppDiData;
 712     /* BITMAPFILEHEADER        *pbmfh; */
 713     BITMAPINFOHEADER           *pbmih;
 714     WORD                        wDIRowBytes;
 715     png_color                   bkgBlack = {0, 0, 0};
 716     png_color                   bkgGray  = {127, 127, 127};
 717     png_color                   bkgWhite = {255, 255, 255};
 718
 719     /* allocate memory for the Device Independent bitmap */
 720
 721     wDIRowBytes = (WORD) ((3 * cxWinSize + 3L) >> 2) << 2;
 722
 723     if (pDib)
 724     {
 725         free (pDib);
 726         pDib = NULL;
 727     }
 728
 729     if (cyWinSize > ((size_t)(-1))/wDIRowBytes) {
 730     {
 731         MessageBox (hwnd, TEXT ("Visual PNG: image is too big");
 732     }
 733     if (!(pDib = (BYTE *) malloc (sizeof(BITMAPINFOHEADER) +
 734         wDIRowBytes * cyWinSize)))
 735     {
 736         MessageBox (hwnd, TEXT ("Error in displaying the PNG image"),
 737             szProgName, MB_ICONEXCLAMATION | MB_OK);
 738         *ppDib = pDib = NULL;
 739         return FALSE;
 740     }
 741     *ppDib = pDib;
 742     memset (pDib, 0, sizeof(BITMAPINFOHEADER));
 743
 744     /* initialize the dib-structure */
 745
 746     pbmih = (BITMAPINFOHEADER *) pDib;
 747     pbmih->biSize = sizeof(BITMAPINFOHEADER);
 748     pbmih->biWidth = cxWinSize;
 749     pbmih->biHeight = -((long) cyWinSize);
 750     pbmih->biPlanes = 1;
 751     pbmih->biBitCount = 24;
 752     pbmih->biCompression = 0;
 753     pDiData = pDib + sizeof(BITMAPINFOHEADER);
 754     *ppDiData = pDiData;
 755
 756     /* first fill bitmap with gray and image border */
 757
 758     InitBitmap (pDiData, cxWinSize, cyWinSize);
 759
 760     /* then fill bitmap with image */
 761
 762     if (pbImage)
 763     {
 764         FillBitmap (
 765             pDiData, cxWinSize, cyWinSize,
 766             pbImage, cxImgSize, cyImgSize, cImgChannels,
 767             bStretched);
 768     }
 769
 770     return TRUE;
 771 }
 772
 773 /*--------------
 774  *  InitBitmap
 775  *--------------
 776  */
 777 BOOL InitBitmap (BYTE *pDiData, int cxWinSize, int cyWinSize)
 778 {
 779     BYTE *dst;
 780     int x, y, col;
 781
 782     /* initialize the background with gray */
 783
 784     dst = pDiData;
 785     for (y = 0; y < cyWinSize; y++)
 786     {
 787         col = 0;
 788         for (x = 0; x < cxWinSize; x++)
 789         {
 790             /* fill with GRAY */
 791             *dst++ = 127;
 792             *dst++ = 127;
 793             *dst++ = 127;
 794             col += 3;
 795         }
 796         /* rows start on 4 byte boundaries */
 797         while ((col % 4) != 0)
 798         {
 799             dst++;
 800             col++;
 801         }
 802     }
 803
 804     return TRUE;
 805 }
 806
 807 /*--------------
 808  *  FillBitmap
 809  *--------------
 810  */
 811 BOOL FillBitmap (
 812         BYTE *pDiData, int cxWinSize, int cyWinSize,
 813         BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
 814         BOOL bStretched)
 815 {
 816     BYTE *pStretchedImage;
 817     BYTE *pImg;
 818     BYTE *src, *dst;
 819     BYTE r, g, b, a;
 820     const int cDIChannels = 3;
 821     WORD wImgRowBytes;
 822     WORD wDIRowBytes;
 823     int cxNewSize, cyNewSize;
 824     int cxImgPos, cyImgPos;
 825     int xImg, yImg;
 826     int xWin, yWin;
 827     int xOld, yOld;
 828     int xNew, yNew;
 829
 830     if (bStretched)
 831     {
 832         cxNewSize = cxWinSize - 2 * MARGIN;
 833         cyNewSize = cyWinSize - 2 * MARGIN;
 834
 835         /* stretch the image to it's window determined size */
 836
 837         /* the following two are mathematically the same, but the first
 838          * has side-effects because of rounding
 839          */
 840 /*      if ((cyNewSize / cxNewSize) > (cyImgSize / cxImgSize)) */
 841         if ((cyNewSize * cxImgSize) > (cyImgSize * cxNewSize))
 842         {
 843             cyNewSize = cxNewSize * cyImgSize / cxImgSize;
 844             cxImgPos = MARGIN;
 845             cyImgPos = (cyWinSize - cyNewSize) / 2;
 846         }
 847         else
 848         {
 849             cxNewSize = cyNewSize * cxImgSize / cyImgSize;
 850             cyImgPos = MARGIN;
 851             cxImgPos = (cxWinSize - cxNewSize) / 2;
 852         }
 853
 854         if (cyNewSize > ((size_t)(-1))/(cImgChannels * cxNewSize)) {
 855         {
 856             MessageBox (hwnd, TEXT ("Visual PNG: stretched image is too big");
 857         }
 858         pStretchedImage = malloc (cImgChannels * cxNewSize * cyNewSize);
 859         pImg = pStretchedImage;
 860
 861         for (yNew = 0; yNew < cyNewSize; yNew++)
 862         {
 863             yOld = yNew * cyImgSize / cyNewSize;
 864             for (xNew = 0; xNew < cxNewSize; xNew++)
 865             {
 866                 xOld = xNew * cxImgSize / cxNewSize;
 867
 868                 r = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 0);
 869                 g = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 1);
 870                 b = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 2);
 871                 *pImg++ = r;
 872                 *pImg++ = g;
 873                 *pImg++ = b;
 874                 if (cImgChannels == 4)
 875                 {
 876                     a = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld)
 877                         + 3);
 878                     *pImg++ = a;
 879                 }
 880             }
 881         }
 882
 883         /* calculate row-bytes */
 884
 885         wImgRowBytes = cImgChannels * cxNewSize;
 886         wDIRowBytes = (WORD) ((cDIChannels * cxWinSize + 3L) >> 2) << 2;
 887
 888         /* copy image to screen */
 889
 890         for (yImg = 0, yWin = cyImgPos; yImg < cyNewSize; yImg++, yWin++)
 891         {
 892             if (yWin >= cyWinSize - cyImgPos)
 893                 break;
 894             src = pStretchedImage + yImg * wImgRowBytes;
 895             dst = pDiData + yWin * wDIRowBytes + cxImgPos * cDIChannels;
 896
 897             for (xImg = 0, xWin = cxImgPos; xImg < cxNewSize; xImg++, xWin++)
 898             {
 899                 if (xWin >= cxWinSize - cxImgPos)
 900                     break;
 901                 r = *src++;
 902                 g = *src++;
 903                 b = *src++;
 904                 *dst++ = b; /* note the reverse order  */
 905                 *dst++ = g;
 906                 *dst++ = r;
 907                 if (cImgChannels == 4)
 908                 {
 909                     a = *src++;
 910                 }
 911             }
 912         }
 913
 914         /* free memory */
 915
 916         if (pStretchedImage != NULL)
 917         {
 918             free (pStretchedImage);
 919             pStretchedImage = NULL;
 920         }
 921
 922     }
 923
 924     /* process the image not-stretched */
 925
 926     else
 927     {
 928         /* calculate the central position */
 929
 930         cxImgPos = (cxWinSize - cxImgSize) / 2;
 931         cyImgPos = (cyWinSize - cyImgSize) / 2;
 932
 933         /* check for image larger than window */
 934
 935         if (cxImgPos < MARGIN)
 936             cxImgPos = MARGIN;
 937         if (cyImgPos < MARGIN)
 938             cyImgPos = MARGIN;
 939
 940         /* calculate both row-bytes */
 941
 942         wImgRowBytes = cImgChannels * cxImgSize;
 943         wDIRowBytes = (WORD) ((cDIChannels * cxWinSize + 3L) >> 2) << 2;
 944
 945         /* copy image to screen */
 946
 947         for (yImg = 0, yWin = cyImgPos; yImg < cyImgSize; yImg++, yWin++)
 948         {
 949             if (yWin >= cyWinSize - MARGIN)
 950                 break;
 951             src = pbImage + yImg * wImgRowBytes;
 952             dst = pDiData + yWin * wDIRowBytes + cxImgPos * cDIChannels;
 953
 954             for (xImg = 0, xWin = cxImgPos; xImg < cxImgSize; xImg++, xWin++)
 955             {
 956                 if (xWin >= cxWinSize - MARGIN)
 957                     break;
 958                 r = *src++;
 959                 g = *src++;
 960                 b = *src++;
 961                 *dst++ = b; /* note the reverse order  */
 962                 *dst++ = g;
 963                 *dst++ = r;
 964                 if (cImgChannels == 4)
 965                 {
 966                     a = *src++;
 967                 }
 968             }
 969         }
 970     }
 971
 972     return TRUE;
 973 }
 974
 975 /*-----------------
 976  *  end of source
 977  *-----------------
 978  */