clipboard.c File Reference

#include <user32.h>

Include dependency graph for clipboard.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (user32)
HANDLE WINAPI	GdiConvertMetaFilePict (HANDLE)
HANDLE WINAPI	GdiConvertEnhMetaFile (HANDLE)
HANDLE WINAPI	GdiCreateLocalEnhMetaFile (HANDLE)
HANDLE WINAPI	GdiCreateLocalMetaFilePict (HANDLE)
BOOL WINAPI	OpenClipboard (HWND hWndNewOwner)
UINT WINAPI	EnumClipboardFormats (UINT format)
INT WINAPI	GetClipboardFormatNameA (UINT format, LPSTR lpszFormatName, int cchMaxCount)
INT WINAPI	GetClipboardFormatNameW (UINT uFormat, LPWSTR lpszFormatName, INT cchMaxCount)
UINT WINAPI	RegisterClipboardFormatA (LPCSTR lpszFormat)
UINT WINAPI	RegisterClipboardFormatW (LPCWSTR lpszFormat)
static PVOID WINAPI	IntSynthesizeMultiByte (PVOID pwStr, DWORD cbStr, BOOL bOem)
static PVOID WINAPI	IntSynthesizeWideChar (PVOID pwStr, DWORD cbStr, BOOL bOem)
HANDLE WINAPI	GetClipboardData (UINT uFormat)
HANDLE WINAPI	SetClipboardData (UINT uFormat, HANDLE hMem)
BOOL WINAPI	AddClipboardFormatListener (HWND hwnd)
BOOL WINAPI	RemoveClipboardFormatListener (HWND hwnd)
BOOL WINAPI	GetUpdatedClipboardFormats (PUINT lpuiFormats, UINT cFormats, PUINT pcFormatsOut)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file clipboard.c.

Function Documentation

AddClipboardFormatListener()

BOOL WINAPI AddClipboardFormatListener

(

HWND

hwnd

)

Definition at line 382 of file clipboard.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

EnumClipboardFormats()

UINT WINAPI EnumClipboardFormats

(

UINT

format

)

Definition at line 39 of file clipboard.c.

{
    SetLastError(NO_ERROR);
    return NtUserxEnumClipboardFormats(format);
}

GdiConvertEnhMetaFile()

HANDLE WINAPI GdiConvertEnhMetaFile

(

HANDLE

)

Referenced by SetClipboardData().

GdiConvertMetaFilePict()

HANDLE WINAPI GdiConvertMetaFilePict

(

HANDLE

hMetaFilePict

)

Definition at line 201 of file metafile.c.

{
    HMETAFILE       hMF;
    UINT            nSize;
    HANDLE          hmo    = NULL;
    BYTE *          Buffer = NULL;
    METAFILEPICT *  pInfo  = NULL;
 
    // get METAFILEPICT pointer
    pInfo = (METAFILEPICT *)GlobalLock(hMetaFilePict);
    if (pInfo == NULL)
        goto Exit;
 
    // get metafile handle
    hMF = pInfo->hMF;
 
    // get size of buffer
    nSize = GetMetaFileBitsEx(hMF, 0, NULL);
    if (nSize == 0)
        goto Exit;
 
    // allocate buffer
    Buffer = (BYTE *)LocalAlloc(LPTR, nSize);
    if (Buffer == NULL)
        goto Exit;
 
    // store to buffer
    nSize = GetMetaFileBitsEx(hMF, nSize, Buffer);
    if (nSize == 0)
        goto Exit;
 
    hmo = NtGdiCreateServerMetaFile( GDITAG_TYPE_MFP, nSize, Buffer, pInfo->mm, pInfo->xExt, pInfo->yExt);
 
Exit:
    // clean up
    if (pInfo)
        GlobalUnlock(hMetaFilePict);
    if (Buffer)
        LocalFree(Buffer);
    return hmo;    // success if non-NULL
}

Referenced by SetClipboardData().

GdiCreateLocalEnhMetaFile()

HANDLE WINAPI GdiCreateLocalEnhMetaFile

(

HANDLE

hmo

)

Definition at line 74 of file enhmfile.c.

