VirtualBox

Changeset 80664 in vbox


Ignore:
Timestamp:
Sep 9, 2019 10:00:04 AM (5 years ago)
Author:
vboxsync
Message:

Shared Clipboard: More renaming + unification.

Location:
trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/GuestHost/SharedClipboard-win.h

    r80662 r80664  
    5252#endif
    5353
    54 #define VBOX_CLIPBOARD_WNDCLASS_NAME         "VBoxSharedClipboardClass"
     54#define SHCL_WIN_WNDCLASS_NAME        "VBoxSharedClipboardClass"
    5555
    5656/** See: https://docs.microsoft.com/en-us/windows/desktop/dataxchg/html-clipboard-format
    5757 *       Do *not* change the name, as this will break compatbility with other (legacy) applications! */
    58 #define VBOX_CLIPBOARD_WIN_REGFMT_HTML       "HTML Format"
     58#define SHCL_WIN_REGFMT_HTML          "HTML Format"
    5959
    6060/** Default timeout (in ms) for passing down messages down the clipboard chain. */
    61 #define VBOX_CLIPBOARD_CBCHAIN_TIMEOUT_MS   5000
     61#define SHCL_WIN_CBCHAIN_TIMEOUT_MS   5000
    6262
    6363/** Reports clipboard formats. */
    64 #define VBOX_CLIPBOARD_WM_REPORT_FORMATS    WM_USER
     64#define SHCL_WIN_WM_REPORT_FORMATS    WM_USER
    6565/** Reads data from the clipboard and sends it to the destination. */
    66 #define VBOX_CLIPBOARD_WM_READ_DATA         WM_USER + 1
     66#define SHCL_WIN_WM_READ_DATA         WM_USER + 1
    6767#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    6868/** Starts a reading transfer from the guest. */
    69 # define VBOX_CLIPBOARD_WM_URI_START_READ   WM_USER + 2
     69# define SHCL_WIN_WM_URI_START_READ   WM_USER + 2
    7070/** Starts a writing transfer to the guest. */
    71 # define VBOX_CLIPBOARD_WM_URI_START_WRITE  WM_USER + 3
     71# define SHCL_WIN_WM_URI_START_WRITE  WM_USER + 3
    7272#endif
    7373
    … …  
    106106{
    107107    /** Window handle of our (invisible) clipbaord window. */
    108     HWND                        hWnd;
     108    HWND               hWnd;
    109109    /** Window handle which is next to us in the clipboard chain. */
    110     HWND                        hWndNextInChain;
     110    HWND               hWndNextInChain;
    111111    /** Window handle of the clipboard owner *if* we are the owner. */
    112     HWND                        hWndClipboardOwnerUs;
     112    HWND               hWndClipboardOwnerUs;
    113113    /** Structure for maintaining the new clipboard API. */
    114114    SHCLWINAPINEW      newAPI;
    … …  
    117117} SHCLWINCTX, *PSHCLWINCTX;
    118118
    119 int VBoxClipboardWinOpen(HWND hWnd);
    120 int VBoxClipboardWinClose(void);
    121 int VBoxClipboardWinClear(void);
    122 
    123 int VBoxClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI);
    124 bool VBoxClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI);
    125 
    126 int VBoxClipboardWinChainAdd(PSHCLWINCTX pCtx);
    127 int VBoxClipboardWinChainRemove(PSHCLWINCTX pCtx);
    128 VOID CALLBACK VBoxClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult);
    129 LRESULT VBoxClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam);
    130 
    131 SHCLFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat);
    132 int VBoxClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats);
     119int SharedClipboardWinOpen(HWND hWnd);
     120int SharedClipboardWinClose(void);
     121int SharedClipboardWinClear(void);
     122
     123int SharedClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI);
     124bool SharedClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI);
     125
     126int SharedClipboardWinChainAdd(PSHCLWINCTX pCtx);
     127int SharedClipboardWinChainRemove(PSHCLWINCTX pCtx);
     128VOID CALLBACK SharedClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult);
     129LRESULT SharedClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, UINT msg, WPARAM wParam, LPARAM lParam);
     130
     131SHCLFORMAT SharedClipboardWinClipboardFormatToVBox(UINT uFormat);
     132int SharedClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats);
    133133
    134134#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    135 int VBoxClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList);
    136 #endif
    137 
    138 int VBoxClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue);
    139 bool VBoxClipboardWinIsCFHTML(const char *pszSource);
    140 int VBoxClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput);
    141 int VBoxClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput);
    142 
    143 LRESULT VBoxClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
    144 int VBoxClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx);
    145 int VBoxClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd);
    146 int VBoxClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx);
    147 
    148 int VBoxClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats);
     135int SharedClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList);
     136#endif
     137
     138int SharedClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue);
     139bool SharedClipboardWinIsCFHTML(const char *pszSource);
     140int SharedClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput);
     141int SharedClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput);
     142
     143LRESULT SharedClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
     144int SharedClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx);
     145int SharedClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd);
     146int SharedClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx);
     147
     148int SharedClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats);
    149149#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    150 int VBoxClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer);
    151 void VBoxClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer);
     150int SharedClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer);
     151void SharedClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer);
    152152#endif
    153153
    … …  
    158158#  endif
    159159
    160 class VBoxClipboardWinDataObject : public IDataObject //, public IDataObjectAsyncCapability
     160class SharedClipboardWinDataObject : public IDataObject //, public IDataObjectAsyncCapability
    161161{
    162162public:
    … …  
    170170public:
    171171
    172     VBoxClipboardWinDataObject(PSHCLURITRANSFER pTransfer,
    173                                LPFORMATETC pFormatEtc = NULL, LPSTGMEDIUM pStgMed = NULL, ULONG cFormats = 0);
    174     virtual ~VBoxClipboardWinDataObject(void);
     172    SharedClipboardWinDataObject(PSHCLURITRANSFER pTransfer,
     173                                 LPFORMATETC pFormatEtc = NULL, LPSTGMEDIUM pStgMed = NULL, ULONG cFormats = 0);
     174    virtual ~SharedClipboardWinDataObject(void);
    175175
    176176public: /* IUnknown methods. */
    … …  
    235235    {
    236236        /** Relative path of the object. */
    237         Utf8Str                  strPath;
     237        Utf8Str       strPath;
    238238        /** Related (cached) object information. */
    239239        SHCLFSOBJINFO objInfo;
    … …  
    248248    LPFORMATETC                 m_pFormatEtc;
    249249    LPSTGMEDIUM                 m_pStgMedium;
    250     PSHCLURITRANSFER m_pTransfer;
     250    PSHCLURITRANSFER            m_pTransfer;
    251251    IStream                    *m_pStream;
    252252    ULONG                       m_uObjIdx;
    … …  
    262262};
    263263
    264 class VBoxClipboardWinEnumFormatEtc : public IEnumFORMATETC
    265 {
    266 public:
    267 
    268     VBoxClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats);
    269     virtual ~VBoxClipboardWinEnumFormatEtc(void);
     264class SharedClipboardWinEnumFormatEtc : public IEnumFORMATETC
     265{
     266public:
     267
     268    SharedClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats);
     269    virtual ~SharedClipboardWinEnumFormatEtc(void);
    270270
    271271public: /* IUnknown methods. */
    … …  
    299299 * through HGCM. Needed on Windows hosts and guests.
    300300 */
    301 class VBoxClipboardWinStreamImpl : public IStream
    302 {
    303 public:
    304 
    305     VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
    306                                const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo);
    307     virtual ~VBoxClipboardWinStreamImpl(void);
     301class SharedClipboardWinStreamImpl : public IStream
     302{
     303public:
     304
     305    SharedClipboardWinStreamImpl(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
     306                                 const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo);
     307    virtual ~SharedClipboardWinStreamImpl(void);
    308308
    309309public: /* IUnknown methods. */
    … …  
    329329public: /* Own methods. */
    330330
    331     static HRESULT Create(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, const Utf8Str &strPath,
     331    static HRESULT Create(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer, const Utf8Str &strPath,
    332332                          PSHCLFSOBJINFO pObjInfo, IStream **ppStream);
    333333private:
    334334
    335335    /** Pointer to the parent data object. */
    336     VBoxClipboardWinDataObject    *m_pParent;
     336    SharedClipboardWinDataObject  *m_pParent;
    337337    /** The stream object's current reference count. */
    338338    LONG                           m_lRefCount;
    339339    /** Pointer to the associated URI transfer. */
    340     PSHCLURITRANSFER    m_pURITransfer;
     340    PSHCLURITRANSFER               m_pURITransfer;
    341341    /** The object handle to use. */
    342     SHCLOBJHANDLE       m_hObj;
     342    SHCLOBJHANDLE                  m_hObj;
    343343    /** Object path. */
    344344    Utf8Str                        m_strPath;
    345345    /** (Cached) object information. */
    346     SHCLFSOBJINFO       m_objInfo;
     346    SHCLFSOBJINFO                  m_objInfo;
    347347    /** Number of bytes already processed. */
    348348    uint64_t                       m_cbProcessed;
    … …  
    369369    /** Pointer to data object to use for this transfer.
    370370     *  Can be NULL if not being used. */
    371     VBoxClipboardWinDataObject *pDataObj;
     371    SharedClipboardWinDataObject *pDataObj;
    372372};
    373373# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp

    r80662 r80664  
    8787static SHCLCONTEXT g_Ctx = { NULL };
    8888/** Static window class name. */
    89 static char s_szClipWndClassName[] = VBOX_CLIPBOARD_WNDCLASS_NAME;
     89static char s_szClipWndClassName[] = SHCL_WIN_WNDCLASS_NAME;
    9090
    9191
    … …  
    428428                * Report available formats to the host. */
    429429               SHCLFORMATDATA Formats;
    430                int rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats);
     430               int rc = SharedClipboardWinGetFormats(&pCtx->Win, &Formats);
    431431               if (RT_SUCCESS(rc))
    432432               {
    … …  
    442442       {
    443443           LogFunc(("WM_CHANGECBCHAIN\n"));
    444            lresultRc = VBoxClipboardWinHandleWMChangeCBChain(pWinCtx, hwnd, msg, wParam, lParam);
     444           lresultRc = SharedClipboardWinHandleWMChangeCBChain(pWinCtx, hwnd, msg, wParam, lParam);
    445445           break;
    446446       }
    … …  
    455455               /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
    456456               SHCLFORMATDATA Formats;
    457                int rc = VBoxClipboardWinGetFormats(pWinCtx, &Formats);
     457               int rc = SharedClipboardWinGetFormats(pWinCtx, &Formats);
    458458               if (RT_SUCCESS(rc))
    459459                   rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
    460460           }
    461461
    462            lresultRc = VBoxClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam);
     462           lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam);
    463463           break;
    464464       }
    … …  
    466466       case WM_TIMER:
    467467       {
    468            int rc = VBoxClipboardWinHandleWMTimer(pWinCtx);
     468           int rc = SharedClipboardWinHandleWMTimer(pWinCtx);
    469469           AssertRC(rc);
    470470
    … …  
    485485           const UINT cfFormat = (UINT)wParam;
    486486
    487            const SHCLFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
     487           const SHCLFORMAT fFormat = SharedClipboardWinClipboardFormatToVBox(cfFormat);
    488488
    489489           LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
    … …  
    492492           {
    493493               LogFunc(("WM_RENDERFORMAT: Unsupported format requested\n"));
    494                VBoxClipboardWinClear();
     494               SharedClipboardWinClear();
    495495           }
    496496           else
    … …  
    632632           LogFunc(("WM_RENDERALLFORMATS\n"));
    633633
    634            int rc = VBoxClipboardWinHandleWMRenderAllFormats(pWinCtx, hwnd);
     634           int rc = SharedClipboardWinHandleWMRenderAllFormats(pWinCtx, hwnd);
    635635           AssertRC(rc);
    636636
    … …  
    638638       }
    639639
    640        case VBOX_CLIPBOARD_WM_REPORT_FORMATS:
     640       case SHCL_WIN_WM_REPORT_FORMATS:
    641641       {
    642642           LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n"));
    … …  
    651651           if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */
    652652           {
    653                int rc = VBoxClipboardWinOpen(hwnd);
     653               int rc = SharedClipboardWinOpen(hwnd);
    654654               if (RT_SUCCESS(rc))
    655655               {
    656                    VBoxClipboardWinClear();
     656                   SharedClipboardWinClear();
    657657
    658658#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    … …  
    665665                        if (pTransfer)
    666666                        {
    667                             rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
     667                            rc = SharedClipboardWinURITransferCreate(pWinCtx, pTransfer);
    668668
    669669                            /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
    … …  
    673673                            AssertFailedStmt(rc = VERR_NOT_FOUND);
    674674
    675                         /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */
     675                        /* Note: SharedClipboardWinURITransferCreate() takes care of closing the clipboard. */
    676676                    }
    677677                    else
    678678                    {
    679679#endif
    680                         rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats);
    681 
    682                         VBoxClipboardWinClose();
     680                        rc = SharedClipboardWinAnnounceFormats(pWinCtx, fFormats);
     681
     682                        SharedClipboardWinClose();
    683683#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    684684                    }
    … …  
    691691       }
    692692
    693        case VBOX_CLIPBOARD_WM_READ_DATA:
     693       case SHCL_WIN_WM_READ_DATA:
    694694       {
    695695           /* Send data in the specified format to the host. */
    … …  
    704704           LogFlowFunc(("VBOX_CLIPBOARD_WM_READ_DATA: uFormat=0x%x\n", uFormat));
    705705
    706            int rc = VBoxClipboardWinOpen(hwnd);
     706           int rc = SharedClipboardWinOpen(hwnd);
    707707           if (RT_SUCCESS(rc))
    708708           {
    … …  
    749749               else if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_HTML)
    750750               {
    751                    UINT format = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML);
     751                   UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
    752752                   if (format != 0)
    753753                   {
    … …  
    777777                   LogFunc(("cTransfersRunning=%RU32\n", SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
    778778
    779                    int rc = VBoxClipboardWinOpen(hwnd);
     779                   int rc = SharedClipboardWinOpen(hwnd);
    780780                   if (RT_SUCCESS(rc))
    781781                   {
    … …  
    799799                                       char    *papszList;
    800800                                       uint32_t cbList;
    801                                        rc = VBoxClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList);
     801                                       rc = SharedClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList);
    802802
    803803                                       GlobalUnlock(hClip);
    … …  
    840840                       }
    841841
    842                        VBoxClipboardWinClose();
     842                       SharedClipboardWinClose();
    843843                   }
    844844
    … …  
    859859               }
    860860
    861                VBoxClipboardWinClose();
     861               SharedClipboardWinClose();
    862862           }
    863863           break;
    … …  
    871871                    SharedClipboardURICtxGetRunningTransfers(&pCtx->URI)));
    872872
    873            int rc = VBoxClipboardWinOpen(hwnd);
     873           int rc = SharedClipboardWinOpen(hwnd);
    874874           if (RT_SUCCESS(rc))
    875875           {
    … …  
    893893                               char    *papszList;
    894894                               uint32_t cbList;
    895                                rc = VBoxClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList);
     895                               rc = SharedClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList);
    896896
    897897                               GlobalUnlock(hClip);
    … …  
    934934               }
    935935
    936                VBoxClipboardWinClose();
     936               SharedClipboardWinClose();
    937937           }
    938938
    … …  
    989989                       if (RT_SUCCESS(rc))
    990990                       {
    991                            rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer);
     991                           rc = SharedClipboardWinURITransferCreate(pWinCtx, pTransfer);
    992992                       }
    993993                   }
    … …  
    10041004           LogFunc(("WM_DESTROY\n"));
    10051005
    1006            int rc = VBoxClipboardWinHandleWMDestroy(pWinCtx);
     1006           int rc = SharedClipboardWinHandleWMDestroy(pWinCtx);
    10071007           AssertRC(rc);
    10081008
    … …  
    10741074                         SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE);
    10751075
    1076             VBoxClipboardWinChainAdd(pWinCtx);
    1077             if (!VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI))
     1076            SharedClipboardWinChainAdd(pWinCtx);
     1077            if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI))
    10781078                pWinCtx->oldAPI.timerRefresh = SetTimer(pWinCtx->hWnd, 0, 10 * 1000 /* 10s */, NULL);
    10791079        }
    … …  
    11461146    {
    11471147        /* Check if new Clipboard API is available. */
    1148         /* ignore rc */ VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
     1148        /* ignore rc */ SharedClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
    11491149
    11501150        rc = VbglR3ClipboardConnectEx(&pCtx->CmdCtx);
    … …  
    12681268                    * Forward the information to the window, so it can later
    12691269                    * respond to WM_RENDERFORMAT message. */
    1270                    ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
     1270                   ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_REPORT_FORMATS,
    12711271                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
    12721272                   break;
    … …  
    12761276               {
    12771277                   /* The host needs data in the specified format. */
    1278                    ::PostMessage(pWinCtx->hWnd, VBOX_CLIPBOARD_WM_READ_DATA,
     1278                   ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_READ_DATA,
    12791279                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
    12801280                   break;

  • trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp

    r80623 r80664  
    2121 * VirtualBox Guest Additions for Haiku.
    2222 * Copyright (c) 2011 Mike Smith <mike@scgtrp.net>
    23  *                    François Revol <revol@free.fr>
     23 *                    Fran�ois Revol <revol@free.fr>
    2424 *
    2525 * Permission is hereby granted, free of charge, to any person

  • trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp

    r80662 r80664  
    181181 * @returns VBox status code
    182182 */
    183 int VBoxClipboardSvcImplConnect(void)
     183int SharedClipboardSvcImplConnect(void)
    184184{
    185185    int rc = VINF_SUCCESS;
    … …  
    294294    if (RT_FAILURE(rc))
    295295        VBClFatalError(("Failed to connect to the VirtualBox kernel service, rc=%Rrc\n", rc));
    296     rc = VBoxClipboardSvcImplConnect();
     296    rc = SharedClipboardSvcImplConnect();
    297297    /* Not RT_SUCCESS: VINF_PERMISSION_DENIED is host service not present. */
    298298    if (rc == VINF_SUCCESS)

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp

    r80662 r80664  
    4141//#define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 0
    4242
    43 VBoxClipboardWinDataObject::VBoxClipboardWinDataObject(PSHCLURITRANSFER pTransfer,
    44                                                        LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
     43SharedClipboardWinDataObject::SharedClipboardWinDataObject(PSHCLURITRANSFER pTransfer,
     44                                                           LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
    4545    : m_enmStatus(Uninitialized)
    4646    , m_lRefCount(0)
    … …  
    129129}
    130130
    131 VBoxClipboardWinDataObject::~VBoxClipboardWinDataObject(void)
     131SharedClipboardWinDataObject::~SharedClipboardWinDataObject(void)
    132132{
    133133    RTSemEventDestroy(m_EventListComplete);
    … …  
    153153 */
    154154
    155 STDMETHODIMP_(ULONG) VBoxClipboardWinDataObject::AddRef(void)
     155STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::AddRef(void)
    156156{
    157157    LONG lCount = InterlockedIncrement(&m_lRefCount);
    … …  
    160160}
    161161
    162 STDMETHODIMP_(ULONG) VBoxClipboardWinDataObject::Release(void)
     162STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::Release(void)
    163163{
    164164    LONG lCount = InterlockedDecrement(&m_lRefCount);
    … …  
    173173}
    174174
    175 STDMETHODIMP VBoxClipboardWinDataObject::QueryInterface(REFIID iid, void **ppvObject)
     175STDMETHODIMP SharedClipboardWinDataObject::QueryInterface(REFIID iid, void **ppvObject)
    176176{
    177177    AssertPtrReturn(ppvObject, E_INVALIDARG);
    … …  
    198198 * @param   phGlobal            Where to store the allocated HGLOBAL object.
    199199 */
    200 int VBoxClipboardWinDataObject::copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal)
     200int SharedClipboardWinDataObject::copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal)
    201201{
    202202    AssertPtrReturn(phGlobal, VERR_INVALID_POINTER);
    … …  
    229229 * @param   strDir              Directory path to handle.
    230230 */
    231 int VBoxClipboardWinDataObject::readDir(PSHCLURITRANSFER pTransfer, const Utf8Str &strDir)
     231int SharedClipboardWinDataObject::readDir(PSHCLURITRANSFER pTransfer, const Utf8Str &strDir)
    232232{
    233233    LogFlowFunc(("strDir=%s\n", strDir.c_str()));
    … …  
    309309 * @returns VBox status code.
    310310 * @param   ThreadSelf          Thread handle. Unused at the moment.
    311  * @param   pvUser              Pointer to user-provided data. Of type VBoxClipboardWinDataObject.
     311 * @param   pvUser              Pointer to user-provided data. Of type SharedClipboardWinDataObject.
    312312 */
    313313/* static */
    314 DECLCALLBACK(int) VBoxClipboardWinDataObject::readThread(RTTHREAD ThreadSelf, void *pvUser)
     314DECLCALLBACK(int) SharedClipboardWinDataObject::readThread(RTTHREAD ThreadSelf, void *pvUser)
    315315{
    316316    RT_NOREF(ThreadSelf);
    … …  
    318318    LogFlowFuncEnter();
    319319
    320     VBoxClipboardWinDataObject *pThis = (VBoxClipboardWinDataObject *)pvUser;
     320    SharedClipboardWinDataObject *pThis = (SharedClipboardWinDataObject *)pvUser;
    321321
    322322    PSHCLURITRANSFER pTransfer = pThis->m_pTransfer;
    … …  
    405405 * @param   phGlobal            Where to store the allocated HGLOBAL object on success.
    406406 */
    407 int VBoxClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLURITRANSFER pTransfer,
     407int SharedClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLURITRANSFER pTransfer,
    408408                                                                      bool fUnicode, HGLOBAL *phGlobal)
    409409{
    … …  
    529529 * @param   pMedium
    530530 */
    531 STDMETHODIMP VBoxClipboardWinDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
     531STDMETHODIMP SharedClipboardWinDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
    532532{
    533533    AssertPtrReturn(pFormatEtc, DV_E_FORMATETC);
    … …  
    564564            {
    565565                /* Start the transfer asynchronously in a separate thread. */
    566                 rc = SharedClipboardURITransferRun(m_pTransfer, &VBoxClipboardWinDataObject::readThread, this);
     566                rc = SharedClipboardURITransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this);
    567567                if (RT_SUCCESS(rc))
    568568                {
    … …  
    614614
    615615            /* Hand-in the provider so that our IStream implementation can continue working with it. */
    616             hr = VBoxClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer,
    617                                                     fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHCLFSOBJINFO */,
    618                                                     &m_pStream);
     616            hr = SharedClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer,
     617                                                      fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHCLFSOBJINFO */,
     618                                                      &m_pStream);
    619619            if (SUCCEEDED(hr))
    620620            {
    … …  
    650650 * @param   pMedium
    651651 */
    652 STDMETHODIMP VBoxClipboardWinDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
     652STDMETHODIMP SharedClipboardWinDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium)
    653653{
    654654    RT_NOREF(pFormatEtc, pMedium);
    … …  
    664664 * @param   pFormatEtc
    665665 */
    666 STDMETHODIMP VBoxClipboardWinDataObject::QueryGetData(LPFORMATETC pFormatEtc)
     666STDMETHODIMP SharedClipboardWinDataObject::QueryGetData(LPFORMATETC pFormatEtc)
    667667{
    668668    LogFlowFunc(("\n"));
    … …  
    670670}
    671671
    672 STDMETHODIMP VBoxClipboardWinDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut)
     672STDMETHODIMP SharedClipboardWinDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut)
    673673{
    674674    RT_NOREF(pFormatEtc);
    … …  
    680680}
    681681
    682 STDMETHODIMP VBoxClipboardWinDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease)
     682STDMETHODIMP SharedClipboardWinDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease)
    683683{
    684684    RT_NOREF(pFormatEtc, pMedium, fRelease);
    … …  
    688688}
    689689
    690 STDMETHODIMP VBoxClipboardWinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc)
     690STDMETHODIMP SharedClipboardWinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc)
    691691{
    692692    LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n", dwDirection, m_cFormats, m_pFormatEtc));
    … …  
    694694    HRESULT hr;
    695695    if (dwDirection == DATADIR_GET)
    696         hr = VBoxClipboardWinEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc);
     696        hr = SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc);
    697697    else
    698698        hr = E_NOTIMPL;
    … …  
    702702}
    703703
    704 STDMETHODIMP VBoxClipboardWinDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink *pAdvSink, DWORD *pdwConnection)
     704STDMETHODIMP SharedClipboardWinDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink *pAdvSink, DWORD *pdwConnection)
    705705{
    706706    RT_NOREF(pFormatEtc, fAdvise, pAdvSink, pdwConnection);
    … …  
    708708}
    709709
    710 STDMETHODIMP VBoxClipboardWinDataObject::DUnadvise(DWORD dwConnection)
     710STDMETHODIMP SharedClipboardWinDataObject::DUnadvise(DWORD dwConnection)
    711711{
    712712    RT_NOREF(dwConnection);
    … …  
    714714}
    715715
    716 STDMETHODIMP VBoxClipboardWinDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise)
     716STDMETHODIMP SharedClipboardWinDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise)
    717717{
    718718    RT_NOREF(ppEnumAdvise);
    … …  
    725725 */
    726726
    727 STDMETHODIMP VBoxClipboardWinDataObject::EndOperation(HRESULT hResult, IBindCtx *pbcReserved, DWORD dwEffects)
     727STDMETHODIMP SharedClipboardWinDataObject::EndOperation(HRESULT hResult, IBindCtx *pbcReserved, DWORD dwEffects)
    728728{
    729729     RT_NOREF(hResult, pbcReserved, dwEffects);
    … …  
    731731}
    732732
    733 STDMETHODIMP VBoxClipboardWinDataObject::GetAsyncMode(BOOL *pfIsOpAsync)
     733STDMETHODIMP SharedClipboardWinDataObject::GetAsyncMode(BOOL *pfIsOpAsync)
    734734{
    735735     RT_NOREF(pfIsOpAsync);
    … …  
    737737}
    738738
    739 STDMETHODIMP VBoxClipboardWinDataObject::InOperation(BOOL *pfInAsyncOp)
     739STDMETHODIMP SharedClipboardWinDataObject::InOperation(BOOL *pfInAsyncOp)
    740740{
    741741     RT_NOREF(pfInAsyncOp);
    … …  
    743743}
    744744
    745 STDMETHODIMP VBoxClipboardWinDataObject::SetAsyncMode(BOOL fDoOpAsync)
     745STDMETHODIMP SharedClipboardWinDataObject::SetAsyncMode(BOOL fDoOpAsync)
    746746{
    747747     RT_NOREF(fDoOpAsync);
    … …  
    749749}
    750750
    751 STDMETHODIMP VBoxClipboardWinDataObject::StartOperation(IBindCtx *pbcReserved)
     751STDMETHODIMP SharedClipboardWinDataObject::StartOperation(IBindCtx *pbcReserved)
    752752{
    753753     RT_NOREF(pbcReserved);
    … …  
    760760 */
    761761
    762 int VBoxClipboardWinDataObject::Init(void)
     762int SharedClipboardWinDataObject::Init(void)
    763763{
    764764    LogFlowFuncLeaveRC(VINF_SUCCESS);
    … …  
    766766}
    767767
    768 void VBoxClipboardWinDataObject::OnTransferComplete(int rc /* = VINF_SUCESS */)
     768void SharedClipboardWinDataObject::OnTransferComplete(int rc /* = VINF_SUCESS */)
    769769{
    770770    RT_NOREF(rc);
    … …  
    785785}
    786786
    787 void VBoxClipboardWinDataObject::OnTransferCanceled(void)
     787void SharedClipboardWinDataObject::OnTransferCanceled(void)
    788788{
    789789    LogFlowFuncEnter();
    … …  
    799799
    800800/* static */
    801 const char* VBoxClipboardWinDataObject::ClipboardFormatToString(CLIPFORMAT fmt)
     801const char* SharedClipboardWinDataObject::ClipboardFormatToString(CLIPFORMAT fmt)
    802802{
    803803#if 0
    … …  
    881881}
    882882
    883 bool VBoxClipboardWinDataObject::lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex)
     883bool SharedClipboardWinDataObject::lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex)
    884884{
    885885    AssertReturn(pFormatEtc, false);
    … …  
    894894        {
    895895            LogRel3(("Shared Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",
    896                       pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(m_pFormatEtc[i].cfFormat),
     896                      pFormatEtc->tymed, pFormatEtc->cfFormat, SharedClipboardWinDataObject::ClipboardFormatToString(m_pFormatEtc[i].cfFormat),
    897897                      pFormatEtc->dwAspect, i));
    898898            if (puIndex)
    … …  
    903903
    904904    LogRel3(("Shared Clipboard: Format NOT found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32\n",
    905              pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
     905             pFormatEtc->tymed, pFormatEtc->cfFormat, SharedClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
    906906             pFormatEtc->dwAspect));
    907907
    … …  
    909909}
    910910
    911 void VBoxClipboardWinDataObject::registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat,
    912                                                 TYMED tyMed, LONG lIndex, DWORD dwAspect,
    913                                                 DVTARGETDEVICE *pTargetDevice)
     911void SharedClipboardWinDataObject::registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat,
     912                                                  TYMED tyMed, LONG lIndex, DWORD dwAspect,
     913                                                  DVTARGETDEVICE *pTargetDevice)
    914914{
    915915    AssertPtr(pFormatEtc);
    … …  
    922922
    923923    LogFlowFunc(("Registered format=%ld, sFormat=%s\n",
    924                  pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat)));
    925 }
    926 
     924                 pFormatEtc->cfFormat, SharedClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat)));
     925}
     926

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp

    r78809 r80664  
    3131
    3232
    33 VBoxClipboardWinEnumFormatEtc::VBoxClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats)
     33SharedClipboardWinEnumFormatEtc::SharedClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats)
    3434    : m_lRefCount(1),
    3535      m_nIndex(0)
    … …  
    4545        {
    4646            LogFlowFunc(("Format %RU32: cfFormat=%RI16, sFormat=%s, tyMed=%RU32, dwAspect=%RU32\n",
    47                          i, pFormatEtc[i].cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc[i].cfFormat),
     47                         i, pFormatEtc[i].cfFormat, SharedClipboardWinDataObject::ClipboardFormatToString(pFormatEtc[i].cfFormat),
    4848                         pFormatEtc[i].tymed, pFormatEtc[i].dwAspect));
    49             VBoxClipboardWinEnumFormatEtc::CopyFormat(&m_pFormatEtc[i], &pFormatEtc[i]);
     49            SharedClipboardWinEnumFormatEtc::CopyFormat(&m_pFormatEtc[i], &pFormatEtc[i]);
    5050        }
    5151
    … …  
    6161}
    6262
    63 VBoxClipboardWinEnumFormatEtc::~VBoxClipboardWinEnumFormatEtc(void)
     63SharedClipboardWinEnumFormatEtc::~SharedClipboardWinEnumFormatEtc(void)
    6464{
    6565    if (m_pFormatEtc)
    … …  
    8282 */
    8383
    84 STDMETHODIMP_(ULONG) VBoxClipboardWinEnumFormatEtc::AddRef(void)
     84STDMETHODIMP_(ULONG) SharedClipboardWinEnumFormatEtc::AddRef(void)
    8585{
    8686    return InterlockedIncrement(&m_lRefCount);
    8787}
    8888
    89 STDMETHODIMP_(ULONG) VBoxClipboardWinEnumFormatEtc::Release(void)
     89STDMETHODIMP_(ULONG) SharedClipboardWinEnumFormatEtc::Release(void)
    9090{
    9191    LONG lCount = InterlockedDecrement(&m_lRefCount);
    … …  
    100100}
    101101
    102 STDMETHODIMP VBoxClipboardWinEnumFormatEtc::QueryInterface(REFIID iid, void **ppvObject)
     102STDMETHODIMP SharedClipboardWinEnumFormatEtc::QueryInterface(REFIID iid, void **ppvObject)
    103103{
    104104    if (   iid == IID_IEnumFORMATETC
    … …  
    114114}
    115115
    116 STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Next(ULONG cFormats, LPFORMATETC pFormatEtc, ULONG *pcFetched)
     116STDMETHODIMP SharedClipboardWinEnumFormatEtc::Next(ULONG cFormats, LPFORMATETC pFormatEtc, ULONG *pcFetched)
    117117{
    118118    ULONG ulCopied  = 0;
    … …  
    124124           && ulCopied < cFormats)
    125125    {
    126         VBoxClipboardWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied], &m_pFormatEtc[m_nIndex]);
     126        SharedClipboardWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied], &m_pFormatEtc[m_nIndex]);
    127127        ulCopied++;
    128128        m_nIndex++;
    … …  
    135135}
    136136
    137 STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Skip(ULONG cFormats)
     137STDMETHODIMP SharedClipboardWinEnumFormatEtc::Skip(ULONG cFormats)
    138138{
    139139    m_nIndex += cFormats;
    … …  
    141141}
    142142
    143 STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Reset(void)
     143STDMETHODIMP SharedClipboardWinEnumFormatEtc::Reset(void)
    144144{
    145145    m_nIndex = 0;
    … …  
    147147}
    148148
    149 STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Clone(IEnumFORMATETC **ppEnumFormatEtc)
     149STDMETHODIMP SharedClipboardWinEnumFormatEtc::Clone(IEnumFORMATETC **ppEnumFormatEtc)
    150150{
    151151    HRESULT hResult = CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc);
    152152    if (hResult == S_OK)
    153         ((VBoxClipboardWinEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex;
     153        ((SharedClipboardWinEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex;
    154154
    155155    return hResult;
    … …  
    157157
    158158/* static */
    159 void VBoxClipboardWinEnumFormatEtc::CopyFormat(LPFORMATETC pDest, LPFORMATETC pSource)
     159void SharedClipboardWinEnumFormatEtc::CopyFormat(LPFORMATETC pDest, LPFORMATETC pSource)
    160160{
    161161    AssertPtrReturnVoid(pDest);
    … …  
    172172
    173173/* static */
    174 HRESULT VBoxClipboardWinEnumFormatEtc::CreateEnumFormatEtc(UINT nNumFormats, LPFORMATETC pFormatEtc, IEnumFORMATETC **ppEnumFormatEtc)
     174HRESULT SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(UINT nNumFormats, LPFORMATETC pFormatEtc, IEnumFORMATETC **ppEnumFormatEtc)
    175175{
    176176    AssertReturn(nNumFormats, E_INVALIDARG);
    … …  
    181181    try
    182182    {
    183         *ppEnumFormatEtc = new VBoxClipboardWinEnumFormatEtc(pFormatEtc, nNumFormats);
     183        *ppEnumFormatEtc = new SharedClipboardWinEnumFormatEtc(pFormatEtc, nNumFormats);
    184184        hr = S_OK;
    185185    }

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp

    r80662 r80664  
    4646
    4747
    48 VBoxClipboardWinStreamImpl::VBoxClipboardWinStreamImpl(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
    49                                                        const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo)
     48SharedClipboardWinStreamImpl::SharedClipboardWinStreamImpl(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
     49                                                           const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo)
    5050    : m_pParent(pParent)
    5151    , m_lRefCount(1) /* Our IDataObjct *always* holds the last reference to this object; needed for the callbacks. */
    … …  
    6262}
    6363
    64 VBoxClipboardWinStreamImpl::~VBoxClipboardWinStreamImpl(void)
     64SharedClipboardWinStreamImpl::~SharedClipboardWinStreamImpl(void)
    6565{
    6666    LogFlowThisFuncEnter();
    … …  
    7171 */
    7272
    73 STDMETHODIMP VBoxClipboardWinStreamImpl::QueryInterface(REFIID iid, void **ppvObject)
     73STDMETHODIMP SharedClipboardWinStreamImpl::QueryInterface(REFIID iid, void **ppvObject)
    7474{
    7575    AssertPtrReturn(ppvObject, E_INVALIDARG);
    … …  
    100100}
    101101
    102 STDMETHODIMP_(ULONG) VBoxClipboardWinStreamImpl::AddRef(void)
     102STDMETHODIMP_(ULONG) SharedClipboardWinStreamImpl::AddRef(void)
    103103{
    104104    LONG lCount = InterlockedIncrement(&m_lRefCount);
    … …  
    107107}
    108108
    109 STDMETHODIMP_(ULONG) VBoxClipboardWinStreamImpl::Release(void)
     109STDMETHODIMP_(ULONG) SharedClipboardWinStreamImpl::Release(void)
    110110{
    111111    LONG lCount = InterlockedDecrement(&m_lRefCount);
    … …  
    130130 */
    131131
    132 STDMETHODIMP VBoxClipboardWinStreamImpl::Clone(IStream** ppStream)
     132STDMETHODIMP SharedClipboardWinStreamImpl::Clone(IStream** ppStream)
    133133{
    134134    RT_NOREF(ppStream);
    … …  
    138138}
    139139
    140 STDMETHODIMP VBoxClipboardWinStreamImpl::Commit(DWORD dwFrags)
     140STDMETHODIMP SharedClipboardWinStreamImpl::Commit(DWORD dwFrags)
    141141{
    142142    RT_NOREF(dwFrags);
    … …  
    146146}
    147147
    148 STDMETHODIMP VBoxClipboardWinStreamImpl::CopyTo(IStream *pDestStream, ULARGE_INTEGER nBytesToCopy, ULARGE_INTEGER *nBytesRead,
    149                                                 ULARGE_INTEGER *nBytesWritten)
     148STDMETHODIMP SharedClipboardWinStreamImpl::CopyTo(IStream *pDestStream, ULARGE_INTEGER nBytesToCopy, ULARGE_INTEGER *nBytesRead,
     149                                                  ULARGE_INTEGER *nBytesWritten)
    150150{
    151151    RT_NOREF(pDestStream, nBytesToCopy, nBytesRead, nBytesWritten);
    … …  
    155155}
    156156
    157 STDMETHODIMP VBoxClipboardWinStreamImpl::LockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes,DWORD dwFlags)
     157STDMETHODIMP SharedClipboardWinStreamImpl::LockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes,DWORD dwFlags)
    158158{
    159159    RT_NOREF(nStart, nBytes, dwFlags);
    … …  
    164164
    165165/* Note: Windows seems to assume EOF if nBytesRead < nBytesToRead. */
    166 STDMETHODIMP VBoxClipboardWinStreamImpl::Read(void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead)
     166STDMETHODIMP SharedClipboardWinStreamImpl::Read(void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead)
    167167{
    168168    LogFlowThisFunc(("Enter: m_cbProcessed=%RU64\n", m_cbProcessed));
    … …  
    266266}
    267267
    268 STDMETHODIMP VBoxClipboardWinStreamImpl::Revert(void)
    269 {
    270     LogFlowThisFuncEnter();
    271     return E_NOTIMPL;
    272 }
    273 
    274 STDMETHODIMP VBoxClipboardWinStreamImpl::Seek(LARGE_INTEGER nMove, DWORD dwOrigin, ULARGE_INTEGER* nNewPos)
     268STDMETHODIMP SharedClipboardWinStreamImpl::Revert(void)
     269{
     270    LogFlowThisFuncEnter();
     271    return E_NOTIMPL;
     272}
     273
     274STDMETHODIMP SharedClipboardWinStreamImpl::Seek(LARGE_INTEGER nMove, DWORD dwOrigin, ULARGE_INTEGER* nNewPos)
    275275{
    276276    RT_NOREF(nMove, dwOrigin, nNewPos);
    … …  
    281281}
    282282
    283 STDMETHODIMP VBoxClipboardWinStreamImpl::SetSize(ULARGE_INTEGER nNewSize)
     283STDMETHODIMP SharedClipboardWinStreamImpl::SetSize(ULARGE_INTEGER nNewSize)
    284284{
    285285    RT_NOREF(nNewSize);
    … …  
    289289}
    290290
    291 STDMETHODIMP VBoxClipboardWinStreamImpl::Stat(STATSTG *pStatStg, DWORD dwFlags)
     291STDMETHODIMP SharedClipboardWinStreamImpl::Stat(STATSTG *pStatStg, DWORD dwFlags)
    292292{
    293293    HRESULT hr = S_OK;
    … …  
    331331}
    332332
    333 STDMETHODIMP VBoxClipboardWinStreamImpl::UnlockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes, DWORD dwFlags)
     333STDMETHODIMP SharedClipboardWinStreamImpl::UnlockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes, DWORD dwFlags)
    334334{
    335335    RT_NOREF(nStart, nBytes, dwFlags);
    … …  
    339339}
    340340
    341 STDMETHODIMP VBoxClipboardWinStreamImpl::Write(const void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead)
     341STDMETHODIMP SharedClipboardWinStreamImpl::Write(const void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead)
    342342{
    343343    RT_NOREF(pvBuffer, nBytesToRead, nBytesRead);
    … …  
    362362 */
    363363/* static */
    364 HRESULT VBoxClipboardWinStreamImpl::Create(VBoxClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
    365                                            const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo,
    366                                            IStream **ppStream)
     364HRESULT SharedClipboardWinStreamImpl::Create(SharedClipboardWinDataObject *pParent, PSHCLURITRANSFER pTransfer,
     365                                             const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo,
     366                                             IStream **ppStream)
    367367{
    368368    AssertPtrReturn(pTransfer, E_POINTER);
    369369
    370     VBoxClipboardWinStreamImpl *pStream = new VBoxClipboardWinStreamImpl(pParent, pTransfer, strPath, pObjInfo);
     370    SharedClipboardWinStreamImpl *pStream = new SharedClipboardWinStreamImpl(pParent, pTransfer, strPath, pObjInfo);
    371371    if (pStream)
    372372    {

  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp

    r80662 r80664  
    4747 * @param   hWnd                Handle of window to open clipboard for.
    4848 */
    49 int VBoxClipboardWinOpen(HWND hWnd)
     49int SharedClipboardWinOpen(HWND hWnd)
    5050{
    5151    /* "OpenClipboard fails if another window has the clipboard open."
    … …  
    9595 * @returns VBox status code.
    9696 */
    97 int VBoxClipboardWinClose(void)
     97int SharedClipboardWinClose(void)
    9898{
    9999    int rc;
    … …  
    123123 * @returns VBox status code.
    124124 */
    125 int VBoxClipboardWinClear(void)
     125int SharedClipboardWinClear(void)
    126126{
    127127    int rc;
    … …  
    154154 *                              Will be set to NULL if the new API is not available.
    155155 */
    156 int VBoxClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI)
     156int SharedClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI)
    157157{
    158158    RTLDRMOD hUser32 = NIL_RTLDRMOD;
    … …  
    188188 * @param   pAPI                Structure used for checking if the new clipboard API is available or not.
    189189 */
    190 bool VBoxClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI)
     190bool SharedClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI)
    191191{
    192192    if (!pAPI)
    … …  
    201201 * @param   pCtx                Windows clipboard context to use to add ourselves.
    202202 */
    203 int VBoxClipboardWinChainAdd(PSHCLWINCTX pCtx)
     203int SharedClipboardWinChainAdd(PSHCLWINCTX pCtx)
    204204{
    205205    const PSHCLWINAPINEW pAPI = &pCtx->newAPI;
    206206
    207207    BOOL fRc;
    208     if (VBoxClipboardWinIsNewAPI(pAPI))
     208    if (SharedClipboardWinIsNewAPI(pAPI))
    209209    {
    210210        fRc = pAPI->pfnAddClipboardFormatListener(pCtx->hWnd);
    … …  
    234234 * @param   pCtx                Windows clipboard context to use to remove ourselves.
    235235 */
    236 int VBoxClipboardWinChainRemove(PSHCLWINCTX pCtx)
     236int SharedClipboardWinChainRemove(PSHCLWINCTX pCtx)
    237237{
    238238    if (!pCtx->hWnd)
    … …  
    242242
    243243    BOOL fRc;
    244     if (VBoxClipboardWinIsNewAPI(pAPI))
     244    if (SharedClipboardWinIsNewAPI(pAPI))
    245245    {
    246246        fRc = pAPI->pfnRemoveClipboardFormatListener(pCtx->hWnd);
    … …  
    276276 * @param   lResult             Additional data to pass. Not used currently.
    277277 */
    278 VOID CALLBACK VBoxClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult)
     278VOID CALLBACK SharedClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult)
    279279{
    280280    RT_NOREF(hWnd);
    … …  
    298298 * @param   lParam              LPARAM to pass.
    299299 */
    300 LRESULT VBoxClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx,
     300LRESULT SharedClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx,
    301301                                        UINT msg, WPARAM wParam, LPARAM lParam)
    302302{
    … …  
    312312        DWORD_PTR dwResult;
    313313        lresultRc = SendMessageTimeout(pWinCtx->hWndNextInChain, msg, wParam, lParam, 0,
    314                                        VBOX_CLIPBOARD_CBCHAIN_TIMEOUT_MS, &dwResult);
     314                                       SHCL_WIN_CBCHAIN_TIMEOUT_MS, &dwResult);
    315315        if (!lresultRc)
    316316            lresultRc = dwResult;
    … …  
    327327 * @param   uFormat             Windows clipboard format to convert.
    328328 */
    329 SHCLFORMAT VBoxClipboardWinClipboardFormatToVBox(UINT uFormat)
     329SHCLFORMAT SharedClipboardWinClipboardFormatToVBox(UINT uFormat)
    330330{
    331331    /* Insert the requested clipboard format data into the clipboard. */
    … …  
    361361                    LogFlowFunc(("uFormat=%u -> szFormatName=%s\n", uFormat, szFormatName));
    362362
    363                     if (RTStrCmp(szFormatName, VBOX_CLIPBOARD_WIN_REGFMT_HTML) == 0)
     363                    if (RTStrCmp(szFormatName, SHCL_WIN_REGFMT_HTML) == 0)
    364364                        vboxFormat = VBOX_SHARED_CLIPBOARD_FMT_HTML;
    365365#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    … …  
    386386 * @param   pFormats            Where to store the retrieved formats.
    387387 */
    388 int VBoxClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats)
     388int SharedClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATDATA pFormats)
    389389{
    390390    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
    … …  
    394394
    395395    /* Query list of available formats and report to host. */
    396     int rc = VBoxClipboardWinOpen(pCtx->hWnd);
     396    int rc = SharedClipboardWinOpen(pCtx->hWnd);
    397397    if (RT_SUCCESS(rc))
    398398    {
    399399        UINT uCurFormat = 0; /* Must be set to zero for EnumClipboardFormats(). */
    400400        while ((uCurFormat = EnumClipboardFormats(uCurFormat)) != 0)
    401             fFormats |= VBoxClipboardWinClipboardFormatToVBox(uCurFormat);
    402 
    403         int rc2 = VBoxClipboardWinClose();
     401            fFormats |= SharedClipboardWinClipboardFormatToVBox(uCurFormat);
     402
     403        int rc2 = SharedClipboardWinClose();
    404404        AssertRC(rc2);
    405405    }
    … …  
    428428 * @param   puValue     Where to return extracted value of CF_HTML field.
    429429 */
    430 int VBoxClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue)
     430int SharedClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue)
    431431{
    432432    AssertPtrReturn(pszSrc, VERR_INVALID_POINTER);
    … …  
    452452 * @param   pszSource   Source string to check.
    453453 */
    454 bool VBoxClipboardWinIsCFHTML(const char *pszSource)
     454bool SharedClipboardWinIsCFHTML(const char *pszSource)
    455455{
    456456    return    RTStrStr(pszSource, "Version:") != NULL
    … …  
    469469 * @param   pcbOutput   Where to the return length of the result (bytes/chars).
    470470 */
    471 int VBoxClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput)
     471int SharedClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput)
    472472{
    473473    Assert(pszSource);
    … …  
    477477
    478478    uint32_t offStart;
    479     int rc = VBoxClipboardWinGetCFHTMLHeaderValue(pszSource, "StartFragment:", &offStart);
     479    int rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "StartFragment:", &offStart);
    480480    if (RT_SUCCESS(rc))
    481481    {
    482482        uint32_t offEnd;
    483         rc = VBoxClipboardWinGetCFHTMLHeaderValue(pszSource, "EndFragment:", &offEnd);
     483        rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "EndFragment:", &offEnd);
    484484        if (RT_SUCCESS(rc))
    485485        {
    … …  
    556556 * @note    Everything inside of fragment can be UTF8. Windows allows it. Everything in header should be Latin1.
    557557 */
    558 int VBoxClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput)
     558int SharedClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput)
    559559{
    560560    Assert(ppszOutput);
    … …  
    649649 * @param   lParam              lParam to pass on.
    650650 */
    651 LRESULT VBoxClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx,
     651LRESULT SharedClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx,
    652652                                              HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    653653{
    … …  
    656656    LogFlowFuncEnter();
    657657
    658     if (VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI))
     658    if (SharedClipboardWinIsNewAPI(&pWinCtx->newAPI))
    659659    {
    660660        lresultRc = DefWindowProc(hWnd, msg, wParam, lParam);
    … …  
    679679                DWORD_PTR dwResult;
    680680                lresultRc = SendMessageTimeout(pWinCtx->hWndNextInChain, WM_CHANGECBCHAIN, wParam, lParam, 0,
    681                                                 VBOX_CLIPBOARD_CBCHAIN_TIMEOUT_MS,
     681                                                SHCL_WIN_CBCHAIN_TIMEOUT_MS,
    682682                                                &dwResult);
    683683                if (!lresultRc)
    … …  
    697697 * @param   pWinCtx             Windows context to use.
    698698 */
    699 int VBoxClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx)
     699int SharedClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx)
    700700{
    701701    LogFlowFuncEnter();
    … …  
    704704
    705705    /* MS recommends to remove from Clipboard chain in this callback. */
    706     VBoxClipboardWinChainRemove(pWinCtx);
     706    SharedClipboardWinChainRemove(pWinCtx);
    707707
    708708    if (pWinCtx->oldAPI.timerRefresh)
    … …  
    723723 * @param   hWnd                Window handle to use.
    724724 */
    725 int VBoxClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd)
     725int SharedClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd)
    726726{
    727727    RT_NOREF(pWinCtx);
    … …  
    732732     * windows is to be destroyed and therefore the guest side becomes inactive.
    733733     */
    734     int rc = VBoxClipboardWinOpen(hWnd);
     734    int rc = SharedClipboardWinOpen(hWnd);
    735735    if (RT_SUCCESS(rc))
    736736    {
    737         VBoxClipboardWinClear();
    738         VBoxClipboardWinClose();
     737        SharedClipboardWinClear();
     738        SharedClipboardWinClose();
    739739    }
    740740
    … …  
    750750 * @param   pWinCtx             Windows context to use.
    751751 */
    752 int VBoxClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx)
     752int SharedClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx)
    753753{
    754754    int rc = VINF_SUCCESS;
    755755
    756     if (!VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI)) /* Only run when using the "old" Windows API. */
     756    if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) /* Only run when using the "old" Windows API. */
    757757    {
    758758        LogFlowFuncEnter();
    … …  
    764764        if (!hViewer || pWinCtx->oldAPI.fCBChainPingInProcess)
    765765        {
    766             VBoxClipboardWinChainRemove(pWinCtx);
    767             VBoxClipboardWinChainAdd(pWinCtx);
     766            SharedClipboardWinChainRemove(pWinCtx);
     767            SharedClipboardWinChainAdd(pWinCtx);
    768768       }
    769769
    … …  
    775775       if (hViewer)
    776776           SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pWinCtx->hWndNextInChain, (LPARAM)pWinCtx->hWndNextInChain,
    777                                VBoxClipboardWinChainPingProc, (ULONG_PTR)pWinCtx);
     777                               SharedClipboardWinChainPingProc, (ULONG_PTR)pWinCtx);
    778778    }
    779779
    … …  
    790790 * @param   fFormats            Clipboard format(s) to announce.
    791791 */
    792 int VBoxClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats)
     792int SharedClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats)
    793793{
    794794    LogFunc(("fFormats=0x%x\n", fFormats));
    … …  
    815815    {
    816816        LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_HTML\n"));
    817         cfFormat = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML);
     817        cfFormat = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
    818818        if (cfFormat != 0)
    819819            hClip = SetClipboardData(cfFormat, NULL);
    … …  
    846846 * @param   pTransfer           URI transfer to use.
    847847 */
    848 int VBoxClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer)
     848int SharedClipboardWinURITransferCreate(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer)
    849849{
    850850    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    … …  
    862862        pTransfer->cbUser = sizeof(SharedClipboardWinURITransferCtx);
    863863
    864         pWinURITransferCtx->pDataObj = new VBoxClipboardWinDataObject(pTransfer);
     864        pWinURITransferCtx->pDataObj = new SharedClipboardWinDataObject(pTransfer);
    865865        if (pWinURITransferCtx->pDataObj)
    866866        {
    … …  
    868868            if (RT_SUCCESS(rc))
    869869            {
    870                 VBoxClipboardWinClose();
     870                SharedClipboardWinClose();
    871871                /* Note: Clipboard must be closed first before calling OleSetClipboard(). */
    872872
    873                 /** @todo There is a potential race between VBoxClipboardWinClose() and OleSetClipboard(),
     873                /** @todo There is a potential race between SharedClipboardWinClose() and OleSetClipboard(),
    874874                 *        where another application could own the clipboard (open), and thus the call to
    875875                 *        OleSetClipboard() will fail. Needs (better) fixing. */
    … …  
    912912 * @param   pTransfer           URI transfer to create implementation-specific data for.
    913913 */
    914 void VBoxClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer)
     914void SharedClipboardWinURITransferDestroy(PSHCLWINCTX pWinCtx, PSHCLURITRANSFER pTransfer)
    915915{
    916916    RT_NOREF(pWinCtx);
    … …  
    949949 * @param   pcbList             Where to store the size (in bytes) of the allocated string list.
    950950 */
    951 int VBoxClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList)
     951int SharedClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList)
    952952{
    953953    AssertPtrReturn(pDropFiles, VERR_INVALID_POINTER);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp

    r80662 r80664  
    5454
    5555/**
    56  * Checks if something is present on the clipboard and calls vboxSvcClipboardReportMsg.
     56 * Checks if something is present on the clipboard and calls sharedClipboardSvcReportMsg.
    5757 *
    5858 * @returns IPRT status code (ignored).
    … …  
    7676        formatData.uFormats = fFormats;
    7777
    78         rc = vboxSvcClipboardFormatsReport(pCtx->pClient, &formatData);
     78        rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData);
    7979    }
    8080
    … …  
    117117
    118118
    119 int VBoxClipboardSvcImplInit(void)
     119int SharedClipboardSvcImplInit(void)
    120120{
    121121    Log(("vboxClipboardInit\n"));
    … …  
    137137}
    138138
    139 void VBoxClipboardSvcImplDestroy(void)
     139void SharedClipboardSvcImplDestroy(void)
    140140{
    141141    /*
    … …  
    156156}
    157157
    158 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     158int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    159159{
    160160    RT_NOREF(fHeadless);
    … …  
    172172
    173173    /* Initially sync the host clipboard content with the client. */
    174     int rc = VBoxClipboardSvcImplSync(pClient);
    175 
    176     VBoxSvcClipboardUnlock();
    177     return rc;
    178 }
    179 
    180 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
     174    int rc = SharedClipboardSvcImplSync(pClient);
     175
     176    VBoxSvcClipboardUnlock();
     177    return rc;
     178}
     179
     180int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
    181181{
    182182    /* Sync the host clipboard content with the client. */
    … …  
    190190}
    191191
    192 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     192int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    193193{
    194194    VBoxSvcClipboardLock();
    … …  
    201201}
    202202
    203 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient,
     203int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient,
    204204                                       PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats)
    205205{
    … …  
    225225    dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    226226
    227     return vboxSvcClipboardDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
     227    return sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
    228228}
    229229
    … …  
    236236 * @param pcbActual             Where to write the actual size of the written data.
    237237 */
    238 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     238int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    239239                                 PSHCLDATABLOCK pData, uint32_t *pcbActual)
    240240{
    … …  
    262262 * @param pData                 Data block to write to clipboard.
    263263 */
    264 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient,
     264int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient,
    265265                                  PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
    266266{
    … …  
    277277
    278278#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    279 int VBoxClipboardSvcImplURIReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
     279int SharedClipboardSvcImplURIReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
    280280{
    281281    RT_NOREF(pClient, pDirData);
    … …  
    283283}
    284284
    285 int VBoxClipboardSvcImplURIWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
     285int SharedClipboardSvcImplURIWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
    286286{
    287287    RT_NOREF(pClient, pDirData);
    … …  
    289289}
    290290
    291 int VBoxClipboardSvcImplURIReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
     291int SharedClipboardSvcImplURIReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
    292292{
    293293    RT_NOREF(pClient, pFileHdr);
    … …  
    295295}
    296296
    297 int VBoxClipboardSvcImplURIWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
     297int SharedClipboardSvcImplURIWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
    298298{
    299299    RT_NOREF(pClient, pFileHdr);
    … …  
    301301}
    302302
    303 int VBoxClipboardSvcImplURIReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
     303int SharedClipboardSvcImplURIReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
    304304{
    305305    RT_NOREF(pClient, pFileData);
    … …  
    307307}
    308308
    309 int VBoxClipboardSvcImplURIWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
     309int SharedClipboardSvcImplURIWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
    310310{
    311311    RT_NOREF(pClient, pFileData);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h

    r80662 r80664  
    4646 * Structure for keeping a Shared Clipboard HGCM message context.
    4747 */
    48 typedef struct _VBOXSHCLMSGCTX
     48typedef struct _SHCLMSGCTX
    4949{
    5050    /** Context ID. */
    5151    uint32_t uContextID;
    52 } VBOXSHCLMSGCTX, *PVBOXSHCLMSGCTX;
     52} SHCLMSGCTX, *PSHCLMSGCTX;
    5353
    5454/**
    … …  
    6464    PVBOXHGCMSVCPARM m_paParms;
    6565    /** Message context. */
    66     VBOXSHCLMSGCTX   m_Ctx;
     66    SHCLMSGCTX       m_Ctx;
    6767} SHCLCLIENTMSG, *PSHCLCLIENTMSG;
    6868
    … …  
    178178 * The service functions. Locking is between the service thread and the platform-dependent (window) thread.
    179179 */
    180 int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
    181 int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
    182 int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
    183 
    184 uint32_t vboxSvcClipboardGetMode(void);
    185 int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
    186 
    187 void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient);
    188 PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms);
    189 void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg);
    190 void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
    191 int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
    192 int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
    193 int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    194 
    195 int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient);
     180int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
     181int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     182int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
     183
     184uint32_t sharedClipboardSvcGetMode(void);
     185int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
     186
     187void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient);
     188PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms);
     189void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg);
     190void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
     191int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
     192int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
     193int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     194
     195int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient);
    196196
    197197# ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    198 int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient,
     198int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient,
    199199                                     SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,
    200200                                     PSHCLURITRANSFER *ppTransfer);
    201 bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
     201bool sharedClipboardSvcURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
    202202# endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    203203
    … …  
    205205 * Platform-dependent implementations.
    206206 */
    207 int VBoxClipboardSvcImplInit(void);
    208 void VBoxClipboardSvcImplDestroy(void);
    209 
    210 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
    211 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient);
    212 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
     207int SharedClipboardSvcImplInit(void);
     208void SharedClipboardSvcImplDestroy(void);
     209
     210int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
     211int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient);
     212int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
    213213/** @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read data.*/
    214 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
    215 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     214int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
     215int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
    216216/**
    217217 * Synchronise the contents of the host clipboard with the guest, called by the HGCM layer
    218218 * after a save and restore of the guest.
    219219 */
    220 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient);
     220int SharedClipboardSvcImplSync(PSHCLCLIENT pClient);
    221221
    222222#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    223 int vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx);
    224 DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx);
    225 
    226 int vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
    227 
    228 int vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx,
     223int sharedClipboardSvcURITransferOpen(PSHCLPROVIDERCTX pCtx);
     224DECLCALLBACK(int) sharedClipboardSvcURITransferClose(PSHCLPROVIDERCTX pCtx);
     225
     226int sharedClipboardSvcURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
     227
     228int sharedClipboardSvcURIListOpen(PSHCLPROVIDERCTX pCtx,
    229229                                PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
    230 int vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
    231 int vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     230int sharedClipboardSvcURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
     231int sharedClipboardSvcURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    232232                                   PSHCLLISTHDR pListHdr);
    233 int vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     233int sharedClipboardSvcURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    234234                                    PSHCLLISTHDR pListHdr);
    235 int vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     235int sharedClipboardSvcURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    236236                                     PSHCLLISTENTRY pListEntry);
    237 int vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
     237int sharedClipboardSvcURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    238238                                      PSHCLLISTENTRY pListEntry);
    239239
    240 int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     240int sharedClipboardSvcURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    241241                               PSHCLOBJHANDLE phObj);
    242 int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
    243 int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     242int sharedClipboardSvcURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
     243int sharedClipboardSvcURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    244244                               void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
    245 int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     245int sharedClipboardSvcURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    246246                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
    247247
    … …  
    253253DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHCLURITRANSFERCALLBACKDATA pData, int rc);
    254254
    255 int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
    256 int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
     255int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
     256int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer);
    257257#endif /*VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    258258

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp

    r80662 r80664  
    4848*   Prototypes                                                                                                                   *
    4949*********************************************************************************************************************************/
    50 static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    51                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
    52 static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    53                                            PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
     50static int sharedClipboardSvcURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     51                                            PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
     52static int sharedClipboardSvcURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     53                                             PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
    5454
    5555
    … …  
    5858*********************************************************************************************************************************/
    5959
    60 DECLCALLBACK(int) vboxSvcClipboardURITransferOpen(PSHCLPROVIDERCTX pCtx)
     60DECLCALLBACK(int) sharedClipboardSvcURITransferOpen(PSHCLPROVIDERCTX pCtx)
    6161{
    6262    RT_NOREF(pCtx);
    … …  
    6666}
    6767
    68 DECLCALLBACK(int) vboxSvcClipboardURITransferClose(PSHCLPROVIDERCTX pCtx)
     68DECLCALLBACK(int) sharedClipboardSvcURITransferClose(PSHCLPROVIDERCTX pCtx)
    6969{
    7070    RT_NOREF(pCtx);
    … …  
    7474}
    7575
    76 DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
     76DECLCALLBACK(int) sharedClipboardSvcURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
    7777{
    7878    LogFlowFuncEnter();
    … …  
    8383    int rc;
    8484
    85     PSHCLCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
     85    PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
    8686                                                               VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
    8787    if (pMsgHdr)
    … …  
    9292        HGCMSvcSetU32(&pMsgHdr->m_paParms[1], 0 /* fRoots */);
    9393
    94         rc = vboxSvcClipboardMsgAdd(pClient, pMsgHdr, true /* fAppend */);
     94        rc = sharedClipboardSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
    9595        if (RT_SUCCESS(rc))
    9696        {
    … …  
    9898            AssertRC(rc2);
    9999
    100             rc = vboxSvcClipboardClientWakeup(pClient);
     100            rc = sharedClipboardSvcClientWakeup(pClient);
    101101            if (RT_SUCCESS(rc))
    102102            {
    … …  
    123123                                for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++)
    124124                                {
    125                                     PSHCLCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
     125                                    PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
    126126                                                                                                 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    127127
    … …  
    136136                                    AssertRC(rc2);
    137137
    138                                     rc = vboxSvcClipboardMsgAdd(pClient, pMsgEntry, true /* fAppend */);
     138                                    rc = sharedClipboardSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
    139139                                    if (RT_FAILURE(rc))
    140140                                        break;
    … …  
    190190}
    191191
    192 DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHCLPROVIDERCTX pCtx,
    193                                               PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
     192DECLCALLBACK(int) sharedClipboardSvcURIListOpen(PSHCLPROVIDERCTX pCtx,
     193                                                PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
    194194{
    195195    LogFlowFuncEnter();
    … …  
    200200    int rc;
    201201
    202     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
    203                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
     202    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN,
     203                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
    204204    if (pMsg)
    205205    {
    … …  
    208208        pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    209209
    210         rc = vboxSvcClipboardURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, pOpenParms);
    211         if (RT_SUCCESS(rc))
    212         {
    213             rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     210        rc = sharedClipboardSvcURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, pOpenParms);
     211        if (RT_SUCCESS(rc))
     212        {
     213            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    214214            if (RT_SUCCESS(rc))
    215215            {
    … …  
    217217                AssertRC(rc2);
    218218
    219                 rc = vboxSvcClipboardClientWakeup(pClient);
     219                rc = sharedClipboardSvcClientWakeup(pClient);
    220220                if (RT_SUCCESS(rc))
    221221                {
    … …  
    248248}
    249249
    250 DECLCALLBACK(int) vboxSvcClipboardURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
     250DECLCALLBACK(int) sharedClipboardSvcURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
    251251{
    252252    LogFlowFuncEnter();
    … …  
    257257    int rc;
    258258
    259     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
     259    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
    260260                                                            VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
    261261    if (pMsg)
    … …  
    265265        pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    266266
    267         rc = vboxSvcClipboardURISetListClose(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, hList);
    268         if (RT_SUCCESS(rc))
    269         {
    270             rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     267        rc = sharedClipboardSvcURISetListClose(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, hList);
     268        if (RT_SUCCESS(rc))
     269        {
     270            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    271271            if (RT_SUCCESS(rc))
    272272            {
    … …  
    274274                AssertRC(rc2);
    275275
    276                 rc = vboxSvcClipboardClientWakeup(pClient);
     276                rc = sharedClipboardSvcClientWakeup(pClient);
    277277                if (RT_SUCCESS(rc))
    278278                {
    … …  
    294294}
    295295
    296 DECLCALLBACK(int) vboxSvcClipboardURIListHdrRead(PSHCLPROVIDERCTX pCtx,
    297                                                  SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     296DECLCALLBACK(int) sharedClipboardSvcURIListHdrRead(PSHCLPROVIDERCTX pCtx,
     297                                                   SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    298298{
    299299    LogFlowFuncEnter();
    … …  
    304304    int rc;
    305305
    306     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
    307                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
     306    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ,
     307                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ_REQ);
    308308    if (pMsg)
    309309    {
    … …  
    314314        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */);
    315315
    316         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     316        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    317317        if (RT_SUCCESS(rc))
    318318        {
    … …  
    320320            AssertRC(rc2);
    321321
    322             rc = vboxSvcClipboardClientWakeup(pClient);
     322            rc = sharedClipboardSvcClientWakeup(pClient);
    323323            if (RT_SUCCESS(rc))
    324324            {
    … …  
    344344}
    345345
    346 DECLCALLBACK(int) vboxSvcClipboardURIListHdrWrite(PSHCLPROVIDERCTX pCtx,
    347                                                   SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     346DECLCALLBACK(int) sharedClipboardSvcURIListHdrWrite(PSHCLPROVIDERCTX pCtx,
     347                                                    SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    348348{
    349349    RT_NOREF(pCtx, hList, pListHdr);
    … …  
    354354}
    355355
    356 DECLCALLBACK(int) vboxSvcClipboardURIListEntryRead(PSHCLPROVIDERCTX pCtx,
    357                                                    SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
     356DECLCALLBACK(int) sharedClipboardSvcURIListEntryRead(PSHCLPROVIDERCTX pCtx,
     357                                                     SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    358358{
    359359    LogFlowFuncEnter();
    … …  
    364364    int rc;
    365365
    366     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
    367                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
     366    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ,
     367                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
    368368    if (pMsg)
    369369    {
    … …  
    374374        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */);
    375375
    376         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     376        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    377377        if (RT_SUCCESS(rc))
    378378        {
    … …  
    380380            AssertRC(rc2);
    381381
    382             rc = vboxSvcClipboardClientWakeup(pClient);
     382            rc = sharedClipboardSvcClientWakeup(pClient);
    383383            if (RT_SUCCESS(rc))
    384384            {
    … …  
    403403}
    404404
    405 DECLCALLBACK(int) vboxSvcClipboardURIListEntryWrite(PSHCLPROVIDERCTX pCtx,
    406                                                     SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
     405DECLCALLBACK(int) sharedClipboardSvcURIListEntryWrite(PSHCLPROVIDERCTX pCtx,
     406                                                      SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    407407{
    408408    RT_NOREF(pCtx, hList, pListEntry);
    … …  
    413413}
    414414
    415 int vboxSvcClipboardURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    416                                PSHCLOBJHANDLE phObj)
     415int sharedClipboardSvcURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     416                                 PSHCLOBJHANDLE phObj)
    417417{
    418418    LogFlowFuncEnter();
    … …  
    423423    int rc;
    424424
    425     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
    426                                                             VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
     425    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
     426                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
    427427    if (pMsg)
    428428    {
    … …  
    439439        HGCMSvcSetU32(&pMsg->m_paParms[4], pCreateParms->fCreate);
    440440
    441         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     441        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    442442        if (RT_SUCCESS(rc))
    443443        {
    … …  
    445445            AssertRC(rc2);
    446446
    447             rc = vboxSvcClipboardClientWakeup(pClient);
     447            rc = sharedClipboardSvcClientWakeup(pClient);
    448448            if (RT_SUCCESS(rc))
    449449            {
    … …  
    473473}
    474474
    475 int vboxSvcClipboardURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
     475int sharedClipboardSvcURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
    476476{
    477477    LogFlowFuncEnter();
    … …  
    482482    int rc;
    483483
    484     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
     484    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
    485485                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
    486486    if (pMsg)
    … …  
    491491        HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
    492492
    493         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     493        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    494494        if (RT_SUCCESS(rc))
    495495        {
    … …  
    497497            AssertRC(rc2);
    498498
    499             rc = vboxSvcClipboardClientWakeup(pClient);
     499            rc = sharedClipboardSvcClientWakeup(pClient);
    500500            if (RT_SUCCESS(rc))
    501501            {
    … …  
    525525}
    526526
    527 int vboxSvcClipboardURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    528                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
     527int sharedClipboardSvcURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     528                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    529529{
    530530    LogFlowFuncEnter();
    … …  
    535535    int rc;
    536536
    537     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
     537    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
    538538                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
    539539    if (pMsg)
    … …  
    546546        HGCMSvcSetU32(&pMsg->m_paParms[3], fFlags);
    547547
    548         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     548        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    549549        if (RT_SUCCESS(rc))
    550550        {
    … …  
    552552            AssertRC(rc2);
    553553
    554             rc = vboxSvcClipboardClientWakeup(pClient);
     554            rc = sharedClipboardSvcClientWakeup(pClient);
    555555            if (RT_SUCCESS(rc))
    556556            {
    … …  
    583583}
    584584
    585 int vboxSvcClipboardURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    586                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
     585int sharedClipboardSvcURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     586                                  void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    587587{
    588588    LogFlowFuncEnter();
    … …  
    593593    int rc;
    594594
    595     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
     595    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
    596596                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
    597597    if (pMsg)
    … …  
    604604        HGCMSvcSetU64(&pMsg->m_paParms[3], fFlags);
    605605
    606         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     606        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    607607        if (RT_SUCCESS(rc))
    608608        {
    … …  
    610610            AssertRC(rc2);
    611611
    612             rc = vboxSvcClipboardClientWakeup(pClient);
     612            rc = sharedClipboardSvcClientWakeup(pClient);
    613613            if (RT_SUCCESS(rc))
    614614            {
    … …  
    688688 * @param   pReply              Where to store the reply.
    689689 */
    690 static int vboxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    691                                        PSHCLREPLY pReply)
     690static int sharedClipboardSvcURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     691                                         PSHCLREPLY pReply)
    692692{
    693693    int rc;
    … …  
    756756 * @param   pRootLstHdr         Where to store the URI root list header on success.
    757757 */
    758 static int vboxSvcClipboardURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    759                                              PSHCLROOTLISTHDR pRootLstHdr)
     758static int sharedClipboardSvcURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     759                                               PSHCLROOTLISTHDR pRootLstHdr)
    760760{
    761761    int rc;
    … …  
    782782 * @param   pListEntry          Where to store the root list entry.
    783783 */
    784 static int vboxSvcClipboardURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    785                                                PSHCLROOTLISTENTRY pListEntry)
     784static int sharedClipboardSvcURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     785                                                 PSHCLROOTLISTENTRY pListEntry)
    786786{
    787787    int rc;
    … …  
    819819 * @param   pOpenParms          Where to store the open parameters of the request.
    820820 */
    821 static int vboxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    822                                           PSHCLLISTOPENPARMS pOpenParms)
     821static int sharedClipboardSvcURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     822                                            PSHCLLISTOPENPARMS pOpenParms)
    823823{
    824824    int rc;
    … …  
    866866 * @param   pOpenParms          List open parameters to set.
    867867 */
    868 static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    869                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
     868static int sharedClipboardSvcURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     869                                            PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
    870870{
    871871    int rc;
    … …  
    899899 * @param   hList               Handle of list to close.
    900900 */
    901 static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    902                                            PVBOXSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
     901static int sharedClipboardSvcURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     902                                             PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
    903903{
    904904    int rc;
    … …  
    927927 * @param   pListHdr            Where to store the list header.
    928928 */
    929 static int vboxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    930                                          PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
     929static int sharedClipboardSvcURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     930                                           PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
    931931{
    932932    int rc;
    … …  
    966966 * @param   pListHdr            Pointer to data to set to the HGCM parameters.
    967967 */
    968 static int vboxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    969                                          PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
     968static int sharedClipboardSvcURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     969                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
    970970{
    971971    int rc;
    … …  
    10011001 * @param   pListEntry          Where to store the list entry.
    10021002 */
    1003 static int vboxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    1004                                            PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
     1003static int sharedClipboardSvcURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     1004                                             PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
    10051005{
    10061006    int rc;
    … …  
    10471047 * @param   pListEntry          Pointer to data to set to the HGCM parameters.
    10481048 */
    1049 static int vboxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     1049static int sharedClipboardSvcURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    10501050                                           PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry)
    10511051{
    … …  
    10791079 * @param   pDataChunk          Where to store the object data chunk data.
    10801080 */
    1081 static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
     1081static int sharedClipboardSvcURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
    10821082{
    10831083    AssertPtrReturn(paParms,    VERR_INVALID_PARAMETER);
    … …  
    11171117 * @param   pRc                 Where to store the received error code.
    11181118 */
    1119 static int vboxSvcClipboardURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
     1119static int sharedClipboardSvcURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
    11201120{
    11211121    AssertPtrReturn(paParms, VERR_INVALID_PARAMETER);
    … …  
    11441144 * @param   paParms             Array function parameters supplied.
    11451145 */
    1146 static int vboxSvcClipboardURITransferHandleReply(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer,
    1147                                                   uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     1146static int sharedClipboardSvcURITransferHandleReply(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer,
     1147                                                    uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    11481148{
    11491149    RT_NOREF(pClient);
    … …  
    11551155    if (pReply)
    11561156    {
    1157         rc = vboxSvcClipboardURIGetReply(cParms, paParms, pReply);
     1157        rc = sharedClipboardSvcURIGetReply(cParms, paParms, pReply);
    11581158        if (RT_SUCCESS(rc))
    11591159        {
    … …  
    12271227 * @param   tsArrival           Timestamp of arrival.
    12281228 */
    1229 int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient,
    1230                                VBOXHGCMCALLHANDLE callHandle,
    1231                                uint32_t u32Function,
    1232                                uint32_t cParms,
    1233                                VBOXHGCMSVCPARM paParms[],
    1234                                uint64_t tsArrival)
     1229int sharedClipboardSvcURIHandler(PSHCLCLIENT pClient,
     1230                                VBOXHGCMCALLHANDLE callHandle,
     1231                                uint32_t u32Function,
     1232                                uint32_t cParms,
     1233                                VBOXHGCMSVCPARM paParms[],
     1234                                uint64_t tsArrival)
    12351235{
    12361236    RT_NOREF(paParms, tsArrival);
    … …  
    12401240
    12411241    /* Check if we've the right mode set. */
    1242     if (!vboxSvcClipboardURIMsgIsAllowed(vboxSvcClipboardGetMode(), u32Function))
     1242    if (!sharedClipboardSvcURIMsgIsAllowed(sharedClipboardSvcGetMode(), u32Function))
    12431243    {
    12441244        LogFunc(("Wrong clipboard mode, denying access\n"));
    … …  
    13251325                if (RT_SUCCESS(rc))
    13261326                {
    1327                     rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer);
     1327                    rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer);
    13281328                    if (RT_SUCCESS(rc))
    13291329                    {
    … …  
    13331333                        creationCtx.enmSource = pClient->State.enmSource;
    13341334
    1335                         creationCtx.Interface.pfnTransferOpen  = vboxSvcClipboardURITransferOpen;
    1336                         creationCtx.Interface.pfnTransferClose = vboxSvcClipboardURITransferClose;
    1337                         creationCtx.Interface.pfnListOpen      = vboxSvcClipboardURIListOpen;
    1338                         creationCtx.Interface.pfnListClose     = vboxSvcClipboardURIListClose;
    1339                         creationCtx.Interface.pfnObjOpen       = vboxSvcClipboardURIObjOpen;
    1340                         creationCtx.Interface.pfnObjClose      = vboxSvcClipboardURIObjClose;
     1335                        creationCtx.Interface.pfnTransferOpen  = sharedClipboardSvcURITransferOpen;
     1336                        creationCtx.Interface.pfnTransferClose = sharedClipboardSvcURITransferClose;
     1337                        creationCtx.Interface.pfnListOpen      = sharedClipboardSvcURIListOpen;
     1338                        creationCtx.Interface.pfnListClose     = sharedClipboardSvcURIListClose;
     1339                        creationCtx.Interface.pfnObjOpen       = sharedClipboardSvcURIObjOpen;
     1340                        creationCtx.Interface.pfnObjClose      = sharedClipboardSvcURIObjClose;
    13411341
    13421342                        if (enmDir == SHCLURITRANSFERDIR_READ)
    13431343                        {
    1344                             creationCtx.Interface.pfnGetRoots        = vboxSvcClipboardURIGetRoots;
    1345                             creationCtx.Interface.pfnListHdrRead     = vboxSvcClipboardURIListHdrRead;
    1346                             creationCtx.Interface.pfnListEntryRead   = vboxSvcClipboardURIListEntryRead;
    1347                             creationCtx.Interface.pfnObjRead         = vboxSvcClipboardURIObjRead;
     1344                            creationCtx.Interface.pfnGetRoots        = sharedClipboardSvcURIGetRoots;
     1345                            creationCtx.Interface.pfnListHdrRead     = sharedClipboardSvcURIListHdrRead;
     1346                            creationCtx.Interface.pfnListEntryRead   = sharedClipboardSvcURIListEntryRead;
     1347                            creationCtx.Interface.pfnObjRead         = sharedClipboardSvcURIObjRead;
    13481348                        }
    13491349                        else
    … …  
    13741374                    if (RT_SUCCESS(rc))
    13751375                    {
    1376                         rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
     1376                        rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
    13771377                        if (RT_SUCCESS(rc))
    1378                             rc = VBoxClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
     1378                            rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
    13791379                    }
    13801380
    13811381                    if (RT_FAILURE(rc))
    13821382                    {
    1383                         VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
     1383                        SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer);
    13841384                        SharedClipboardURITransferDestroy(pTransfer);
    13851385                    }
    … …  
    13981398        case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY:
    13991399        {
    1400             rc = vboxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms);
     1400            rc = sharedClipboardSvcURITransferHandleReply(pClient, pTransfer, cParms, paParms);
    14011401            break;
    14021402        }
    … …  
    14101410        {
    14111411            SHCLROOTLISTHDR lstHdr;
    1412             rc = vboxSvcClipboardURIGetRootListHdr(cParms, paParms, &lstHdr);
     1412            rc = sharedClipboardSvcURIGetRootListHdr(cParms, paParms, &lstHdr);
    14131413            if (RT_SUCCESS(rc))
    14141414            {
    … …  
    14591459        {
    14601460            SHCLROOTLISTENTRY lstEntry;
    1461             rc = vboxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry);
     1461            rc = sharedClipboardSvcURIGetRootListEntry(cParms, paParms, &lstEntry);
    14621462            if (RT_SUCCESS(rc))
    14631463            {
    … …  
    14871487        {
    14881488            SHCLLISTOPENPARMS listOpenParms;
    1489             rc = vboxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms);
     1489            rc = sharedClipboardSvcURIGetListOpen(cParms, paParms, &listOpenParms);
    14901490            if (RT_SUCCESS(rc))
    14911491            {
    … …  
    15271527                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    15281528                /*if (RT_SUCCESS(rc))
    1529                     rc = vboxSvcClipboardURISetListHdr(cParms, paParms, &hdrList);*/
     1529                    rc = sharedClipboardSvcURISetListHdr(cParms, paParms, &hdrList);*/
    15301530            }
    15311531            break;
    … …  
    15391539            {
    15401540                SHCLLISTHANDLE hList;
    1541                 rc = vboxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList);
     1541                rc = sharedClipboardSvcURIGetListHdr(cParms, paParms, &hList, &hdrList);
    15421542                if (RT_SUCCESS(rc))
    15431543                {
    … …  
    15871587            {
    15881588                SHCLLISTHANDLE hList;
    1589                 rc = vboxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList);
     1589                rc = sharedClipboardSvcURIGetListEntry(cParms, paParms, &hList, &entryList);
    15901590                if (RT_SUCCESS(rc))
    15911591                {
    … …  
    16331633        {
    16341634            SHCLOBJDATACHUNK dataChunk;
    1635             rc = vboxSvcClipboardURIGetObjDataChunk(cParms, paParms, &dataChunk);
     1635            rc = sharedClipboardSvcURIGetObjDataChunk(cParms, paParms, &dataChunk);
    16361636            if (RT_SUCCESS(rc))
    16371637            {
    … …  
    18381838        {
    18391839            int rcGuest;
    1840             rc = vboxSvcClipboardURIGetError(cParms,paParms, &rcGuest);
     1840            rc = sharedClipboardSvcURIGetError(cParms,paParms, &rcGuest);
    18411841            if (RT_SUCCESS(rc))
    18421842                LogRel(("Shared Clipboard: Transfer error: %Rrc\n", rcGuest));
    … …  
    18691869 * @param   paParms             Array function parameters  supplied.
    18701870 */
    1871 int vboxSvcClipboardURIHostHandler(uint32_t u32Function,
     1871int sharedClipboardSvcURIHostHandler(uint32_t u32Function,
    18721872                                   uint32_t cParms,
    18731873                                   VBOXHGCMSVCPARM paParms[])
    … …  
    19011901 * @param   pTransfer           URI transfer to register a clipboard area for.
    19021902 */
    1903 int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
     1903int sharedClipboardSvcURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    19041904{
    19051905    RT_NOREF(pClientState);
    … …  
    19501950 * @param   pTransfer           URI transfer to unregister a clipboard area from.
    19511951 */
    1952 int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
     1952int sharedClipboardSvcURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    19531953{
    19541954    RT_NOREF(pClientState);
    … …  
    19981998 * @param   uID                 ID of clipboard area to to attach to. Specify 0 to attach to the most recent one.
    19991999 */
    2000 int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer,
     2000int sharedClipboardSvcURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer,
    20012001                                  SHCLAREAID uID)
    20022002{
    … …  
    20462046 * @param   pTransfer           URI transfer to detach a clipboard area from.
    20472047 */
    2048 int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
     2048int sharedClipboardSvcURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer)
    20492049{
    20502050    RT_NOREF(pClientState);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h

    r80662 r80664  
    2222#endif
    2323
    24 int vboxSvcClipboardURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
    25 int vboxSvcClipboardURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     24int sharedClipboardSvcURIHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
     25int sharedClipboardSvcURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    2626
    27 int vboxSvcClipboardURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
    28 int vboxSvcClipboardURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
    29 int vboxSvcClipboardURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID);
    30 int vboxSvcClipboardURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
     27int sharedClipboardSvcURIAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
     28int sharedClipboardSvcURIAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
     29int sharedClipboardSvcURIAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer, SHCLAREAID uID);
     30int sharedClipboardSvcURIAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLURITRANSFER pTransfer);
    3131
    3232#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_uri_h */

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp

    r80662 r80664  
    107107            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_START\n"));
    108108
    109             if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
    110                 && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     109            if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
     110                && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    111111            {
    112112                LogFlowFunc(("Wrong clipboard mode, skipping\n"));
    … …  
    130130}
    131131
    132 bool vboxSvcClipboardURIReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     132bool sharedClipboardSvcURIReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    133133{
    134134    RT_NOREF(pClient, cParms, paParms);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp

    r80662 r80664  
    7373
    7474    if (   u32Format == VBOX_SHARED_CLIPBOARD_FMT_HTML
    75         && VBoxClipboardWinIsCFHTML((const char *)pvSrc))
     75        && SharedClipboardWinIsCFHTML((const char *)pvSrc))
    7676    {
    7777        /** @todo r=bird: Why the double conversion? */
    7878        char *pszBuf = NULL;
    7979        uint32_t cbBuf = 0;
    80         int rc = VBoxClipboardWinConvertCFHTMLToMIME((const char *)pvSrc, cbSrc, &pszBuf, &cbBuf);
     80        int rc = SharedClipboardWinConvertCFHTMLToMIME((const char *)pvSrc, cbSrc, &pszBuf, &cbBuf);
    8181        if (RT_SUCCESS(rc))
    8282        {
    … …  
    175175    RT_ZERO(dataReq);
    176176
    177     dataReq.uFmt   = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
     177    dataReq.uFmt   = SharedClipboardWinClipboardFormatToVBox(cfFormat);
    178178    dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    179179
    180180    SHCLEVENTID uEvent = 0;
    181     int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
     181    int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
    182182    if (RT_SUCCESS(rc))
    183183    {
    … …  
    222222                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    223223                if (RT_SUCCESS(rc))
    224                     vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
     224                    sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
    225225            }
    226226
    … …  
    231231        {
    232232            LogFunc(("WM_CHANGECBCHAIN\n"));
    233             lresultRc = VBoxClipboardWinHandleWMChangeCBChain(pWinCtx, hWnd, uMsg, wParam, lParam);
     233            lresultRc = SharedClipboardWinHandleWMChangeCBChain(pWinCtx, hWnd, uMsg, wParam, lParam);
    234234            break;
    235235        }
    … …  
    244244                int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    245245                if (RT_SUCCESS(rc))
    246                     vboxSvcClipboardSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
    247             }
    248 
    249             lresultRc = VBoxClipboardWinChainPassToNext(pWinCtx, uMsg, wParam, lParam);
     246                    sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
     247            }
     248
     249            lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, uMsg, wParam, lParam);
    250250            break;
    251251        }
    … …  
    253253        case WM_TIMER:
    254254        {
    255             int rc = VBoxClipboardWinHandleWMTimer(pWinCtx);
     255            int rc = SharedClipboardWinHandleWMTimer(pWinCtx);
    256256            AssertRC(rc);
    257257
    … …  
    266266            const UINT cfFormat = (UINT)wParam;
    267267
    268             const SHCLFORMAT fFormat = VBoxClipboardWinClipboardFormatToVBox(cfFormat);
     268            const SHCLFORMAT fFormat = SharedClipboardWinClipboardFormatToVBox(cfFormat);
    269269
    270270            LogFunc(("WM_RENDERFORMAT: cfFormat=%u -> fFormat=0x%x\n", cfFormat, fFormat));
    … …  
    275275                /* Unsupported clipboard format is requested. */
    276276                LogFunc(("WM_RENDERFORMAT unsupported format requested or client is not active\n"));
    277                 VBoxClipboardWinClear();
     277                SharedClipboardWinClear();
    278278            }
    279279            else
    … …  
    293293
    294294                if (RT_FAILURE(rc))
    295                     VBoxClipboardWinClear();
     295                    SharedClipboardWinClear();
    296296            }
    297297
    … …  
    303303            LogFunc(("WM_RENDERALLFORMATS\n"));
    304304
    305             int rc = VBoxClipboardWinHandleWMRenderAllFormats(pWinCtx, hWnd);
     305            int rc = SharedClipboardWinHandleWMRenderAllFormats(pWinCtx, hWnd);
    306306            AssertRC(rc);
    307307
    … …  
    309309        }
    310310
    311         case VBOX_CLIPBOARD_WM_REPORT_FORMATS:
     311        case SHCL_WIN_WM_REPORT_FORMATS:
    312312        {
    313313            LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n"));
    … …  
    317317            if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */
    318318            {
    319                 int rc = VBoxClipboardWinOpen(hWnd);
     319                int rc = SharedClipboardWinOpen(hWnd);
    320320                if (RT_SUCCESS(rc))
    321321                {
    322                     VBoxClipboardWinClear();
    323 
    324                     rc = VBoxClipboardWinAnnounceFormats(pWinCtx, fFormats);
    325 
    326                     VBoxClipboardWinClose();
     322                    SharedClipboardWinClear();
     323
     324                    rc = SharedClipboardWinAnnounceFormats(pWinCtx, fFormats);
     325
     326                    SharedClipboardWinClose();
    327327                }
    328328
    … …  
    337337            LogFunc(("WM_DESTROY\n"));
    338338
    339             int rc = VBoxClipboardWinHandleWMDestroy(pWinCtx);
     339            int rc = SharedClipboardWinHandleWMDestroy(pWinCtx);
    340340            AssertRC(rc);
    341341
    … …  
    416416    char szWndClassName[32];
    417417    RTStrPrintf2(szWndClassName, sizeof(szWndClassName),
    418                  "%s-%RU64", VBOX_CLIPBOARD_WNDCLASS_NAME, RTThreadGetNative(hThreadSelf));
     418                 "%s-%RU64", SHCL_WIN_WNDCLASS_NAME, RTThreadGetNative(hThreadSelf));
    419419    wc.lpszClassName = szWndClassName;
    420420
    … …  
    444444                         SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE);
    445445
    446             rc = VBoxClipboardWinChainAdd(&pCtx->Win);
     446            rc = SharedClipboardWinChainAdd(&pCtx->Win);
    447447            if (RT_SUCCESS(rc))
    448448            {
    449                 if (!VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI))
     449                if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI))
    450450                    pWinCtx->oldAPI.timerRefresh = SetTimer(pWinCtx->hWnd, 0, 10 * 1000, NULL);
    451451            }
    … …  
    530530        RT_ZERO(Formats);
    531531
    532         rc = VBoxClipboardWinGetFormats(&pCtx->Win, &Formats);
     532        rc = SharedClipboardWinGetFormats(&pCtx->Win, &Formats);
    533533        if (   RT_SUCCESS(rc)
    534534            && Formats.uFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE)
    535535        {
    536             rc = vboxSvcClipboardFormatsReport(pCtx->pClient, &Formats);
     536            rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &Formats);
    537537        }
    538538    }
    … …  
    548548 */
    549549
    550 int VBoxClipboardSvcImplInit(void)
    551 {
    552     /* Initialization is done in VBoxClipboardSvcImplConnect(). */
     550int SharedClipboardSvcImplInit(void)
     551{
     552    /* Initialization is done in SharedClipboardSvcImplConnect(). */
    553553    return VINF_SUCCESS;
    554554}
    555555
    556 void VBoxClipboardSvcImplDestroy(void)
    557 {
    558     /* Destruction is done in VBoxClipboardSvcImplDisconnect(). */
    559 }
    560 
    561 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     556void SharedClipboardSvcImplDestroy(void)
     557{
     558    /* Destruction is done in SharedClipboardSvcImplDisconnect(). */
     559}
     560
     561int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    562562{
    563563    RT_NOREF(fHeadless);
    … …  
    571571    {
    572572        /* Check that new Clipboard API is available. */
    573         rc = VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
     573        rc = SharedClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
    574574        if (RT_SUCCESS(rc))
    575575        {
    … …  
    587587
    588588        /* Sync the host clipboard content with the client. */
    589         rc = VBoxClipboardSvcImplSync(pClient);
     589        rc = SharedClipboardSvcImplSync(pClient);
    590590    }
    591591    else
    … …  
    596596}
    597597
    598 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
     598int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
    599599{
    600600    /* Sync the host clipboard content with the client. */
    … …  
    602602}
    603603
    604 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     604int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    605605{
    606606    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    641641}
    642642
    643 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    644                                        PSHCLFORMATDATA pFormats)
     643int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     644                                         PSHCLFORMATDATA pFormats)
    645645{
    646646    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    658658    {
    659659        PSHCLURITRANSFER pTransfer;
    660         rc = vboxSvcClipboardURITransferStart(pClient,
    661                                               SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE,
    662                                               &pTransfer);
     660        rc = sharedClipboardSvcURITransferStart(pClient,
     661                                                SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE,
     662                                                &pTransfer);
    663663        if (RT_SUCCESS(rc))
    664664        {
    665665            /* Create the IDataObject implementation the host OS needs and assign
    666666             * the newly created transfer to this object. */
    667             rc = VBoxClipboardWinURITransferCreate(&pCtx->Win, pTransfer);
     667            rc = SharedClipboardWinURITransferCreate(&pCtx->Win, pTransfer);
    668668
    669669            /*  Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
    … …  
    678678         * The guest announced formats. Forward to the window thread.
    679679         */
    680         PostMessage(pCtx->Win.hWnd, VBOX_CLIPBOARD_WM_REPORT_FORMATS,
     680        PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_REPORT_FORMATS,
    681681                    0 /* wParam */, pFormats->uFormats /* lParam */);
    682682
    … …  
    691691}
    692692
    693 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    694                                  PSHCLDATABLOCK pData, uint32_t *pcbActual)
     693int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     694                                   PSHCLDATABLOCK pData, uint32_t *pcbActual)
    695695{
    696696    AssertPtrReturn(pClient,             VERR_INVALID_POINTER);
    … …  
    707707     * The guest wants to read data in the given format.
    708708     */
    709     int rc = VBoxClipboardWinOpen(pWinCtx->hWnd);
     709    int rc = SharedClipboardWinOpen(pWinCtx->hWnd);
    710710    if (RT_SUCCESS(rc))
    711711    {
    … …  
    758758        else if (pData->uFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
    759759        {
    760             UINT format = RegisterClipboardFormat(VBOX_CLIPBOARD_WIN_REGFMT_HTML);
     760            UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
    761761            if (format != 0)
    762762            {
    … …  
    789789        }
    790790#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    791         VBoxClipboardWinClose();
     791        SharedClipboardWinClose();
    792792    }
    793793
    … …  
    802802}
    803803
    804 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    805                                   PSHCLDATABLOCK pData)
     804int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     805                                    PSHCLDATABLOCK pData)
    806806{
    807807    LogFlowFuncEnter();
    808808
    809     int rc = vboxSvcClipboardDataReadSignal(pClient, pCmdCtx, pData);
     809    int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData);
    810810
    811811    LogFlowFuncLeaveRC(rc);
    … …  
    814814
    815815#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    816 int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     816int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    817817{
    818818    RT_NOREF(pClient, pTransfer);
    … …  
    823823}
    824824
    825 int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     825int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    826826{
    827827    LogFlowFuncEnter();
    828828
    829     VBoxClipboardWinURITransferDestroy(&pClient->State.pCtx->Win, pTransfer);
     829    SharedClipboardWinURITransferDestroy(&pClient->State.pCtx->Win, pTransfer);
    830830
    831831    return VINF_SUCCESS;

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp

    r80662 r80664  
    6969 * after a save and restore of the guest.
    7070 */
    71 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
     71int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
    7272{
    7373    RT_NOREF(pClient);
    … …  
    8181 * @param   pClient         Structure containing context information about the guest system
    8282 */
    83 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     83int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    8484{
    8585    RT_NOREF(pClient);
    … …  
    9595 * @param pFormats              Clipboard formats the guest is offering.
    9696 */
    97 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     97int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    9898                                       PSHCLFORMATDATA pFormats)
    9999{
    … …  
    110110 * @param pcbActual     Where to store the actual amount of data available.
    111111 */
    112 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     112int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    113113                                 PSHCLDATABLOCK pData, uint32_t *pcbActual)
    114114{
    … …  
    121121}
    122122
    123 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     123int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    124124                                  PSHCLDATABLOCK pData)
    125125{

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp

    r80662 r80664  
    7272    formatData.uFormats = u32Formats;
    7373
    74     int rc2 = vboxSvcClipboardFormatsReport(pCtx->pClient, &formatData);
     74    int rc2 = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData);
    7575    AssertRC(rc2);
    7676}
    … …  
    8080 * @note  Host glue code
    8181 */
    82 int VBoxClipboardSvcImplInit(void)
     82int SharedClipboardSvcImplInit(void)
    8383{
    8484    LogFlowFuncEnter();
    … …  
    9090 * @note  host glue code
    9191 */
    92 void VBoxClipboardSvcImplDestroy(void)
     92void SharedClipboardSvcImplDestroy(void)
    9393{
    9494    LogFlowFuncEnter();
    … …  
    100100 *        the clipboard and leave ownership to X11.
    101101 */
    102 int VBoxClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     102int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    103103{
    104104    int rc = VINF_SUCCESS;
    … …  
    142142 * @note  Host glue code
    143143 */
    144 int VBoxClipboardSvcImplSync(PSHCLCLIENT pClient)
     144int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
    145145{
    146146    LogFlowFuncEnter();
    … …  
    154154    formatData.uFormats = VBOX_SHARED_CLIPBOARD_FMT_NONE;
    155155
    156     return vboxSvcClipboardFormatsReport(pClient, &formatData);
     156    return sharedClipboardSvcFormatsReport(pClient, &formatData);
    157157}
    158158
    … …  
    161161 * @note  Host glue code
    162162 */
    163 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     163int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
    164164{
    165165    LogFlowFuncEnter();
    … …  
    174174    /* If there is a currently pending request, release it immediately. */
    175175    SHCLDATABLOCK dataBlock = { 0, NULL, 0 };
    176     VBoxClipboardSvcImplWriteData(pClient, NULL, &dataBlock);
     176    SharedClipboardSvcImplWriteData(pClient, NULL, &dataBlock);
    177177
    178178    int rc = ClipStopX11(pCtx->pBackend);
    … …  
    199199 * @param pFormats              Clipboard formats the guest is offering.
    200200 */
    201 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    202                                        PSHCLFORMATDATA pFormats)
     201int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     202                                         PSHCLFORMATDATA pFormats)
    203203{
    204204    RT_NOREF(pCmdCtx);
    … …  
    245245 *
    246246 */
    247 int VBoxClipboardSvcImplReadData(PSHCLCLIENT pClient,
    248                                  PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
     247int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient,
     248                                   PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
    249249{
    250250    RT_NOREF(pCmdCtx);
    … …  
    299299 * @param  pData                Data block to write to clipboard.
    300300 */
    301 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT pClient,
    302                                   PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
     301int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient,
     302                                    PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
    303303{
    304304    LogFlowFunc(("pClient=%p, pv=%p, cb=%RU32, uFormat=%02X\n",
    305305                 pClient, pData->pvData, pData->cbData, pData->uFormat));
    306306
    307     int rc = vboxSvcClipboardDataReadSignal(pClient, pCmdCtx, pData);
     307    int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData);
    308308
    309309    LogFlowFuncLeaveRC(rc);
    … …  
    368368
    369369    SHCLEVENTID uEvent;
    370     int rc = vboxSvcClipboardDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
     370    int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
    371371    if (RT_SUCCESS(rc))
    372372    {
    … …  
    390390
    391391#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    392 int VBoxClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     392int SharedClipboardSvcImplURITransferCreate(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    393393{
    394394    RT_NOREF(pClient, pTransfer);
    … …  
    396396}
    397397
    398 int VBoxClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     398int SharedClipboardSvcImplURITransferDestroy(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
    399399{
    400400    RT_NOREF(pClient, pTransfer);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp

    r80662 r80664  
    224224*   Prototypes                                                                                                                   *
    225225*********************************************************************************************************************************/
    226 static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
    227 static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState);
    228 static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState);
     226static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
     227static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
     228static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
    229229
    230230
    … …  
    260260 * @param   puID                Where to store the created event source ID on success.
    261261 */
    262 int vboxSvcClipboardEventSourceCreateID(PSHCLEVENTSOURCEID puID)
     262int sharedClipboardSvcEventSourceCreateID(PSHCLEVENTSOURCEID puID)
    263263{
    264264    AssertPtrReturn(puID, VERR_INVALID_POINTER);
    … …  
    277277}
    278278
    279 uint32_t vboxSvcClipboardGetMode(void)
     279uint32_t sharedClipboardSvcGetMode(void)
    280280{
    281281    return g_uMode;
    … …  
    286286uint32_t TestClipSvcGetMode(void)
    287287{
    288     return vboxSvcClipboardGetMode();
     288    return sharedClipboardSvcGetMode();
    289289}
    290290#endif
    … …  
    296296}
    297297
    298 static int vboxSvcClipboardModeSet(uint32_t uMode)
     298static int sharedClipboardSvcModeSet(uint32_t uMode)
    299299{
    300300    int rc = VERR_NOT_SUPPORTED;
    … …  
    343343 * @param   pClient             Pointer to the client data structure to reset message queue for.
    344344 */
    345 void vboxSvcClipboardMsgQueueReset(PSHCLCLIENT pClient)
     345void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient)
    346346{
    347347    LogFlowFuncEnter();
    … …  
    361361 * @param   cParms              Number of HGCM parameters to allocate.
    362362 */
    363 PSHCLCLIENTMSG vboxSvcClipboardMsgAlloc(uint32_t uMsg, uint32_t cParms)
     363PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms)
    364364{
    365365    PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG));
    … …  
    386386 *                              The pointer will be invalid after calling this function.
    387387 */
    388 void vboxSvcClipboardMsgFree(PSHCLCLIENTMSG pMsg)
     388void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg)
    389389{
    390390    if (!pMsg)
    … …  
    407407 * @remarks ASSUMES the parameters has been cleared by clientMsgPeek.
    408408 */
    409 void vboxSvcClipboardMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     409void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
    410410{
    411411    Assert(cDstParms >= 2);
    … …  
    437437 * @param   cDstParms   The number of peek parameters (at least two).
    438438 */
    439 int vboxSvcClipboardMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     439int sharedClipboardSvcMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
    440440{
    441441    AssertPtrReturn(pMsg,           VERR_INVALID_POINTER);
    … …  
    494494 * @param   fAppend             Whether to append or prepend the message to the queue.
    495495 */
    496 int vboxSvcClipboardMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
     496int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
    497497{
    498498    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
    … …  
    527527 *                      immediately.
    528528 */
    529 int vboxSvcClipboardMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    530                             bool fWait)
     529int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     530                              bool fWait)
    531531{
    532532    /*
    … …  
    574574        if (pFirstMsg)
    575575        {
    576             vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, paParms, cParms);
     576            sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
    577577            LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
    578578                         pClient->uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg),
    … …  
    616616 * @param   paParms     Array of parameters.
    617617 */
    618 int vboxSvcClipboardMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     618int sharedClipboardSvcMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    619619{
    620620    int rc;
    … …  
    640640                         pFirstMsg->m_cParms));
    641641
    642             rc = vboxSvcClipboardMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms);
     642            rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms);
    643643            if (RT_SUCCESS(rc))
    644644            {
    … …  
    648648                {
    649649                    pClient->queueMsg.removeFirst();
    650                     vboxSvcClipboardMsgFree(pFirstMsg);
     650                    sharedClipboardSvcMsgFree(pFirstMsg);
    651651
    652652                    rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
    … …  
    692692 * @param   paParms      Array of parameters.
    693693 */
    694 int vboxSvcClipboardMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     694int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    695695{
    696696    /*
    … …  
    782782                {
    783783                    pClient->queueMsg.removeFirst();
    784                     vboxSvcClipboardMsgFree(pFirstMsg);
     784                    sharedClipboardSvcMsgFree(pFirstMsg);
    785785                }
    786786
    … …  
    807807 * @param   pClient             Client to wake up.
    808808 */
    809 int vboxSvcClipboardClientWakeup(PSHCLCLIENT pClient)
     809int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient)
    810810{
    811811    int rc = VINF_NO_CHANGE;
    … …  
    830830                if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT)
    831831                {
    832                     vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
     832                    sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
    833833                    fDonePending = true;
    834834                }
    835835                else if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */
    836836                {
    837                     rc = vboxSvcClipboardMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
     837                    rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
    838838                    if (RT_SUCCESS(rc))
    839839                    {
    … …  
    841841                         * remove the actual message from our queue right now. */
    842842                        pClient->queueMsg.removeFirst();
    843                         vboxSvcClipboardMsgFree(pFirstMsg);
     843                        sharedClipboardSvcMsgFree(pFirstMsg);
    844844
    845845                        fDonePending = true;
    … …  
    879879 * @param   puEvent             Event ID for waiting for new data. Optional.
    880880 */
    881 int vboxSvcClipboardDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
    882                                     PSHCLEVENTID puEvent)
     881int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
     882                                      PSHCLEVENTID puEvent)
    883883{
    884884    AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
    … …  
    888888    int rc;
    889889
    890     PSHCLCLIENTMSG pMsgReadData = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    891                                                                     VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
     890    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     891                                                             VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA);
    892892    if (pMsgReadData)
    893893    {
    … …  
    898898        HGCMSvcSetU32(&pMsgReadData->m_paParms[2], pClient->State.cbChunkSize);
    899899
    900         rc = vboxSvcClipboardMsgAdd(pClient, pMsgReadData, true /* fAppend */);
     900        rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
    901901        if (RT_SUCCESS(rc))
    902902        {
    … …  
    904904            if (RT_SUCCESS(rc))
    905905            {
    906                 rc = vboxSvcClipboardClientWakeup(pClient);
     906                rc = sharedClipboardSvcClientWakeup(pClient);
    907907                if (RT_SUCCESS(rc))
    908908                {
    … …  
    922922}
    923923
    924 int vboxSvcClipboardDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    925                                    PSHCLDATABLOCK pData)
     924int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     925                                     PSHCLDATABLOCK pData)
    926926{
    927927    SHCLEVENTID uEvent;
    … …  
    952952}
    953953
    954 int vboxSvcClipboardFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
     954int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
    955955{
    956956    AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
    … …  
    959959    int rc;
    960960
    961     PSHCLCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3);
     961    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT, 3);
    962962    if (pMsg)
    963963    {
    … …  
    968968        HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */);
    969969
    970         rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     970        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    971971        if (RT_SUCCESS(rc))
    972             rc = vboxSvcClipboardClientWakeup(pClient);
     972            rc = sharedClipboardSvcClientWakeup(pClient);
    973973    }
    974974    else
    … …  
    979979}
    980980
    981 int vboxSvcClipboardGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     981int sharedClipboardSvcGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    982982{
    983983    LogFlowFuncEnter();
    984984
    985     if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
    986         && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     985    if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
     986        && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    987987    {
    988988        return VERR_NOT_SUPPORTED;
    … …  
    10541054        }
    10551055
    1056         rc = VBoxClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
     1056        rc = SharedClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
    10571057    }
    10581058
    … …  
    10611061}
    10621062
    1063 int vboxSvcClipboardSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
     1063int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
    10641064{
    10651065    if (!pClient) /* If no client connected (anymore), bail out. */
    … …  
    10821082
    10831083#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1084 int vboxSvcClipboardURITransferStart(PSHCLCLIENT pClient,
     1084int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient,
    10851085                                     SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,
    10861086                                     PSHCLURITRANSFER *ppTransfer)
    … …  
    11031103            if (enmDir == SHCLURITRANSFERDIR_READ)
    11041104            {
    1105                 rc = vboxSvcClipboardURIAreaRegister(&pClient->State, pTransfer);
     1105                rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer);
    11061106                if (RT_SUCCESS(rc))
    11071107                {
    11081108                    creationCtx.enmSource = pClient->State.enmSource;
    11091109
    1110                     creationCtx.Interface.pfnTransferOpen    = vboxSvcClipboardURITransferOpen;
    1111                     creationCtx.Interface.pfnTransferClose   = vboxSvcClipboardURITransferClose;
    1112                     creationCtx.Interface.pfnListOpen        = vboxSvcClipboardURIListOpen;
    1113                     creationCtx.Interface.pfnListClose       = vboxSvcClipboardURIListClose;
    1114                     creationCtx.Interface.pfnObjOpen         = vboxSvcClipboardURIObjOpen;
    1115                     creationCtx.Interface.pfnObjClose        = vboxSvcClipboardURIObjClose;
    1116 
    1117                     creationCtx.Interface.pfnGetRoots        = vboxSvcClipboardURIGetRoots;
    1118                     creationCtx.Interface.pfnListHdrRead     = vboxSvcClipboardURIListHdrRead;
    1119                     creationCtx.Interface.pfnListEntryRead   = vboxSvcClipboardURIListEntryRead;
    1120                     creationCtx.Interface.pfnObjRead         = vboxSvcClipboardURIObjRead;
     1110                    creationCtx.Interface.pfnTransferOpen    = sharedClipboardSvcURITransferOpen;
     1111                    creationCtx.Interface.pfnTransferClose   = sharedClipboardSvcURITransferClose;
     1112                    creationCtx.Interface.pfnListOpen        = sharedClipboardSvcURIListOpen;
     1113                    creationCtx.Interface.pfnListClose       = sharedClipboardSvcURIListClose;
     1114                    creationCtx.Interface.pfnObjOpen         = sharedClipboardSvcURIObjOpen;
     1115                    creationCtx.Interface.pfnObjClose        = sharedClipboardSvcURIObjClose;
     1116
     1117                    creationCtx.Interface.pfnGetRoots        = sharedClipboardSvcURIGetRoots;
     1118                    creationCtx.Interface.pfnListHdrRead     = sharedClipboardSvcURIListHdrRead;
     1119                    creationCtx.Interface.pfnListEntryRead   = sharedClipboardSvcURIListEntryRead;
     1120                    creationCtx.Interface.pfnObjRead         = sharedClipboardSvcURIObjRead;
    11211121
    11221122                    creationCtx.pvUser = pClient;
    … …  
    11461146                rc = SharedClipboardURICtxTransferAdd(&pClient->URI, pTransfer);
    11471147                if (RT_SUCCESS(rc))
    1148                     rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
     1148                    rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
    11491149
    11501150                if (RT_FAILURE(rc))
    1151                     VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
     1151                    SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer);
    11521152            }
    11531153
    … …  
    11771177    if (RT_SUCCESS(rc))
    11781178    {
    1179         vboxSvcClipboardModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF);
    1180 
    1181         rc = VBoxClipboardSvcImplInit();
     1179        sharedClipboardSvcModeSet(VBOX_SHARED_CLIPBOARD_MODE_OFF);
     1180
     1181        rc = SharedClipboardSvcImplInit();
    11821182
    11831183        /* Clean up on failure, because 'svnUnload' will not be called
    … …  
    11971197    LogFlowFuncEnter();
    11981198
    1199     VBoxClipboardSvcImplDestroy();
     1199    SharedClipboardSvcImplDestroy();
    12001200
    12011201    RTCritSectDelete(&g_CritSect);
    … …  
    12161216    PSHCLURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, 0 /* Index*/);
    12171217    if (pTransfer)
    1218         vboxSvcClipboardURIAreaDetach(&pClient->State, pTransfer);
     1218        sharedClipboardSvcURIAreaDetach(&pClient->State, pTransfer);
    12191219
    12201220    SharedClipboardURICtxDestroy(&pClient->URI);
    12211221#endif
    12221222
    1223     VBoxClipboardSvcImplDisconnect(pClient);
    1224 
    1225     vboxSvcClipboardClientStateReset(&pClient->State);
    1226     vboxSvcClipboardClientStateDestroy(&pClient->State);
     1223    SharedClipboardSvcImplDisconnect(pClient);
     1224
     1225    sharedClipboardSvcClientStateReset(&pClient->State);
     1226    sharedClipboardSvcClientStateDestroy(&pClient->State);
    12271227
    12281228    SharedClipboardEventSourceDestroy(&pClient->Events);
    … …  
    12511251    /* Create the client's own event source. */
    12521252    SHCLEVENTSOURCEID uEventSourceID;
    1253     int rc = vboxSvcClipboardEventSourceCreateID(&uEventSourceID);
     1253    int rc = sharedClipboardSvcEventSourceCreateID(&uEventSourceID);
    12541254    if (RT_SUCCESS(rc))
    12551255        rc = SharedClipboardEventSourceCreate(&pClient->Events, uEventSourceID);
    … …  
    12591259
    12601260        /* Reset the client state. */
    1261         vboxSvcClipboardClientStateReset(&pClient->State);
     1261        sharedClipboardSvcClientStateReset(&pClient->State);
    12621262
    12631263        /* (Re-)initialize the client state. */
    1264         rc = vboxSvcClipboardClientStateInit(&pClient->State, u32ClientID);
     1264        rc = sharedClipboardSvcClientStateInit(&pClient->State, u32ClientID);
    12651265        if (RT_SUCCESS(rc))
    12661266        {
    1267             rc = VBoxClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
     1267            rc = SharedClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
    12681268#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    12691269            if (RT_SUCCESS(rc))
    … …  
    13241324        case VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD:
    13251325        {
    1326             rc = vboxSvcClipboardMsgGetOld(pClient, callHandle, cParms, paParms);
     1326            rc = sharedClipboardSvcMsgGetOld(pClient, callHandle, cParms, paParms);
    13271327            if (rc == VINF_HGCM_ASYNC_EXECUTE)
    13281328                fDoCallComplete = false;
    … …  
    13441344                rc = VERR_INVALID_PARAMETER;
    13451345            }
    1346             else if (vboxSvcClipboardGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF)
     1346            else if (sharedClipboardSvcGetMode() == VBOX_SHARED_CLIPBOARD_MODE_OFF)
    13471347            {
    13481348                rc = VERR_ACCESS_DENIED;
    … …  
    13691369        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_NOWAIT:
    13701370        {
    1371             rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
     1371            rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
    13721372            break;
    13731373        }
    … …  
    13751375        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT:
    13761376        {
    1377             rc = vboxSvcClipboardMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
     1377            rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
    13781378            if (rc == VINF_HGCM_ASYNC_EXECUTE)
    13791379                fDoCallComplete = false;
    … …  
    13831383        case VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET:
    13841384        {
    1385             rc = vboxSvcClipboardMsgGet(pClient, callHandle, cParms, paParms);
     1385            rc = sharedClipboardSvcMsgGet(pClient, callHandle, cParms, paParms);
    13861386            if (rc == VINF_HGCM_ASYNC_EXECUTE)
    13871387                fDoCallComplete = false;
    … …  
    14301430            if (RT_SUCCESS(rc))
    14311431            {
    1432                 if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
    1433                     && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     1432                if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
     1433                    && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    14341434                {
    14351435                    rc = VERR_ACCESS_DENIED;
    … …  
    14371437                else
    14381438                {
    1439                     rc = vboxSvcClipboardSetSource(pClient, SHCLSOURCE_REMOTE);
     1439                    rc = sharedClipboardSvcSetSource(pClient, SHCLSOURCE_REMOTE);
    14401440                    if (RT_SUCCESS(rc))
    14411441                    {
    … …  
    14581458                        formatData.uFormats = uFormats;
    14591459
    1460                         rc = VBoxClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
     1460                        rc = SharedClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
    14611461                    }
    14621462                }
    … …  
    14811481            else
    14821482            {
    1483                 if (   vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
    1484                     && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
     1483                if (   sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
     1484                    && sharedClipboardSvcGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
    14851485                {
    14861486                    rc = VERR_ACCESS_DENIED;
    … …  
    15061506                            {
    15071507                                /* Attach to the most recent clipboard area. */
    1508                                 rc = vboxSvcClipboardURIAreaAttach(&pClient->State, pTransfer, 0 /* Area ID */);
     1508                                rc = sharedClipboardSvcURIAreaAttach(&pClient->State, pTransfer, 0 /* Area ID */);
    15091509                                if (RT_SUCCESS(rc))
    15101510                                {
    … …  
    15161516                                    RT_ZERO(creationCtx.Interface);
    15171517
    1518                                     creationCtx.Interface.pfnListHdrWrite    = vboxSvcClipboardURIListHdrWrite;
    1519                                     creationCtx.Interface.pfnListEntryWrite  = vboxSvcClipboardURIListEntryWrite;
    1520                                     creationCtx.Interface.pfnObjWrite        = vboxSvcClipboardURIObjWrite;
     1518                                    creationCtx.Interface.pfnListHdrWrite    = sharedClipboardSvcURIListHdrWrite;
     1519                                    creationCtx.Interface.pfnListEntryWrite  = sharedClipboardSvcURIListEntryWrite;
     1520                                    creationCtx.Interface.pfnObjWrite        = sharedClipboardSvcURIObjWrite;
    15211521
    15221522                                    creationCtx.pvUser = pClient;
    … …  
    15291529                                if (RT_SUCCESS(rc))
    15301530                                {
    1531                                     rc = VBoxClipboardSvcImplURITransferCreate(pClient, pTransfer);
     1531                                    rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
    15321532                                }
    15331533                                else
    15341534                                {
    1535                                     VBoxClipboardSvcImplURITransferDestroy(pClient, pTransfer);
     1535                                    SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer);
    15361536                                    SharedClipboardURITransferDestroy(pTransfer);
    15371537                                }
    … …  
    15821582                                    formatData.uFormats = g_ExtState.uDelayedFormats;
    15831583
    1584                                     int rc2 = vboxSvcClipboardFormatsReport(pClient, &formatData);
     1584                                    int rc2 = sharedClipboardSvcFormatsReport(pClient, &formatData);
    15851585                                    AssertRC(rc2);
    15861586
    … …  
    16141614                                dataBlock.uFormat = uFormat;
    16151615
    1616                                 rc = VBoxClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
     1616                                rc = SharedClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
    16171617                                if (RT_SUCCESS(rc))
    16181618                                    HGCMSvcSetU32(&paParms[2], cbActual);
    … …  
    16301630        case VBOX_SHARED_CLIPBOARD_GUEST_FN_DATA_WRITE:
    16311631        {
    1632             rc = vboxSvcClipboardGetDataWrite(pClient, cParms, paParms);
     1632            rc = sharedClipboardSvcGetDataWrite(pClient, cParms, paParms);
    16331633            break;
    16341634        }
    … …  
    16371637        {
    16381638#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1639             rc = vboxSvcClipboardURIHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
     1639            rc = sharedClipboardSvcURIHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
    16401640#else
    16411641            rc = VERR_NOT_IMPLEMENTED;
    … …  
    16601660 * @param   uClientID           Client ID (HGCM) to use for this client state.
    16611661 */
    1662 static int vboxSvcClipboardClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
     1662static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
    16631663{
    16641664    LogFlowFuncEnter();
    16651665
    1666     vboxSvcClipboardClientStateReset(pClientState);
     1666    sharedClipboardSvcClientStateReset(pClientState);
    16671667
    16681668    /* Register the client.
    … …  
    16801680 * @param   pClientState        Client state to destroy.
    16811681 */
    1682 static int vboxSvcClipboardClientStateDestroy(PSHCLCLIENTSTATE pClientState)
     1682static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState)
    16831683{
    16841684    RT_NOREF(pClientState);
    … …  
    16941694 * @param   pClientState    Client state to reset.
    16951695 */
    1696 static void vboxSvcClipboardClientStateReset(PSHCLCLIENTSTATE pClientState)
     1696static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState)
    16971697{
    16981698    LogFlowFuncEnter();
    … …  
    17321732                rc = HGCMSvcGetU32(&paParms[0], &u32Mode);
    17331733                if (RT_SUCCESS(rc))
    1734                     rc = vboxSvcClipboardModeSet(u32Mode);
     1734                    rc = sharedClipboardSvcModeSet(u32Mode);
    17351735            }
    17361736
    … …  
    17601760        {
    17611761#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    1762             rc = vboxSvcClipboardURIHostHandler(u32Function, cParms, paParms);
     1762            rc = sharedClipboardSvcURIHostHandler(u32Function, cParms, paParms);
    17631763#else
    17641764            rc = VERR_NOT_IMPLEMENTED;
    … …  
    18091809static SSMFIELD const s_aShClSSMClientMsgCtx[] =
    18101810{
    1811     SSMFIELD_ENTRY(VBOXSHCLMSGCTX, uContextID),
     1811    SSMFIELD_ENTRY(SHCLMSGCTX, uContextID),
    18121812    SSMFIELD_ENTRY_TERM()
    18131813};
    … …  
    18511851        AssertRCReturn(rc, rc);
    18521852
    1853         rc = SSMR3PutStructEx(pSSM, &pMsg->m_Ctx, sizeof(VBOXSHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);
     1853        rc = SSMR3PutStructEx(pSSM, &pMsg->m_Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);
    18541854        AssertRCReturn(rc, rc);
    18551855
    … …  
    19411941            AssertRCReturn(rc, rc);
    19421942
    1943             rc = SSMR3GetStructEx(pSSM, &pMsg->m_Ctx, sizeof(VBOXSHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);
     1943            rc = SSMR3GetStructEx(pSSM, &pMsg->m_Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);
    19441944            AssertRCReturn(rc, rc);
    19451945
    … …  
    19531953            }
    19541954
    1955             rc = vboxSvcClipboardMsgAdd(pClient, pMsg, true /* fAppend */);
     1955            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    19561956            AssertRCReturn(rc, rc);
    19571957        }
    … …  
    19641964
    19651965    /* Actual host data are to be reported to guest (SYNC). */
    1966     VBoxClipboardSvcImplSync(pClient);
     1966    SharedClipboardSvcImplSync(pClient);
    19671967
    19681968#else  /* UNIT_TEST */
    … …  
    20052005                    formatData.uFormats = u32Format;
    20062006
    2007                     rc = vboxSvcClipboardFormatsReport(pClient, &formatData);
     2007                    rc = sharedClipboardSvcFormatsReport(pClient, &formatData);
    20082008                }
    20092009
    … …  
    20202020                dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    20212021
    2022                 rc = vboxSvcClipboardDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
     2022                rc = sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
    20232023                break;
    20242024            }

  • trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

    r80662 r80664  
    123123                  2, parms, 0);
    124124    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
    125     vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    126                               VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
     125    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     126                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
    127127    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    128128    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
    … …  
    135135    RTTestISub("Testing FN_GET_HOST_MSG, one format, no waiting guest calls.");
    136136    RT_ZERO(g_Client.State);
    137     vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    138                               VBOX_SHARED_CLIPBOARD_FMT_HTML);
     137    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     138                                   VBOX_SHARED_CLIPBOARD_FMT_HTML);
    139139    HGCMSvcSetU32(&parms[0], 0);
    140140    HGCMSvcSetU32(&parms[1], 0);
    … …  
    158158                  2, parms, 0);
    159159    RTTESTI_CHECK_RC(call.rc, VERR_TRY_AGAIN);  /* This should get updated only when the guest call completes. */
    160     vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    161                               VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
     160    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     161                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
    162162    RTTESTI_CHECK(parms[0].u.uint32 == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
    163163    RTTESTI_CHECK(parms[1].u.uint32 == VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
    … …  
    176176    RTTestISub("Testing FN_GET_HOST_MSG, two formats, no waiting guest calls.");
    177177    RT_ZERO(g_Client.State);
    178     vboxSvcClipboardOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    179                               VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
     178    sharedClipboardSvcOldReportMsg(&g_Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     179                                   VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT | VBOX_SHARED_CLIPBOARD_FMT_HTML);
    180180    HGCMSvcSetU32(&parms[0], 0);
    181181    HGCMSvcSetU32(&parms[1], 0);
    … …  
    277277}
    278278
    279 int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; }
    280 void VBoxClipboardSvcImplDestroy() { }
    281 int VBoxClipboardSvcImplDisconnect(PSHCLCLIENT)
     279int SharedClipboardSvcImplInit() { return VINF_SUCCESS; }
     280void SharedClipboardSvcImplDestroy() { }
     281int SharedClipboardSvcImplDisconnect(PSHCLCLIENT)
    282282{ return VINF_SUCCESS; }
    283 int VBoxClipboardSvcImplConnect(PSHCLCLIENT, bool)
     283int SharedClipboardSvcImplConnect(PSHCLCLIENT, bool)
    284284{ return VINF_SUCCESS; }
    285 int VBoxClipboardSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA)
     285int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA)
    286286{ AssertFailed(); return VINF_SUCCESS; }
    287 int VBoxClipboardSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *)
     287int SharedClipboardSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *)
    288288{ AssertFailed(); return VERR_WRONG_ORDER; }
    289 int VBoxClipboardSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK)
     289int SharedClipboardSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK)
    290290{ AssertFailed(); return VINF_SUCCESS; }
    291 int VBoxClipboardSvcImplSync(PSHCLCLIENT)
     291int SharedClipboardSvcImplSync(PSHCLCLIENT)
    292292{ AssertFailed(); return VERR_WRONG_ORDER; }
    293293
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette