/*------------------------------------

* VisualPng.C -- Shows a PNG image

*------------------------------------

*

* Copyright 2000, Willem van Schaik.

*

* This code is released under the libpng license.

* For conditions of distribution and use, see the disclaimer

* and license in png.h

*/

/* switches */

/* defines */

#define PROGNAME "VisualPng"

#define LONGNAME "Win32 Viewer for PNG-files"

#define VERSION "1.0 of 2000 June 07"

/* constants */

#define MARGIN 8

/* standard includes */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <windows.h>

#include <zlib.h>

/* application includes */

#include "png.h"

#include "pngfile.h"

#include "resource.h"

/* macros */

/* function prototypes */

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);

BOOL CALLBACK AboutDlgProc (HWND, UINT, WPARAM, LPARAM) ;

BOOL CenterAbout (HWND hwndChild, HWND hwndParent);

BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,

int *pFileIndex);

BOOL SearchPngList (TCHAR *pFileList, int FileCount, int *pFileIndex,

PTSTR pstrPrevName, PTSTR pstrNextName);

BOOL LoadImageFile(HWND hwnd, PTSTR pstrPathName,

png_byte **ppbImage, int *pxImgSize, int *pyImgSize, int *piChannels,

png_color *pBkgColor);

BOOL DisplayImage (HWND hwnd, BYTE **ppDib,

BYTE **ppDiData, int cxWinSize, int cyWinSize,

BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,

BOOL bStretched);

BOOL InitBitmap (

BYTE *pDiData, int cxWinSize, int cyWinSize);

BOOL FillBitmap (

BYTE *pDiData, int cxWinSize, int cyWinSize,

BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,

BOOL bStretched);

/* a few global variables */

static char *szProgName = PROGNAME;

static char *szAppName = LONGNAME;

static char *szIconName = PROGNAME;

static char szCmdFileName [MAX_PATH];

/* MAIN routine */

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,

PSTR szCmdLine, int iCmdShow)

{

HACCEL hAccel;

HWND hwnd;

MSG msg;

WNDCLASS wndclass;

int ixBorders, iyBorders;

wndclass.style = CS_HREDRAW | CS_VREDRAW;

wndclass.lpfnWndProc = WndProc;

wndclass.cbClsExtra = 0;

wndclass.cbWndExtra = 0;

wndclass.hInstance = hInstance;

wndclass.hIcon = LoadIcon (hInstance, szIconName) ;

wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);

wndclass.hbrBackground = NULL; /* (HBRUSH) GetStockObject (GRAY_BRUSH); */

wndclass.lpszMenuName = szProgName;

wndclass.lpszClassName = szProgName;

if (!RegisterClass (&wndclass))

{

MessageBox (NULL, TEXT ("Error: this program requires Windows NT!"),

szProgName, MB_ICONERROR);

return 0;

}

/* if filename given on commandline, store it */

if ((szCmdLine != NULL) && (*szCmdLine != '\0'))

if (szCmdLine[0] == '"')

strncpy (szCmdFileName, szCmdLine + 1, strlen(szCmdLine) - 2);

else

strcpy (szCmdFileName, szCmdLine);

else

strcpy (szCmdFileName, "");

/* calculate size of window-borders */

ixBorders = 2 * (GetSystemMetrics (SM_CXBORDER) +

GetSystemMetrics (SM_CXDLGFRAME));

iyBorders = 2 * (GetSystemMetrics (SM_CYBORDER) +

GetSystemMetrics (SM_CYDLGFRAME)) +

GetSystemMetrics (SM_CYCAPTION) +

GetSystemMetrics (SM_CYMENUSIZE) +

1; /* WvS: don't ask me why? */

hwnd = CreateWindow (szProgName, szAppName,

WS_OVERLAPPEDWINDOW,

CW_USEDEFAULT, CW_USEDEFAULT,

512 + 2 * MARGIN + ixBorders, 384 + 2 * MARGIN + iyBorders,

/* CW_USEDEFAULT, CW_USEDEFAULT, */

NULL, NULL, hInstance, NULL);

ShowWindow (hwnd, iCmdShow);

UpdateWindow (hwnd);

hAccel = LoadAccelerators (hInstance, szProgName);

while (GetMessage (&msg, NULL, 0, 0))

{

if (!TranslateAccelerator (hwnd, hAccel, &msg))

{

TranslateMessage (&msg);

DispatchMessage (&msg);

}

}

return msg.wParam;

}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,

LPARAM lParam)

{

static HINSTANCE hInstance ;

static HDC hdc;

static PAINTSTRUCT ps;

static HMENU hMenu;

static BITMAPFILEHEADER *pbmfh;

static BITMAPINFOHEADER *pbmih;

static BYTE *pbImage;

static int cxWinSize, cyWinSize;

static int cxImgSize, cyImgSize;

static int cImgChannels;

static png_color bkgColor = {127, 127, 127};

static BOOL bStretched = TRUE;

static BYTE *pDib = NULL;

static BYTE *pDiData = NULL;

static TCHAR szImgPathName [MAX_PATH];

static TCHAR szTitleName [MAX_PATH];

static TCHAR *pPngFileList = NULL;

static int iPngFileCount;

static int iPngFileIndex;

BOOL bOk;

switch (message)

{

case WM_CREATE:

hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;

PngFileInitialize (hwnd);

strcpy (szImgPathName, "");

/* in case we process file given on command-line */

if (szCmdFileName[0] != '\0')

{

strcpy (szImgPathName, szCmdFileName);

/* read the other png-files in the directory for later */

/* next/previous commands */

BuildPngList (szImgPathName, &pPngFileList, &iPngFileCount,

&iPngFileIndex);

/* load the image from file */

if (!LoadImageFile (hwnd, szImgPathName,

&pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))

return 0;

/* invalidate the client area for later update */

InvalidateRect (hwnd, NULL, TRUE);

/* display the PNG into the DIBitmap */

DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,

pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);

}

return 0;

case WM_SIZE:

cxWinSize = LOWORD (lParam);

cyWinSize = HIWORD (lParam);

/* invalidate the client area for later update */

InvalidateRect (hwnd, NULL, TRUE);

/* display the PNG into the DIBitmap */

DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,

pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);

return 0;

case WM_INITMENUPOPUP:

hMenu = GetMenu (hwnd);

if (pbImage)

EnableMenuItem (hMenu, IDM_FILE_SAVE, MF_ENABLED);

else

EnableMenuItem (hMenu, IDM_FILE_SAVE, MF_GRAYED);

return 0;

case WM_COMMAND:

hMenu = GetMenu (hwnd);

switch (LOWORD (wParam))

{

case IDM_FILE_OPEN:

/* show the File Open dialog box */

if (!PngFileOpenDlg (hwnd, szImgPathName, szTitleName))

return 0;

/* read the other png-files in the directory for later */

/* next/previous commands */

BuildPngList (szImgPathName, &pPngFileList, &iPngFileCount,

&iPngFileIndex);

/* load the image from file */

if (!LoadImageFile (hwnd, szImgPathName,

&pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))

return 0;

/* invalidate the client area for later update */

InvalidateRect (hwnd, NULL, TRUE);

/* display the PNG into the DIBitmap */

DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,

pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);

return 0;

case IDM_FILE_SAVE:

/* show the File Save dialog box */

if (!PngFileSaveDlg (hwnd, szImgPathName, szTitleName))

return 0;

/* save the PNG to a disk file */

SetCursor (LoadCursor (NULL, IDC_WAIT));

ShowCursor (TRUE);

bOk = PngSaveImage (szImgPathName, pDiData, cxWinSize, cyWinSize,

bkgColor);

ShowCursor (FALSE);

SetCursor (LoadCursor (NULL, IDC_ARROW));

if (!bOk)

MessageBox (hwnd, TEXT ("Error in saving the PNG image"),

szProgName, MB_ICONEXCLAMATION | MB_OK);

return 0;

case IDM_FILE_NEXT:

/* read next entry in the directory */

if (SearchPngList (pPngFileList, iPngFileCount, &iPngFileIndex,

NULL, szImgPathName))

{

if (strcmp (szImgPathName, "") == 0)

return 0;

/* load the image from file */

if (!LoadImageFile (hwnd, szImgPathName, &pbImage,

&cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))

return 0;

/* invalidate the client area for later update */

InvalidateRect (hwnd, NULL, TRUE);

/* display the PNG into the DIBitmap */

DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,

pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);

}