{
    HENHMETAFILE hEMF;
    BYTE *       Buffer = NULL;
    UINT         nSize;
    DWORD        iType, mm, xExt, yExt;
 
    nSize = NtGdiGetServerMetaFileBits( hmo, 0, NULL, NULL, NULL, NULL, NULL);
    if (nSize == 0)
        goto Exit;
 
    // allocate buffer
    Buffer = (BYTE *)LocalAlloc(LPTR, nSize);
    if (Buffer == NULL)
        goto Exit;
 
    // store to buffer
    nSize = NtGdiGetServerMetaFileBits( hmo, nSize, Buffer, &iType, &mm, &xExt, &yExt);
    if (nSize == 0)
        goto Exit;
 
    if ( iType == GDITAG_TYPE_MFP ) // handle conversion to EMF
    {
        METAFILEPICT Info;
 
        Info.hMF  = NULL;
        Info.mm   = mm;
        Info.xExt = xExt;
        Info.yExt = yExt;
 
        hEMF = SetWinMetaFileBits( nSize, Buffer, NULL, &Info ); // Translate from old style to new style.
        if (hEMF == NULL)
            goto Exit;
    }
    else
    {
        hEMF = SetEnhMetaFileBits(nSize, Buffer);
        if (hEMF == NULL)
            goto Exit;
    }
 
Exit:
    // clean up
    if (Buffer)
        LocalFree(Buffer);
    return hEMF;
}

Referenced by GetClipboardData().

GdiCreateLocalMetaFilePict()

HANDLE WINAPI GdiCreateLocalMetaFilePict

(

HANDLE

hmo

)

Definition at line 95 of file metafile.c.

{
    HGLOBAL         hMetaFilePict;
    METAFILEPICT *  pInfo;
    HMETAFILE       hMF = NULL;
    BYTE *          Buffer = NULL;
    BYTE *          BufNew = NULL;
    HDC             hDC = NULL;
    UINT            nSize, cSize;
    DWORD           iType;
 
    // NOTE: On Win32, there is no difference between the local heap and
    //       the global heap. GlobalAlloc and LocalAlloc have same effect.
 
    // allocate for METAFILEPICT
    hMetaFilePict = GlobalAlloc(GHND | GMEM_SHARE, sizeof(METAFILEPICT));
    pInfo = (METAFILEPICT *)GlobalLock(hMetaFilePict);
    if (pInfo == NULL)
        goto Exit;
 
    nSize = NtGdiGetServerMetaFileBits( hmo, 0, NULL, NULL, NULL, NULL, NULL );
 
    // allocate buffer
    Buffer = (BYTE *)LocalAlloc(LPTR, nSize);
    if (Buffer == NULL)
        goto Exit;
 
    // store to buffer
    nSize = NtGdiGetServerMetaFileBits( hmo, nSize, Buffer, &iType, (PDWORD)&pInfo->mm, (PDWORD)&pInfo->xExt, (PDWORD)&pInfo->yExt );
    if (nSize == 0)
        goto Exit;
 
    if ( iType == GDITAG_TYPE_EMF ) // handle conversion to MFP
    {
        static const WCHAR szDisplayW[] = { 'D','I','S','P','L','A','Y','\0' };
        HENHMETAFILE hEMF;
        ENHMETAHEADER emh;
 
        hEMF = SetEnhMetaFileBits(nSize, Buffer);
        if (hEMF == NULL)
            goto Exit;
 
        if (!GetEnhMetaFileHeader( hEMF, sizeof(emh), &emh ))
        {
            DeleteEnhMetaFile(hEMF);
            goto Exit;
        }
 
        pInfo->mm   = MM_ANISOTROPIC; // wine uses MM_ISOTROPIC.
        pInfo->xExt = emh.rclFrame.right   - emh.rclFrame.left; // Width
        pInfo->yExt = emh.rclFrame.bottom  - emh.rclFrame.top;  // Height
 
        hDC = CreateDCW(szDisplayW, NULL, NULL, NULL);
        if (hDC)
        {
            cSize = GetWinMetaFileBits( hEMF, 0, NULL, MM_ANISOTROPIC, hDC );
            if (cSize)
            {
                BufNew = (BYTE *)LocalAlloc(LPTR, cSize);
                if (BufNew)
                {
                    nSize = GetWinMetaFileBits( hEMF, cSize, (LPBYTE)BufNew, MM_ANISOTROPIC, hDC );
                    if (nSize == cSize)
                    {
                        if (Buffer) LocalFree(Buffer);
                        Buffer = BufNew;
                    }
                }
            }
            DeleteDC(hDC);
        }
        DeleteEnhMetaFile(hEMF);
 
        if (Buffer != BufNew)
            goto Exit;
    }
 
    // create metafile from buffer
    hMF = SetMetaFileBitsEx(nSize, Buffer);
    if (hMF == NULL)
        goto Exit;
 
    // set metafile handle
    pInfo->hMF = hMF;
 
Exit:
    // clean up
    if (Buffer)
        LocalFree(Buffer);
    if (pInfo)
        GlobalUnlock(hMetaFilePict);
    if (hMF == NULL)
    {
        // failure
        GlobalFree(hMetaFilePict);
        hMetaFilePict = NULL;
    }
 
    return hMetaFilePict;   // success if non-NULL
}

Referenced by GetClipboardData().

GetClipboardData()

HANDLE WINAPI GetClipboardData

(

UINT

uFormat

)

Definition at line 198 of file clipboard.c.

{
    HANDLE hData = NULL;
    PVOID pData = NULL;
    DWORD cbData = 0;
    GETCLIPBDATA gcd;
 
    hData = NtUserGetClipboardData(uFormat, &gcd);
    if (!hData)
        return NULL;
 
    switch (uFormat)
    {
        case CF_DSPMETAFILEPICT:
        case CF_METAFILEPICT:
            return GdiCreateLocalMetaFilePict(hData);
        case CF_DSPENHMETAFILE:
        case CF_ENHMETAFILE:
            return GdiCreateLocalEnhMetaFile(hData);
    }
 
    if (gcd.fGlobalHandle)
    {
        HANDLE hGlobal;
 
        NtUserCreateLocalMemHandle(hData, NULL, 0, &cbData);
        hGlobal = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbData);
        pData = GlobalLock(hGlobal);
        NtUserCreateLocalMemHandle(hData, pData, cbData, NULL);
        hData = hGlobal;
    }
 
    if (gcd.uFmtRet != uFormat)
    {
        SETCLIPBDATA scd = {FALSE, FALSE};
        HANDLE hNewData = NULL;
        PVOID pNewData = NULL;
 
        /* Synthesize requested format */
        switch (uFormat)
        {
            case CF_TEXT:
                if (gcd.uFmtRet == CF_UNICODETEXT)
                    pNewData = IntSynthesizeMultiByte(pData, cbData, uFormat == CF_OEMTEXT);
                else // CF_OEMTEXT
                    OemToCharBuffA(pData, pData, cbData);
                break;
            case CF_OEMTEXT:
                if (gcd.uFmtRet == CF_UNICODETEXT)
                    pNewData = IntSynthesizeMultiByte(pData, cbData, uFormat == CF_OEMTEXT);
                else
                    CharToOemBuffA(pData, pData, cbData);
                break;
            case CF_UNICODETEXT:
                pNewData = IntSynthesizeWideChar(pData, cbData, gcd.uFmtRet == CF_OEMTEXT);
                break;
            default:
                FIXME("Format: %u != %u\n", uFormat, gcd.uFmtRet);
        }
 
        /* Is it a global handle? */
        if (pNewData)
            hNewData = GlobalHandle(pNewData);
 
        if (hNewData)
        {
            /* Free old data */
            if (pData)
            {
                GlobalUnlock(hData);
                GlobalFree(hData);
            }
            hData = hNewData;
            pData = pNewData;
        }
 
        /* Save synthesized format in clipboard */
        if (pData)
        {
            HANDLE hMem;
 
            scd.fGlobalHandle = TRUE;
            hMem = NtUserConvertMemHandle(pData, GlobalSize(hData));
            NtUserSetClipboardData(uFormat, hMem, &scd);
        }
        else if (hData)
            NtUserSetClipboardData(uFormat, hData, &scd);
    }
 
    /* Unlock global handle */
    if (pData)
        GlobalUnlock(hData);
 
    return hData;
}

