| /* |
| * 16-bit resource functions |
| * |
| * Copyright 1993 Robert J. Amstadt |
| * Copyright 1997 Alex Korobka |
| * Copyright 1998 Ulrich Weigand |
| * Copyright 1995, 2003 Alexandre Julliard |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/types.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wownt32.h" |
| #include "wine/winbase16.h" |
| #include "wine/winuser16.h" |
| #include "wine/unicode.h" |
| #include "kernel16_private.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(resource); |
| |
| /* handle conversions */ |
| #define HRSRC_32(h16) ((HRSRC)(ULONG_PTR)(h16)) |
| #define HGLOBAL_32(h16) ((HGLOBAL)(ULONG_PTR)(h16)) |
| |
| static inline NE_MODULE *get_module( HMODULE16 mod ) |
| { |
| if (!mod) mod = TASK_GetCurrent()->hModule; |
| return NE_GetPtr( mod ); |
| } |
| |
| #define HRSRC_MAP_BLOCKSIZE 16 |
| |
| typedef struct _HRSRC_ELEM |
| { |
| HRSRC hRsrc; |
| WORD type; |
| } HRSRC_ELEM; |
| |
| typedef struct _HRSRC_MAP |
| { |
| int nAlloc; |
| int nUsed; |
| HRSRC_ELEM *elem; |
| } HRSRC_MAP; |
| |
| |
| /********************************************************************** |
| * MapHRsrc32To16 |
| */ |
| static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HRSRC hRsrc32, WORD type ) |
| { |
| HRSRC_MAP *map = pModule->rsrc32_map; |
| HRSRC_ELEM *newElem; |
| int i; |
| |
| /* On first call, initialize HRSRC map */ |
| if ( !map ) |
| { |
| if ( !(map = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HRSRC_MAP) ) ) ) |
| { |
| ERR("Cannot allocate HRSRC map\n" ); |
| return 0; |
| } |
| pModule->rsrc32_map = map; |
| } |
| |
| /* Check whether HRSRC32 already in map */ |
| for ( i = 0; i < map->nUsed; i++ ) |
| if ( map->elem[i].hRsrc == hRsrc32 ) |
| return (HRSRC16)(i + 1); |
| |
| /* If no space left, grow table */ |
| if ( map->nUsed == map->nAlloc ) |
| { |
| |
| if (map->elem) |
| newElem = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, |
| map->elem, (map->nAlloc + HRSRC_MAP_BLOCKSIZE) * sizeof(HRSRC_ELEM) ); |
| else |
| newElem = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, |
| (map->nAlloc + HRSRC_MAP_BLOCKSIZE) * sizeof(HRSRC_ELEM) ); |
| |
| if ( !newElem ) |
| { |
| ERR("Cannot grow HRSRC map\n" ); |
| return 0; |
| } |
| map->elem = newElem; |
| map->nAlloc += HRSRC_MAP_BLOCKSIZE; |
| } |
| |
| /* Add HRSRC32 to table */ |
| map->elem[map->nUsed].hRsrc = hRsrc32; |
| map->elem[map->nUsed].type = type; |
| map->nUsed++; |
| |
| return (HRSRC16)map->nUsed; |
| } |
| |
| /********************************************************************** |
| * MapHRsrc16To32 |
| */ |
| static HRSRC MapHRsrc16To32( NE_MODULE *pModule, HRSRC16 hRsrc16 ) |
| { |
| HRSRC_MAP *map = pModule->rsrc32_map; |
| if ( !map || !hRsrc16 || hRsrc16 > map->nUsed ) return 0; |
| |
| return map->elem[hRsrc16-1].hRsrc; |
| } |
| |
| /********************************************************************** |
| * MapHRsrc16ToType |
| */ |
| static WORD MapHRsrc16ToType( NE_MODULE *pModule, HRSRC16 hRsrc16 ) |
| { |
| HRSRC_MAP *map = pModule->rsrc32_map; |
| if ( !map || !hRsrc16 || hRsrc16 > map->nUsed ) return 0; |
| |
| return map->elem[hRsrc16-1].type; |
| } |
| |
| |
| /********************************************************************** |
| * get_res_name |
| * |
| * Convert a resource name from '#xxx' form to numerical id. |
| */ |
| static inline LPCSTR get_res_name( LPCSTR name ) |
| { |
| if (HIWORD(name) && name[0] == '#') name = MAKEINTRESOURCEA( atoi( name + 1 ) ); |
| return name; |
| } |
| |
| |
| /********************************************************************** |
| * next_typeinfo |
| */ |
| static inline NE_TYPEINFO *next_typeinfo( NE_TYPEINFO *info ) |
| { |
| return (NE_TYPEINFO *)((char*)(info + 1) + info->count * sizeof(NE_NAMEINFO)); |
| } |
| |
| |
| /********************************************************************** |
| * get_default_res_handler |
| */ |
| static inline FARPROC16 get_default_res_handler(void) |
| { |
| static FARPROC16 handler; |
| |
| if (!handler) handler = GetProcAddress16( GetModuleHandle16("KERNEL"), "DefResourceHandler" ); |
| return handler; |
| } |
| |
| |
| /*********************************************************************** |
| * NE_FindNameTableId |
| * |
| * Find the type and resource id from their names. |
| * Return value is MAKELONG( typeId, resId ), or 0 if not found. |
| */ |
| static DWORD NE_FindNameTableId( NE_MODULE *pModule, LPCSTR typeId, LPCSTR resId ) |
| { |
| NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2); |
| NE_NAMEINFO *pNameInfo; |
| HGLOBAL16 handle; |
| WORD *p; |
| DWORD ret = 0; |
| int count; |
| |
| for (; pTypeInfo->type_id != 0; |
| pTypeInfo = (NE_TYPEINFO *)((char*)(pTypeInfo+1) + |
| pTypeInfo->count * sizeof(NE_NAMEINFO))) |
| { |
| if (pTypeInfo->type_id != 0x800f) continue; |
| pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1); |
| for (count = pTypeInfo->count; count > 0; count--, pNameInfo++) |
| { |
| TRACE("NameTable entry: type=%04x id=%04x\n", |
| pTypeInfo->type_id, pNameInfo->id ); |
| handle = LoadResource16( pModule->self, |
| (HRSRC16)((char *)pNameInfo - (char *)pModule) ); |
| for(p = (WORD*)LockResource16(handle); p && *p; p = (WORD *)((char*)p+*p)) |
| { |
| TRACE(" type=%04x '%s' id=%04x '%s'\n", |
| p[1], (char *)(p+3), p[2], |
| (char *)(p+3)+strlen((char *)(p+3))+1 ); |
| /* Check for correct type */ |
| |
| if (p[1] & 0x8000) |
| { |
| if (!HIWORD(typeId)) continue; |
| if (strcasecmp( typeId, (char *)(p + 3) )) continue; |
| } |
| else if (HIWORD(typeId) || (((DWORD)typeId & ~0x8000)!= p[1])) |
| continue; |
| |
| /* Now check for the id */ |
| |
| if (p[2] & 0x8000) |
| { |
| if (!HIWORD(resId)) continue; |
| if (strcasecmp( resId, (char*)(p+3)+strlen((char*)(p+3))+1 )) continue; |
| |
| } |
| else if (HIWORD(resId) || ((LOWORD(resId) & ~0x8000) != p[2])) |
| continue; |
| |
| /* If we get here, we've found the entry */ |
| |
| TRACE(" Found!\n" ); |
| ret = MAKELONG( p[1], p[2] ); |
| break; |
| } |
| FreeResource16( handle ); |
| if (ret) return ret; |
| } |
| } |
| return 0; |
| } |
| |
| |
| /*********************************************************************** |
| * NE_FindTypeSection |
| * |
| * Find header struct for a particular resource type. |
| */ |
| static NE_TYPEINFO *NE_FindTypeSection( LPBYTE pResTab, NE_TYPEINFO *pTypeInfo, LPCSTR typeId ) |
| { |
| /* start from pTypeInfo */ |
| |
| if (HIWORD(typeId) != 0) /* Named type */ |
| { |
| LPCSTR str = typeId; |
| BYTE len = strlen( str ); |
| while (pTypeInfo->type_id) |
| { |
| if (!(pTypeInfo->type_id & 0x8000)) |
| { |
| BYTE *p = pResTab + pTypeInfo->type_id; |
| if ((*p == len) && !strncasecmp( (char*)p+1, str, len )) |
| { |
| TRACE(" Found type '%s'\n", str ); |
| return pTypeInfo; |
| } |
| } |
| TRACE(" Skipping type %04x\n", pTypeInfo->type_id ); |
| pTypeInfo = next_typeinfo(pTypeInfo); |
| } |
| } |
| else /* Numeric type id */ |
| { |
| WORD id = LOWORD(typeId) | 0x8000; |
| while (pTypeInfo->type_id) |
| { |
| if (pTypeInfo->type_id == id) |
| { |
| TRACE(" Found type %04x\n", id ); |
| return pTypeInfo; |
| } |
| TRACE(" Skipping type %04x\n", pTypeInfo->type_id ); |
| pTypeInfo = next_typeinfo(pTypeInfo); |
| } |
| } |
| return NULL; |
| } |
| |
| |
| /*********************************************************************** |
| * NE_FindResourceFromType |
| * |
| * Find a resource once the type info structure has been found. |
| */ |
| static NE_NAMEINFO *NE_FindResourceFromType( LPBYTE pResTab, NE_TYPEINFO *pTypeInfo, LPCSTR resId ) |
| { |
| BYTE *p; |
| int count; |
| NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1); |
| |
| if (HIWORD(resId) != 0) /* Named resource */ |
| { |
| LPCSTR str = resId; |
| BYTE len = strlen( str ); |
| for (count = pTypeInfo->count; count > 0; count--, pNameInfo++) |
| { |
| if (pNameInfo->id & 0x8000) continue; |
| p = pResTab + pNameInfo->id; |
| if ((*p == len) && !strncasecmp( (char*)p+1, str, len )) |
| return pNameInfo; |
| } |
| } |
| else /* Numeric resource id */ |
| { |
| WORD id = LOWORD(resId) | 0x8000; |
| for (count = pTypeInfo->count; count > 0; count--, pNameInfo++) |
| if (pNameInfo->id == id) return pNameInfo; |
| } |
| return NULL; |
| } |
| |
| |
| /*********************************************************************** |
| * DefResourceHandler (KERNEL.456) |
| * |
| * This is the default LoadProc() function. |
| */ |
| HGLOBAL16 WINAPI NE_DefResourceHandler( HGLOBAL16 hMemObj, HMODULE16 hModule, |
| HRSRC16 hRsrc ) |
| { |
| HGLOBAL16 handle; |
| WORD sizeShift; |
| NE_NAMEINFO* pNameInfo; |
| NE_MODULE* pModule = NE_GetPtr( hModule ); |
| |
| if (!pModule) return 0; |
| |
| sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab); |
| pNameInfo = (NE_NAMEINFO *)((char *)pModule + hRsrc); |
| |
| if ( hMemObj ) |
| handle = GlobalReAlloc16( hMemObj, pNameInfo->length << sizeShift, 0 ); |
| else |
| handle = AllocResource16( hModule, hRsrc, 0 ); |
| |
| if (handle) |
| { |
| if (!NE_READ_DATA( pModule, GlobalLock16( handle ), |
| (int)pNameInfo->offset << sizeShift, |
| (int)pNameInfo->length << sizeShift )) |
| { |
| GlobalFree16( handle ); |
| handle = 0; |
| } |
| } |
| return handle; |
| } |
| |
| |
| /********************************************************************** |
| * SetResourceHandler (KERNEL.67) |
| */ |
| FARPROC16 WINAPI SetResourceHandler16( HMODULE16 hModule, LPCSTR typeId, FARPROC16 resourceHandler ) |
| { |
| LPBYTE pResTab; |
| NE_TYPEINFO *pTypeInfo; |
| FARPROC16 prevHandler = NULL; |
| NE_MODULE *pModule = NE_GetPtr( hModule ); |
| |
| if (!pModule || !pModule->ne_rsrctab) return NULL; |
| |
| pResTab = (LPBYTE)pModule + pModule->ne_rsrctab; |
| pTypeInfo = (NE_TYPEINFO *)(pResTab + 2); |
| |
| TRACE("module=%04x type=%s\n", hModule, debugstr_a(typeId) ); |
| |
| for (;;) |
| { |
| if (!(pTypeInfo = NE_FindTypeSection( pResTab, pTypeInfo, typeId ))) |
| break; |
| memcpy_unaligned( &prevHandler, &pTypeInfo->resloader, sizeof(FARPROC16) ); |
| memcpy_unaligned( &pTypeInfo->resloader, &resourceHandler, sizeof(FARPROC16) ); |
| pTypeInfo = next_typeinfo(pTypeInfo); |
| } |
| if (!prevHandler) prevHandler = get_default_res_handler(); |
| return prevHandler; |
| } |
| |
| static inline DWORD get_dword(LPCVOID *p) |
| { |
| DWORD ret = *(const DWORD *)*p; |
| *p = (const DWORD *)*p + 1; |
| return ret; |
| } |
| |
| static inline void put_dword(LPVOID *p, DWORD d) |
| { |
| *(DWORD*)*p = d; |
| *p = (DWORD *)*p + 1; |
| } |
| |
| static inline WORD get_word(LPCVOID *p) |
| { |
| WORD ret = *(const WORD *)*p; |
| *p = (const WORD *)*p + 1; |
| return ret; |
| } |
| |
| static inline void put_word(LPVOID *p, WORD w) |
| { |
| *(WORD*)*p = w; |
| *p = (WORD *)*p + 1; |
| } |
| |
| static inline BYTE get_byte(LPCVOID *p) |
| { |
| BYTE ret = *(const BYTE *)*p; |
| *p = (const BYTE *)*p + 1; |
| return ret; |
| } |
| |
| static inline void put_byte(LPVOID *p, BYTE b) |
| { |
| *(BYTE *)*p = b; |
| *p = (BYTE *)*p + 1; |
| } |
| |
| /* convert a resource name */ |
| static void convert_name( LPVOID *dst, LPCVOID *src ) |
| { |
| int len; |
| switch (*(const WORD *)*src) |
| { |
| case 0x0000: |
| get_word( src ); |
| put_byte( dst, 0 ); |
| break; |
| case 0xffff: |
| get_word( src ); |
| put_byte( dst, 0xff ); |
| put_word( dst, get_word(src) ); |
| break; |
| default: |
| len = WideCharToMultiByte( CP_ACP, 0, *src, -1, *dst, 0x7fffffff, NULL,NULL ); |
| *dst = (char *)*dst + len; |
| *src = (LPCWSTR)*src + strlenW( *src ) + 1; |
| break; |
| } |
| } |
| |
| /********************************************************************** |
| * ConvertDialog32To16 (KERNEL.615) |
| */ |
| VOID WINAPI ConvertDialog32To16( LPCVOID dialog32, DWORD size, LPVOID dialog16 ) |
| { |
| WORD nbItems, data, dialogEx; |
| DWORD style; |
| |
| style = get_dword( &dialog32 ); |
| put_dword( &dialog16, style ); |
| dialogEx = (style == 0xffff0001); /* DIALOGEX resource */ |
| if (dialogEx) |
| { |
| put_dword( &dialog16, get_dword( &dialog32 ) ); /* helpID */ |
| put_dword( &dialog16, get_dword( &dialog32 ) ); /* exStyle */ |
| style = get_dword( &dialog32 ); |
| put_dword( &dialog16, style ); /* style */ |
| } |
| else |
| dialog32 = (const DWORD *)dialog32 + 1; /* exStyle ignored in 16-bit standard dialog */ |
| |
| nbItems = get_word( &dialog32 ); |
| put_byte( &dialog16, nbItems ); |
| put_word( &dialog16, get_word( &dialog32 ) ); /* x */ |
| put_word( &dialog16, get_word( &dialog32 ) ); /* y */ |
| put_word( &dialog16, get_word( &dialog32 ) ); /* cx */ |
| put_word( &dialog16, get_word( &dialog32 ) ); /* cy */ |
| |
| /* Transfer menu name */ |
| convert_name( &dialog16, &dialog32 ); |
| |
| /* Transfer class name */ |
| convert_name( &dialog16, &dialog32 ); |
| |
| /* Transfer window caption */ |
| WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL ); |
| dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1; |
| dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1; |
| |
| /* Transfer font info */ |
| if (style & DS_SETFONT) |
| { |
| put_word( &dialog16, get_word( &dialog32 ) ); /* pointSize */ |
| if (dialogEx) |
| { |
| put_word( &dialog16, get_word( &dialog32 ) ); /* weight */ |
| put_word( &dialog16, get_word( &dialog32 ) ); /* italic */ |
| } |
| WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL ); /* faceName */ |
| dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1; |
| dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1; |
| } |
| |
| /* Transfer dialog items */ |
| while (nbItems) |
| { |
| /* align on DWORD boundary (32-bit only) */ |
| dialog32 = (LPCVOID)(((UINT_PTR)dialog32 + 3) & ~3); |
| |
| if (dialogEx) |
| { |
| put_dword( &dialog16, get_dword( &dialog32 ) ); /* helpID */ |
| put_dword( &dialog16, get_dword( &dialog32 ) ); /* exStyle */ |
| put_dword( &dialog16, get_dword( &dialog32 ) ); /* style */ |
| } |
| else |
| { |
| style = get_dword( &dialog32 ); /* save style */ |
| dialog32 = (const DWORD *)dialog32 + 1; /* ignore exStyle */ |
| } |
| |
| put_word( &dialog16, get_word( &dialog32 ) ); /* x */ |
| put_word( &dialog16, get_word( &dialog32 ) ); /* y */ |
| put_word( &dialog16, get_word( &dialog32 ) ); /* cx */ |
| put_word( &dialog16, get_word( &dialog32 ) ); /* cy */ |
| |
| if (dialogEx) |
| put_dword( &dialog16, get_dword( &dialog32 ) ); /* ID */ |
| else |
| { |
| put_word( &dialog16, get_word( &dialog32 ) ); /* ID */ |
| put_dword( &dialog16, style ); /* style from above */ |
| } |
| |
| /* Transfer class name */ |
| switch (*(const WORD *)dialog32) |
| { |
| case 0x0000: |
| get_word( &dialog32 ); |
| put_byte( &dialog16, 0 ); |
| break; |
| case 0xffff: |
| get_word( &dialog32 ); |
| put_byte( &dialog16, get_word( &dialog32 ) ); |
| break; |
| default: |
| WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL ); |
| dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1; |
| dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1; |
| break; |
| } |
| |
| /* Transfer window name */ |
| convert_name( &dialog16, &dialog32 ); |
| |
| /* Transfer data */ |
| data = get_word( &dialog32 ); |
| if (dialogEx) |
| put_word(&dialog16, data); |
| else |
| put_byte(&dialog16,(BYTE)data); |
| |
| if (data) |
| { |
| memcpy( dialog16, dialog32, data ); |
| dialog16 = (BYTE *)dialog16 + data; |
| dialog32 = (const BYTE *)dialog32 + data; |
| } |
| |
| /* Next item */ |
| nbItems--; |
| } |
| } |
| |
| |
| /********************************************************************** |
| * GetDialog32Size (KERNEL.618) |
| */ |
| WORD WINAPI GetDialog32Size16( LPCVOID dialog32 ) |
| { |
| LPCVOID p = dialog32; |
| WORD nbItems, data, dialogEx; |
| DWORD style; |
| |
| style = get_dword(&p); |
| dialogEx = (style == 0xffff0001); /* DIALOGEX resource */ |
| if (dialogEx) |
| { |
| p = (const DWORD *)p + 1; /* helpID */ |
| p = (const DWORD *)p + 1; /* exStyle */ |
| style = get_dword(&p); /* style */ |
| } |
| else |
| p = (const DWORD *)p + 1; /* exStyle */ |
| |
| nbItems = get_word(&p); |
| p = (const DWORD *)p + 1; /* x */ |
| p = (const DWORD *)p + 1; /* y */ |
| p = (const DWORD *)p + 1; /* cx */ |
| p = (const DWORD *)p + 1; /* cy */ |
| |
| /* Skip menu name */ |
| switch (*(const DWORD *)p) |
| { |
| case 0x0000: p = (const DWORD *)p + 1; break; |
| case 0xffff: p = (const DWORD *)p + 2; break; |
| default: p = (LPCWSTR)p + strlenW( p ) + 1; break; |
| } |
| |
| /* Skip class name */ |
| switch (*(const DWORD *)p) |
| { |
| case 0x0000: p = (const DWORD *)p + 1; break; |
| case 0xffff: p = (const DWORD *)p + 2; break; |
| default: p = (LPCWSTR)p + strlenW( p ) + 1; break; |
| } |
| |
| /* Skip window caption */ |
| p = (LPCWSTR)p + strlenW( p ) + 1; |
| |
| /* Skip font info */ |
| if (style & DS_SETFONT) |
| { |
| p = (const DWORD *)p + 1; /* pointSize */ |
| if (dialogEx) |
| { |
| p = (const DWORD *)p + 1; /* weight */ |
| p = (const DWORD *)p + 1; /* italic */ |
| } |
| p = (LPCWSTR)p + strlenW( p ) + 1; /* faceName */ |
| } |
| |
| /* Skip dialog items */ |
| while (nbItems) |
| { |
| /* align on DWORD boundary */ |
| p = (LPCVOID)(((UINT_PTR)p + 3) & ~3); |
| |
| if (dialogEx) |
| { |
| p = (const DWORD *)p + 1; /* helpID */ |
| p = (const DWORD *)p + 1; /* exStyle */ |
| p = (const DWORD *)p + 1; /* style */ |
| } |
| else |
| { |
| p = (const DWORD *)p + 1; /* style */ |
| p = (const DWORD *)p + 1; /* exStyle */ |
| } |
| |
| p = (const DWORD *)p + 1; /* x */ |
| p = (const DWORD *)p + 1; /* y */ |
| p = (const DWORD *)p + 1; /* cx */ |
| p = (const DWORD *)p + 1; /* cy */ |
| |
| if (dialogEx) |
| p = (const DWORD *)p + 1; /* ID */ |
| else |
| p = (const DWORD *)p + 1; /* ID */ |
| |
| /* Skip class name */ |
| switch (*(const DWORD *)p) |
| { |
| case 0x0000: p = (const DWORD *)p + 1; break; |
| case 0xffff: p = (const DWORD *)p + 2; break; |
| default: p = (LPCWSTR)p + strlenW( p ) + 1; break; |
| } |
| |
| /* Skip window name */ |
| switch (*(const DWORD *)p) |
| { |
| case 0x0000: p = (const DWORD *)p + 1; break; |
| case 0xffff: p = (const DWORD *)p + 2; break; |
| default: p = (LPCWSTR)p + strlenW( p ) + 1; break; |
| } |
| |
| /* Skip data */ |
| data = get_word(&p); |
| p = (const BYTE *)p + data; |
| |
| /* Next item */ |
| nbItems--; |
| } |
| |
| return (WORD)((LPCSTR)p - (LPCSTR)dialog32); |
| } |
| |
| |
| /********************************************************************** |
| * ConvertMenu32To16 (KERNEL.616) |
| */ |
| VOID WINAPI ConvertMenu32To16( LPCVOID menu32, DWORD size, LPVOID menu16 ) |
| { |
| WORD version, headersize, flags, level = 1; |
| |
| version = get_word( &menu32 ); |
| headersize = get_word( &menu32 ); |
| put_word( &menu16, version ); |
| put_word( &menu16, headersize ); |
| if ( headersize ) |
| { |
| memcpy( menu16, menu32, headersize ); |
| menu16 = (BYTE *)menu16 + headersize; |
| menu32 = (const BYTE *)menu32 + headersize; |
| } |
| |
| while ( level ) |
| if ( version == 0 ) /* standard */ |
| { |
| flags = get_word( &menu32 ); |
| put_word( &menu16, flags ); |
| if ( !(flags & MF_POPUP) ) |
| put_word( &menu16, get_word( &menu32 ) ); /* ID */ |
| else |
| level++; |
| |
| WideCharToMultiByte( CP_ACP, 0, menu32, -1, menu16, 0x7fffffff, NULL, NULL ); |
| menu16 = (LPSTR)menu16 + strlen( menu16 ) + 1; |
| menu32 = (LPCWSTR)menu32 + strlenW( menu32 ) + 1; |
| |
| if ( flags & MF_END ) |
| level--; |
| } |
| else /* extended */ |
| { |
| put_dword( &menu16, get_dword( &menu32 ) ); /* fType */ |
| put_dword( &menu16, get_dword( &menu32 ) ); /* fState */ |
| put_word( &menu16, get_dword( &menu32 ) ); /* ID */ |
| flags = get_word( &menu32 ); |
| put_byte(&menu16,flags); |
| |
| WideCharToMultiByte( CP_ACP, 0, menu32, -1, menu16, 0x7fffffff, NULL, NULL ); |
| menu16 = (LPSTR)menu16 + strlen( menu16 ) + 1; |
| menu32 = (LPCWSTR)menu32 + strlenW( menu32 ) + 1; |
| |
| /* align on DWORD boundary (32-bit only) */ |
| menu32 = (LPCVOID)(((UINT_PTR)menu32 + 3) & ~3); |
| |
| /* If popup, transfer helpid */ |
| if ( flags & 1) |
| { |
| put_dword( &menu16, get_dword( &menu32 ) ); |
| level++; |
| } |
| |
| if ( flags & MF_END ) |
| level--; |
| } |
| } |
| |
| |
| /********************************************************************** |
| * GetMenu32Size (KERNEL.617) |
| */ |
| WORD WINAPI GetMenu32Size16( LPCVOID menu32 ) |
| { |
| LPCVOID p = menu32; |
| WORD version, headersize, flags, level = 1; |
| |
| version = get_word(&p); |
| headersize = get_word(&p); |
| p = (const BYTE *)p + headersize; |
| |
| while ( level ) |
| if ( version == 0 ) /* standard */ |
| { |
| flags = get_word(&p); |
| if ( !(flags & MF_POPUP) ) |
| p = (const WORD *)p + 1; /* ID */ |
| else |
| level++; |
| |
| p = (LPCWSTR)p + strlenW( p ) + 1; |
| |
| if ( flags & MF_END ) |
| level--; |
| } |
| else /* extended */ |
| { |
| p = (const DWORD *)p + 1; /* fType */ |
| p = (const DWORD *)p + 1; /* fState */ |
| p = (const DWORD *)p + 1; /* ID */ |
| flags = get_word(&p); |
| |
| p = (LPCWSTR)p + strlenW( p ) + 1; |
| |
| /* align on DWORD boundary (32-bit only) */ |
| p = (LPCVOID)(((UINT_PTR)p + 3) & ~3); |
| |
| /* If popup, skip helpid */ |
| if ( flags & 1) |
| { |
| p = (const DWORD *)p + 1; |
| level++; |
| } |
| |
| if ( flags & MF_END ) |
| level--; |
| } |
| |
| return (WORD)((LPCSTR)p - (LPCSTR)menu32); |
| } |
| |
| |
| /********************************************************************** |
| * ConvertAccelerator32To16 |
| */ |
| static void ConvertAccelerator32To16( LPCVOID acc32, DWORD size, LPVOID acc16 ) |
| { |
| BYTE type; |
| |
| do |
| { |
| /* Copy type */ |
| type = get_byte(&acc32); |
| put_byte(&acc16, type); |
| /* Skip padding */ |
| get_byte(&acc32); |
| /* Copy event and IDval */ |
| put_word(&acc16, get_word(&acc32)); |
| put_word(&acc16, get_word(&acc32)); |
| /* Skip padding */ |
| get_word(&acc32); |
| |
| } while ( !( type & 0x80 ) ); |
| } |
| |
| |
| /********************************************************************** |
| * NE_LoadPEResource |
| */ |
| static HGLOBAL16 NE_LoadPEResource( NE_MODULE *pModule, WORD type, LPCVOID bits, DWORD size ) |
| { |
| HGLOBAL16 handle; |
| |
| TRACE("module=%04x type=%04x\n", pModule->self, type ); |
| |
| handle = GlobalAlloc16( 0, size ); |
| |
| switch (type) |
| { |
| case RT_MENU: |
| ConvertMenu32To16( bits, size, GlobalLock16( handle ) ); |
| break; |
| case RT_DIALOG: |
| ConvertDialog32To16( bits, size, GlobalLock16( handle ) ); |
| break; |
| case RT_ACCELERATOR: |
| ConvertAccelerator32To16( bits, size, GlobalLock16( handle ) ); |
| break; |
| case RT_STRING: |
| FIXME("not yet implemented!\n" ); |
| /* fall through */ |
| default: |
| memcpy( GlobalLock16( handle ), bits, size ); |
| break; |
| } |
| return handle; |
| } |
| |
| |
| /********************************************************************** |
| * AllocResource (KERNEL.66) |
| */ |
| HGLOBAL16 WINAPI AllocResource16( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size) |
| { |
| NE_NAMEINFO *pNameInfo=NULL; |
| WORD sizeShift; |
| HGLOBAL16 ret; |
| |
| NE_MODULE *pModule = NE_GetPtr( hModule ); |
| if (!pModule || !pModule->ne_rsrctab || !hRsrc) return 0; |
| |
| TRACE("module=%04x res=%04x size=%d\n", hModule, hRsrc, size ); |
| |
| sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab); |
| pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc); |
| if (size < (DWORD)pNameInfo->length << sizeShift) |
| size = (DWORD)pNameInfo->length << sizeShift; |
| ret = GlobalAlloc16( GMEM_FIXED, size ); |
| if (ret) FarSetOwner16( ret, hModule ); |
| return ret; |
| } |
| |
| |
| /********************************************************************** |
| * DirectResAlloc (KERNEL.168) |
| * |
| * Check Schulman, p. 232 for details |
| */ |
| HGLOBAL16 WINAPI DirectResAlloc16( HINSTANCE16 hInstance, WORD wType, |
| UINT16 wSize ) |
| { |
| HGLOBAL16 ret; |
| TRACE("(%04x,%04x,%04x)\n", hInstance, wType, wSize ); |
| if (!(hInstance = GetExePtr( hInstance ))) return 0; |
| if(wType != 0x10) /* 0x10 is the only observed value, passed from |
| CreateCursorIndirect. */ |
| TRACE("(wType=%x)\n", wType); |
| ret = GlobalAlloc16( GMEM_MOVEABLE, wSize ); |
| if (ret) FarSetOwner16( ret, hInstance ); |
| return ret; |
| } |
| |
| |
| /********************************************************************** |
| * AccessResource (KERNEL.64) |
| */ |
| INT16 WINAPI AccessResource16( HINSTANCE16 hModule, HRSRC16 hRsrc ) |
| { |
| HFILE16 fd; |
| NE_MODULE *pModule = NE_GetPtr( hModule ); |
| |
| if (!pModule || !pModule->ne_rsrctab || !hRsrc) return -1; |
| |
| TRACE("module=%04x res=%04x\n", pModule->self, hRsrc ); |
| |
| if ((fd = _lopen16( NE_MODULE_NAME(pModule), OF_READ )) != HFILE_ERROR16) |
| { |
| WORD sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab); |
| NE_NAMEINFO *pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc); |
| _llseek16( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET ); |
| } |
| return fd; |
| } |
| |
| |
| /********************************************************************** |
| * FindResource (KERNEL.60) |
| */ |
| HRSRC16 WINAPI FindResource16( HMODULE16 hModule, LPCSTR name, LPCSTR type ) |
| { |
| NE_TYPEINFO *pTypeInfo; |
| NE_NAMEINFO *pNameInfo; |
| LPBYTE pResTab; |
| NE_MODULE *pModule = get_module( hModule ); |
| |
| if (!pModule) return 0; |
| |
| if (pModule->module32) |
| { |
| /* 32-bit PE module */ |
| HRSRC hRsrc32 = FindResourceA( pModule->module32, name, type ); |
| return MapHRsrc32To16( pModule, hRsrc32, HIWORD(type) ? 0 : LOWORD(type) ); |
| } |
| |
| TRACE("module=%04x name=%s type=%s\n", pModule->self, debugstr_a(name), debugstr_a(type) ); |
| |
| if (!pModule->ne_rsrctab) return 0; |
| |
| type = get_res_name( type ); |
| name = get_res_name( name ); |
| |
| if (HIWORD(type) || HIWORD(name)) |
| { |
| DWORD id = NE_FindNameTableId( pModule, type, name ); |
| if (id) /* found */ |
| { |
| type = (LPCSTR)(ULONG_PTR)LOWORD(id); |
| name = (LPCSTR)(ULONG_PTR)HIWORD(id); |
| } |
| } |
| pResTab = (LPBYTE)pModule + pModule->ne_rsrctab; |
| pTypeInfo = (NE_TYPEINFO *)( pResTab + 2 ); |
| |
| for (;;) |
| { |
| if (!(pTypeInfo = NE_FindTypeSection( pResTab, pTypeInfo, type ))) break; |
| if ((pNameInfo = NE_FindResourceFromType( pResTab, pTypeInfo, name ))) |
| { |
| TRACE(" Found id %p\n", name ); |
| return (HRSRC16)( (char *)pNameInfo - (char *)pModule ); |
| } |
| pTypeInfo = next_typeinfo(pTypeInfo); |
| } |
| return 0; |
| } |
| |
| |
| /********************************************************************** |
| * LoadResource (KERNEL.61) |
| */ |
| HGLOBAL16 WINAPI LoadResource16( HMODULE16 hModule, HRSRC16 hRsrc ) |
| { |
| NE_TYPEINFO *pTypeInfo; |
| NE_NAMEINFO *pNameInfo = NULL; |
| NE_MODULE *pModule = get_module( hModule ); |
| int d; |
| |
| if (!hRsrc || !pModule) return 0; |
| |
| if (pModule->module32) |
| { |
| /* load 32-bit resource and convert it */ |
| HRSRC hRsrc32 = MapHRsrc16To32( pModule, hRsrc ); |
| WORD type = MapHRsrc16ToType( pModule, hRsrc ); |
| HGLOBAL hMem = LoadResource( pModule->module32, hRsrc32 ); |
| DWORD size = SizeofResource( pModule->module32, hRsrc32 ); |
| if (!hMem) return 0; |
| return NE_LoadPEResource( pModule, type, LockResource( hMem ), size ); |
| } |
| |
| /* first, verify hRsrc (just an offset from pModule to the needed pNameInfo) */ |
| |
| d = pModule->ne_rsrctab + 2; |
| pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d); |
| while( hRsrc > d ) |
| { |
| if (pTypeInfo->type_id == 0) break; /* terminal entry */ |
| d += sizeof(NE_TYPEINFO) + pTypeInfo->count * sizeof(NE_NAMEINFO); |
| if (hRsrc < d) |
| { |
| if( ((d - hRsrc)%sizeof(NE_NAMEINFO)) == 0 ) |
| { |
| pNameInfo = (NE_NAMEINFO *)((char *)pModule + hRsrc); |
| break; |
| } |
| else break; /* NE_NAMEINFO boundary mismatch */ |
| } |
| pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d); |
| } |
| |
| if (pNameInfo) |
| { |
| if (pNameInfo->handle && !(GlobalFlags16(pNameInfo->handle) & GMEM_DISCARDED)) |
| { |
| pNameInfo->usage++; |
| TRACE(" Already loaded, new count=%d\n", pNameInfo->usage ); |
| } |
| else |
| { |
| FARPROC16 resloader; |
| memcpy_unaligned( &resloader, &pTypeInfo->resloader, sizeof(FARPROC16) ); |
| if (resloader && resloader != get_default_res_handler()) |
| { |
| WORD args[3]; |
| DWORD ret; |
| |
| args[2] = pNameInfo->handle; |
| args[1] = pModule->self; |
| args[0] = hRsrc; |
| WOWCallback16Ex( (DWORD)resloader, WCB16_PASCAL, sizeof(args), args, &ret ); |
| pNameInfo->handle = LOWORD(ret); |
| } |
| else |
| pNameInfo->handle = NE_DefResourceHandler( pNameInfo->handle, pModule->self, hRsrc ); |
| |
| if (pNameInfo->handle) |
| { |
| pNameInfo->usage++; |
| pNameInfo->flags |= NE_SEGFLAGS_LOADED; |
| } |
| } |
| return pNameInfo->handle; |
| } |
| return 0; |
| } |
| |
| |
| /********************************************************************** |
| * LockResource (KERNEL.62) |
| */ |
| SEGPTR WINAPI WIN16_LockResource16( HGLOBAL16 handle ) |
| { |
| TRACE("(%04x)\n", handle ); |
| /* May need to reload the resource if discarded */ |
| return WOWGlobalLock16( handle ); |
| } |
| |
| |
| /********************************************************************** |
| * LockResource16 (KERNEL32.@) |
| */ |
| LPVOID WINAPI LockResource16( HGLOBAL16 handle ) |
| { |
| return MapSL( WIN16_LockResource16(handle) ); |
| } |
| |
| |
| /********************************************************************** |
| * SizeofResource (KERNEL.65) |
| */ |
| DWORD WINAPI SizeofResource16( HMODULE16 hModule, HRSRC16 hRsrc ) |
| { |
| NE_MODULE *pModule = NE_GetPtr( hModule ); |
| |
| TRACE("(%x, %x)\n", hModule, hRsrc ); |
| |
| if (!hRsrc) return 0; |
| if (!(pModule = get_module( hModule ))) return 0; |
| if (pModule->ne_rsrctab) |
| { |
| WORD sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab); |
| NE_NAMEINFO *pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc); |
| return (DWORD)pNameInfo->length << sizeShift; |
| } |
| if (pModule->module32) |
| { |
| /* 32-bit PE module */ |
| return SizeofResource( pModule->module32, MapHRsrc16To32( pModule, hRsrc ) ); |
| } |
| return 0; |
| } |
| |
| |
| typedef WORD (WINAPI *pDestroyIcon32Proc)( HGLOBAL16 handle, UINT16 flags ); |
| |
| /********************************************************************** |
| * FreeResource (KERNEL.63) |
| */ |
| BOOL16 WINAPI FreeResource16( HGLOBAL16 handle ) |
| { |
| pDestroyIcon32Proc proc; |
| HMODULE user; |
| NE_MODULE *pModule = NE_GetPtr( FarGetOwner16( handle ) ); |
| |
| TRACE("(%04x)\n", handle ); |
| |
| /* Try NE resource first */ |
| |
| if (pModule && pModule->ne_rsrctab) |
| { |
| NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2); |
| while (pTypeInfo->type_id) |
| { |
| WORD count; |
| NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1); |
| for (count = pTypeInfo->count; count > 0; count--) |
| { |
| if (pNameInfo->handle == handle) |
| { |
| if (pNameInfo->usage > 0) pNameInfo->usage--; |
| if (pNameInfo->usage == 0) |
| { |
| GlobalFree16( pNameInfo->handle ); |
| pNameInfo->handle = 0; |
| pNameInfo->flags &= ~NE_SEGFLAGS_LOADED; |
| } |
| return 0; |
| } |
| pNameInfo++; |
| } |
| pTypeInfo = (NE_TYPEINFO *)pNameInfo; |
| } |
| } |
| |
| /* If this failed, call USER.DestroyIcon32; this will check |
| whether it is a shared cursor/icon; if not it will call |
| GlobalFree16() */ |
| user = GetModuleHandleA( "user32.dll" ); |
| if (user && (proc = (pDestroyIcon32Proc)GetProcAddress( user, "DestroyIcon32" ))) |
| return proc( handle, 1 /*CID_RESOURCE*/ ); |
| else |
| return GlobalFree16( handle ); |
| } |