return 0;

case IDM_FILE_PREVIOUS:

/* read previous entry in the directory */

if (SearchPngList (pPngFileList, iPngFileCount, &iPngFileIndex,

szImgPathName, NULL))

{

if (strcmp (szImgPathName, "") == 0)

return 0;

/* load the image from file */

if (!LoadImageFile (hwnd, szImgPathName, &pbImage, &cxImgSize,

&cyImgSize, &cImgChannels, &bkgColor))

return 0;

/* invalidate the client area for later update */

InvalidateRect (hwnd, NULL, TRUE);

/* display the PNG into the DIBitmap */

DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,

pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);

}

return 0;

case IDM_FILE_EXIT:

/* more cleanup needed... */

/* free image buffer */

if (pDib != NULL)

{

free (pDib);

pDib = NULL;

}

/* free file-list */

if (pPngFileList != NULL)

{

free (pPngFileList);

pPngFileList = NULL;

}

/* let's go ... */

exit (0);

return 0;

case IDM_OPTIONS_STRETCH:

bStretched = !bStretched;

if (bStretched)

CheckMenuItem (hMenu, IDM_OPTIONS_STRETCH, MF_CHECKED);

else

CheckMenuItem (hMenu, IDM_OPTIONS_STRETCH, MF_UNCHECKED);

/* invalidate the client area for later update */

InvalidateRect (hwnd, NULL, TRUE);

/* display the PNG into the DIBitmap */

DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,

pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);

return 0;

case IDM_HELP_ABOUT:

DialogBox (hInstance, TEXT ("AboutBox"), hwnd, AboutDlgProc) ;

return 0;

} /* end switch */

break;

case WM_PAINT:

hdc = BeginPaint (hwnd, &ps);

if (pDib)

SetDIBitsToDevice (hdc, 0, 0, cxWinSize, cyWinSize, 0, 0,

0, cyWinSize, pDiData, (BITMAPINFO *) pDib, DIB_RGB_COLORS);

EndPaint (hwnd, &ps);

return 0;

case WM_DESTROY:

if (pbmfh)

{

free (pbmfh);

pbmfh = NULL;

}

PostQuitMessage (0);

return 0;

}

return DefWindowProc (hwnd, message, wParam, lParam);

}

BOOL CALLBACK AboutDlgProc (HWND hDlg, UINT message,

WPARAM wParam, LPARAM lParam)

{

switch (message)

{

case WM_INITDIALOG :

ShowWindow (hDlg, SW_HIDE);

CenterAbout (hDlg, GetWindow (hDlg, GW_OWNER));

ShowWindow (hDlg, SW_SHOW);

return TRUE ;

case WM_COMMAND :

switch (LOWORD (wParam))

{

case IDOK :

case IDCANCEL :

EndDialog (hDlg, 0) ;

return TRUE ;

}

break ;

}

return FALSE ;

}

/*---------------

* CenterAbout

*---------------

*/

BOOL CenterAbout (HWND hwndChild, HWND hwndParent)

{

RECT rChild, rParent, rWorkArea;

int wChild, hChild, wParent, hParent;

int xNew, yNew;

BOOL bResult;

/* Get the Height and Width of the child window */

GetWindowRect (hwndChild, &rChild);

wChild = rChild.right - rChild.left;

hChild = rChild.bottom - rChild.top;

/* Get the Height and Width of the parent window */

GetWindowRect (hwndParent, &rParent);

wParent = rParent.right - rParent.left;

hParent = rParent.bottom - rParent.top;

/* Get the limits of the 'workarea' */

bResult = SystemParametersInfo(

SPI_GETWORKAREA, /* system parameter to query or set */

sizeof(RECT),

&rWorkArea,

0);

if (!bResult) {

rWorkArea.left = rWorkArea.top = 0;

rWorkArea.right = GetSystemMetrics(SM_CXSCREEN);

rWorkArea.bottom = GetSystemMetrics(SM_CYSCREEN);

}

/* Calculate new X position, then adjust for workarea */

xNew = rParent.left + ((wParent - wChild) /2);

if (xNew < rWorkArea.left) {

xNew = rWorkArea.left;

} else if ((xNew+wChild) > rWorkArea.right) {

xNew = rWorkArea.right - wChild;

}

/* Calculate new Y position, then adjust for workarea */

yNew = rParent.top + ((hParent - hChild) /2);

if (yNew < rWorkArea.top) {

yNew = rWorkArea.top;

} else if ((yNew+hChild) > rWorkArea.bottom) {

yNew = rWorkArea.bottom - hChild;

}

/* Set it, and return */

return SetWindowPos (hwndChild, NULL, xNew, yNew, 0, 0, SWP_NOSIZE |

SWP_NOZORDER);

}

