C++ CClipboard类代码示例

bool ClipboardSetText(HWND owner, const UString &s)
{
  CClipboard clipboard;
  if (!clipboard.Open(owner))
    return false;
#ifdef _WIN32
  if (!::EmptyClipboard())
    return false;

  bool res;
  res = ClipboardSetData(CF_UNICODETEXT, (const wchar_t *)s, (s.Length() + 1) * sizeof(wchar_t));
  #ifndef _UNICODE
  AString a;
  a = UnicodeStringToMultiByte(s, CP_ACP);
  res |=  ClipboardSetData(CF_TEXT, (const char *)a, (a.Length() + 1) * sizeof(char));
  a = UnicodeStringToMultiByte(s, CP_OEMCP);
  res |=  ClipboardSetData(CF_OEMTEXT, (const char *)a, (a.Length() + 1) * sizeof(char));
  #endif
  return res;
#else
  wxTheClipboard->Clear();
  // This data objects are held by the clipboard,
  // so do not delete them in the app.
  wxString ws(s);
  wxTheClipboard->SetData( new wxTextDataObject(ws) );
  return true;
#endif
}

// TODO: there's some integer -> char encoding going on here. i find it 
// hard to believe that the clipboard is the only thing doing this. maybe
// we should refactor this stuff out of the clipboard.
TEST(CClipboardTests, marshall_withTextSize285_sizeCharsValid)
{
	// 285 chars
	CString data;
	data.append("Synergy is Free and Open Source Software that lets you ");
	data.append("easily share your mouse and keyboard between multiple ");
	data.append("computers, where each computer has it's own display. No ");
	data.append("special hardware is required, all you need is a local area ");
	data.append("network. Synergy is supported on Windows, Mac OS X and Linux.");

	CClipboard clipboard;
	clipboard.open(0);
	clipboard.add(IClipboard::kText, data);
	clipboard.close();

	CString actual = clipboard.marshall();

	// 4 asserts here, but that's ok because we're really just asserting 1 
	// thing. the 32-bit size value is split into 4 chars. if the size is 285
	// (29 more than the 8-bit max size), the last char "rolls over" to 29 
	// (this is caused by a bit-wise & on 0xff and 8-bit truncation). each 
	// char before the last stores a bit-shifted version of the number, each 
	// 1 more power than the last, which is done by bit-shifting [0] by 24, 
	// [1] by 16, [2] by 8 ([3] is not bit-shifted).
	EXPECT_EQ(0, actual[8]); // 285 >> 24 = 285 / (256^3) = 0
	EXPECT_EQ(0, actual[9]); // 285 >> 16 = 285 / (256^2) = 0
	EXPECT_EQ(1, actual[10]); // 285 >> 8 = 285 / (256^1) = 1(.11328125)
	EXPECT_EQ(29, actual[11]); // 285 - 256 = 29
}

int CPreGame::KeyPressed(unsigned short k,bool isRepeat)
{
	if (k == SDLK_ESCAPE){
		if(keys[SDLK_LSHIFT]){
			logOutput.Print("User exited");
			globalQuit=true;
		} else
			logOutput.Print("Use shift-esc to quit");
	}
	if(showList){					//are we currently showing a list?
		showList->KeyPressed(k, isRepeat);
		return 0;
	}

	if (userWriting){
		keys[k] = true;
		if (k == SDLK_v && keys[SDLK_LCTRL]){
			CClipboard clipboard;
			userInput += clipboard.GetContents();
			return 0;
		}
		if(k == SDLK_BACKSPACE){ //backspace
			if(userInput.size()!=0)
				userInput.erase(userInput.size()-1,1);
			return 0;
		}
		if(k == SDLK_RETURN){
			userWriting=false;
			return 0;
		}
		return 0;
	}

	return 0;
}

/*
-----------------------------------------------------------------------------

-----------------------------------------------------------------------------
*/
void CShowString::HandleViewCommandL(TInt aCommand)
    {
    switch(aCommand)
        {
		case ESSCopyClipBoard:
			if(iString)
			{
				CClipboard* cb = CClipboard::NewForWritingLC(CCoeEnv::Static()->FsSession());
				
				cb->StreamDictionary().At(KClipboardUidTypePlainText);
				
				CPlainText* BPlainText = CPlainText::NewL();
				CleanupStack::PushL(BPlainText);
				
				BPlainText->InsertL(0,iString->Des());
				
				BPlainText->CopyToStoreL(cb->Store(),cb->StreamDictionary(),0,BPlainText->DocumentLength());
				
				CleanupStack::PopAndDestroy(); // CBPlainText
				cb->CommitL();
				CleanupStack::PopAndDestroy(); // cb
			}
			break;
        };
    }

void CGameController::PasteClipboard()
{
	CClipboard clipboard;
	const std::string text = clipboard.GetContents();
	userInput.insert(writingPos, text);
	writingPos += text.length();
}

