Sweden-Number/dlls/user/resource.c

445 lines
12 KiB
C
Raw Normal View History

/*
* USER resource functions
*
* Copyright 1993 Robert J. Amstadt
* Copyright 1995 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "winnls.h"
#include "wine/winbase16.h"
#include "wine/winuser16.h"
#include "wownt32.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(resource);
WINE_DECLARE_DEBUG_CHANNEL(accel);
/* this is the 8 byte accel struct used in Win32 resources (internal only) */
typedef struct
{
WORD fVirt;
WORD key;
WORD cmd;
WORD pad;
} PE_ACCEL, *LPPE_ACCEL;
/**********************************************************************
2001-07-02 21:59:40 +02:00
* LoadAccelerators [USER.177]
*/
HACCEL16 WINAPI LoadAccelerators16(HINSTANCE16 instance, LPCSTR lpTableName)
{
HRSRC16 hRsrc;
TRACE_(accel)("%04x %s\n", instance, debugstr_a(lpTableName) );
if (!(hRsrc = FindResource16( instance, lpTableName, (LPSTR)RT_ACCELERATOR ))) {
WARN_(accel)("couldn't find accelerator table resource\n");
return 0;
}
TRACE_(accel)("returning HACCEL 0x%x\n", hRsrc);
return LoadResource16(instance,hRsrc);
}
/**********************************************************************
2001-01-25 23:22:21 +01:00
* LoadAcceleratorsW (USER32.@)
* The image layout seems to look like this (not 100% sure):
* 00: WORD type type of accelerator
* 02: WORD event
2002-06-01 01:06:46 +02:00
* 04: WORD IDval
* 06: WORD pad (to DWORD boundary)
*/
HACCEL WINAPI LoadAcceleratorsW(HINSTANCE instance,LPCWSTR lpTableName)
{
HRSRC hRsrc;
2002-08-28 02:39:39 +02:00
HACCEL hMem;
HACCEL16 hRetval=0;
DWORD size;
if (HIWORD(lpTableName))
TRACE_(accel)("%p '%s'\n",
2004-11-30 22:38:57 +01:00
(LPVOID)instance, (const char *)( lpTableName ) );
else
TRACE_(accel)("%p 0x%04x\n",
(LPVOID)instance, LOWORD(lpTableName) );
if (!(hRsrc = FindResourceW( instance, lpTableName, (LPWSTR)RT_ACCELERATOR )))
{
WARN_(accel)("couldn't find accelerator table resource\n");
} else {
hMem = LoadResource( instance, hRsrc );
size = SizeofResource( instance, hRsrc );
if(size>=sizeof(PE_ACCEL))
{
LPPE_ACCEL accel_table = (LPPE_ACCEL) hMem;
LPACCEL16 accel16;
int i,nrofaccells = size/sizeof(PE_ACCEL);
hRetval = GlobalAlloc16(0,sizeof(ACCEL16)*nrofaccells);
accel16 = (LPACCEL16)GlobalLock16(hRetval);
for (i=0;i<nrofaccells;i++) {
accel16[i].fVirt = accel_table[i].fVirt & 0x7f;
accel16[i].key = accel_table[i].key;
if( !(accel16[i].fVirt & FVIRTKEY) )
accel16[i].key &= 0x00ff;
accel16[i].cmd = accel_table[i].cmd;
}
accel16[i-1].fVirt |= 0x80;
}
}
2002-11-22 22:22:14 +01:00
TRACE_(accel)("returning HACCEL %p\n", hRsrc);
2002-08-28 02:39:39 +02:00
return HACCEL_32(hRetval);
}
/***********************************************************************
2001-01-25 23:22:21 +01:00
* LoadAcceleratorsA (USER32.@)
*/
HACCEL WINAPI LoadAcceleratorsA(HINSTANCE instance,LPCSTR lpTableName)
{
INT len;
LPWSTR uni;
HACCEL result = 0;
if (!HIWORD(lpTableName)) return LoadAcceleratorsW( instance, (LPCWSTR)lpTableName );
len = MultiByteToWideChar( CP_ACP, 0, lpTableName, -1, NULL, 0 );
if ((uni = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
{
MultiByteToWideChar( CP_ACP, 0, lpTableName, -1, uni, len );
result = LoadAcceleratorsW(instance,uni);
HeapFree( GetProcessHeap(), 0, uni);
}
return result;
}
/**********************************************************************
2001-01-25 23:22:21 +01:00
* CopyAcceleratorTableA (USER32.@)
*/
INT WINAPI CopyAcceleratorTableA(HACCEL src, LPACCEL dst, INT entries)
{
return CopyAcceleratorTableW(src, dst, entries);
}
/**********************************************************************
2001-01-25 23:22:21 +01:00
* CopyAcceleratorTableW (USER32.@)
*
* By mortene@pvv.org 980321
*/
INT WINAPI CopyAcceleratorTableW(HACCEL src, LPACCEL dst,
INT entries)
{
int i,xsize;
2002-08-28 02:39:39 +02:00
LPACCEL16 accel = (LPACCEL16)GlobalLock16(HACCEL_16(src));
BOOL done = FALSE;
/* Do parameter checking to avoid the explosions and the screaming
as far as possible. */
2002-12-02 19:10:57 +01:00
if((dst && (entries < 1)) || (src == NULL) || !accel) {
WARN_(accel)("Application sent invalid parameters (%p %p %d).\n",
(LPVOID)src, (LPVOID)dst, entries);
return 0;
}
2002-08-28 02:39:39 +02:00
xsize = GlobalSize16(HACCEL_16(src))/sizeof(ACCEL16);
if (xsize<entries) entries=xsize;
i=0;
while(!done) {
/* Spit out some debugging information. */
TRACE_(accel)("accel %d: type 0x%02x, event '%c', IDval 0x%04x.\n",
i, accel[i].fVirt, accel[i].key, accel[i].cmd);
/* Copy data to the destination structure array (if dst == NULL,
we're just supposed to count the number of entries). */
if(dst) {
dst[i].fVirt = accel[i].fVirt&0x7f;
dst[i].key = accel[i].key;
dst[i].cmd = accel[i].cmd;
/* Check if we've reached the end of the application supplied
accelerator table. */
if(i+1 == entries)
done = TRUE;
}
/* The highest order bit seems to mark the end of the accelerator
resource table, but not always. Use GlobalSize() check too. */
if((accel[i].fVirt & 0x80) != 0) done = TRUE;
i++;
}
return i;
}
/*********************************************************************
2001-01-25 23:22:21 +01:00
* CreateAcceleratorTableA (USER32.@)
*
* By mortene@pvv.org 980321
*/
HACCEL WINAPI CreateAcceleratorTableA(LPACCEL lpaccel, INT cEntries)
{
HACCEL hAccel;
LPACCEL16 accel;
int i;
/* Do parameter checking just in case someone's trying to be
funny. */
if(cEntries < 1) {
WARN_(accel)("Application sent invalid parameters (%p %d).\n",
lpaccel, cEntries);
SetLastError(ERROR_INVALID_PARAMETER);
2002-12-02 19:10:57 +01:00
return NULL;
}
/* Allocate memory and copy the table. */
2002-08-28 02:39:39 +02:00
hAccel = HACCEL_32(GlobalAlloc16(0,cEntries*sizeof(ACCEL16)));
2002-11-22 22:22:14 +01:00
TRACE_(accel)("handle %p\n", hAccel);
if(!hAccel) {
ERR_(accel)("Out of memory.\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2002-12-02 19:10:57 +01:00
return NULL;
}
2002-08-28 02:39:39 +02:00
accel = GlobalLock16(HACCEL_16(hAccel));
for (i=0;i<cEntries;i++) {
accel[i].fVirt = lpaccel[i].fVirt&0x7f;
accel[i].key = lpaccel[i].key;
if( !(accel[i].fVirt & FVIRTKEY) )
accel[i].key &= 0x00ff;
accel[i].cmd = lpaccel[i].cmd;
}
/* Set the end-of-table terminator. */
accel[cEntries-1].fVirt |= 0x80;
TRACE_(accel)("Allocated accelerator handle %p with %d entries\n", hAccel,cEntries);
return hAccel;
}
/*********************************************************************
2001-01-25 23:22:21 +01:00
* CreateAcceleratorTableW (USER32.@)
*
2002-06-01 01:06:46 +02:00
*
*/
HACCEL WINAPI CreateAcceleratorTableW(LPACCEL lpaccel, INT cEntries)
{
HACCEL hAccel;
LPACCEL16 accel;
int i;
2002-06-01 01:06:46 +02:00
char ckey;
/* Do parameter checking just in case someone's trying to be
funny. */
if(cEntries < 1) {
WARN_(accel)("Application sent invalid parameters (%p %d).\n",
lpaccel, cEntries);
SetLastError(ERROR_INVALID_PARAMETER);
2002-12-02 19:10:57 +01:00
return NULL;
}
/* Allocate memory and copy the table. */
2002-08-28 02:39:39 +02:00
hAccel = HACCEL_32(GlobalAlloc16(0,cEntries*sizeof(ACCEL16)));
2002-11-22 22:22:14 +01:00
TRACE_(accel)("handle %p\n", hAccel);
if(!hAccel) {
ERR_(accel)("Out of memory.\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2002-12-02 19:10:57 +01:00
return NULL;
}
2002-08-28 02:39:39 +02:00
accel = GlobalLock16(HACCEL_16(hAccel));
for (i=0;i<cEntries;i++) {
accel[i].fVirt = lpaccel[i].fVirt&0x7f;
if( !(accel[i].fVirt & FVIRTKEY) ) {
ckey = (char) lpaccel[i].key;
if(!MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, &ckey, 1, &accel[i].key, 1))
2004-01-27 01:01:43 +01:00
WARN_(accel)("Error converting ASCII accelerator table to Unicode\n");
}
2002-06-01 01:06:46 +02:00
else
accel[i].key = lpaccel[i].key;
accel[i].cmd = lpaccel[i].cmd;
}
/* Set the end-of-table terminator. */
accel[cEntries-1].fVirt |= 0x80;
2002-11-22 22:22:14 +01:00
TRACE_(accel)("Allocated accelerator handle %p\n", hAccel);
return hAccel;
}
/******************************************************************************
2001-01-25 23:22:21 +01:00
* DestroyAcceleratorTable [USER32.@]
* Destroys an accelerator table
*
* NOTES
* By mortene@pvv.org 980321
*
* PARAMS
* handle [I] Handle to accelerator table
*
* RETURNS STD
*/
BOOL WINAPI DestroyAcceleratorTable( HACCEL handle )
{
if( !handle )
return FALSE;
2002-08-28 02:39:39 +02:00
return !GlobalFree16(HACCEL_16(handle));
}
2002-06-01 01:06:46 +02:00
/**********************************************************************
2001-07-02 21:59:40 +02:00
* LoadString (USER.176)
*/
INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id,
LPSTR buffer, INT16 buflen )
{
HGLOBAL16 hmem;
HRSRC16 hrsrc;
unsigned char *p;
int string_num;
int i;
TRACE("inst=%04x id=%04x buff=%p len=%d\n",
instance, resource_id, buffer, buflen);
hrsrc = FindResource16( instance, MAKEINTRESOURCEA((resource_id>>4)+1), (LPSTR)RT_STRING );
if (!hrsrc) return 0;
hmem = LoadResource16( instance, hrsrc );
if (!hmem) return 0;
2002-06-01 01:06:46 +02:00
p = LockResource16(hmem);
string_num = resource_id & 0x000f;
for (i = 0; i < string_num; i++)
p += *p + 1;
2002-06-01 01:06:46 +02:00
TRACE("strlen = %d\n", (int)*p );
2002-06-01 01:06:46 +02:00
if (buffer == NULL) return *p;
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;
}
2004-01-06 23:08:33 +01:00
WARN("Don't know why caller gave buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
}
FreeResource16( hmem );
TRACE("'%s' loaded !\n", buffer);
return i;
}
/**********************************************************************
2001-01-25 23:22:21 +01:00
* LoadStringW (USER32.@)
*/
INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
LPWSTR buffer, INT buflen )
{
HGLOBAL hmem;
HRSRC hrsrc;
WCHAR *p;
int string_num;
int i;
if (HIWORD(resource_id)==0xFFFF) /* netscape 3 passes this */
resource_id = (UINT)(-((INT)resource_id));
TRACE("instance = %p, id = %04x, buffer = %p, length = %d\n",
instance, resource_id, buffer, buflen);
2002-06-01 01:06:46 +02:00
/* Use bits 4 - 19 (incremented by 1) as resourceid, mask out
* 20 - 31. */
hrsrc = FindResourceW( instance, MAKEINTRESOURCEW(((resource_id>>4)&0xffff)+1),
(LPWSTR)RT_STRING );
if (!hrsrc) return 0;
hmem = LoadResource( instance, hrsrc );
if (!hmem) return 0;
2002-06-01 01:06:46 +02:00
p = LockResource(hmem);
string_num = resource_id & 0x000f;
for (i = 0; i < string_num; i++)
p += *p + 1;
2002-06-01 01:06:46 +02:00
TRACE("strlen = %d\n", (int)*p );
2002-06-01 01:06:46 +02:00
if (buffer == NULL) return *p;
i = min(buflen - 1, *p);
if (i > 0) {
memcpy(buffer, p + 1, i * sizeof (WCHAR));
buffer[i] = (WCHAR) 0;
} else {
if (buflen > 1) {
buffer[0] = (WCHAR) 0;
return 0;
}
#if 0
2004-01-06 23:08:33 +01:00
WARN("Don't know why caller gave buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
#endif
}
TRACE("%s loaded !\n", debugstr_w(buffer));
return i;
}
/**********************************************************************
2001-01-25 23:22:21 +01:00
* LoadStringA (USER32.@)
*/
INT WINAPI LoadStringA( HINSTANCE instance, UINT resource_id,
LPSTR buffer, INT buflen )
{
INT retval;
LPWSTR wbuf;
TRACE("instance = %p, id = %04x, buffer = %p, length = %d\n",
instance, resource_id, buffer, buflen);
if(buffer == NULL) /* asked size of string */
return LoadStringW(instance, resource_id, NULL, 0);
2002-06-01 01:06:46 +02:00
wbuf = HeapAlloc(GetProcessHeap(), 0, buflen * sizeof(WCHAR));
if(!wbuf)
return 0;
retval = LoadStringW(instance, resource_id, wbuf, buflen);
if(retval != 0)
{
retval = WideCharToMultiByte(CP_ACP, 0, wbuf, retval, buffer, buflen - 1, NULL, NULL);
buffer[retval] = 0;
TRACE("%s loaded !\n", debugstr_a(buffer));
}
else buffer[0] = 0; /* no check of buflen here */
HeapFree( GetProcessHeap(), 0, wbuf );
return retval;
}
/**********************************************************************
* GetGuiResources (USER32.@)
*/
DWORD WINAPI GetGuiResources( HANDLE hProcess, DWORD uiFlags )
{
FIXME("(%p,%lx): stub\n",hProcess,uiFlags);
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return 0;
}