Camelot: BodgeTextClipMap Class Reference

Invokes this mapping for exporting This takes the document tree of Source, and exports it to the external (windows) clipboard.

Notes: The returned handle should be the thing you'd pass to SetClipboardData if you were dealing with it directly. You must adhere to all the Windows rules for this - i.e. a global data block, unlocked, etc etc.

01083 {
01084     const DWORD Increment = 1024 * sizeof(char);
01085     DWORD CurrentSize   = 0;
01086     DWORD MaxSize       = Increment;
01087 
01088 #if (_OLE_VER >= 0x200)
01089 
01090     // If necessary allocate the memory.
01091     BOOL fDidAlloc = FALSE;
01092     HANDLE hGlobalMem = m_hMem;
01093     if (hGlobalMem)
01094     {
01095         // We have some already.  Set the size.
01096         MaxSize = m_cbMemSize;
01097     }
01098     else
01099     {
01100         // We don't have any, so try to allocate and remember that we did so.
01101         hGlobalMem = m_hMem = GlobalAlloc(GHND, MaxSize);
01102         if (!hGlobalMem) return 0;
01103         fDidAlloc = TRUE;
01104     }
01105 
01106 #else
01107 
01108     // Allocate a block of global memory to store the text
01109     HANDLE hGlobalMem = GlobalAlloc(GHND, MaxSize);
01110 
01111     if (hGlobalMem == NULL)
01112         return(NULL);
01113 
01114 #endif
01115 
01116     // Get a UNICODE text buffer
01117     char* buff = (char*) GlobalLock(hGlobalMem);
01118     if (buff == NULL)
01119     {
01120         return(NULL);
01121     }
01122 
01123     // Scan the entire document tree, and lob every TextChar we find into the export buffer
01124     // NOTE that the Global{Re}Alloc zeros memory, so we don't need to worry about 0-termination.
01125     Node *pSubtree = InternalClipboard::GetInsertionLayer();
01126     Node *pNode = pSubtree->FindFirstDepthFirst();
01127     while (pNode != NULL)
01128     {
01129         if (pNode->IsKindOf(CC_RUNTIME_CLASS(TextChar)) || pNode->IsKindOf(CC_RUNTIME_CLASS(EOLNode)))
01130         {
01131             if (pNode->IsKindOf(CC_RUNTIME_CLASS(TextChar)))
01132             {
01133                 UINT32 ComposedChar = UnicodeManager::UnicodeToMultiByte(((TextChar *) pNode)->GetUnicodeValue());
01134                 BYTE LeadByte = 0;
01135                 BYTE TrailByte = 0;
01136                 UnicodeManager::DecomposeMultiBytes(ComposedChar, &LeadByte, &TrailByte);
01137 
01138                 if (LeadByte != 0)
01139                     buff[CurrentSize++] = LeadByte;
01140 
01141                 buff[CurrentSize++] = TrailByte;
01142             }
01143             else
01144             {
01145                 if (!((EOLNode*)pNode)->IsVirtual())
01146                 {
01147                     buff[CurrentSize++] = (char) 0x0D;      // CRLF - newline
01148                     buff[CurrentSize++] = (char) 0x0A;
01149                 }
01150             }
01151 
01152             // Check if we've overrun the buffer - if so, we need to make the buffer bigger
01153             // (Allow 3 entries at the end (1 to guarantee we have a zero terminator, and 2 more
01154             // to allow room to fit the 2-char newline sequence in!)
01155             if ( (CurrentSize * sizeof(char)) >= MaxSize - 3)
01156             {
01157             #if (_OLE_VER >= 0x200)
01158                 // If we didn't allocate the block then we can't resize it.
01159                 if (!fDidAlloc) return 0;
01160                 m_hMem = 0;
01161             #endif
01162                 
01163                 GlobalUnlock(hGlobalMem);
01164 
01165                 MaxSize += Increment;
01166                 HANDLE hNewMem = GlobalReAlloc(hGlobalMem, MaxSize, GHND);
01167                 if (hNewMem == NULL)
01168                 {
01169                     GlobalFree(hGlobalMem);
01170                     return(NULL);
01171                 }
01172 
01173                 hGlobalMem = hNewMem;
01174                 buff = (char *)GlobalLock(hGlobalMem);
01175 
01176                 if (buff == NULL)
01177                 {
01178                     GlobalFree(hGlobalMem);
01179                     return(NULL);
01180                 }
01181 
01182             #if (_OLE_VER >= 0x200)
01183                 // Remember this block.
01184                 m_hMem = hNewMem;
01185             #endif
01186             }
01187         }
01188         pNode = pNode->FindNextDepthFirst(pSubtree);
01189     }
01190 
01191     // We must unlock the block before giving it to the clipboard
01192     GlobalUnlock(hGlobalMem);
01193 
01194     return(hGlobalMem);
01195 }


Static Public Member Functions
static void	CreateAndRegister (ClipboardMappingType TheType, UINT32 ClaimType=0)
	Constructs and registers a clipboard mapping with the ExternalClipboard manager. This mapping info describes a filter which is able to import data from or export data to a windows clipboard in some way.
Protected Member Functions
	BodgeTextClipMap ()
	BodgeTextClipMap (ClipboardMappingType TheType, UINT32 ClaimType=0)
	Constructs a clipboard mapping with the ExternalClipboard manager. This mapping info describes a filter which is able to import data from or export data to a windows clipboard in some way.
virtual BOOL	HandleImport (SelOperation Caller, HANDLE ClipboardData, InternalClipboard Dest)
	Calls the parent filter as appropriate to import the given data from the external clipboard.
virtual HANDLE	HandleExport (Operation Caller, InternalClipboard Source)
	Invokes this mapping for exporting This takes the document tree of Source, and exports it to the external (windows) clipboard.
Friends
class	ExternalClipboard
class	OpClipboardExport
class	OpClipboardImport

BodgeTextClipMap Class Reference

Static Public Member Functions

Protected Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation