FAQ VC++ et MFCConsultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
  
bool CopyBitmapToClipBoard(CBitmap *pBitmap)  
{  
    if(!AfxGetMainWnd()->OpenClipboard()) return false;  
     if(!EmptyClipboard()) return false;  
  
     bool bret=(SetClipboardData(CF_BITMAP, pBitmap->m_hObject)!=NULL);  
     bret=(CloseClipboard()==TRUE);  
    return bret;  
}  
CBitmap *pBmp=CopyWindowToBitmap(this,true);  
CopyBitmapToClipBoard(pBmp);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
  
// Zafir Anjum : http://www.codeguru.com/Cpp/G-M/bitmap/article.php/c1757/ 
HBITMAP DIBToDDB( HANDLE hDIB ) 
{ 
    LPBITMAPINFOHEADERlpbi; 
    HBITMAP hbm; 
    CPalettepal; 
    CPalette*pOldPal; 
    CClientDCdc(NULL); 
  
    if (hDIB == NULL) 
        return NULL; 
  
    lpbi = (LPBITMAPINFOHEADER)hDIB; 
  
    int nColors = lpbi->biClrUsed ? lpbi->biClrUsed :  
    1 << lpbi->biBitCount; 
  
    BITMAPINFO &bmInfo = *(LPBITMAPINFO)hDIB ; 
    LPVOID lpDIBBits; 
    if( bmInfo.bmiHeader.biBitCount > 8 ) 
        lpDIBBits = (LPVOID)((LPDWORD)(bmInfo.bmiColors +  
        bmInfo.bmiHeader.biClrUsed) +  
        ((bmInfo.bmiHeader.biCompression == BI_BITFIELDS) ? 3 : 0)); 
    else 
        lpDIBBits = (LPVOID)(bmInfo.bmiColors + nColors); 
  
    // Create and select a logical palette if needed 
    if( nColors <= 256 && dc.GetDeviceCaps(RASTERCAPS) & RC_PALETTE) 
    { 
        UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors); 
        LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize]; 
  
        pLP->palVersion = 0x300; 
        pLP->palNumEntries = nColors; 
  
        for( int i=0; i < nColors; i++) 
        { 
            pLP->palPalEntry[i].peRed = bmInfo.bmiColors[i].rgbRed; 
            pLP->palPalEntry[i].peGreen = bmInfo.bmiColors[i].rgbGreen; 
            pLP->palPalEntry[i].peBlue = bmInfo.bmiColors[i].rgbBlue; 
            pLP->palPalEntry[i].peFlags = 0; 
        } 
  
        pal.CreatePalette( pLP ); 
  
        delete[] pLP; 
  
        // Select and realize the palette 
        pOldPal = dc.SelectPalette( &pal, FALSE ); 
        dc.RealizePalette(); 
    } 
  
  
    hbm = CreateDIBitmap(dc.GetSafeHdc(),// handle to device context 
        (LPBITMAPINFOHEADER)lpbi,// pointer to bitmap info header  
        (LONG)CBM_INIT,// initialization flag 
        lpDIBBits,// pointer to initialization data  
        (LPBITMAPINFO)lpbi,// pointer to bitmap info 
        DIB_RGB_COLORS );// color-data usage  
  
    if (pal.GetSafeHandle()) 
        dc.SelectPalette(pOldPal,FALSE); 
  
    return hbm; 
  
} 
  
HGLOBAL WINAPI CopyHandle (HGLOBAL h) 
{ 
   if (h == NULL) return NULL; 
   DWORD dwLen = ::GlobalSize((HGLOBAL) h); 
   HGLOBAL hCopy = ::GlobalAlloc(GHND, dwLen); 
   if (hCopy != NULL) 
   { 
        void* lpCopy = ::GlobalLock((HGLOBAL) hCopy); 
        void* lp     = ::GlobalLock((HGLOBAL) h); 
        memcpy(lpCopy, lp, dwLen); 
        ::GlobalUnlock(hCopy); 
        ::GlobalUnlock(h); 
   } 
   return hCopy; 
} 
// le test est fait dans une CFormView 
void CTestSDIView::OnInitialUpdate() 
{ 
    CFormView::OnInitialUpdate(); 
    GetParentFrame()->RecalcLayout(); 
    ResizeParentToFit(); 
  
    HANDLE hNewDIB = NULL; 
  
    // une image est disponible ? 
    if(!::IsClipboardFormatAvailable(CF_DIB)) return; 
  
    // ouverture du presse papier 
    if (!OpenClipboard()) return; 
  
    // copie l'image du presse papier. 
    hNewDIB = CopyHandle(::GetClipboardData(CF_DIB)); 
  
    // fermeture presse papier 
    CloseClipboard();         
  
    // lock l'espace memoire alloué au dib. 
    HGLOBAL h=::GlobalLock((HGLOBAL)hNewDIB); 
  
    CBitmap Bitmap; 
    // fabrique un bitmap DDB 
    Bitmap.Attach(DIBToDDB(h)); 
  
    // edition du bitmap. 
    PrintBmp(&Bitmap); 
  
    // unlock  
    ::GlobalUnlock((HGLOBAL)hNewDIB); 
  
    // remet l'image dans le presse papier 
    OpenClipboard() ; 
    EmptyClipboard() ; // vide au préalable 
    SetClipboardData(CF_DIB,hNewDIB); 
    CloseClipboard () ;   
  
    // liberation du handle hNewDIB 
    ::GlobalFree(hNewDIB);         
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  
DWORD len; 
HGLOBAL hgbl; 
char temp[MAX_PATH]; 
char *pmem; 
  
len = GetModuleFileName(NULL,temp,MAX_PATH); 
if (!len) return 0; 
hgbl = GlobalAlloc(GHND, len + 1); 
if(!hgbl) return 0; 
pmem = (char*)GlobalLock(hgbl); 
strcpy(pmem,temp); 
GlobalUnlock(hgbl); 
OpenClipboard(NULL); 
EmptyClipboard(); 
SetClipboardData(CF_TEXT, hgbl); 
CloseClipboard();