VirtualBox

Ignore:
Timestamp:
Sep 17, 2019 9:38:16 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
133417
Message:

Shared Clipboard/URI: More renaming to make code base more uniform.

Location:
trunk/src/VBox/Additions/haiku/VBoxTray
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r80664 r80847  
    7878
    7979
    80 VBoxClipboardService::VBoxClipboardService()
    81      : BHandler("VBoxClipboardService"),
     80VBoxShClService::VBoxShClService()
     81     : BHandler("VBoxShClService"),
    8282       fClientId(-1),
    8383       fServiceThreadID(-1),
    … …  
    8787
    8888
    89 VBoxClipboardService::~VBoxClipboardService()
    90 {
    91 }
    92 
    93 
    94 status_t VBoxClipboardService::Connect()
     89VBoxShClService::~VBoxShClService()
     90{
     91}
     92
     93
     94status_t VBoxShClService::Connect()
    9595{
    9696    status_t err;
    … …  
    100100    if (RT_SUCCESS(rc))
    101101    {
    102         err = fServiceThreadID = spawn_thread(_ServiceThreadNub, "VBoxClipboardService", B_NORMAL_PRIORITY, this);
     102        err = fServiceThreadID = spawn_thread(_ServiceThreadNub, "VBoxShClService", B_NORMAL_PRIORITY, this);
    103103        if (err >= B_OK)
    104104        {
    … …  
    109109                return B_OK;
    110110            else
    111                 LogRel(("VBoxClipboardService: Error watching the system clipboard: %ld\n", err));
     111                LogRel(("VBoxShClService: Error watching the system clipboard: %ld\n", err));
    112112        }
    113113        else
    114             LogRel(("VBoxClipboardService: Error starting service thread: %ld\n", err));
     114            LogRel(("VBoxShClService: Error starting service thread: %ld\n", err));
    115115
    116116        //rc = RTErrConvertFromErrno(err);
    … …  
    118118    }
    119119    else
    120         LogRel(("VBoxClipboardService: Error starting service thread: %d\n", rc));
     120        LogRel(("VBoxShClService: Error starting service thread: %d\n", rc));
    121121    return B_ERROR;
    122122}
    123123
    124124
    125 status_t VBoxClipboardService::Disconnect()
     125status_t VBoxShClService::Disconnect()
    126126{
    127127    status_t status;
    … …  
    138138
    139139
    140 void VBoxClipboardService::MessageReceived(BMessage *message)
     140void VBoxShClService::MessageReceived(BMessage *message)
    141141{
    142142    uint32_t formats = 0;
    … …  
    168168            }
    169169
    170             if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
    171             {
    172                 pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &cb);
     170            if (formats & VBOX_SHCL_FMT_UNICODETEXT)
     171            {
     172                pv = _VBoxReadHostClipboard(VBOX_SHCL_FMT_UNICODETEXT, &cb);
    173173                if (pv)
    174174                {
    … …  
    190190            }
    191191
    192             if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
    193             {
    194                 pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_BITMAP, &cb);
     192            if (formats & VBOX_SHCL_FMT_BITMAP)
     193            {
     194                pv = _VBoxReadHostClipboard(VBOX_SHCL_FMT_BITMAP, &cb);
    195195                if (pv)
    196196                {
    … …  
    253253            clip->PrintToStream();
    254254
    255             if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
     255            if (formats & VBOX_SHCL_FMT_UNICODETEXT)
    256256            {
    257257                const char *text;
    … …  
    269269                        uint32_t cb = (RTUtf16Len(pwsz) + 1) * sizeof(RTUTF16);
    270270
    271                         rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, pwsz, cb);
     271                        rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHCL_FMT_UNICODETEXT, pwsz, cb);
    272272                        //printf("VbglR3ClipboardWriteData: %d\n", rc);
    273273                        RTUtf16Free(pwsz);
    … …  
    275275                }
    276276            }
    277             else if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
     277            else if (formats & VBOX_SHCL_FMT_BITMAP)
    278278            {
    279279                BMessage archivedBitmap;
    … …  
    298298                                if (RT_SUCCESS(rc))
    299299                                {
    300                                     rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHARED_CLIPBOARD_FMT_BITMAP, (void *)pDib,
     300                                    rc = VbglR3ClipboardWriteData(fClientId, VBOX_SHCL_FMT_BITMAP, (void *)pDib,
    301301                                                                  cbDibSize);
    302302                                }
    … …  
    335335
    336336            if (clip->FindData("text/plain", B_MIME_TYPE, &data, &dataLen) == B_OK)
    337                 formats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
     337                formats |= VBOX_SHCL_FMT_UNICODETEXT;
    338338
    339339            if (   clip->HasMessage("image/bitmap")
    340340                || clip->HasMessage("image/x-be-bitmap"))
    341341            {
    342                 formats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
     342                formats |= VBOX_SHCL_FMT_BITMAP;
    343343            }
    344344
    … …  
    359359
    360360
    361 status_t VBoxClipboardService::_ServiceThreadNub(void *_this)
    362 {
    363     VBoxClipboardService *service = (VBoxClipboardService *)_this;
     361status_t VBoxShClService::_ServiceThreadNub(void *_this)
     362{
     363    VBoxShClService *service = (VBoxShClService *)_this;
    364364    return service->_ServiceThread();
    365365}
    366366
    367367
    368 status_t VBoxClipboardService::_ServiceThread()
    369 {
    370     printf("VBoxClipboardService::%s()\n", __FUNCTION__);
     368status_t VBoxShClService::_ServiceThread()
     369{
     370    printf("VBoxShClService::%s()\n", __FUNCTION__);
    371371
    372372    /* The thread waits for incoming messages from the host. */
    … …  
    380380            switch (u32Msg)
    381381            {
    382                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT:
     382                case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
    383383                {
    384384                    /*
    … …  
    386386                     * the information to the handler.
    387387                     */
    388                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS u32Formats=%x\n", u32Formats));
     388                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_REPORT_FORMATS u32Formats=%x\n", u32Formats));
    389389                    BMessage msg(VBOX_GUEST_CLIPBOARD_HOST_MSG_FORMATS);
    390390                    msg.AddInt32("Formats", (uint32)u32Formats);
    … …  
    393393                }
    394394
    395                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
     395                case VBOX_SHCL_HOST_MSG_READ_DATA:
    396396                {
    397397                    /* The host needs data in the specified format. */
    398                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA u32Formats=%x\n", u32Formats));
     398                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_READ_DATA u32Formats=%x\n", u32Formats));
    399399                    BMessage msg(VBOX_GUEST_CLIPBOARD_HOST_MSG_READ_DATA);
    400400                    msg.AddInt32("Formats", (uint32)u32Formats);
    … …  
    403403                }
    404404
    405                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
     405                case VBOX_SHCL_HOST_MSG_QUIT:
    406406                {
    407407                    /* The host is terminating. */
    408                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT\n"));
     408                    LogRelFlowFunc(("VBOX_SHCL_HOST_MSG_QUIT\n"));
    409409                    fExiting = true;
    410410                    return VERR_INTERRUPTED;
    … …  
    412412
    413413                default:
    414                     Log(("VBoxClipboardService::%s: Unsupported message from host! Message = %u\n", __FUNCTION__, u32Msg));
     414                    Log(("VBoxShClService::%s: Unsupported message from host! Message = %u\n", __FUNCTION__, u32Msg));
    415415            }
    416416        }
    … …  
    427427
    428428
    429 void* VBoxClipboardService::_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb)
     429void* VBoxShClService::_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb)
    430430{
    431431    uint32_t cb = 1024;

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

    r76563 r80847  
    5353#include <Handler.h>
    5454
    55 class VBoxClipboardService : public BHandler
     55class VBoxShClService : public BHandler
    5656{
    5757    public:
    58         VBoxClipboardService();
    59         virtual ~VBoxClipboardService();
     58        VBoxShClService();
     59        virtual ~VBoxShClService();
    6060
    6161        virtual status_t    Connect();

  • trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestApplication.h

    r76563 r80847  
    6565#include <VBoxGuestInternal.h>
    6666
    67 class VBoxClipboardService;
     67class VBoxShClService;
    6868
    6969class VBoxGuestApplication : public BApplication

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

    r76553 r80847  
    269269        if (RT_SUCCESS(rc))
    270270        {
    271             fClipboardService = new VBoxClipboardService();
     271            fClipboardService = new VBoxShClService();
    272272            fDisplayService = new VBoxDisplayService();
    273273        }

  • trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.h

    r76563 r80847  
    9292        BBitmap               *fIcon;
    9393
    94         VBoxClipboardService *fClipboardService;
     94        VBoxShClService *fClipboardService;
    9595        VBoxDisplayService *fDisplayService;
    9696};

  • trunk/src/VBox/Additions/haiku/VBoxTray/VBoxServiceDescriptor.h

    r76563 r80847  
    5353#include <Handler.h>
    5454
    55 class VBoxClipboardService : public BHandler
     55class VBoxShClService : public BHandler
    5656{
    5757    public:
    58         VBoxClipboardService();
    59         virtual ~VBoxClipboardService();
     58        VBoxShClService();
     59        virtual ~VBoxShClService();
    6060};
    6161
    6262/* The shared clipboard service prototypes. */
    63 int VBoxClipboardInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
    64 unsigned __stdcall VBoxClipboardThread(void *pInstance);
    65 void VBoxClipboardDestroy(const VBOXSERVICEENV *pEnv, void *pInstance);
     63int VBoxShClInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
     64unsigned __stdcall VBoxShClThread(void *pInstance);
     65void VBoxShClDestroy(const VBOXSERVICEENV *pEnv, void *pInstance);
    6666
    6767#endif /* !GA_INCLUDED_SRC_haiku_VBoxTray_VBoxServiceDescriptor_h */
Note: See TracChangeset for help on using the changeset viewer.

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