clipboard.c File Reference

#include <win32k.h>

Include dependency graph for clipboard.c:

Go to the source code of this file.

Macros
#define	DATA_DELAYED   (HANDLE)0
#define	DATA_SYNTH_USER   (HANDLE)1
#define	DATA_SYNTH_KRNL   (HANDLE)2
#define	IS_DATA_DELAYED(ce)   ((ce)->hData == DATA_DELAYED)
#define	IS_DATA_SYNTHESIZED(ce)   ((ce)->hData == DATA_SYNTH_USER || (ce)->hData == DATA_SYNTH_KRNL)

Functions
	DBG_DEFAULT_CHANNEL (UserClipbrd)
static PWINSTATION_OBJECT FASTCALL	IntGetWinStaForCbAccess (VOID)
static PCLIP FASTCALL	IntGetFormatElement (PWINSTATION_OBJECT pWinStaObj, UINT fmt)
static BOOL FASTCALL	IntIsFormatAvailable (PWINSTATION_OBJECT pWinStaObj, UINT fmt)
static VOID FASTCALL	IntFreeElementData (PCLIP pElement)
static PCLIP NTAPI	IntAddFormatedData (PWINSTATION_OBJECT pWinStaObj, UINT fmt, HANDLE hData, BOOLEAN fGlobalHandle, BOOL bEnd)
static BOOL FASTCALL	IntIsClipboardOpenByMe (PWINSTATION_OBJECT pWinSta)
static VOID NTAPI	IntSynthesizeDib (PWINSTATION_OBJECT pWinStaObj, HBITMAP hbm)
static VOID WINAPI	IntSynthesizeBitmap (PWINSTATION_OBJECT pWinStaObj, PCLIP pBmEl)
static VOID NTAPI	IntAddSynthesizedFormats (PWINSTATION_OBJECT pWinStaObj)
VOID NTAPI	UserEmptyClipboardData (PWINSTATION_OBJECT pWinSta)
VOID FASTCALL	UserClipboardRelease (PWND pWindow)
VOID FASTCALL	UserClipboardFreeWindow (PWND pWindow)
UINT APIENTRY	UserEnumClipboardFormats (UINT fmt)
BOOL NTAPI	UserOpenClipboard (HWND hWnd)
BOOL APIENTRY	NtUserOpenClipboard (HWND hWnd, DWORD Unknown1)
BOOL NTAPI	UserCloseClipboard (VOID)
BOOL APIENTRY	NtUserCloseClipboard (VOID)
HWND APIENTRY	NtUserGetOpenClipboardWindow (VOID)
BOOL APIENTRY	NtUserChangeClipboardChain (HWND hWndRemove, HWND hWndNewNext)
DWORD APIENTRY	NtUserCountClipboardFormats (VOID)
BOOL NTAPI	UserEmptyClipboard (VOID)
BOOL APIENTRY	NtUserEmptyClipboard (VOID)
INT APIENTRY	NtUserGetClipboardFormatName (UINT fmt, LPWSTR lpszFormatName, INT cchMaxCount)
HWND APIENTRY	NtUserGetClipboardOwner (VOID)
HWND APIENTRY	NtUserGetClipboardViewer (VOID)
INT APIENTRY	NtUserGetPriorityClipboardFormat (UINT *paFormatPriorityList, INT cFormats)
BOOL APIENTRY	NtUserIsClipboardFormatAvailable (UINT fmt)
HANDLE APIENTRY	NtUserGetClipboardData (UINT fmt, PGETCLIPBDATA pgcd)
HANDLE NTAPI	UserSetClipboardData (UINT fmt, HANDLE hData, PSETCLIPBDATA scd)
HANDLE APIENTRY	NtUserSetClipboardData (UINT fmt, HANDLE hData, PSETCLIPBDATA pUnsafeScd)
HWND APIENTRY	NtUserSetClipboardViewer (HWND hWndNewViewer)
DWORD APIENTRY	NtUserGetClipboardSequenceNumber (VOID)
HANDLE APIENTRY	NtUserConvertMemHandle (PVOID pData, DWORD cbData)
NTSTATUS APIENTRY	NtUserCreateLocalMemHandle (HANDLE hMem, PVOID pData, DWORD cbData, DWORD *pcbData)

Macro Definition Documentation

DATA_DELAYED

#define DATA_DELAYED   (HANDLE)0

Definition at line 14 of file clipboard.c.

DATA_SYNTH_KRNL

#define DATA_SYNTH_KRNL   (HANDLE)2

Definition at line 16 of file clipboard.c.

DATA_SYNTH_USER

#define DATA_SYNTH_USER   (HANDLE)1

Definition at line 15 of file clipboard.c.

IS_DATA_DELAYED

#define IS_DATA_DELAYED

(

ce

)

((ce)->hData == DATA_DELAYED)

Definition at line 17 of file clipboard.c.

IS_DATA_SYNTHESIZED

#define IS_DATA_SYNTHESIZED

(

ce

)

((ce)->hData == DATA_SYNTH_USER || (ce)->hData == DATA_SYNTH_KRNL)

Definition at line 18 of file clipboard.c.

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

UserClipbrd

)

IntAddFormatedData()

static PCLIP NTAPI IntAddFormatedData ( PWINSTATION_OBJECT  pWinStaObj, UINT  fmt, HANDLE  hData, BOOLEAN  fGlobalHandle, BOOL  bEnd  )

static

Definition at line 84 of file clipboard.c.

{
    PCLIP pElement = NULL;
 
    /* Use existing entry with specified format */
    if (!bEnd)
        pElement = IntGetFormatElement(pWinStaObj, fmt);
 
    /* Put new entry at the end if nothing was found */
    if (!pElement)
    {
        /* Allocate bigger clipboard if needed. We could use lists but Windows uses array */
        if (pWinStaObj->cNumClipFormats % 4 == 0)
        {
            PCLIP pNewClip;
 
            /* Allocate new clipboard */
            pNewClip = ExAllocatePoolWithTag(PagedPool,
                                             (pWinStaObj->cNumClipFormats + 4) * sizeof(CLIP),
                                             USERTAG_CLIPBOARD);
            if (!pNewClip)
            {
                EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return NULL;
            }
 
            /* Copy data */
            memcpy(pNewClip, pWinStaObj->pClipBase, pWinStaObj->cNumClipFormats * sizeof(CLIP));
 
            /* Free old clipboard */
            if (pWinStaObj->pClipBase)
                ExFreePoolWithTag(pWinStaObj->pClipBase, USERTAG_CLIPBOARD);
 
            /* Update WinSta */
            pWinStaObj->pClipBase = pNewClip;
        }
 
        /* New element is at the end */
        pElement = &pWinStaObj->pClipBase[pWinStaObj->cNumClipFormats];
        pElement->fmt = fmt;
        pWinStaObj->cNumClipFormats++;
    }
    else
        IntFreeElementData(pElement);
 
    pElement->hData = hData;
    pElement->fGlobalHandle = fGlobalHandle;
 
    return pElement;
}

Referenced by IntAddSynthesizedFormats(), IntSynthesizeDib(), and UserSetClipboardData().

IntAddSynthesizedFormats()

static VOID NTAPI IntAddSynthesizedFormats ( PWINSTATION_OBJECT  pWinStaObj )

static

Definition at line 291 of file clipboard.c.

{
    BOOL bHaveText, bHaveUniText, bHaveOemText, bHaveLocale, bHaveBm, bHaveDib, bHaveMFP, bHaveEMF;
 
    bHaveText = IntIsFormatAvailable(pWinStaObj, CF_TEXT);
    bHaveOemText = IntIsFormatAvailable(pWinStaObj, CF_OEMTEXT);
    bHaveUniText = IntIsFormatAvailable(pWinStaObj, CF_UNICODETEXT);
    bHaveLocale = IntIsFormatAvailable(pWinStaObj, CF_LOCALE);
    bHaveBm = IntIsFormatAvailable(pWinStaObj, CF_BITMAP);
    bHaveDib = IntIsFormatAvailable(pWinStaObj, CF_DIB);
    bHaveMFP = IntIsFormatAvailable(pWinStaObj, CF_METAFILEPICT);
    bHaveEMF = IntIsFormatAvailable(pWinStaObj, CF_ENHMETAFILE);
 
    /* Add CF_LOCALE format if we have CF_TEXT, CF_OEMTEXT or CF_UNICODETEXT */
    if (!bHaveLocale && (bHaveText || bHaveOemText || bHaveUniText))
    {
        PCLIPBOARDDATA pMemObj;
        HANDLE hMem;
 
        pMemObj = (PCLIPBOARDDATA)UserCreateObject(gHandleTable, NULL, NULL, &hMem, TYPE_CLIPDATA,
                                                   sizeof(CLIPBOARDDATA) + sizeof(LCID));
        if (pMemObj)
        {
            pMemObj->cbData = sizeof(LCID);
            *((LCID*)pMemObj->Data) = NtCurrentTeb()->CurrentLocale;
            IntAddFormatedData(pWinStaObj, CF_LOCALE, hMem, TRUE, TRUE);
 
            /* Release the extra reference (UserCreateObject added 2 references) */
            UserDereferenceObject(pMemObj);
        }
    }
 
    /* Add CF_TEXT. Note: it is synthesized in user32.dll */
    if (!bHaveText && (bHaveUniText || bHaveOemText))
        IntAddFormatedData(pWinStaObj, CF_TEXT, DATA_SYNTH_USER, FALSE, TRUE);
 
    /* Add CF_OEMTEXT. Note: it is synthesized in user32.dll */
    if (!bHaveOemText && (bHaveUniText || bHaveText))
        IntAddFormatedData(pWinStaObj, CF_OEMTEXT, DATA_SYNTH_USER, FALSE, TRUE);
 
    /* Add CF_UNICODETEXT. Note: it is synthesized in user32.dll */
    if (!bHaveUniText && (bHaveText || bHaveOemText))
        IntAddFormatedData(pWinStaObj, CF_UNICODETEXT, DATA_SYNTH_USER, FALSE, TRUE);
 
    /* Add CF_BITMAP. Note: it is synthesized on demand */
    if (!bHaveBm && bHaveDib)
        IntAddFormatedData(pWinStaObj, CF_BITMAP, DATA_SYNTH_KRNL, FALSE, TRUE);
 
    /* Add CF_ENHMETAFILE. Note: it is synthesized in gdi32.dll */
    if (bHaveMFP && !bHaveEMF)
        IntAddFormatedData(pWinStaObj, CF_ENHMETAFILE, DATA_SYNTH_USER, FALSE, TRUE);
 
    /* Add CF_METAFILEPICT. Note: it is synthesized in gdi32.dll */
    if (bHaveEMF && !bHaveMFP)
        IntAddFormatedData(pWinStaObj, CF_METAFILEPICT, DATA_SYNTH_USER, FALSE, TRUE);
 
    /* Note: We need to render the DIB or DIBV5 format as soon as possible
       because palette information may change */
    if (!bHaveDib && bHaveBm)
        IntSynthesizeDib(pWinStaObj, IntGetFormatElement(pWinStaObj, CF_BITMAP)->hData);
}

Referenced by UserClipboardRelease(), and UserCloseClipboard().

IntFreeElementData()

static VOID FASTCALL IntFreeElementData ( PCLIP  pElement )

static

Definition at line 61 of file clipboard.c.

{
    if (!IS_DATA_DELAYED(pElement) &&
        !IS_DATA_SYNTHESIZED(pElement))
    {
        if (pElement->fGlobalHandle)
            UserDeleteObject(pElement->hData, TYPE_CLIPDATA);
        else if (pElement->fmt == CF_BITMAP          ||
                 pElement->fmt == CF_PALETTE         ||
                 pElement->fmt == CF_DSPBITMAP       ||
                 pElement->fmt == CF_METAFILEPICT    ||
                 pElement->fmt == CF_DSPMETAFILEPICT ||
                 pElement->fmt == CF_DSPENHMETAFILE  ||
                 pElement->fmt == CF_ENHMETAFILE )
        {
            GreSetObjectOwner(pElement->hData, GDI_OBJ_HMGR_POWNED);
            GreDeleteObject(pElement->hData);
        }
    }
}

Referenced by IntAddFormatedData(), and UserEmptyClipboardData().

