vwemirror/firestorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4cb3ab8ea8f7f7f36d14059ed68dd220f50621da
firestorm/Gameleap/code/mw4/Tools/PrintScrToFile/PrintScrToFileDlg.cpp
T
Cyd 2b8ca921cb Initial full mirror of c:\VWE (source + assets + toolchain + outputs) via Git LFS 
Complete disaster-recovery snapshot: engine/game source, game data assets,
VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive.
Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false,
no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
2026-06-24 21:28:16 -05:00

1810 lines
59 KiB
C++
Raw Blame History

// PrintScrToFileDlg.cpp : implementation file
//
#include "stdafx.h"
#include "PrintScrToFile.h"
#include "PrintScrToFileDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CPrintScrToFileDlg dialog
CPrintScrToFileDlg::CPrintScrToFileDlg(CWnd* pParent /*=NULL*/)
: CDialog(CPrintScrToFileDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CPrintScrToFileDlg)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hwndClipboardViewer = NULL;
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
m_fInCall = FALSE;
m_nCurrentCount = 0;
}
void CPrintScrToFileDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CPrintScrToFileDlg)
DDX_Control(pDX, IDC_BITMAP_FORMAT, m_lstFormats);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CPrintScrToFileDlg, CDialog)
//{{AFX_MSG_MAP(CPrintScrToFileDlg)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
ON_WM_DRAWCLIPBOARD()
ON_WM_CHANGECBCHAIN()
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CPrintScrToFileDlg message handlers
BOOL CPrintScrToFileDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
m_fInCall = TRUE;
m_hwndClipboardViewer = SetClipboardViewer();
m_fInCall = FALSE;
int nCur = LB_ERR;
int nDefault = LB_ERR;
nDefault = nCur = m_lstFormats.AddString("<Default Data Format>");
if (nCur != LB_ERR)
{
m_lstFormats.SetItemData(nCur, 0);
}
nCur = m_lstFormats.AddString("As CF_DIB (default format)");
if (nCur != LB_ERR)
{
m_lstFormats.SetItemData(nCur, 1);
}
nCur = m_lstFormats.AddString("32 bit uncompressed");
if (nCur != LB_ERR)
{
m_lstFormats.SetItemData(nCur, 2);
}
nCur = m_lstFormats.AddString("24 bit uncompressed");
if (nCur != LB_ERR)
{
m_lstFormats.SetItemData(nCur, 3);
}
nCur = m_lstFormats.AddString("16 bit uncompressed");
if (nCur != LB_ERR)
{
m_lstFormats.SetItemData(nCur, 4);
}
m_lstFormats.SetCurSel(nDefault);
return TRUE; // return TRUE unless you set the focus to a control
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CPrintScrToFileDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CPrintScrToFileDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
void CPrintScrToFileDlg::OnOK()
{
//
// App ends when this happens
//
CDialog::OnOK();
PostQuitMessage(0);
}
BOOL CPrintScrToFileDlg::DestroyWindow()
{
ChangeClipboardChain(m_hwndClipboardViewer);
return CDialog::DestroyWindow();
}
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
void CPrintScrToFileDlg::OnDrawClipboard()
{
int nCur = m_lstFormats.GetCurSel();
if (nCur != LB_ERR ) // use current format if none selected
{
int iItemData = m_lstFormats.GetItemData(nCur);
switch (iItemData)
{
case 1: // DrawClipboardPassedIn
DrawClipboardPassedIn();
break;
case 2: // 32-bit Uncompressed
DrawClipboard32Uncompressed();
break;
case 3: // 24bit Uncompressed
DrawClipboard24Uncompressed();
break;
case 4: // 16-bit Uncompressed
DrawClipboard16Uncompressed();
break;
case 0:
DrawClipboardDefault();
default:
break;
}
}
}
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
void CPrintScrToFileDlg::DrawClipboard32Uncompressed()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
BITMAPINFO * pbmInfo3 = NULL;
BITMAPINFO * pbmPassedIn = NULL;
HBITMAP hbmDeviceDependentBitmap = NULL;
HBITMAP hbmClipboardHBitmap = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
hbmClipboardHBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
if (!hbmClipboardHBitmap)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have a file open and a handle to a bitmap.
//
BITMAP bm;
bm.bmBits = NULL;
int nBytes = ::GetObject(hbmClipboardHBitmap, sizeof(bm), &bm);
if (!nBytes)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have the memory, lets load it into memory
//
pbmInfo1 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) /* +
sizeof(RGBQUAD)*256*/);
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
memset(pbmInfo1, 0, sizeof(BITMAPINFOHEADER) );
pbmInfo1->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pDC = GetDC();
bRet = GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap , 0, 1, NULL, pbmInfo1, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
// we now have the header info
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmInfo1->bmiHeader.biSize,
pbmInfo1->bmiHeader.biWidth,
pbmInfo1->bmiHeader.biHeight,
pbmInfo1->bmiHeader.biPlanes,
pbmInfo1->bmiHeader.biBitCount,
pbmInfo1->bmiHeader.biCompression,
pbmInfo1->bmiHeader.biSizeImage/1024,
pbmInfo1->bmiHeader.biXPelsPerMeter,
pbmInfo1->bmiHeader.biYPelsPerMeter,
pbmInfo1->bmiHeader.biClrUsed,
pbmInfo1->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
//
// At this point we know the native format, so lets put it up for display
//
int nSizeOfColorTable = 0;
int nSize = pbmInfo1->bmiHeader.biHeight * pbmInfo1->bmiHeader.biWidth *
32 / sizeof(BYTE);
pbmInfo3 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + nSizeOfColorTable);
memcpy(pbmInfo3, pbmInfo1, sizeof(BITMAPINFOHEADER));
lpv = malloc(nSize);
pbmInfo3->bmiHeader.biBitCount = 32;
pbmInfo3->bmiHeader.biCompression = BI_RGB;
pbmInfo3->bmiHeader.biSizeImage = /*nSize*/0;
pbmInfo3->bmiHeader.biClrUsed = 0;
pDC = GetDC();
bRet = ::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap, 0, pbmInfo3->bmiHeader.biHeight, lpv, pbmInfo3, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
pDC = NULL;
if (fClipboardOpen )
CloseClipboard();
fClipboardOpen = FALSE;
SaveBitmap(nSizeOfColorTable, pbmInfo3->bmiHeader.biSizeImage ? pbmInfo3->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmInfo3, (LPVOID)lpv, strOutput);
}
FunctionEnd:
if (pbmPassedIn)
LocalFree(pbmPassedIn); // am I supposed to do this?
if (hbmDeviceDependentBitmap)
::DeleteObject(hbmDeviceDependentBitmap);
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
#if 0
void CPrintScrToFileDlg::DrawClipboard32Uncompressed()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
BITMAPINFO * pbmInfo3 = NULL;
BITMAPINFO * pbmPassedIn = NULL;
HBITMAP hbmDeviceDependentBitmap = NULL;
HBITMAP hbmClipboardHBitmap = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
hbmClipboardHBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
if (!hbmClipboardHBitmap)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have a file open and a handle to a bitmap.
//
BITMAP bm;
bm.bmBits = NULL;
int nBytes = ::GetObject(hbmClipboardHBitmap, sizeof(bm), &bm);
if (!nBytes)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have the memory, lets load it into memory
//
pbmInfo1 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) /* +
sizeof(RGBQUAD)*256*/);
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
memset(pbmInfo1, 0, sizeof(BITMAPINFOHEADER) );
pbmInfo1->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pDC = GetDC();
bRet = GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap , 0, 1, NULL, pbmInfo1, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
// we now have the header info
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmInfo1->bmiHeader.biSize,
pbmInfo1->bmiHeader.biWidth,
pbmInfo1->bmiHeader.biHeight,
pbmInfo1->bmiHeader.biPlanes,
pbmInfo1->bmiHeader.biBitCount,
pbmInfo1->bmiHeader.biCompression,
pbmInfo1->bmiHeader.biSizeImage/1024,
pbmInfo1->bmiHeader.biXPelsPerMeter,
pbmInfo1->bmiHeader.biYPelsPerMeter,
pbmInfo1->bmiHeader.biClrUsed,
pbmInfo1->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
//
// At this point we know the native format, so lets put it up for display
//
int nSizeOfColorTable = 0;
int nSize = pbmInfo1->bmiHeader.biHeight * pbmInfo1->bmiHeader.biWidth *
32 / sizeof(BYTE);
pbmInfo3 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + nSizeOfColorTable);
memcpy(pbmInfo3, pbmInfo1, sizeof(BITMAPINFOHEADER));
lpv = malloc(nSize);
pbmInfo3->bmiHeader.biBitCount = 32;
pbmInfo3->bmiHeader.biCompression = BI_RGB;
pbmInfo3->bmiHeader.biSizeImage = /*nSize*/0;
pbmInfo3->bmiHeader.biClrUsed = 0;
pDC = GetDC();
bRet = ::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap, 0, pbmInfo3->bmiHeader.biHeight, lpv, pbmInfo3, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
pDC = NULL;
if (fClipboardOpen )
CloseClipboard();
fClipboardOpen = FALSE;
SaveBitmap(nSizeOfColorTable, pbmInfo3->bmiHeader.biSizeImage ? pbmInfo3->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmInfo3, (LPVOID)lpv, strOutput);
}
FunctionEnd:
if (pbmPassedIn)
LocalFree(pbmPassedIn); // am I supposed to do this?
if (hbmDeviceDependentBitmap)
::DeleteObject(hbmDeviceDependentBitmap);
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
#endif
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
void CPrintScrToFileDlg::DrawClipboard16Uncompressed()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
BITMAPINFO * pbmInfo3 = NULL;
BITMAPINFO * pbmPassedIn = NULL;
HBITMAP hbmDeviceDependentBitmap = NULL;
HBITMAP hbmClipboardHBitmap = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
hbmClipboardHBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
if (!hbmClipboardHBitmap)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have a file open and a handle to a bitmap.
//
BITMAP bm;
bm.bmBits = NULL;
int nBytes = ::GetObject(hbmClipboardHBitmap, sizeof(bm), &bm);
if (!nBytes)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have the memory, lets load it into memory
//
pbmInfo1 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) /* +
sizeof(RGBQUAD)*256*/);
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
memset(pbmInfo1, 0, sizeof(BITMAPINFOHEADER) );
pbmInfo1->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pDC = GetDC();
bRet = GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap , 0, 1, NULL, pbmInfo1, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
// we now have the header info
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmInfo1->bmiHeader.biSize,
pbmInfo1->bmiHeader.biWidth,
pbmInfo1->bmiHeader.biHeight,
pbmInfo1->bmiHeader.biPlanes,
pbmInfo1->bmiHeader.biBitCount,
pbmInfo1->bmiHeader.biCompression,
pbmInfo1->bmiHeader.biSizeImage/1024,
pbmInfo1->bmiHeader.biXPelsPerMeter,
pbmInfo1->bmiHeader.biYPelsPerMeter,
pbmInfo1->bmiHeader.biClrUsed,
pbmInfo1->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
//
// At this point we know the native format, so lets put it up for display
//
int nSizeOfColorTable = pbmInfo1->bmiHeader.biClrUsed * sizeof(DWORD);
int nSize = pbmInfo1->bmiHeader.biHeight * pbmInfo1->bmiHeader.biWidth *
16 / sizeof(BYTE);
pbmInfo3 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + nSizeOfColorTable);
memcpy(pbmInfo3, pbmInfo1, sizeof(BITMAPINFOHEADER));
lpv = malloc(nSize);
pbmInfo3->bmiHeader.biBitCount = 16;
pbmInfo3->bmiHeader.biCompression = BI_RGB;
pbmInfo3->bmiHeader.biSizeImage = /*nSize*/0;
pDC = GetDC();
bRet = ::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap, 0, pbmInfo3->bmiHeader.biHeight, lpv, pbmInfo3, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
pDC = NULL;
if (fClipboardOpen )
CloseClipboard();
fClipboardOpen = FALSE;
SaveBitmap(nSizeOfColorTable, pbmInfo3->bmiHeader.biSizeImage ? pbmInfo3->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmInfo3, (LPVOID)lpv, strOutput);
}
FunctionEnd:
if (pbmPassedIn)
LocalFree(pbmPassedIn); // am I supposed to do this?
if (hbmDeviceDependentBitmap)
::DeleteObject(hbmDeviceDependentBitmap);
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
#if 0
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
void CPrintScrToFileDlg::DrawClipboard16Uncompressed()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
BITMAPINFO * pbmInfo3 = NULL;
BITMAPINFO * pbmPassedIn = NULL;
HBITMAP hbmDeviceDependentBitmap = NULL;
HBITMAP hbmClipboardHBitmap = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
hbmClipboardHBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
if (!hbmClipboardHBitmap)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have a file open and a handle to a bitmap.
//
BITMAP bm;
bm.bmBits = NULL;
int nBytes = ::GetObject(hbmClipboardHBitmap, sizeof(bm), &bm);
if (!nBytes)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have the memory, lets load it into memory
//
pbmInfo1 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) /* +
sizeof(RGBQUAD)*256*/);
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
memset(pbmInfo1, 0, sizeof(BITMAPINFOHEADER) );
pbmInfo1->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pDC = GetDC();
bRet = GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap , 0, 1, NULL, pbmInfo1, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
// we now have the header info
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmInfo1->bmiHeader.biSize,
pbmInfo1->bmiHeader.biWidth,
pbmInfo1->bmiHeader.biHeight,
pbmInfo1->bmiHeader.biPlanes,
pbmInfo1->bmiHeader.biBitCount,
pbmInfo1->bmiHeader.biCompression,
pbmInfo1->bmiHeader.biSizeImage/1024,
pbmInfo1->bmiHeader.biXPelsPerMeter,
pbmInfo1->bmiHeader.biYPelsPerMeter,
pbmInfo1->bmiHeader.biClrUsed,
pbmInfo1->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
//
// At this point we know the native format, so lets put it up for display
//
int nSizeOfColorTable = pbmInfo3->bmiHeader.biClrUsed * sizeof(DWORD);
int nSize = pbmInfo1->bmiHeader.biHeight * pbmInfo1->bmiHeader.biWidth *
16 / sizeof(BYTE);
pbmInfo3 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + nSizeOfColorTable);
memcpy(pbmInfo3, pbmInfo1, sizeof(BITMAPINFOHEADER));
lpv = malloc(nSize);
pbmInfo3->bmiHeader.biBitCount = 16;
pbmInfo3->bmiHeader.biCompression = BI_RGB;
pbmInfo3->bmiHeader.biSizeImage = /*nSize*/0;
pDC = GetDC();
bRet = ::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap, 0, pbmInfo3->bmiHeader.biHeight, lpv, pbmInfo3, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
pDC = NULL;
if (fClipboardOpen )
CloseClipboard();
fClipboardOpen = FALSE;
SaveBitmap(nSizeOfColorTable, pbmInfo3->bmiHeader.biSizeImage ? pbmInfo3->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmInfo3, (LPVOID)lpv, strOutput);
}
FunctionEnd:
if (pbmPassedIn)
LocalFree(pbmPassedIn); // am I supposed to do this?
if (hbmDeviceDependentBitmap)
::DeleteObject(hbmDeviceDependentBitmap);
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
#endif
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
void CPrintScrToFileDlg::DrawClipboard24Uncompressed()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
BITMAPINFO * pbmInfo3 = NULL;
BITMAPINFO * pbmPassedIn = NULL;
HBITMAP hbmDeviceDependentBitmap = NULL;
HBITMAP hbmClipboardHBitmap = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
hbmClipboardHBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
if (!hbmClipboardHBitmap)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have a file open and a handle to a bitmap.
//
BITMAP bm;
bm.bmBits = NULL;
int nBytes = ::GetObject(hbmClipboardHBitmap, sizeof(bm), &bm);
if (!nBytes)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have the memory, lets load it into memory
//
pbmInfo1 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) /* +
sizeof(RGBQUAD)*256*/);
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
memset(pbmInfo1, 0, sizeof(BITMAPINFOHEADER) );
pbmInfo1->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pDC = GetDC();
bRet = GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap , 0, 1, NULL, pbmInfo1, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
// we now have the header info
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmInfo1->bmiHeader.biSize,
pbmInfo1->bmiHeader.biWidth,
pbmInfo1->bmiHeader.biHeight,
pbmInfo1->bmiHeader.biPlanes,
pbmInfo1->bmiHeader.biBitCount,
pbmInfo1->bmiHeader.biCompression,
pbmInfo1->bmiHeader.biSizeImage/1024,
pbmInfo1->bmiHeader.biXPelsPerMeter,
pbmInfo1->bmiHeader.biYPelsPerMeter,
pbmInfo1->bmiHeader.biClrUsed,
pbmInfo1->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
//
// At this point we know the native format, so lets put it up for display
//
int nSizeOfColorTable = 0;
int nSize = pbmInfo1->bmiHeader.biHeight * pbmInfo1->bmiHeader.biWidth *
24 / sizeof(BYTE);
pbmInfo3 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + nSizeOfColorTable);
memcpy(pbmInfo3, pbmInfo1, sizeof(BITMAPINFOHEADER));
lpv = malloc(nSize);
if (!lpv)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
pbmInfo3->bmiHeader.biBitCount = 24;
pbmInfo3->bmiHeader.biCompression = BI_RGB;
pbmInfo3->bmiHeader.biSizeImage = /*nSize*/0;
pbmInfo3->bmiHeader.biClrUsed = 0;
pDC = GetDC();
bRet = ::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap, 0, pbmInfo3->bmiHeader.biHeight, lpv, pbmInfo3, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
pDC = NULL;
if (fClipboardOpen )
CloseClipboard();
fClipboardOpen = FALSE;
SaveBitmap(nSizeOfColorTable, pbmInfo3->bmiHeader.biSizeImage ? pbmInfo3->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmInfo3, (LPVOID)lpv, strOutput);
}
FunctionEnd:
if (pbmPassedIn)
LocalFree(pbmPassedIn); // am I supposed to do this?
if (hbmDeviceDependentBitmap)
::DeleteObject(hbmDeviceDependentBitmap);
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
#if 0
void CPrintScrToFileDlg::DrawClipboard24Uncompressed()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
BITMAPINFO * pbmInfo3 = NULL;
BITMAPINFO * pbmPassedIn = NULL;
HBITMAP hbmDeviceDependentBitmap = NULL;
HBITMAP hbmClipboardHBitmap = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
hbmClipboardHBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
if (!hbmClipboardHBitmap)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have a file open and a handle to a bitmap.
//
BITMAP bm;
bm.bmBits = NULL;
int nBytes = ::GetObject(hbmClipboardHBitmap, sizeof(bm), &bm);
if (!nBytes)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have the memory, lets load it into memory
//
pbmInfo1 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) /* +
sizeof(RGBQUAD)*256*/);
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
memset(pbmInfo1, 0, sizeof(BITMAPINFOHEADER) );
pbmInfo1->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pDC = GetDC();
bRet = GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap , 0, 1, NULL, pbmInfo1, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
// we now have the header info
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmInfo1->bmiHeader.biSize,
pbmInfo1->bmiHeader.biWidth,
pbmInfo1->bmiHeader.biHeight,
pbmInfo1->bmiHeader.biPlanes,
pbmInfo1->bmiHeader.biBitCount,
pbmInfo1->bmiHeader.biCompression,
pbmInfo1->bmiHeader.biSizeImage/1024,
pbmInfo1->bmiHeader.biXPelsPerMeter,
pbmInfo1->bmiHeader.biYPelsPerMeter,
pbmInfo1->bmiHeader.biClrUsed,
pbmInfo1->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
//
// At this point we know the native format, so lets put it up for display
//
int nSizeOfColorTable = 0;
int nSize = pbmInfo1->bmiHeader.biHeight * pbmInfo1->bmiHeader.biWidth *
24 / sizeof(BYTE);
pbmInfo3 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + nSizeOfColorTable);
memcpy(pbmInfo3, pbmInfo1, sizeof(BITMAPINFOHEADER));
lpv = malloc(nSize);
pbmInfo3->bmiHeader.biBitCount = 24;
pbmInfo3->bmiHeader.biCompression = BI_RGB;
pbmInfo3->bmiHeader.biSizeImage = /*nSize*/0;
pbmInfo3->bmiHeader.biClrUsed = 0;
pDC = GetDC();
bRet = ::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap, 0, pbmInfo3->bmiHeader.biHeight, lpv, pbmInfo3, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
pDC = NULL;
if (fClipboardOpen )
CloseClipboard();
fClipboardOpen = FALSE;
SaveBitmap(nSizeOfColorTable, pbmInfo3->bmiHeader.biSizeImage ? pbmInfo3->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmInfo3, (LPVOID)lpv, strOutput);
}
FunctionEnd:
if (pbmPassedIn)
LocalFree(pbmPassedIn); // am I supposed to do this?
if (hbmDeviceDependentBitmap)
::DeleteObject(hbmDeviceDependentBitmap);
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
#endif
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
void CPrintScrToFileDlg::DrawClipboardPassedIn()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
BITMAPINFO * pbmInfo3 = NULL;
BITMAPINFO * pbmPassedIn = NULL;
HBITMAP hbmDeviceDependentBitmap = NULL;
HBITMAP hbmClipboardHBitmap = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
pbmPassedIn = (BITMAPINFO *)GetClipboardData(CF_DIB);
if (!pbmPassedIn)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmPassedIn->bmiHeader.biSize,
pbmPassedIn->bmiHeader.biWidth,
pbmPassedIn->bmiHeader.biHeight,
pbmPassedIn->bmiHeader.biPlanes,
pbmPassedIn->bmiHeader.biBitCount,
pbmPassedIn->bmiHeader.biCompression,
pbmPassedIn->bmiHeader.biSizeImage/1024,
pbmPassedIn->bmiHeader.biXPelsPerMeter,
pbmPassedIn->bmiHeader.biYPelsPerMeter,
pbmPassedIn->bmiHeader.biClrUsed,
pbmPassedIn->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
//
// At this point we know the native format, so lets put it up for display
//
int nSizeOfColorTable = 0;
int nSize = pbmPassedIn->bmiHeader.biHeight * pbmPassedIn->bmiHeader.biWidth *
pbmPassedIn->bmiHeader.biBitCount / sizeof(BYTE);
if (pbmPassedIn->bmiHeader.biBitCount < 24)
{
nSizeOfColorTable = sizeof(RGBQUAD)*256 * pbmPassedIn->bmiHeader.biBitCount ;
}
else if (pbmPassedIn->bmiHeader.biCompression == BI_BITFIELDS )
{
nSizeOfColorTable = 3 * sizeof(DWORD);
}
else
{
nSizeOfColorTable = 0;
}
if (fClipboardOpen )
CloseClipboard();
fClipboardOpen = FALSE;
SaveBitmap(nSizeOfColorTable, pbmPassedIn->bmiHeader.biSizeImage ? pbmPassedIn->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmPassedIn, (LPVOID)((DWORD)&(pbmPassedIn->bmiHeader) + (DWORD)pbmPassedIn->bmiHeader.biSize), strOutput);
}
FunctionEnd:
if (pbmPassedIn)
LocalFree(pbmPassedIn); // am I supposed to do this?
if (hbmDeviceDependentBitmap)
::DeleteObject(hbmDeviceDependentBitmap);
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
void CPrintScrToFileDlg::DrawClipboardDefault()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
HANDLE hFile = INVALID_HANDLE_VALUE;
DWORD dwError = ERROR_ALREADY_EXISTS;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
HANDLE hBitmap = GetClipboardData(CF_BITMAP);
if (hBitmap)
{
//
// Find the first file that isn't used already fitting the format
//
while (hFile == INVALID_HANDLE_VALUE &&
(dwError == ERROR_ALREADY_EXISTS || dwError == ERROR_FILE_EXISTS))
{
strFilename.Format("PrintScrToFile_%03d.bmp", m_nCurrentCount);
hFile = CreateFile((LPCSTR)strFilename, GENERIC_WRITE | GENERIC_READ, 0, NULL,
CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
dwError = GetLastError();
m_nCurrentCount++;
}
if (hFile == INVALID_HANDLE_VALUE) // we had some other error
{
strOutput.Format("Failed save, couldn't open file");
goto FunctionEnd;
}
//
// We now have a file open and a handle to a bitmap.
//
BITMAP bm;
bm.bmBits = NULL;
int nBytes = ::GetObject(hBitmap, sizeof(bm), &bm);
if (!nBytes)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have the memory, lets load it into memory
//
pbmInfo1 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) /* +
sizeof(RGBQUAD)*256*/);
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
memset(pbmInfo1, 0, sizeof(BITMAPINFOHEADER) );
pbmInfo1->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pDC = GetDC();
bRet = GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hBitmap, 0, 1, NULL, pbmInfo1, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
// we now have the header info
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmInfo1->bmiHeader.biSize,
pbmInfo1->bmiHeader.biWidth,
pbmInfo1->bmiHeader.biHeight,
pbmInfo1->bmiHeader.biPlanes,
pbmInfo1->bmiHeader.biBitCount,
pbmInfo1->bmiHeader.biCompression,
pbmInfo1->bmiHeader.biSizeImage/1024,
pbmInfo1->bmiHeader.biXPelsPerMeter,
pbmInfo1->bmiHeader.biYPelsPerMeter,
pbmInfo1->bmiHeader.biClrUsed,
pbmInfo1->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
int nSize = pbmInfo1->bmiHeader.biSizeImage; // we're asking for 24bpp no matter what below
int nSizeOfColorTable = 0;
if (pbmInfo1->bmiHeader.biBitCount < 16)
{
nSizeOfColorTable = sizeof(RGBQUAD)*256 * pbmInfo1->bmiHeader.biBitCount ;
}
else if (pbmInfo1->bmiHeader.biCompression == BI_BITFIELDS )
{
nSizeOfColorTable = 3 * sizeof(DWORD);
}
else if (pbmInfo1->bmiHeader.biBitCount == 16)
{
nSizeOfColorTable = sizeof(RGBQUAD) * pbmInfo1->bmiHeader.biClrUsed ;
}
else
{
nSizeOfColorTable = 0;
}
pbmInfo2 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) +
nSizeOfColorTable);
memset(pbmInfo2, 0, sizeof(BITMAPINFO));
memcpy(pbmInfo2, pbmInfo1, sizeof(BITMAPINFOHEADER) +
nSizeOfColorTable);
pbmInfo2->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
if (!pbmInfo2)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
lpv = malloc(nSize);
if (!lpv)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
if (!::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hBitmap, 0, pbmInfo2->bmiHeader.biHeight, lpv, pbmInfo2, DIB_RGB_COLORS))
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
CloseClipboard();
fClipboardOpen = FALSE;
//
// Now we have all the data, so save it off
//
// SaveBitmap(nSizeOfColorTable, (BITMAPINFOHEADER *)pbmInfo2, (LPVOID)((DWORD)&(pbmInfo2->bmiHeader) + (DWORD)pbmInfo2->bmiHeader.biSize), strOutput);
if (fClipboardOpen )
CloseClipboard();
fClipboardOpen = FALSE;
SaveBitmap(nSizeOfColorTable, pbmInfo2->bmiHeader.biSizeImage ? pbmInfo2->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmInfo2, lpv, strOutput);
/*
DWORD dwBytesOut = 0;
BITMAPFILEHEADER bmHeader;
bmHeader.bfType = 'MB';
bmHeader.bfReserved1 = 0;
bmHeader.bfReserved2 = 0;
bmHeader.bfSize = nSize + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
nSizeOfColorTable;
bmHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
nSizeOfColorTable;
WriteFile(hFile, &bmHeader, sizeof(BITMAPFILEHEADER), &dwBytesOut, NULL);
WriteFile(hFile, pbmInfo2, sizeof(BITMAPINFOHEADER) + nSizeOfColorTable, &dwBytesOut, NULL);
WriteFile(hFile, lpv, nSize, &dwBytesOut, NULL);
// update the IDC_LASTSAVED field
strOutput.Format("Saved '%s'", (LPCSTR)strFilename);
*/
}
}
FunctionEnd:
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
void CPrintScrToFileDlg::SaveBitmap(int nSizeOfColorTable, int nSizeofData, BITMAPINFOHEADER * pbmInfo2, LPVOID lpv, CString & strOutput)
{
HANDLE hFile = INVALID_HANDLE_VALUE;
DWORD dwError = ERROR_ALREADY_EXISTS;
CString strFilename;
//int nSize = pbmInfo2->biSizeImage;
int nSize = nSizeofData;
DWORD dwBytesOut = 0;
BITMAPFILEHEADER bmHeader;
//
// Find the first file that isn't used already fitting the format
//
while (hFile == INVALID_HANDLE_VALUE &&
(dwError == ERROR_ALREADY_EXISTS || dwError == ERROR_FILE_EXISTS))
{
strFilename.Format("PrintScrToFile_%03d.bmp", m_nCurrentCount);
hFile = CreateFile((LPCSTR)strFilename, GENERIC_WRITE | GENERIC_READ, 0, NULL,
CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
dwError = GetLastError();
m_nCurrentCount++;
}
if (hFile == INVALID_HANDLE_VALUE) // we had some other error
{
strOutput.Format("Failed save, couldn't open file");
goto FunctionEnd;
}
//
// Now we have all the data, so save it off
//
bmHeader.bfType = 'MB';
bmHeader.bfReserved1 = 0;
bmHeader.bfReserved2 = 0;
bmHeader.bfSize = nSize + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
nSizeOfColorTable;
bmHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
nSizeOfColorTable;
WriteFile(hFile, &bmHeader, sizeof(BITMAPFILEHEADER), &dwBytesOut, NULL);
WriteFile(hFile, pbmInfo2, sizeof(BITMAPINFOHEADER) + nSizeOfColorTable, &dwBytesOut, NULL);
WriteFile(hFile, lpv, nSize, &dwBytesOut, NULL);
// update the IDC_LASTSAVED field
strOutput.Format("Saved '%s'", (LPCSTR)strFilename);
FunctionEnd:
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
}
void CPrintScrToFileDlg::OnChangeCbChain( HWND hWndRemove, HWND hWndAfter )
{
if (m_hwndClipboardViewer == hWndRemove)
{
m_hwndClipboardViewer = hWndAfter;
}
if (m_hwndClipboardViewer)
{
SendMessage(WM_DRAWCLIPBOARD, 0, 0);
}
}
//***************************************************************************************************
//***************************************************************************************************
//***************************************************************************************************
#if 0
void CPrintScrToFileDlg::OnDrawClipboard()
{
CString strOutput;
strOutput.Format("Failed save.");
BOOL fClipboardOpen = FALSE;
CString strFilename;
BOOL bRet = FALSE;
BITMAPINFO * pbmInfo1 = NULL;
BITMAPINFO * pbmInfo2 = NULL;
BITMAPINFO * pbmInfo3 = NULL;
BITMAPINFO * pbmPassedIn = NULL;
HBITMAP hbmDeviceDependentBitmap = NULL;
HBITMAP hbmClipboardHBitmap = NULL;
CDC * pDC = NULL;
LPVOID lpv = NULL;
if (!m_fInCall)
{
if (OpenClipboard())
{
fClipboardOpen = TRUE;
pbmPassedIn = (BITMAPINFO *)GetClipboardData(CF_DIB);
/*
HANDLE hBitmap = GetClipboardData(CF_BITMAP);
if (hBitmap)
{
//
// We now have a file open and a handle to a bitmap.
//
BITMAP bm;
bm.bmBits = NULL;
int nBytes = ::GetObject(hBitmap, sizeof(bm), &bm);
if (!nBytes)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// We now have the memory, lets load it into memory
//
pbmInfo1 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) // +
//sizeof(RGBQUAD)*256
);
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
memset(pbmInfo1, 0, sizeof(BITMAPINFOHEADER) );
pbmInfo1->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pDC = GetDC();
bRet = GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hBitmap, 0, 1, NULL, pbmInfo1, DIB_RGB_COLORS);
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
// we now have the header info
*/
if (!pbmPassedIn)
{
strOutput.Format("Failed save '%s' failed to get data from GetClipboardData(CF_DIB)", (LPCSTR)strFilename);
goto FunctionEnd;
}
strOutput.Format("Size (%ld), H/W (%ld, %ld), Planes (%d),\r\n"
"BitCount (%d), Compression (0x%08X), SizeImage (%ldKB),\r\n"
"XPels/YPels per M (%ld, %ld), ClrUsed (%ld), ClrImportant (%ld)",
pbmPassedIn->bmiHeader.biSize,
pbmPassedIn->bmiHeader.biWidth,
pbmPassedIn->bmiHeader.biHeight,
pbmPassedIn->bmiHeader.biPlanes,
pbmPassedIn->bmiHeader.biBitCount,
pbmPassedIn->bmiHeader.biCompression,
pbmPassedIn->bmiHeader.biSizeImage/1024,
pbmPassedIn->bmiHeader.biXPelsPerMeter,
pbmPassedIn->bmiHeader.biYPelsPerMeter,
pbmPassedIn->bmiHeader.biClrUsed,
pbmPassedIn->bmiHeader.biClrImportant);
GetDlgItem(IDC_NATIVE_FORMAT)->SetWindowText(strOutput);
//
// At this point we know the native format, so lets put it up for display
//
int nSizeOfColorTable = 0;
int nSize = pbmPassedIn->bmiHeader.biHeight * pbmPassedIn->bmiHeader.biWidth *
pbmPassedIn->bmiHeader.biBitCount / sizeof(BYTE);
int nCur = m_lstFormats.GetCurSel();
if (nCur != LB_ERR ) // use current format if none selected
{
int iItemData = m_lstFormats.GetItemData(nCur);
switch (iItemData)
{
case 1: // 32-bit Uncompressed
{
hbmClipboardHBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
nSize = pbmPassedIn->bmiHeader.biHeight * pbmPassedIn->bmiHeader.biWidth *
pbmPassedIn->bmiHeader.biBitCount / sizeof(BYTE);
pbmInfo3 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER));
memcpy(pbmInfo3, pbmPassedIn, sizeof(BITMAPINFOHEADER));
lpv = malloc(pbmInfo3->bmiHeader.biWidth * pbmInfo3->bmiHeader.biHeight * 32);
pbmInfo3->bmiHeader.biBitCount = 32;
pbmInfo3->bmiHeader.biCompression = BI_RGB;
pbmInfo3->bmiHeader.biSizeImage = /*nSize*/0;
pDC = GetDC();
bRet = ::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hbmClipboardHBitmap, 0, pbmInfo3->bmiHeader.biHeight, lpv, pbmInfo3, DIB_RGB_COLORS);
//
// Experiment with creating a device dependent bitmap then getting what I want from it
//
//
//
//
if (!bRet)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
pDC = NULL;
SaveBitmap(nSizeOfColorTable, nSize, (BITMAPINFOHEADER *)pbmInfo3, (LPVOID)lpv, strOutput);
}
break;
case 2: // 24-bit uncompressed
{
}
break;
/* // 32-bit RLE8
case 3: // 32-bit RLE4
{
}
break;
case 4: // 32-bit BITFIELD
{
}
break;
case 5: // 32-bit JPEG
{
}
break;
case 6: // 32-bit PNG
{
}
break;
*/
case 0:
default: // do nothing, just use the passed in stats for the bitmap
{
if (pbmPassedIn->bmiHeader.biBitCount < 16)
{
nSizeOfColorTable = sizeof(RGBQUAD)*256 * pbmPassedIn->bmiHeader.biBitCount ;
}
else if (pbmPassedIn->bmiHeader.biCompression == BI_BITFIELDS )
{
nSizeOfColorTable = 3 * sizeof(DWORD);
}
else
{
nSizeOfColorTable = 0;
}
SaveBitmap(nSizeOfColorTable, pbmPassedIn->bmiHeader.biSizeImage ? pbmPassedIn->bmiHeader.biSizeImage : nSize, (BITMAPINFOHEADER *)pbmPassedIn, (LPVOID)((DWORD)&(pbmPassedIn->bmiHeader) + (DWORD)pbmPassedIn->bmiHeader.biSize), strOutput);
}
break;
}
}
/*
if (!pbmInfo1)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
//
// Now I have to do a bunch of annoying detection to find out how big tieh color table is supposed
// to be for this specific format.
//
int nSize = pbmInfo1->bmiHeader.biSizeImage; // we're asking for 24bpp no matter what below
int nSizeOfColorTable = 0;
if (pbmInfo1->bmiHeader.biBitCount < 24)
{
nSizeOfColorTable = sizeof(RGBQUAD)*256 * pbmInfo1->bmiHeader.biBitCount ;
}
else if (pbmInfo1->bmiHeader.biCompression == BI_BITFIELDS )
{
nSizeOfColorTable = 3 * sizeof(DWORD);
}
else
{
nSizeOfColorTable = 0;
}
pbmInfo2 = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) +
nSizeOfColorTable);
memset(pbmInfo2, 0, sizeof(BITMAPINFO));
memcpy(pbmInfo2, pbmInfo1, sizeof(BITMAPINFOHEADER) +
nSizeOfColorTable);
pbmInfo2->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
if (!pbmInfo2)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
lpv = malloc(nSize);
if (!lpv)
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
if (!::GetDIBits(pDC->GetSafeHdc(), (HBITMAP)hBitmap, 0, pbmInfo2->bmiHeader.biHeight, lpv, pbmInfo2, DIB_RGB_COLORS))
{
strOutput.Format("Failed save '%s'", (LPCSTR)strFilename);
goto FunctionEnd;
}
ReleaseDC(pDC);
pDC = NULL;
CloseClipboard();
fClipboardOpen = FALSE;
}
void SaveBitmap(int nSizeOfColorTable, BITMAPINFOHEADER * pbmInfo2, LPVOID lpv, CString & strOutput)
*/
}
FunctionEnd:
if (pbmPassedIn)
LocalFree(pbmPassedIn); // am I supposed to do this?
if (hbmDeviceDependentBitmap)
::DeleteObject(hbmDeviceDependentBitmap);
if (fClipboardOpen )
CloseClipboard();
GetDlgItem(IDC_LASTSAVED)->SetWindowText(strOutput);
if (pDC)
ReleaseDC(pDC);
if (lpv)
free(lpv);
if (pbmInfo1 )
free(pbmInfo1);
if (pbmInfo2 )
free(pbmInfo2);
if (m_hwndClipboardViewer)
::SendMessage(m_hwndClipboardViewer, WM_DRAWCLIPBOARD, 0, 0);
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink