int KeystrokePaste( PCONSOLE_INFO pdp ) { if( OpenClipboard(NULL) ) { uint32_t format; // successful open... format = EnumClipboardFormats( 0 ); while( format ) { //DECLTEXT( msg, " " ); //msg.data.size = sprintf( msg.data.data, "Format: %d", format ); //EnqueLink( pdp->ps->Command->ppOutput, SegDuplicate( (PTEXT)&msg ) ); #ifndef CF_TEXT #define CF_TEXT 1 #endif if( format == CF_TEXT ) { HANDLE hData = GetClipboardData( CF_TEXT ); LPVOID pData = GlobalLock( hData ); PTEXT pStroke = SegCreateFromText( pData ); int ofs, n; GlobalUnlock( hData ); n = ofs = 0; while( pStroke->data.data[n] ) { pStroke->data.data[ofs] = pStroke->data.data[n]; if( pStroke->data.data[n] == '\r' ) // trash extra returns... keep newlines { n++; continue; } else { ofs++; n++; } } pStroke->data.size = ofs; pStroke->data.data[ofs] = pStroke->data.data[n]; if( PSI_DoStroke( pdp, pStroke ) ) 1; // RenderCommandLine( pdp ); //EnqueLink( pdp->ps->Command->ppOutput, SegDuplicate(pStroke) ); LineRelease( pStroke ); break; } format = EnumClipboardFormats( format ); } CloseClipboard(); } else { #ifdef __DEKWARE__PLUGIN__ DECLTEXT( msg, "Clipboard was not available" ); EnqueLink( &pdp->common.Owner->Command->Output, &msg ); #endif } return 0; }
int main(int argc, char* argv[]) { bool resetClipboard = false; char *cp; for(argv++; *argv && *(cp = *argv) == '-'; argv++) { for(cp++; *cp; cp++) { switch(*cp) { case 'r': resetClipboard = true; continue; default: usage(); } break; } } if(OpenClipboard(NULL) == 0) { _ftprintf(stderr,_T("%s\n"), getLastErrorText().cstr()); return -1; } if(resetClipboard) { if(EmptyClipboard() == 0) { _ftprintf(stderr,_T("%s\n"), getLastErrorText().cstr()); return -1; } } else { for(int cf = EnumClipboardFormats(0); cf; cf = EnumClipboardFormats(cf)) { TCHAR name[256]; GetClipboardFormatName(cf,name,ARRAYSIZE(name)); TCHAR *cfName = findFormatName(cf); if(cfName != NULL) { _tprintf(_T("format:%-20s:"), cfName); } else { _tprintf(_T("format:%-20s:"), name); } HANDLE t = GetClipboardData(cf); if(t == NULL) { _tprintf(_T("GetClipboardData failed:%s\n"), getLastErrorText().cstr()); } else { TCHAR *str = (TCHAR*)t; if(cf == CF_TEXT) { _tprintf(_T("<%s>\n"), str); } try { hexdump(str,40,stdout); } catch(...) { } } } } CloseClipboard(); return 0; }
WStringAutoPtr ClipboardFormats ( void ) { wstring format_list = L""; if ( OpenClipboard ( NULL ) ) { UINT formats = CountClipboardFormats(); UINT next_format = 0; for ( UINT i = 0 ; i < formats ; i++ ) { next_format = EnumClipboardFormats ( next_format ); const int max_count = 4096; wchar_t format_name[max_count]; int name_length = GetClipboardFormatName ( next_format, format_name, max_count ); if ( name_length > 0 ) { format_list += format_name; format_list += L"\r"; } } CloseClipboard(); } return WStringAutoPtr ( new wstring ( format_list ) ); } // ClipboardFormats
void VDAgent::on_clipboard_grab() { uint32_t types[clipboard_formats_count * VD_CLIPBOARD_FORMAT_MAX_TYPES]; int count = 0; if (!VD_AGENT_HAS_CAPABILITY(_client_caps, _client_caps_size, VD_AGENT_CAP_CLIPBOARD_BY_DEMAND)) { return; } if (CountClipboardFormats() == 0) { return; } for (unsigned int i = 0; i < clipboard_formats_count; i++) { if (IsClipboardFormatAvailable(clipboard_formats[i].format)) { for (uint32_t* ptype = clipboard_formats[i].types; *ptype; ptype++) { types[count++] = *ptype; } } } if (count) { write_message(VD_AGENT_CLIPBOARD_GRAB, count * sizeof(types[0]), types); set_clipboard_owner(owner_guest); } else { UINT format = 0; while ((format = EnumClipboardFormats(format))) { vd_printf("Unsupported clipboard format %u", format); } } }
static void UpdateDisplayMenu(void) { UINT uFormat; HMENU hMenu; WCHAR szFormatName[MAX_FMT_NAME_LEN + 1]; hMenu = GetSubMenu(Globals.hMenu, DISPLAY_MENU_POS); while (GetMenuItemCount(hMenu) > 1) { DeleteMenu(hMenu, 1, MF_BYPOSITION); } if (CountClipboardFormats() == 0) return; if (!OpenClipboard(Globals.hMainWnd)) return; AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL); /* Display the supported clipboard formats first */ for (uFormat = EnumClipboardFormats(0); uFormat; uFormat = EnumClipboardFormats(uFormat)) { if (IsClipboardFormatSupported(uFormat)) { RetrieveClipboardFormatName(Globals.hInstance, uFormat, TRUE, szFormatName, ARRAYSIZE(szFormatName)); AppendMenuW(hMenu, MF_STRING, CMD_AUTOMATIC + uFormat, szFormatName); } } /* Now display the unsupported clipboard formats */ for (uFormat = EnumClipboardFormats(0); uFormat; uFormat = EnumClipboardFormats(uFormat)) { if (!IsClipboardFormatSupported(uFormat)) { RetrieveClipboardFormatName(Globals.hInstance, uFormat, TRUE, szFormatName, ARRAYSIZE(szFormatName)); AppendMenuW(hMenu, MF_STRING | MF_GRAYED, 0, szFormatName); } } CloseClipboard(); }
static void vboxClipboardChanged (VBOXCLIPBOARDCONTEXT *pCtx) { LogFlow(("vboxClipboardChanged\n")); if (pCtx->pClient == NULL) { return; } /* Query list of available formats and report to host. */ if (OpenClipboard (pCtx->hwnd)) { uint32_t u32Formats = 0; UINT format = 0; while ((format = EnumClipboardFormats (format)) != 0) { LogFlow(("vboxClipboardChanged format %#x\n", format)); switch (format) { case CF_UNICODETEXT: case CF_TEXT: u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT; break; case CF_DIB: case CF_BITMAP: u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP; break; default: if (format >= 0xC000) { TCHAR szFormatName[256]; int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR)); if (cActual) { if (strcmp (szFormatName, "HTML Format") == 0) { u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_HTML; } } } break; } } CloseClipboard (); LogFlow(("vboxClipboardChanged u32Formats %02X\n", u32Formats)); vboxSvcClipboardReportMsg (pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, u32Formats); } }
bool hasUnsignedFormat(unsigned format) { ClipboardGuard clipboardGuard(GetClipboardOwner()); if (!clipboardGuard.isOpen()) { return false; } bool didFind = false; UINT enumFormat = EnumClipboardFormats(0); while (enumFormat && !didFind) { if (enumFormat == format) { didFind = true; } enumFormat = EnumClipboardFormats(enumFormat); } return didFind; }
static void test_synthesized(void) { HGLOBAL h, htext; HENHMETAFILE emf; BOOL r; UINT cf; HANDLE data; htext = create_text(); emf = create_emf(); r = OpenClipboard(NULL); ok(r, "gle %d\n", GetLastError()); r = EmptyClipboard(); ok(r, "gle %d\n", GetLastError()); h = SetClipboardData(CF_TEXT, htext); ok(h == htext, "got %p\n", h); h = SetClipboardData(CF_ENHMETAFILE, emf); ok(h == emf, "got %p\n", h); r = CloseClipboard(); ok(r, "gle %d\n", GetLastError()); r = OpenClipboard(NULL); ok(r, "gle %d\n", GetLastError()); cf = EnumClipboardFormats(0); ok(cf == CF_TEXT, "cf %08x\n", cf); data = GetClipboardData(cf); ok(data != NULL, "couldn't get data, cf %08x\n", cf); cf = EnumClipboardFormats(cf); ok(cf == CF_ENHMETAFILE, "cf %08x\n", cf); data = GetClipboardData(cf); ok(data != NULL, "couldn't get data, cf %08x\n", cf); cf = EnumClipboardFormats(cf); todo_wine ok(cf == CF_LOCALE, "cf %08x\n", cf); if(cf == CF_LOCALE) cf = EnumClipboardFormats(cf); ok(cf == CF_OEMTEXT, "cf %08x\n", cf); data = GetClipboardData(cf); ok(data != NULL, "couldn't get data, cf %08x\n", cf); cf = EnumClipboardFormats(cf); ok(cf == CF_UNICODETEXT, "cf %08x\n", cf); cf = EnumClipboardFormats(cf); ok(cf == CF_METAFILEPICT, "cf %08x\n", cf); data = GetClipboardData(cf); todo_wine ok(data != NULL, "couldn't get data, cf %08x\n", cf); cf = EnumClipboardFormats(cf); ok(cf == 0, "cf %08x\n", cf); r = EmptyClipboard(); ok(r, "gle %d\n", GetLastError()); r = CloseClipboard(); ok(r, "gle %d\n", GetLastError()); }
static int vboxClipboardChanged(PVBOXCLIPBOARDCONTEXT pCtx) { AssertPtr(pCtx); /* Query list of available formats and report to host. */ int rc = vboxOpenClipboard(pCtx->hwnd); if (RT_SUCCESS(rc)) { uint32_t u32Formats = 0; UINT format = 0; while ((format = EnumClipboardFormats(format)) != 0) { LogFlowFunc(("vboxClipboardChanged: format = 0x%08X\n", format)); switch (format) { case CF_UNICODETEXT: case CF_TEXT: u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT; break; case CF_DIB: case CF_BITMAP: u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP; break; default: { if (format >= 0xC000) { TCHAR szFormatName[256]; int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR)); if (cActual) { if (strcmp (szFormatName, "HTML Format") == 0) { u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_HTML; } } } break; } } } CloseClipboard(); rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, u32Formats); } else { LogFlow(("vboxClipboardChanged: error in open clipboard. hwnd: %x. err: %Rrc\n", pCtx->hwnd, rc)); } return rc; }
wchar_t* GetCliboardText(DWORD& rnErrCode, wchar_t* rsErrText, INT_PTR cchErrMax) { if (!rsErrText || cchErrMax < 255) { _ASSERTE(FALSE && "Invalid arguments"); return NULL; } HGLOBAL hglb; LPCWSTR lptstr; wchar_t* pszBuf = NULL; if ((hglb = GetClipboardData(CF_UNICODETEXT)) == NULL) { rnErrCode = GetLastError(); _wsprintf(rsErrText, SKIPLEN(cchErrMax) L"Clipboard does not contain CF_UNICODETEXT, nothing to paste (code=%u)", rnErrCode); gpConEmu->LogString(rsErrText); _wcscpy_c(rsErrText, cchErrMax, L"Available formats:"); int nLen = lstrlen(rsErrText); UINT fmt = 0; while (((nLen + 11) < cchErrMax) && ((fmt = EnumClipboardFormats(fmt)) != 0)) { _wsprintf(rsErrText+nLen, SKIPLEN(cchErrMax-nLen) L" x%04X", fmt); nLen += lstrlen(rsErrText+nLen); } gpConEmu->LogString(rsErrText); rsErrText[0] = 0; // Don't call DisplayLastError TODO("Сделать статусное сообщение с таймаутом"); //this->SetConStatus(L"Clipboard does not contains text. Nothing to paste."); } else if ((lptstr = (LPCWSTR)GlobalLock(hglb)) == NULL) { rnErrCode = GetLastError(); _wsprintf(rsErrText, SKIPLEN(cchErrMax) L"Can't lock CF_UNICODETEXT, paste failed (code=%u)", rnErrCode); gpConEmu->LogString(rsErrText); } else if (*lptstr == 0) { rnErrCode = GetLastError(); _wsprintf(rsErrText, SKIPLEN(cchErrMax) L"CF_UNICODETEXT is empty, nothing to paste (code=%u)", rnErrCode); gpConEmu->LogString(rsErrText); rsErrText[0] = 0; // Don't call DisplayLastError GlobalUnlock(hglb); } else { pszBuf = lstrdup(lptstr, 1); // Reserve memory for space-termination Assert(pszBuf!=NULL); GlobalUnlock(hglb); } return pszBuf; }
static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx) { AssertPtr(pCtx); /* Query list of available formats and report to host. */ int rc = VINF_SUCCESS; if (FALSE == OpenClipboard(pCtx->hwnd)) { rc = RTErrConvertFromWin32(GetLastError()); } else { uint32_t u32Formats = 0; UINT format = 0; while ((format = EnumClipboardFormats (format)) != 0) { Log(("VBoxTray: vboxClipboardChanged: format = 0x%08X\n", format)); switch (format) { case CF_UNICODETEXT: case CF_TEXT: u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT; break; case CF_DIB: case CF_BITMAP: u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP; break; default: if (format >= 0xC000) { TCHAR szFormatName[256]; int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR)); if (cActual) { if (strcmp (szFormatName, "HTML Format") == 0) { u32Formats |= VBOX_SHARED_CLIPBOARD_FMT_HTML; } } } break; } } CloseClipboard (); rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, u32Formats); } return rc; }
FarString PasteFromClipboard() { OSVERSIONINFO WinVer; WinVer.dwOSVersionInfoSize = sizeof (OSVERSIONINFO); GetVersionEx (&WinVer); HANDLE hClipData; if (!OpenClipboard(NULL)) return(NULL); int Unicode=FALSE; int Format=0; int ReadType=CF_OEMTEXT; while ((Format=EnumClipboardFormats(Format))!=0) { if (Format==CF_UNICODETEXT && WinVer.dwPlatformId==VER_PLATFORM_WIN32_NT) { Unicode=TRUE; break; } if (Format==CF_TEXT) { ReadType=CF_TEXT; break; } if (Format==CF_OEMTEXT) break; } FarString ClipText; if ((hClipData=GetClipboardData(Unicode ? CF_UNICODETEXT:ReadType))!=NULL) { int BufferSize; char *ClipAddr=(char *)GlobalLock(hClipData); if (Unicode) BufferSize=lstrlenW((LPCWSTR)ClipAddr)+1; else BufferSize=strlen(ClipAddr)+1; if (Unicode) { ClipText.SetLength (BufferSize); WideCharToMultiByte(CP_OEMCP,0,(LPCWSTR)ClipAddr,-1,ClipText.GetBuffer(),BufferSize,NULL,FALSE); } else { ClipText.SetText (ClipAddr, BufferSize); if (ReadType==CF_TEXT) ClipText = ClipText.ToOEM(); } GlobalUnlock(hClipData); } CloseClipboard(); return ClipText; }
static void test_synthesized(void) { HGLOBAL h, htext; HENHMETAFILE emf; BOOL r; UINT cf; htext = create_text(); emf = create_emf(); r = OpenClipboard(NULL); ok(r, "gle %d\n", GetLastError()); r = EmptyClipboard(); ok(r, "gle %d\n", GetLastError()); h = SetClipboardData(CF_TEXT, htext); ok(h == htext, "got %p\n", h); h = SetClipboardData(CF_ENHMETAFILE, emf); ok(h == emf, "got %p\n", h); r = CloseClipboard(); ok(r, "gle %d\n", GetLastError()); r = OpenClipboard(NULL); ok(r, "gle %d\n", GetLastError()); cf = EnumClipboardFormats(0); ok(cf == CF_TEXT, "cf %08x\n", cf); cf = EnumClipboardFormats(cf); ok(cf == CF_ENHMETAFILE, "cf %08x\n", cf); cf = EnumClipboardFormats(cf); todo_wine ok(cf == CF_LOCALE, "cf %08x\n", cf); if(cf == CF_LOCALE) cf = EnumClipboardFormats(cf); ok(cf == CF_OEMTEXT, "cf %08x\n", cf); cf = EnumClipboardFormats(cf); ok(cf == CF_UNICODETEXT || broken(cf == CF_METAFILEPICT), /* win9x and winME has no CF_UNICODETEXT */ "cf %08x\n", cf); if(cf == CF_UNICODETEXT) cf = EnumClipboardFormats(cf); ok(cf == CF_METAFILEPICT, "cf %08x\n", cf); cf = EnumClipboardFormats(cf); ok(cf == 0, "cf %08x\n", cf); r = EmptyClipboard(); ok(r, "gle %d\n", GetLastError()); r = CloseClipboard(); ok(r, "gle %d\n", GetLastError()); }
long MainWindow::GetClipboardContentLen(void) { long len = 0; UINT format = 0; HGLOBAL hGlobal; while ((format = EnumClipboardFormats(format)) != 0) { hGlobal = GetClipboardData(format); ASSERT(hGlobal != NULL); len += GlobalSize(hGlobal); } return len; }
std::unique_ptr<Clipboard> Clipboard::Capture() { auto clipboard = std::make_unique<Clipboard>(GetClipboardOwner()); if (clipboard == nullptr) return nullptr; UINT format_id = 0; for (auto i = 0, l = CountClipboardFormats(); i < l; ++i) { format_id = EnumClipboardFormats(format_id); if (format_id == 0) // error break; auto handle = GetClipboardData(format_id); if (handle == NULL) // error continue; std::unique_ptr<Format> format; if (format_id == CF_BITMAP) { // ignore } else if (format_id == CF_ENHMETAFILE) { auto meta_file = CopyEnhMetaFile(reinterpret_cast<HENHMETAFILE>(handle), nullptr); if (meta_file == NULL) // error continue; format = std::make_unique<MetaFileFormat>(meta_file); } else { auto size = GlobalSize(handle); auto memory = GlobalLock(handle); if (memory == nullptr) // error continue; format = std::make_unique<Format>(format_id, size); memcpy(format->Get(), memory, size); GlobalUnlock(handle); } if (format != nullptr) clipboard->Add(std::move(format)); } if (clipboard->IsEmpty()) return nullptr; return clipboard; }
bool ClipboardUtil::getAvailableClipboardFormats(std::vector<std::string> *formatsArray) { //KITDIAG_ASSERT(formatsArray); ClipboardGuard clipboardGuard(GetClipboardOwner()); if (!clipboardGuard.isOpen()) { return false; } formatsArray->clear(); char formatName[100]; std::string formatNameString; UINT uFormat = EnumClipboardFormats(0); while (uFormat) { if (getStandardClipboardFormatName(&formatNameString, uFormat)) { formatsArray->push_back(formatNameString); } else if (GetClipboardFormatNameA(uFormat, formatName, sizeof(formatName))) { formatNameString = formatName; formatsArray->push_back(formatNameString); } uFormat = EnumClipboardFormats(uFormat); } return true; }
CString CMSWindowsClipboard::get(EFormat format) const { // find the converter for the first clipboard format we can handle IMSWindowsClipboardConverter* converter = NULL; UINT win32Format = EnumClipboardFormats(0); while (converter == NULL && win32Format != 0) { for (ConverterList::const_iterator index = m_converters.begin(); index != m_converters.end(); ++index) { converter = *index; if (converter->getWin32Format() == win32Format && converter->getFormat() == format) { break; } converter = NULL; } win32Format = EnumClipboardFormats(win32Format); } // if no converter then we don't recognize any formats if (converter == NULL) { return CString(); } // get a handle to the clipboard data HANDLE win32Data = GetClipboardData(converter->getWin32Format()); if (win32Data == NULL) { // nb: can't cause this using integ tests; this is only caused when // the selected converter returns an invalid format -- which you // cannot cause using public functions. return CString(); } // convert return converter->toIClipboard(win32Data); }
bool CAppUtils::HasClipboardFormat(UINT format) { if (OpenClipboard(NULL)) { UINT enumFormat = 0; do { if (enumFormat == format) { CloseClipboard(); return true; } } while((enumFormat = EnumClipboardFormats(enumFormat))!=0); CloseClipboard(); } return false; }
SEXP getClipboardFormats(void) { SEXP ans = R_NilValue; int j, size, format = 0; if(OpenClipboard(NULL)) { size = CountClipboardFormats(); PROTECT(ans = allocVector(INTSXP, size)); for (j = 0; j < size; j++) { format = EnumClipboardFormats(format); INTEGER(ans)[j] = format; } UNPROTECT(1); CloseClipboard(); } return ans; }
/* * clipboard_get_datainfo - クリップボードの内容からデータリストを作成 */ DATA_INFO *clipboard_get_datainfo(const BOOL use_filter, const BOOL get_data, TCHAR *err_str) { DATA_INFO *ret_di = NULL; DATA_INFO *new_item; DATA_INFO *di; TCHAR buf[BUF_SIZE]; HANDLE data; UINT format; format = 0; while ((format = EnumClipboardFormats(format)) != 0) { clipboard_get_format(format, buf); // フィルタ (形式) if (use_filter == TRUE && filter_format_check(buf) == FALSE) { continue; } // アイテムの作成 if ((new_item = data_create_data(format, buf, NULL, 0, FALSE, err_str)) == NULL) { return NULL; } if (get_data == TRUE) { // クリップボードデータのコピー if ((data = GetClipboardData(format)) != NULL && (new_item->data = format_copy_data(new_item->format_name, data, &new_item->size)) == NULL) { new_item->data = clipboard_copy_data(format, data, &new_item->size); } } // フィルタ (サイズ) if (use_filter == TRUE && filter_size_check(new_item->format_name, new_item->size) == FALSE) { data_free(new_item); continue; } // リストに追加 if (ret_di == NULL) { ret_di = new_item; } else { di->next = new_item; } di = new_item; } return ret_di; }
BOOL IsImageInClipboard(HWND hWnd) { if (!OpenClipboard(hWnd)) return FALSE; BOOL ret = FALSE; UINT fmt = 0; while ((fmt = EnumClipboardFormats(fmt))) { if (fmt == CF_BITMAP || fmt == CF_DIB || fmt == CF_DIBV5) { ret = TRUE; break; } } CloseClipboard(); return ret; }
bool CClipboard::HasText () { bool result = false; if (owner.OpenClipboard () != 0) { UINT format = 0; while ((format = EnumClipboardFormats (format))) { if (format == CF_UNICODETEXT || format == CF_TEXT) { result = true; break; } } CloseClipboard (); } return result; }
bool COpenDlg::CheckAndEnableClipboardChecker() { int radio = GetCheckedRadioButton(IDC_MERGERADIO, IDC_APPLYRADIO); bool bUDiffOnClipboard = false; if (radio == IDC_APPLYRADIO) { if (OpenClipboard()) { UINT enumFormat = 0; do { if (enumFormat == m_cFormat) { bUDiffOnClipboard = true; } } while((enumFormat = EnumClipboardFormats(enumFormat))!=0); CloseClipboard(); } } DialogEnableWindow(IDC_PATCHFROMCLIPBOARD, bUDiffOnClipboard); return bUDiffOnClipboard; }
/** * クリップボードのデータをすべて取得する。 * * 取得したデータはすぐに複製を取っておく。 * このデータは #Clipboard_SetClipboardAllData に渡すことで * クリップボードの内容を元に戻すことができる(はずである)。 * * 戻り値を #Clipboard_SetClipboardAllData に渡さない場合、 * 呼び出し元は std::pair の second の HANDLE を適切に * GlobalFree で開放しなければならない。 * * @return クリップボードの内容。クリップボードが空の場合はサイズが 0 */ std::vector<std::pair<UINT, HANDLE> > Clipboard_GetClipboardAllData() { std::vector<std::pair<UINT, HANDLE> > data; UINT format = 0; OpenClipboard(NULL); while (format = EnumClipboardFormats(format)) { data.push_back(std::pair<UINT, HANDLE>(format, GetClipboardData(format))); } CloseClipboard(); std::vector<std::pair<UINT, HANDLE> > copy; std::vector<std::pair<UINT, HANDLE> >::iterator it; for (it = data.begin(); it != data.end(); it++) { SIZE_T size = GlobalSize(it->second); HANDLE h = GlobalAlloc(GHND, size); PVOID dst = GlobalLock(h); PVOID src = GlobalLock(it->second); memcpy(dst, src, size); GlobalUnlock(src); GlobalUnlock(dst); copy.push_back(std::pair<UINT, HANDLE>(it->first, dst)); } return copy; }
bool CTortoiseMergeApp::HasClipboardPatch() { // check if there's a patchfile in the clipboard const UINT cFormat = RegisterClipboardFormat(_T("TSVN_UNIFIEDDIFF")); if (cFormat == 0) return false; if (OpenClipboard(NULL) == 0) return false; bool containsPatch = false; UINT enumFormat = 0; do { if (enumFormat == cFormat) { containsPatch = true; // yes, there's a patchfile in the clipboard } } while((enumFormat = EnumClipboardFormats(enumFormat))!=0); CloseClipboard(); return containsPatch; }
int scrap_get_types_win (char** types) { UINT format = 0; char **tmptypes; int count = -1; int i, len, size; char tmp[100] = { '\0' }; if (!OpenClipboard (_sdlwindow)) { SDL_SetError ("could not access clipboard"); return -1; } size = CountClipboardFormats (); if (size == 0) { CloseClipboard (); return 0; /* No clipboard data. */ } for (i = 0; i < size; i++) { format = EnumClipboardFormats (format); if (format == 0) { /* Something wicked happened. */ while (i > 0) free (types[i]); free (types); CloseClipboard (); SDL_SetError ("error on retrieving the formats"); return -1; } /* No predefined name, get the (truncated) name. */ len = _lookup_clipboard_format (format, tmp, 100); if (len == 0) continue; count++; tmptypes = realloc (types, sizeof (char *) * (count + 1)); if (!tmptypes) { while (count > 0) { free (types[count]); count--; } free (types); CloseClipboard (); SDL_SetError ("could allocate memory"); return -1; } types = tmptypes; types[count] = malloc (sizeof (char) * (len + 1)); if (!types[count]) { while (count > 0) { free (types[count]); count--; } free (types); CloseClipboard (); SDL_SetError ("could allocate memory"); return -1; } memset (types[count], 0, len + 1); memcpy (types[count], tmp, len); } tmptypes = realloc (types, sizeof (char *) * (count + 1)); if (!tmptypes) { while (count > 0) { free (types[count]); count--; } free (types); CloseClipboard (); SDL_SetError ("could allocate memory"); return -1; } types = tmptypes; types[count] = NULL; CloseClipboard (); return 1; }
/*! クリップボードのデータをいただく・同じモノが、DocInsDelCtrl.cpp にある @param[in] pVoid 特になし @return 確保した文字列・mallocしてるので、函数呼んだ方でfree忘れないように */ LPTSTR ClipboardDataGet( LPVOID pVoid ) { LPTSTR ptString = NULL, ptClipTxt; LPSTR pcStr, pcClipTp; // 変換用臨時 DWORD cbSize; UINT dEnumFmt; INT ixCount, iC; HANDLE hClipData; // クリップボードの中身をチェキ・どっちにしてもユニコードテキストフラグはある if( IsClipboardFormatAvailable( CF_UNICODETEXT ) ) { OpenClipboard( NULL ); // クリップボードをオーポンする // 開けっ放しだと他のアプリに迷惑なのですぐ閉めるように dEnumFmt = 0; // 初期値は0 ixCount = CountClipboardFormats( ); for( iC = 0; ixCount > iC; iC++ ) { // 順番に列挙して、先にヒットしたフォーマットで扱う dEnumFmt = EnumClipboardFormats( dEnumFmt ); if( CF_UNICODETEXT == dEnumFmt || CF_TEXT == dEnumFmt ){ break; } } if( 0 == dEnumFmt ){ return NULL; } // それ以上列挙が無いか、函数失敗なら0になる // クリップボードのデータをゲッツ! // ハンドルのオーナーはクリップボードなので、こちらからは操作しないように // 中身の変更などもってのほかである hClipData = GetClipboardData( dEnumFmt ); if( CF_UNICODETEXT == dEnumFmt ) { // 取得データを処理。TEXTなら、ハンドルはグローバルメモリハンドル // 新たにコピーされたらハンドルは無効になるので、中身をコピーせよ ptClipTxt = (LPTSTR)GlobalLock( hClipData ); cbSize = GlobalSize( (HGLOBAL)hClipData ); // 確保出来るのはバイトサイズ・テキストだと末尾のNULLターミネータ含む if( 0 < cbSize ) { ptString = (LPTSTR)malloc( cbSize ); StringCchCopy( ptString, (cbSize / 2), ptClipTxt ); } } else // 非ユニコードが優先されている場合 { pcClipTp = (LPSTR)GlobalLock( hClipData ); cbSize = GlobalSize( (HGLOBAL)hClipData ); if( 0 < cbSize ) { pcStr = (LPSTR)malloc( cbSize ); StringCchCopyA( pcStr, cbSize, pcClipTp ); ptString = SjisDecodeAlloc( pcStr ); // SJISの内容をユニコードにする free( pcStr ); } } // 使い終わったら閉じておく GlobalUnlock( hClipData ); CloseClipboard( ); } return ptString; }
void WriteClipboardFile(LPCWSTR lpFileName, WORD wFileIdentifier) { CLIPFILEHEADER ClipFileHeader; CLIPFORMATHEADER ClipFormatArray; NTCLIPFILEHEADER NtClipFileHeader; NTCLIPFORMATHEADER NtClipFormatArray; PVOID pClipFileHeader; PVOID pClipFormatArray; DWORD SizeOfFileHeader, SizeOfFormatHeader; WORD wFormatCount; DWORD dwFormatID; DWORD dwLenData; DWORD dwOffData; // PVOID szName; HANDLE hFile; DWORD dwBytesWritten; int i; /* Create the file for write access */ hFile = CreateFileW(lpFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { ShowLastWin32Error(Globals.hMainWnd); goto done; } wFormatCount = CountClipboardFormats(); /* Select the file format and setup the header according to the clipboard file format ID */ switch (wFileIdentifier) { case CLIP_FMT_31: SizeOfFileHeader = sizeof(CLIPFILEHEADER); SizeOfFormatHeader = sizeof(CLIPFORMATHEADER); pClipFileHeader = &ClipFileHeader; pClipFormatArray = &ClipFormatArray; ClipFileHeader.wFileIdentifier = CLIP_FMT_31; // wFileIdentifier ClipFileHeader.wFormatCount = wFormatCount; break; case CLIP_FMT_NT: case CLIP_FMT_BK: SizeOfFileHeader = sizeof(NTCLIPFILEHEADER); SizeOfFormatHeader = sizeof(NTCLIPFORMATHEADER); pClipFileHeader = &NtClipFileHeader; pClipFormatArray = &NtClipFormatArray; NtClipFileHeader.wFileIdentifier = CLIP_FMT_NT; // wFileIdentifier NtClipFileHeader.wFormatCount = wFormatCount; break; default: MessageBoxRes(Globals.hMainWnd, Globals.hInstance, ERROR_INVALID_FILE_FORMAT, 0, MB_ICONSTOP | MB_OK); goto done; } /* Write the header */ SetFilePointer(hFile, 0, NULL, FILE_BEGIN); if (!WriteFile(hFile, pClipFileHeader, SizeOfFileHeader, &dwBytesWritten, NULL) || dwBytesWritten != SizeOfFileHeader) { ShowLastWin32Error(Globals.hMainWnd); goto done; } /* Compute where the data should start (after the file header and the format array) */ dwOffData = SizeOfFileHeader + wFormatCount * SizeOfFormatHeader; /* Loop through each format and save the data */ i = 0; dwFormatID = EnumClipboardFormats(0); while (dwFormatID) { if (i >= wFormatCount) { /* Must never happen! */ assert(FALSE); break; } /* Write the clipboard data at the specified offset, and retrieve its length */ if (!ClipboardWriteMemory(hFile, dwFormatID, dwOffData, &dwLenData)) goto Cont; /* Write the format data header */ switch (wFileIdentifier) { case CLIP_FMT_31: ZeroMemory(pClipFormatArray, sizeof(CLIPFORMATHEADER)); ((CLIPFORMATHEADER*)pClipFormatArray)->dwFormatID = dwFormatID; ((CLIPFORMATHEADER*)pClipFormatArray)->dwLenData = dwLenData; ((CLIPFORMATHEADER*)pClipFormatArray)->dwOffData = dwOffData; RetrieveClipboardFormatName(Globals.hInstance, dwFormatID, FALSE, ((CLIPFORMATHEADER*)pClipFormatArray)->szName, ARRAYSIZE(((CLIPFORMATHEADER*)pClipFormatArray)->szName)); break; case CLIP_FMT_NT: case CLIP_FMT_BK: ZeroMemory(pClipFormatArray, sizeof(NTCLIPFORMATHEADER)); ((NTCLIPFORMATHEADER*)pClipFormatArray)->dwFormatID = dwFormatID; ((NTCLIPFORMATHEADER*)pClipFormatArray)->dwLenData = dwLenData; ((NTCLIPFORMATHEADER*)pClipFormatArray)->dwOffData = dwOffData; RetrieveClipboardFormatName(Globals.hInstance, dwFormatID, TRUE, ((NTCLIPFORMATHEADER*)pClipFormatArray)->szName, ARRAYSIZE(((NTCLIPFORMATHEADER*)pClipFormatArray)->szName)); break; } if (SetFilePointer(hFile, SizeOfFileHeader + i * SizeOfFormatHeader, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER) { ShowLastWin32Error(Globals.hMainWnd); goto done; } if (!WriteFile(hFile, pClipFormatArray, SizeOfFormatHeader, &dwBytesWritten, NULL)) { ShowLastWin32Error(Globals.hMainWnd); goto done; } /* Adjust the offset for the next data stream */ dwOffData += dwLenData; Cont: i++; dwFormatID = EnumClipboardFormats(dwFormatID); } done: if (hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile); return; }
static void cliprdr_send_format_list(cliprdrContext *cliprdr) { RDP_CB_FORMAT_LIST_EVENT *cliprdr_event; BYTE *format_data; int format = 0; int data_size; int format_count; int len = 0; int namelen; if (!OpenClipboard(cliprdr->hwndClipboard)) { DEBUG_CLIPRDR("OpenClipboard failed with 0x%x", GetLastError()); return; } format_count = CountClipboardFormats(); data_size = format_count * (4 + MAX_PATH * 2); format_data = (BYTE *)calloc(1, data_size); assert(format_data != NULL); while (format = EnumClipboardFormats(format)) { Write_UINT32(format_data + len, format); len += 4; if ((cliprdr->capabilities & CAPS_USE_LONG_FORMAT_NAMES) != 0) { if (format >= CF_MAX) { namelen = GetClipboardFormatNameW(format, (LPWSTR)(format_data + len), MAX_PATH); len += namelen * sizeof(WCHAR); } len += 2; /* end of Unicode string */ } else { if (format >= CF_MAX) { static wchar_t wName[MAX_PATH] = {0}; int wLen; ZeroMemory(wName, MAX_PATH*2); wLen = GetClipboardFormatNameW(format, wName, MAX_PATH); if (wLen < 16) { memcpy(format_data + len, wName, wLen * sizeof(WCHAR)); } else { memcpy(format_data + len, wName, 32); /* truncate the long name to 32 bytes */ } } len += 32; } } CloseClipboard(); cliprdr_event = (RDP_CB_FORMAT_LIST_EVENT *) freerdp_event_new(CliprdrChannel_Class, CliprdrChannel_FormatList, NULL, NULL); cliprdr_event->raw_format_data = (BYTE *)calloc(1, len); assert(cliprdr_event->raw_format_data != NULL); CopyMemory(cliprdr_event->raw_format_data, format_data, len); cliprdr_event->raw_format_data_size = len; free(format_data); freerdp_channels_send_event(cliprdr->channels, (wMessage *) cliprdr_event); }
static int cliprdr_send_format_list(wfClipboard* clipboard) { int count; int length; UINT32 index; UINT32 numFormats; UINT32 formatId = 0; char formatName[1024]; CLIPRDR_FORMAT* format; CLIPRDR_FORMAT* formats; CLIPRDR_FORMAT_LIST formatList; ZeroMemory(&formatList, sizeof(CLIPRDR_FORMAT_LIST)); if (!OpenClipboard(clipboard->hwnd)) return -1; count = CountClipboardFormats(); numFormats = (UINT32) count; formats = (CLIPRDR_FORMAT*) calloc(numFormats, sizeof(CLIPRDR_FORMAT)); index = 0; while (formatId = EnumClipboardFormats(formatId)) { format = &formats[index++]; format->formatId = formatId; length = 0; format->formatName = NULL; if (formatId >= CF_MAX) { length = GetClipboardFormatNameA(formatId, formatName, sizeof(formatName) - 1); } if (length > 0) { format->formatName = _strdup(formatName); } } CloseClipboard(); formatList.msgFlags = 0; formatList.numFormats = numFormats; formatList.formats = formats; clipboard->context->ClientFormatList(clipboard->context, &formatList); for (index = 0; index < numFormats; index++) { format = &formats[index]; free(format->formatName); } free(formats); return 1; }