Advanced MFC Programming

Chapter 9. Font
GHND
GPTR
Same with GMEM_MOVEABLE | GMEM_ZEROINIT
Same with GMEM_FIXED | GMEM_ZEROINIT
The most commonly used flag is GHND, which specifies that the memory block should be movable and
all buffers should be initialized to zeros. For the clipboard usage, we also need to specify flag GMEM_SHARE,
which will enhance the performance of clipboard operation.
Actually, in Win32 programming, the memory block allocated by one process can not be shared by
other processes. Flag GMEM_SHARE exists just for the backward compatibility purpose. For a general
application, we can not allocate a block of memory using flag GMEM_SHARE and share it with other
applications. In Win32, this flag is solely used for clipboard and DDE (see chapter 15) implementation.
The memory size that will be allocated is specified by dwBytes parameter of function
::GlobalAlloc(…).
Apart from these functions, there is another set of functions whose functionality is exactly the same,
the only difference is that they have a different set of function names:
HLOCAL ::LocalAlloc(UINT uFlags, UINT uBytes);
LPVOID ::LocalLock(HLOCAL hMem);
HLOCAL ::LocalReAlloc(HLOCAL hMem, UINT uBytes, UINT uFlags);
BOOL ::LocalUnlock(HLOCAL hMem);
HLOCAL ::LocalFree(HLOCAL hMem);
Everything is exactly the same except that all the “Global” keywords are changed to “Local” here.
These functions are originated from the old Win16 programming, which uses 16-bit memory mode. In that
case the memory can be allocated either from the local heap or global heap. In Win32 programming, there
is only one heap, so two sets of functions become exactly the same. They exist just for the compatibility
purpose. We can use either of them in our program. We can even call ::GlobalAlloc(…) to allocate
memory and release it using ::LocalFree(…).
Clipboard Funcitons
To copy our own data to the clipboard, we need to first prepare the data. The following lists the
necessary steps for allocating memory blcok and fill it with our data: 1) Allocate enough buffers by calling
function ::GlobalAlloc(…). 2) Lock the memory by calling function ::GlobalLock(…), which will return
a pointer that can be used to access the memory buffers. 3) Fill these buffers with data. 4) Call
::GlobalUnlock(…) to unlock the memory.
We need to use a series of functions in order to put the data to the clipboard: 1) First we need to call
function CWnd::OpenClipboard(…), which will let the clipboard be owned by our application (Only the
window that owns the clipboard can modify the data contained in the clipboard, any other application is
forbidden to access the clipboard during this period). 2) Before putting any data to the clipboard, we must
call ::EmptyClipboard() to clear any existing data. 3) We can call ::SetClipboardData() to put new data
to the clipboard. 4) Finally we need to call ::CloseClipboard() to close the clipboard, this will let the
clipboard be accessible to other windows.
When calling function ::SetClipboardData(…), besides passing the handle of the global memory, we
also need to specify the data format. There are many standard clipboard data formats such as CF_TEXT,
CF_DIB, which represent text data and bitmap data respectively. We can also define our own data format by
calling function ::RegisterClipboardFormat(…).
To copy data from the clipboard, we need to open the clipboard first, then call function
::GetClipboardData(), which will return a global memory handle. With this handle, we can call
::GlobalLock(…) to lock the memory, copy the data from the global memory to our own buffers, call
::GlobalUnlock(…) to unlock the memory, and close the clipboard. We can not free the global memory
obtained from the clipboard because after the clipboard is closed, some other applications may also want to
access it.
Deleting Selected Text
Sample 9.9\GDI is based on sample 9.8\GDI, it allows the user to cut or copy the selected text to the
clipboard, and paste the data from clipboard.
269