Index: /trunk/include/VBox/GuestHost/SharedClipboard-win.h =================================================================== --- /trunk/include/VBox/GuestHost/SharedClipboard-win.h (revision 80663) +++ /trunk/include/VBox/GuestHost/SharedClipboard-win.h (revision 80664) @@ -52,22 +52,22 @@ #endif -#define VBOX_CLIPBOARD_WNDCLASS_NAME "VBoxSharedClipboardClass" +#define SHCL_WIN_WNDCLASS_NAME "VBoxSharedClipboardClass" /** See: https://docs.microsoft.com/en-us/windows/desktop/dataxchg/html-clipboard-format * Do *not* change the name, as this will break compatbility with other (legacy) applications! */ -#define VBOX_CLIPBOARD_WIN_REGFMT_HTML "HTML Format" +#define SHCL_WIN_REGFMT_HTML "HTML Format" /** Default timeout (in ms) for passing down messages down the clipboard chain. */ -#define VBOX_CLIPBOARD_CBCHAIN_TIMEOUT_MS 5000 +#define SHCL_WIN_CBCHAIN_TIMEOUT_MS 5000 /** Reports clipboard formats. */ -#define VBOX_CLIPBOARD_WM_REPORT_FORMATS WM_USER +#define SHCL_WIN_WM_REPORT_FORMATS WM_USER /** Reads data from the clipboard and sends it to the destination. */ -#define VBOX_CLIPBOARD_WM_READ_DATA WM_USER + 1 +#define SHCL_WIN_WM_READ_DATA WM_USER + 1 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST /** Starts a reading transfer from the guest. */ -# define VBOX_CLIPBOARD_WM_URI_START_READ WM_USER + 2 +# define SHCL_WIN_WM_URI_START_READ WM_USER + 2 /** Starts a writing transfer to the guest. */ -# define VBOX_CLIPBOARD_WM_URI_START_WRITE WM_USER + 3 +# define SHCL_WIN_WM_URI_START_WRITE WM_USER + 3 #endif @@ -106,9 +106,9 @@ { /** Window handle of our (invisible) clipbaord window. */ - HWND hWnd; + HWND hWnd; /** Window handle which is next to us in the clipboard chain. */ - HWND hWndNextInChain; + HWND hWndNextInChain; /** Window handle of the clipboard owner *if* we are the owner. */ - HWND hWndClipboardOwnerUs; + HWND hWndClipboardOwnerUs; /** Structure for maintaining the new clipboard API. */ SHCLWINAPINEW newAPI; @@ -117,37 +117,37 @@ } SHCLWINCTX, *PSHCLWINCTX; -int VBoxClipboardWinOpen(HWND hWnd); -int VBoxClipboardWinClose(void); -int VBoxClipboardWinClear(void); - -int VBoxClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI); -bool VBoxClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI); - -int VBoxClipboardWinChainAdd(PSHCLWINCTX pCtx); -int VBoxClipboardWinChainRemove(PSHCLWINCTX pCtx); -VOID CALLBACK VBoxClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult); -LRESULT VBoxClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam); - -SHCLFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat); -int VBoxClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats); +int SharedClipboardWinOpen(HWND hWnd); +int SharedClipboardWinClose(void); +int SharedClipboardWinClear(void); + +int SharedClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI); +bool SharedClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI); + +int SharedClipboardWinChainAdd(PSHCLWINCTX pCtx); +int SharedClipboardWinChainRemove(PSHCLWINCTX pCtx); +VOID CALLBACK SharedClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult); +LRESULT SharedClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam); + +SHCLFORMAT SharedClipboardWinClipboardFormatToVBox(UINT uFormat); +int SharedClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList); -#endif - -int VBoxClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue); -bool VBoxClipboardWinIsCFHTML(const char *pszSource); -int VBoxClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput); -int VBoxClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput); - -LRESULT VBoxClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); -int VBoxClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx); -int VBoxClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd); -int VBoxClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx); - -int VBoxClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats); +int SharedClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList); +#endif + +int SharedClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue); +bool SharedClipboardWinIsCFHTML(const char *pszSource); +int SharedClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput); +int SharedClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput); + +LRESULT SharedClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); +int SharedClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx); +int SharedClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd); +int SharedClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx); + +int SharedClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer); -void VBoxClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer); +int SharedClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer); +void SharedClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer); #endif @@ -158,5 +158,5 @@ # endif -class VBoxClipboardWinDataObject : public IDataObject //, public IDataObjectAsyncCapability +class SharedClipboardWinDataObject : public IDataObject //, public IDataObjectAsyncCapability { public: @@ -170,7 +170,7 @@ public: - VBoxClipboardWinDataObject(PSHCLURITRANSFER pTransfer, - LPFORMATETC pFormatEtc = NULL, LPSTGMEDIUM pStgMed = NULL, ULONG cFormats = 0); - virtual ~VBoxClipboardWinDataObject(void); + SharedClipboardWinDataObject(PSHCLURITRANSFER pTransfer, + LPFORMATETC pFormatEtc = NULL, LPSTGMEDIUM pStgMed = NULL, ULONG cFormats = 0); + virtual ~SharedClipboardWinDataObject(void); public: /* IUnknown methods. */ @@ -235,5 +235,5 @@ { /** Relative path of the object. */ - Utf8Str strPath; + Utf8Str strPath; /** Related (cached) object information. */ SHCLFSOBJINFO objInfo; @@ -248,5 +248,5 @@ LPFORMATETC m_pFormatEtc; LPSTGMEDIUM m_pStgMedium; - PSHCLURITRANSFER m_pTransfer; + PSHCLURITRANSFER m_pTransfer; IStream *m_pStream; ULONG m_uObjIdx; @@ -262,10 +262,10 @@ }; -class VBoxClipboardWinEnumFormatEtc : public IEnumFORMATETC -{ -public: - - VBoxClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats); - virtual ~VBoxClipboardWinEnumFormatEtc(void); +class SharedClipboardWinEnumFormatEtc : public IEnumFORMATETC +{ +public: + + SharedClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats); + virtual ~SharedClipboardWinEnumFormatEtc(void); public: /* IUnknown methods. */ @@ -299,11 +299,11 @@ * through HGCM. Needed on Windows hosts and guests. */ -class VBoxClipboardWinStreamImpl : public IStream -{ -public: - - VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, - const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo); - virtual ~VBoxClipboardWinStreamImpl(void); +class SharedClipboardWinStreamImpl : public IStream +{ +public: + + SharedClipboardWinStreamImpl(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, + const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo); + virtual ~SharedClipboardWinStreamImpl(void); public: /* IUnknown methods. */ @@ -329,20 +329,20 @@ public: /* Own methods. */ - static HRESULT Create(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, const Utf8Str &strPath, + static HRESULT Create(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo, IStream **ppStream); private: /** Pointer to the parent data object. */ - VBoxClipboardWinDataObject *m_pParent; + SharedClipboardWinDataObject *m_pParent; /** The stream object's current reference count. */ LONG m_lRefCount; /** Pointer to the associated URI transfer. */ - PSHCLURITRANSFER m_pURITransfer; + PSHCLURITRANSFER m_pURITransfer; /** The object handle to use. */ - SHCLOBJHANDLE m_hObj; + SHCLOBJHANDLE m_hObj; /** Object path. */ Utf8Str m_strPath; /** (Cached) object information. */ - SHCLFSOBJINFO m_objInfo; + SHCLFSOBJINFO m_objInfo; /** Number of bytes already processed. */ uint64_t m_cbProcessed; @@ -369,5 +369,5 @@ /** Pointer to data object to use for this transfer. * Can be NULL if not being used. */ - VBoxClipboardWinDataObject *pDataObj; + SharedClipboardWinDataObject *pDataObj; }; # endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ Index: /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp =================================================================== --- /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp (revision 80663) +++ /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp (revision 80664) @@ -87,5 +87,5 @@ static SHCLCONTEXT g_Ctx = { NULL }; /** Static window class name. */ -static char s_szClipWndClassName[] = VBOX_CLIPBOARD_WNDCLASS_NAME; +static char s_szClipWndClassName[] = SHCL_WIN_WNDCLASS_NAME; @@ -428,5 +428,5 @@ * Report available formats to the host. */ SHCLFORMATDATA Formats; - int rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats); + int rc = SharedClipboardWinGetFormats(&pCtx->Win, &Formats); if (RT_SUCCESS(rc)) { @@ -442,5 +442,5 @@ { LogFunc(("WM_CHANGECBCHAIN\n")); - lresultRc = VBoxClipboardWinHandleWMChangeCBChain(pWinCtx, hwnd, msg, wParam, lParam); + lresultRc = SharedClipboardWinHandleWMChangeCBChain(pWinCtx, hwnd, msg, wParam, lParam); break; } @@ -455,10 +455,10 @@ /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */ SHCLFORMATDATA Formats; - int rc = VBoxClipboardWinGetFormats(pWinCtx, &Formats); + int rc = SharedClipboardWinGetFormats(pWinCtx, &Formats); if (RT_SUCCESS(rc)) rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats); } - lresultRc = VBoxClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam); + lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam); break; } @@ -466,5 +466,5 @@ case WM_TIMER: { - int rc = VBoxClipboardWinHandleWMTimer(pWinCtx); + int rc = SharedClipboardWinHandleWMTimer(pWinCtx); AssertRC(rc); @@ -485,5 +485,5 @@ const UINT cfFormat = (UINT)wParam; - const SHCLFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat); + const SHCLFORMAT fFormat = SharedClipboardWinClipboardFormatToVBox(cfFormat); LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat)); @@ -492,5 +492,5 @@ { LogFunc(("WM_RENDERFORMAT: Unsupported format requested\n")); - VBoxClipboardWinClear(); + SharedClipboardWinClear(); } else @@ -632,5 +632,5 @@ LogFunc(("WM_RENDERALLFORMATS\n")); - int rc = VBoxClipboardWinHandleWMRenderAllFormats(pWinCtx, hwnd); + int rc = SharedClipboardWinHandleWMRenderAllFormats(pWinCtx, hwnd); AssertRC(rc); @@ -638,5 +638,5 @@ } - case VBOX_CLIPBOARD_WM_REPORT_FORMATS: + case SHCL_WIN_WM_REPORT_FORMATS: { LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n")); @@ -651,8 +651,8 @@ if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */ { - int rc = VBoxClipboardWinOpen(hwnd); + int rc = SharedClipboardWinOpen(hwnd); if (RT_SUCCESS(rc)) { - VBoxClipboardWinClear(); + SharedClipboardWinClear(); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST @@ -665,5 +665,5 @@ if (pTransfer) { - rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer); + rc = SharedClipboardWinURITransferCreate(pWinCtx, pTransfer); /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation @@ -673,12 +673,12 @@ AssertFailedStmt(rc = VERR_NOT_FOUND); - /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */ + /* Note: SharedClipboardWinURITransferCreate() takes care of closing the clipboard. */ } else { #endif - rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats); - - VBoxClipboardWinClose(); + rc = SharedClipboardWinAnnounceFormats(pWinCtx, fFormats); + + SharedClipboardWinClose(); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST } @@ -691,5 +691,5 @@ } - case VBOX_CLIPBOARD_WM_READ_DATA: + case SHCL_WIN_WM_READ_DATA: { /* Send data in the specified format to the host. */ @@ -704,5 +704,5 @@ LogFlowFunc(("VBOX_CLIPBOARD_WM_READ_DATA: uFormat=0x%x\n", uFormat)); - int rc = VBoxClipboardWinOpen(hwnd); + int rc = SharedClipboardWinOpen(hwnd); if (RT_SUCCESS(rc)) { @@ -749,5 +749,5 @@ else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML) { - UINT format = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML); + UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML); if (format != 0) { @@ -777,5 +777,5 @@ LogFunc(("cTransfersRunning=%RU32\n", SharedClipboardURICtxGetRunningTransfers(&pCtx->URI))); - int rc = VBoxClipboardWinOpen(hwnd); + int rc = SharedClipboardWinOpen(hwnd); if (RT_SUCCESS(rc)) { @@ -799,5 +799,5 @@ char *papszList; uint32_t cbList; - rc = VBoxClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList); + rc = SharedClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList); GlobalUnlock(hClip); @@ -840,5 +840,5 @@ } - VBoxClipboardWinClose(); + SharedClipboardWinClose(); } @@ -859,5 +859,5 @@ } - VBoxClipboardWinClose(); + SharedClipboardWinClose(); } break; @@ -871,5 +871,5 @@ SharedClipboardURICtxGetRunningTransfers(&pCtx->URI))); - int rc = VBoxClipboardWinOpen(hwnd); + int rc = SharedClipboardWinOpen(hwnd); if (RT_SUCCESS(rc)) { @@ -893,5 +893,5 @@ char *papszList; uint32_t cbList; - rc = VBoxClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList); + rc = SharedClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList); GlobalUnlock(hClip); @@ -934,5 +934,5 @@ } - VBoxClipboardWinClose(); + SharedClipboardWinClose(); } @@ -989,5 +989,5 @@ if (RT_SUCCESS(rc)) { - rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer); + rc = SharedClipboardWinURITransferCreate(pWinCtx, pTransfer); } } @@ -1004,5 +1004,5 @@ LogFunc(("WM_DESTROY\n")); - int rc = VBoxClipboardWinHandleWMDestroy(pWinCtx); + int rc = SharedClipboardWinHandleWMDestroy(pWinCtx); AssertRC(rc); @@ -1074,6 +1074,6 @@ SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE); - VBoxClipboardWinChainAdd(pWinCtx); - if (!VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI)) + SharedClipboardWinChainAdd(pWinCtx); + if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) pWinCtx->oldAPI.timerRefresh = SetTimer(pWinCtx->hWnd, 0, 10 * 1000 /* 10s */, NULL); } @@ -1146,5 +1146,5 @@ { /* Check if new Clipboard API is available. */ - /* ignore rc */ VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI); + /* ignore rc */ SharedClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI); rc = VbglR3ClipboardConnectEx(&pCtx->CmdCtx); @@ -1268,5 +1268,5 @@ * Forward the information to the window, so it can later * respond to WM_RENDERFORMAT message. */ - ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS, + ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_REPORT_FORMATS, 0 /* wParam */, (LPARAM)pEvent /* lParam */); break; @@ -1276,5 +1276,5 @@ { /* The host needs data in the specified format. */ - ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_READ_DATA, + ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_READ_DATA, 0 /* wParam */, (LPARAM)pEvent /* lParam */); break; Index: /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp =================================================================== --- /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp (revision 80663) +++ /trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp (revision 80664) @@ -21,5 +21,5 @@ * VirtualBox Guest Additions for Haiku. * Copyright (c) 2011 Mike Smith - * François Revol + * Fran�ois Revol * * Permission is hereby granted, free of charge, to any person Index: /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp =================================================================== --- /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp (revision 80663) +++ /trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp (revision 80664) @@ -181,5 +181,5 @@ * @returns VBox status code */ -int VBoxClipboardSvcImplConnect(void) +int SharedClipboardSvcImplConnect(void) { int rc = VINF_SUCCESS; @@ -294,5 +294,5 @@ if (RT_FAILURE(rc)) VBClFatalError(("Failed to connect to the VirtualBox kernel service, rc=%Rrc\n", rc)); - rc = VBoxClipboardSvcImplConnect(); + rc = SharedClipboardSvcImplConnect(); /* Not RT_SUCCESS: VINF_PERMISSION_DENIED is host service not present. */ if (rc == VINF_SUCCESS) Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp (revision 80663) +++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp (revision 80664) @@ -41,6 +41,6 @@ //#define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 0 -VBoxClipboardWinDataObject::VBoxClipboardWinDataObject(PSHCLURITRANSFER pTransfer, - LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats) +SharedClipboardWinDataObject::SharedClipboardWinDataObject(PSHCLURITRANSFER pTransfer, + LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats) : m_enmStatus(Uninitialized) , m_lRefCount(0) @@ -129,5 +129,5 @@ } -VBoxClipboardWinDataObject::~VBoxClipboardWinDataObject(void) +SharedClipboardWinDataObject::~SharedClipboardWinDataObject(void) { RTSemEventDestroy(m_EventListComplete); @@ -153,5 +153,5 @@ */ -STDMETHODIMP_(ULONG) VBoxClipboardWinDataObject::AddRef(void) +STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::AddRef(void) { LONG lCount = InterlockedIncrement(&m_lRefCount); @@ -160,5 +160,5 @@ } -STDMETHODIMP_(ULONG) VBoxClipboardWinDataObject::Release(void) +STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::Release(void) { LONG lCount = InterlockedDecrement(&m_lRefCount); @@ -173,5 +173,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::QueryInterface(REFIID iid, void **ppvObject) +STDMETHODIMP SharedClipboardWinDataObject::QueryInterface(REFIID iid, void **ppvObject) { AssertPtrReturn(ppvObject, E_INVALIDARG); @@ -198,5 +198,5 @@ * @param phGlobal Where to store the allocated HGLOBAL object. */ -int VBoxClipboardWinDataObject::copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal) +int SharedClipboardWinDataObject::copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal) { AssertPtrReturn(phGlobal, VERR_INVALID_POINTER); @@ -229,5 +229,5 @@ * @param strDir Directory path to handle. */ -int VBoxClipboardWinDataObject::readDir(PSHCLURITRANSFER pTransfer, const Utf8Str &strDir) +int SharedClipboardWinDataObject::readDir(PSHCLURITRANSFER pTransfer, const Utf8Str &strDir) { LogFlowFunc(("strDir=%s\n", strDir.c_str())); @@ -309,8 +309,8 @@ * @returns VBox status code. * @param ThreadSelf Thread handle. Unused at the moment. - * @param pvUser Pointer to user-provided data. Of type VBoxClipboardWinDataObject. + * @param pvUser Pointer to user-provided data. Of type SharedClipboardWinDataObject. */ /* static */ -DECLCALLBACK(int) VBoxClipboardWinDataObject::readThread(RTTHREAD ThreadSelf, void *pvUser) +DECLCALLBACK(int) SharedClipboardWinDataObject::readThread(RTTHREAD ThreadSelf, void *pvUser) { RT_NOREF(ThreadSelf); @@ -318,5 +318,5 @@ LogFlowFuncEnter(); - VBoxClipboardWinDataObject *pThis = (VBoxClipboardWinDataObject *)pvUser; + SharedClipboardWinDataObject *pThis = (SharedClipboardWinDataObject *)pvUser; PSHCLURITRANSFER pTransfer = pThis->m_pTransfer; @@ -405,5 +405,5 @@ * @param phGlobal Where to store the allocated HGLOBAL object on success. */ -int VBoxClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLURITRANSFER pTransfer, +int SharedClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLURITRANSFER pTransfer, bool fUnicode, HGLOBAL *phGlobal) { @@ -529,5 +529,5 @@ * @param pMedium */ -STDMETHODIMP VBoxClipboardWinDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium) +STDMETHODIMP SharedClipboardWinDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium) { AssertPtrReturn(pFormatEtc, DV_E_FORMATETC); @@ -564,5 +564,5 @@ { /* Start the transfer asynchronously in a separate thread. */ - rc = SharedClipboardURITransferRun(m_pTransfer, &VBoxClipboardWinDataObject::readThread, this); + rc = SharedClipboardURITransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this); if (RT_SUCCESS(rc)) { @@ -614,7 +614,7 @@ /* Hand-in the provider so that our IStream implementation can continue working with it. */ - hr = VBoxClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer, - fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHCLFSOBJINFO */, - &m_pStream); + hr = SharedClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer, + fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHCLFSOBJINFO */, + &m_pStream); if (SUCCEEDED(hr)) { @@ -650,5 +650,5 @@ * @param pMedium */ -STDMETHODIMP VBoxClipboardWinDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium) +STDMETHODIMP SharedClipboardWinDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium) { RT_NOREF(pFormatEtc, pMedium); @@ -664,5 +664,5 @@ * @param pFormatEtc */ -STDMETHODIMP VBoxClipboardWinDataObject::QueryGetData(LPFORMATETC pFormatEtc) +STDMETHODIMP SharedClipboardWinDataObject::QueryGetData(LPFORMATETC pFormatEtc) { LogFlowFunc(("\n")); @@ -670,5 +670,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut) +STDMETHODIMP SharedClipboardWinDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut) { RT_NOREF(pFormatEtc); @@ -680,5 +680,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease) +STDMETHODIMP SharedClipboardWinDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease) { RT_NOREF(pFormatEtc, pMedium, fRelease); @@ -688,5 +688,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc) +STDMETHODIMP SharedClipboardWinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc) { LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n", dwDirection, m_cFormats, m_pFormatEtc)); @@ -694,5 +694,5 @@ HRESULT hr; if (dwDirection == DATADIR_GET) - hr = VBoxClipboardWinEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc); + hr = SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc); else hr = E_NOTIMPL; @@ -702,5 +702,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink *pAdvSink, DWORD *pdwConnection) +STDMETHODIMP SharedClipboardWinDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink *pAdvSink, DWORD *pdwConnection) { RT_NOREF(pFormatEtc, fAdvise, pAdvSink, pdwConnection); @@ -708,5 +708,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::DUnadvise(DWORD dwConnection) +STDMETHODIMP SharedClipboardWinDataObject::DUnadvise(DWORD dwConnection) { RT_NOREF(dwConnection); @@ -714,5 +714,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise) +STDMETHODIMP SharedClipboardWinDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise) { RT_NOREF(ppEnumAdvise); @@ -725,5 +725,5 @@ */ -STDMETHODIMP VBoxClipboardWinDataObject::EndOperation(HRESULT hResult, IBindCtx *pbcReserved, DWORD dwEffects) +STDMETHODIMP SharedClipboardWinDataObject::EndOperation(HRESULT hResult, IBindCtx *pbcReserved, DWORD dwEffects) { RT_NOREF(hResult, pbcReserved, dwEffects); @@ -731,5 +731,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::GetAsyncMode(BOOL *pfIsOpAsync) +STDMETHODIMP SharedClipboardWinDataObject::GetAsyncMode(BOOL *pfIsOpAsync) { RT_NOREF(pfIsOpAsync); @@ -737,5 +737,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::InOperation(BOOL *pfInAsyncOp) +STDMETHODIMP SharedClipboardWinDataObject::InOperation(BOOL *pfInAsyncOp) { RT_NOREF(pfInAsyncOp); @@ -743,5 +743,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::SetAsyncMode(BOOL fDoOpAsync) +STDMETHODIMP SharedClipboardWinDataObject::SetAsyncMode(BOOL fDoOpAsync) { RT_NOREF(fDoOpAsync); @@ -749,5 +749,5 @@ } -STDMETHODIMP VBoxClipboardWinDataObject::StartOperation(IBindCtx *pbcReserved) +STDMETHODIMP SharedClipboardWinDataObject::StartOperation(IBindCtx *pbcReserved) { RT_NOREF(pbcReserved); @@ -760,5 +760,5 @@ */ -int VBoxClipboardWinDataObject::Init(void) +int SharedClipboardWinDataObject::Init(void) { LogFlowFuncLeaveRC(VINF_SUCCESS); @@ -766,5 +766,5 @@ } -void VBoxClipboardWinDataObject::OnTransferComplete(int rc /* = VINF_SUCESS */) +void SharedClipboardWinDataObject::OnTransferComplete(int rc /* = VINF_SUCESS */) { RT_NOREF(rc); @@ -785,5 +785,5 @@ } -void VBoxClipboardWinDataObject::OnTransferCanceled(void) +void SharedClipboardWinDataObject::OnTransferCanceled(void) { LogFlowFuncEnter(); @@ -799,5 +799,5 @@ /* static */ -const char* VBoxClipboardWinDataObject::ClipboardFormatToString(CLIPFORMAT fmt) +const char* SharedClipboardWinDataObject::ClipboardFormatToString(CLIPFORMAT fmt) { #if 0 @@ -881,5 +881,5 @@ } -bool VBoxClipboardWinDataObject::lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex) +bool SharedClipboardWinDataObject::lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex) { AssertReturn(pFormatEtc, false); @@ -894,5 +894,5 @@ { LogRel3(("Shared Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n", - pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(m_pFormatEtc[i].cfFormat), + pFormatEtc->tymed, pFormatEtc->cfFormat, SharedClipboardWinDataObject::ClipboardFormatToString(m_pFormatEtc[i].cfFormat), pFormatEtc->dwAspect, i)); if (puIndex) @@ -903,5 +903,5 @@ LogRel3(("Shared Clipboard: Format NOT found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32\n", - pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat), + pFormatEtc->tymed, pFormatEtc->cfFormat, SharedClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat), pFormatEtc->dwAspect)); @@ -909,7 +909,7 @@ } -void VBoxClipboardWinDataObject::registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat, - TYMED tyMed, LONG lIndex, DWORD dwAspect, - DVTARGETDEVICE *pTargetDevice) +void SharedClipboardWinDataObject::registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat, + TYMED tyMed, LONG lIndex, DWORD dwAspect, + DVTARGETDEVICE *pTargetDevice) { AssertPtr(pFormatEtc); @@ -922,5 +922,5 @@ LogFlowFunc(("Registered format=%ld, sFormat=%s\n", - pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat))); -} - + pFormatEtc->cfFormat, SharedClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat))); +} + Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp (revision 80663) +++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp (revision 80664) @@ -31,5 +31,5 @@ -VBoxClipboardWinEnumFormatEtc::VBoxClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats) +SharedClipboardWinEnumFormatEtc::SharedClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats) : m_lRefCount(1), m_nIndex(0) @@ -45,7 +45,7 @@ { LogFlowFunc(("Format %RU32: cfFormat=%RI16, sFormat=%s, tyMed=%RU32, dwAspect=%RU32\n", - i, pFormatEtc[i].cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc[i].cfFormat), + i, pFormatEtc[i].cfFormat, SharedClipboardWinDataObject::ClipboardFormatToString(pFormatEtc[i].cfFormat), pFormatEtc[i].tymed, pFormatEtc[i].dwAspect)); - VBoxClipboardWinEnumFormatEtc::CopyFormat(&m_pFormatEtc[i], &pFormatEtc[i]); + SharedClipboardWinEnumFormatEtc::CopyFormat(&m_pFormatEtc[i], &pFormatEtc[i]); } @@ -61,5 +61,5 @@ } -VBoxClipboardWinEnumFormatEtc::~VBoxClipboardWinEnumFormatEtc(void) +SharedClipboardWinEnumFormatEtc::~SharedClipboardWinEnumFormatEtc(void) { if (m_pFormatEtc) @@ -82,10 +82,10 @@ */ -STDMETHODIMP_(ULONG) VBoxClipboardWinEnumFormatEtc::AddRef(void) +STDMETHODIMP_(ULONG) SharedClipboardWinEnumFormatEtc::AddRef(void) { return InterlockedIncrement(&m_lRefCount); } -STDMETHODIMP_(ULONG) VBoxClipboardWinEnumFormatEtc::Release(void) +STDMETHODIMP_(ULONG) SharedClipboardWinEnumFormatEtc::Release(void) { LONG lCount = InterlockedDecrement(&m_lRefCount); @@ -100,5 +100,5 @@ } -STDMETHODIMP VBoxClipboardWinEnumFormatEtc::QueryInterface(REFIID iid, void **ppvObject) +STDMETHODIMP SharedClipboardWinEnumFormatEtc::QueryInterface(REFIID iid, void **ppvObject) { if ( iid == IID_IEnumFORMATETC @@ -114,5 +114,5 @@ } -STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Next(ULONG cFormats, LPFORMATETC pFormatEtc, ULONG *pcFetched) +STDMETHODIMP SharedClipboardWinEnumFormatEtc::Next(ULONG cFormats, LPFORMATETC pFormatEtc, ULONG *pcFetched) { ULONG ulCopied = 0; @@ -124,5 +124,5 @@ && ulCopied < cFormats) { - VBoxClipboardWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied], &m_pFormatEtc[m_nIndex]); + SharedClipboardWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied], &m_pFormatEtc[m_nIndex]); ulCopied++; m_nIndex++; @@ -135,5 +135,5 @@ } -STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Skip(ULONG cFormats) +STDMETHODIMP SharedClipboardWinEnumFormatEtc::Skip(ULONG cFormats) { m_nIndex += cFormats; @@ -141,5 +141,5 @@ } -STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Reset(void) +STDMETHODIMP SharedClipboardWinEnumFormatEtc::Reset(void) { m_nIndex = 0; @@ -147,9 +147,9 @@ } -STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Clone(IEnumFORMATETC **ppEnumFormatEtc) +STDMETHODIMP SharedClipboardWinEnumFormatEtc::Clone(IEnumFORMATETC **ppEnumFormatEtc) { HRESULT hResult = CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc); if (hResult == S_OK) - ((VBoxClipboardWinEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex; + ((SharedClipboardWinEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex; return hResult; @@ -157,5 +157,5 @@ /* static */ -void VBoxClipboardWinEnumFormatEtc::CopyFormat(LPFORMATETC pDest, LPFORMATETC pSource) +void SharedClipboardWinEnumFormatEtc::CopyFormat(LPFORMATETC pDest, LPFORMATETC pSource) { AssertPtrReturnVoid(pDest); @@ -172,5 +172,5 @@ /* static */ -HRESULT VBoxClipboardWinEnumFormatEtc::CreateEnumFormatEtc(UINT nNumFormats, LPFORMATETC pFormatEtc, IEnumFORMATETC **ppEnumFormatEtc) +HRESULT SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(UINT nNumFormats, LPFORMATETC pFormatEtc, IEnumFORMATETC **ppEnumFormatEtc) { AssertReturn(nNumFormats, E_INVALIDARG); @@ -181,5 +181,5 @@ try { - *ppEnumFormatEtc = new VBoxClipboardWinEnumFormatEtc(pFormatEtc, nNumFormats); + *ppEnumFormatEtc = new SharedClipboardWinEnumFormatEtc(pFormatEtc, nNumFormats); hr = S_OK; } Index: /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp (revision 80663) +++ /trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp (revision 80664) @@ -46,6 +46,6 @@ -VBoxClipboardWinStreamImpl::VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, - const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo) +SharedClipboardWinStreamImpl::SharedClipboardWinStreamImpl(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, + const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo) : m_pParent(pParent) , m_lRefCount(1) /* Our IDataObjct *always* holds the last reference to this object; needed for the callbacks. */ @@ -62,5 +62,5 @@ } -VBoxClipboardWinStreamImpl::~VBoxClipboardWinStreamImpl(void) +SharedClipboardWinStreamImpl::~SharedClipboardWinStreamImpl(void) { LogFlowThisFuncEnter(); @@ -71,5 +71,5 @@ */ -STDMETHODIMP VBoxClipboardWinStreamImpl::QueryInterface(REFIID iid, void **ppvObject) +STDMETHODIMP SharedClipboardWinStreamImpl::QueryInterface(REFIID iid, void **ppvObject) { AssertPtrReturn(ppvObject, E_INVALIDARG); @@ -100,5 +100,5 @@ } -STDMETHODIMP_(ULONG) VBoxClipboardWinStreamImpl::AddRef(void) +STDMETHODIMP_(ULONG) SharedClipboardWinStreamImpl::AddRef(void) { LONG lCount = InterlockedIncrement(&m_lRefCount); @@ -107,5 +107,5 @@ } -STDMETHODIMP_(ULONG) VBoxClipboardWinStreamImpl::Release(void) +STDMETHODIMP_(ULONG) SharedClipboardWinStreamImpl::Release(void) { LONG lCount = InterlockedDecrement(&m_lRefCount); @@ -130,5 +130,5 @@ */ -STDMETHODIMP VBoxClipboardWinStreamImpl::Clone(IStream** ppStream) +STDMETHODIMP SharedClipboardWinStreamImpl::Clone(IStream** ppStream) { RT_NOREF(ppStream); @@ -138,5 +138,5 @@ } -STDMETHODIMP VBoxClipboardWinStreamImpl::Commit(DWORD dwFrags) +STDMETHODIMP SharedClipboardWinStreamImpl::Commit(DWORD dwFrags) { RT_NOREF(dwFrags); @@ -146,6 +146,6 @@ } -STDMETHODIMP VBoxClipboardWinStreamImpl::CopyTo(IStream *pDestStream, ULARGE_INTEGER nBytesToCopy, ULARGE_INTEGER *nBytesRead, - ULARGE_INTEGER *nBytesWritten) +STDMETHODIMP SharedClipboardWinStreamImpl::CopyTo(IStream *pDestStream, ULARGE_INTEGER nBytesToCopy, ULARGE_INTEGER *nBytesRead, + ULARGE_INTEGER *nBytesWritten) { RT_NOREF(pDestStream, nBytesToCopy, nBytesRead, nBytesWritten); @@ -155,5 +155,5 @@ } -STDMETHODIMP VBoxClipboardWinStreamImpl::LockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes,DWORD dwFlags) +STDMETHODIMP SharedClipboardWinStreamImpl::LockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes,DWORD dwFlags) { RT_NOREF(nStart, nBytes, dwFlags); @@ -164,5 +164,5 @@ /* Note: Windows seems to assume EOF if nBytesRead < nBytesToRead. */ -STDMETHODIMP VBoxClipboardWinStreamImpl::Read(void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead) +STDMETHODIMP SharedClipboardWinStreamImpl::Read(void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead) { LogFlowThisFunc(("Enter: m_cbProcessed=%RU64\n", m_cbProcessed)); @@ -266,11 +266,11 @@ } -STDMETHODIMP VBoxClipboardWinStreamImpl::Revert(void) -{ - LogFlowThisFuncEnter(); - return E_NOTIMPL; -} - -STDMETHODIMP VBoxClipboardWinStreamImpl::Seek(LARGE_INTEGER nMove, DWORD dwOrigin, ULARGE_INTEGER* nNewPos) +STDMETHODIMP SharedClipboardWinStreamImpl::Revert(void) +{ + LogFlowThisFuncEnter(); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::Seek(LARGE_INTEGER nMove, DWORD dwOrigin, ULARGE_INTEGER* nNewPos) { RT_NOREF(nMove, dwOrigin, nNewPos); @@ -281,5 +281,5 @@ } -STDMETHODIMP VBoxClipboardWinStreamImpl::SetSize(ULARGE_INTEGER nNewSize) +STDMETHODIMP SharedClipboardWinStreamImpl::SetSize(ULARGE_INTEGER nNewSize) { RT_NOREF(nNewSize); @@ -289,5 +289,5 @@ } -STDMETHODIMP VBoxClipboardWinStreamImpl::Stat(STATSTG *pStatStg, DWORD dwFlags) +STDMETHODIMP SharedClipboardWinStreamImpl::Stat(STATSTG *pStatStg, DWORD dwFlags) { HRESULT hr = S_OK; @@ -331,5 +331,5 @@ } -STDMETHODIMP VBoxClipboardWinStreamImpl::UnlockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes, DWORD dwFlags) +STDMETHODIMP SharedClipboardWinStreamImpl::UnlockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes, DWORD dwFlags) { RT_NOREF(nStart, nBytes, dwFlags); @@ -339,5 +339,5 @@ } -STDMETHODIMP VBoxClipboardWinStreamImpl::Write(const void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead) +STDMETHODIMP SharedClipboardWinStreamImpl::Write(const void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead) { RT_NOREF(pvBuffer, nBytesToRead, nBytesRead); @@ -362,11 +362,11 @@ */ /* static */ -HRESULT VBoxClipboardWinStreamImpl::Create(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, - const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo, - IStream **ppStream) +HRESULT SharedClipboardWinStreamImpl::Create(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, + const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo, + IStream **ppStream) { AssertPtrReturn(pTransfer, E_POINTER); - VBoxClipboardWinStreamImpl *pStream = new VBoxClipboardWinStreamImpl(pParent, pTransfer, strPath, pObjInfo); + SharedClipboardWinStreamImpl *pStream = new SharedClipboardWinStreamImpl(pParent, pTransfer, strPath, pObjInfo); if (pStream) { Index: /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp =================================================================== --- /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp (revision 80663) +++ /trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp (revision 80664) @@ -47,5 +47,5 @@ * @param hWnd Handle of window to open clipboard for. */ -int VBoxClipboardWinOpen(HWND hWnd) +int SharedClipboardWinOpen(HWND hWnd) { /* "OpenClipboard fails if another window has the clipboard open." @@ -95,5 +95,5 @@ * @returns VBox status code. */ -int VBoxClipboardWinClose(void) +int SharedClipboardWinClose(void) { int rc; @@ -123,5 +123,5 @@ * @returns VBox status code. */ -int VBoxClipboardWinClear(void) +int SharedClipboardWinClear(void) { int rc; @@ -154,5 +154,5 @@ * Will be set to NULL if the new API is not available. */ -int VBoxClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI) +int SharedClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI) { RTLDRMOD hUser32 = NIL_RTLDRMOD; @@ -188,5 +188,5 @@ * @param pAPI Structure used for checking if the new clipboard API is available or not. */ -bool VBoxClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI) +bool SharedClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI) { if (!pAPI) @@ -201,10 +201,10 @@ * @param pCtx Windows clipboard context to use to add ourselves. */ -int VBoxClipboardWinChainAdd(PSHCLWINCTX pCtx) +int SharedClipboardWinChainAdd(PSHCLWINCTX pCtx) { const PSHCLWINAPINEW pAPI = &pCtx->newAPI; BOOL fRc; - if (VBoxClipboardWinIsNewAPI(pAPI)) + if (SharedClipboardWinIsNewAPI(pAPI)) { fRc = pAPI->pfnAddClipboardFormatListener(pCtx->hWnd); @@ -234,5 +234,5 @@ * @param pCtx Windows clipboard context to use to remove ourselves. */ -int VBoxClipboardWinChainRemove(PSHCLWINCTX pCtx) +int SharedClipboardWinChainRemove(PSHCLWINCTX pCtx) { if (!pCtx->hWnd) @@ -242,5 +242,5 @@ BOOL fRc; - if (VBoxClipboardWinIsNewAPI(pAPI)) + if (SharedClipboardWinIsNewAPI(pAPI)) { fRc = pAPI->pfnRemoveClipboardFormatListener(pCtx->hWnd); @@ -276,5 +276,5 @@ * @param lResult Additional data to pass. Not used currently. */ -VOID CALLBACK VBoxClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult) +VOID CALLBACK SharedClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult) { RT_NOREF(hWnd); @@ -298,5 +298,5 @@ * @param lParam LPARAM to pass. */ -LRESULT VBoxClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, +LRESULT SharedClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam) { @@ -312,5 +312,5 @@ DWORD_PTR dwResult; lresultRc = SendMessageTimeout(pWinCtx->hWndNextInChain, msg, wParam, lParam, 0, - VBOX_CLIPBOARD_CBCHAIN_TIMEOUT_MS, &dwResult); + SHCL_WIN_CBCHAIN_TIMEOUT_MS, &dwResult); if (!lresultRc) lresultRc = dwResult; @@ -327,5 +327,5 @@ * @param uFormat Windows clipboard format to convert. */ -SHCLFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat) +SHCLFORMAT SharedClipboardWinClipboardFormatToVBox(UINT uFormat) { /* Insert the requested clipboard format data into the clipboard. */ @@ -361,5 +361,5 @@ LogFlowFunc(("uFormat=%u -> szFormatName=%s\n", uFormat, szFormatName)); - if (RTStrCmp(szFormatName, VBOX_CLIPBOARD_WIN_REGFMT_HTML) == 0) + if (RTStrCmp(szFormatName, SHCL_WIN_REGFMT_HTML) == 0) vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_HTML; #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST @@ -386,5 +386,5 @@ * @param pFormats Where to store the retrieved formats. */ -int VBoxClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats) +int SharedClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); @@ -394,12 +394,12 @@ /* Query list of available formats and report to host. */ - int rc = VBoxClipboardWinOpen(pCtx->hWnd); + int rc = SharedClipboardWinOpen(pCtx->hWnd); if (RT_SUCCESS(rc)) { UINT uCurFormat = 0; /* Must be set to zero for EnumClipboardFormats(). */ while ((uCurFormat = EnumClipboardFormats(uCurFormat)) != 0) - fFormats |= VBoxClipboardWinClipboardFormatToVBox(uCurFormat); - - int rc2 = VBoxClipboardWinClose(); + fFormats |= SharedClipboardWinClipboardFormatToVBox(uCurFormat); + + int rc2 = SharedClipboardWinClose(); AssertRC(rc2); } @@ -428,5 +428,5 @@ * @param puValue Where to return extracted value of CF_HTML field. */ -int VBoxClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue) +int SharedClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue) { AssertPtrReturn(pszSrc, VERR_INVALID_POINTER); @@ -452,5 +452,5 @@ * @param pszSource Source string to check. */ -bool VBoxClipboardWinIsCFHTML(const char *pszSource) +bool SharedClipboardWinIsCFHTML(const char *pszSource) { return RTStrStr(pszSource, "Version:") != NULL @@ -469,5 +469,5 @@ * @param pcbOutput Where to the return length of the result (bytes/chars). */ -int VBoxClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput) +int SharedClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput) { Assert(pszSource); @@ -477,9 +477,9 @@ uint32_t offStart; - int rc = VBoxClipboardWinGetCFHTMLHeaderValue(pszSource, "StartFragment:", &offStart); + int rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "StartFragment:", &offStart); if (RT_SUCCESS(rc)) { uint32_t offEnd; - rc = VBoxClipboardWinGetCFHTMLHeaderValue(pszSource, "EndFragment:", &offEnd); + rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "EndFragment:", &offEnd); if (RT_SUCCESS(rc)) { @@ -556,5 +556,5 @@ * @note Everything inside of fragment can be UTF8. Windows allows it. Everything in header should be Latin1. */ -int VBoxClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput) +int SharedClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput) { Assert(ppszOutput); @@ -649,5 +649,5 @@ * @param lParam lParam to pass on. */ -LRESULT VBoxClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, +LRESULT SharedClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { @@ -656,5 +656,5 @@ LogFlowFuncEnter(); - if (VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI)) + if (SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) { lresultRc = DefWindowProc(hWnd, msg, wParam, lParam); @@ -679,5 +679,5 @@ DWORD_PTR dwResult; lresultRc = SendMessageTimeout(pWinCtx->hWndNextInChain, WM_CHANGECBCHAIN, wParam, lParam, 0, - VBOX_CLIPBOARD_CBCHAIN_TIMEOUT_MS, + SHCL_WIN_CBCHAIN_TIMEOUT_MS, &dwResult); if (!lresultRc) @@ -697,5 +697,5 @@ * @param pWinCtx Windows context to use. */ -int VBoxClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx) +int SharedClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx) { LogFlowFuncEnter(); @@ -704,5 +704,5 @@ /* MS recommends to remove from Clipboard chain in this callback. */ - VBoxClipboardWinChainRemove(pWinCtx); + SharedClipboardWinChainRemove(pWinCtx); if (pWinCtx->oldAPI.timerRefresh) @@ -723,5 +723,5 @@ * @param hWnd Window handle to use. */ -int VBoxClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd) +int SharedClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd) { RT_NOREF(pWinCtx); @@ -732,9 +732,9 @@ * windows is to be destroyed and therefore the guest side becomes inactive. */ - int rc = VBoxClipboardWinOpen(hWnd); + int rc = SharedClipboardWinOpen(hWnd); if (RT_SUCCESS(rc)) { - VBoxClipboardWinClear(); - VBoxClipboardWinClose(); + SharedClipboardWinClear(); + SharedClipboardWinClose(); } @@ -750,9 +750,9 @@ * @param pWinCtx Windows context to use. */ -int VBoxClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx) +int SharedClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx) { int rc = VINF_SUCCESS; - if (!VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI)) /* Only run when using the "old" Windows API. */ + if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) /* Only run when using the "old" Windows API. */ { LogFlowFuncEnter(); @@ -764,6 +764,6 @@ if (!hViewer || pWinCtx->oldAPI.fCBChainPingInProcess) { - VBoxClipboardWinChainRemove(pWinCtx); - VBoxClipboardWinChainAdd(pWinCtx); + SharedClipboardWinChainRemove(pWinCtx); + SharedClipboardWinChainAdd(pWinCtx); } @@ -775,5 +775,5 @@ if (hViewer) SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pWinCtx->hWndNextInChain, (LPARAM)pWinCtx->hWndNextInChain, - VBoxClipboardWinChainPingProc, (ULONG_PTR)pWinCtx); + SharedClipboardWinChainPingProc, (ULONG_PTR)pWinCtx); } @@ -790,5 +790,5 @@ * @param fFormats Clipboard format(s) to announce. */ -int VBoxClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats) +int SharedClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats) { LogFunc(("fFormats=0x%x\n", fFormats)); @@ -815,5 +815,5 @@ { LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_HTML\n")); - cfFormat = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML); + cfFormat = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML); if (cfFormat != 0) hClip = SetClipboardData(cfFormat, NULL); @@ -846,5 +846,5 @@ * @param pTransfer URI transfer to use. */ -int VBoxClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer) +int SharedClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer) { AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); @@ -862,5 +862,5 @@ pTransfer->cbUser = sizeof(SharedClipboardWinURITransferCtx); - pWinURITransferCtx->pDataObj = new VBoxClipboardWinDataObject(pTransfer); + pWinURITransferCtx->pDataObj = new SharedClipboardWinDataObject(pTransfer); if (pWinURITransferCtx->pDataObj) { @@ -868,8 +868,8 @@ if (RT_SUCCESS(rc)) { - VBoxClipboardWinClose(); + SharedClipboardWinClose(); /* Note: Clipboard must be closed first before calling OleSetClipboard(). */ - /** @todo There is a potential race between VBoxClipboardWinClose() and OleSetClipboard(), + /** @todo There is a potential race between SharedClipboardWinClose() and OleSetClipboard(), * where another application could own the clipboard (open), and thus the call to * OleSetClipboard() will fail. Needs (better) fixing. */ @@ -912,5 +912,5 @@ * @param pTransfer URI transfer to create implementation-specific data for. */ -void VBoxClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer) +void SharedClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer) { RT_NOREF(pWinCtx); @@ -949,5 +949,5 @@ * @param pcbList Where to store the size (in bytes) of the allocated string list. */ -int VBoxClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList) +int SharedClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList) { AssertPtrReturn(pDropFiles, VERR_INVALID_POINTER); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp (revision 80664) @@ -54,5 +54,5 @@ /** - * Checks if something is present on the clipboard and calls vboxSvcClipboardReportMsg. + * Checks if something is present on the clipboard and calls sharedClipboardSvcReportMsg. * * @returns IPRT status code (ignored). @@ -76,5 +76,5 @@ formatData.uFormats = fFormats; - rc = vboxSvcClipboardFormatsReport(pCtx->pClient, &formatData); + rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData); } @@ -117,5 +117,5 @@ -int VBoxClipboardSvcImplInit(void) +int SharedClipboardSvcImplInit(void) { Log(("vboxClipboardInit\n")); @@ -137,5 +137,5 @@ } -void VBoxClipboardSvcImplDestroy(void) +void SharedClipboardSvcImplDestroy(void) { /* @@ -156,5 +156,5 @@ } -int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) +int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) { RT_NOREF(fHeadless); @@ -172,11 +172,11 @@ /* Initially sync the host clipboard content with the client. */ - int rc = VBoxClipboardSvcImplSync(pClient); - - VBoxSvcClipboardUnlock(); - return rc; -} - -int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient) + int rc = SharedClipboardSvcImplSync(pClient); + + VBoxSvcClipboardUnlock(); + return rc; +} + +int SharedClipboardSvcImplSync(PSHCLCLIENT pClient) { /* Sync the host clipboard content with the client. */ @@ -190,5 +190,5 @@ } -int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient) +int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient) { VBoxSvcClipboardLock(); @@ -201,5 +201,5 @@ } -int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, +int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats) { @@ -225,5 +225,5 @@ dataReq.cbSize = _64K; /** @todo Make this more dynamic. */ - return vboxSvcClipboardDataReadRequest(pClient, &dataReq, NULL /* puEvent */); + return sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */); } @@ -236,5 +236,5 @@ * @param pcbActual Where to write the actual size of the written data. */ -int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, +int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual) { @@ -262,5 +262,5 @@ * @param pData Data block to write to clipboard. */ -int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, +int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData) { @@ -277,5 +277,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardSvcImplURIReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData) +int SharedClipboardSvcImplURIReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData) { RT_NOREF(pClient, pDirData); @@ -283,5 +283,5 @@ } -int VBoxClipboardSvcImplURIWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData) +int SharedClipboardSvcImplURIWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData) { RT_NOREF(pClient, pDirData); @@ -289,5 +289,5 @@ } -int VBoxClipboardSvcImplURIReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr) +int SharedClipboardSvcImplURIReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr) { RT_NOREF(pClient, pFileHdr); @@ -295,5 +295,5 @@ } -int VBoxClipboardSvcImplURIWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr) +int SharedClipboardSvcImplURIWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr) { RT_NOREF(pClient, pFileHdr); @@ -301,5 +301,5 @@ } -int VBoxClipboardSvcImplURIReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData) +int SharedClipboardSvcImplURIReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData) { RT_NOREF(pClient, pFileData); @@ -307,5 +307,5 @@ } -int VBoxClipboardSvcImplURIWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData) +int SharedClipboardSvcImplURIWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData) { RT_NOREF(pClient, pFileData); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h (revision 80664) @@ -46,9 +46,9 @@ * Structure for keeping a Shared Clipboard HGCM message context. */ -typedef struct _VBOXSHCLMSGCTX +typedef struct _SHCLMSGCTX { /** Context ID. */ uint32_t uContextID; -} VBOXSHCLMSGCTX, *PVBOXSHCLMSGCTX; +} SHCLMSGCTX, *PSHCLMSGCTX; /** @@ -64,5 +64,5 @@ PVBOXHGCMSVCPARM m_paParms; /** Message context. */ - VBOXSHCLMSGCTX m_Ctx; + SHCLMSGCTX m_Ctx; } SHCLCLIENTMSG, *PSHCLCLIENTMSG; @@ -178,26 +178,26 @@ * The service functions. Locking is between the service thread and the platform-dependent (window) thread. */ -int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent); -int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData); -int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats); - -uint32_t vboxSvcClipboardGetMode(void); -int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource); - -void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient); -PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms); -void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg); -void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms); -int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend); -int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait); -int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); - -int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient); +int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent); +int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData); +int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats); + +uint32_t sharedClipboardSvcGetMode(void); +int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource); + +void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient); +PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms); +void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg); +void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms); +int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend); +int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait); +int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); + +int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient); # ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient, +int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient, SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource, PSHCLURITRANSFER *ppTransfer); -bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg); +bool sharedClipboardSvcURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg); # endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ @@ -205,43 +205,43 @@ * Platform-dependent implementations. */ -int VBoxClipboardSvcImplInit(void); -void VBoxClipboardSvcImplDestroy(void); - -int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless); -int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient); -int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats); +int SharedClipboardSvcImplInit(void); +void SharedClipboardSvcImplDestroy(void); + +int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless); +int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient); +int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats); /** @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read data.*/ -int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual); -int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData); +int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual); +int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData); /** * Synchronise the contents of the host clipboard with the guest, called by the HGCM layer * after a save and restore of the guest. */ -int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient); +int SharedClipboardSvcImplSync(PSHCLCLIENT pClient); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx); -DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx); - -int vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList); - -int vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx, +int sharedClipboardSvcURITransferOpen(PSHCLPROVIDERCTX pCtx); +DECLCALLBACK(int) sharedClipboardSvcURITransferClose(PSHCLPROVIDERCTX pCtx); + +int sharedClipboardSvcURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList); + +int sharedClipboardSvcURIListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList); -int vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList); -int vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, +int sharedClipboardSvcURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList); +int sharedClipboardSvcURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr); -int vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, +int sharedClipboardSvcURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr); -int vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, +int sharedClipboardSvcURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry); -int vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, +int sharedClipboardSvcURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry); -int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, +int sharedClipboardSvcURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj); -int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj); -int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, +int sharedClipboardSvcURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj); +int sharedClipboardSvcURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead); -int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, +int sharedClipboardSvcURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten); @@ -253,6 +253,6 @@ DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc); -int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer); -int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer); +int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer); +int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer); #endif /*VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp (revision 80664) @@ -48,8 +48,8 @@ * Prototypes * *********************************************************************************************************************************/ -static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms); -static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList); +static int sharedClipboardSvcURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms); +static int sharedClipboardSvcURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList); @@ -58,5 +58,5 @@ *********************************************************************************************************************************/ -DECLCALLBACK(int) vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx) +DECLCALLBACK(int) sharedClipboardSvcURITransferOpen(PSHCLPROVIDERCTX pCtx) { RT_NOREF(pCtx); @@ -66,5 +66,5 @@ } -DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx) +DECLCALLBACK(int) sharedClipboardSvcURITransferClose(PSHCLPROVIDERCTX pCtx) { RT_NOREF(pCtx); @@ -74,5 +74,5 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList) +DECLCALLBACK(int) sharedClipboardSvcURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList) { LogFlowFuncEnter(); @@ -83,5 +83,5 @@ int rc; - PSHCLCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ, + PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ); if (pMsgHdr) @@ -92,5 +92,5 @@ HGCMSvcSetU32(&pMsgHdr->m_paParms[1], 0 /* fRoots */); - rc = vboxSvcClipboardMsgAdd(pClient, pMsgHdr, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -98,5 +98,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -123,5 +123,5 @@ for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++) { - PSHCLCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ, + PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ); @@ -136,5 +136,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardMsgAdd(pClient, pMsgEntry, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */); if (RT_FAILURE(rc)) break; @@ -190,6 +190,6 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx, - PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList) +DECLCALLBACK(int) sharedClipboardSvcURIListOpen(PSHCLPROVIDERCTX pCtx, + PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList) { LogFlowFuncEnter(); @@ -200,6 +200,6 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN, - VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN); + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN, + VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN); if (pMsg) { @@ -208,8 +208,8 @@ pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent); - rc = vboxSvcClipboardURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, pOpenParms); - if (RT_SUCCESS(rc)) - { - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, pOpenParms); + if (RT_SUCCESS(rc)) + { + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -217,5 +217,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -248,5 +248,5 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList) +DECLCALLBACK(int) sharedClipboardSvcURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList) { LogFlowFuncEnter(); @@ -257,5 +257,5 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE); if (pMsg) @@ -265,8 +265,8 @@ pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent); - rc = vboxSvcClipboardURISetListClose(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, hList); - if (RT_SUCCESS(rc)) - { - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcURISetListClose(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, hList); + if (RT_SUCCESS(rc)) + { + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -274,5 +274,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -294,6 +294,6 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx, - SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) +DECLCALLBACK(int) sharedClipboardSvcURIListHdrRead(PSHCLPROVIDERCTX pCtx, + SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) { LogFlowFuncEnter(); @@ -304,6 +304,6 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ, - VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ); + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ, + VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ); if (pMsg) { @@ -314,5 +314,5 @@ HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */); - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -320,5 +320,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -344,6 +344,6 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx, - SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) +DECLCALLBACK(int) sharedClipboardSvcURIListHdrWrite(PSHCLPROVIDERCTX pCtx, + SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr) { RT_NOREF(pCtx, hList, pListHdr); @@ -354,6 +354,6 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx, - SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry) +DECLCALLBACK(int) sharedClipboardSvcURIListEntryRead(PSHCLPROVIDERCTX pCtx, + SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry) { LogFlowFuncEnter(); @@ -364,6 +364,6 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ, - VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ); + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ, + VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ); if (pMsg) { @@ -374,5 +374,5 @@ HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */); - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -380,5 +380,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -403,6 +403,6 @@ } -DECLCALLBACK(int) vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx, - SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry) +DECLCALLBACK(int) sharedClipboardSvcURIListEntryWrite(PSHCLPROVIDERCTX pCtx, + SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry) { RT_NOREF(pCtx, hList, pListEntry); @@ -413,6 +413,6 @@ } -int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, - PSHCLOBJHANDLE phObj) +int sharedClipboardSvcURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, + PSHCLOBJHANDLE phObj) { LogFlowFuncEnter(); @@ -423,6 +423,6 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN, - VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN); + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN, + VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN); if (pMsg) { @@ -439,5 +439,5 @@ HGCMSvcSetU32(&pMsg->m_paParms[4], pCreateParms->fCreate); - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -445,5 +445,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -473,5 +473,5 @@ } -int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj) +int sharedClipboardSvcURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj) { LogFlowFuncEnter(); @@ -482,5 +482,5 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE, + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE); if (pMsg) @@ -491,5 +491,5 @@ HGCMSvcSetU64(&pMsg->m_paParms[1], hObj); - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -497,5 +497,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -525,6 +525,6 @@ } -int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, - void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead) +int sharedClipboardSvcURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, + void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead) { LogFlowFuncEnter(); @@ -535,5 +535,5 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ, + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ); if (pMsg) @@ -546,5 +546,5 @@ HGCMSvcSetU32(&pMsg->m_paParms[3], fFlags); - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -552,5 +552,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -583,6 +583,6 @@ } -int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, - void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten) +int sharedClipboardSvcURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, + void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten) { LogFlowFuncEnter(); @@ -593,5 +593,5 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE, + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE); if (pMsg) @@ -604,5 +604,5 @@ HGCMSvcSetU64(&pMsg->m_paParms[3], fFlags); - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -610,5 +610,5 @@ AssertRC(rc2); - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -688,6 +688,6 @@ * @param pReply Where to store the reply. */ -static int vboxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PSHCLREPLY pReply) +static int sharedClipboardSvcURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLREPLY pReply) { int rc; @@ -756,6 +756,6 @@ * @param pRootLstHdr Where to store the URI root list header on success. */ -static int vboxSvcClipboardURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PSHCLROOTLISTHDR pRootLstHdr) +static int sharedClipboardSvcURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLROOTLISTHDR pRootLstHdr) { int rc; @@ -782,6 +782,6 @@ * @param pListEntry Where to store the root list entry. */ -static int vboxSvcClipboardURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PSHCLROOTLISTENTRY pListEntry) +static int sharedClipboardSvcURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLROOTLISTENTRY pListEntry) { int rc; @@ -819,6 +819,6 @@ * @param pOpenParms Where to store the open parameters of the request. */ -static int vboxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PSHCLLISTOPENPARMS pOpenParms) +static int sharedClipboardSvcURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLLISTOPENPARMS pOpenParms) { int rc; @@ -866,6 +866,6 @@ * @param pOpenParms List open parameters to set. */ -static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms) +static int sharedClipboardSvcURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms) { int rc; @@ -899,6 +899,6 @@ * @param hList Handle of list to close. */ -static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList) +static int sharedClipboardSvcURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList) { int rc; @@ -927,6 +927,6 @@ * @param pListHdr Where to store the list header. */ -static int vboxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr) +static int sharedClipboardSvcURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr) { int rc; @@ -966,6 +966,6 @@ * @param pListHdr Pointer to data to set to the HGCM parameters. */ -static int vboxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr) +static int sharedClipboardSvcURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr) { int rc; @@ -1001,6 +1001,6 @@ * @param pListEntry Where to store the list entry. */ -static int vboxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], - PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry) +static int sharedClipboardSvcURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], + PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry) { int rc; @@ -1047,5 +1047,5 @@ * @param pListEntry Pointer to data to set to the HGCM parameters. */ -static int vboxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], +static int sharedClipboardSvcURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry) { @@ -1079,5 +1079,5 @@ * @param pDataChunk Where to store the object data chunk data. */ -static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk) +static int sharedClipboardSvcURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk) { AssertPtrReturn(paParms, VERR_INVALID_PARAMETER); @@ -1117,5 +1117,5 @@ * @param pRc Where to store the received error code. */ -static int vboxSvcClipboardURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc) +static int sharedClipboardSvcURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc) { AssertPtrReturn(paParms, VERR_INVALID_PARAMETER); @@ -1144,6 +1144,6 @@ * @param paParms Array function parameters supplied. */ -static int vboxSvcClipboardURITransferHandleReply(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer, - uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +static int sharedClipboardSvcURITransferHandleReply(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer, + uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { RT_NOREF(pClient); @@ -1155,5 +1155,5 @@ if (pReply) { - rc = vboxSvcClipboardURIGetReply(cParms, paParms, pReply); + rc = sharedClipboardSvcURIGetReply(cParms, paParms, pReply); if (RT_SUCCESS(rc)) { @@ -1227,10 +1227,10 @@ * @param tsArrival Timestamp of arrival. */ -int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient, - VBOXHGCMCALLHANDLE callHandle, - uint32_t u32Function, - uint32_t cParms, - VBOXHGCMSVCPARM paParms[], - uint64_t tsArrival) +int sharedClipboardSvcURIHandler(PSHCLCLIENT pClient, + VBOXHGCMCALLHANDLE callHandle, + uint32_t u32Function, + uint32_t cParms, + VBOXHGCMSVCPARM paParms[], + uint64_t tsArrival) { RT_NOREF(paParms, tsArrival); @@ -1240,5 +1240,5 @@ /* Check if we've the right mode set. */ - if (!vboxSvcClipboardURIMsgIsAllowed(vboxSvcClipboardGetMode(), u32Function)) + if (!sharedClipboardSvcURIMsgIsAllowed(sharedClipboardSvcGetMode(), u32Function)) { LogFunc(("Wrong clipboard mode, denying access\n")); @@ -1325,5 +1325,5 @@ if (RT_SUCCESS(rc)) { - rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer); + rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer); if (RT_SUCCESS(rc)) { @@ -1333,17 +1333,17 @@ creationCtx.enmSource = pClient->State.enmSource; - creationCtx.Interface.pfnTransferOpen = vboxSvcClipboardURITransferOpen; - creationCtx.Interface.pfnTransferClose = vboxSvcClipboardURITransferClose; - creationCtx.Interface.pfnListOpen = vboxSvcClipboardURIListOpen; - creationCtx.Interface.pfnListClose = vboxSvcClipboardURIListClose; - creationCtx.Interface.pfnObjOpen = vboxSvcClipboardURIObjOpen; - creationCtx.Interface.pfnObjClose = vboxSvcClipboardURIObjClose; + creationCtx.Interface.pfnTransferOpen = sharedClipboardSvcURITransferOpen; + creationCtx.Interface.pfnTransferClose = sharedClipboardSvcURITransferClose; + creationCtx.Interface.pfnListOpen = sharedClipboardSvcURIListOpen; + creationCtx.Interface.pfnListClose = sharedClipboardSvcURIListClose; + creationCtx.Interface.pfnObjOpen = sharedClipboardSvcURIObjOpen; + creationCtx.Interface.pfnObjClose = sharedClipboardSvcURIObjClose; if (enmDir == SHCLURITRANSFERDIR_READ) { - creationCtx.Interface.pfnGetRoots = vboxSvcClipboardURIGetRoots; - creationCtx.Interface.pfnListHdrRead = vboxSvcClipboardURIListHdrRead; - creationCtx.Interface.pfnListEntryRead = vboxSvcClipboardURIListEntryRead; - creationCtx.Interface.pfnObjRead = vboxSvcClipboardURIObjRead; + creationCtx.Interface.pfnGetRoots = sharedClipboardSvcURIGetRoots; + creationCtx.Interface.pfnListHdrRead = sharedClipboardSvcURIListHdrRead; + creationCtx.Interface.pfnListEntryRead = sharedClipboardSvcURIListEntryRead; + creationCtx.Interface.pfnObjRead = sharedClipboardSvcURIObjRead; } else @@ -1374,12 +1374,12 @@ if (RT_SUCCESS(rc)) { - rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer); + rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer); if (RT_SUCCESS(rc)) - rc = VBoxClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST); + rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST); } if (RT_FAILURE(rc)) { - VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer); + SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer); SharedClipboardURITransferDestroy(pTransfer); } @@ -1398,5 +1398,5 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY: { - rc = vboxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms); + rc = sharedClipboardSvcURITransferHandleReply(pClient, pTransfer, cParms, paParms); break; } @@ -1410,5 +1410,5 @@ { SHCLROOTLISTHDR lstHdr; - rc = vboxSvcClipboardURIGetRootListHdr(cParms, paParms, &lstHdr); + rc = sharedClipboardSvcURIGetRootListHdr(cParms, paParms, &lstHdr); if (RT_SUCCESS(rc)) { @@ -1459,5 +1459,5 @@ { SHCLROOTLISTENTRY lstEntry; - rc = vboxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry); + rc = sharedClipboardSvcURIGetRootListEntry(cParms, paParms, &lstEntry); if (RT_SUCCESS(rc)) { @@ -1487,5 +1487,5 @@ { SHCLLISTOPENPARMS listOpenParms; - rc = vboxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms); + rc = sharedClipboardSvcURIGetListOpen(cParms, paParms, &listOpenParms); if (RT_SUCCESS(rc)) { @@ -1527,5 +1527,5 @@ rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList); /*if (RT_SUCCESS(rc)) - rc = vboxSvcClipboardURISetListHdr(cParms, paParms, &hdrList);*/ + rc = sharedClipboardSvcURISetListHdr(cParms, paParms, &hdrList);*/ } break; @@ -1539,5 +1539,5 @@ { SHCLLISTHANDLE hList; - rc = vboxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList); + rc = sharedClipboardSvcURIGetListHdr(cParms, paParms, &hList, &hdrList); if (RT_SUCCESS(rc)) { @@ -1587,5 +1587,5 @@ { SHCLLISTHANDLE hList; - rc = vboxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList); + rc = sharedClipboardSvcURIGetListEntry(cParms, paParms, &hList, &entryList); if (RT_SUCCESS(rc)) { @@ -1633,5 +1633,5 @@ { SHCLOBJDATACHUNK dataChunk; - rc = vboxSvcClipboardURIGetObjDataChunk(cParms, paParms, &dataChunk); + rc = sharedClipboardSvcURIGetObjDataChunk(cParms, paParms, &dataChunk); if (RT_SUCCESS(rc)) { @@ -1838,5 +1838,5 @@ { int rcGuest; - rc = vboxSvcClipboardURIGetError(cParms,paParms, &rcGuest); + rc = sharedClipboardSvcURIGetError(cParms,paParms, &rcGuest); if (RT_SUCCESS(rc)) LogRel(("Shared Clipboard: Transfer error: %Rrc\n", rcGuest)); @@ -1869,5 +1869,5 @@ * @param paParms Array function parameters supplied. */ -int vboxSvcClipboardURIHostHandler(uint32_t u32Function, +int sharedClipboardSvcURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) @@ -1901,5 +1901,5 @@ * @param pTransfer URI transfer to register a clipboard area for. */ -int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) +int sharedClipboardSvcURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClientState); @@ -1950,5 +1950,5 @@ * @param pTransfer URI transfer to unregister a clipboard area from. */ -int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) +int sharedClipboardSvcURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClientState); @@ -1998,5 +1998,5 @@ * @param uID ID of clipboard area to to attach to. Specify 0 to attach to the most recent one. */ -int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, +int sharedClipboardSvcURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID) { @@ -2046,5 +2046,5 @@ * @param pTransfer URI transfer to detach a clipboard area from. */ -int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) +int sharedClipboardSvcURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClientState); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h (revision 80664) @@ -22,11 +22,11 @@ #endif -int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival); -int vboxSvcClipboardURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); +int sharedClipboardSvcURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival); +int sharedClipboardSvcURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); -int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); -int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); -int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID); -int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); +int sharedClipboardSvcURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); +int sharedClipboardSvcURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); +int sharedClipboardSvcURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID); +int sharedClipboardSvcURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer); #endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_uri_h */ Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp (revision 80664) @@ -107,6 +107,6 @@ LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n")); - if ( vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST - && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) + if ( sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST + && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) { LogFlowFunc(("Wrong clipboard mode, skipping\n")); @@ -130,5 +130,5 @@ } -bool vboxSvcClipboardURIReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +bool sharedClipboardSvcURIReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { RT_NOREF(pClient, cParms, paParms); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (revision 80664) @@ -73,10 +73,10 @@ if ( u32Format == VBOX_SHARED_CLIPBOARD_FMT_HTML - && VBoxClipboardWinIsCFHTML((const char *)pvSrc)) + && SharedClipboardWinIsCFHTML((const char *)pvSrc)) { /** @todo r=bird: Why the double conversion? */ char *pszBuf = NULL; uint32_t cbBuf = 0; - int rc = VBoxClipboardWinConvertCFHTMLToMIME((const char *)pvSrc, cbSrc, &pszBuf, &cbBuf); + int rc = SharedClipboardWinConvertCFHTMLToMIME((const char *)pvSrc, cbSrc, &pszBuf, &cbBuf); if (RT_SUCCESS(rc)) { @@ -175,9 +175,9 @@ RT_ZERO(dataReq); - dataReq.uFmt = VBoxClipboardWinClipboardFormatToVBox(cfFormat); + dataReq.uFmt = SharedClipboardWinClipboardFormatToVBox(cfFormat); dataReq.cbSize = _64K; /** @todo Make this more dynamic. */ SHCLEVENTID uEvent = 0; - int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent); + int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent); if (RT_SUCCESS(rc)) { @@ -222,5 +222,5 @@ int rc = vboxClipboardSvcWinSyncInternal(pCtx); if (RT_SUCCESS(rc)) - vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL); + sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL); } @@ -231,5 +231,5 @@ { LogFunc(("WM_CHANGECBCHAIN\n")); - lresultRc = VBoxClipboardWinHandleWMChangeCBChain(pWinCtx, hWnd, uMsg, wParam, lParam); + lresultRc = SharedClipboardWinHandleWMChangeCBChain(pWinCtx, hWnd, uMsg, wParam, lParam); break; } @@ -244,8 +244,8 @@ int rc = vboxClipboardSvcWinSyncInternal(pCtx); if (RT_SUCCESS(rc)) - vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL); - } - - lresultRc = VBoxClipboardWinChainPassToNext(pWinCtx, uMsg, wParam, lParam); + sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL); + } + + lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, uMsg, wParam, lParam); break; } @@ -253,5 +253,5 @@ case WM_TIMER: { - int rc = VBoxClipboardWinHandleWMTimer(pWinCtx); + int rc = SharedClipboardWinHandleWMTimer(pWinCtx); AssertRC(rc); @@ -266,5 +266,5 @@ const UINT cfFormat = (UINT)wParam; - const SHCLFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat); + const SHCLFORMAT fFormat = SharedClipboardWinClipboardFormatToVBox(cfFormat); LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat)); @@ -275,5 +275,5 @@ /* Unsupported clipboard format is requested. */ LogFunc(("WM_RENDERFORMAT unsupported format requested or client is not active\n")); - VBoxClipboardWinClear(); + SharedClipboardWinClear(); } else @@ -293,5 +293,5 @@ if (RT_FAILURE(rc)) - VBoxClipboardWinClear(); + SharedClipboardWinClear(); } @@ -303,5 +303,5 @@ LogFunc(("WM_RENDERALLFORMATS\n")); - int rc = VBoxClipboardWinHandleWMRenderAllFormats(pWinCtx, hWnd); + int rc = SharedClipboardWinHandleWMRenderAllFormats(pWinCtx, hWnd); AssertRC(rc); @@ -309,5 +309,5 @@ } - case VBOX_CLIPBOARD_WM_REPORT_FORMATS: + case SHCL_WIN_WM_REPORT_FORMATS: { LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n")); @@ -317,12 +317,12 @@ if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */ { - int rc = VBoxClipboardWinOpen(hWnd); + int rc = SharedClipboardWinOpen(hWnd); if (RT_SUCCESS(rc)) { - VBoxClipboardWinClear(); - - rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats); - - VBoxClipboardWinClose(); + SharedClipboardWinClear(); + + rc = SharedClipboardWinAnnounceFormats(pWinCtx, fFormats); + + SharedClipboardWinClose(); } @@ -337,5 +337,5 @@ LogFunc(("WM_DESTROY\n")); - int rc = VBoxClipboardWinHandleWMDestroy(pWinCtx); + int rc = SharedClipboardWinHandleWMDestroy(pWinCtx); AssertRC(rc); @@ -416,5 +416,5 @@ char szWndClassName[32]; RTStrPrintf2(szWndClassName, sizeof(szWndClassName), - "%s-%RU64", VBOX_CLIPBOARD_WNDCLASS_NAME, RTThreadGetNative(hThreadSelf)); + "%s-%RU64", SHCL_WIN_WNDCLASS_NAME, RTThreadGetNative(hThreadSelf)); wc.lpszClassName = szWndClassName; @@ -444,8 +444,8 @@ SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE); - rc = VBoxClipboardWinChainAdd(&pCtx->Win); + rc = SharedClipboardWinChainAdd(&pCtx->Win); if (RT_SUCCESS(rc)) { - if (!VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI)) + if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) pWinCtx->oldAPI.timerRefresh = SetTimer(pWinCtx->hWnd, 0, 10 * 1000, NULL); } @@ -530,9 +530,9 @@ RT_ZERO(Formats); - rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats); + rc = SharedClipboardWinGetFormats(&pCtx->Win, &Formats); if ( RT_SUCCESS(rc) && Formats.uFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) { - rc = vboxSvcClipboardFormatsReport(pCtx->pClient, &Formats); + rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &Formats); } } @@ -548,16 +548,16 @@ */ -int VBoxClipboardSvcImplInit(void) -{ - /* Initialization is done in VBoxClipboardSvcImplConnect(). */ +int SharedClipboardSvcImplInit(void) +{ + /* Initialization is done in SharedClipboardSvcImplConnect(). */ return VINF_SUCCESS; } -void VBoxClipboardSvcImplDestroy(void) -{ - /* Destruction is done in VBoxClipboardSvcImplDisconnect(). */ -} - -int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) +void SharedClipboardSvcImplDestroy(void) +{ + /* Destruction is done in SharedClipboardSvcImplDisconnect(). */ +} + +int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) { RT_NOREF(fHeadless); @@ -571,5 +571,5 @@ { /* Check that new Clipboard API is available. */ - rc = VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI); + rc = SharedClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI); if (RT_SUCCESS(rc)) { @@ -587,5 +587,5 @@ /* Sync the host clipboard content with the client. */ - rc = VBoxClipboardSvcImplSync(pClient); + rc = SharedClipboardSvcImplSync(pClient); } else @@ -596,5 +596,5 @@ } -int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient) +int SharedClipboardSvcImplSync(PSHCLCLIENT pClient) { /* Sync the host clipboard content with the client. */ @@ -602,5 +602,5 @@ } -int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient) +int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -641,6 +641,6 @@ } -int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, - PSHCLFORMATDATA pFormats) +int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLFORMATDATA pFormats) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -658,12 +658,12 @@ { PSHCLURITRANSFER pTransfer; - rc = vboxSvcClipboardURITransferStart(pClient, - SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE, - &pTransfer); + rc = sharedClipboardSvcURITransferStart(pClient, + SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE, + &pTransfer); if (RT_SUCCESS(rc)) { /* Create the IDataObject implementation the host OS needs and assign * the newly created transfer to this object. */ - rc = VBoxClipboardWinURITransferCreate(&pCtx->Win, pTransfer); + rc = SharedClipboardWinURITransferCreate(&pCtx->Win, pTransfer); /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation @@ -678,5 +678,5 @@ * The guest announced formats. Forward to the window thread. */ - PostMessage(pCtx->Win.hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS, + PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_REPORT_FORMATS, 0 /* wParam */, pFormats->uFormats /* lParam */); @@ -691,6 +691,6 @@ } -int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, - PSHCLDATABLOCK pData, uint32_t *pcbActual) +int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData, uint32_t *pcbActual) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -707,5 +707,5 @@ * The guest wants to read data in the given format. */ - int rc = VBoxClipboardWinOpen(pWinCtx->hWnd); + int rc = SharedClipboardWinOpen(pWinCtx->hWnd); if (RT_SUCCESS(rc)) { @@ -758,5 +758,5 @@ else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML) { - UINT format = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML); + UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML); if (format != 0) { @@ -789,5 +789,5 @@ } #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ - VBoxClipboardWinClose(); + SharedClipboardWinClose(); } @@ -802,10 +802,10 @@ } -int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, - PSHCLDATABLOCK pData) +int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData) { LogFlowFuncEnter(); - int rc = vboxSvcClipboardDataReadSignal(pClient, pCmdCtx, pData); + int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData); LogFlowFuncLeaveRC(rc); @@ -814,5 +814,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) +int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClient, pTransfer); @@ -823,9 +823,9 @@ } -int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) +int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) { LogFlowFuncEnter(); - VBoxClipboardWinURITransferDestroy(&pClient->State.pCtx->Win, pTransfer); + SharedClipboardWinURITransferDestroy(&pClient->State.pCtx->Win, pTransfer); return VINF_SUCCESS; Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp (revision 80664) @@ -69,5 +69,5 @@ * after a save and restore of the guest. */ -int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient) +int SharedClipboardSvcImplSync(PSHCLCLIENT pClient) { RT_NOREF(pClient); @@ -81,5 +81,5 @@ * @param pClient Structure containing context information about the guest system */ -int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient) +int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient) { RT_NOREF(pClient); @@ -95,5 +95,5 @@ * @param pFormats Clipboard formats the guest is offering. */ -int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, +int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats) { @@ -110,5 +110,5 @@ * @param pcbActual Where to store the actual amount of data available. */ -int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, +int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual) { @@ -121,5 +121,5 @@ } -int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, +int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData) { Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp (revision 80664) @@ -72,5 +72,5 @@ formatData.uFormats = u32Formats; - int rc2 = vboxSvcClipboardFormatsReport(pCtx->pClient, &formatData); + int rc2 = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData); AssertRC(rc2); } @@ -80,5 +80,5 @@ * @note Host glue code */ -int VBoxClipboardSvcImplInit(void) +int SharedClipboardSvcImplInit(void) { LogFlowFuncEnter(); @@ -90,5 +90,5 @@ * @note host glue code */ -void VBoxClipboardSvcImplDestroy(void) +void SharedClipboardSvcImplDestroy(void) { LogFlowFuncEnter(); @@ -100,5 +100,5 @@ * the clipboard and leave ownership to X11. */ -int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) +int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless) { int rc = VINF_SUCCESS; @@ -142,5 +142,5 @@ * @note Host glue code */ -int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient) +int SharedClipboardSvcImplSync(PSHCLCLIENT pClient) { LogFlowFuncEnter(); @@ -154,5 +154,5 @@ formatData.uFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE; - return vboxSvcClipboardFormatsReport(pClient, &formatData); + return sharedClipboardSvcFormatsReport(pClient, &formatData); } @@ -161,5 +161,5 @@ * @note Host glue code */ -int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient) +int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient) { LogFlowFuncEnter(); @@ -174,5 +174,5 @@ /* If there is a currently pending request, release it immediately. */ SHCLDATABLOCK dataBlock = { 0, NULL, 0 }; - VBoxClipboardSvcImplWriteData(pClient, NULL, &dataBlock); + SharedClipboardSvcImplWriteData(pClient, NULL, &dataBlock); int rc = ClipStopX11(pCtx->pBackend); @@ -199,6 +199,6 @@ * @param pFormats Clipboard formats the guest is offering. */ -int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, - PSHCLFORMATDATA pFormats) +int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLFORMATDATA pFormats) { RT_NOREF(pCmdCtx); @@ -245,6 +245,6 @@ * */ -int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, - PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual) +int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, + PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual) { RT_NOREF(pCmdCtx); @@ -299,11 +299,11 @@ * @param pData Data block to write to clipboard. */ -int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, - PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData) +int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, + PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData) { LogFlowFunc(("pClient=%p, pv=%p, cb=%RU32, uFormat=%02X\n", pClient, pData->pvData, pData->cbData, pData->uFormat)); - int rc = vboxSvcClipboardDataReadSignal(pClient, pCmdCtx, pData); + int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData); LogFlowFuncLeaveRC(rc); @@ -368,5 +368,5 @@ SHCLEVENTID uEvent; - int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent); + int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent); if (RT_SUCCESS(rc)) { @@ -390,5 +390,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) +int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClient, pTransfer); @@ -396,5 +396,5 @@ } -int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) +int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) { RT_NOREF(pClient, pTransfer); Index: /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (revision 80664) @@ -224,7 +224,7 @@ * Prototypes * *********************************************************************************************************************************/ -static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID); -static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState); -static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState); +static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID); +static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState); +static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState); @@ -260,5 +260,5 @@ * @param puID Where to store the created event source ID on success. */ -int vboxSvcClipboardEventSourceCreateID(PSHCLEVENTSOURCEID puID) +int sharedClipboardSvcEventSourceCreateID(PSHCLEVENTSOURCEID puID) { AssertPtrReturn(puID, VERR_INVALID_POINTER); @@ -277,5 +277,5 @@ } -uint32_t vboxSvcClipboardGetMode(void) +uint32_t sharedClipboardSvcGetMode(void) { return g_uMode; @@ -286,5 +286,5 @@ uint32_t TestClipSvcGetMode(void) { - return vboxSvcClipboardGetMode(); + return sharedClipboardSvcGetMode(); } #endif @@ -296,5 +296,5 @@ } -static int vboxSvcClipboardModeSet(uint32_t uMode) +static int sharedClipboardSvcModeSet(uint32_t uMode) { int rc = VERR_NOT_SUPPORTED; @@ -343,5 +343,5 @@ * @param pClient Pointer to the client data structure to reset message queue for. */ -void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient) +void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient) { LogFlowFuncEnter(); @@ -361,5 +361,5 @@ * @param cParms Number of HGCM parameters to allocate. */ -PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms) +PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms) { PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG)); @@ -386,5 +386,5 @@ * The pointer will be invalid after calling this function. */ -void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg) +void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg) { if (!pMsg) @@ -407,5 +407,5 @@ * @remarks ASSUMES the parameters has been cleared by clientMsgPeek. */ -void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms) +void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms) { Assert(cDstParms >= 2); @@ -437,5 +437,5 @@ * @param cDstParms The number of peek parameters (at least two). */ -int vboxSvcClipboardMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms) +int sharedClipboardSvcMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms) { AssertPtrReturn(pMsg, VERR_INVALID_POINTER); @@ -494,5 +494,5 @@ * @param fAppend Whether to append or prepend the message to the queue. */ -int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend) +int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend) { AssertPtrReturn(pMsg, VERR_INVALID_POINTER); @@ -527,6 +527,6 @@ * immediately. */ -int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], - bool fWait) +int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], + bool fWait) { /* @@ -574,5 +574,5 @@ if (pFirstMsg) { - vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, paParms, cParms); + sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms); LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n", pClient->uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), @@ -616,5 +616,5 @@ * @param paParms Array of parameters. */ -int vboxSvcClipboardMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +int sharedClipboardSvcMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { int rc; @@ -640,5 +640,5 @@ pFirstMsg->m_cParms)); - rc = vboxSvcClipboardMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms); + rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms); if (RT_SUCCESS(rc)) { @@ -648,5 +648,5 @@ { pClient->queueMsg.removeFirst(); - vboxSvcClipboardMsgFree(pFirstMsg); + sharedClipboardSvcMsgFree(pFirstMsg); rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */ @@ -692,5 +692,5 @@ * @param paParms Array of parameters. */ -int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { /* @@ -782,5 +782,5 @@ { pClient->queueMsg.removeFirst(); - vboxSvcClipboardMsgFree(pFirstMsg); + sharedClipboardSvcMsgFree(pFirstMsg); } @@ -807,5 +807,5 @@ * @param pClient Client to wake up. */ -int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient) +int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient) { int rc = VINF_NO_CHANGE; @@ -830,10 +830,10 @@ if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT) { - vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms); + sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms); fDonePending = true; } else if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */ { - rc = vboxSvcClipboardMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms); + rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms); if (RT_SUCCESS(rc)) { @@ -841,5 +841,5 @@ * remove the actual message from our queue right now. */ pClient->queueMsg.removeFirst(); - vboxSvcClipboardMsgFree(pFirstMsg); + sharedClipboardSvcMsgFree(pFirstMsg); fDonePending = true; @@ -879,6 +879,6 @@ * @param puEvent Event ID for waiting for new data. Optional. */ -int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, - PSHCLEVENTID puEvent) +int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, + PSHCLEVENTID puEvent) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -888,6 +888,6 @@ int rc; - PSHCLCLIENTMSG pMsgReadData = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, - VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA); + PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, + VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA); if (pMsgReadData) { @@ -898,5 +898,5 @@ HGCMSvcSetU32(&pMsgReadData->m_paParms[2], pClient->State.cbChunkSize); - rc = vboxSvcClipboardMsgAdd(pClient, pMsgReadData, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */); if (RT_SUCCESS(rc)) { @@ -904,5 +904,5 @@ if (RT_SUCCESS(rc)) { - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); if (RT_SUCCESS(rc)) { @@ -922,6 +922,6 @@ } -int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, - PSHCLDATABLOCK pData) +int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, + PSHCLDATABLOCK pData) { SHCLEVENTID uEvent; @@ -952,5 +952,5 @@ } -int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats) +int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats) { AssertPtrReturn(pClient, VERR_INVALID_POINTER); @@ -959,5 +959,5 @@ int rc; - PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3); + PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3); if (pMsg) { @@ -968,7 +968,7 @@ HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */); - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); if (RT_SUCCESS(rc)) - rc = vboxSvcClipboardClientWakeup(pClient); + rc = sharedClipboardSvcClientWakeup(pClient); } else @@ -979,10 +979,10 @@ } -int vboxSvcClipboardGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) +int sharedClipboardSvcGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) { LogFlowFuncEnter(); - if ( vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST - && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) + if ( sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST + && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) { return VERR_NOT_SUPPORTED; @@ -1054,5 +1054,5 @@ } - rc = VBoxClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock); + rc = SharedClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock); } @@ -1061,5 +1061,5 @@ } -int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource) +int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource) { if (!pClient) /* If no client connected (anymore), bail out. */ @@ -1082,5 +1082,5 @@ #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST -int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient, +int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient, SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource, PSHCLURITRANSFER *ppTransfer) @@ -1103,20 +1103,20 @@ if (enmDir == SHCLURITRANSFERDIR_READ) { - rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer); + rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer); if (RT_SUCCESS(rc)) { creationCtx.enmSource = pClient->State.enmSource; - creationCtx.Interface.pfnTransferOpen = vboxSvcClipboardURITransferOpen; - creationCtx.Interface.pfnTransferClose = vboxSvcClipboardURITransferClose; - creationCtx.Interface.pfnListOpen = vboxSvcClipboardURIListOpen; - creationCtx.Interface.pfnListClose = vboxSvcClipboardURIListClose; - creationCtx.Interface.pfnObjOpen = vboxSvcClipboardURIObjOpen; - creationCtx.Interface.pfnObjClose = vboxSvcClipboardURIObjClose; - - creationCtx.Interface.pfnGetRoots = vboxSvcClipboardURIGetRoots; - creationCtx.Interface.pfnListHdrRead = vboxSvcClipboardURIListHdrRead; - creationCtx.Interface.pfnListEntryRead = vboxSvcClipboardURIListEntryRead; - creationCtx.Interface.pfnObjRead = vboxSvcClipboardURIObjRead; + creationCtx.Interface.pfnTransferOpen = sharedClipboardSvcURITransferOpen; + creationCtx.Interface.pfnTransferClose = sharedClipboardSvcURITransferClose; + creationCtx.Interface.pfnListOpen = sharedClipboardSvcURIListOpen; + creationCtx.Interface.pfnListClose = sharedClipboardSvcURIListClose; + creationCtx.Interface.pfnObjOpen = sharedClipboardSvcURIObjOpen; + creationCtx.Interface.pfnObjClose = sharedClipboardSvcURIObjClose; + + creationCtx.Interface.pfnGetRoots = sharedClipboardSvcURIGetRoots; + creationCtx.Interface.pfnListHdrRead = sharedClipboardSvcURIListHdrRead; + creationCtx.Interface.pfnListEntryRead = sharedClipboardSvcURIListEntryRead; + creationCtx.Interface.pfnObjRead = sharedClipboardSvcURIObjRead; creationCtx.pvUser = pClient; @@ -1146,8 +1146,8 @@ rc = SharedClipboardURICtxTransferAdd(&pClient->URI, pTransfer); if (RT_SUCCESS(rc)) - rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer); + rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer); if (RT_FAILURE(rc)) - VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer); + SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer); } @@ -1177,7 +1177,7 @@ if (RT_SUCCESS(rc)) { - vboxSvcClipboardModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF); - - rc = VBoxClipboardSvcImplInit(); + sharedClipboardSvcModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF); + + rc = SharedClipboardSvcImplInit(); /* Clean up on failure, because 'svnUnload' will not be called @@ -1197,5 +1197,5 @@ LogFlowFuncEnter(); - VBoxClipboardSvcImplDestroy(); + SharedClipboardSvcImplDestroy(); RTCritSectDelete(&g_CritSect); @@ -1216,13 +1216,13 @@ PSHCLURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, 0 /* Index*/); if (pTransfer) - vboxSvcClipboardURIAreaDetach(&pClient->State, pTransfer); + sharedClipboardSvcURIAreaDetach(&pClient->State, pTransfer); SharedClipboardURICtxDestroy(&pClient->URI); #endif - VBoxClipboardSvcImplDisconnect(pClient); - - vboxSvcClipboardClientStateReset(&pClient->State); - vboxSvcClipboardClientStateDestroy(&pClient->State); + SharedClipboardSvcImplDisconnect(pClient); + + sharedClipboardSvcClientStateReset(&pClient->State); + sharedClipboardSvcClientStateDestroy(&pClient->State); SharedClipboardEventSourceDestroy(&pClient->Events); @@ -1251,5 +1251,5 @@ /* Create the client's own event source. */ SHCLEVENTSOURCEID uEventSourceID; - int rc = vboxSvcClipboardEventSourceCreateID(&uEventSourceID); + int rc = sharedClipboardSvcEventSourceCreateID(&uEventSourceID); if (RT_SUCCESS(rc)) rc = SharedClipboardEventSourceCreate(&pClient->Events, uEventSourceID); @@ -1259,11 +1259,11 @@ /* Reset the client state. */ - vboxSvcClipboardClientStateReset(&pClient->State); + sharedClipboardSvcClientStateReset(&pClient->State); /* (Re-)initialize the client state. */ - rc = vboxSvcClipboardClientStateInit(&pClient->State, u32ClientID); + rc = sharedClipboardSvcClientStateInit(&pClient->State, u32ClientID); if (RT_SUCCESS(rc)) { - rc = VBoxClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless()); + rc = SharedClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless()); #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST if (RT_SUCCESS(rc)) @@ -1324,5 +1324,5 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD: { - rc = vboxSvcClipboardMsgGetOld(pClient, callHandle, cParms, paParms); + rc = sharedClipboardSvcMsgGetOld(pClient, callHandle, cParms, paParms); if (rc == VINF_HGCM_ASYNC_EXECUTE) fDoCallComplete = false; @@ -1344,5 +1344,5 @@ rc = VERR_INVALID_PARAMETER; } - else if (vboxSvcClipboardGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF) + else if (sharedClipboardSvcGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF) { rc = VERR_ACCESS_DENIED; @@ -1369,5 +1369,5 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT: { - rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/); + rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/); break; } @@ -1375,5 +1375,5 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT: { - rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/); + rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/); if (rc == VINF_HGCM_ASYNC_EXECUTE) fDoCallComplete = false; @@ -1383,5 +1383,5 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET: { - rc = vboxSvcClipboardMsgGet(pClient, callHandle, cParms, paParms); + rc = sharedClipboardSvcMsgGet(pClient, callHandle, cParms, paParms); if (rc == VINF_HGCM_ASYNC_EXECUTE) fDoCallComplete = false; @@ -1430,6 +1430,6 @@ if (RT_SUCCESS(rc)) { - if ( vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST - && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) + if ( sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST + && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) { rc = VERR_ACCESS_DENIED; @@ -1437,5 +1437,5 @@ else { - rc = vboxSvcClipboardSetSource(pClient, SHCLSOURCE_REMOTE); + rc = sharedClipboardSvcSetSource(pClient, SHCLSOURCE_REMOTE); if (RT_SUCCESS(rc)) { @@ -1458,5 +1458,5 @@ formatData.uFormats = uFormats; - rc = VBoxClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData); + rc = SharedClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData); } } @@ -1481,6 +1481,6 @@ else { - if ( vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST - && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) + if ( sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST + && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) { rc = VERR_ACCESS_DENIED; @@ -1506,5 +1506,5 @@ { /* Attach to the most recent clipboard area. */ - rc = vboxSvcClipboardURIAreaAttach(&pClient->State, pTransfer, 0 /* Area ID */); + rc = sharedClipboardSvcURIAreaAttach(&pClient->State, pTransfer, 0 /* Area ID */); if (RT_SUCCESS(rc)) { @@ -1516,7 +1516,7 @@ RT_ZERO(creationCtx.Interface); - creationCtx.Interface.pfnListHdrWrite = vboxSvcClipboardURIListHdrWrite; - creationCtx.Interface.pfnListEntryWrite = vboxSvcClipboardURIListEntryWrite; - creationCtx.Interface.pfnObjWrite = vboxSvcClipboardURIObjWrite; + creationCtx.Interface.pfnListHdrWrite = sharedClipboardSvcURIListHdrWrite; + creationCtx.Interface.pfnListEntryWrite = sharedClipboardSvcURIListEntryWrite; + creationCtx.Interface.pfnObjWrite = sharedClipboardSvcURIObjWrite; creationCtx.pvUser = pClient; @@ -1529,9 +1529,9 @@ if (RT_SUCCESS(rc)) { - rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer); + rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer); } else { - VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer); + SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer); SharedClipboardURITransferDestroy(pTransfer); } @@ -1582,5 +1582,5 @@ formatData.uFormats = g_ExtState.uDelayedFormats; - int rc2 = vboxSvcClipboardFormatsReport(pClient, &formatData); + int rc2 = sharedClipboardSvcFormatsReport(pClient, &formatData); AssertRC(rc2); @@ -1614,5 +1614,5 @@ dataBlock.uFormat = uFormat; - rc = VBoxClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual); + rc = SharedClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual); if (RT_SUCCESS(rc)) HGCMSvcSetU32(&paParms[2], cbActual); @@ -1630,5 +1630,5 @@ case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE: { - rc = vboxSvcClipboardGetDataWrite(pClient, cParms, paParms); + rc = sharedClipboardSvcGetDataWrite(pClient, cParms, paParms); break; } @@ -1637,5 +1637,5 @@ { #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST - rc = vboxSvcClipboardURIHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival); + rc = sharedClipboardSvcURIHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival); #else rc = VERR_NOT_IMPLEMENTED; @@ -1660,9 +1660,9 @@ * @param uClientID Client ID (HGCM) to use for this client state. */ -static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID) +static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID) { LogFlowFuncEnter(); - vboxSvcClipboardClientStateReset(pClientState); + sharedClipboardSvcClientStateReset(pClientState); /* Register the client. @@ -1680,5 +1680,5 @@ * @param pClientState Client state to destroy. */ -static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState) +static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState) { RT_NOREF(pClientState); @@ -1694,5 +1694,5 @@ * @param pClientState Client state to reset. */ -static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState) +static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState) { LogFlowFuncEnter(); @@ -1732,5 +1732,5 @@ rc = HGCMSvcGetU32(&paParms[0], &u32Mode); if (RT_SUCCESS(rc)) - rc = vboxSvcClipboardModeSet(u32Mode); + rc = sharedClipboardSvcModeSet(u32Mode); } @@ -1760,5 +1760,5 @@ { #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST - rc = vboxSvcClipboardURIHostHandler(u32Function, cParms, paParms); + rc = sharedClipboardSvcURIHostHandler(u32Function, cParms, paParms); #else rc = VERR_NOT_IMPLEMENTED; @@ -1809,5 +1809,5 @@ static SSMFIELD const s_aShClSSMClientMsgCtx[] = { - SSMFIELD_ENTRY(VBOXSHCLMSGCTX, uContextID), + SSMFIELD_ENTRY(SHCLMSGCTX, uContextID), SSMFIELD_ENTRY_TERM() }; @@ -1851,5 +1851,5 @@ AssertRCReturn(rc, rc); - rc = SSMR3PutStructEx(pSSM, &pMsg->m_Ctx, sizeof(VBOXSHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL); + rc = SSMR3PutStructEx(pSSM, &pMsg->m_Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL); AssertRCReturn(rc, rc); @@ -1941,5 +1941,5 @@ AssertRCReturn(rc, rc); - rc = SSMR3GetStructEx(pSSM, &pMsg->m_Ctx, sizeof(VBOXSHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL); + rc = SSMR3GetStructEx(pSSM, &pMsg->m_Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL); AssertRCReturn(rc, rc); @@ -1953,5 +1953,5 @@ } - rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */); + rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); AssertRCReturn(rc, rc); } @@ -1964,5 +1964,5 @@ /* Actual host data are to be reported to guest (SYNC). */ - VBoxClipboardSvcImplSync(pClient); + SharedClipboardSvcImplSync(pClient); #else /* UNIT_TEST */ @@ -2005,5 +2005,5 @@ formatData.uFormats = u32Format; - rc = vboxSvcClipboardFormatsReport(pClient, &formatData); + rc = sharedClipboardSvcFormatsReport(pClient, &formatData); } @@ -2020,5 +2020,5 @@ dataReq.cbSize = _64K; /** @todo Make this more dynamic. */ - rc = vboxSvcClipboardDataReadRequest(pClient, &dataReq, NULL /* puEvent */); + rc = sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */); break; } Index: /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp (revision 80663) +++ /trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp (revision 80664) @@ -123,6 +123,6 @@ 2, parms, 0); RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN); /* This should get updated only when the guest call completes. */ - vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, - VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT); + sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, + VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT); RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA); RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT); @@ -135,6 +135,6 @@ RTTestISub("Testing FN_GET_HOST_MSG, one format, no waiting guest calls."); RT_ZERO(g_Client.State); - vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, - VBOX_SHARED_CLIPBOARD_FMT_HTML); + sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, + VBOX_SHARED_CLIPBOARD_FMT_HTML); HGCMSvcSetU32(&parms[0], 0); HGCMSvcSetU32(&parms[1], 0); @@ -158,6 +158,6 @@ 2, parms, 0); RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN); /* This should get updated only when the guest call completes. */ - vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, - VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML); + sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, + VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML); RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA); RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT); @@ -176,6 +176,6 @@ RTTestISub("Testing FN_GET_HOST_MSG, two formats, no waiting guest calls."); RT_ZERO(g_Client.State); - vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, - VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML); + sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, + VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML); HGCMSvcSetU32(&parms[0], 0); HGCMSvcSetU32(&parms[1], 0); @@ -277,17 +277,17 @@ } -int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; } -void VBoxClipboardSvcImplDestroy() { } -int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT) +int SharedClipboardSvcImplInit() { return VINF_SUCCESS; } +void SharedClipboardSvcImplDestroy() { } +int SharedClipboardSvcImplDisconnect(PSHCLCLIENT) { return VINF_SUCCESS; } -int VBoxClipboardSvcImplConnect(PSHCLCLIENT, bool) +int SharedClipboardSvcImplConnect(PSHCLCLIENT, bool) { return VINF_SUCCESS; } -int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA) +int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA) { AssertFailed(); return VINF_SUCCESS; } -int VBoxClipboardSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *) +int SharedClipboardSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *) { AssertFailed(); return VERR_WRONG_ORDER; } -int VBoxClipboardSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK) +int SharedClipboardSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK) { AssertFailed(); return VINF_SUCCESS; } -int VBoxClipboardSvcImplSync(PSHCLCLIENT) +int SharedClipboardSvcImplSync(PSHCLCLIENT) { AssertFailed(); return VERR_WRONG_ORDER; }