GetClipboardFormatNameA()

INT WINAPI GetClipboardFormatNameA	(	UINT	format,
		LPSTR	lpszFormatName,
		int	cchMaxCount
	)

Definition at line 50 of file clipboard.c.

{
    LPWSTR lpBuffer;
    INT Length;
 
    lpBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, cchMaxCount * sizeof(WCHAR));
    if (!lpBuffer)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return 0;
    }
 
    /* we need a UNICODE string */
    Length = NtUserGetClipboardFormatName(format, lpBuffer, cchMaxCount);
 
    if (Length != 0)
    {
        if (!WideCharToMultiByte(CP_ACP, 0, lpBuffer, Length, lpszFormatName, cchMaxCount, NULL, NULL))
        {
            /* clear result string */
            Length = 0;
        }
        lpszFormatName[Length] = ANSI_NULL;
    }
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, lpBuffer);
    return Length;
}

GetClipboardFormatNameW()

INT WINAPI GetClipboardFormatNameW	(	UINT	uFormat,
		LPWSTR	lpszFormatName,
		INT	cchMaxCount
	)

Definition at line 86 of file clipboard.c.

{
    return NtUserGetClipboardFormatName(uFormat, lpszFormatName, cchMaxCount);
}

GetUpdatedClipboardFormats()

BOOL WINAPI GetUpdatedClipboardFormats	(	PUINT	lpuiFormats,
		UINT	cFormats,
		PUINT	pcFormatsOut
	)

Definition at line 403 of file clipboard.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

IntSynthesizeMultiByte()

static PVOID WINAPI IntSynthesizeMultiByte ( PVOID  pwStr, DWORD  cbStr, BOOL  bOem  )

static

Definition at line 154 of file clipboard.c.

{
    HANDLE hGlobal;
    PVOID pGlobal;
    INT cbGlobal;
 
    cbGlobal = WideCharToMultiByte(bOem ? CP_OEMCP : CP_ACP,
                                0, pwStr, cbStr / sizeof(WCHAR),
                                NULL, 0, NULL, NULL);
    hGlobal = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbGlobal);
    if (!hGlobal)
        return NULL;
 
    pGlobal = GlobalLock(hGlobal);
    WideCharToMultiByte(bOem ? CP_OEMCP : CP_ACP,
                        0, pwStr, cbStr / sizeof(WCHAR),
                        pGlobal, cbGlobal, NULL, NULL);
    return pGlobal;
}

Referenced by GetClipboardData().

IntSynthesizeWideChar()

static PVOID WINAPI IntSynthesizeWideChar ( PVOID  pwStr, DWORD  cbStr, BOOL  bOem  )

static

Definition at line 175 of file clipboard.c.

{
    HANDLE hGlobal;
    PVOID pGlobal;
    INT cbGlobal;
 
    cbGlobal = MultiByteToWideChar(bOem ? CP_OEMCP : CP_ACP,
                                   0, pwStr, cbStr, NULL, 0) * sizeof(WCHAR);
    hGlobal = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbGlobal);
    if (!hGlobal)
        return NULL;
 
    pGlobal = GlobalLock(hGlobal);
    MultiByteToWideChar(bOem ? CP_OEMCP : CP_ACP,
                        0, pwStr, cbStr, pGlobal, cbGlobal);
    return pGlobal;
}

Referenced by GetClipboardData().

OpenClipboard()

BOOL WINAPI OpenClipboard

(

HWND

hWndNewOwner

)

Definition at line 29 of file clipboard.c.

{
    return NtUserOpenClipboard(hWndNewOwner, 0);
}

RegisterClipboardFormatA()

UINT WINAPI RegisterClipboardFormatA

(

LPCSTR

lpszFormat

)

Definition at line 98 of file clipboard.c.

{
    UINT ret;
    UNICODE_STRING usFormat = {0};
 
    if (lpszFormat == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (*lpszFormat == ANSI_NULL)
    {
        SetLastError(ERROR_INVALID_NAME);
        return 0;
    }
 
    if (!RtlCreateUnicodeStringFromAsciiz(&usFormat, lpszFormat))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return 0;
    }
 
    ret = NtUserRegisterWindowMessage(&usFormat); //(LPCWSTR)
 
    RtlFreeUnicodeString(&usFormat);
 
    return ret;
}

RegisterClipboardFormatW()

UINT WINAPI RegisterClipboardFormatW

(

LPCWSTR

lpszFormat

)

Definition at line 133 of file clipboard.c.

{
    UNICODE_STRING usFormat = {0};
 
    if (lpszFormat == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (*lpszFormat == UNICODE_NULL)
    {
        SetLastError(ERROR_INVALID_NAME);
        return 0;
    }
 
    RtlInitUnicodeString(&usFormat, lpszFormat);
    return NtUserRegisterWindowMessage(&usFormat);
}

RemoveClipboardFormatListener()

BOOL WINAPI RemoveClipboardFormatListener

(

HWND

hwnd

)

Definition at line 392 of file clipboard.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

SetClipboardData()

HANDLE WINAPI SetClipboardData	(	UINT	uFormat,
		HANDLE	hMem
	)

Definition at line 299 of file clipboard.c.

{
    DWORD dwSize;
    HANDLE hGlobal;
    LPVOID pMem;
    HANDLE hRet = NULL, hTemp;
    SETCLIPBDATA scd = {FALSE, FALSE};
 
    /* Check if this is a delayed rendering */
    if (hMem == NULL)
        return NtUserSetClipboardData(uFormat, NULL, &scd);
 
    if (hMem <= (HANDLE)4)
        SetLastError(ERROR_INVALID_PARAMETER);
    /* Bitmaps and palette does not use global handles */
    else if (uFormat == CF_BITMAP || uFormat == CF_DSPBITMAP || uFormat == CF_PALETTE)
        hRet = NtUserSetClipboardData(uFormat, hMem, &scd);
    /* Meta files are probably checked for validity */
    else if (uFormat == CF_DSPMETAFILEPICT || uFormat == CF_METAFILEPICT )
    {
        hTemp = GdiConvertMetaFilePict( hMem );
        hRet = NtUserSetClipboardData(uFormat, hTemp, &scd); // Note : LOL, it returns a BOOL not a HANDLE!!!!
        if (hRet == hTemp) hRet = hMem;                      // If successful "TRUE", return the original handle.
    }
    else if (uFormat == CF_DSPENHMETAFILE || uFormat == CF_ENHMETAFILE)
    {
        hTemp = GdiConvertEnhMetaFile( hMem );
        hRet = NtUserSetClipboardData(uFormat, hTemp, &scd);
        if (hRet == hTemp) hRet = hMem;
    }
    else
    {
        /* Some formats accept only global handles, other accept global handles or integer values */
        pMem = GlobalLock(hMem);
        dwSize = GlobalSize(hMem);
 
        if (pMem || uFormat == CF_DIB || uFormat == CF_DIBV5 ||
            uFormat == CF_DSPTEXT || uFormat == CF_LOCALE ||
            uFormat == CF_OEMTEXT || uFormat == CF_TEXT ||
            uFormat == CF_UNICODETEXT)
        {
            if (pMem)
            {
                /* This is a local memory. Make global memory object */
                hGlobal = NtUserConvertMemHandle(pMem, dwSize);
 
                /* Unlock memory */
                GlobalUnlock(hMem);
                /* FIXME: free hMem when CloseClipboard is called */
 
                if (hGlobal)
                {
                    /* Save data */
                    scd.fGlobalHandle = TRUE;
                    hRet = NtUserSetClipboardData(uFormat, hGlobal, &scd);
                }
 
                /* On success NtUserSetClipboardData returns pMem
                   however caller expects us to return hMem */
                if (hRet == hGlobal)
                    hRet = hMem;
            }
            else
                SetLastError(ERROR_INVALID_HANDLE);
        }
        else
        {
            /* Save a number */
            hRet = NtUserSetClipboardData(uFormat, hMem, &scd);
        }
    }
 
    if (!hRet)
        ERR("SetClipboardData(%u, %p) failed\n", uFormat, hMem);
 
    return hRet;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

user32

)