\n\nThis page has been machine-translated from the original page.
\n
This time, I will summarize what I learned about Windows clipboard operations, its mechanisms, and how to inspect data, together with sample programs.
\n\nThe clipboard itself is a mechanism that allows applications to transfer data.
\nBy using clipboard functionality, users can exchange various kinds of data such as text, files, and images between different applications.
\nReference: About the Clipboard - Win32 apps | Microsoft Learn
\nThe Windows clipboard can store not only text, but also HTML, rich text, and objects in various formats.
\nBecause of this, for example, when you copy text from a browser or editor to another application, situations can arise where not only plain text but also various kinds of information such as text decoration and background color are copied.
\nMany commonly used data types are included in the standard Windows clipboard formats, but users can also register new clipboard formats.
\nIt also seems that applications can register what are called private formats.
\nReference: Clipboard Formats - Win32 apps | Microsoft Learn
\nThere are various kinds of system-predefined clipboard formats. For example, copied text appears to be automatically stored as CF_UNICODETEXT or CF_TEXT.
Reference: Standard Clipboard Formats (Winuser.h) - Win32 apps | Microsoft Learn
\nThere seem to be several available ways to implement clipboard operations, but regardless of which method you use, it appears that the starting point is ultimately to open the clipboard with OpenClipboard function (winuser.h).
\nAlso, because only one application in the system can open the clipboard at a time, if a particular application has opened the clipboard by using the OpenClipboard function, other applications cannot open the clipboard.
\nReference: Clipboard Operations - Win32 apps | Microsoft Learn
\nIn practice, when I ran the following program as a test, copy and paste operations in other applications such as browsers stopped working during the sleep period after the clipboard was acquired by the OpenClipboard function.
\n#include <windows.h>\n#include <iostream>\n#include <string>\n\nvoid OpenClipboardWithSleep() {\n\n if (!OpenClipboard(NULL)) {\n std::cerr << \"Failed to open clipboard.\" << std::endl;\n return;\n }\n\n // Sleep for demonstration purposes (not required in production)\n Sleep(10000);\n\n CloseClipboard();\n\n}\n\nint wmain() {\n\n OpenClipboardWithSleep();\n return 0;\n}Sample code related to clipboard operations is collected below.
\nReference: Using the Clipboard - Win32 apps | Microsoft Learn
\nWhen copying information to the clipboard, you first call the EmptyClipboard function (winuser.h) to empty the data in the clipboard and release handles, and then assign ownership of that clipboard to the window that currently has the clipboard open.
\nThe owner of the clipboard can be checked with the GetClipboardOwner function (winuser.h).
\nThe clipboard also has a mechanism called delayed rendering for improving performance, and you can use it by specifying NULL for the hMem parameter when saving data to the clipboard with the SetClipboardData function (winuser.h).
\nWhen delayed rendering is used, data in the requested format is copied from the clipboard owner not at copy time but when requested, such as during paste, which avoids the performance impact of unnecessary rendering.
\nAlthough delayed rendering can improve performance when copying large data and similar cases, it also seems to have disadvantages such as delayed application responsiveness during paste and being unable to copy data if the application has already exited.
\nReference: Clipboard Operations - Win32 apps | Microsoft Learn
\nReference: Windows clipboard performance varies depending on the hardware spec | Doslabo
\nTo study the Windows clipboard, I created some code and checked how it behaved.
\nBelow is a HEX dump of the result of reading data from the clipboard with the GetClipboardData function (winuser.h).
\nThe GetClipboardData function returns a handle to the clipboard object corresponding to the clipboard format value received as an argument. The list of clipboard formats currently available in the clipboard can be obtained on each call to the EnumClipboardFormats function (winuser.h), so the following loop checks the clipboard data in sequence. (If there is no more available clipboard data, the function returns 0.) The data inside the handle of the acquired clipboard object is read after locking the memory block with the GlobalLock function (winbase.h), as in the sample code in Paste Information from the Clipboard. When saving clipboard data with the SetClipboardData function (winuser.h), the destination global memory must have been allocated as movable memory by using the If the hMem parameter identifies a memory object, the object must have been allocated by using a function with the GMEM_MOVEABLE flag. Reference: c++ - Windows API - Clipboard - GlobalLock - use or not to use? - Stack Overflow Reference: Clipboard Writing information to the clipboard (copying) can also be achieved by implementing processing similar to the sample code below. Reference: Copy Information to the Clipboard In the above code, the clipboard is first opened and assigned to the current task with the OpenClipboard function called with NULL as its argument, then the clipboard is emptied with the EmptyClipboard function (winuser.h), after which ownership of the clipboard is assigned to the current window. In addition, as mentioned above, movable memory is allocated by the GlobalAlloc function (winbase.h) using the Finally, the handle into which the data to be stored was written is placed on the clipboard in This confirms that, as shown below, the text saved to the clipboard in Windows also automatically stores certain clipboard formats as corresponding data in other formats. Reference: Clipboard Formats - Win32 apps | Microsoft Learn Therefore, even if data is explicitly saved only to the clipboard in HANDLE GetClipboardData(\n [in] UINT uFormat\n);// Enumerate all clipboard formats\nwhile ((format = EnumClipboardFormats(format)) != 0) { }// If we can lock the data, we assume it's a memory block\nvoid* pData = GlobalLock(hData);\nif (pData) {\n size_t size = GlobalSize(hData);\n std::cout << \" Type: Memory Block | Size: \" << std::dec << size << \" bytes\" << std::endl << std::endl;\n\n PrintHexDump(pData, size);\n\n GlobalUnlock(hData);\n}GMEM_MOVEABLE flag, so the GlobalLock function is required to access that memory region.\n
\nWrite Operations with the Win32 API
\n// Using Win32 API to write and read clipboard text\nbool WriteTextToClipboard(const std::wstring& text) {\n \n if (!OpenClipboard(NULL)) {\n std::cerr << \"Failed to open clipboard.\" << std::endl;\n return false;\n }\n if (!EmptyClipboard()) {\n std::cerr << \"Failed to empty clipboard.\" << std::endl;\n CloseClipboard();\n return false;\n}\n\n// Calculate size in bytes (including null terminator)\n size_t size = (text.length() + 1) * sizeof(wchar_t);\n\n// Need to allocate global memory for clipboard data(GMEM_MOVEABLE)\n HGLOBAL hGlob = GlobalAlloc(GMEM_MOVEABLE, size);\n if (!hGlob) {\n CloseClipboard();\n return false;\n }\n\n// Lock the memory and copy the text\n void* pMem = GlobalLock(hGlob);\n if (pMem) {\n\n memcpy(pMem, text.c_str(), size);\n GlobalUnlock(hGlob);\n\n// Set the clipboard data as CF_UNICODETEXT\n if (SetClipboardData(CF_UNICODETEXT, hGlob) == NULL) {\n GlobalFree(hGlob);\n std::cerr << \"Failed to set clipboard data.\" << std::endl;\n }\n else {\n std::cout << \"[Write] Successfully copied text to clipboard.\" << std::endl;\n }\n }\n\n CloseClipboard();\n return true;\n}GMEM_MOVEABLE flag, and the data to be stored in the clipboard is written with GlobalLock -> memcpy -> GlobalUnlock.CF_UNICODETEXT format with the SetClipboardData function (winuser.h).CF_UNICODETEXT format has been written as a wide string.CF_UNICODETEXT format by SetClipboardData(CF_UNICODETEXT, hGlob), it appears that the text is also automatically converted to a single-byte string and stored in CF_TEXT and CF_OEMTEXT, which are implicit type-conversion targets of CF_UNICODETEXT.