archive
/
windows-nt-4.0
mirror of https://github.com/lianthony/NT4.0
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Windows NT 4.0 source code leak
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
184 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-nt-4.0/private/windows/shell/accesory/ole2pbsh/loadbit.c

363 lines
10 KiB
Raw Permalink Blame History

/****************************Module*Header******************************\
* Module Name: loadbit.c *
* *
* *
* *
* Created: 1989 *
* *
* Copyright (c) 1987 - 1991 Microsoft Corporation *
* *
* A general description of how the module is used goes here. *
* *
* Additional information such as restrictions, limitations, or special *
* algorithms used if they are externally visible or effect proper use *
* of the module. *
\***********************************************************************/
#define NOVIRTUALKEYCODES
#define NOKANJI
#define NOWH
#define NOCOMM
#define NOSOUND
#define NOSCROLL
#define NOICONS
#include <windows.h>
#include <stdio.h>
#include "port1632.h"
#include "pbrush.h"
#define DIBID 0x4D42
#define SBITMAPFILEHEADER 14
extern int DlgCaptionNo;
extern int pickWid, pickHgt, defaultWid, defaultHgt;
extern HWND pbrushWnd[];
extern HPALETTE hPalette;
extern int imagePlanes, imagePixels;
extern HDC pickDC;
extern WORD wFileType;
extern BOOL gfDirty;
extern TCHAR filePath[];
int LoadBitmapFile(HWND hWnd, LPTSTR lpFilename, LPBITMAPINFO lpInfoHeader)
{
BITMAPFILEHEADER hdr;
BITMAPINFO hdrInfo;
O_BITMAPINFO O_hdrInfo;
LPBITMAPINFO lpDIBinfo;
HANDLE fh;
BOOL error = TRUE;
int wplanes, wbitpx, i;
HANDLE hDIBbits = NULL, hDIBinfo = NULL;
HDC hdc = NULL, parentdc = NULL;
LPBYTE lpDIBbits = NULL;
HBITMAP hbitmap = NULL, htempbit = NULL;
DWORD dwSize, dwHdrSize, dwRGBsize, dwNumColors;
HCURSOR oldCsr;
int alloc;
WORD errmsg;
UINT wUsage;
UINT wSize;
HPALETTE hNewPal = NULL;
LONG lCurPos;
int ht;
int height;
if ((fh = MyOpenFile(lpFilename, NULL, OF_READ | OF_SHARE_DENY_WRITE)) == INVALID_HANDLE_VALUE)
{
errmsg = IDSCantOpen;
goto error1;
}
if (!MyByteReadFile(fh, &hdr, SBITMAPFILEHEADER))
{
errmsg = IDSUnableHdr;
goto error2;
}
lCurPos = MyFileSeek(fh, 0L, 1);
/* read in size field to determine if we are reading old or new DIB */
if (!MyByteReadFile(fh, (LPBYTE) &dwHdrSize, sizeof(DWORD)))
{
errmsg = IDSUnableHdr;
goto error2;
}
MyFileSeek(fh, lCurPos, 0);
/* call the appropriate routine to fill in the header */
switch (LOWORD(dwHdrSize)) {
case sizeof(BITMAPINFOHEADER):
wSize = sizeof(BITMAPINFOHEADER);
if (!MyByteReadFile(fh, &hdrInfo, wSize))
{
errmsg = IDSUnableHdr;
goto error2;
}
dwRGBsize = sizeof(RGBQUAD);
break;
case sizeof(O_BITMAPCOREHEADER):
wSize = sizeof(O_BITMAPCOREHEADER);
if (!MyByteReadFile(fh, &O_hdrInfo, wSize))
{
errmsg = IDSUnableHdr;
goto error2;
}
/* fill in new bitmap header fields by hand... */
hdrInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
hdrInfo.bmiHeader.biWidth = O_hdrInfo.bmciHeader.bcWidth;
hdrInfo.bmiHeader.biHeight = O_hdrInfo.bmciHeader.bcHeight;
hdrInfo.bmiHeader.biPlanes = O_hdrInfo.bmciHeader.bcPlanes;
hdrInfo.bmiHeader.biBitCount = O_hdrInfo.bmciHeader.bcBitCount;
hdrInfo.bmiHeader.biCompression = 0;
hdrInfo.bmiHeader.biSizeImage = 0;
hdrInfo.bmiHeader.biXPelsPerMeter = 0;
hdrInfo.bmiHeader.biYPelsPerMeter = 0;
hdrInfo.bmiHeader.biClrUsed = 0;
hdrInfo.bmiHeader.biClrImportant = 0;
dwRGBsize = sizeof(RGBTRIPLE);
break;
default:
errmsg = IDSUnableHdr;
goto error2;
}
if (hdrInfo.bmiHeader.biPlanes != 1 || hdr.bfType != DIBID) {
errmsg = IDSUnableHdr;
goto error2;
}
if (hdrInfo.bmiHeader.biCompression) {
errmsg = IDSUnknownFmt;
goto error2;
}
if (DlgCaptionNo == PASTEFROM) {
pickWid = LOWORD(hdrInfo.bmiHeader.biWidth);
pickHgt = LOWORD(hdrInfo.bmiHeader.biHeight);
}
/* if lpInfoHeader != NULL then we are just supposed to read header */
if (lpInfoHeader)
{
*lpInfoHeader = hdrInfo;
MyCloseFile(fh);
return 0;
}
if (!(dwNumColors = hdrInfo.bmiHeader.biClrUsed))
if (hdrInfo.bmiHeader.biBitCount != 24)
dwNumColors = (1L << hdrInfo.bmiHeader.biBitCount);
if (!(parentdc = GetDisplayDC(hWnd))) {
errmsg = IDSCantAlloc;
goto error2;
}
if (hdrInfo.bmiHeader.biBitCount != 1) {
wplanes = GetDeviceCaps(parentdc, PLANES);
wbitpx = GetDeviceCaps(parentdc, BITSPIXEL);
} else {
wplanes = 1;
wbitpx = 1;
}
oldCsr = SetCursor(LoadCursor(NULL, IDC_WAIT));
if (DlgCaptionNo == PASTEFROM) {
if (!(alloc = AlocPick(parentdc))) {
errmsg = IDSCantAlloc;
goto error3;
}
} else if (errmsg = AllocImg(LOWORD(abs( hdrInfo.bmiHeader.biWidth ) ),
LOWORD(abs( hdrInfo.bmiHeader.biHeight ) ),
wplanes, wbitpx, FALSE))
goto error3;
dwSize = sizeof(BITMAPINFOHEADER)
+ (dwNumColors ? dwNumColors : 1) * sizeof(RGBQUAD);
if (!(hDIBinfo = GlobalAlloc(GMEM_MOVEABLE, dwSize))) {
errmsg = IDSCantAlloc;
goto error3;
}
if (!(lpDIBinfo = (LPBITMAPINFO) GlobalLock(hDIBinfo))) {
errmsg = IDSCantAlloc;
goto error4;
}
/* copy header into allocated memory */
*lpDIBinfo = hdrInfo;
/* read in the palette if not 24 bits */
if (dwNumColors) {
wSize = LOWORD(dwRGBsize * dwNumColors);
if (!MyByteReadFile(fh, lpDIBinfo->bmiColors, wSize))
{
errmsg = IDSUnablePalette;
goto error5;
}
if (dwRGBsize == sizeof(RGBTRIPLE)) {
TripleToQuad(lpDIBinfo, FALSE);
}
}
hNewPal = MakeImagePalette(hPalette, hDIBinfo, &wUsage);
if (hNewPal && hNewPal != hPalette) {
SelectPalette(hdcWork, hNewPal, 0);
RealizePalette(hdcWork);
SelectPalette(hdcImage, hNewPal, 0);
RealizePalette(hdcImage);
hPalette = hNewPal;
}
hdc = CreateCompatibleDC((DlgCaptionNo == PASTEFROM) ? pickDC : parentdc);
ReleaseDC(hWnd, parentdc);
parentdc = NULL;
if (!hdc) {
errmsg = IDSNoMemAvail;
goto error7;
}
wSize = (WORD)(((hdrInfo.bmiHeader.biWidth *
hdrInfo.bmiHeader.biBitCount + 31) & (~31)) / 8);
height = abs( (int)hdrInfo.bmiHeader.biHeight );
for (ht = abs( height ), hbitmap = NULL; ht && !hbitmap; ) {
if (!(hDIBbits = GlobalAlloc(GMEM_MOVEABLE, (DWORD)wSize * (DWORD)ht))
|| !(hbitmap = CreateBitmap(LOWORD(hdrInfo.bmiHeader.biWidth), ht,
(BYTE) imagePlanes, (BYTE) imagePixels,
NULL))) {
if (hDIBbits)
GlobalFree(hDIBbits);
ht = ht >> 1;
}
}
if (!ht) {
errmsg = IDSNoMemAvail;
goto error7;
}
if (!(lpDIBbits = GlobalLock(hDIBbits))) {
errmsg = IDSNoMemAvail;
goto error7;
}
if(!(htempbit = SelectObject(hdc, hbitmap))) {
errmsg = IDSNoMemAvail;
goto error7;
}
if (hPalette) {
SelectPalette(hdc, hPalette, FALSE);
RealizePalette(hdc);
}
lpDIBinfo->bmiHeader.biHeight = ht;
if (MyFileSeek(fh, hdr.bfOffBits, 0) == -1) {
errmsg = IDSBadData;
goto error7;
}
error = FALSE;
for (i = height; i; i -= ht) {
if (i < ht)
lpDIBinfo->bmiHeader.biHeight = ht = i;
if (!MyByteReadFile(fh, lpDIBbits, (DWORD) wSize*ht)) {
errmsg = IDSBadData;
error = TRUE;
break;
}
if(!(hbitmap = SelectObject(hdc, htempbit))) { /* BUGBUGBUG */
errmsg = IDSNoMemAvail;
goto error7;
}
if(!SetDIBits(hdc, hbitmap, 0, ht, lpDIBbits, lpDIBinfo, wUsage)) {
errmsg = IDSNoMemAvail;
error = TRUE;
break;
}
if(!(htempbit = SelectObject(hdc, hbitmap))) { /* BUGBUGBUG */
errmsg = IDSNoMemAvail;
goto error7;
}
if (DlgCaptionNo != PASTEFROM)
BitBlt(hdcWork, 0, i - ht, (WORD) hdrInfo.bmiHeader.biWidth, ht,
hdc, 0, 0, SRCCOPY);
else
BitBlt(pickDC, 0, i - ht, (WORD) hdrInfo.bmiHeader.biWidth, ht,
hdc, 0, 0, SRCCOPY);
}
if (DlgCaptionNo != PASTEFROM) {
BitBlt(hdcImage, 0, 0, LOWORD(hdrInfo.bmiHeader.biWidth),
LOWORD(hdrInfo.bmiHeader.biHeight),
hdcWork, 0, 0, SRCCOPY);
wFileType = GetImageFileType(hdrInfo.bmiHeader.biBitCount);
if (error)
ClearImg();
}
gfDirty = FALSE;
if (!error)
GetCurrentDirectory(PATHlen, filePath);
error7:
if (hdc)
{
if (htempbit)
SelectObject(hdc, htempbit);
DeleteDC(hdc);
}
if (hbitmap)
DeleteObject(hbitmap);
if (lpDIBbits)
GlobalUnlock(hDIBbits);
if (hDIBbits)
GlobalFree(hDIBbits);
error5:
if (lpDIBinfo)
GlobalUnlock(hDIBinfo);
error4:
if (hDIBinfo)
GlobalFree(hDIBinfo);
error3:
if (error && DlgCaptionNo == PASTEFROM)
FreePick();
if (parentdc)
ReleaseDC(hWnd, parentdc);
SetCursor(oldCsr);
error2:
MyCloseFile(fh);
error1:
return error ? errmsg : 0;
}