diff options
Diffstat (limited to '')
| -rw-r--r-- | private/mvdm/wow32/wuclip.c | 1245 |
1 files changed, 1245 insertions, 0 deletions
diff --git a/private/mvdm/wow32/wuclip.c b/private/mvdm/wow32/wuclip.c new file mode 100644 index 000000000..b33d49a06 --- /dev/null +++ b/private/mvdm/wow32/wuclip.c @@ -0,0 +1,1245 @@ +/*++ + * + * WOW v1.0 + * + * Copyright (c) 1991, Microsoft Corporation + * + * WUCLIP.C + * WOW32 16-bit User API support + * + * History: + * WOW Clipboard functionality designed and developed by ChandanC + * +--*/ + + +#include "precomp.h" +#pragma hdrstop + +struct _CBFORMATS ClipboardFormats; + +DLLENTRYPOINTS OleStringConversion[WOW_OLESTRINGCONVERSION_COUNT] = + {"ConvertObjDescriptor", NULL}; + + + +UINT CFOLEObjectDescriptor; +UINT CFOLELinkSrcDescriptor; + + +MODNAME(wuclip.c); + + +/*++ + BOOL ChangeClipboardChain(<hwnd>, <hwndNext>) + HWND <hwnd>; + HWND <hwndNext>; + + The %ChangeClipboardChain% function removes the window specified by the + <hwnd> parameter from the chain of clipboard viewers and makes the window + specified by the <hwndNext> parameter the descendant of the <hwnd> + parameter's ancestor in the chain. + + <hwnd> + Identifies the window that is to be removed from the chain. The handle + must previously have been passed to the SetClipboardViewer function. + + <hwndNext> + Identifies the window that follows <hwnd> in the clipboard-viewer + chain (this is the handle returned by the %SetClipboardViewer% function, + unless the sequence was changed in response to a WM_CHANGECBCHAIN + message). + + The return value specifies the status of the <hwnd> window. It is TRUE if + the window is found and removed. Otherwise, it is FALSE. +--*/ + +ULONG FASTCALL WU32ChangeClipboardChain(PVDMFRAME pFrame) +{ + ULONG ul; + register PCHANGECLIPBOARDCHAIN16 parg16; + + GETARGPTR(pFrame, sizeof(CHANGECLIPBOARDCHAIN16), parg16); + + ul = GETBOOL16(ChangeClipboardChain( + HWND32(parg16->f1), + HWND32(parg16->f2) + )); + + FREEARGPTR(parg16); + RETURN(ul); +} + + +/*++ + BOOL CloseClipboard(VOID) + + The %CloseClipboard% function closes the clipboard. The %CloseClipboard% + function should be called when a window has finished examining or changing + the clipboard. It lets other applications access the clipboard. + + This function has no parameters. + + The return value specifies whether the clipboard is closed. It is TRUE if + the clipboard is closed. Otherwise, it is FALSE. +--*/ + +ULONG FASTCALL WU32CloseClipboard(PVDMFRAME pFrame) +{ + ULONG ul; + + UNREFERENCED_PARAMETER(pFrame); + + ul = GETBOOL16(CloseClipboard()); + + RETURN(ul); +} + + +/*++ + No REF header file +--*/ + +ULONG FASTCALL WU32CountClipboardFormats(PVDMFRAME pFrame) +{ + ULONG ul; + + UNREFERENCED_PARAMETER(pFrame); + + ul = GETINT16(CountClipboardFormats()); + + RETURN(ul); +} + + +/*++ + BOOL EmptyClipboard(VOID) + + The %EmptyClipboard% function empties the clipboard and frees handles to + data in the clipboard. It then assigns ownership of the clipboard to the + window that currently has the clipboard open. + + This function has no parameters. + + The return value specifies the status of the clipboard. It is TRUE if the + clipboard is emptied. It is FALSE if an error occurs. + + The clipboard must be open when the %EmptyClipboard% function is called. +--*/ + +ULONG FASTCALL WU32EmptyClipboard(PVDMFRAME pFrame) +{ + ULONG ul; + + UNREFERENCED_PARAMETER(pFrame); + + ul = GETBOOL16(EmptyClipboard()); + + W32EmptyClipboard (); + + RETURN(ul); +} + + +/*++ + WORD EnumClipboardFormats(<wFormat>) + WORD <wFormat>; + + The %EnumClipboardFormats% function enumerates the formats found in a list + of available formats that belong to the clipboard. On each call to this + function, the <wFormat> parameter specifies a known available format, and + the function returns the format that appears next in the list. The first + format in the list can be retrieved by setting <wFormat> to zero. + + <wFormat> + Specifies a known format. + + The return value specifies the next known clipboard data format. It is zero + if <wFormat> specifies the last format in the list of available formats. It + is zero if the clipboard is not open. + + Before it enumerates the formats by using the %EnumClipboardFormats% + function, an application must open the clipboard by using the + %OpenClipboard% function. + + The order that an application uses for putting alternative formats for the + same data into the clipboard is the same order that the enumerator uses when + returning them to the pasting application. The pasting application should + use the first format enumerated that it can handle. This gives the donor a + chance to recommend formats that involve the least loss of data. +--*/ + +ULONG FASTCALL WU32EnumClipboardFormats(PVDMFRAME pFrame) +{ + ULONG ul; + register PENUMCLIPBOARDFORMATS16 parg16; + + GETARGPTR(pFrame, sizeof(ENUMCLIPBOARDFORMATS16), parg16); + + ul = GETWORD16(EnumClipboardFormats( + WORD32(parg16->f1) + )); + + FREEARGPTR(parg16); + RETURN(ul); +} + + +/*++ + HANDLE GetClipboardData(<wFormat>) + WORD <wFormat>; + + The %GetClipboardData% function retrieves data from the clipboard in the + format given by the <wFormat> parameter. The clipboard must have been opened + previously. + + <wFormat> + Specifies a data format. For a description of the data formats, see the + SetClipboardData function, later in this chapter. + + The return value identifies the memory block that contains the data from the + clipboard. The handle type depends on the type of data specified by the + <wFormat> parameter. It is NULL if there is an error. + + The available formats can be enumerated in advance by using the + %EnumClipboardFormats% function. + + The data handle returned by %GetClipboardData% is controlled by the + clipboard, not by the application. The application should copy the data + immediately, instead of relying on the data handle for long-term use. The + application should not free the data handle or leave it locked. + + Windows supports two formats for text, CF_TEXT and CF_OEMTEXT. CF_TEXT is + the default Windows text clipboard format, while Windows uses the CF_OEMTEXT + format for text in non-Windows applications. If you call %GetClipboardData% + to retrieve data in one text format and the other text format is the only + available text format, Windows automatically converts the text to the + requested format before supplying it to your application. + + If the clipboard contains data in the CF_PALETTE (logical color palette) + format, the application should assume that any other data in the clipboard + is realized against that logical palette. +--*/ + +ULONG FASTCALL WU32GetClipboardData(PVDMFRAME pFrame) +{ + ULONG ul = 0; + HANDLE hMem32, hMeta32 = 0; + HMEM16 hMem16=0, hMeta16 = 0; + VPVOID vp; + LPBYTE lpMem32; + LPBYTE lpMem16; + int cb; + register PGETCLIPBOARDDATA16 parg16; + + GETARGPTR(pFrame, sizeof(GETCLIPBOARDDATA16), parg16); + + LOGDEBUG(6, ("WOW::WUICBGetClipboardData(): CF_FORMAT is %04x\n", parg16->f1)); + + switch (parg16->f1) { + + // This is intentional to let it thru to the "case statements". + // ChandanC 5/11/92. + + default: + if ((parg16->f1 == CFOLEObjectDescriptor) || (parg16->f1 == CFOLELinkSrcDescriptor)) { + hMem32 = GetClipboardData(WORD32(parg16->f1)); + if (hMem32) { + hMem16 = (HMEM16) W32ConvertObjDescriptor(hMem32, CFOLE_UNICODE_TO_ANSI); + } + WU32ICBStoreHandle(parg16->f1, hMem16); + break; + } + + case CF_DIB: + case CF_TEXT: + case CF_DSPTEXT: + case CF_SYLK: + case CF_DIF: + case CF_TIFF: + case CF_OEMTEXT: + case CF_PENDATA: + case CF_RIFF: + case CF_WAVE: + case CF_OWNERDISPLAY: + hMem16 = WU32ICBGetHandle(parg16->f1); + if (!hMem16) { + hMem32 = GetClipboardData(WORD32(parg16->f1)); + + if (hMem16 = WU32ICBGetHandle(parg16->f1)) { + + // + // We couldn't find the hMem16 using WU32ICBGetHandle + // before we called Win32 GetClipboardData, but we can + // now, so that means it was cut/copied from a task in + // this WOW using delayed rendering, so that the actual + // non-NULL hMem16 wasn't SetClipboardData until we + // just called GetClipboardData. Since we now have + // a valid cached copy of the data in 16-bit land, + // we can just return that. + // + + break; + } + + if (hMem32) { + lpMem32 = GlobalLock(hMem32); + cb = GlobalSize(hMem32); + vp = GlobalAllocLock16(GMEM_MOVEABLE | GMEM_DDESHARE, cb, &hMem16); + // 16-bit memory may have moved - refresh flat pointers + FREEARGPTR(parg16); + FREEVDMPTR(pFrame); + GETFRAMEPTR(((PTD)CURRENTPTD())->vpStack, pFrame); + GETARGPTR(pFrame, sizeof(GETCLIPBOARDDATA16), parg16); + if (vp) { + GETMISCPTR(vp, lpMem16); + RtlCopyMemory(lpMem16, lpMem32, cb); + GlobalUnlock16(hMem16); + FLUSHVDMPTR(vp, cb, lpMem16); + FREEMISCPTR(lpMem16); + } + GlobalUnlock(hMem32); + } + + WU32ICBStoreHandle(parg16->f1, hMem16); + } + break; + + case CF_HDROP: + // This is the case when app is retrieving cf_hdrop from the + // clipboard, thus we will convert the dropfiles structure + // from 32 to 16-bit one + hMem16 = WU32ICBGetHandle(parg16->f1); + if (!hMem16) { + hMem32 = GetClipboardData(WORD32(parg16->f1)); + if (hMem32) { + hMem16 = CopyDropFilesFrom32(hMem32); + } + WU32ICBStoreHandle(parg16->f1, hMem16); + } + break; + + case CF_DSPBITMAP: + case CF_BITMAP: + hMem16 = GETHBITMAP16(GetClipboardData(WORD32(parg16->f1))); + break; + + case CF_PALETTE: + hMem16 = GETHPALETTE16(GetClipboardData(WORD32(parg16->f1))); + break; + + case CF_DSPMETAFILEPICT: + case CF_METAFILEPICT: + hMem16 = WU32ICBGetHandle(parg16->f1); + if (!(hMem16)) { + hMem32 = GetClipboardData(WORD32(parg16->f1)); + + if (hMem16 = WU32ICBGetHandle(parg16->f1)) { + + // + // We couldn't find the hMem16 using WU32ICBGetHandle + // before we called Win32 GetClipboardData, but we can + // now, so that means it was cut/copied from a task in + // this WOW using delayed rendering, so that the actual + // non-NULL hMem16 wasn't SetClipboardData until we + // just called GetClipboardData. Since we now have + // a valid cached copy of the data in 16-bit land, + // we can just return that. + // + + break; + } + + if (hMem32) { + lpMem32 = GlobalLock(hMem32); + vp = GlobalAllocLock16(GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(METAFILEPICT16), &hMem16); + // 16-bit memory may have moved - refresh flat pointers + FREEARGPTR(parg16); + FREEVDMPTR(pFrame); + GETFRAMEPTR(((PTD)CURRENTPTD())->vpStack, pFrame); + GETARGPTR(pFrame, sizeof(GETCLIPBOARDDATA16), parg16); + if (vp) { + GETMISCPTR(vp, lpMem16); + FixMetafile32To16 ((LPMETAFILEPICT) lpMem32, (LPMETAFILEPICT16) lpMem16); + FREEMISCPTR(lpMem16); + + hMeta32 = ((LPMETAFILEPICT) lpMem32)->hMF; + if (hMeta32) { + hMeta16 = WinMetaFileFromHMF(hMeta32, FALSE); + // 16-bit memory may have moved + FREEARGPTR(parg16); + FREEVDMPTR(pFrame); + GETFRAMEPTR(((PTD)CURRENTPTD())->vpStack, pFrame); + GETARGPTR(pFrame, sizeof(GETCLIPBOARDDATA16), parg16); + } + + GETMISCPTR(vp, lpMem16); + STOREWORD(((LPMETAFILEPICT16) lpMem16)->hMF, hMeta16); + GlobalUnlock16(hMem16); + FLUSHVDMPTR(vp, sizeof(METAFILEPICT16), lpMem16); + FREEMISCPTR(lpMem16); + } + GlobalUnlock(hMem32); + } + WU32ICBStoreHandle(parg16->f1, hMem16); + } + break; + } + + ul = (ULONG) hMem16; + + FREEARGPTR(parg16); + RETURN(ul); +} + + +/*++ + int GetClipboardFormatName(<wFormat>, <lpFormatName>, <nMaxCount>) + WORD <wFormat>; + LPSTR <lpFormatName>; + int <nMaxCount>; + + The %GetClipboardFormatName% function retrieves from the clipboard the name + of the registered format specified by the <wFormat> parameter. The name is + copied to the buffer pointed to by the <lpFormatName> parameter. + + <wFormat> + Specifies the type of format to be retrieved. It must not specify any of + the predefined clipboard formats. + + <lpFormatName> + Points to the buffer that is to receive the format name. + + <nMaxCount> + Specifies the maximum length (in bytes) of the string to be copied + to the buffer. If the actual name is longer, it is truncated. + + The return value specifies the actual length of the string copied to the + buffer. It is zero if the requested format does not exist or is a predefined + format. +--*/ + +ULONG FASTCALL WU32GetClipboardFormatName(PVDMFRAME pFrame) +{ + ULONG ul; + PSZ psz2 = NULL; + register PGETCLIPBOARDFORMATNAME16 parg16; + + GETARGPTR(pFrame, sizeof(GETCLIPBOARDFORMATNAME16), parg16); + ALLOCVDMPTR(parg16->f2, parg16->f3, psz2); + + ul = GETINT16(GetClipboardFormatName( + WORD32(parg16->f1), + psz2, + INT32(parg16->f3) + )); + + FLUSHVDMPTR(parg16->f2, strlen(psz2)+1, psz2); + FREEVDMPTR(psz2); + FREEARGPTR(parg16); + RETURN(ul); +} + + +/*++ + HWND GetClipboardOwner(VOID) + + The %GetClipboardOwner% function retrieves the window handle of the current + owner of the clipboard. + + This function has no parameters. + + The return value identifies the window that owns the clipboard. It is NULL + if the clipboard is not owned. + + The clipboard can still contain data even if the clipboard is not currently + owned. +--*/ + +ULONG FASTCALL WU32GetClipboardOwner(PVDMFRAME pFrame) +{ + ULONG ul; + + UNREFERENCED_PARAMETER(pFrame); + + ul = GETHWND16(GetClipboardOwner()); + + RETURN(ul); +} + + +/*++ + HWND GetClipboardViewer(VOID) + + The %GetClipboardViewer% function retrieves the window handle of the first + window in the clipboard-viewer chain. + + This function has no parameters. + + The return value identifies the window currently responsible for displaying + the clipboard. It is NULL if there is no viewer. +--*/ + +ULONG FASTCALL WU32GetClipboardViewer(PVDMFRAME pFrame) +{ + ULONG ul; + + UNREFERENCED_PARAMETER(pFrame); + + ul = GETHWND16(GetClipboardViewer()); + + RETURN(ul); +} + + +/*++ + int GetPriorityClipboardFormat(<lpPriorityList>, <cEntries>) + LPWORD <lpPriorityList>; + int <cEntries>; + + The %GetPriorityClipboardFormat% function returns the first clipboard format + in a list for which data exist in the clipboard. + + <lpPriorityList> + Points to an integer array that contains a list of clipboard formats in + priority order. For a description of the data formats, see the + SetClipboardData function later in this chapter. + + <cEntries> + Specifies the number of entries in <lpPriorityList>. This value + must not be greater than the actual number of entries in the list. + + The return value is the highest priority clipboard format in the list for + which data exist. If no data exist in the clipboard, this function returns + NULL. If data exist in the clipboard which did not match any format in the + list, the return value is -1. +--*/ + +ULONG FASTCALL WU32GetPriorityClipboardFormat(PVDMFRAME pFrame) +{ + ULONG ul; + UINT *pu1; + register PGETPRIORITYCLIPBOARDFORMAT16 parg16; + INT BufferT[256]; // comfortably large array + + + GETARGPTR(pFrame, sizeof(GETPRIORITYCLIPBOARDFORMAT16), parg16); + pu1 = STACKORHEAPALLOC(parg16->f2 * sizeof(INT), sizeof(BufferT), BufferT); + getuintarray16(parg16->f1, parg16->f2, pu1); + + if (pu1) { + ul = GETINT16(GetPriorityClipboardFormat( + pu1, + INT32(parg16->f2) + )); + } else { + ul = (ULONG)-1; + } + + STACKORHEAPFREE(pu1, BufferT); + FREEARGPTR(parg16); + RETURN(ul); +} + + +/*++ + BOOL IsClipboardFormatAvailable(<wFormat>) + WORD <wFormat>; + + The %IsClipboardFormatAvailable% function specifies whether data of a + certain type exist in the clipboard. + + <wFormat> + Specifies a registered clipboard format. For information on clipboard + formats, see the description of the SetClipboardData function, later in + this chapter. + + The return value specifies the outcome of the function. It is TRUE if data + having the specified format are present. Otherwise, it is FALSE. + + This function is typically called during processing of the WM_INITMENU or + WM_INITMENUPOPUP message to determine whether the clipboard contains data + that the application can paste. If such data are present, the application + typically enables the Paste command (in its Edit menu). +--*/ + +ULONG FASTCALL WU32IsClipboardFormatAvailable(PVDMFRAME pFrame) +{ + ULONG ul; + register PISCLIPBOARDFORMATAVAILABLE16 parg16; + + GETARGPTR(pFrame, sizeof(ISCLIPBOARDFORMATAVAILABLE16), parg16); + + // Hack-a-roo! PhotoShop 2.5 has a bug in its code for handling large DIB's + // on the clipboard and will fault if it encounters one. On WFW, it usually + // won't encounter one because most apps (in this case alt-Prtscrn button) + // copy BITMAPS, not DIBS, to the clipboard. On NT, anytime an app writes + // a BITMAP to the clipboard it gets converted to a DIB & vice versa-making + // more clipboard data formats available to inquiring apps. Unfortunately, + // Photoshop checks for DIBS before BITMAPS and finds one on Win + // Versions >= 4.0. a-craigj + + // if this is a DIB check && the app is PhotoShop... + if((WORD32(parg16->f1) == CF_DIB) && + (CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_NODIBSHERE)) { + + // ...see if there is a bitmap format available too + if(IsClipboardFormatAvailable(CF_BITMAP)) { + + // if so return FALSE which will cause Photoshop to ask for a + // BITMAP format next + ul = FALSE; + } + + // otherwise we'll check for a DIB anyway & hope it's a small one + else { + ul = GETBOOL16(IsClipboardFormatAvailable(CF_DIB)); + } + } + + // no hack path + else { + ul = GETBOOL16(IsClipboardFormatAvailable(WORD32(parg16->f1))); + } + + FREEARGPTR(parg16); + RETURN(ul); +} + + +/*++ + BOOL OpenClipboard(<hwnd>) + HWND <hwnd>; + + The %OpenClipboard% function opens the clipboard. Other applications will + not be able to modify the clipboard until the %CloseClipboard% function is + called. + + <hwnd> + Identifies the window to be associated with the open clipboard. + + The return value is TRUE if the clipboard is opened, or FALSE if another + application or window has the clipboard opened. + + The window specified by the <hwnd> parameter will not become the owner of + the clipboard until the %EmptyCLipboard% function is called. +--*/ + +ULONG FASTCALL WU32OpenClipboard(PVDMFRAME pFrame) +{ + ULONG ul; + register POPENCLIPBOARD16 parg16; + + GETARGPTR(pFrame, sizeof(OPENCLIPBOARD16), parg16); + + ul = GETBOOL16(OpenClipboard( + HWND32(parg16->f1) + )); + + FREEARGPTR(parg16); + RETURN(ul); +} + + +/*++ + WORD RegisterClipboardFormat(<lpFormatName>) + LPSTR <lpFormatName>; + + The %RegisterClipboardFormat% function registers a new clipboard format + whose name is pointed to by the <lpFormatName> parameter. The registered + format can be used in subsequent clipboard functions as a valid format in + which to render data, and it will appear in the clipboard's list of + formats. + + <lpFormatName> + Points to a character string that names the new format. The string must + be a null-terminated string. + + The return value specifies the newly registered format. If the identical + format name has been registered before, even by a different application, the + format's reference count is increased and the same value is returned as when + the format was originally registered. The return value is zero if the format + cannot be registered. + + The format value returned by the %RegisterClipboardFormat% function is + within the range of 0xC000 to 0xFFFF. +--*/ + +ULONG FASTCALL WU32RegisterClipboardFormat(PVDMFRAME pFrame) +{ + ULONG ul; + PSZ psz1; + register PREGISTERCLIPBOARDFORMAT16 parg16; + + GETARGPTR(pFrame, sizeof(REGISTERCLIPBOARDFORMAT16), parg16); + GETPSZPTR(parg16->f1, psz1); + + ul = GETWORD16(RegisterClipboardFormat( + psz1 + )); + + FREEPSZPTR(psz1); + FREEARGPTR(parg16); + RETURN(ul); +} + + +/*++ + HANDLE SetClipboardData(<wFormat>, <hData>) + WORD <wFormat>; + HANDLE <hData>; + + The %SetClipboardData% function sets the data in the clipboard. The + application must have called the %OpenClipboard% function before calling + the %SetClipboardData% function. + + <wFormat> + Specifies the format of the data. It can be any one of the + system-defined formats, or a format registered by the + %RegisterClipboardFormat% function. For a list of system-defined + formats, + + <hData> + Identifies the data to be placed into the clipboard. For all formats + except CF_BITMAP and CF_PALETTE, this parameter must be a handle to + memory allocated by the %GlobalAlloc% function. For CF_BITMAP format, + the <hData> parameter is a handle to a bitmap (see %LoadBitmap%). For + CF_PALETTE format, the <hData> parameter is a handle to a palette (see + %CreatePalette%). + + If this parameter is NULL, the owner of the clipboard will be sent a + WM_RENDERFORMAT message when it needs to supply the data. + + The return value is a handle to the data if the function is succesful, or + NULL if an error occurred. + + If the <hData> parameter contains a handle to memory allocated by the + %GlobalAlloc% function, the application must not use this handle once it + has called the %SetClipboardData% function. + + The following list contains the system-defined clipboard formats: + + CF_BITMAP + The data is a bitmap. + + CF_DIB + The data is a memory block containing a %BITMAPINFO% structure followed + by the bitmap data. + + CF_DIF + The data is in Software Arts' Data Interchange Format. + + CF_DSPBITMAP + The data is a bitmap representation of a private format. This data is + displayed in bitmap format in lieu of the privately formatted data. + + CF_DSPMETAFILEPICT + The data is a metafile representation of a private data format. This + data is displayed in metafile-picture format in lieu of the privately + formatted data. + + CF_DSPTEXT + The data is a textual representation of a private data format. This data + is displayed in text format in lieu of the privately formatted data. + + CF_METAFILEPICT + The data is a metafile (see description of the %METAFILEPICT% + structure). + + CF_OEMTEXT + The data is an array of text characters in the OEM character set. Each + line ends with a carriage return/linefeed (CR-LF) combination. A null + character signals the end of the data. + + CF_OWNERDISPLAY + The data is in a private format that the clipboard owner must display. + + CF_PALETTE + The data is a color palette. + + CF_SYLK + The data is in Microsoft Symbolic Link (SYLK) format. + + CF_TEXT + The data is an array of text characters. Each line ends with a carriage + return/linefeed (CR-LF) combination. A null character signals the end of + the data. + + CF_TIFF + The data is in Tag Image File Format. + + Private data formats in the range of CF_PRIVATEFIRST to CF_PRIVATELAST are + not automatically freed when the data is deleted from the clipboard. Data + handles associated with these formats should be freed upon receiving a + WM_DESTROYCLIPBOARD message. + + Private data formats in the range of CF_GDIOBJFIRST to CF_GDIOBJLAST will + be automatically deleted with a call to %DeleteObject% when the data is + deleted from the clipboard. + + If the Windows clipboard application is running, it will not update its + window to show the data placed in the clipboard by the %SetClipboardData% + until after the %CloseClipboard% function is called. + + 31-Oct-1990 [ralphw] Miscelanious material, needs to be moved to other + function descriptions/overviews. + + Whenever an application places data in the clipboard that depends on or + assumes a color palette, it should also place the palette in the + clipboard as well. + + If the clipboard contains data in the CF_PALETTE (logical color palette) + format, the application should assume that any other data in the + clipboard is realized against that logical palette. + + The clipboard-viewer application (CLIPBRD.EXE) always uses as its + current palette any object in CF_PALETTE format that is in the clipboard + when it displays the other formats in the clipboard. + + Windows supports two formats for text, CF_TEXT and CF_OEMTEXT. CF_TEXT + is the default Windows text clipboard format, while Windows uses the + CF_OEMTEXT format for text in non-Windows applications. If you call + %GetClipboardData% to retrieve data in one text format and the other + text format is the only available text format, Windows automatically + converts the text to the requested format before supplying it to your + application. + + An application registers other standard formats, such as Rich Text + Format (RTF), by name using the %RegisterClipboardFormat% function + rather than by a symbolic constant. For information on these external + formats, see the README.TXT file. +--*/ + +ULONG FASTCALL WU32SetClipboardData(PVDMFRAME pFrame) +{ + ULONG ul = 0; + HANDLE hMem32 = NULL, hMF32 = NULL; + HAND16 hMem16, hMeta16 = 0; + LPBYTE lpMem16, lpMem32; + INT cb; + VPVOID vp; + + + register PSETCLIPBOARDDATA16 parg16; + + GETARGPTR(pFrame, sizeof(SETCLIPBOARDDATA16), parg16); + + LOGDEBUG(6, ("WOW::WUICBSetClipboardData(): CF_FORMAT is %04x\n", parg16->f1)); + + switch (parg16->f1) { + + default: + if ((parg16->f1 == CFOLEObjectDescriptor) || (parg16->f1 == CFOLELinkSrcDescriptor)) { + if (parg16->f2) { + hMem32 = W32ConvertObjDescriptor((HANDLE) parg16->f2, CFOLE_ANSI_TO_UNICODE); + } + ul = (ULONG) SetClipboardData(WORD32(parg16->f1), hMem32); + WU32ICBStoreHandle(parg16->f1, parg16->f2); + break; + } + + // It is intentional to let it thru to the "case statements". + // ChandanC 5/11/92. + + case CF_DIB: + case CF_TEXT: + case CF_DSPTEXT: + case CF_SYLK: + case CF_DIF: + case CF_TIFF: + case CF_OEMTEXT: + case CF_PENDATA: + case CF_RIFF: + case CF_WAVE: + case CF_OWNERDISPLAY: + hMem16 = parg16->f2; + if (hMem16) { + vp = GlobalLock16(hMem16, &cb); + if (vp) { + GETMISCPTR(vp, lpMem16); + hMem32 = Copyh16Toh32 (cb, lpMem16); + GlobalUnlock16(hMem16); + FREEMISCPTR(lpMem16); + } + } + + ul = (ULONG) SetClipboardData(WORD32(parg16->f1), hMem32); + + WU32ICBStoreHandle(parg16->f1, hMem16); + break; + + case CF_HDROP: + // support cf_hdrop format by converting the dropfiles structure + hMem16 = parg16->f2; + if (hMem16) { + hMem32 = CopyDropFilesFrom16(hMem16); + } + ul = (ULONG)SetClipboardData(WORD32(parg16->f1), hMem32); + WU32ICBStoreHandle(parg16->f1, hMem16); + break; + + case CF_DSPBITMAP: + case CF_BITMAP: + ul = (ULONG) SetClipboardData(WORD32(parg16->f1), + HBITMAP32(parg16->f2)); + break; + + + case CF_PALETTE: + ul = (ULONG) SetClipboardData(WORD32(parg16->f1), + HPALETTE32(parg16->f2)); + break; + + case CF_DSPMETAFILEPICT: + case CF_METAFILEPICT: + hMem16 = parg16->f2; + if (hMem16) { + vp = GlobalLock16(hMem16, &cb); + if (vp) { + GETMISCPTR(vp, lpMem16); + hMem32 = GlobalAlloc(GMEM_DDESHARE, sizeof(METAFILEPICT)); + WOW32ASSERT(hMem32); + if (hMem32) { + lpMem32 = GlobalLock(hMem32); + ((LPMETAFILEPICT) lpMem32)->mm = FETCHSHORT(((LPMETAFILEPICT16) lpMem16)->mm); + ((LPMETAFILEPICT) lpMem32)->xExt = (LONG) FETCHSHORT(((LPMETAFILEPICT16) lpMem16)->xExt); + ((LPMETAFILEPICT) lpMem32)->yExt = (LONG) FETCHSHORT(((LPMETAFILEPICT16) lpMem16)->yExt); + hMeta16 = FETCHWORD(((LPMETAFILEPICT16) lpMem16)->hMF); + if (hMeta16) { + hMF32 = (HMETAFILE) HMFFromWinMetaFile(hMeta16, FALSE); + } + ((LPMETAFILEPICT) lpMem32)->hMF = hMF32; + GlobalUnlock(hMem32); + } + GlobalUnlock16(hMem16); + FREEMISCPTR(lpMem16); + } + + } + + ul = (ULONG) SetClipboardData(WORD32(parg16->f1), hMem32); + + WU32ICBStoreHandle(parg16->f1, hMem16); + break; + + } + + if (parg16->f2) { + ul = parg16->f2; + } + + FREEARGPTR(parg16); + RETURN(ul); +} + + + +/*++ + HWND SetClipboardViewer(<hwnd>) + HWND <hwnd>; + + The %SetClipboardViewer% function adds the window specified by the <hwnd> + parameter to the chain of windows that are notified (via the + WM_DRAWCLIPBOARD message) whenever the contents of the clipboard are + changed. + + <hwnd> + Identifies the window to receive clipboard-viewer chain messages. + + The return value identifies the next window in the clipboard-viewer chain. + This handle should be saved in static memory and used in responding to + clipboard-viewer chain messages. + + Windows that are part of the clipboard-viewer chain must respond to + WM_CHANGECBCHAIN, WM_DRAWCLIPBOARD, and WM_DESTROY messages. + + If an application wishes to remove itself from the clipboard-viewer chain, + it must call the %ChangeClipboardChain% function. +--*/ + +ULONG FASTCALL WU32SetClipboardViewer(PVDMFRAME pFrame) +{ + ULONG ul; + register PSETCLIPBOARDVIEWER16 parg16; + + GETARGPTR(pFrame, sizeof(SETCLIPBOARDVIEWER16), parg16); + + ul = GETHWND16(SetClipboardViewer(HWND32(parg16->f1))); + + FREEARGPTR(parg16); + RETURN(ul); +} + + +VOID WU32ICBStoreHandle(WORD wFormat, HMEM16 hMem16) +{ + HAND16 h16, hMeta16; + PCBNODE Temp, Temp1; + LPBYTE lpMem16; + VPVOID vp; + int cb; + + + if ((wFormat == CF_METAFILEPICT) || (wFormat == CF_DSPMETAFILEPICT)) { + if (wFormat == CF_METAFILEPICT) { + h16 = ClipboardFormats.Pre1[wFormat]; + } + else { + h16 = ClipboardFormats.Pre2[3]; + } + + if (h16) { + vp = GlobalLock16(h16, &cb); + if (vp) { + GETMISCPTR(vp, lpMem16); + hMeta16 = FETCHWORD(((LPMETAFILEPICT16) lpMem16)->hMF); + GlobalUnlockFree16(GlobalLock16(hMeta16, NULL)); + } + GlobalUnlockFree16(vp); + + if (wFormat == CF_METAFILEPICT) { + ClipboardFormats.Pre1[wFormat] = 0; + } + else { + ClipboardFormats.Pre2[3] = 0; + } + } + } + + if ((wFormat >= CF_TEXT ) && (wFormat <= CF_WAVE)) { + if (ClipboardFormats.Pre1[wFormat]) { + GlobalUnlockFree16(GlobalLock16(ClipboardFormats.Pre1[wFormat], NULL)); + } + ClipboardFormats.Pre1[wFormat] = hMem16; + } + else if ((wFormat >= CF_OWNERDISPLAY) && (wFormat <= CF_DSPMETAFILEPICT)) { + wFormat = (wFormat & (WORD) 3); + + if (ClipboardFormats.Pre2[wFormat]) { + GlobalUnlockFree16(GlobalLock16(ClipboardFormats.Pre2[wFormat], NULL)); + } + + ClipboardFormats.Pre2[wFormat] = hMem16; + } + else if (wFormat == CF_HDROP) { + + if (ClipboardFormats.hmem16Drop) { + GlobalUnlockFree16(GlobalLock16(ClipboardFormats.hmem16Drop, NULL)); + } + ClipboardFormats.hmem16Drop = hMem16; + } + else { + Temp = ClipboardFormats.NewFormats; + if (Temp) { + while ((Temp->Next) && (Temp->Id != wFormat)) { + Temp = Temp->Next; + } + + if (Temp->Id == wFormat) { + + // free a previous handle if it exists + if (Temp->hMem16) { + GlobalUnlockFree16(GlobalLock16(Temp->hMem16, NULL)); + } + + Temp->hMem16 = hMem16; + } + else { + Temp1 = (PCBNODE) malloc_w (sizeof(CBNODE)); + if (Temp1) { + Temp->Next = Temp1; + Temp1->Id = wFormat; + Temp1->hMem16 = hMem16; + Temp1->Next = NULL; + + LOGDEBUG(6,("WOW::WU32ICBStoreHandle: Adding a new node for private clipboard data format %04lx\n", wFormat)); + } + } + } + else { + Temp = (PCBNODE) malloc_w (sizeof(CBNODE)); + if (Temp) { + ClipboardFormats.NewFormats = Temp; + Temp->Id = wFormat; + Temp->hMem16 = hMem16; + Temp->Next = NULL; + + LOGDEBUG(6,("WOW::WU32ICBStoreHandle: Adding the FIRST node for private clipboard data format %04lx\n", wFormat)); + } + } + } +} + + + +HMEM16 WU32ICBGetHandle(WORD wFormat) +{ + HMEM16 hMem16 = 0; + PCBNODE Temp; + + if ((wFormat >= CF_TEXT) && (wFormat <= CF_WAVE)) { + hMem16 = ClipboardFormats.Pre1[wFormat]; + } + else if ((wFormat >= CF_OWNERDISPLAY) && (wFormat <= CF_DSPMETAFILEPICT)) { + wFormat = (wFormat & (WORD) 3); + hMem16 = ClipboardFormats.Pre2[wFormat]; + } + else if (wFormat == CF_HDROP) { + hMem16 = ClipboardFormats.hmem16Drop; + } + else { + Temp = ClipboardFormats.NewFormats; + if (Temp) { + while ((Temp->Next) && (Temp->Id != wFormat)) { + Temp = Temp->Next; + } + + if (Temp->Id == wFormat) { + hMem16 = Temp->hMem16; + } + else { + LOGDEBUG(6,("WOW::WU32ICBGetHandle: Cann't find private clipboard data format %04lx\n", wFormat)); + hMem16 = (WORD) NULL; + } + } + } + + return (hMem16); +} + + + +VOID W32EmptyClipboard () +{ + PCBNODE Temp, Temp1; + int wFormat, cb; + HAND16 hMem16, hMeta16; + LPBYTE lpMem16; + VPVOID vp; + + // Empty CF_METAFILEPICT + + hMem16 = ClipboardFormats.Pre1[CF_METAFILEPICT]; + if (hMem16) { + vp = GlobalLock16(hMem16, &cb); + if (vp) { + GETMISCPTR(vp, lpMem16); + hMeta16 = FETCHWORD(((LPMETAFILEPICT16) lpMem16)->hMF); + GlobalUnlockFree16(GlobalLock16(hMeta16, NULL)); + } + GlobalUnlockFree16(vp); + ClipboardFormats.Pre1[CF_METAFILEPICT] = 0; + } + + // Empty CF_DSPMETAFILEPICT + + hMem16 = ClipboardFormats.Pre2[3]; + if (hMem16) { + vp = GlobalLock16(hMem16, &cb); + if (vp) { + GETMISCPTR(vp, lpMem16); + hMeta16 = FETCHWORD(((LPMETAFILEPICT16) lpMem16)->hMF); + GlobalUnlockFree16(GlobalLock16(hMeta16, NULL)); + } + GlobalUnlockFree16(vp); + ClipboardFormats.Pre2[3] = 0; + } + + // Empty rest of the formats + + for (wFormat=0; wFormat <= CF_WAVE ; wFormat++) { + if (ClipboardFormats.Pre1[wFormat]) { + GlobalUnlockFree16(GlobalLock16(ClipboardFormats.Pre1[wFormat], NULL)); + ClipboardFormats.Pre1[wFormat] = 0; + } + } + + for (wFormat=0; wFormat < 4 ; wFormat++) { + if (ClipboardFormats.Pre2[wFormat]) { + GlobalUnlockFree16(GlobalLock16(ClipboardFormats.Pre2[wFormat], NULL)); + ClipboardFormats.Pre2[wFormat] = 0; + } + } + + if (ClipboardFormats.hmem16Drop) { + GlobalUnlockFree16(GlobalLock16(ClipboardFormats.hmem16Drop, NULL)); + } + ClipboardFormats.hmem16Drop = 0; + + + // These are the private registered data formats. This list is purged when + // 32 bit USER purges its clipboard cache. + + Temp = ClipboardFormats.NewFormats; + ClipboardFormats.NewFormats = NULL; + + while (Temp) { + + Temp1 = Temp->Next; + + if (Temp->hMem16) { + GlobalUnlockFree16(GlobalLock16(Temp->hMem16, NULL)); + } + + free_w(Temp); + + Temp = Temp1; + } + +} + + +VOID InitCBFormats () + +{ + int wFormat; + + for (wFormat = 0 ; wFormat <= CF_WAVE ; wFormat++) { + ClipboardFormats.Pre1[wFormat] = 0; + } + + for (wFormat=0; wFormat < 4; wFormat++) { + ClipboardFormats.Pre2[wFormat] = 0; + } + + ClipboardFormats.hmem16Drop = 0; + + // These are the private registered data formats. + + ClipboardFormats.NewFormats = NULL; + + + CFOLEObjectDescriptor = RegisterClipboardFormat ("Object Descriptor"); + CFOLELinkSrcDescriptor = RegisterClipboardFormat ("Link Source Descriptor"); + +#ifdef DEBUG + + // + // This would assert in LoadLibraryAndGetProcAddresses if the function + // or DLL name has changed. + // + + if (!(OleStringConversion[WOW_OLE_STRINGCONVERSION].lpfn)) { + LoadLibraryAndGetProcAddresses("OLETHK32.DLL", OleStringConversion, WOW_OLESTRINGCONVERSION_COUNT); + } + +#endif + + +} + + +HGLOBAL W32ConvertObjDescriptor(HANDLE hMem, UINT flag) +{ + HANDLE hMemOut; + + if (!(OleStringConversion[WOW_OLE_STRINGCONVERSION].lpfn)) { + if (!LoadLibraryAndGetProcAddresses("OLETHK32.DLL", OleStringConversion, WOW_OLESTRINGCONVERSION_COUNT)) { + return (0); + } + } + + hMemOut = (HANDLE) (*OleStringConversion[WOW_OLE_STRINGCONVERSION].lpfn) (hMem, flag); + + return (hMemOut); +} |