VirtualBox

Ignore:
Timestamp:
Mar 3, 2008 12:32:52 PM (17 years ago)
Author:
vboxsync
Message:

fTerminate should be volatile.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/HostServices/SharedClipboard/win32.cpp

    r7165 r7234  
    3636    HWND    hwnd;
    3737    HWND    hwndNextInChain;
    38    
     38
    3939    RTTHREAD thread;
    40     bool   fTerminate;
     40    bool volatile fTerminate;
    4141
    4242    HANDLE hRenderEvent;
    43    
     43
    4444    VBOXCLIPBOARDCLIENTDATA *pClient;
    4545};
     
    9393{
    9494    dprintf (("vboxClipboardGetData.\n"));
    95    
     95
    9696    *pcbActualDst = cbSrc;
    97    
     97
    9898    LogFlow(("vboxClipboardGetData cbSrc = %d, cbDst = %d\n", cbSrc, cbDst));
    99      
     99
    100100    if (cbSrc > cbDst)
    101101    {
     
    103103        return;
    104104    }
    105    
     105
    106106    memcpy (pvDst, pvSrc, cbSrc);
    107    
     107
    108108    vboxClipboardDump(pvDst, cbSrc, u32Format);
    109109
     
    115115    Assert(pCtx->pClient);
    116116    Assert(pCtx->pClient->data.pv == NULL && pCtx->pClient->data.cb == 0 && pCtx->pClient->data.u32Format == 0);
    117    
     117
    118118    LogFlow(("vboxClipboardReadDataFromClient u32Format = %02X\n", u32Format));
    119    
     119
    120120    ResetEvent (pCtx->hRenderEvent);
    121    
     121
    122122    vboxSvcClipboardReportMsg (pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
    123    
     123
    124124    WaitForSingleObject(pCtx->hRenderEvent, INFINITE);
    125    
     125
    126126    LogFlow(("vboxClipboardReadDataFromClient wait completed\n"));
    127    
     127
    128128    return VINF_SUCCESS;
    129129}
     
    132132{
    133133    LogFlow(("vboxClipboardChanged\n"));
    134    
     134
    135135    if (pCtx->pClient == NULL)
    136136    {
    137137        return;
    138138    }
    139    
     139
    140140    /* Query list of available formats and report to host. */
    141141    if (OpenClipboard (pCtx->hwnd))
     
    166166
    167167                        int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR));
    168                        
     168
    169169                        if (cActual)
    170170                        {
     
    180180
    181181        CloseClipboard ();
    182        
     182
    183183        LogFlow(("vboxClipboardChanged u32Formats %02X\n", u32Formats));
    184        
     184
    185185        vboxSvcClipboardReportMsg (pCtx->pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, u32Formats);
    186186    }
     
    190190{
    191191    LRESULT rc = 0;
    192    
     192
    193193    VBOXCLIPBOARDCONTEXT *pCtx = &g_ctx;
    194    
     194
    195195    switch (msg)
    196196    {
     
    240240            /* Do nothing. Ignore the message. */
    241241        } break;
    242        
     242
    243243        case WM_RENDERFORMAT:
    244244        {
     
    249249
    250250            Log(("WM_RENDERFORMAT %d\n", format));
    251            
     251
    252252            switch (format)
    253253            {
     
    266266
    267267                        int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR));
    268                        
     268
    269269                        if (cActual)
    270270                        {
     
    277277                    break;
    278278            }
    279            
     279
    280280            if (u32Format == 0 || pCtx->pClient == NULL)
    281281            {
     
    308308                        {
    309309                            Log(("WM_RENDERFORMAT setting data\n"));
    310                            
     310
    311311                            if (pCtx->pClient->data.pv)
    312312                            {
    313313                                memcpy (pMem, pCtx->pClient->data.pv, pCtx->pClient->data.cb);
    314                            
     314
    315315                                RTMemFree (pCtx->pClient->data.pv);
    316316                                pCtx->pClient->data.pv        = NULL;
     
    340340                    }
    341341                }
    342                
     342
    343343                RTMemFree (pCtx->pClient->data.pv);
    344344                pCtx->pClient->data.pv        = NULL;
    345345                pCtx->pClient->data.cb        = 0;
    346346                pCtx->pClient->data.u32Format = 0;
    347                
     347
    348348                /* Something went wrong. */
    349349                EmptyClipboard ();
     
    354354        {
    355355            Log(("WM_RENDERALLFORMATS\n"));
    356            
     356
    357357            /* Do nothing. The clipboard formats will be unavailable now, because the
    358358             * windows is to be destroyed and therefore the guest side becames inactive.
     
    375375                break;
    376376            }
    377            
     377
    378378            /* Announce available formats. Do not insert data, they will be inserted in WM_RENDER*. */
    379379            uint32_t u32Formats = (uint32_t)lParam;
    380            
     380
    381381            Log(("WM_USER u32Formats = %02X\n", u32Formats));
    382            
     382
    383383            if (OpenClipboard (hwnd))
    384384            {
    385385                EmptyClipboard();
    386                
     386
    387387                Log(("WM_USER emptied clipboard\n"));
    388            
     388
    389389                HANDLE hClip = NULL;
    390390
     
    392392                {
    393393                    dprintf(("window proc WM_USER: VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT\n"));
    394                    
     394
    395395                    hClip = SetClipboardData (CF_UNICODETEXT, NULL);
    396396                }
     
    399399                {
    400400                    dprintf(("window proc WM_USER: VBOX_SHARED_CLIPBOARD_FMT_BITMAP\n"));
    401                    
     401
    402402                    hClip = SetClipboardData (CF_DIB, NULL);
    403403                }
     
    442442
    443443    VBOXCLIPBOARDCONTEXT *pCtx = &g_ctx;
    444    
     444
    445445    HINSTANCE hInstance = (HINSTANCE)GetModuleHandle (NULL);
    446446
     
    521521
    522522    g_ctx.hRenderEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    523    
    524     rc = RTThreadCreate (&g_ctx.thread, VBoxClipboardThread, NULL, 65536, 
     523
     524    rc = RTThreadCreate (&g_ctx.thread, VBoxClipboardThread, NULL, 65536,
    525525                         RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP");
    526526
     
    538538
    539539    /* Set the termination flag and ping the window thread. */
    540     g_ctx.fTerminate = true;
    541    
     540    ASMAtomicWriteBool (&g_ctx.fTerminate, true);
     541
    542542    if (g_ctx.hwnd)
    543543    {
     
    546546
    547547    CloseHandle (g_ctx.hRenderEvent);
    548    
     548
    549549    /* Wait for the window thread to terminate. */
    550550    RTThreadWait (g_ctx.thread, RT_INDEFINITE_WAIT, NULL);
     
    556556{
    557557    Log(("vboxClipboardConnect\n"));
    558    
     558
    559559    if (g_ctx.pClient != NULL)
    560560    {
     
    564564
    565565    pClient->pCtx = &g_ctx;
    566    
     566
    567567    pClient->pCtx->pClient = pClient;
    568    
     568
    569569    /* Synch the host clipboard content with the client. */
    570570    vboxClipboardSync (pClient);
    571    
     571
    572572    return VINF_SUCCESS;
    573573}
     
    577577    /* Synch the host clipboard content with the client. */
    578578    vboxClipboardChanged (pClient->pCtx);
    579    
     579
    580580    return VINF_SUCCESS;
    581581}
     
    584584{
    585585    Log(("vboxClipboardDisconnect\n"));
    586    
     586
    587587    g_ctx.pClient = NULL;
    588588}
     
    599599{
    600600    LogFlow(("vboxClipboardReadData: u32Format = %02X\n", u32Format));
    601    
     601
    602602    HANDLE hClip = NULL;
    603    
     603
    604604    /*
    605605     * The guest wants to read data in the given format.
     
    608608    {
    609609        dprintf(("Clipboard opened.\n"));
    610        
     610
    611611        if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
    612612        {
     
    643643                {
    644644                    dprintf(("CF_UNICODETEXT\n"));
    645                        
     645
    646646                    vboxClipboardGetData (VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, uniString, (lstrlenW (uniString) + 1) * 2,
    647647                                          pv, cb, pcbActual);
     
    690690        dprintf(("failed to open clipboard\n"));
    691691    }
    692    
     692
    693693    if (hClip == NULL)
    694694    {
     
    697697                              pv, cb, pcbActual);
    698698    }
    699    
     699
    700700    return VINF_SUCCESS;
    701701}
     
    704704{
    705705    LogFlow(("vboxClipboardWriteData\n"));
    706    
     706
    707707    /*
    708708     * The guest returns data that was requested in the WM_RENDERFORMAT handler.
    709709     */
    710710    Assert(pClient->data.pv == NULL && pClient->data.cb == 0 && pClient->data.u32Format == 0);
    711    
     711
    712712    vboxClipboardDump(pv, cb, u32Format);
    713713
     
    715715    {
    716716        pClient->data.pv = RTMemAlloc (cb);
    717        
     717
    718718        if (pClient->data.pv)
    719719        {
     
    723723        }
    724724    }
    725    
     725
    726726    SetEvent(pClient->pCtx->hRenderEvent);
    727727}
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