dlls/user32/resource.c

   1 /*
   2  * USER resource functions
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995, 2009 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winerror.h"
  27 #include "winternl.h"
  28 #include "winnls.h"
  29 #include "wine/debug.h"
  30 #include "user_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(resource);
  33 WINE_DECLARE_DEBUG_CHANNEL(accel);
  34
  35 /* this is the 8 byte accel struct used in Win32 resources (internal only) */
  36 typedef struct
  37 {
  38     WORD   fVirt;
  39     WORD   key;
  40     WORD   cmd;
  41     WORD   pad;
  42 } PE_ACCEL;
  43
  44 /* the accelerator user object */
  45 struct accelerator
  46 {
  47     struct user_object obj;
  48     unsigned int       count;
  49     PE_ACCEL           table[1];
  50 };
  51
  52 /**********************************************************************
  53  *                      LoadAcceleratorsW       (USER32.@)
  54  */
  55 HACCEL WINAPI LoadAcceleratorsW(HINSTANCE instance, LPCWSTR name)
  56 {
  57     struct accelerator *accel;
  58     const PE_ACCEL *table;
  59     HRSRC rsrc;
  60     HACCEL handle;
  61     DWORD count;
  62
  63     if (!(rsrc = FindResourceW( instance, name, (LPWSTR)RT_ACCELERATOR ))) return 0;
  64     table = LoadResource( instance, rsrc );
  65     count = SizeofResource( instance, rsrc ) / sizeof(*table);
  66     if (!count) return 0;
  67     accel = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( struct accelerator, table[count] ));
  68     if (!accel) return 0;
  69     accel->count = count;
  70     memcpy( accel->table, table, count * sizeof(*table) );
  71     if (!(handle = alloc_user_handle( &accel->obj, USER_ACCEL )))
  72         HeapFree( GetProcessHeap(), 0, accel );
  73     return handle;
  74     TRACE_(accel)("%p %s returning %p\n", instance, debugstr_w(name), handle );
  75     return handle;
  76 }
  77
  78 /***********************************************************************
  79  *              LoadAcceleratorsA   (USER32.@)
  80  */
  81 HACCEL WINAPI LoadAcceleratorsA(HINSTANCE instance,LPCSTR lpTableName)
  82 {
  83     INT len;
  84     LPWSTR uni;
  85     HACCEL result = 0;
  86
  87     if (!HIWORD(lpTableName)) return LoadAcceleratorsW( instance, (LPCWSTR)lpTableName );
  88
  89     len = MultiByteToWideChar( CP_ACP, 0, lpTableName, -1, NULL, 0 );
  90     if ((uni = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
  91     {
  92         MultiByteToWideChar( CP_ACP, 0, lpTableName, -1, uni, len );
  93         result = LoadAcceleratorsW(instance,uni);
  94         HeapFree( GetProcessHeap(), 0, uni);
  95     }
  96     return result;
  97 }
  98
  99 /**********************************************************************
 100  *             CopyAcceleratorTableA   (USER32.@)
 101  */
 102 INT WINAPI CopyAcceleratorTableA(HACCEL src, LPACCEL dst, INT count)
 103 {
 104     char ch;
 105     int i, ret = CopyAcceleratorTableW( src, dst, count );
 106
 107     if (ret && dst)
 108     {
 109         for (i = 0; i < ret; i++)
 110         {
 111             if (dst[i].fVirt & FVIRTKEY) continue;
 112             WideCharToMultiByte( CP_ACP, 0, &dst[i].key, 1, &ch, 1, NULL, NULL );
 113             dst[i].key = ch;
 114         }
 115     }
 116     return ret;
 117 }
 118
 119 /**********************************************************************
 120  *             CopyAcceleratorTableW   (USER32.@)
 121  */
 122 INT WINAPI CopyAcceleratorTableW(HACCEL src, LPACCEL dst, INT count)
 123 {
 124     struct accelerator *accel;
 125     int i;
 126
 127     if (!(accel = get_user_handle_ptr( src, USER_ACCEL ))) return 0;
 128     if (accel == OBJ_OTHER_PROCESS)
 129     {
 130         FIXME( "other process handle %p?\n", src );
 131         return 0;
 132     }
 133     if (dst)
 134     {
 135         if (count > accel->count) count = accel->count;
 136         for (i = 0; i < count; i++)
 137         {
 138             dst[i].fVirt = accel->table[i].fVirt & 0x7f;
 139             dst[i].key   = accel->table[i].key;
 140             dst[i].cmd   = accel->table[i].cmd;
 141         }
 142     }
 143     else count = accel->count;
 144     release_user_handle_ptr( accel );
 145     return count;
 146 }
 147
 148 /*********************************************************************
 149  *                    CreateAcceleratorTableA   (USER32.@)
 150  */
 151 HACCEL WINAPI CreateAcceleratorTableA(LPACCEL lpaccel, INT count)
 152 {
 153     struct accelerator *accel;
 154     HACCEL handle;
 155     int i;
 156
 157     if (count < 1)
 158     {
 159         SetLastError( ERROR_INVALID_PARAMETER );
 160         return 0;
 161     }
 162     accel = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( struct accelerator, table[count] ));
 163     if (!accel) return 0;
 164     accel->count = count;
 165     for (i = 0; i < count; i++)
 166     {
 167         accel->table[i].fVirt = lpaccel[i].fVirt;
 168         accel->table[i].cmd   = lpaccel[i].cmd;
 169         if (!(lpaccel[i].fVirt & FVIRTKEY))
 170         {
 171             char ch = lpaccel[i].key;
 172             MultiByteToWideChar( CP_ACP, 0, &ch, 1, &accel->table[i].key, 1 );
 173         }
 174         else accel->table[i].key = lpaccel[i].key;
 175     }
 176     if (!(handle = alloc_user_handle( &accel->obj, USER_ACCEL )))
 177         HeapFree( GetProcessHeap(), 0, accel );
 178     TRACE_(accel)("returning %p\n", handle );
 179     return handle;
 180 }
 181
 182 /*********************************************************************
 183  *                    CreateAcceleratorTableW   (USER32.@)
 184  */
 185 HACCEL WINAPI CreateAcceleratorTableW(LPACCEL lpaccel, INT count)
 186 {
 187     struct accelerator *accel;
 188     HACCEL handle;
 189     int i;
 190
 191     if (count < 1)
 192     {
 193         SetLastError( ERROR_INVALID_PARAMETER );
 194         return 0;
 195     }
 196     accel = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( struct accelerator, table[count] ));
 197     if (!accel) return 0;
 198     accel->count = count;
 199     for (i = 0; i < count; i++)
 200     {
 201         accel->table[i].fVirt = lpaccel[i].fVirt;
 202         accel->table[i].key   = lpaccel[i].key;
 203         accel->table[i].cmd   = lpaccel[i].cmd;
 204     }
 205     if (!(handle = alloc_user_handle( &accel->obj, USER_ACCEL )))
 206         HeapFree( GetProcessHeap(), 0, accel );
 207     TRACE_(accel)("returning %p\n", handle );
 208     return handle;
 209 }
 210
 211 /******************************************************************************
 212  * DestroyAcceleratorTable [USER32.@]
 213  * Destroys an accelerator table
 214  *
 215  * PARAMS
 216  *    handle [I] Handle to accelerator table
 217  *
 218  * RETURNS
 219  *    Success: TRUE
 220  *    Failure: FALSE
 221  */
 222 BOOL WINAPI DestroyAcceleratorTable( HACCEL handle )
 223 {
 224     struct accelerator *accel;
 225
 226     if (!(accel = free_user_handle( handle, USER_ACCEL ))) return FALSE;
 227     if (accel == OBJ_OTHER_PROCESS)
 228     {
 229         FIXME( "other process handle %p?\n", accel );
 230         return FALSE;
 231     }
 232     return HeapFree( GetProcessHeap(), 0, accel );
 233 }
 234
 235 /**********************************************************************
 236  *      LoadStringW             (USER32.@)
 237  */
 238 INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
 239                             LPWSTR buffer, INT buflen )
 240 {
 241     HGLOBAL hmem;
 242     HRSRC hrsrc;
 243     WCHAR *p;
 244     int string_num;
 245     int i;
 246
 247     TRACE("instance = %p, id = %04x, buffer = %p, length = %d\n",
 248           instance, resource_id, buffer, buflen);
 249
 250     if(buffer == NULL)
 251         return 0;
 252
 253     /* Use loword (incremented by 1) as resourceid */
 254     hrsrc = FindResourceW( instance, MAKEINTRESOURCEW((LOWORD(resource_id) >> 4) + 1),
 255                            (LPWSTR)RT_STRING );
 256     if (!hrsrc) return 0;
 257     hmem = LoadResource( instance, hrsrc );
 258     if (!hmem) return 0;
 259
 260     p = LockResource(hmem);
 261     string_num = resource_id & 0x000f;
 262     for (i = 0; i < string_num; i++)
 263         p += *p + 1;
 264
 265     TRACE("strlen = %d\n", (int)*p );
 266
 267     /*if buflen == 0, then return a read-only pointer to the resource itself in buffer
 268     it is assumed that buffer is actually a (LPWSTR *) */
 269     if(buflen == 0)
 270     {
 271         *((LPWSTR *)buffer) = p + 1;
 272         return *p;
 273     }
 274
 275     i = min(buflen - 1, *p);
 276     if (i > 0) {
 277         memcpy(buffer, p + 1, i * sizeof (WCHAR));
 278         buffer[i] = 0;
 279     } else {
 280         if (buflen > 1) {
 281             buffer[0] = 0;
 282             return 0;
 283         }
 284     }
 285
 286     TRACE("%s loaded !\n", debugstr_w(buffer));
 287     return i;
 288 }
 289
 290 /**********************************************************************
 291  *      LoadStringA     (USER32.@)
 292  */
 293 INT WINAPI LoadStringA( HINSTANCE instance, UINT resource_id, LPSTR buffer, INT buflen )
 294 {
 295     HGLOBAL hmem;
 296     HRSRC hrsrc;
 297     DWORD retval = 0;
 298
 299     TRACE("instance = %p, id = %04x, buffer = %p, length = %d\n",
 300           instance, resource_id, buffer, buflen);
 301
 302     if (!buflen) return -1;
 303
 304     /* Use loword (incremented by 1) as resourceid */
 305     if ((hrsrc = FindResourceW( instance, MAKEINTRESOURCEW((LOWORD(resource_id) >> 4) + 1),
 306                                 (LPWSTR)RT_STRING )) &&
 307         (hmem = LoadResource( instance, hrsrc )))
 308     {
 309         const WCHAR *p = LockResource(hmem);
 310         unsigned int id = resource_id & 0x000f;
 311
 312         while (id--) p += *p + 1;
 313
 314         RtlUnicodeToMultiByteN( buffer, buflen - 1, &retval, p + 1, *p * sizeof(WCHAR) );
 315     }
 316     buffer[retval] = 0;
 317     TRACE("returning %s\n", debugstr_a(buffer));
 318     return retval;
 319 }
 320
 321 /**********************************************************************
 322  *      GetGuiResources (USER32.@)
 323  */
 324 DWORD WINAPI GetGuiResources( HANDLE hProcess, DWORD uiFlags )
 325 {
 326     static BOOL warn = TRUE;
 327
 328     if (warn) {
 329         FIXME("(%p,%x): stub\n",hProcess,uiFlags);
 330        warn = FALSE;
 331     }
 332
 333     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 334     return 0;
 335 }