cliputils.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
LRESULT	SendClipboardOwnerMessage (IN BOOL bUnicode, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
void	RetrieveClipboardFormatName (HINSTANCE hInstance, UINT uFormat, BOOL Unicode, PVOID lpszFormat, UINT cch)
void	DeleteClipboardContent (void)
UINT	GetAutomaticClipboardFormat (void)
BOOL	IsClipboardFormatSupported (UINT uFormat)
SIZE_T	GetLineExtentW (IN LPCWSTR lpText, OUT LPCWSTR *lpNextLine)
SIZE_T	GetLineExtentA (IN LPCSTR lpText, OUT LPCSTR *lpNextLine)
BOOL	GetClipboardDataDimensions (UINT uFormat, PRECT pRc)

Function Documentation

DeleteClipboardContent()

void DeleteClipboardContent

(

void

)

Definition at line 134 of file cliputils.c.

{
    if (!OpenClipboard(Globals.hMainWnd))
    {
        ShowLastWin32Error(Globals.hMainWnd);
        return;
    }
 
    if (!EmptyClipboard())
    {
        ShowLastWin32Error(Globals.hMainWnd);
    }
 
    CloseClipboard();
}

Referenced by MainWndProc(), and OnCommand().

GetAutomaticClipboardFormat()

UINT GetAutomaticClipboardFormat

(

void

)

Definition at line 150 of file cliputils.c.

{
    static UINT uFormatList[] =
    {
        CF_OWNERDISPLAY,
        CF_UNICODETEXT,
        CF_TEXT,
        CF_OEMTEXT,
        CF_ENHMETAFILE,
        CF_METAFILEPICT,
        CF_DIBV5,
        CF_DIB,
        CF_BITMAP,
        CF_DSPTEXT,
        CF_DSPBITMAP,
        CF_DSPMETAFILEPICT,
        CF_DSPENHMETAFILE,
        CF_PALETTE,
        CF_HDROP
    };
 
    return GetPriorityClipboardFormat(uFormatList, ARRAYSIZE(uFormatList));
}

Referenced by SetDisplayFormat().

GetClipboardDataDimensions()

BOOL GetClipboardDataDimensions	(	UINT	uFormat,
		PRECT	pRc
	)

Definition at line 249 of file cliputils.c.

{
    SetRectEmpty(pRc);
 
    if (!OpenClipboard(Globals.hMainWnd))
    {
        return FALSE;
    }
 
    switch (uFormat)
    {
        case CF_DSPBITMAP:
        case CF_BITMAP:
        {
            HBITMAP hBitmap;
            BITMAP bmp;
 
            hBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
            GetObjectW(hBitmap, sizeof(bmp), &bmp);
            SetRect(pRc, 0, 0, bmp.bmWidth, bmp.bmHeight);
            break;
        }
 
        case CF_DIB:
        case CF_DIBV5:
        {
            HGLOBAL hGlobal;
            LPBITMAPINFOHEADER lpInfoHeader;
 
            hGlobal = GetClipboardData(uFormat);
            if (!hGlobal)
                break;
 
            lpInfoHeader = GlobalLock(hGlobal);
            if (!lpInfoHeader)
                break;
 
            if (lpInfoHeader->biSize == sizeof(BITMAPCOREHEADER))
            {
                LPBITMAPCOREHEADER lpCoreHeader = (LPBITMAPCOREHEADER)lpInfoHeader;
                SetRect(pRc, 0, 0,
                        lpCoreHeader->bcWidth,
                        lpCoreHeader->bcHeight);
            }
            else if ((lpInfoHeader->biSize == sizeof(BITMAPINFOHEADER)) ||
                     (lpInfoHeader->biSize == sizeof(BITMAPV4HEADER))   ||
                     (lpInfoHeader->biSize == sizeof(BITMAPV5HEADER)))
            {
                SetRect(pRc, 0, 0,
                        lpInfoHeader->biWidth,
                        /* NOTE: biHeight < 0 for bottom-up DIBs, or > 0 for top-down DIBs */
                        (lpInfoHeader->biHeight > 0) ?  lpInfoHeader->biHeight
                                                     : -lpInfoHeader->biHeight);
            }
            else
            {
                /* Invalid format */
            }
 
            GlobalUnlock(hGlobal);
            break;
        }
 
        case CF_DSPTEXT:
        case CF_TEXT:
        case CF_OEMTEXT:
        case CF_UNICODETEXT:
        {
            HDC hDC;
            HGLOBAL hGlobal;
            PVOID lpText, ptr;
            DWORD dwSize;
            SIZE txtSize = {0, 0};
            SIZE_T lineSize;
 
            hGlobal = GetClipboardData(uFormat);
            if (!hGlobal)
                break;
 
            lpText = GlobalLock(hGlobal);
            if (!lpText)
                break;
 
            hDC = GetDC(Globals.hMainWnd);
 
            /* Find the size of the rectangle enclosing the text */
            for (;;)
            {
                if (uFormat == CF_UNICODETEXT)
                {
                    if (*(LPCWSTR)lpText == UNICODE_NULL)
                        break;
                    lineSize = GetLineExtentW(lpText, (LPCWSTR*)&ptr);
                    dwSize = GetTabbedTextExtentW(hDC, lpText, lineSize, 0, NULL);
                }
                else
                {
                    if (*(LPCSTR)lpText == ANSI_NULL)
                        break;
                    lineSize = GetLineExtentA(lpText, (LPCSTR*)&ptr);
                    dwSize = GetTabbedTextExtentA(hDC, lpText, lineSize, 0, NULL);
                }
                txtSize.cx = max(txtSize.cx, LOWORD(dwSize));
                txtSize.cy += HIWORD(dwSize);
                lpText = ptr;
            }
 
            ReleaseDC(Globals.hMainWnd, hDC);
 
            GlobalUnlock(hGlobal);
 
            SetRect(pRc, 0, 0, txtSize.cx, txtSize.cy);
            break;
        }
 
        default:
        {
            break;
        }
    }
 
    CloseClipboard();
 
    return TRUE;
}

Referenced by MainWndProc(), and SetDisplayFormat().

GetLineExtentA()

SIZE_T GetLineExtentA	(	IN LPCSTR	lpText,
		OUT LPCSTR *	lpNextLine
	)

Definition at line 225 of file cliputils.c.

{
    LPCSTR ptr;
 
    /* Find the next line of text (lpText is NULL-terminated) */
    /* For newlines, focus only on '\n', not on '\r' */
    ptr = strchr(lpText, '\n'); // Find the end of this line.
    if (ptr)
    {
        /* We have the end of this line, go to the next line (ignore the endline in the count) */
        *lpNextLine = ptr + 1;
    }
    else
    {
        /* This line was the last one, go pointing to the terminating NULL */
        ptr = lpText + strlen(lpText);
        *lpNextLine = ptr;
    }
 
    return (ptr - lpText);
}

Referenced by DrawTextFromClipboard(), and GetClipboardDataDimensions().

GetLineExtentW()

SIZE_T GetLineExtentW	(	IN LPCWSTR	lpText,
		OUT LPCWSTR *	lpNextLine
	)

Definition at line 200 of file cliputils.c.

{
    LPCWSTR ptr;
 
    /* Find the next line of text (lpText is NULL-terminated) */
    /* For newlines, focus only on '\n', not on '\r' */
    ptr = wcschr(lpText, L'\n'); // Find the end of this line.
    if (ptr)
    {
        /* We have the end of this line, go to the next line (ignore the endline in the count) */
        *lpNextLine = ptr + 1;
    }
    else
    {
        /* This line was the last one, go pointing to the terminating NULL */
        ptr = lpText + wcslen(lpText);
        *lpNextLine = ptr;
    }
 
    return (ptr - lpText);
}

Referenced by DrawTextFromClipboard(), and GetClipboardDataDimensions().

IsClipboardFormatSupported()

BOOL IsClipboardFormatSupported

(

UINT

uFormat

)

Definition at line 174 of file cliputils.c.

{
    switch (uFormat)
    {
        case CF_OWNERDISPLAY:
        case CF_UNICODETEXT:
        case CF_TEXT:
        case CF_OEMTEXT:
        case CF_BITMAP:
        case CF_ENHMETAFILE:
        case CF_METAFILEPICT:
        case CF_DIB:
        case CF_DIBV5:
        case CF_HDROP:
        {
            return TRUE;
        }
 
        default:
        {
            return FALSE;
        }
    }
}

Referenced by MainWndProc(), and UpdateDisplayMenu().

RetrieveClipboardFormatName()

void RetrieveClipboardFormatName	(	HINSTANCE	hInstance,
		UINT	uFormat,
		BOOL	Unicode,
		PVOID	lpszFormat,
		UINT	cch
	)

Definition at line 95 of file cliputils.c.

{
    ZeroMemory(lpszFormat, cch * (Unicode ? sizeof(WCHAR) : sizeof(CHAR)));
 
    /* Check for predefined clipboard format */
    if (GetPredefinedClipboardFormatName(hInstance, uFormat, Unicode, lpszFormat, cch) != 0)
        return;
 
    /* Check for owner-display format */
    if (uFormat == CF_OWNERDISPLAY)
    {
        if (SendClipboardOwnerMessage(Unicode, WM_ASKCBFORMATNAME,
                                      (WPARAM)cch, (LPARAM)lpszFormat) != 0)
        {
            if (Unicode)
                LoadStringW(hInstance, STRING_CF_UNKNOWN, (LPWSTR)lpszFormat, cch);
            else
                LoadStringA(hInstance, STRING_CF_UNKNOWN, (LPSTR)lpszFormat, cch);
        }
        return;
    }
 
    /* Fallback to registered clipboard format */
    if (Unicode)
    {
        if (!GetClipboardFormatNameW(uFormat, (LPWSTR)lpszFormat, cch))
            LoadStringW(hInstance, STRING_CF_UNKNOWN, (LPWSTR)lpszFormat, cch);
    }
    else
    {
        if (!GetClipboardFormatNameA(uFormat, (LPSTR)lpszFormat, cch))
            LoadStringA(hInstance, STRING_CF_UNKNOWN, (LPSTR)lpszFormat, cch);
    }
}

Referenced by UpdateDisplayMenu(), and WriteClipboardFile().

SendClipboardOwnerMessage()

LRESULT SendClipboardOwnerMessage	(	IN BOOL	bUnicode,
		IN UINT	uMsg,
		IN WPARAM	wParam,
		IN LPARAM	lParam
	)

Definition at line 12 of file cliputils.c.

{
    HWND hwndOwner;
 
    hwndOwner = GetClipboardOwner();
    if (!hwndOwner)
        return GetLastError();
 
    if (bUnicode)
        return SendMessageW(hwndOwner, uMsg, wParam, lParam);
    else
        return SendMessageA(hwndOwner, uMsg, wParam, lParam);
}

Referenced by MainWndProc(), OnPaint(), OnScroll(), and RetrieveClipboardFormatName().