/*----------------

* BuildPngList

*----------------

*/

BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,

int *pFileIndex)

{

static TCHAR szImgPathName [MAX_PATH];

static TCHAR szImgFileName [MAX_PATH];

static TCHAR szImgFindName [MAX_PATH];

WIN32_FIND_DATA finddata;

HANDLE hFind;

static TCHAR szTmp [MAX_PATH];

BOOL bOk;

int i, ii;

int j, jj;

/* free previous file-list */

if (*ppFileList != NULL)

{

free (*ppFileList);

*ppFileList = NULL;

}

/* extract foldername, filename and search-name */

strcpy (szImgPathName, pstrPathName);

strcpy (szImgFileName, strrchr (pstrPathName, '\\') + 1);

strcpy (szImgFindName, szImgPathName);

*(strrchr (szImgFindName, '\\') + 1) = '\0';

strcat (szImgFindName, "*.png");

/* first cycle: count number of files in directory for memory allocation */

*pFileCount = 0;

hFind = FindFirstFile(szImgFindName, &finddata);

bOk = (hFind != (HANDLE) -1);

while (bOk)

{

*pFileCount += 1;

bOk = FindNextFile(hFind, &finddata);

}

FindClose(hFind);

/* allocation memory for file-list */

*ppFileList = (TCHAR *) malloc (*pFileCount * MAX_PATH);

/* second cycle: read directory and store filenames in file-list */

hFind = FindFirstFile(szImgFindName, &finddata);

bOk = (hFind != (HANDLE) -1);

i = 0;

ii = 0;

while (bOk)

{

strcpy (*ppFileList + ii, szImgPathName);

strcpy (strrchr(*ppFileList + ii, '\\') + 1, finddata.cFileName);

if (strcmp(pstrPathName, *ppFileList + ii) == 0)

*pFileIndex = i;

ii += MAX_PATH;

i++;

bOk = FindNextFile(hFind, &finddata);

}

FindClose(hFind);

/* finally we must sort the file-list */

for (i = 0; i < *pFileCount - 1; i++)

{

ii = i * MAX_PATH;

for (j = i+1; j < *pFileCount; j++)

{

jj = j * MAX_PATH;

if (strcmp (*ppFileList + ii, *ppFileList + jj) > 0)

{

strcpy (szTmp, *ppFileList + jj);

strcpy (*ppFileList + jj, *ppFileList + ii);

strcpy (*ppFileList + ii, szTmp);

/* check if this was the current image that we moved */

if (*pFileIndex == i)

*pFileIndex = j;

else

if (*pFileIndex == j)

*pFileIndex = i;

}

}

}

return TRUE;

}

/*----------------

* SearchPngList

*----------------

*/

BOOL SearchPngList (

TCHAR *pFileList, int FileCount, int *pFileIndex,

PTSTR pstrPrevName, PTSTR pstrNextName)

{

if (FileCount > 0)

{

/* get previous entry */

if (pstrPrevName != NULL)

{

if (*pFileIndex > 0)

*pFileIndex -= 1;

else

*pFileIndex = FileCount - 1;

strcpy (pstrPrevName, pFileList + (*pFileIndex * MAX_PATH));

}

/* get next entry */

if (pstrNextName != NULL)

{

if (*pFileIndex < FileCount - 1)

*pFileIndex += 1;

else

*pFileIndex = 0;

strcpy (pstrNextName, pFileList + (*pFileIndex * MAX_PATH));

}

return TRUE;

}

else

{

return FALSE;

}

}

/*-----------------

* LoadImageFile

*-----------------

*/

