windows-xp/Source/XPSP1/NT/shell/osshell/accesory/clipbrd/clipfile.c

/*
 * CLIPFILE.C - Windows Clipboard File I/O Routines
 *
 *  Copyright 1985-92, Microsoft Corporation
 */

/* NOTE:
 *   When saving the contents of the clipboard we SetClipboardData(fmt, NULL)
 *   to free up the memory associated with each clipboard format.  Then
 *   after we are done saving we take over as the clipboard owner.  This
 *   causes OWNERDRAW formats to be lost in the save process.
 */


/*
*
*    Touched by    :    Anas Jarrah
*    On Date        :    May 11/1992.
*    Revision remarks by Anas Jarrah ext #15201
*    This file has been changed to comply with the Unicode standard
*    Following is a quick overview of what I have done.
*
*    Was            Changed it into        Remark
*    ===            ===============        ======
*    CHAR              TCHAR             if it refers to a text elements
*    LPCHAR & LPSTR    LPTSTR            if it refers to text.
*    LPCHAR & LPSTR    LPBYTE            if it does not refer to text
*    "..."             TEXT("...")       compile time macro resolves it.
*    '...'             TEXT('...')       same
*    strlen            CharStrLen        compile time macro resolves it.
*    strcpy            CharStrCpy        compile time macro resolves it.
*    strcmp            CharStrCmp        compile time macro resolves it.
*    strcat            CharStrCat        compile time macro resolves it.
*    LoadResource      LoadResource(A/W) NT compiles resource strings into
*                                         Unicode binaries
*    MOpenFile()       MapOpenFile/MOpenFile   Depending on whether Unicode is defined or not.
*                                              This is a temporary cluge, That has to be taken care of.
*
*
*/

#include "clipbrd.h"
#include "dib.h"

#define ATTRDIRLIST 0xC010

// Windows 3.1 programs were packed on byte boundaries.
#pragma pack(1)
// Windows 3.1 BITMAP struct - used to save Win 3.1 .CLP files
typedef struct {
   WORD bmType;
   WORD bmWidth;
   WORD bmHeight;
   WORD bmWidthBytes;
   BYTE bmPlanes;
   BYTE bmBitsPixel;
   LPVOID bmBits;
   } WIN31BITMAP;
#pragma pack()

/* EXTERN data */
extern BOOL fAnythingToRender;

/* FORWARD procs */
HBITMAP PASCAL BitmapToBitmap(HBITMAP, WORD, WORD);

TCHAR       szFileSpecifier[] = TEXT("*.CLP");
TCHAR       szFileName[MAX_PATH];
BOOL        fNTReadFileFormat;
#ifdef JAPAN
extern TCHAR szCaptionName[];
#endif

/* ofSaveStruct is required; Otherwise, the following bug will occur
 *   When the contents of the clipboard are loaded from a file, the
 *   ofStruct is used to open the file and the data handles assigned to
 *   the clipboard are NULL because of DELAYED RENDERING; Delayed
 *   rendering will be done by reading from the file (ofStruct). But,
 *   now, if the contents are to be saved into another file, it should
 *   use the same ofStruct, because data has to be obtained from this
 *   file using delayed rendering; So, a temporary ofSaveStruct is used
 *   to hold the saved file's info; Once the save is successful, the
 *   contents of ofSaveStruct are copied onto ofStruct
 */
/* the ofStruct and ofSaveStruct are replaced by szFileName and
 * szSaveFileName strings.
 */
TCHAR       szSaveFileName[MAX_PATH];
BOOL        fNTSaveFileFormat;


/*
 *  IsWriteable()
 *
 * Test if a clipboard format is writeable(i.e. if it makes sense to write it)
 * OWNERDRAW and others can't be written because we (CLIPBRD) will become the
 * owner when the files are reopened.
 */

BOOL NEAR PASCAL IsWriteable(UINT Format)

{
  /* Are the PRIVATEFIRST and PRIVATELAST things right? */
  if ((Format >= CF_PRIVATEFIRST && Format <= CF_PRIVATELAST) || Format == CF_OWNERDISPLAY)
      return(FALSE);
  if (!fNTSaveFileFormat &&
      (Format == CF_UNICODETEXT || Format == CF_ENHMETAFILE || Format == CF_DSPENHMETAFILE))
      return(FALSE);
  return(TRUE);
}


/*
 *  ReadClipboardFromFile()
 *
 * Read in a clipboard file and register all the formats in delayed mode.
 * to render things for real reopen the file specified by szFileName (was ofStruct).
 *
 * NOTE:
 *    This makes us the clipboard owner.
 *
 * Bug 14564:  Changed return value to a short integer noting why the
 * reading failed.
 * Return Value:  0  Success
 *                1  Improper format
 *                2  OpenClipboard failed
 */
#define READFILE_SUCCESS         0
#define READFILE_IMPROPERFORMAT  1
#define READFILE_OPENCLIPBRDFAIL 2

short NEAR PASCAL ReadClipboardFromFile(HWND hwnd,INT fh)

{
register WORD i;
FILEHEADER    FileHeader;
FORMATHEADER  FormatHeader;

    /* Read the File Header */
    _lread(fh, (LPBYTE)&FileHeader, sizeof(FILEHEADER));

    /* Sanity check, make sure this is one of ours. */
#ifndef JAPAN
    if (FileHeader.magic == CLP_NT_ID)
        fNTReadFileFormat = TRUE;
    else if (FileHeader.magic == CLP_ID)
        fNTReadFileFormat = FALSE;
    else
        return(READFILE_IMPROPERFORMAT);

    if (FileHeader.FormatCount > 100)
        return(READFILE_IMPROPERFORMAT);
#else
    if (FileHeader.magic == CLP_NT_ID)
        fNTReadFileFormat = TRUE;
    else if (FileHeader.magic == CLP_ID)
        fNTReadFileFormat = FALSE;
    else
        goto improperformat;

    if (FileHeader.FormatCount > 100)
    {

improperformat:
    TCHAR szOutMessage[BUFFERLEN];
    TCHAR szCapBuffer[SMALLBUFFERLEN];

    LoadStringW(hInst, IDS_NAME, szCapBuffer, SMALLBUFFERLEN);
    LoadStringW(hInst, IDS_ENOTVALIDFILE, szOutMessage, BUFFERLEN);
    MessageBox(hwnd, szOutMessage,szCapBuffer, MB_OK | MB_ICONEXCLAMATION);
        return(READFILE_IMPROPERFORMAT);
    }
#endif

    /* We become the clipboard owner here! */
    if (!OpenClipboard(hwnd))
        return(READFILE_OPENCLIPBRDFAIL);

    EmptyClipboard();

    for (i=0; i < FileHeader.FormatCount; i++)
        {

        if (fNTReadFileFormat)
            _lread(fh, (LPBYTE)&(FormatHeader.FormatID), sizeof(FormatHeader.FormatID));
        else {
            FormatHeader.FormatID = 0;  /* initialize the high WORD */
            _lread(fh, (LPBYTE)&(FormatHeader.FormatID), sizeof(WORD));
        }
        _lread(fh, (LPBYTE)&(FormatHeader.DataLen), sizeof(FormatHeader.DataLen));
        _lread(fh, (LPBYTE)&(FormatHeader.DataOffset), sizeof(FormatHeader.DataOffset));
        _lread(fh, (LPBYTE)&(FormatHeader.Name), sizeof(FormatHeader.Name));

        if (PRIVATE_FORMAT(FormatHeader.FormatID))
            FormatHeader.FormatID = (UINT)RegisterClipboardFormat(FormatHeader.Name);

        /* Delayed Render. */
        SetClipboardData(FormatHeader.FormatID, NULL);
        }

    /* Now, clipbrd viewer has something to render */
    if (FileHeader.FormatCount > 0)
        fAnythingToRender = TRUE;

    CloseClipboard();
    return(READFILE_SUCCESS);
}


/*
 *  OpenClipboardFile()
 */

void NEAR PASCAL OpenClipboardFile(HWND hwnd)

