void CopyToClipboard(HWND hwnd) {
if (!hwnd || !OpenClipboard(hwnd)) return;
LRESULT len = SendDlgItemMessage(hwnd, IDC_LOGWIN, WM_GETTEXTLENGTH, 0, 0);
HGLOBAL mem = GlobalAlloc(GMEM_MOVEABLE, (++len)*sizeof(TCHAR));
if (!mem) { CloseClipboard(); return; }
TCHAR *txt = (TCHAR *)GlobalLock(mem);
if (!txt) { CloseClipboard(); return; }
EmptyClipboard();
txt[0] = 0;
SendDlgItemMessage(hwnd, IDC_LOGWIN, WM_GETTEXT, (WPARAM)(len), (LPARAM)txt);
GlobalUnlock(mem);
#ifdef _UNICODE
SetClipboardData(CF_UNICODETEXT, mem);
#else
SetClipboardData(CF_TEXT, mem);
#endif
CloseClipboard();
}
Status sys_clipboard_set(const wchar_t* text)
{
if(!OpenClipboard(hWndNewOwner))
WARN_RETURN(ERR::FAIL);
WARN_IF_FALSE(EmptyClipboard());
// NB: to enable copy/pasting something other than text, add
// message handlers for WM_RENDERFORMAT and WM_RENDERALLFORMATS.
HGLOBAL hMem;
Status ret = SetClipboardText(text, hMem);
WARN_IF_FALSE(CloseClipboard()); // must happen before GlobalFree
ENSURE(GlobalFree(hMem) == 0); // (0 indicates success)
return ret;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
// clipboard
//////////////////////////////////////////////////////////////////////////////////////////////////
void cGUIEdit::ClipboardCopy()
{
int s1 = sel1(), s2 = sel2();
int size = s2-s1;
if(size==0) return; // no selection
if(!OpenClipboard(NULL)) return;
if(EmptyClipboard())
{
HGLOBAL handler = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE,size+1); assert(handler!=NULL);
void* data = GlobalLock(handler); assert(data!=NULL);
memcpy(data,txt.c_str() + s1,size);
((LPWSTR)data)[size]=0;
GlobalUnlock(handler);
SetClipboardData(CF_UNICODETEXT,handler);
}
CloseClipboard();
}
BOOL CClipboard::SetTextW(HWND owner, const wchar_t* str, int len)
{
if (str && *str && OpenClipboard(owner))
{
EmptyClipboard();
HANDLE hmem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len + 4);
if (hmem)
{
wchar_t* buf = (wchar_t*)GlobalLock(hmem);
memcpy(buf, str, len + 4);
GlobalUnlock(hmem);
SetClipboardData(CF_UNICODETEXT, hmem);
}
CloseClipboard();
return TRUE;
}
return FALSE;
}
void CopyToClipboard(const char* text) ///Copies a string to the clipboard.
{
HGLOBAL hText;
char *pText;
hText = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, strlen(text)+1);
pText = (char*)GlobalLock(hText);
strcpy(pText, text);
OpenClipboard(0);
EmptyClipboard();
if(!SetClipboardData(CF_OEMTEXT, hText))
{
MessageBeep(MB_ICONERROR);
}
MessageBeep(MB_ICONINFORMATION);
CloseClipboard();
}
LRESULT CMainDlg::OnCopyClip(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
OpenClipboard();
EmptyClipboard();
FrqValue atk = GetSetting(gen1AtkEd);
AmpValue pk = GetSetting(gen1VolEd);
FrqValue dec = GetSetting(gen1DecEd);
AmpValue sus = GetSetting(gen1SusEd);
FrqValue rel = GetSetting(gen1RelEd);
FrqValue mul1 = GetSetting(gen2MulEd);
AmpValue amp1 = GetSetting(gen2NdxEd);
FrqValue atk1 = GetSetting(gen2AtkEd);
AmpValue pk1 = GetSetting(gen2PckEd);
FrqValue dec1 = GetSetting(gen2DecEd);
AmpValue sus1 = GetSetting(gen2SusEd);
FrqValue rel1 = GetSetting(gen2RelEd);
AmpValue end1 = GetSetting(gen2EndEd);
FrqValue mul2 = GetSetting(gen3MulEd);
AmpValue amp2 = GetSetting(gen3NdxEd);
FrqValue atk2 = GetSetting(gen3AtkEd);
AmpValue pk2 = GetSetting(gen3PckEd);
FrqValue dec2 = GetSetting(gen3DecEd);
AmpValue sus2 = GetSetting(gen3SusEd);
FrqValue rel2 = GetSetting(gen3RelEd);
AmpValue end2 = GetSetting(gen3EndEd);
char txt[1024];
sprintf(txt, "{ %4d, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f,\r\n%6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f,\r\n%6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f },\r\n",
algorithm, 0.0, atk, pk, dec, sus, rel, 0.0,
mul1, amp1, atk1, pk1, dec1, sus1, rel1, end1,
mul2, amp2, atk2, pk2, dec2, sus2, rel2, end2);
HANDLE mem = GlobalAlloc(0, strlen(txt)+1);
char *ptxt = (char*)GlobalLock(mem);
strcpy(ptxt, txt);
GlobalUnlock(mem);
SetClipboardData(CF_TEXT, mem);
CloseClipboard();
return 0;
}
void CutOrCopyFiles(LPCTSTR lpBuffer,UINT uBufLen,BOOL bCopy)
{
UINT uDropEffect;
DROPFILES dropFiles;
UINT uGblLen,uDropFilesLen;
HGLOBAL hGblFiles,hGblEffect;
char *szData,*szFileList;
DWORD *dwDropEffect;
uDropEffect=RegisterClipboardFormat(L"Preferred DropEffect");
hGblEffect=GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE|GMEM_DDESHARE,sizeof(DWORD));
dwDropEffect=(DWORD*)GlobalLock(hGblEffect);
if(bCopy)
*dwDropEffect=DROPEFFECT_COPY;
else
*dwDropEffect=DROPEFFECT_MOVE;
GlobalUnlock(hGblEffect);
uDropFilesLen=sizeof(DROPFILES);
dropFiles.pFiles =uDropFilesLen;
dropFiles.pt.x=0;
dropFiles.pt.y=0;
dropFiles.fNC =FALSE;
dropFiles.fWide =TRUE;
uGblLen=uDropFilesLen+uBufLen*2+20;
hGblFiles= GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE|GMEM_DDESHARE, uGblLen);
szData=(char*)GlobalLock(hGblFiles);
memset(szData, 0, uGblLen);
memcpy(szData,(LPVOID)(&dropFiles),uDropFilesLen);
szFileList=szData+uDropFilesLen;
memcpy(szFileList, lpBuffer, uBufLen*sizeof(TCHAR));
GlobalUnlock(hGblFiles);
if( OpenClipboard(NULL) )
{
EmptyClipboard();
SetClipboardData( CF_HDROP, hGblFiles );
SetClipboardData(uDropEffect,hGblEffect);
CloseClipboard();
}
}
void CCommunicationTrafficDlg::OnBnClickedCopy()
{
//--------------------------------------------------------------------------------------------------------------------
CArray <int, int> aryListSel;
int nCount= m_DataList.GetSelCount();
aryListSel.SetSize(nCount);
m_DataList.GetSelItems(nCount, aryListSel.GetData());
// aryListSel中存的就是选中列的index值，如果需要取内容，加以下语句：
CString str,content;
for (int i= nCount-1; i>= 0; i--)
{
m_DataList.GetText(aryListSel.GetAt(i), (CString&)str);
str+=_T("\n");
content==str;
}
//--------------------------------------------------------------------------------------------------------------------
HGLOBAL hClip;
//定义一个HGLOBAL句柄变量用来指向分配的内存块
if (OpenClipboard())
{
EmptyClipboard(); //将剪贴板内容清空
hClip=GlobalAlloc(GMEM_MOVEABLE,content.GetLength()+1);
//在堆上分配可移动的内存块，程序返回一个内存句柄
char * buff; //定义指向字符型的指针变量
buff=(char*)GlobalLock(hClip);
//对分配的内存块进行加锁，将内存块句柄转化成一个指针,并将相应的引用计数器加1
strcpy(buff,(char*)content.GetBuffer());
//将用户输入的数据复制到指针变量中，实际上就是复制到分配的内存块中
GlobalUnlock(hClip);
//数据写入完毕，进行解锁操作，并将引用计数器数字减1
SetClipboardData(CF_TEXT,hClip);
//将存放有数据的内存块放入剪贴板的资源管理中
CloseClipboard();
//关闭剪贴板，释放剪贴板资源的占用权
}
//--------------------------------------------------------------------------------------------------------------------
}
void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
{
WCHAR* wideString;
HANDLE stringHandle;
size_t wideSize;
wideString = _glfwCreateWideStringFromUTF8(string);
if (!wideString)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Win32: Failed to convert string to UTF-16");
return;
}
wideSize = (wcslen(wideString) + 1) * sizeof(WCHAR);
stringHandle = GlobalAlloc(GMEM_MOVEABLE, wideSize);
if (!stringHandle)
{
free(wideString);
_glfwInputError(GLFW_PLATFORM_ERROR,
"Win32: Failed to allocate global handle for clipboard");
return;
}
memcpy(GlobalLock(stringHandle), wideString, wideSize);
GlobalUnlock(stringHandle);
if (!OpenClipboard(window->win32.handle))
{
GlobalFree(stringHandle);
free(wideString);
_glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to open clipboard");
return;
}
EmptyClipboard();
SetClipboardData(CF_UNICODETEXT, stringHandle);
CloseClipboard();
free(wideString);
}
VOID
CopyTextToClipboard(LPCWSTR lpszText)
{
if(OpenClipboard(NULL))
{
HGLOBAL ClipBuffer;
WCHAR *Buffer;
EmptyClipboard();
ClipBuffer = GlobalAlloc(GMEM_DDESHARE, (wcslen(lpszText) + 1) * sizeof(TCHAR));
Buffer = (WCHAR*)GlobalLock(ClipBuffer);
wcscpy(Buffer, lpszText);
GlobalUnlock(ClipBuffer);
SetClipboardData(CF_UNICODETEXT, ClipBuffer);
CloseClipboard();
}
}
int CBitmap::SetClipboard() {
HANDLE hGMem = GlobalAlloc(GHND, m_bmpInfoHeader.biSize + m_image.buf.size());
BITMAPINFOHEADER *pBih = (BITMAPINFOHEADER *)GlobalLock(hGMem);
*pBih = *(BITMAPINFOHEADER *)&m_bmpInfoHeader;
//pBih->biBitCount = 32;
//pBih->biCompression = BI_RGB;
int width = m_image.width;
int height = m_image.height;
int bytesPerPixel = m_bmpInfoHeader.biBitCount / 8;
int bytesPerLine = ( (width + (m_bmpInfoHeader.biBitCount % 32 != 0) ) * bytesPerPixel >> 2) << 2;
// int writeSize = bytesPerLine * height;
printf("Setting... w=%d, h=%d", width, height);
int offset = pBih->biSize + pBih->biClrUsed * (pBih->biBitCount > 24 ? sizeof(RGBQuad) : sizeof(RGBTriple));
u8 *imgData = (u8 *)pBih + offset;
u32 *pBuf = (u32 *)&m_image.buf[0];
switch(m_bmpInfoHeader.biBitCount) {
case 24: {
if(m_bmpInfoHeader.biHeight < 0) // Top to bottom
REP(y, height) REP(x, width) *(RGBTriple *)&imgData[bytesPerLine*y + 3*x] = *(RGBTriple *)&pBuf[width*y+x];
else // Bottom to top
REV(y, height) REP(x, width) *(RGBTriple *)&imgData[bytesPerLine*y + 3*x] = *(RGBTriple *)&pBuf[width*y+x];
} break;
case 32: {
if(m_bmpInfoHeader.biHeight < 0) // Top to bottom
REP(y, height) REP(x, width) *(u32 *)&imgData[(width*y+x)*4] = pBuf[width*y+x];
else // Bottom to top
REV(y, height) REP(x, width) *(u32 *)&imgData[(width*y+x)*4] = pBuf[width*y+x];
} break;
}
GlobalUnlock(hGMem);
if( !OpenClipboard(NULL) ) return -1;
EmptyClipboard();
SetClipboardData(CF_DIB, hGMem);
CloseClipboard();
puts("OK");
return 0;
}
void CGumpListView::OnPopupCopygumpid()
{
int iGumpID = GetSelectedGumpID();
CString strText = GfxXtoA(iGumpID);
if (!OpenClipboard()) return;
EmptyClipboard();
HGLOBAL hClipboardData;
hClipboardData = GlobalAlloc(GMEM_DDESHARE, strText.GetLength()+1);
char * pchData = (char*)GlobalLock(hClipboardData);
strcpy(pchData, strText);
GlobalUnlock(hClipboardData);
SetClipboardData(CF_TEXT,hClipboardData);
CloseClipboard();
}
void Clipboard::set(std::string text)
{
if ( !OpenClipboard(NULL) )
{
//AfxMessageBox( _T("Cannot open the Clipboard") );
std::cout << "Clipboard.set(): Cannot open the Clipboard" << std::endl;
return;
}
// Remove the current Clipboard contents
if( !EmptyClipboard() )
{
std::cout << "Clipboard.set(): Cannot empty the Clipboard" << std::endl;
return;
}
// Get the currently selected data
//std::cout << "this is causing a crash somewhere: sizeof(text):" << sizeof(text) << " text.length():" << text.length();
HGLOBAL hGlob = GlobalAlloc(GMEM_MOVEABLE, text.size()+1);
//strcpy_s((char*)hGlob, 64, text.c_str());
if (!hGlob)
{
std::cout << "Clipboard.set(): could not allocate hGlob" << std::endl;
CloseClipboard();
return;
}
memcpy(GlobalLock(hGlob),text.c_str(),text.size()+1);
GlobalUnlock(hGlob);
// For the appropriate data formats...
if ( ::SetClipboardData( CF_TEXT, hGlob ) == NULL )
{
std::cout << "Clipboard.set(): Unable to set Clipboard data, error: " << GetLastError() << std::endl;
//CString msg;
//msg.Format(_T("Unable to set Clipboard data, error: %d"), GetLastError());
//AfxMessageBox( msg );
CloseClipboard();
GlobalFree(hGlob);
return;
}
CloseClipboard();
get_instance()->__text = text;
}
void Copy( const char * data, int len )
{
HWND hWnd = GetForegroundWindow();
if (!::OpenClipboard( hWnd ))
return;
EmptyClipboard();
HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE,(len + 1) * sizeof(WCHAR));
WCHAR * pMem = (WCHAR*)GlobalLock(h);
ZeroMemory( pMem, (len + 1) * sizeof(WCHAR) );
CopyMemory( pMem, data, (len + 1) * sizeof(WCHAR) );
GlobalUnlock(h);
SetClipboardData(CF_TEXT,h);
CloseClipboard();
}
static bool win_set_clipboard_text(ALLEGRO_DISPLAY *display, const char *text)
{
HWND handle = get_window_handle(display);
HANDLE hMem = NULL;
wchar_t *tstr = NULL;
size_t size;
size_t len;
LPTSTR dst;
if (!OpenClipboard(handle)) {
ALLEGRO_DEBUG("Could not open clipboard for handle %p", handle);
return false;
}
/* Convert the text from UTF-8 to Windows Unicode */
tstr = _al_win_utf16(text);
len = wcslen(tstr);
size = (len+1) * sizeof(wchar_t);
/* Save the data to the clipboard */
hMem = GlobalAlloc(GMEM_MOVEABLE, size);
if (!hMem) {
al_free(tstr);
ALLEGRO_DEBUG("GlobalAlloc failed to allocate memory for the clipboard data");
return false;
}
dst = (LPTSTR)GlobalLock(hMem);
/* Copy the text over. Unlike SDL, do NOT convert newlines, that's for the
* use to decide. */
memmove(dst, tstr, size);
dst[len] = 0;
GlobalUnlock(hMem);
EmptyClipboard();
if (!SetClipboardData(TEXT_FORMAT, hMem)) {
al_free(tstr);
ALLEGRO_DEBUG("Couldn't set clipboard data");
return false;
}
al_free(tstr);
CloseClipboard();
return true;
}
BOOL CopyTextToClipboard(HWND hwnd, const std::wstring &wtext) {
OpenClipboard(hwnd);
EmptyClipboard();
HANDLE hglbCopy = GlobalAlloc(GMEM_MOVEABLE, (wtext.size() + 1) * sizeof(wchar_t));
if (hglbCopy == NULL) {
CloseClipboard();
return FALSE;
}
// Lock the handle and copy the text to the buffer.
wchar_t *lptstrCopy = (wchar_t *)GlobalLock(hglbCopy);
wcscpy(lptstrCopy, wtext.c_str());
lptstrCopy[wtext.size()] = (wchar_t) 0; // null character
GlobalUnlock(hglbCopy);
SetClipboardData(CF_UNICODETEXT, hglbCopy);
CloseClipboard();
return TRUE;
}
void SetClipboard(const tstring& sBuf)
{
if (!OpenClipboard(NULL))
return;
EmptyClipboard();
HGLOBAL hClipboard;
hClipboard = GlobalAlloc(GMEM_MOVEABLE, sBuf.length()+1);
char* pszBuffer = (char*)GlobalLock(hClipboard);
strcpy(pszBuffer, LPCSTR(sBuf.c_str()));
GlobalUnlock(hClipboard);
SetClipboardData(CF_TEXT, hClipboard);
CloseClipboard();
}
HRESULT cdecl LogFlush(HWND hwnd)
{
int i;
HGLOBAL hGlobalMemory=NULL;
TCHAR *lpGlobalMemory=NULL;
OpenClipboard(hwnd);
EmptyClipboard();
hGlobalMemory=GlobalAlloc(GHND, (DWORD) (gLoggerPointer + 1)*sizeof(TCHAR));
lpGlobalMemory=(TCHAR *)GlobalLock(hGlobalMemory);
for(i=0;i<gLoggerPointer;i++)
*lpGlobalMemory++=gLoggerArray[i];
SetClipboardData(CF_TEXT,hGlobalMemory);
CloseClipboard();
return(NOERROR);
}
bool Clipboard::Set(const Clipboard* clipboard, HWND fallback_owner) {
auto fallback = false;
if (!OpenClipboard(clipboard->owner())) {
if (!OpenClipboard(fallback_owner))
return false;
fallback = true;
}
if (!EmptyClipboard()) {
CloseClipboard();
return false;
}
for (auto& pair : *clipboard) {
const auto& format_id = pair.first;
if (fallback && format_id == CF_OWNERDISPLAY)
continue;
auto& format = pair.second;
auto handle = GlobalAlloc(GMEM_MOVEABLE, format->size());
if (handle == NULL)
continue;
auto failed = true;
auto memory = GlobalLock(handle);
if (memory != nullptr) {
memcpy(memory, format->Get(), format->size());
GlobalUnlock(memory);
if (SetClipboardData(format_id, handle) != NULL)
failed = false;
}
if (failed)
GlobalFree(handle);
}
CloseClipboard();
return true;
}
/// copy text onto the clipboard.
// @param text the text
// @function set_clipboard
def set_clipboard(Str text) {
HGLOBAL glob;
LPWSTR p;
int bufsize = 3*strlen(text);
if (! OpenClipboard(NULL)) {
return push_error(L);
}
EmptyClipboard();
glob = GlobalAlloc(GMEM_MOVEABLE, bufsize);
p = (LPWSTR)GlobalLock(glob);
wstring_buff(text,p,bufsize);
GlobalUnlock(glob);
if (SetClipboardData(CF_UNICODETEXT,glob) == NULL) {
CloseClipboard();
return push_error(L);
}
CloseClipboard();
return 0;
}
PUBLIC void
put_scrap(int type, int srclen, char *src)
{
scrap_type format;
int dstlen;
char *dst;
format = convert_format(type);
dstlen = convert_data(type, NULL, src, srclen);
#if defined(X11_SCRAP)
/* * */
dst = (char *)alloca(dstlen);
if ( dst != NULL )
{
convert_data(type, dst, src, srclen);
XChangeProperty(SDL_Display, DefaultRootWindow(SDL_Display),
XA_CUT_BUFFER0, format, 8, PropModeReplace,
(unsigned char *) dst, dstlen);
if ( we_lost_clipboard() )
XSetSelectionOwner(SDL_Display, XA_PRIMARY, SDL_Window, CurrentTime);
}
#elif defined(WIN_SCRAP)
/* * */
if ( OpenClipboard(SDL_Window) )
{
HANDLE hMem;
hMem = GlobalAlloc((GMEM_MOVEABLE|GMEM_DDESHARE), dstlen);
if ( hMem != NULL )
{
dst = (char *)GlobalLock(hMem);
convert_data(type, dst, src, srclen);
GlobalUnlock(hMem);
EmptyClipboard();
SetClipboardData(format, hMem);
}
CloseClipboard();
}
#endif /* scrap type */
}
void CLogGraph::CopyToClipboard()
{
if (!m_bDragSel)return;
if ( !OpenClipboard() )
{
AfxMessageBox( "Cannot open the Clipboard" );
return;
}
if( !EmptyClipboard() )
{
AfxMessageBox( "Cannot empty the Clipboard" );
return;
}
int size = m_pDataEt - m_pDataSt;
tdata* p = m_pDataSt;
CString strsum = "";
CString str;
for (int i = 0; i<size; i++)
{
str.Format("%s, %d\r\n", tformat("%Y-%m-%d %H:%M:%S", p->time), p->temp/100);
strsum += str;
p++;
}
HGLOBAL hGlobal = GlobalAlloc( GHND | GMEM_SHARE, (strsum.GetLength() + 1) *sizeof(TCHAR) );
PSTR pGlobal = (PSTR)GlobalLock( hGlobal );
lstrcpy( pGlobal, TEXT( strsum ) );
GlobalUnlock( hGlobal );
if ( ::SetClipboardData( CF_TEXT, hGlobal ) == NULL )
{
AfxMessageBox( "Unable to set Clipboard data" );
CloseClipboard();
return;
}
CloseClipboard();
}
// CopyToClipBoard ////////////////////////////////////////////////////////1.00
// 選択されている範囲があれば、
// それをコピーしてクリップボードに渡す。
int
ClassABrowserView::CopyToClipboard()
{
if (!dwQuerySize)
return 0;
// メモリを確保してクリップボード用のデータを作成
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, dwQuerySize);
char* pstr = (char*)GlobalLock(hMem);
QueryGenerate(pstr);
GlobalUnlock(hMem);
OpenClipboard(hWnd);
EmptyClipboard();
SetClipboardData(CF_TEXT, hMem);
CloseClipboard();
return 0;
}
INT_PTR CALLBACK DialogProc(HWND hwndDlg,UINT uMsg,WPARAM wParam,LPARAM lParam) {
size_t i;
switch (uMsg) {
case WM_INITDIALOG:
SendMessage(hwndDlg, WM_SETICON, 0, 0);
for (i = 0; i < sizeof(primary)/sizeof(line); i++)
SendDlgItemMessage(hwndDlg, IDC_PRIMARY, CB_ADDSTRING, 0, (LPARAM)primary[i].name);
for (i = 0; i < sizeof(sub)/sizeof(line); i++)
SendDlgItemMessage(hwndDlg, IDC_SUB, CB_ADDSTRING, 0, (LPARAM)sub[i].name);
break;
case WM_COMMAND:
if (LOWORD(wParam) == IDCANCEL) {
EndDialog(hwndDlg, 0);
PostQuitMessage(0);
}
else if (HIWORD(wParam) == CBN_SELCHANGE) {
if (SendDlgItemMessage(hwndDlg, IDC_PRIMARY, CB_GETCURSEL, 0, 0) != CB_ERR && SendDlgItemMessage(hwndDlg, IDC_SUB, CB_GETCURSEL, 0, 0) != CB_ERR) {
TCHAR lang[512];
wsprintf(lang, _T("Language ID: %d"), MAKELANGID(primary[SendDlgItemMessage(hwndDlg, IDC_PRIMARY, CB_GETCURSEL, 0, 0)].id, sub[SendDlgItemMessage(hwndDlg, IDC_SUB, CB_GETCURSEL, 0, 0)].id));
SetDlgItemText(hwndDlg, IDC_RESULT, lang);
}
}
else if (LOWORD(wParam) == IDOK) {
if (SendDlgItemMessage(hwndDlg, IDC_PRIMARY, CB_GETCURSEL, 0, 0) != CB_ERR && SendDlgItemMessage(hwndDlg, IDC_SUB, CB_GETCURSEL, 0, 0) != CB_ERR) {
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, 16*sizeof(TCHAR));
if (!hMem) return 0;
TCHAR *lang_id = (TCHAR *)GlobalLock(hMem);
wsprintf(lang_id, _T("%u"), MAKELANGID(primary[SendDlgItemMessage(hwndDlg, IDC_PRIMARY, CB_GETCURSEL, 0, 0)].id, sub[SendDlgItemMessage(hwndDlg, IDC_SUB, CB_GETCURSEL, 0, 0)].id));
GlobalUnlock(hMem);
if (!OpenClipboard(hwndDlg)) return 0;
EmptyClipboard();
#ifdef _UNICODE
SetClipboardData(CF_UNICODETEXT,hMem);
#else
SetClipboardData(CF_TEXT,hMem);
#endif
CloseClipboard();
}
}
break;
}
return 0;
}
void IntegerToRoman::OnBnClickedButton3()
{
// TODO: 在此添加控件通知处理程序代码
CString source;
GetDlgItem(IDC_EDIT2)->GetWindowTextA(source);
//文本内容保存在source变量中
if(OpenClipboard())
{
HGLOBAL clipbuffer;
char * buffer;
EmptyClipboard();
clipbuffer = GlobalAlloc(GMEM_DDESHARE, source.GetLength()+1);
buffer = (char*)GlobalLock(clipbuffer);
strcpy(buffer, LPCSTR(source));
GlobalUnlock(clipbuffer);
SetClipboardData(CF_TEXT,clipbuffer);
CloseClipboard();
}
}
void CLeashDebugWindow::OnCopyToClipboard()
{
if (!OpenClipboard())
{
MessageBox("Unable to open Clipboard!", "Error", MB_OK);
return;
}
EmptyClipboard();
int maxItems = m_debugListBox.GetCount();
const int MAX_MEM = maxItems * 90; // 90 chars per line seems safe like a safe bet
HGLOBAL hDebugText = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, MAX_MEM);
if (NULL != hDebugText)
{
CString listboxItem;
LPSTR pDebugText = (LPSTR) GlobalLock(hDebugText);
if (!pDebugText)
{
MessageBox("Unable to write to Clipboard!", "Error", MB_OK);
ASSERT(pDebugText);
return;
}
*pDebugText = 0;
for (int xItem = 0; xItem < maxItems; xItem++)
{
m_debugListBox.GetText(xItem, listboxItem);
strcat(pDebugText, listboxItem);
strcat(pDebugText, "\r\n");
}
GlobalUnlock(hDebugText);
}
if (NULL != hDebugText)
SetClipboardData(CF_TEXT, hDebugText);
CloseClipboard();
MessageBox("Copy to Clipboard was Successful!\r\n Paste it in your favorite editor.",
"Note", MB_OK);
}
BOOL WINAPI EditCopy( HWND hDlg )
{
LPTSTR lptstrCopy;
HGLOBAL hglbCopy;
// Open the clipboard, and empty it.
if (!OpenClipboard(hDlg))
return FALSE;
EmptyClipboard();
if (hDlg)
{
long count, item;
count = ListView_GetSelectedCount( GetDlgItem(hDlg, IDC_FILEVIEW) );
if ( count ){
char string[LINELEN];
HWND hlist = GetDlgItem(hDlg, IDC_FILEVIEW);
hglbCopy = GlobalAlloc(GMEM_MOVEABLE, (count*LINELEN) * sizeof(TCHAR));
lptstrCopy = (LPTSTR)GlobalLock(hglbCopy);
if ( lptstrCopy ){
lptstrCopy[0] = 0;
item = ListView_GetNextItem( hlist, -1 , LVNI_SELECTED );
while( item != -1 ){
ListView_GetItemText( hlist, item, 0, string, LINELEN );
strcat( lptstrCopy, string );
strcat( lptstrCopy, "\r\n" );
item = ListView_GetNextItem( hlist, item , LVNI_SELECTED );
}
}
GlobalUnlock(hglbCopy);
SetClipboardData(CF_TEXT, hglbCopy);
}
}
// Close the clipboard.
CloseClipboard();
return TRUE;
}
BOOL CUtils::SetClipboardText(const CString& text)
{
if (!OpenClipboard())
return FALSE;
const int nLength = text.GetLength() + 1;
const HGLOBAL hClipboard = GlobalAlloc(GHND, nLength);
if (!hClipboard)
return FALSE;
const LPVOID pMem = GlobalLock(hClipboard);
memcpy(pMem, LPCTSTR(text), nLength);
GlobalUnlock(hClipboard);
EmptyClipboard();
if (SetClipboardData(CF_TEXT, hClipboard) == NULL) {
CloseClipboard();
return FALSE;
}
CloseClipboard();
return TRUE;
}
void do_copy_paste()
{
if (!OpenClipboard(g_hwnd)) return;
/*or we are editing text and clipboard is not empty*/
if (IsClipboardFormatAvailable(CF_TEXT) && (gf_term_paste_text(term, NULL, 1)==GF_OK)) {
HGLOBAL hglbCopy = GetClipboardData(CF_TEXT);
if (hglbCopy) {
#ifdef _WIN32_WCE
char szString[1024];
LPCTSTR paste_string = (LPCTSTR) GlobalLock(hglbCopy);
CE_WideToChar((u16 *) paste_string, szString);
gf_term_paste_text(term, szString, 0);
#else
char *szString = (char *)GlobalLock(hglbCopy);
gf_term_paste_text(term, szString, 0);
#endif
GlobalUnlock(hglbCopy);
}
}
/*we have something to copy*/
else if (gf_term_get_text_selection(term, 1)!=NULL) {
u32 len;
const char *text = gf_term_get_text_selection(term, 0);
if (text && strlen(text)) {
EmptyClipboard();
len = strlen(text);
#ifdef _WIN32_WCE
HGLOBAL hglbCopy = GlobalAlloc(GMEM_MOVEABLE, (len + 1) * sizeof(u16));
LPCTSTR new_string = (LPCTSTR) GlobalLock(hglbCopy);
CE_CharToWide((char*)text, (u16*)new_string);
#else
HGLOBAL hglbCopy = GlobalAlloc(GMEM_MOVEABLE, (len + 1) * sizeof(u8));
char *new_string = (char*) GlobalLock(hglbCopy);
strcpy(new_string, text);
#endif
GlobalUnlock(hglbCopy);
SetClipboardData(CF_TEXT, hglbCopy);
}
}
CloseClipboard();
}
void copy_rect_to_clipboard(HWND hwnd, RECT *rt)
{
int width = rt->right - rt->left;
int height = rt->bottom - rt->top;
HDC hdc = GetDC(hwnd);
HDC mem_dc = CreateCompatibleDC(hdc);
HBITMAP bitmap = CreateCompatibleBitmap(hdc, width, height);
SelectObject(mem_dc, bitmap);
BitBlt(mem_dc, 0, 0, width, height, hdc, rt->left, rt->top, SRCCOPY);
OpenClipboard(hwnd);
EmptyClipboard();
SetClipboardData(CF_BITMAP, bitmap);
DeleteObject(bitmap);
DeleteDC(mem_dc);
ReleaseDC(hwnd, hdc);
}