IntGetFormatElement()

static PCLIP FASTCALL IntGetFormatElement ( PWINSTATION_OBJECT  pWinStaObj, UINT  fmt  )

static

Definition at line 41 of file clipboard.c.

{
    DWORD i;
 
    for (i = 0; i < pWinStaObj->cNumClipFormats; ++i)
    {
        if (pWinStaObj->pClipBase[i].fmt == fmt)
            return &pWinStaObj->pClipBase[i];
    }
 
    return NULL;
}

Referenced by IntAddFormatedData(), IntAddSynthesizedFormats(), IntIsFormatAvailable(), IntSynthesizeBitmap(), NtUserGetClipboardData(), and UserEnumClipboardFormats().

IntGetWinStaForCbAccess()

static PWINSTATION_OBJECT FASTCALL IntGetWinStaForCbAccess ( VOID  )

static

Definition at line 21 of file clipboard.c.

{
    HWINSTA hWinSta;
    PWINSTATION_OBJECT pWinStaObj;
    NTSTATUS Status;
 
    hWinSta = UserGetProcessWindowStation();
    Status = IntValidateWindowStationHandle(hWinSta, UserMode, WINSTA_ACCESSCLIPBOARD, &pWinStaObj, 0);
    if (!NT_SUCCESS(Status))
    {
        ERR("Cannot open winsta\n");
        SetLastNtError(Status);
        return NULL;
    }
 
    return pWinStaObj;
}

Referenced by NtUserChangeClipboardChain(), NtUserCountClipboardFormats(), NtUserGetClipboardData(), NtUserGetClipboardOwner(), NtUserGetClipboardSequenceNumber(), NtUserGetClipboardViewer(), NtUserGetOpenClipboardWindow(), NtUserGetPriorityClipboardFormat(), NtUserIsClipboardFormatAvailable(), NtUserSetClipboardViewer(), UserClipboardFreeWindow(), UserClipboardRelease(), UserCloseClipboard(), UserEmptyClipboard(), UserEnumClipboardFormats(), UserOpenClipboard(), and UserSetClipboardData().

IntIsClipboardOpenByMe()

static BOOL FASTCALL IntIsClipboardOpenByMe ( PWINSTATION_OBJECT  pWinSta )

static

Definition at line 136 of file clipboard.c.

{
    /* Check if the current thread has opened the clipboard */
    return (pWinSta->ptiClipLock &&
            pWinSta->ptiClipLock == PsGetCurrentThreadWin32Thread());
}

Referenced by NtUserGetClipboardData(), UserCloseClipboard(), UserEmptyClipboard(), UserEnumClipboardFormats(), and UserOpenClipboard().

IntIsFormatAvailable()

static BOOL FASTCALL IntIsFormatAvailable ( PWINSTATION_OBJECT  pWinStaObj, UINT  fmt  )

static

Definition at line 55 of file clipboard.c.

{
    return IntGetFormatElement(pWinStaObj, fmt) != NULL;
}

Referenced by IntAddSynthesizedFormats(), NtUserGetPriorityClipboardFormat(), and NtUserIsClipboardFormatAvailable().

IntSynthesizeBitmap()

static VOID WINAPI IntSynthesizeBitmap ( PWINSTATION_OBJECT  pWinStaObj, PCLIP  pBmEl  )

static

Definition at line 230 of file clipboard.c.

{
    HDC hdc = NULL;
    PBITMAPINFO pBmi, pConvertedBmi = NULL;
    HBITMAP hBm = NULL;
    PCLIPBOARDDATA pMemObj;
    PCLIP pDibEl;
    ULONG Offset;
 
    TRACE("IntSynthesizeBitmap(%p, %p)\n", pWinStaObj, pBmEl);
 
    pDibEl = IntGetFormatElement(pWinStaObj, CF_DIB);
    ASSERT(pDibEl && !IS_DATA_SYNTHESIZED(pDibEl));
    if (!pDibEl->fGlobalHandle)
        return;
 
    pMemObj = (PCLIPBOARDDATA)UserGetObject(gHandleTable, pDibEl->hData, TYPE_CLIPDATA);
    if (!pMemObj)
        return;
 
    pBmi = (BITMAPINFO*)pMemObj->Data;
 
    if (pMemObj->cbData < sizeof(DWORD) && pMemObj->cbData < pBmi->bmiHeader.biSize)
        goto cleanup;
 
    pConvertedBmi = DIB_ConvertBitmapInfo(pBmi, DIB_RGB_COLORS);
    if (!pConvertedBmi)
        goto cleanup;
 
    Offset = DIB_BitmapInfoSize(pBmi, DIB_RGB_COLORS);
 
    hdc = UserGetDCEx(NULL, NULL, DCX_USESTYLE);
    if (!hdc)
        goto cleanup;
 
    hBm = GreCreateDIBitmapInternal(hdc,
                                    pConvertedBmi->bmiHeader.biWidth,
                                    pConvertedBmi->bmiHeader.biHeight,
                                    CBM_INIT,
                                    pMemObj->Data + Offset,
                                    pConvertedBmi,
                                    DIB_RGB_COLORS,
                                    0,
                                    pMemObj->cbData - Offset,
                                    0);
 
    if (hBm)
    {
        GreSetObjectOwner(hBm, GDI_OBJ_HMGR_PUBLIC);
        pBmEl->hData = hBm;
    }
 
cleanup:
    if (hdc)
        UserReleaseDC(NULL, hdc, FALSE);
 
    if (pConvertedBmi)
        DIB_FreeConvertedBitmapInfo(pConvertedBmi, pBmi, -1);
}

Referenced by NtUserGetClipboardData().

IntSynthesizeDib()

static VOID NTAPI IntSynthesizeDib ( PWINSTATION_OBJECT  pWinStaObj, HBITMAP  hbm  )

static

Definition at line 144 of file clipboard.c.

{
    HDC hdc;
    ULONG cjInfoSize, cjDataSize;
    PCLIPBOARDDATA pClipboardData;
    HANDLE hMem;
    INT iResult;
    struct
    {
        BITMAPINFOHEADER bmih;
        RGBQUAD rgbColors[256];
    } bmiBuffer;
    PBITMAPINFO pbmi = (PBITMAPINFO)&bmiBuffer;
 
    /* Get the display DC */
    hdc = UserGetDCEx(NULL, NULL, DCX_USESTYLE);
    if (!hdc)
    {
        return;
    }
 
    /* Get information about the bitmap format */
    memset(&bmiBuffer, 0, sizeof(bmiBuffer));
    pbmi->bmiHeader.biSize = sizeof(bmiBuffer.bmih);
    iResult = GreGetDIBitsInternal(hdc,
                                   hbm,
                                   0,
                                   0,
                                   NULL,
                                   pbmi,
                                   DIB_RGB_COLORS,
                                   0,
                                   sizeof(bmiBuffer));
    if (iResult == 0)
    {
       goto cleanup;
    }
 
    /* Get the size for a full BITMAPINFO */
    cjInfoSize = DIB_BitmapInfoSize(pbmi, DIB_RGB_COLORS);
 
    /* Calculate the size of the clipboard data, which is a packed DIB */
    cjDataSize = cjInfoSize + pbmi->bmiHeader.biSizeImage;
 
    /* Create the clipboard data */
    pClipboardData = (PCLIPBOARDDATA)UserCreateObject(gHandleTable,
                                                      NULL,
                                                      NULL,
                                                      &hMem,
                                                      TYPE_CLIPDATA,
                                                      sizeof(CLIPBOARDDATA) + cjDataSize);
    if (!pClipboardData)
    {
        goto cleanup;
    }
 
    /* Set the data size */
    pClipboardData->cbData = cjDataSize;
 
    /* Copy the BITMAPINFOHEADER */
    memcpy(pClipboardData->Data, pbmi, sizeof(BITMAPINFOHEADER));
 
    /* Get the bitmap bits and the color table */
    iResult = GreGetDIBitsInternal(hdc,
                                   hbm,
                                   0,
                                   abs(pbmi->bmiHeader.biHeight),
                                   (LPBYTE)pClipboardData->Data + cjInfoSize,
                                   (LPBITMAPINFO)pClipboardData->Data,
                                   DIB_RGB_COLORS,
                                   pbmi->bmiHeader.biSizeImage,
                                   cjInfoSize);
 
    /* Add the clipboard data */
    IntAddFormatedData(pWinStaObj, CF_DIB, hMem, TRUE, TRUE);
 
    /* Release the extra reference (UserCreateObject added 2 references) */
    UserDereferenceObject(pClipboardData);
 
cleanup:
    UserReleaseDC(NULL, hdc, FALSE);
}

Referenced by IntAddSynthesizedFormats().

NtUserChangeClipboardChain()

BOOL APIENTRY NtUserChangeClipboardChain	(	HWND	hWndRemove,
		HWND	hWndNewNext
	)

Definition at line 624 of file clipboard.c.

{
    BOOL bRet = FALSE;
    PWND pWindowRemove;
    PWINSTATION_OBJECT pWinStaObj;
 
    TRACE("NtUserChangeClipboardChain(%p, %p)\n", hWndRemove, hWndNewNext);
 
    UserEnterExclusive();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    pWindowRemove = UserGetWindowObject(hWndRemove);
 
    if (pWindowRemove && pWinStaObj->spwndClipViewer)
    {
        if (pWindowRemove == pWinStaObj->spwndClipViewer)
            pWinStaObj->spwndClipViewer = UserGetWindowObject(hWndNewNext);
 
        if (pWinStaObj->spwndClipViewer)
            bRet = (BOOL)co_IntSendMessage(UserHMGetHandle(pWinStaObj->spwndClipViewer), WM_CHANGECBCHAIN, (WPARAM)hWndRemove, (LPARAM)hWndNewNext);
    }
 
    ObDereferenceObject(pWinStaObj);
 
cleanup:
    UserLeave();
 
    return bRet;
}

Referenced by ChangeClipboardChain().

NtUserCloseClipboard()

BOOL APIENTRY NtUserCloseClipboard

(

VOID

)

Definition at line 589 of file clipboard.c.

{
    BOOL bRet;
 
    UserEnterExclusive();
    bRet = UserCloseClipboard();
    UserLeave();
 
    return bRet;
}

Referenced by CloseClipboard().

NtUserConvertMemHandle()

HANDLE APIENTRY NtUserConvertMemHandle	(	PVOID	pData,
		DWORD	cbData
	)

Definition at line 1187 of file clipboard.c.

{
    HANDLE hMem = NULL;
    PCLIPBOARDDATA pMemObj;
 
    UserEnterExclusive();
 
    /* Create Clipboard data object */
    pMemObj = UserCreateObject(gHandleTable, NULL, NULL, &hMem, TYPE_CLIPDATA, sizeof(CLIPBOARDDATA) + cbData);
    if (!pMemObj)
        goto cleanup;
 
    pMemObj->cbData = cbData;
 
    /* Copy data */
    _SEH2_TRY
    {
        ProbeForRead(pData, cbData, 1);
        memcpy(pMemObj->Data, pData, cbData);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        pMemObj = NULL;
    }
    _SEH2_END;
 
    /* Release the extra reference (UserCreateObject added 2 references) */
    UserDereferenceObject(pMemObj);
 
    /* If we failed to copy data, remove handle */
    if (!pMemObj)
    {
        UserDeleteObject(hMem, TYPE_CLIPDATA);
        hMem = NULL;
    }
 
cleanup:
    UserLeave();
 
    return hMem;
}

Referenced by GetClipboardData(), and SetClipboardData().

NtUserCountClipboardFormats()

DWORD APIENTRY NtUserCountClipboardFormats

(

VOID

)

Definition at line 658 of file clipboard.c.

{
    DWORD cFormats = 0;
    PWINSTATION_OBJECT pWinStaObj;
 
    UserEnterShared();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    cFormats = pWinStaObj->cNumClipFormats;
 
    ObDereferenceObject(pWinStaObj);
 
cleanup:
    UserLeave();
 
    return cFormats;
}

Referenced by CountClipboardFormats(), and START_TEST().

NtUserCreateLocalMemHandle()

NTSTATUS APIENTRY NtUserCreateLocalMemHandle	(	HANDLE	hMem,
		PVOID	pData,
		DWORD	cbData,
		DWORD *	pcbData
	)

