| /* |
| static char RCSId[] = "$Id: resource.c,v 1.4 1993/07/04 04:04:21 root Exp root $"; |
| static char Copyright[] = "Copyright Robert J. Amstadt, 1993"; |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include "arch.h" |
| #include "windows.h" |
| #include "gdi.h" |
| #include "bitmap.h" |
| #include "neexe.h" |
| #include "icon.h" |
| #include "menu.h" |
| #include "accel.h" |
| #include "dlls.h" |
| #include "resource.h" |
| #include "library.h" |
| #include "stddebug.h" |
| #include "debug.h" |
| #include "../rc/sysresbm.h" |
| |
| #define MIN(a,b) ((a) < (b) ? (a) : (b)) |
| |
| RESOURCE *Top = NULL; |
| |
| extern int NE_FindResource(HANDLE, LPSTR, LPSTR, RESOURCE *); |
| extern int PE_FindResource(HANDLE, LPSTR, LPSTR, RESOURCE *); |
| extern HBITMAP OBM_LoadOEMBitmap( WORD id ); /* objects/oembitmap.c */ |
| |
| #define PrintId(name) \ |
| if (HIWORD((DWORD)name)) \ |
| printf(", %s", name); \ |
| else \ |
| printf(", #%d", (int) name); |
| |
| /********************************************************************** |
| * FindResource [KERNEL.60] |
| */ |
| HANDLE FindResource(HANDLE instance, LPSTR name, LPSTR type) |
| { |
| int status; |
| RESOURCE *r; |
| HANDLE rh; |
| |
| if(debugging_resource){ |
| printf("FindResource(%04X", instance); |
| PrintId(name); |
| PrintId(type); |
| printf(")\n"); |
| } |
| |
| if (instance == (HANDLE)NULL) |
| instance = hSysRes; |
| |
| /* FIXME: did we already find this one ? */ |
| |
| if ((rh = GlobalAlloc(GMEM_MOVEABLE, sizeof(RESOURCE))) == 0) |
| return 0; |
| |
| r = (RESOURCE *)GlobalLock(rh); |
| r->next = Top; |
| Top = r; |
| r->info_mem = rh; |
| r->rsc_mem = 0; |
| r->count = 0; |
| if (HIWORD((DWORD)name)) |
| r->name = strdup(name); |
| else |
| r->name = name; |
| |
| if (HIWORD((DWORD)type)) |
| r->type = strdup(type); |
| else |
| r->type = type; |
| |
| r->wpnt = GetFileInfo(instance); |
| r->fd = dup(r->wpnt->fd); |
| if (r->wpnt->ne) |
| status = NE_FindResource(instance, name, type, r); |
| else |
| status = PE_FindResource(instance, name, type, r); |
| |
| if (!status) { |
| if (HIWORD((DWORD)r->name)) |
| free(r->name); |
| |
| if (HIWORD((DWORD)r->type)) |
| free(r->type); |
| close(r->fd); |
| |
| Top = r->next; |
| GlobalUnlock(rh); |
| return 0; |
| } else |
| return rh; |
| } |
| |
| /********************************************************************** |
| * AllocResource [KERNEL.66] |
| */ |
| HANDLE AllocResource(HANDLE instance, HANDLE hResInfo, DWORD dwSize) |
| { |
| RESOURCE *r; |
| int image_size; |
| |
| dprintf_resource(stddeb, "AllocResource(%04X, %04X, %08X);\n", |
| instance, hResInfo, (int) dwSize); |
| |
| if (instance == (HANDLE)NULL) |
| instance = hSysRes; |
| |
| if ((r = (RESOURCE *)GlobalLock(hResInfo)) == NULL) |
| return 0; |
| |
| image_size = r->size; |
| |
| if (dwSize == 0) |
| r->rsc_mem = GlobalAlloc(GMEM_MOVEABLE, image_size); |
| else |
| r->rsc_mem = GlobalAlloc(GMEM_MOVEABLE, dwSize); |
| |
| GlobalUnlock(hResInfo); |
| |
| return r->rsc_mem; |
| } |
| |
| /********************************************************************** |
| * AccessResource [KERNEL.64] |
| */ |
| int AccessResource(HANDLE instance, HANDLE hResInfo) |
| { |
| int fd; |
| RESOURCE *r; |
| |
| dprintf_resource(stddeb, "AccessResource(%04X, %04X);\n", |
| instance, hResInfo); |
| |
| if (instance == (HANDLE)NULL) |
| instance = hSysRes; |
| |
| if ((r = (RESOURCE *)GlobalLock(hResInfo)) == NULL) |
| return -1; |
| |
| fd = r->fd; |
| lseek(fd, r->offset, SEEK_SET); |
| GlobalUnlock(hResInfo); |
| |
| return fd; |
| } |
| |
| /********************************************************************** |
| * SizeofResource [KERNEL.65] |
| */ |
| WORD SizeofResource(HANDLE instance, HANDLE hResInfo) |
| { |
| RESOURCE *r; |
| int size; |
| |
| dprintf_resource(stddeb, "SizeofResource(%04X, %04X);\n", |
| instance, hResInfo); |
| |
| if (instance == (HANDLE)NULL) |
| instance = hSysRes; |
| |
| if ((r = (RESOURCE *)GlobalLock(hResInfo)) == NULL) |
| return 0; |
| |
| size = r->size; |
| GlobalUnlock(hResInfo); |
| |
| return size; |
| } |
| |
| /********************************************************************** |
| * LoadResource [KERNEL.61] |
| */ |
| HANDLE LoadResource(HANDLE instance, HANDLE hResInfo) |
| { |
| RESOURCE *r; |
| int image_size, fd; |
| void *image; |
| HANDLE h; |
| |
| dprintf_resource(stddeb, "LoadResource(%04X, %04X);\n", instance, hResInfo); |
| |
| if (instance == (HANDLE)NULL) |
| instance = hSysRes; |
| |
| if ((r = (RESOURCE *)GlobalLock(hResInfo)) == NULL) |
| return 0; |
| |
| h = r->rsc_mem = AllocResource(instance, hResInfo, 0); |
| image = GlobalLinearLock(h); |
| image_size = r->size; |
| fd = AccessResource(instance, hResInfo); |
| |
| if (image == NULL || read(fd, image, image_size) != image_size) { |
| GlobalFree(h); |
| GlobalUnlock(hResInfo); |
| return 0; |
| } |
| r->count++; |
| close(fd); |
| GlobalLinearUnlock(h); |
| GlobalUnlock(hResInfo); |
| return h; |
| } |
| |
| /********************************************************************** |
| * LockResource [KERNEL.62] |
| */ |
| LPSTR LockResource(HANDLE hResData) |
| { |
| return GlobalLock(hResData); |
| } |
| |
| /********************************************************************** |
| * FreeResource [KERNEL.63] |
| */ |
| HANDLE FreeResource(HANDLE hResData) |
| { |
| RESOURCE *r, *rp; |
| |
| dprintf_resource(stddeb, "FreeResource: handle %04x\n", hResData); |
| |
| for (r = rp = Top; r ; r = r->next) { |
| if (r->rsc_mem == hResData) { |
| if (r->count == 0) { |
| if (rp != r) |
| rp->next = r->next; |
| else |
| Top = r->next; |
| |
| if (HIWORD((DWORD)r->name)) |
| free(r->name); |
| if (HIWORD((DWORD)r->type)) |
| free(r->type); |
| GlobalFree(r->rsc_mem); |
| GlobalFree(r->info_mem); |
| return 0; |
| } else |
| r->count--; |
| } |
| rp = r; |
| } |
| return hResData; |
| } |
| |
| /********************************************************************** |
| * ConvertCoreBitmap |
| */ |
| HBITMAP ConvertCoreBitmap( HDC hdc, BITMAPCOREHEADER * image ) |
| { |
| BITMAPINFO * bmpInfo; |
| HBITMAP hbitmap; |
| char * bits; |
| int i, size, n_colors; |
| |
| n_colors = 1 << image->bcBitCount; |
| if (image->bcBitCount < 24) |
| { |
| size = sizeof(BITMAPINFOHEADER) + n_colors * sizeof(RGBQUAD); |
| bits = (char *) (image + 1) + (n_colors * sizeof(RGBTRIPLE)); |
| } |
| else |
| { |
| size = sizeof(BITMAPINFOHEADER); |
| bits = (char *) (image + 1); |
| } |
| bmpInfo = (BITMAPINFO *) malloc( size ); |
| |
| bmpInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); |
| bmpInfo->bmiHeader.biWidth = image->bcWidth; |
| bmpInfo->bmiHeader.biHeight = image->bcHeight; |
| bmpInfo->bmiHeader.biPlanes = image->bcPlanes; |
| bmpInfo->bmiHeader.biBitCount = image->bcBitCount; |
| bmpInfo->bmiHeader.biCompression = 0; |
| bmpInfo->bmiHeader.biSizeImage = 0; |
| bmpInfo->bmiHeader.biXPelsPerMeter = 0; |
| bmpInfo->bmiHeader.biYPelsPerMeter = 0; |
| bmpInfo->bmiHeader.biClrUsed = 0; |
| bmpInfo->bmiHeader.biClrImportant = 0; |
| |
| if (image->bcBitCount < 24) |
| { |
| RGBTRIPLE * oldMap = (RGBTRIPLE *)(image + 1); |
| RGBQUAD * newMap = bmpInfo->bmiColors; |
| for (i = 0; i < n_colors; i++, oldMap++, newMap++) |
| { |
| newMap->rgbRed = oldMap->rgbtRed; |
| newMap->rgbGreen = oldMap->rgbtGreen; |
| newMap->rgbBlue = oldMap->rgbtBlue; |
| newMap->rgbReserved = 0; |
| } |
| } |
| |
| hbitmap = CreateDIBitmap( hdc, &bmpInfo->bmiHeader, CBM_INIT, |
| bits, bmpInfo, DIB_RGB_COLORS ); |
| free( bmpInfo ); |
| return hbitmap; |
| } |
| |
| /********************************************************************** |
| * ConvertInfoBitmap |
| */ |
| HBITMAP ConvertInfoBitmap( HDC hdc, BITMAPINFO * image ) |
| { |
| char * bits = ((char *)image) + DIB_BitmapInfoSize(image, DIB_RGB_COLORS); |
| return CreateDIBitmap( hdc, &image->bmiHeader, CBM_INIT, |
| bits, image, DIB_RGB_COLORS ); |
| } |
| |
| /********************************************************************** |
| * RSC_LoadResource |
| */ |
| HANDLE |
| RSC_LoadResource(int instance, LPSTR rsc_name, LPSTR type, int *image_size_ret) |
| { |
| HANDLE hResInfo; |
| RESOURCE *r; |
| |
| if (instance == (HANDLE)NULL) |
| instance = hSysRes; |
| |
| dprintf_resource(stddeb, "RSC_LoadResource: instance = %04x, name = %08x, type = %08x\n", |
| instance, (int) rsc_name, (int) type); |
| |
| if ((hResInfo = FindResource(instance, rsc_name, (LPSTR) type)) == (HANDLE) NULL) { |
| return (HANDLE)NULL; |
| } |
| r = (RESOURCE *)GlobalLock(hResInfo); |
| if (image_size_ret) |
| *image_size_ret = r->size; |
| r->count++; |
| GlobalUnlock(hResInfo); |
| return LoadResource(instance, hResInfo); |
| } |
| |
| /********************************************************************** |
| * LoadIcon [USER.174] |
| */ |
| HICON LoadIcon(HANDLE instance, LPSTR icon_name) |
| { |
| HICON hIcon; |
| HANDLE rsc_mem; |
| WORD *lp; |
| ICONDESCRIP *lpicodesc; |
| ICONALLOC *lpico; |
| int width, height; |
| BITMAPINFO *bmi; |
| BITMAPINFOHEADER *bih; |
| RGBQUAD *rgbq; |
| HDC hdc; |
| int image_size; |
| |
| if(debugging_resource){ |
| printf("LoadIcon(%04X", instance); |
| PrintId(icon_name); |
| printf(")\n"); |
| } |
| |
| if (!(hdc = GetDC(GetDesktopWindow()))) return 0; |
| rsc_mem = RSC_LoadResource(instance, icon_name, (LPSTR) NE_RSCTYPE_GROUP_ICON, |
| &image_size); |
| if (rsc_mem == (HANDLE)NULL) { |
| printf("LoadIcon / Icon %04X not Found !\n", (int) icon_name); |
| ReleaseDC(GetDesktopWindow(), hdc); |
| return 0; |
| } |
| lp = (WORD *)GlobalLock(rsc_mem); |
| if (lp == NULL) { |
| GlobalFree(rsc_mem); |
| ReleaseDC(GetDesktopWindow(), hdc); |
| return 0; |
| } |
| lpicodesc = (ICONDESCRIP *)(lp + 3); |
| hIcon = GlobalAlloc(GMEM_MOVEABLE, sizeof(ICONALLOC) + 1024); |
| if (hIcon == (HICON)NULL) { |
| GlobalFree(rsc_mem); |
| ReleaseDC(GetDesktopWindow(), hdc); |
| return 0; |
| } |
| lpico = (ICONALLOC *)GlobalLock(hIcon); |
| lpico->descriptor = *lpicodesc; |
| width = lpicodesc->Width; |
| height = lpicodesc->Height; |
| GlobalUnlock(rsc_mem); |
| GlobalFree(rsc_mem); |
| rsc_mem = RSC_LoadResource(instance, |
| MAKEINTRESOURCE(lpicodesc->icoDIBOffset), |
| (LPSTR) NE_RSCTYPE_ICON, &image_size); |
| if (rsc_mem == (HANDLE)NULL) { |
| printf("LoadIcon / Icon %04X Bitmaps not Found !\n", (int) icon_name); |
| ReleaseDC(GetDesktopWindow(), hdc); |
| return 0; |
| } |
| lp = (WORD *)GlobalLock(rsc_mem); |
| if (lp == NULL) { |
| GlobalFree(rsc_mem); |
| ReleaseDC(GetDesktopWindow(), hdc); |
| return 0; |
| } |
| bmi = (BITMAPINFO *)lp; |
| bih = (BITMAPINFOHEADER *)lp; |
| rgbq = &bmi->bmiColors[0]; |
| bih->biHeight = bih->biHeight / 2; |
| /* |
| printf("LoadIcon / image_size=%d width=%d height=%d bih->biBitCount=%d bih->biSizeImage=%ld\n", |
| image_size, width, height, bih->biBitCount, bih->biSizeImage); |
| */ |
| if (bih->biSize == sizeof(BITMAPINFOHEADER)) |
| lpico->hBitmap = ConvertInfoBitmap(hdc, (BITMAPINFO *)bih); |
| else |
| lpico->hBitmap = 0; |
| bih->biBitCount = 1; |
| bih->biClrUsed = bih->biClrImportant = 2; |
| rgbq[0].rgbBlue = rgbq[0].rgbGreen = rgbq[0].rgbRed = 0x00; |
| rgbq[1].rgbBlue = rgbq[1].rgbGreen = rgbq[1].rgbRed = 0xff; |
| rgbq[0].rgbReserved = rgbq[1].rgbReserved = 0; |
| if (bih->biSizeImage == 0) { |
| if (bih->biCompression != BI_RGB) { |
| fprintf(stderr,"Unknown size for compressed Icon bitmap.\n"); |
| GlobalFree(rsc_mem); |
| ReleaseDC(GetDesktopWindow(), hdc); |
| return 0; |
| } |
| bih->biSizeImage = (bih->biWidth * bih->biHeight * bih->biBitCount |
| + 7) / 8; |
| } |
| lpico->hBitMask = CreateDIBitmap(hdc, bih, CBM_INIT, |
| (LPSTR)lp + bih->biSizeImage - sizeof(BITMAPINFOHEADER) / 2 - 4, |
| (BITMAPINFO *)bih, DIB_RGB_COLORS ); |
| GlobalUnlock(rsc_mem); |
| GlobalFree(rsc_mem); |
| ReleaseDC(GetDesktopWindow(), hdc); |
| GlobalUnlock(hIcon); |
| dprintf_resource(stddeb,"LoadIcon Alloc hIcon=%X\n", hIcon); |
| return hIcon; |
| } |
| |
| /********************************************************************** |
| * CreateIcon [USER.407] |
| */ |
| HICON CreateIcon(HANDLE hInstance, int nWidth, int nHeight, |
| BYTE nPlanes, BYTE nBitsPixel, LPSTR lpANDbits, |
| LPSTR lpXORbits) |
| { |
| HICON hIcon; |
| ICONALLOC *lpico; |
| |
| dprintf_resource(stddeb, "CreateIcon: hInstance = %04x, nWidth = %08x, nHeight = %08x \n", |
| hInstance, nWidth, nHeight); |
| dprintf_resource(stddeb, " nPlanes = %04x, nBitsPixel = %04x,",nPlanes, nBitsPixel); |
| dprintf_resource(stddeb, " lpANDbits= %04x, lpXORbits = %04x, \n", (int)lpANDbits, |
| (int)lpXORbits); |
| |
| if (hInstance == (HANDLE)NULL) { |
| printf("CreateIcon / hInstance %04x not Found!\n",hInstance); |
| return 0; |
| } |
| hIcon = GlobalAlloc(GMEM_MOVEABLE, sizeof(ICONALLOC) + 1024); |
| if (hIcon == (HICON)NULL) { |
| printf("Can't allocate memory for Icon in CreateIcon\n"); |
| return 0; |
| } |
| lpico= (ICONALLOC *)GlobalLock(hIcon); |
| |
| lpico->descriptor.Width=nWidth; |
| lpico->descriptor.Height=nHeight; |
| lpico->descriptor.ColorCount=16; /* Dummy Value */ |
| lpico->descriptor.Reserved1=0; |
| lpico->descriptor.Reserved2=nPlanes; |
| lpico->descriptor.Reserved3=nWidth*nHeight; |
| |
| /* either nPlanes and/or nBitCount is set to one */ |
| lpico->descriptor.icoDIBSize=nWidth*nHeight*nPlanes*nBitsPixel; |
| lpico->descriptor.icoDIBOffset=0; |
| |
| if( !(lpico->hBitmap=CreateBitmap(nWidth, nHeight, nPlanes, nBitsPixel, |
| lpXORbits)) ) { |
| printf("CreateIcon: couldn't create the XOR bitmap\n"); |
| return(0); |
| } |
| |
| /* the AND BitMask is always monochrome */ |
| if( !(lpico->hBitMask=CreateBitmap(nWidth, nHeight, 1, 1, lpANDbits)) ) { |
| printf("CreateIcon: couldn't create the AND bitmap\n"); |
| return(0); |
| } |
| |
| GlobalUnlock(hIcon); |
| dprintf_resource(stddeb, "CreateIcon Alloc hIcon=%X\n", hIcon); |
| return hIcon; |
| } |
| |
| /********************************************************************** |
| * DestroyIcon [USER.457] |
| */ |
| BOOL DestroyIcon(HICON hIcon) |
| { |
| ICONALLOC *lpico; |
| |
| if (hIcon == (HICON)NULL) |
| return FALSE; |
| lpico = (ICONALLOC *)GlobalLock(hIcon); |
| if (lpico->hBitmap != (HBITMAP)NULL) |
| DeleteObject(lpico->hBitmap); |
| GlobalFree(hIcon); |
| return TRUE; |
| } |
| |
| /********************************************************************** |
| * LoadAccelerators [USER.177] |
| */ |
| HANDLE LoadAccelerators(HANDLE instance, LPSTR lpTableName) |
| { |
| HANDLE hAccel; |
| HANDLE rsc_mem; |
| BYTE *lp; |
| ACCELHEADER *lpAccelTbl; |
| int i, image_size, n; |
| |
| if(debugging_accel){ |
| printf("LoadAccelerators(%04X", instance); |
| PrintId(lpTableName); |
| printf(")\n"); |
| } |
| |
| rsc_mem = RSC_LoadResource(instance, lpTableName, (LPSTR) NE_RSCTYPE_ACCELERATOR, |
| &image_size); |
| if (rsc_mem == (HANDLE)NULL) { |
| printf("LoadAccelerators(%04X", instance); |
| PrintId(lpTableName); |
| printf(") not found !\n"); |
| return 0; |
| } |
| lp = (BYTE *)GlobalLock(rsc_mem); |
| if (lp == NULL) { |
| GlobalFree(rsc_mem); |
| return 0; |
| } |
| dprintf_accel(stddeb,"LoadAccelerators / image_size=%d\n", image_size); |
| n = image_size/5; |
| hAccel = GlobalAlloc(GMEM_MOVEABLE, |
| sizeof(ACCELHEADER) + (n + 1)*sizeof(ACCELENTRY)); |
| lpAccelTbl = (LPACCELHEADER)GlobalLock(hAccel); |
| lpAccelTbl->wCount = 0; |
| for (i = 0; i < n; i++) { |
| lpAccelTbl->tbl[i].type = *(lp++); |
| lpAccelTbl->tbl[i].wEvent = *((WORD *)lp); |
| lp += 2; |
| lpAccelTbl->tbl[i].wIDval = *((WORD *)lp); |
| lp += 2; |
| if (lpAccelTbl->tbl[i].wEvent == 0) break; |
| dprintf_accel(stddeb, |
| "Accelerator #%u / event=%04X id=%04X type=%02X \n", |
| i, lpAccelTbl->tbl[i].wEvent, lpAccelTbl->tbl[i].wIDval, |
| lpAccelTbl->tbl[i].type); |
| lpAccelTbl->wCount++; |
| } |
| GlobalUnlock(hAccel); |
| GlobalUnlock(rsc_mem); |
| GlobalFree(rsc_mem); |
| return hAccel; |
| } |
| |
| /********************************************************************** |
| * TranslateAccelerator [USER.178] |
| */ |
| int TranslateAccelerator(HWND hWnd, HANDLE hAccel, LPMSG msg) |
| { |
| ACCELHEADER *lpAccelTbl; |
| int i; |
| |
| if (hAccel == 0 || msg == NULL) return 0; |
| if (msg->message != WM_KEYDOWN && |
| msg->message != WM_KEYUP && |
| msg->message != WM_CHAR) return 0; |
| |
| dprintf_accel(stddeb, "TranslateAccelerators hAccel=%04X !\n", hAccel); |
| |
| lpAccelTbl = (LPACCELHEADER)GlobalLock(hAccel); |
| for (i = 0; i < lpAccelTbl->wCount; i++) { |
| if (lpAccelTbl->tbl[i].type & VIRTKEY_ACCEL) { |
| if (msg->wParam == lpAccelTbl->tbl[i].wEvent && |
| msg->message == WM_KEYDOWN) { |
| if ((lpAccelTbl->tbl[i].type & SHIFT_ACCEL) && |
| !(GetKeyState(VK_SHIFT) & 0xf)) { |
| GlobalUnlock(hAccel); |
| return 0; |
| } |
| if ((lpAccelTbl->tbl[i].type & CONTROL_ACCEL) && |
| !(GetKeyState(VK_CONTROL) & 0xf)) { |
| GlobalUnlock(hAccel); |
| return 0; |
| } |
| if ((lpAccelTbl->tbl[i].type & ALT_ACCEL) && |
| !(GetKeyState(VK_MENU) & 0xf)) { |
| GlobalUnlock(hAccel); |
| return 0; |
| } |
| SendMessage(hWnd, WM_COMMAND, lpAccelTbl->tbl[i].wIDval, 0x00010000L); |
| GlobalUnlock(hAccel); |
| return 1; |
| } |
| if (msg->message == WM_KEYUP) return 1; |
| } |
| else { |
| if (msg->wParam == lpAccelTbl->tbl[i].wEvent && |
| msg->message == WM_CHAR) { |
| SendMessage(hWnd, WM_COMMAND, lpAccelTbl->tbl[i].wIDval, 0x00010000L); |
| GlobalUnlock(hAccel); |
| return 1; |
| } |
| } |
| } |
| GlobalUnlock(hAccel); |
| return 0; |
| } |
| |
| /********************************************************************** |
| * LoadString |
| */ |
| int |
| LoadString(HANDLE instance, WORD resource_id, LPSTR buffer, int buflen) |
| { |
| HANDLE hmem; |
| int rsc_size; |
| unsigned char *p; |
| int string_num; |
| int i; |
| |
| dprintf_resource(stddeb, "LoadString: instance = %04x, id = %d, buffer = %08x, " |
| "length = %d\n", instance, resource_id, (int) buffer, buflen); |
| |
| hmem = RSC_LoadResource(instance, (char *) ((resource_id >> 4) + 1), |
| (LPSTR) NE_RSCTYPE_STRING, &rsc_size); |
| if (hmem == 0) |
| return 0; |
| |
| p = GlobalLock(hmem); |
| string_num = resource_id & 0x000f; |
| for (i = 0; i < string_num; i++) |
| p += *p + 1; |
| |
| i = MIN(buflen - 1, *p); |
| if (i > 0) { |
| memcpy(buffer, p + 1, i); |
| buffer[i] = '\0'; |
| } |
| else { |
| if (buflen > 1) { |
| buffer[0] = '\0'; |
| return 0; |
| } |
| fprintf(stderr,"LoadString // I dont know why , but caller give buflen=%d *p=%d !\n", buflen, *p); |
| fprintf(stderr,"LoadString // and try to obtain string '%s'\n", p + 1); |
| } |
| GlobalFree(hmem); |
| |
| dprintf_resource(stddeb,"LoadString // '%s' copied !\n", buffer); |
| return i; |
| } |
| |
| /********************************************************************** |
| * LoadMenu [USER.150] |
| */ |
| HMENU LoadMenu(HINSTANCE instance, char *menu_name) |
| { |
| HMENU hMenu; |
| HANDLE hMenu_desc; |
| MENU_HEADER *menu_desc; |
| |
| if(debugging_menu){ |
| printf("LoadMenu(%04X", instance); |
| PrintId(menu_name); |
| printf(")\n"); |
| } |
| if (menu_name == NULL) |
| return 0; |
| |
| if ((hMenu_desc = RSC_LoadResource(instance, menu_name, (LPSTR) NE_RSCTYPE_MENU, NULL)) == (HANDLE) NULL) |
| return 0; |
| |
| menu_desc = (MENU_HEADER *) GlobalLock(hMenu_desc); |
| hMenu = LoadMenuIndirect((LPSTR)menu_desc); |
| return hMenu; |
| } |
| |
| /********************************************************************** |
| * LoadBitmap |
| */ |
| HBITMAP |
| LoadBitmap(HANDLE instance, LPSTR bmp_name) |
| { |
| HBITMAP hbitmap; |
| HANDLE rsc_mem; |
| HDC hdc; |
| long *lp; |
| int image_size; |
| int size; |
| |
| if(debugging_resource){ |
| printf("LoadBitmap(%04X", instance); |
| PrintId(bmp_name); |
| printf(")\n"); |
| } |
| |
| if (!instance) { |
| struct ResourceTable *it; |
| hbitmap = OBM_LoadOEMBitmap(((int) bmp_name) & 0xffff); |
| if (hbitmap) |
| return hbitmap; |
| /* Load from sysresbm */ |
| dprintf_resource(stddeb,"Searching for %d\n", (int) bmp_name); |
| for(it=sysresbmTable;it->value;it++){ |
| if(it->type==NE_RSCTYPE_BITMAP) |
| if((((int)bmp_name & 0xFFFF0000) == 0)) |
| {if(it->id==(int)bmp_name)break;} |
| else if(!strcmp(it->name,bmp_name))break; |
| } |
| if(!it->value)return 0; |
| dprintf_resource(stddeb,"Found %s\n",it->name); |
| lp=(long *)it->value; |
| rsc_mem=(HANDLE)NULL; |
| } else { /* Load from file - indent this code properly later */ |
| |
| rsc_mem = RSC_LoadResource(instance, bmp_name, (LPSTR) NE_RSCTYPE_BITMAP, |
| &image_size); |
| if (rsc_mem == (HANDLE)NULL) { |
| printf("LoadBitmap(%04X", instance); |
| PrintId(bmp_name); |
| printf(") NOT found!\n"); |
| return 0; |
| } |
| lp = (long *) GlobalLinearLock(rsc_mem); |
| if (lp == NULL) |
| { |
| GlobalFree(rsc_mem); |
| return 0; |
| } |
| } /* Load from file */ |
| if (!(hdc = GetDC(0))) lp = NULL; |
| size = CONV_LONG (*lp); |
| if (size == sizeof(BITMAPCOREHEADER)){ |
| CONV_BITMAPCOREHEADER (lp); |
| hbitmap = ConvertCoreBitmap( hdc, (BITMAPCOREHEADER *) lp ); |
| } else if (size == sizeof(BITMAPINFOHEADER)){ |
| CONV_BITMAPINFO (lp); |
| hbitmap = ConvertInfoBitmap( hdc, (BITMAPINFO *) lp ); |
| } else hbitmap = 0; |
| GlobalFree(rsc_mem); |
| ReleaseDC( 0, hdc ); |
| return hbitmap; |
| } |