int CPreGame::KeyPressed(unsigned short k,bool isRepeat)
{
    if (k == SDLK_ESCAPE) {
        if(keys[SDLK_LSHIFT]) {
            logOutput.Print("User exited");
            globalQuit=true;
        } else
            logOutput.Print("Use shift-esc to quit");
    }
    if(showList) {					//are we currently showing a list?
        showList->KeyPressed(k, isRepeat);
        return 0;
    }

    if (userWriting) {
        keys[k] = true;
        if (k == SDLK_v && keys[SDLK_LCTRL]) {
            CClipboard clipboard;
            const string text = clipboard.GetContents();
            userInput.insert(writingPos, text);
            writingPos += text.length();
            return 0;
        }
        if(k == SDLK_BACKSPACE) {
            if (!userInput.empty() && (writingPos > 0)) {
                userInput.erase(writingPos - 1, 1);
                writingPos--;
            }
            return 0;
        }
        if(k == SDLK_DELETE) {
            if (!userInput.empty() && (writingPos < (int)userInput.size())) {
                userInput.erase(writingPos, 1);
            }
            return 0;
        }
        else if(k==SDLK_LEFT) {
            writingPos = max(0, min((int)userInput.length(), writingPos - 1));
        }
        else if(k==SDLK_RIGHT) {
            writingPos = max(0, min((int)userInput.length(), writingPos + 1));
        }
        else if(k==SDLK_HOME) {
            writingPos = 0;
        }
        else if(k==SDLK_END) {
            writingPos = (int)userInput.length();
        }
        if(k == SDLK_RETURN) {
            userWriting=false;
            return 0;
        }
        return 0;
    }

    return 0;
}

void
CPrimaryClient::setClipboard(ClipboardID id, const IClipboard* clipboard)
{
	LOG((CLOG_INFO "xCprimaryClient::setClipboard call. Name: %s", getName().c_str()));
	// ignore if this clipboard is already clean
	if (m_clipboardDirty[id]) {
		// this clipboard is now clean
		m_clipboardDirty[id] = false;
	CClipboard Clipboard;
	Clipboard.copy(&Clipboard,clipboard); 
	Clipboard.open(0);
			CString content, new_content;
			if(Clipboard.has(IClipboard::kFilePath)) 
			{
				CString prefix, source;
				content = Clipboard.get(IClipboard::kFilePath);
				size_t pos = content.find("\n");
				source = content.substr(0,pos);
				//content = content.substr(pos+1, content.size());
				CScreenMounts *map = ((CServerApp*) &ARCH->app())->args().m_config->getMounts(source, getName());
				LOG((CLOG_INFO "X_PAS1 setClipboard: %s %s",source.c_str(), content.c_str()));
				
				if (map!=NULL && !map->empty())
				{
					while (pos < content.size())
					{
						++pos;
						CString line = content.substr(pos, content.find("\n", pos)-pos+1);
						pos = content.find("\n", pos);
						LOG ((CLOG_INFO "X_PAS2 The line is: %s\n", line.c_str()));
						for( CScreenMounts::iterator it = map->begin(); it != map->end(); it++)
						{
							int p = line.find(it->first);
							
							if( p != std::string::npos)
							{
								line = it->second + line.substr(p + it->first.size() );
								
								break;
							}
						}
						LOG ((CLOG_INFO "it changed to: %s\n", line.c_str()));
						new_content.append(line);
					}
					Clipboard.add(IClipboard::kFilePath, new_content);
					LOG((CLOG_INFO "X_PAS3 setClipboard: %s %s",source.c_str(), Clipboard.get(IClipboard::kFilePath).c_str()));
				}
				LOG((CLOG_INFO "X_PAS4 Changed2 clipboard: %s", new_content.c_str()));
			}		
			Clipboard.close();
		// set clipboard
		m_screen->setClipboard(id, &Clipboard);
	}
}

bool ClipboardSetText(HWND owner, const UString &s)
{
  CClipboard clipboard;
  if (!clipboard.Open(owner))
    return false;
  if (!::EmptyClipboard())
    return false;

  bool res;
  res = ClipboardSetData(CF_UNICODETEXT, (const wchar_t *)s, (s.Length() + 1) * sizeof(wchar_t));
  #ifndef _UNICODE
  AString a;
  a = UnicodeStringToMultiByte(s, CP_ACP);
  res |=  ClipboardSetData(CF_TEXT, (const char *)a, (a.Length() + 1) * sizeof(char));
  a = UnicodeStringToMultiByte(s, CP_OEMCP);
  res |=  ClipboardSetData(CF_OEMTEXT, (const char *)a, (a.Length() + 1) * sizeof(char));
  #endif
  return res;
}

const QMimeData* QClipboard::mimeData(Mode mode) const
{
    if (mode != Clipboard) return 0;
    QClipboardData *d = clipboardData();
    bool dataExists(false);
    if (d)
    {
        TRAPD(err,{
            RFs fs = qt_s60GetRFs();
            CClipboard* cb = CClipboard::NewForReadingLC(fs);
            Q_ASSERT(cb);
            //stream for qt
            RStoreReadStream stream;
            TStreamId stid = (cb->StreamDictionary()).At(KQtCbDataStream);
            if (stid != 0) {
                stream.OpenLC(cb->Store(),stid);
                QT_TRYCATCH_LEAVING(readFromStreamLX(d->source(),stream));
                CleanupStack::PopAndDestroy(&stream);
                dataExists = true;
            }
            else {
                //symbian clipboard
                RStoreReadStream symbianStream;
                TStreamId symbianStId = (cb->StreamDictionary()).At(KClipboardUidTypePlainText);
                if (symbianStId != 0) {
                    symbianStream.OpenLC(cb->Store(), symbianStId);
                    QT_TRYCATCH_LEAVING(readSymbianStoreLX(d->source(), cb));
                    CleanupStack::PopAndDestroy(&symbianStream);
                    dataExists = true;
                }
            }
            CleanupStack::PopAndDestroy(cb);
        });
        if (err != KErrNone){
            qDebug()<< "clipboard is empty/err: " << err;
        }

        if (dataExists) {
            return d->source();
        }
    }