Definition at line 1232 of file clipboard.c.

{
    PCLIPBOARDDATA pMemObj;
    NTSTATUS Status = STATUS_SUCCESS;
 
    UserEnterShared();
 
    /* Get Clipboard data object */
    pMemObj = (PCLIPBOARDDATA)UserGetObject(gHandleTable, hMem, TYPE_CLIPDATA);
    if (!pMemObj)
    {
        Status = STATUS_INVALID_HANDLE;
        goto cleanup;
    }
 
    /* Don't overrun */
    if (cbData > pMemObj->cbData)
        cbData = pMemObj->cbData;
 
    /* Copy data to usermode */
    _SEH2_TRY
    {
        if (pcbData)
        {
            ProbeForWrite(pcbData, sizeof(*pcbData), 1);
            *pcbData = pMemObj->cbData;
        }
 
        ProbeForWrite(pData, cbData, 1);
        memcpy(pData, pMemObj->Data, cbData);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
cleanup:
    UserLeave();
 
    return Status;
}

Referenced by GetClipboardData().

NtUserEmptyClipboard()

BOOL APIENTRY NtUserEmptyClipboard

(

VOID

)

Definition at line 722 of file clipboard.c.

{
    BOOL bRet;
 
    TRACE("NtUserEmptyClipboard()\n");
 
    UserEnterExclusive();
    bRet = UserEmptyClipboard();
    UserLeave();
 
    return bRet;
}

Referenced by EmptyClipboard().

NtUserGetClipboardData()

HANDLE APIENTRY NtUserGetClipboardData	(	UINT	fmt,
		PGETCLIPBDATA	pgcd
	)

Definition at line 897 of file clipboard.c.

{
    HANDLE hRet = NULL;
    PCLIP pElement;
    PWINSTATION_OBJECT pWinStaObj;
    UINT uSourceFmt = fmt;
 
    TRACE("NtUserGetClipboardData(%x, %p)\n", fmt, pgcd);
 
    UserEnterShared();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    /* Check if the clipboard has been opened */
    if (!IntIsClipboardOpenByMe(pWinStaObj))
    {
        EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
        goto cleanup;
    }
 
    pElement = IntGetFormatElement(pWinStaObj, fmt);
    if (!pElement)
        goto cleanup;
 
    if (IS_DATA_SYNTHESIZED(pElement))
    {
        /* Note: Data is synthesized in usermode */
        /* TODO: Add more formats */
        switch (fmt)
        {
            case CF_UNICODETEXT:
            case CF_TEXT:
            case CF_OEMTEXT:
                uSourceFmt = CF_UNICODETEXT;
                pElement = IntGetFormatElement(pWinStaObj, uSourceFmt);
                if (IS_DATA_SYNTHESIZED(pElement))
                {
                    uSourceFmt = CF_TEXT;
                    pElement = IntGetFormatElement(pWinStaObj, uSourceFmt);
                }
                if (IS_DATA_SYNTHESIZED(pElement))
                {
                    uSourceFmt = CF_OEMTEXT;
                    pElement = IntGetFormatElement(pWinStaObj, uSourceFmt);
                }
                break;
 
            case CF_BITMAP:
                IntSynthesizeBitmap(pWinStaObj, pElement);
                break;
 
            case CF_METAFILEPICT:
                uSourceFmt = CF_ENHMETAFILE;
                pElement = IntGetFormatElement(pWinStaObj, uSourceFmt);
                break;
 
            case CF_ENHMETAFILE:
                uSourceFmt = CF_METAFILEPICT;
                pElement = IntGetFormatElement(pWinStaObj, uSourceFmt);
                break;
 
            default:
                ASSERT(FALSE);
        }
    }
 
    if (pElement && IS_DATA_DELAYED(pElement) && pWinStaObj->spwndClipOwner)
    {
        /* Send WM_RENDERFORMAT message */
        pWinStaObj->fInDelayedRendering = TRUE;
        co_IntSendMessage(UserHMGetHandle(pWinStaObj->spwndClipOwner), WM_RENDERFORMAT, (WPARAM)uSourceFmt, 0);
        pWinStaObj->fInDelayedRendering = FALSE;
 
        /* Data should be in clipboard now */
        pElement = IntGetFormatElement(pWinStaObj, uSourceFmt);
    }
 
    if (!pElement || IS_DATA_DELAYED(pElement))
        goto cleanup;
 
    _SEH2_TRY
    {
        ProbeForWrite(pgcd, sizeof(*pgcd), 1);
        pgcd->uFmtRet = pElement->fmt;
        pgcd->fGlobalHandle = pElement->fGlobalHandle;
 
        /* Text and bitmap needs more data */
        if (fmt == CF_TEXT)
        {
            PCLIP pLocaleEl;
 
            pLocaleEl = IntGetFormatElement(pWinStaObj, CF_LOCALE);
            if (pLocaleEl && !IS_DATA_DELAYED(pLocaleEl))
                pgcd->hLocale = pLocaleEl->hData;
        }
        else if (fmt == CF_BITMAP)
        {
            PCLIP pPaletteEl;
 
            pPaletteEl = IntGetFormatElement(pWinStaObj, CF_PALETTE);
            if (pPaletteEl && !IS_DATA_DELAYED(pPaletteEl))
                pgcd->hPalette = pPaletteEl->hData;
        }
 
        hRet = pElement->hData;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
cleanup:
    if (pWinStaObj)
        ObDereferenceObject(pWinStaObj);
 
    UserLeave();
 
    TRACE("NtUserGetClipboardData returns %p\n", hRet);
 
    return hRet;
}

Referenced by GetClipboardData().

NtUserGetClipboardFormatName()

INT APIENTRY NtUserGetClipboardFormatName	(	UINT	fmt,
		LPWSTR	lpszFormatName,
		INT	cchMaxCount
	)

Definition at line 736 of file clipboard.c.

{
    INT iRet = 0;
 
    UserEnterShared();
 
    /* If the format is built-in we fail */
    if (fmt < 0xc000 || fmt > 0xffff)
    {
        /* Registetrated formats are >= 0xc000 */
        goto cleanup;
    }
 
    if (cchMaxCount < 1 || !lpszFormatName)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        goto cleanup;
    }
 
    _SEH2_TRY
    {
        ProbeForWrite(lpszFormatName, cchMaxCount * sizeof(WCHAR), 1);
 
        iRet = IntGetAtomName((RTL_ATOM)fmt,
                              lpszFormatName,
                              cchMaxCount * sizeof(WCHAR));
        iRet /= sizeof(WCHAR);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
cleanup:
    UserLeave();
 
    return iRet;
}

Referenced by GetClipboardFormatNameA(), and GetClipboardFormatNameW().

NtUserGetClipboardOwner()

HWND APIENTRY NtUserGetClipboardOwner

(

VOID

)

Definition at line 777 of file clipboard.c.

{
    HWND hWnd = NULL;
    PWINSTATION_OBJECT pWinStaObj;
 
    UserEnterShared();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    if (pWinStaObj->spwndClipOwner)
        hWnd = UserHMGetHandle(pWinStaObj->spwndClipOwner);
 
    ObDereferenceObject(pWinStaObj);
 
cleanup:
    UserLeave();
 
    return hWnd;
}

Referenced by GetClipboardOwner().

NtUserGetClipboardSequenceNumber()

DWORD APIENTRY NtUserGetClipboardSequenceNumber

(

VOID

)

Definition at line 1164 of file clipboard.c.

{
    DWORD dwRet = 0;
    PWINSTATION_OBJECT pWinStaObj;
 
    UserEnterShared();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    /* Get windowstation sequence number */
    dwRet = (DWORD)pWinStaObj->iClipSequenceNumber;
 
    ObDereferenceObject(pWinStaObj);
 
cleanup:
    UserLeave();
 
    return dwRet;
}

Referenced by GetClipboardSequenceNumber().

NtUserGetClipboardViewer()

HWND APIENTRY NtUserGetClipboardViewer

(

VOID

)

Definition at line 800 of file clipboard.c.

{
    HWND hWnd = NULL;
    PWINSTATION_OBJECT pWinStaObj;
 
    UserEnterShared();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    if (pWinStaObj->spwndClipViewer)
        hWnd = UserHMGetHandle(pWinStaObj->spwndClipViewer);
 
    ObDereferenceObject(pWinStaObj);
 
cleanup:
    UserLeave();
 
    return hWnd;
}

Referenced by GetClipboardViewer().

NtUserGetOpenClipboardWindow()

HWND APIENTRY NtUserGetOpenClipboardWindow

(

VOID

)

Definition at line 601 of file clipboard.c.

{
    HWND hWnd = NULL;
    PWINSTATION_OBJECT pWinStaObj;
 
    UserEnterShared();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    if (pWinStaObj->spwndClipOpen)
        hWnd = UserHMGetHandle(pWinStaObj->spwndClipOpen);
 
    ObDereferenceObject(pWinStaObj);
 
cleanup:
    UserLeave();
 
    return hWnd;
}

Referenced by GetOpenClipboardWindow().

NtUserGetPriorityClipboardFormat()

INT APIENTRY NtUserGetPriorityClipboardFormat	(	UINT *	paFormatPriorityList,
		INT	cFormats
	)

Definition at line 823 of file clipboard.c.

{
    INT i, iRet = 0;
    PWINSTATION_OBJECT pWinStaObj;
 
    UserEnterShared();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    if (pWinStaObj->pClipBase == NULL)
    {
        iRet = 0;
    }
    else
    {
        _SEH2_TRY
        {
            ProbeForRead(paFormatPriorityList, cFormats * sizeof(UINT), sizeof(UINT));
 
            iRet = -1;
 
            for (i = 0; i < cFormats; ++i)
            {
                if (IntIsFormatAvailable(pWinStaObj, paFormatPriorityList[i]))
                {
                    iRet = paFormatPriorityList[i];
                    break;
                }
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            SetLastNtError(_SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    ObDereferenceObject(pWinStaObj);
 
cleanup:
    UserLeave();
 
    return iRet;
 
}

Referenced by GetPriorityClipboardFormat().

NtUserIsClipboardFormatAvailable()

BOOL APIENTRY NtUserIsClipboardFormatAvailable

(

UINT

fmt

)

Definition at line 872 of file clipboard.c.

{
    BOOL bRet = FALSE;
    PWINSTATION_OBJECT pWinStaObj;
 
    TRACE("NtUserIsClipboardFormatAvailable(%x)\n", fmt);
 
    UserEnterShared();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    if (IntIsFormatAvailable(pWinStaObj, fmt))
        bRet = TRUE;
 
    ObDereferenceObject(pWinStaObj);
 
cleanup:
    UserLeave();
 
    return bRet;
}

Referenced by IsClipboardFormatAvailable().

NtUserOpenClipboard()

BOOL APIENTRY NtUserOpenClipboard	(	HWND	hWnd,
		DWORD	Unknown1
	)

Definition at line 533 of file clipboard.c.

{
    BOOL bRet;
 
    UserEnterExclusive();
    bRet = UserOpenClipboard(hWnd);
    UserLeave();
 
    return bRet;
}

Referenced by OpenClipboard().

NtUserSetClipboardData()

HANDLE APIENTRY NtUserSetClipboardData	(	UINT	fmt,
		HANDLE	hData,
		PSETCLIPBDATA	pUnsafeScd
	)

Definition at line 1084 of file clipboard.c.

{
    SETCLIPBDATA scd;
    HANDLE hRet;
 
    TRACE("NtUserSetClipboardData(%x %p %p)\n", fmt, hData, pUnsafeScd);
 
    _SEH2_TRY
    {
        ProbeForRead(pUnsafeScd, sizeof(*pUnsafeScd), 1);
        RtlCopyMemory(&scd, pUnsafeScd, sizeof(scd));
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
        _SEH2_YIELD(return NULL;)
    }
    _SEH2_END
 
    UserEnterExclusive();
 
    /* Call internal function */
    hRet = UserSetClipboardData(fmt, hData, &scd);
 
    UserLeave();
 
    return hRet;
}

Referenced by GetClipboardData(), and SetClipboardData().

NtUserSetClipboardViewer()

HWND APIENTRY NtUserSetClipboardViewer

(

HWND

hWndNewViewer

)

Definition at line 1114 of file clipboard.c.

{
    HWND hWndNext = NULL;
    PWINSTATION_OBJECT pWinStaObj;
    PWND pWindow;
 
    UserEnterExclusive();
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    pWindow = UserGetWindowObject(hWndNewViewer);
    if (!pWindow)
    {
        EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
        goto cleanup;
    }
 
    /* Return previous viewer. New viever window should
       send messages to rest of the chain */
    if (pWinStaObj->spwndClipViewer)
        hWndNext = UserHMGetHandle(pWinStaObj->spwndClipViewer);
 
    /* Set new viewer window */
    pWinStaObj->spwndClipViewer = pWindow;
 
    /* Notify viewer windows in chain */
    pWinStaObj->fClipboardChanged = FALSE;
    if (pWinStaObj->spwndClipViewer)
    {
        TRACE("Clipboard: sending WM_DRAWCLIPBOARD to %p\n", UserHMGetHandle(pWinStaObj->spwndClipViewer));
        // For 32-bit applications this message is sent as a notification
        co_IntSendMessageNoWait(UserHMGetHandle(pWinStaObj->spwndClipViewer), WM_DRAWCLIPBOARD, 0, 0);
    }
 
cleanup:
    if (pWinStaObj)
        ObDereferenceObject(pWinStaObj);
 
    UserLeave();
 
    return hWndNext;
}

Referenced by SetClipboardViewer().

UserClipboardFreeWindow()

VOID FASTCALL UserClipboardFreeWindow

(

PWND

pWindow

)

Definition at line 414 of file clipboard.c.

{
    PWINSTATION_OBJECT pWinStaObj;
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        return;
 
    if (pWindow == pWinStaObj->spwndClipOwner)
    {
        /* The owner window was destroyed */
        pWinStaObj->spwndClipOwner = NULL;
    }
 
    /* Check if clipboard is not locked by this window, if yes, unlock it */
    if (pWindow == pWinStaObj->spwndClipOpen)
    {
        /* The window that opens the clipboard was destroyed */
        pWinStaObj->spwndClipOpen = NULL;
        pWinStaObj->ptiClipLock = NULL;
    }
    /* Remove window from window chain */
    if (pWindow == pWinStaObj->spwndClipViewer)
        pWinStaObj->spwndClipViewer = NULL;
 
    ObDereferenceObject(pWinStaObj);
}

Referenced by co_UserFreeWindow().

UserClipboardRelease()

VOID FASTCALL UserClipboardRelease

(

PWND

pWindow

)

Definition at line 374 of file clipboard.c.

{
    PWINSTATION_OBJECT pWinStaObj;
 
    if (!pWindow)
        return;
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        return;
 
    co_IntSendMessage(UserHMGetHandle(pWinStaObj->spwndClipOwner), WM_RENDERALLFORMATS, 0, 0);
 
    /* If the window being destroyed is the current clipboard owner... */
    if (pWindow == pWinStaObj->spwndClipOwner)
    {
        /* ... make it release the clipboard */
        pWinStaObj->spwndClipOwner = NULL;
    }
 
    if (pWinStaObj->fClipboardChanged)
    {
        /* Add synthesized formats - they are rendered later */
        IntAddSynthesizedFormats(pWinStaObj);
 
        /* Notify viewer windows in chain */
        pWinStaObj->fClipboardChanged = FALSE;
        if (pWinStaObj->spwndClipViewer)
        {
            TRACE("Clipboard: sending WM_DRAWCLIPBOARD to %p\n", UserHMGetHandle(pWinStaObj->spwndClipViewer));
            // For 32-bit applications this message is sent as a notification
            co_IntSendMessageNoWait(UserHMGetHandle(pWinStaObj->spwndClipViewer), WM_DRAWCLIPBOARD, 0, 0);
        }
    }
 
    ObDereferenceObject(pWinStaObj);
}

Referenced by IntSendDestroyMsg().

UserCloseClipboard()

BOOL NTAPI UserCloseClipboard

(

VOID

)

Definition at line 545 of file clipboard.c.

{
    BOOL bRet = FALSE;
    PWINSTATION_OBJECT pWinStaObj;
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    /* Check if the clipboard has been opened */
    if (!IntIsClipboardOpenByMe(pWinStaObj))
    {
        EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
        goto cleanup;
    }
 
    /* Clipboard is no longer open */
    pWinStaObj->spwndClipOpen = NULL;
    pWinStaObj->ptiClipLock = NULL;
    bRet = TRUE;
 
    if (pWinStaObj->fClipboardChanged)
    {
        /* Add synthesized formats - they are rendered later */
        IntAddSynthesizedFormats(pWinStaObj);
 
        /* Notify viewer windows in chain */
        pWinStaObj->fClipboardChanged = FALSE;
        if (pWinStaObj->spwndClipViewer)
        {
            TRACE("Clipboard: sending WM_DRAWCLIPBOARD to %p\n", UserHMGetHandle(pWinStaObj->spwndClipViewer));
            // For 32-bit applications this message is sent as a notification
            co_IntSendMessageNoWait(UserHMGetHandle(pWinStaObj->spwndClipViewer), WM_DRAWCLIPBOARD, 0, 0);
        }
    }
 
cleanup:
    if (pWinStaObj)
        ObDereferenceObject(pWinStaObj);
 
    return bRet;
}

Referenced by DefWndScreenshot(), ExitThreadCallback(), NtUserCloseClipboard(), and SnapWindow().

UserEmptyClipboard()

BOOL NTAPI UserEmptyClipboard

(

VOID

)

Definition at line 680 of file clipboard.c.

{
    BOOL bRet = FALSE;
    PWINSTATION_OBJECT pWinStaObj;
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        return FALSE;
 
    /* Check if the clipboard has been opened */
    if (!IntIsClipboardOpenByMe(pWinStaObj))
    {
        EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
        goto cleanup;
    }
 
    UserEmptyClipboardData(pWinStaObj);
 
    if (pWinStaObj->spwndClipOwner)
    {
        TRACE("Clipboard: WM_DESTROYCLIPBOARD to %p\n", UserHMGetHandle(pWinStaObj->spwndClipOwner));
        // For 32-bit applications this message is sent as a notification
        co_IntSendMessage(UserHMGetHandle(pWinStaObj->spwndClipOwner), WM_DESTROYCLIPBOARD, 0, 0);
    }
 
    pWinStaObj->spwndClipOwner = pWinStaObj->spwndClipOpen;
 
    pWinStaObj->iClipSerialNumber++;
    pWinStaObj->iClipSequenceNumber++;
    pWinStaObj->fClipboardChanged = TRUE;
    pWinStaObj->fInDelayedRendering = FALSE;
 
    bRet = TRUE;
 
cleanup:
    if (pWinStaObj)
        ObDereferenceObject(pWinStaObj);
 
    return bRet;
}

Referenced by DefWndScreenshot(), NtUserEmptyClipboard(), and SnapWindow().

UserEmptyClipboardData()

VOID NTAPI UserEmptyClipboardData

(

PWINSTATION_OBJECT

pWinSta

)

Definition at line 354 of file clipboard.c.

{
    DWORD i;
    PCLIP pElement;
 
    for (i = 0; i < pWinSta->cNumClipFormats; ++i)
    {
        pElement = &pWinSta->pClipBase[i];
        IntFreeElementData(pElement);
    }
 
    if (pWinSta->pClipBase)
        ExFreePoolWithTag(pWinSta->pClipBase, USERTAG_CLIPBOARD);
 
    pWinSta->pClipBase = NULL;
    pWinSta->cNumClipFormats = 0;
}

Referenced by IntWinStaObjectDelete(), and UserEmptyClipboard().

UserEnumClipboardFormats()

UINT APIENTRY UserEnumClipboardFormats

(

UINT

fmt

)

Definition at line 443 of file clipboard.c.

{
    UINT Ret = 0;
    PCLIP pElement;
    PWINSTATION_OBJECT pWinStaObj;
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    /* Check if the clipboard has been opened */
    if (!IntIsClipboardOpenByMe(pWinStaObj))
    {
        EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
        goto cleanup;
    }
 
    if (fmt == 0)
    {
        /* Return first format */
        if (pWinStaObj->pClipBase)
            Ret = pWinStaObj->pClipBase[0].fmt;
    }
    else
    {
        /* Return next format */
        pElement = IntGetFormatElement(pWinStaObj, fmt);
        if (pElement != NULL)
        {
            ++pElement;
            if (pElement < &pWinStaObj->pClipBase[pWinStaObj->cNumClipFormats])
            {
                Ret = pElement->fmt;
            }
        }
    }
 
cleanup:
    if (pWinStaObj)
        ObDereferenceObject(pWinStaObj);
 
    return Ret;
}

Referenced by NtUserCallOneParam().

UserOpenClipboard()

BOOL NTAPI UserOpenClipboard

(

HWND

hWnd

)

Definition at line 488 of file clipboard.c.

{
    PWND pWindow = NULL;
    BOOL bRet = FALSE;
    PWINSTATION_OBJECT pWinStaObj = NULL;
 
    if (hWnd)
    {
        pWindow = UserGetWindowObject(hWnd);
        if (!pWindow)
            goto cleanup;
    }
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    /* Check if we already opened the clipboard */
    if ((pWindow == pWinStaObj->spwndClipOpen) && IntIsClipboardOpenByMe(pWinStaObj))
    {
        bRet = TRUE;
        goto cleanup;
    }
 
    /* If the clipboard was already opened by somebody else, bail out */
    if ((pWindow != pWinStaObj->spwndClipOpen) && pWinStaObj->ptiClipLock)
    {
        ERR("Access denied!\n");
        EngSetLastError(ERROR_ACCESS_DENIED);
        goto cleanup;
    }
 
    /* Open the clipboard */
    pWinStaObj->spwndClipOpen = pWindow;
    pWinStaObj->ptiClipLock = PsGetCurrentThreadWin32Thread();
    bRet = TRUE;
 
cleanup:
    if (pWinStaObj)
        ObDereferenceObject(pWinStaObj);
 
    return bRet;
}

Referenced by DefWndScreenshot(), NtUserOpenClipboard(), and SnapWindow().

UserSetClipboardData()

HANDLE NTAPI UserSetClipboardData	(	UINT	fmt,
		HANDLE	hData,
		PSETCLIPBDATA	scd
	)

Definition at line 1023 of file clipboard.c.

{
    HANDLE hRet = NULL;
    PWINSTATION_OBJECT pWinStaObj;
 
    pWinStaObj = IntGetWinStaForCbAccess();
    if (!pWinStaObj)
        goto cleanup;
 
    if (!fmt || !pWinStaObj->ptiClipLock)
    {
        ERR("Access denied!\n");
        EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN);
        goto cleanup;
    }
 
    if (scd->fIncSerialNumber)
        pWinStaObj->iClipSerialNumber++;
 
    /* Is it a delayed rendering? */
    if (hData)
    {
        /* Is it a bitmap? */
        if (fmt == CF_BITMAP)
        {
            /* Make bitmap public */
            GreSetObjectOwner(hData, GDI_OBJ_HMGR_PUBLIC);
        }
 
        /* Save data in the clipboard */
        IntAddFormatedData(pWinStaObj, fmt, hData, scd->fGlobalHandle, FALSE);
        TRACE("hData stored\n");
 
        /* If the serial number was increased, increase also the sequence number */
        if (scd->fIncSerialNumber)
            pWinStaObj->iClipSequenceNumber++;
 
        pWinStaObj->fClipboardChanged = TRUE;
 
        /* Note: Synthesized formats are added in NtUserCloseClipboard */
    }
    else
    {
        /* This is a delayed rendering */
        IntAddFormatedData(pWinStaObj, fmt, DATA_DELAYED, FALSE, FALSE);
        TRACE("SetClipboardData delayed format: %u\n", fmt);
    }
 
    /* Return hData on success */
    hRet = hData;
 
cleanup:
    TRACE("NtUserSetClipboardData returns: %p\n", hRet);
 
    if (pWinStaObj)
        ObDereferenceObject(pWinStaObj);
 
    return hRet;
}

Referenced by DefWndScreenshot(), NtUserSetClipboardData(), and SnapWindow().