Пример #1
0
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;

}
Пример #2
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;
}
Пример #3
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);
        }
    }  
}
Пример #5
0
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);
    }
}
Пример #7
0
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;
}
Пример #8
0
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());
}
Пример #9
0
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;
}
Пример #10
0
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;
}
Пример #11
0
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;
}
Пример #12
0
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;
}
Пример #13
0
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());
}
Пример #14
0
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;
}
Пример #15
0
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;
}
Пример #16
0
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;
}
Пример #17
0
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);
}
Пример #18
0
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;
}
Пример #19
0
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;
}
Пример #20
0
/*
 * 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;
}
Пример #21
0
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;
}
Пример #22
0
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;
}
Пример #23
0
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;
}
Пример #24
0
/**
 * クリップボードのデータをすべて取得する。
 *
 * 取得したデータはすぐに複製を取っておく。
 * このデータは #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;
}
Пример #25
0
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;
}
Пример #26
0
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;
}
Пример #27
0
/*!
	クリップボードのデータをいただく・同じモノが、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;
}
Пример #28
0
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;
}
Пример #29
0
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);
}
Пример #30
0
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;
}