{
INT     fh;

   lstrcpy(szFileName, TEXT(""));
   OFN.lpstrTitle = szOpenCaption;
   OFN.lpstrFile  = szFileName;
   /* Added OFN_FILEMUSTEXIST.  4 March 1991   clarkc   */
   /* Added OFN_HIDEREADONLY. Happy now, Patrick? :) 1 Oct 1992 a-mgates.*/
   OFN.Flags       = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;

    /* All long pointers should be defined immediately before the call.
     * L.Raman - 2/12/91
     */
   OFN.lpstrDefExt       = (LPTSTR)szDefExt;
   OFN.lpstrFilter       = (LPTSTR)szFilterSpec;
   OFN.lpstrCustomFilter = (LPTSTR)szCustFilterSpec;

   fh = GetOpenFileName ((LPOPENFILENAME) &OFN);
   if (fh)
      {
      fh = (INT)CreateFile((LPCTSTR)szFileName, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
            NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

      if (fh > 0)
         {
         short nReadError;

         if (ClearClipboard(hwnd))
            {
            if (nReadError = ReadClipboardFromFile(hwnd, fh))
               {
               TCHAR szErr[MSGMAX];

               LoadString (hInst, IDS_READERR + nReadError, szErr, MSGMAX);
               MessageBox(hwnd,szErr,szAppName,MB_OK | MB_ICONEXCLAMATION);
               }
           }
        _lclose(fh);
        }
     }

  /* On GetOpenFileName failure CommDlgExtendedError will return a value.*/
  if(CommDlgExtendedError())
     {
     MemErrorMessage();
     }

}


/*
 *  WriteFormatBlock() -
 */
DWORD NEAR PASCAL WriteFormatBlock(INT fh,DWORD offset,DWORD DataOffset,
                                    DWORD DataLen,UINT Format,LPSTR szName)
{
FORMATHEADER    FormatHeader;
DWORD           dwBytesWritten = 0;

    FormatHeader.FormatID = Format;
    FormatHeader.DataLen = DataLen;
    FormatHeader.DataOffset = DataOffset;
    lstrcpy(FormatHeader.Name, szName);
    _llseek(fh, offset, 0);

    if (fNTSaveFileFormat)
        dwBytesWritten += _lwrite(fh, (LPSTR)&(FormatHeader.FormatID), sizeof(FormatHeader.FormatID));
    else
        dwBytesWritten += _lwrite(fh, (LPSTR)&(FormatHeader.FormatID), sizeof(WORD));
    dwBytesWritten += _lwrite(fh, (LPSTR)&(FormatHeader.DataLen), sizeof(FormatHeader.DataLen));
    dwBytesWritten += _lwrite(fh, (LPSTR)&(FormatHeader.DataOffset), sizeof(FormatHeader.DataOffset));
    dwBytesWritten += _lwrite(fh, (LPSTR)&(FormatHeader.Name), sizeof(FormatHeader.Name));
    return(dwBytesWritten);
}


/*
 *  lread() - Good ol' _lread that will handle >64k
 */
#define MAXREAD   ((LONG)  (60L * 1024L))

DWORD APIENTRY lread(INT hFile,void FAR *pBuffer,DWORD dwBytes)
{
DWORD   dwByteCount = dwBytes;
#ifdef WIN16
BYTE    huge *hpBuffer = pBuffer;

    while (dwByteCount > MAXREAD)
        {
    if (_lread(hFile, hpBuffer, (WORD)MAXREAD) != MAXREAD)
            return(0);

        dwByteCount -= MAXREAD;
        hpBuffer += MAXREAD;
        }
#else
BYTE    FAR  *hpBuffer = pBuffer;
#endif
    if ((DWORD)_lread(hFile, hpBuffer, dwByteCount) != dwByteCount)
        return(0);

    return(dwBytes);
}


/*
 *  lwrite() -  Good ol' _lwrite that will handle >64k
 */
DWORD APIENTRY lwrite(INT hFile,void FAR *pBuffer,DWORD dwBytes)

{
DWORD   dwByteCount=dwBytes;
#ifdef WIN16
BYTE    huge *hpBuffer = pBuffer;

    while (dwByteCount > MAXREAD)
        {
    if (_lwrite(hFile, (LPSTR)hpBuffer, (WORD)MAXREAD) != MAXREAD)
            return(0);
        dwByteCount -= MAXREAD;
        hpBuffer += MAXREAD;
        }

#else
BYTE    FAR  *hpBuffer = pBuffer;
#endif

    if ((DWORD)_lwrite(hFile, (LPSTR)hpBuffer, dwByteCount) != dwByteCount)
        return(0);

    return(dwBytes);
}


/*
 *  WriteDataBlock() -
 *
 * Returns:
 *    # of bytes written to the output file
 *
 * NOTE: Write saves the name of a temp file in the clipboard for it's
 * own internal clipboard format.  This file goes aways when Write
 * (or windows?) shuts down.  Thus saving Write clipboards won't work
 * (should we special case hack this?)
 *
 */
DWORD NEAR PASCAL WriteDataBlock(register INT hFile,LONG offset,UINT Format)
{
WORD    wPalEntries;
LPBYTE   lpData;
DWORD   dwSize;
BITMAP  bitmap;
HANDLE  hMF;
HANDLE  hBitmap;
HANDLE  hLogPalette;
register HANDLE hData;
LPLOGPALETTE    lpLogPalette;
LPMETAFILEPICT  lpMFP;
HENHMETAFILE    hEMF;
WIN31BITMAP     bmWin31;

    if (!(hData = GetClipboardData(Format)))
        return(0);

    if(_llseek(hFile, offset, 0) != (int)offset)
        return(0);

    /* We have to special case a few common formats but most things
     * get handled in the default case.
     */
    switch (Format)
        {
        case CF_ENHMETAFILE:
            hEMF = hData;
            dwSize = (DWORD) GetEnhMetaFileBits(hEMF, 0, NULL); /* Get data size */
            if (!(hData = GlobalAlloc(GHND, dwSize)))   /* allocate mem for EMF bits */
                return(0);
            if (!(lpData = GlobalLock(hData)))
                return(0);
            if (!GetEnhMetaFileBits(hEMF, dwSize, (LPBYTE)lpData))
                return(0);
            dwSize = lwrite(hFile, lpData, dwSize);
            GlobalUnlock(hData);
            GlobalFree(hData);
            break;


        case CF_METAFILEPICT:
            if (!(lpMFP = (LPMETAFILEPICT)GlobalLock(hData))) /* get header */
                return(0);

            if (fNTSaveFileFormat)
                _lwrite(hFile, (LPBYTE)lpMFP, sizeof(METAFILEPICT)); /* write header */
            else {
                /* If we save the metafile in the Windows 3.1 .CLP file format
                   we have to save the METAFILEPICT structure as a 16bit METAFILEPICT
                   structure. This may cause loss of information if the
                   hight half of the METAFILEPICT structure's fields are used.
                   [pierrej 5/27/92]                                        */

                _lwrite(hFile, (LPBYTE)&(lpMFP->mm), sizeof(WORD));
                _lwrite(hFile, (LPBYTE)&(lpMFP->xExt), sizeof(WORD));
                _lwrite(hFile, (LPBYTE)&(lpMFP->yExt), sizeof(WORD));
                _lwrite(hFile, (LPBYTE)&(lpMFP->hMF), sizeof(WORD));
            }

            hMF = lpMFP->hMF;

            GlobalUnlock(hData);            /* unlock the header */

            /* A-MGates 9/15/92 - Converted this block to use */
            /* GetMetaFileBitsEx                              */

            /* Figure out how big a block we need */
            dwSize = GetMetaFileBitsEx(hMF, 0, NULL);
            if (0 == dwSize)
               {
               return(0);
               }

            hData = GlobalAlloc(GMEM_MOVEABLE, dwSize);
            if (!(lpData = GlobalLock(hData)))
               {
               return(0);
               }

            if (dwSize != GetMetaFileBitsEx(hMF, dwSize, lpData))
               {
               GlobalUnlock(hData);
               GlobalFree(hData);
               return(0);
               }

            dwSize = lwrite(hFile, lpData, dwSize); /* spit them out */

            GlobalUnlock(hData);
            GlobalFree(hData);

            if(dwSize)
                if (fNTSaveFileFormat)
                    dwSize += sizeof(METAFILEPICT);     /* we wrote this much data */
                else
                    dwSize += SIZE_OF_WIN31_METAFILEPICT_STRUCT;
            break;

        case CF_BITMAP:
            // hBitmap = hData;

            /* Writing DDBs to disk is bad. Therefore, we */
            /* write an intelligent CF_DIB block instead.    */
            /* A-MGATES 9/29/92                              */

            Format = CF_DIB;

            hBitmap = DibFromBitmap((HBITMAP)hData, BI_RGB, 4, NULL);

            lpData = GlobalLock(hBitmap);

            // dwSize might be too big, but we can live with that.
            dwSize = GlobalSize(lpData);

            _lwrite(hFile, lpData, dwSize);

            GlobalUnlock(hBitmap);
            GlobalFree(hBitmap);

            break;

#ifdef ICKYOLDCODE

            if (!fNTSaveFileFormat)
                hBitmap = BitmapToBitmap(hBitmap, 4, 1);

            GetObject(hBitmap, sizeof(BITMAP), (LPBYTE) &bitmap);
            dwSize = (DWORD)bitmap.bmWidthBytes * bitmap.bmHeight * bitmap.bmPlanes;

            if (!fNTSaveFileFormat)
               {
               // Round up to the nearest TWO bytes when saving to Win 3.1,
               // not the nearest four, which is what GetObject gives you.
               // Note: The WidthBytes calculation does not include
               // bmPlanes in the multiplication because it seems to represent
               // bytes in a given plane.
               bitmap.bmWidthBytes =
                     ((bitmap.bmWidth * bitmap.bmBitsPixel)+ 15 ) >> 3;
                      // ">> 3" == " / 8", except cheaper.

               if (bitmap.bmWidthBytes & 1)
                  {
                  bitmap.bmWidthBytes++;
                  }
               }

            if (!(hData = GlobalAlloc(GHND, dwSize)))
                return(0);

            if (!(lpData = GlobalLock(hData)))
                {
                GlobalFree(hData);
                return(0);
                }

            GetBitmapBits(hBitmap, dwSize, lpData);

            if (fNTSaveFileFormat)
                _lwrite(hFile, (LPBYTE) & bitmap, sizeof(BITMAP));
            else {
                /* If we save the bitmap in the Windows 3.1 .CLP file format
                   we have to save the BITMAP structure as a 16bit BITMAP
                   structure. This may cause loss of information if the
                   hight half of the BITMAP structure's fields are used.
                   [pierrej 5/27/92]                                        */

                bmWin31.bmType = bitmap.bmType;
                bmWin31.bmWidth = bitmap.bmWidth;
                bmWin31.bmHeight = bitmap.bmHeight;
                bmWin31.bmWidthBytes = bitmap.bmWidthBytes;
                bmWin31.bmPlanes = bitmap.bmPlanes;
                bmWin31.bmBitsPixel = bitmap.bmBitsPixel;
                bmWin31.bmBits = bitmap.bmBits;

                _lwrite(hFile, (LPBYTE) &bmWin31, sizeof(WIN31BITMAP));
            }
            dwSize = lwrite(hFile, lpData, dwSize);

            GlobalUnlock(hData);
            GlobalFree(hData);
            if(dwSize)
                if (fNTSaveFileFormat)
                    dwSize += sizeof(BITMAP);
                else
                    dwSize += sizeof(WIN31BITMAP);
            break;

#endif

        case CF_PALETTE:
            /* Get the number of palette entries */
            GetObject(hData, sizeof(WORD), (LPBYTE)&wPalEntries);

            /* Allocate enough place to build the LOGPALETTE struct */
            dwSize = (DWORD)(sizeof(LOGPALETTE) + (LONG)wPalEntries * sizeof(PALETTEENTRY));
            if (!(hLogPalette = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE, dwSize)))
                {
                dwSize = 0L;
                goto Palette_Error;
                }

            if (!(lpLogPalette = (LPLOGPALETTE)GlobalLock(hLogPalette)))
                {
                dwSize = 0L;
                goto Palette_Error;
                }

            lpLogPalette->palVersion = 0x300;      /* Windows 3.00 */
            lpLogPalette->palNumEntries = wPalEntries;

        if (GetPaletteEntries(hData, 0, wPalEntries,
              (LPPALETTEENTRY)(lpLogPalette->palPalEntry)) == 0)
                {
                dwSize = 0L;
                goto Palette_Error;
                }

            /* Write the LOGPALETTE structure onto disk */
            dwSize = lwrite(hFile, (LPBYTE)lpLogPalette, dwSize);

Palette_Error:
            if (lpLogPalette)
                GlobalUnlock(hLogPalette);
            if (hLogPalette)
                GlobalFree(hLogPalette);
            break;

        default:
            dwSize = GlobalSize(hData);

            if (0 ==(lpData = GlobalLock(hData)) )
               {
               return 0;
               }

            dwSize = _lwrite(hFile, lpData, dwSize);
            GlobalUnlock(hData);
            break;
        }

    /* Return the number of bytes written. */
    return(dwSize);
}