BOOL LoadImageFile (HWND hwnd, PTSTR pstrPathName,

png_byte **ppbImage, int *pxImgSize, int *pyImgSize,

int *piChannels, png_color *pBkgColor)

{

static TCHAR szTmp [MAX_PATH];

/* if there's an existing PNG, free the memory */

if (*ppbImage)

{

free (*ppbImage);

*ppbImage = NULL;

}

/* Load the entire PNG into memory */

SetCursor (LoadCursor (NULL, IDC_WAIT));

ShowCursor (TRUE);

PngLoadImage (pstrPathName, ppbImage, pxImgSize, pyImgSize, piChannels,

pBkgColor);

ShowCursor (FALSE);

SetCursor (LoadCursor (NULL, IDC_ARROW));

if (*ppbImage != NULL)

{

sprintf (szTmp, "VisualPng - %s", strrchr(pstrPathName, '\\') + 1);

SetWindowText (hwnd, szTmp);

}

else

{

MessageBox (hwnd, TEXT ("Error in loading the PNG image"),

szProgName, MB_ICONEXCLAMATION | MB_OK);

return FALSE;

}

return TRUE;

}

/*----------------

* DisplayImage

*----------------

*/

BOOL DisplayImage (HWND hwnd, BYTE **ppDib,

BYTE **ppDiData, int cxWinSize, int cyWinSize,

BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,

BOOL bStretched)

{

BYTE *pDib = *ppDib;

BYTE *pDiData = *ppDiData;

/* BITMAPFILEHEADER *pbmfh; */

BITMAPINFOHEADER *pbmih;

WORD wDIRowBytes;

png_color bkgBlack = {0, 0, 0};

png_color bkgGray = {127, 127, 127};

png_color bkgWhite = {255, 255, 255};

/* allocate memory for the Device Independant bitmap */

wDIRowBytes = (WORD) ((3 * cxWinSize + 3L) >> 2) << 2;

if (pDib)

{

free (pDib);

pDib = NULL;

}

if (!(pDib = (BYTE *) malloc (sizeof(BITMAPINFOHEADER) +

wDIRowBytes * cyWinSize)))

{

MessageBox (hwnd, TEXT ("Error in displaying the PNG image"),

szProgName, MB_ICONEXCLAMATION | MB_OK);

*ppDib = pDib = NULL;

return FALSE;

}

*ppDib = pDib;

memset (pDib, 0, sizeof(BITMAPINFOHEADER));

/* initialize the dib-structure */

pbmih = (BITMAPINFOHEADER *) pDib;

pbmih->biSize = sizeof(BITMAPINFOHEADER);

pbmih->biWidth = cxWinSize;

pbmih->biHeight = -((long) cyWinSize);

pbmih->biPlanes = 1;

pbmih->biBitCount = 24;

pbmih->biCompression = 0;

pDiData = pDib + sizeof(BITMAPINFOHEADER);

*ppDiData = pDiData;

/* first fill bitmap with gray and image border */

InitBitmap (pDiData, cxWinSize, cyWinSize);

/* then fill bitmap with image */

if (pbImage)

{

FillBitmap (

pDiData, cxWinSize, cyWinSize,

pbImage, cxImgSize, cyImgSize, cImgChannels,

bStretched);

}

return TRUE;

}

/*--------------

* InitBitmap

*--------------

*/

BOOL InitBitmap (BYTE *pDiData, int cxWinSize, int cyWinSize)

{

BYTE *dst;

int x, y, col;

/* initialize the background with gray */

dst = pDiData;

for (y = 0; y < cyWinSize; y++)

{

col = 0;

for (x = 0; x < cxWinSize; x++)

{

/* fill with GRAY */

*dst++ = 127;

*dst++ = 127;

*dst++ = 127;

col += 3;

}

/* rows start on 4 byte boundaries */

while ((col % 4) != 0)

{

dst++;

col++;

}

}

return TRUE;

}

/*--------------

* FillBitmap

*--------------

*/

BOOL FillBitmap (

BYTE *pDiData, int cxWinSize, int cyWinSize,

BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,

BOOL bStretched)

{

BYTE *pStretchedImage;

BYTE *pImg;

BYTE *src, *dst;

BYTE r, g, b, a;

const int cDIChannels = 3;

WORD wImgRowBytes;

WORD wDIRowBytes;

int cxNewSize, cyNewSize;

int cxImgPos, cyImgPos;

int xImg, yImg;

int xWin, yWin;

int xOld, yOld;

int xNew, yNew;

if (bStretched)

{

cxNewSize = cxWinSize - 2 * MARGIN;

cyNewSize = cyWinSize - 2 * MARGIN;

/* stretch the image to it's window determined size */

/* the following two are mathematically the same, but the first

* has side-effects because of rounding

*/

/* if ((cyNewSize / cxNewSize) > (cyImgSize / cxImgSize)) */

if ((cyNewSize * cxImgSize) > (cyImgSize * cxNewSize))

{

cyNewSize = cxNewSize * cyImgSize / cxImgSize;

cxImgPos = MARGIN;

cyImgPos = (cyWinSize - cyNewSize) / 2;

}

else

{

cxNewSize = cyNewSize * cxImgSize / cyImgSize;

cyImgPos = MARGIN;

cxImgPos = (cxWinSize - cxNewSize) / 2;

}

pStretchedImage = malloc (cImgChannels * cxNewSize * cyNewSize);

pImg = pStretchedImage;

for (yNew = 0; yNew < cyNewSize; yNew++)

{

yOld = yNew * cyImgSize / cyNewSize;

for (xNew = 0; xNew < cxNewSize; xNew++)

{

xOld = xNew * cxImgSize / cxNewSize;

r = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 0);

g = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 1);

b = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld) + 2);

*pImg++ = r;

*pImg++ = g;

*pImg++ = b;

if (cImgChannels == 4)

{

a = *(pbImage + cImgChannels * ((yOld * cxImgSize) + xOld)

+ 3);

*pImg++ = a;

}

}

}

/* calculate row-bytes */

wImgRowBytes = cImgChannels * cxNewSize;

wDIRowBytes = (WORD) ((cDIChannels * cxWinSize + 3L) >> 2) << 2;

/* copy image to screen */

for (yImg = 0, yWin = cyImgPos; yImg < cyNewSize; yImg++, yWin++)

{

if (yWin >= cyWinSize - cyImgPos)

break;

src = pStretchedImage + yImg * wImgRowBytes;

dst = pDiData + yWin * wDIRowBytes + cxImgPos * cDIChannels;

for (xImg = 0, xWin = cxImgPos; xImg < cxNewSize; xImg++, xWin++)

{

if (xWin >= cxWinSize - cxImgPos)

break;

r = *src++;

g = *src++;

b = *src++;

*dst++ = b; /* note the reverse order */

*dst++ = g;

*dst++ = r;

if (cImgChannels == 4)

{

a = *src++;

}

}

}

/* free memory */

if (pStretchedImage != NULL)

{

free (pStretchedImage);

pStretchedImage = NULL;

}

}

/* process the image not-stretched */

else

{

/* calculate the central position */

cxImgPos = (cxWinSize - cxImgSize) / 2;

cyImgPos = (cyWinSize - cyImgSize) / 2;

/* check for image larger than window */

if (cxImgPos < MARGIN)

cxImgPos = MARGIN;

if (cyImgPos < MARGIN)

cyImgPos = MARGIN;

/* calculate both row-bytes */

wImgRowBytes = cImgChannels * cxImgSize;

wDIRowBytes = (WORD) ((cDIChannels * cxWinSize + 3L) >> 2) << 2;

/* copy image to screen */

for (yImg = 0, yWin = cyImgPos; yImg < cyImgSize; yImg++, yWin++)

{

if (yWin >= cyWinSize - MARGIN)

break;

src = pbImage + yImg * wImgRowBytes;

dst = pDiData + yWin * wDIRowBytes + cxImgPos * cDIChannels;

for (xImg = 0, xWin = cxImgPos; xImg < cxImgSize; xImg++, xWin++)

{

if (xWin >= cxWinSize - MARGIN)

break;

r = *src++;

g = *src++;

b = *src++;

*dst++ = b; /* note the reverse order */

*dst++ = g;

*dst++ = r;

if (cImgChannels == 4)

{

a = *src++;

}

}

}

}

return TRUE;

}

/*-----------------

* end of source

*-----------------

*/