// 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 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//-----------------