/* This function will return the number of clipboard formats compatible with
   the Windows 3.1 clipboard, this excludes CF_UNICODETEXT, CF_ENHMETAFILE and
   CF_DSPENHMETAFILE
*/

int Count16BitClipboardFormats(void)
{
    int iCount;

    iCount = CountClipboardFormats();
    if (IsClipboardFormatAvailable(CF_UNICODETEXT))
        iCount--;
    if (IsClipboardFormatAvailable(CF_ENHMETAFILE))
        iCount--;
    if (IsClipboardFormatAvailable(CF_DSPENHMETAFILE))
        iCount--;

    return iCount;
}


/*
 *  SaveClipboardData() - Writes a clipboard file.
 *
 * In:
 *    hwnd        handle of wnd that becomes the clipboard owner
 *    szFileName  file handle to read from
 *
 * NOTE:
 *    When done we call ReadClipboardFromFile(). this makes us the
 *    clipboard owner.
 */

BOOL NEAR PASCAL SaveClipboardData(HWND    hwnd,LPTSTR szLocalFileName)

{
INT    fh;
register UINT Format;
DWORD     HeaderPos;
DWORD     DataPos;
DWORD     datasize;
BOOL      fComplain;
BOOL      fDIBUsed;
HCURSOR   hCursor;
FILEHEADER FileHeader;
TCHAR      szComplaint[BUFFERLEN];
TCHAR      szName[CCHFMTNAMEMAX];
WORD      wHeaderSize;
UINT      uiSizeHeaderToWrite;

    /* First open the clipboard */
    if (!OpenClipboard(hwndMain))
        return(FALSE);

    /* Open the file */

    fh = (INT)CreateFile((LPCTSTR)szLocalFileName, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
                    NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (fh == -1)
        {
        GetLastError();
        CloseClipboard();
        return(FALSE);
        }
    /* Fill out the file header structure */
    if (fNTSaveFileFormat) {
        FileHeader.magic = CLP_NT_ID;          /* magic number to tag our files */
        uiSizeHeaderToWrite = (sizeof(UINT) + 2*sizeof(DWORD) + CCHFMTNAMEMAX*sizeof(TCHAR));
    } else {
        FileHeader.magic = CLP_ID;          /* magic number to tag our files */
        uiSizeHeaderToWrite = (sizeof(WORD) + 2*sizeof(DWORD) + CCHFMTNAMEMAX*sizeof(TCHAR));
    }
    FileHeader.FormatCount = 0;          /* dummy for now */

    /* Update HeaderPos and DataPos */
    HeaderPos = sizeof(FILEHEADER);

    /* This is the maximum number of formats that will be written.  Potentially
     * some may fail and some space will be wasted.
     * In 32bit the number of bytes written to the disk isn't sizeof(FORMATHEADER)
     * because of DWORD alignment in the FORMATHEADER structure. Instead we write
     * the format headre structure one field at a time to remain compatible with
     * the 16bit Windows versions.
     */

    if (fNTSaveFileFormat)
        DataPos = HeaderPos + (uiSizeHeaderToWrite * CountClipboardFormats());
    else
        DataPos = HeaderPos + (uiSizeHeaderToWrite * Count16BitClipboardFormats());

    /* Now loop throught the data, one format at a time, and write out the data. */
    fComplain = FALSE;

    LoadString(hInst, IDS_FMTNOTSAV, szComplaint, BUFFERLEN);

    hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
    ShowCursor(TRUE);

    /* Enumerate all formats */
    Format = 0;
    fDIBUsed = FALSE;
    while ((Format = EnumClipboardFormats(Format)) != 0)
        {
        if (IsWriteable(Format))
            {
            // DO NOT write CF_BITMAP to disk. Transform to CF_DIB
            // and write that instead.
            if (CF_BITMAP == Format || CF_DIB == Format)
               {
               if (!fDIBUsed)
                  {
                  fDIBUsed = TRUE;
                  }
               // If I've already done DIB, go on to the next format.
               else continue;
               }

            GetClipboardName((Format == CF_BITMAP ? CF_DIB : Format),
                  szName, sizeof(szName));

            if ((datasize = WriteDataBlock(fh, DataPos, Format)) != 0)
                {
                /* Create a Format header and write it to the file */
                wHeaderSize = (WORD)WriteFormatBlock(fh,
                     HeaderPos, DataPos, datasize,
                     (Format == CF_BITMAP ? CF_DIB : Format),
                     (LPTSTR)szName);
                if(wHeaderSize < uiSizeHeaderToWrite)
                    {
                    fComplain = TRUE;
                    break;
                    }
                HeaderPos += wHeaderSize;

                /* Update the data pos for the next block */
                DataPos += datasize;

                FileHeader.FormatCount++;       /* this format has been written */
                }
            else
                {
                fComplain = TRUE;
                break;
                }
            }
        }

    ShowCursor(FALSE);
    SetCursor(hCursor);

    if (fComplain)
        {
#ifdef JAPAN
        /* Use Japanese message for caption instead of app name */
        MessageBox(hwnd, szComplaint, szCaptionName, MB_OK | MB_ICONEXCLAMATION);
#else
        MessageBox(hwnd, szComplaint, szAppName, MB_OK | MB_ICONEXCLAMATION);
#endif
        CloseClipboard();
        _lclose(fh);
        return(FALSE);
        }

    CloseClipboard();      /* we are done looking at this */

    _llseek(fh, 0L, 0);     /* move back to the start of file */

    /* Write the File Header with the correct number of formats written */
    _lwrite(fh, (LPBYTE) & FileHeader, sizeof(FILEHEADER));

    /* Now we open the clipboard and become the owner.  this places
     * all the things we just saved in the clipboard (and throws out
     * those things we didn't save)
     */
    _llseek(fh, 0L, 0);

    /* ofStruct will be used for reopening the file */
    lstrcpy(szFileName, szSaveFileName);
    fNTReadFileFormat = fNTSaveFileFormat;

    ReadClipboardFromFile(hwndMain, fh);

    _lclose(fh);

    return(TRUE);
}

/*
 *  SaveClipboardToFile() -
 */
void NEAR PASCAL SaveClipboardToFile(HWND hwnd)
{
INT    hFile;

OFN.lpstrTitle = szSaveCaption;
OFN.lpstrFile  = szSaveFileName;
szSaveFileName[0] = 0;
OFN.Flags      = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST |
                 OFN_OVERWRITEPROMPT | OFN_NOREADONLYRETURN;

/* All long pointers should be defined immediately before the call. */
OFN.lpstrDefExt       = (LPTSTR)szDefExt;
OFN.lpstrFilter       = (LPTSTR)szFilterSpec;
OFN.lpstrCustomFilter = NULL;
OFN.lpfnHook          = NULL;
OFN.nFilterIndex      = 1;

hFile = GetSaveFileName ((LPOPENFILENAME) &OFN);
if (hFile)
   {
   // The first filter listed is "NT Clipboard File". The second is
   // "Windows 3.1 Clipboard file".
   fNTSaveFileFormat = (1 == OFN.nFilterIndex);

   hFile = (INT)CreateFile((LPCTSTR)szSaveFileName, GENERIC_READ, FILE_SHARE_READ,
                     NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
   if (hFile != -1)
      /* The file already exists and the user wants to
       * overwrite! Now, we have to check whether this
       * file is the most recently saved clip file;
       * If so, it will be used for delayed rendering; So,
       * before we overwrite this file we must read all data
       * from it thro RENDERALLFORMATS;
       * Fix for Bug #5602 --SANKAR-- 10-16-89
       */
      {
      CloseHandle((HANDLE)hFile);
      if (lstrcmp(szSaveFileName, szFileName) == 0)
         {
         SendMessage(hwndMain, WM_RENDERALLFORMATS, 0, 0L);
         }
      }

   if (!SaveClipboardData(hwnd, (LPTSTR)szSaveFileName))
      {
      /* If Failure, Delete the incomplete file */
      DeleteFile(szSaveFileName);
      }
   }
}


//
// Purpose:
//    Convert an existing bitmap to the given number of planes and
//    bits/pixel.
//
// Parameters:
//    hBitmap - Handle to the existing bitmap.
//    wPlanes - Number of planes in the destination bitmap.
//    wBitCount - Number of bits/pel in the destination bitmap.
//
// Returns:
//    A handle to the converted bitmap.
//
////////////////////////////////////////////////////////////////////////////
HBITMAP PASCAL BitmapToBitmap(HBITMAP hBitmap, WORD wPlanes, WORD wBitCount)
{
    BITMAP  bm;
    BITMAPINFOHEADER    BmpInfoHeader;
    HANDLE  hDib, hBmp;
    LPBYTE  lpDib, lpBits;
    DWORD   dwLength, dwSize;
    int     iColorTable;
    int     iColorUsed;
    HDC     hDC;

    /*
    ** Get the size of the bitmap.  These values are used to setup the memory
    ** requirements for the DIB.
    */
    GetObject(hBitmap,sizeof(BITMAP),(LPSTR)&bm);
    if ((bm.bmBitsPixel == wBitCount) && (bm.bmPlanes == wPlanes))
        return hBitmap;

    #if 0
    dwSize = dwLength = (DWORD)(bm.bmWidthBytes+sizeof(WORD)) * bm.bmHeight * bm.bmPlanes;
    #else
    dwSize = dwLength = (DWORD)(((bm.bmWidth * wBitCount + 7)/8)*2 + 1)/2
         * wPlanes * bm.bmHeight;
    #endif

    switch(bm.bmBitsPixel * bm.bmPlanes)
    {
        case 1:
            iColorTable = sizeof(RGBQUAD) * 2;
            break;

        case 4:
            iColorTable = sizeof(RGBQUAD) * 16;
            break;

        case 8:
            iColorTable = sizeof(RGBQUAD) * 256;
            break;

        case 24:
        default:
            iColorTable = 0;
            break;
    }
    iColorUsed = iColorTable / sizeof(RGBQUAD);
    dwLength   += (sizeof(BITMAPINFOHEADER) + iColorTable);


    /*
    ** Create the DIB.  First, to the size of the bitmap.  We will calculate
    ** the new memory requirements if DIB-Compression is desired.
    */
    if(hDib = GlobalAlloc(GHND,dwLength)) {
        if(lpDib = GlobalLock(hDib))
           {
           ((LPBITMAPINFOHEADER)lpDib)->biSize          = sizeof(BITMAPINFOHEADER);
           ((LPBITMAPINFOHEADER)lpDib)->biWidth         = bm.bmWidth;
           ((LPBITMAPINFOHEADER)lpDib)->biHeight        = bm.bmHeight;
           ((LPBITMAPINFOHEADER)lpDib)->biPlanes        = 1;
           ((LPBITMAPINFOHEADER)lpDib)->biBitCount      = bm.bmBitsPixel*bm.bmPlanes;
           ((LPBITMAPINFOHEADER)lpDib)->biCompression   = BI_RGB;
           ((LPBITMAPINFOHEADER)lpDib)->biSizeImage     = 0;
           ((LPBITMAPINFOHEADER)lpDib)->biXPelsPerMeter = 0;
           ((LPBITMAPINFOHEADER)lpDib)->biYPelsPerMeter = 0;
           ((LPBITMAPINFOHEADER)lpDib)->biClrUsed       = 0;
           ((LPBITMAPINFOHEADER)lpDib)->biClrImportant  = 0;


           // Figure out where the bits go
           lpBits = (LPBYTE)lpDib+sizeof(BITMAPINFOHEADER)+iColorTable;
           hDC = GetDC(hwndMain);
           if (NULL != hDC)
              {
              if (bm.bmHeight == GetDIBits(hDC,hBitmap,0,
                        bm.bmHeight,lpBits,(LPBITMAPINFO)lpDib,
                        // DIB_PAL_INDICES))
                        DIB_RGB_COLORS))
                 {
                 BmpInfoHeader.biSize          = sizeof(BITMAPINFOHEADER);
                 BmpInfoHeader.biWidth         = bm.bmWidth;
                 BmpInfoHeader.biHeight        = bm.bmHeight;
                 BmpInfoHeader.biPlanes        = wPlanes;
                 BmpInfoHeader.biBitCount      = wBitCount;
                 BmpInfoHeader.biCompression   = BI_RGB;
                 BmpInfoHeader.biSizeImage     = dwSize;
                 BmpInfoHeader.biXPelsPerMeter = 0;
                 BmpInfoHeader.biYPelsPerMeter = 0;
                 BmpInfoHeader.biClrUsed       = iColorUsed;
                 BmpInfoHeader.biClrImportant  = iColorUsed;
                 hBmp = CreateDIBitmap(NULL, &BmpInfoHeader, CBM_INIT,
                            lpBits, (LPBITMAPINFO)lpDib, DIB_RGB_COLORS);
                 }
              ReleaseDC(hwndMain, hDC);
              }
           GlobalUnlock(hDib);
           }
        GlobalFree(hDib);
        }

    return(hBmp);
}