dlls/kernel32/resource16.c

   1 /*
   2  * 16-bit resource functions
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1997 Alex Korobka
   6  * Copyright 1998 Ulrich Weigand
   7  * Copyright 1995, 2003 Alexandre Julliard
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <sys/types.h>
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "wownt32.h"
  36 #include "wine/winbase16.h"
  37 #include "wine/winuser16.h"
  38 #include "wine/unicode.h"
  39 #include "kernel16_private.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(resource);
  43
  44 /* handle conversions */
  45 #define HRSRC_32(h16)   ((HRSRC)(ULONG_PTR)(h16))
  46 #define HGLOBAL_32(h16) ((HGLOBAL)(ULONG_PTR)(h16))
  47
  48 static inline NE_MODULE *get_module( HMODULE16 mod )
  49 {
  50     if (!mod) mod = TASK_GetCurrent()->hModule;
  51     return NE_GetPtr( mod );
  52 }
  53
  54 #define HRSRC_MAP_BLOCKSIZE 16
  55
  56 typedef struct _HRSRC_ELEM
  57 {
  58     HRSRC hRsrc;
  59     WORD  type;
  60 } HRSRC_ELEM;
  61
  62 typedef struct _HRSRC_MAP
  63 {
  64     int nAlloc;
  65     int nUsed;
  66     HRSRC_ELEM *elem;
  67 } HRSRC_MAP;
  68
  69
  70 /**********************************************************************
  71  *          MapHRsrc32To16
  72  */
  73 static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HRSRC hRsrc32, WORD type )
  74 {
  75     HRSRC_MAP *map = pModule->rsrc32_map;
  76     HRSRC_ELEM *newElem;
  77     int i;
  78
  79     /* On first call, initialize HRSRC map */
  80     if ( !map )
  81     {
  82         if ( !(map = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HRSRC_MAP) ) ) )
  83         {
  84             ERR("Cannot allocate HRSRC map\n" );
  85             return 0;
  86         }
  87         pModule->rsrc32_map = map;
  88     }
  89
  90     /* Check whether HRSRC32 already in map */
  91     for ( i = 0; i < map->nUsed; i++ )
  92         if ( map->elem[i].hRsrc == hRsrc32 )
  93             return (HRSRC16)(i + 1);
  94
  95     /* If no space left, grow table */
  96     if ( map->nUsed == map->nAlloc )
  97     {
  98
  99         if (map->elem)
 100             newElem = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 101                     map->elem, (map->nAlloc + HRSRC_MAP_BLOCKSIZE) * sizeof(HRSRC_ELEM) );
 102         else
 103             newElem = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 104                     (map->nAlloc + HRSRC_MAP_BLOCKSIZE) * sizeof(HRSRC_ELEM) );
 105
 106         if ( !newElem )
 107         {
 108             ERR("Cannot grow HRSRC map\n" );
 109             return 0;
 110         }
 111         map->elem = newElem;
 112         map->nAlloc += HRSRC_MAP_BLOCKSIZE;
 113     }
 114
 115     /* Add HRSRC32 to table */
 116     map->elem[map->nUsed].hRsrc = hRsrc32;
 117     map->elem[map->nUsed].type  = type;
 118     map->nUsed++;
 119
 120     return (HRSRC16)map->nUsed;
 121 }
 122
 123 /**********************************************************************
 124  *          MapHRsrc16To32
 125  */
 126 static HRSRC MapHRsrc16To32( NE_MODULE *pModule, HRSRC16 hRsrc16 )
 127 {
 128     HRSRC_MAP *map = pModule->rsrc32_map;
 129     if ( !map || !hRsrc16 || hRsrc16 > map->nUsed ) return 0;
 130
 131     return map->elem[hRsrc16-1].hRsrc;
 132 }
 133
 134 /**********************************************************************
 135  *          MapHRsrc16ToType
 136  */
 137 static WORD MapHRsrc16ToType( NE_MODULE *pModule, HRSRC16 hRsrc16 )
 138 {
 139     HRSRC_MAP *map = pModule->rsrc32_map;
 140     if ( !map || !hRsrc16 || hRsrc16 > map->nUsed ) return 0;
 141
 142     return map->elem[hRsrc16-1].type;
 143 }
 144
 145
 146 /**********************************************************************
 147  *          get_res_name
 148  *
 149  * Convert a resource name from '#xxx' form to numerical id.
 150  */
 151 static inline LPCSTR get_res_name( LPCSTR name )
 152 {
 153     if (HIWORD(name) && name[0] == '#') name = MAKEINTRESOURCEA( atoi( name + 1 ) );
 154     return name;
 155 }
 156
 157
 158 /**********************************************************************
 159  *          next_typeinfo
 160  */
 161 static inline NE_TYPEINFO *next_typeinfo( NE_TYPEINFO *info )
 162 {
 163     return (NE_TYPEINFO *)((char*)(info + 1) + info->count * sizeof(NE_NAMEINFO));
 164 }
 165
 166
 167 /**********************************************************************
 168  *          get_default_res_handler
 169  */
 170 static inline FARPROC16 get_default_res_handler(void)
 171 {
 172     static FARPROC16 handler;
 173
 174     if (!handler) handler = GetProcAddress16( GetModuleHandle16("KERNEL"), "DefResourceHandler" );
 175     return handler;
 176 }
 177
 178
 179 /***********************************************************************
 180  *           NE_FindNameTableId
 181  *
 182  * Find the type and resource id from their names.
 183  * Return value is MAKELONG( typeId, resId ), or 0 if not found.
 184  */
 185 static DWORD NE_FindNameTableId( NE_MODULE *pModule, LPCSTR typeId, LPCSTR resId )
 186 {
 187     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2);
 188     NE_NAMEINFO *pNameInfo;
 189     HGLOBAL16 handle;
 190     WORD *p;
 191     DWORD ret = 0;
 192     int count;
 193
 194     for (; pTypeInfo->type_id != 0;
 195            pTypeInfo = (NE_TYPEINFO *)((char*)(pTypeInfo+1) +
 196                                         pTypeInfo->count * sizeof(NE_NAMEINFO)))
 197     {
 198         if (pTypeInfo->type_id != 0x800f) continue;
 199         pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
 200         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
 201         {
 202             TRACE("NameTable entry: type=%04x id=%04x\n",
 203                               pTypeInfo->type_id, pNameInfo->id );
 204             handle = LoadResource16( pModule->self,
 205                                      (HRSRC16)((char *)pNameInfo - (char *)pModule) );
 206             for(p = LockResource16(handle); p && *p; p = (WORD *)((char*)p+*p))
 207             {
 208                 TRACE("  type=%04x '%s' id=%04x '%s'\n",
 209                                   p[1], (char *)(p+3), p[2],
 210                                   (char *)(p+3)+strlen((char *)(p+3))+1 );
 211                 /* Check for correct type */
 212
 213                 if (p[1] & 0x8000)
 214                 {
 215                     if (!HIWORD(typeId)) continue;
 216                     if (strcasecmp( typeId, (char *)(p + 3) )) continue;
 217                 }
 218                 else if (HIWORD(typeId) || (((DWORD)typeId & ~0x8000)!= p[1]))
 219                   continue;
 220
 221                 /* Now check for the id */
 222
 223                 if (p[2] & 0x8000)
 224                 {
 225                     if (!HIWORD(resId)) continue;
 226                     if (strcasecmp( resId, (char*)(p+3)+strlen((char*)(p+3))+1 )) continue;
 227
 228                 }
 229                 else if (HIWORD(resId) || ((LOWORD(resId) & ~0x8000) != p[2]))
 230                   continue;
 231
 232                 /* If we get here, we've found the entry */
 233
 234                 TRACE("  Found!\n" );
 235                 ret = MAKELONG( p[1], p[2] );
 236                 break;
 237             }
 238             FreeResource16( handle );
 239             if (ret) return ret;
 240         }
 241     }
 242     return 0;
 243 }
 244
 245
 246 /***********************************************************************
 247  *           NE_FindTypeSection
 248  *
 249  * Find header struct for a particular resource type.
 250  */
 251 static NE_TYPEINFO *NE_FindTypeSection( LPBYTE pResTab, NE_TYPEINFO *pTypeInfo, LPCSTR typeId )
 252 {
 253     /* start from pTypeInfo */
 254
 255     if (HIWORD(typeId) != 0)  /* Named type */
 256     {
 257         LPCSTR str = typeId;
 258         BYTE len = strlen( str );
 259         while (pTypeInfo->type_id)
 260         {
 261             if (!(pTypeInfo->type_id & 0x8000))
 262             {
 263                 BYTE *p = pResTab + pTypeInfo->type_id;
 264                 if ((*p == len) && !strncasecmp( (char*)p+1, str, len ))
 265                 {
 266                     TRACE("  Found type '%s'\n", str );
 267                     return pTypeInfo;
 268                 }
 269             }
 270             TRACE("  Skipping type %04x\n", pTypeInfo->type_id );
 271             pTypeInfo = next_typeinfo(pTypeInfo);
 272         }
 273     }
 274     else  /* Numeric type id */
 275     {
 276         WORD id = LOWORD(typeId) | 0x8000;
 277         while (pTypeInfo->type_id)
 278         {
 279             if (pTypeInfo->type_id == id)
 280             {
 281                 TRACE("  Found type %04x\n", id );
 282                 return pTypeInfo;
 283             }
 284             TRACE("  Skipping type %04x\n", pTypeInfo->type_id );
 285             pTypeInfo = next_typeinfo(pTypeInfo);
 286         }
 287     }
 288     return NULL;
 289 }
 290
 291
 292 /***********************************************************************
 293  *           NE_FindResourceFromType
 294  *
 295  * Find a resource once the type info structure has been found.
 296  */
 297 static NE_NAMEINFO *NE_FindResourceFromType( LPBYTE pResTab, NE_TYPEINFO *pTypeInfo, LPCSTR resId )
 298 {
 299     BYTE *p;
 300     int count;
 301     NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
 302
 303     if (HIWORD(resId) != 0)  /* Named resource */
 304     {
 305         LPCSTR str = resId;
 306         BYTE len = strlen( str );
 307         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
 308         {
 309             if (pNameInfo->id & 0x8000) continue;
 310             p = pResTab + pNameInfo->id;
 311             if ((*p == len) && !strncasecmp( (char*)p+1, str, len ))
 312                 return pNameInfo;
 313         }
 314     }
 315     else  /* Numeric resource id */
 316     {
 317         WORD id = LOWORD(resId) | 0x8000;
 318         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
 319             if (pNameInfo->id == id) return pNameInfo;
 320     }
 321     return NULL;
 322 }
 323
 324
 325 /***********************************************************************
 326  *           DefResourceHandler (KERNEL.456)
 327  *
 328  * This is the default LoadProc() function.
 329  */
 330 HGLOBAL16 WINAPI NE_DefResourceHandler( HGLOBAL16 hMemObj, HMODULE16 hModule,
 331                                         HRSRC16 hRsrc )
 332 {
 333     HGLOBAL16 handle;
 334     WORD sizeShift;
 335     NE_NAMEINFO* pNameInfo;
 336     NE_MODULE* pModule = NE_GetPtr( hModule );
 337
 338     if (!pModule) return 0;
 339
 340     sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
 341     pNameInfo = (NE_NAMEINFO *)((char *)pModule + hRsrc);
 342
 343     if ( hMemObj )
 344         handle = GlobalReAlloc16( hMemObj, pNameInfo->length << sizeShift, 0 );
 345     else
 346         handle = AllocResource16( hModule, hRsrc, 0 );
 347
 348     if (handle)
 349     {
 350         if (!NE_READ_DATA( pModule, GlobalLock16( handle ),
 351                            (int)pNameInfo->offset << sizeShift,
 352                            (int)pNameInfo->length << sizeShift ))
 353         {
 354             GlobalFree16( handle );
 355             handle = 0;
 356         }
 357     }
 358     return handle;
 359 }
 360
 361
 362 /**********************************************************************
 363  *      SetResourceHandler      (KERNEL.67)
 364  */
 365 FARPROC16 WINAPI SetResourceHandler16( HMODULE16 hModule, LPCSTR typeId, FARPROC16 resourceHandler )
 366 {
 367     LPBYTE pResTab;
 368     NE_TYPEINFO *pTypeInfo;
 369     FARPROC16 prevHandler = NULL;
 370     NE_MODULE *pModule = NE_GetPtr( hModule );
 371
 372     if (!pModule || !pModule->ne_rsrctab) return NULL;
 373
 374     pResTab = (LPBYTE)pModule + pModule->ne_rsrctab;
 375     pTypeInfo = (NE_TYPEINFO *)(pResTab + 2);
 376
 377     TRACE("module=%04x type=%s\n", hModule, debugstr_a(typeId) );
 378
 379     for (;;)
 380     {
 381         if (!(pTypeInfo = NE_FindTypeSection( pResTab, pTypeInfo, typeId )))
 382             break;
 383         memcpy_unaligned( &prevHandler, &pTypeInfo->resloader, sizeof(FARPROC16) );
 384         memcpy_unaligned( &pTypeInfo->resloader, &resourceHandler, sizeof(FARPROC16) );
 385         pTypeInfo = next_typeinfo(pTypeInfo);
 386     }
 387     if (!prevHandler) prevHandler = get_default_res_handler();
 388     return prevHandler;
 389 }
 390
 391 static inline DWORD get_dword(LPCVOID *p)
 392 {
 393     DWORD ret = *(const DWORD *)*p;
 394     *p = (const DWORD *)*p + 1;
 395     return ret;
 396 }
 397
 398 static inline void put_dword(LPVOID *p, DWORD d)
 399 {
 400     *(DWORD*)*p = d;
 401     *p = (DWORD *)*p + 1;
 402 }
 403
 404 static inline WORD get_word(LPCVOID *p)
 405 {
 406     WORD ret = *(const WORD *)*p;
 407     *p = (const WORD *)*p + 1;
 408     return ret;
 409 }
 410
 411 static inline void put_word(LPVOID *p, WORD w)
 412 {
 413     *(WORD*)*p = w;
 414     *p = (WORD *)*p + 1;
 415 }
 416
 417 static inline BYTE get_byte(LPCVOID *p)
 418 {
 419     BYTE ret = *(const BYTE *)*p;
 420     *p = (const BYTE *)*p + 1;
 421     return ret;
 422 }
 423
 424 static inline void put_byte(LPVOID *p, BYTE b)
 425 {
 426     *(BYTE *)*p = b;
 427     *p = (BYTE *)*p + 1;
 428 }
 429
 430 /* convert a resource name */
 431 static void convert_name( LPVOID *dst, LPCVOID *src )
 432 {
 433     int len;
 434     switch (*(const WORD *)*src)
 435     {
 436     case 0x0000:
 437         get_word( src );
 438         put_byte( dst, 0 );
 439         break;
 440     case 0xffff:
 441         get_word( src );
 442         put_byte( dst, 0xff );
 443         put_word( dst, get_word(src) );
 444         break;
 445     default:
 446         len = WideCharToMultiByte( CP_ACP, 0, *src, -1, *dst, 0x7fffffff, NULL,NULL );
 447         *dst = (char *)*dst + len;
 448         *src = (LPCWSTR)*src + strlenW( *src ) + 1;
 449         break;
 450     }
 451 }
 452
 453 /**********************************************************************
 454  *          ConvertDialog32To16   (KERNEL.615)
 455  */
 456 VOID WINAPI ConvertDialog32To16( LPCVOID dialog32, DWORD size, LPVOID dialog16 )
 457 {
 458     WORD nbItems, data, dialogEx;
 459     DWORD style;
 460
 461     style = get_dword( &dialog32 );
 462     put_dword( &dialog16, style );
 463     dialogEx = (style == 0xffff0001);  /* DIALOGEX resource */
 464     if (dialogEx)
 465     {
 466         put_dword( &dialog16, get_dword( &dialog32 ) );  /* helpID */
 467         put_dword( &dialog16, get_dword( &dialog32 ) );  /* exStyle */
 468         style = get_dword( &dialog32 );
 469         put_dword( &dialog16, style );                   /* style */
 470     }
 471     else
 472         dialog32 = (const DWORD *)dialog32 + 1; /* exStyle ignored in 16-bit standard dialog */
 473
 474     nbItems = get_word( &dialog32 );
 475     put_byte( &dialog16, nbItems );
 476     put_word( &dialog16, get_word( &dialog32 ) ); /* x */
 477     put_word( &dialog16, get_word( &dialog32 ) ); /* y */
 478     put_word( &dialog16, get_word( &dialog32 ) ); /* cx */
 479     put_word( &dialog16, get_word( &dialog32 ) ); /* cy */
 480
 481     /* Transfer menu name */
 482     convert_name( &dialog16, &dialog32 );
 483
 484     /* Transfer class name */
 485     convert_name( &dialog16, &dialog32 );
 486
 487     /* Transfer window caption */
 488     WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL );
 489     dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1;
 490     dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1;
 491
 492     /* Transfer font info */
 493     if (style & DS_SETFONT)
 494     {
 495         put_word( &dialog16, get_word( &dialog32 ) );  /* pointSize */
 496         if (dialogEx)
 497         {
 498             put_word( &dialog16, get_word( &dialog32 ) ); /* weight */
 499             put_word( &dialog16, get_word( &dialog32 ) ); /* italic */
 500         }
 501         WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL );  /* faceName */
 502         dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1;
 503         dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1;
 504     }
 505
 506     /* Transfer dialog items */
 507     while (nbItems)
 508     {
 509         /* align on DWORD boundary (32-bit only) */
 510         dialog32 = (LPCVOID)(((UINT_PTR)dialog32 + 3) & ~3);
 511
 512         if (dialogEx)
 513         {
 514             put_dword( &dialog16, get_dword( &dialog32 ) ); /* helpID */
 515             put_dword( &dialog16, get_dword( &dialog32 ) ); /* exStyle */
 516             put_dword( &dialog16, get_dword( &dialog32 ) ); /* style */
 517         }
 518         else
 519         {
 520             style = get_dword( &dialog32 );          /* save style */
 521             dialog32 = (const DWORD *)dialog32 + 1;  /* ignore exStyle */
 522         }
 523
 524         put_word( &dialog16, get_word( &dialog32 ) ); /* x */
 525         put_word( &dialog16, get_word( &dialog32 ) ); /* y */
 526         put_word( &dialog16, get_word( &dialog32 ) ); /* cx */
 527         put_word( &dialog16, get_word( &dialog32 ) ); /* cy */
 528
 529         if (dialogEx)
 530             put_dword( &dialog16, get_dword( &dialog32 ) ); /* ID */
 531         else
 532         {
 533             put_word( &dialog16, get_word( &dialog32 ) ); /* ID */
 534             put_dword( &dialog16, style );  /* style from above */
 535         }
 536
 537         /* Transfer class name */
 538         switch (*(const WORD *)dialog32)
 539         {
 540         case 0x0000:
 541             get_word( &dialog32 );
 542             put_byte( &dialog16, 0 );
 543             break;
 544         case 0xffff:
 545             get_word( &dialog32 );
 546             put_byte( &dialog16, get_word( &dialog32 ) );
 547             break;
 548         default:
 549             WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL );
 550             dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1;
 551             dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1;
 552             break;
 553         }
 554
 555         /* Transfer window name */
 556         convert_name( &dialog16, &dialog32 );
 557
 558         /* Transfer data */
 559         data = get_word( &dialog32 );
 560         if (dialogEx)
 561             put_word(&dialog16, data);
 562         else
 563             put_byte(&dialog16,(BYTE)data);
 564
 565         if (data)
 566         {
 567             memcpy( dialog16, dialog32, data );
 568             dialog16 = (BYTE *)dialog16 + data;
 569             dialog32 = (const BYTE *)dialog32 + data;
 570         }
 571
 572         /* Next item */
 573         nbItems--;
 574     }
 575 }
 576
 577
 578 /**********************************************************************
 579  *          GetDialog32Size   (KERNEL.618)
 580  */
 581 WORD WINAPI GetDialog32Size16( LPCVOID dialog32 )
 582 {
 583     LPCVOID p = dialog32;
 584     WORD nbItems, data, dialogEx;
 585     DWORD style;
 586
 587     style = get_dword(&p);
 588     dialogEx = (style == 0xffff0001);  /* DIALOGEX resource */
 589     if (dialogEx)
 590     {
 591         p = (const DWORD *)p + 1; /* helpID */
 592         p = (const DWORD *)p + 1; /* exStyle */
 593         style = get_dword(&p); /* style */
 594     }
 595     else
 596         p = (const DWORD *)p + 1; /* exStyle */
 597
 598     nbItems = get_word(&p);
 599     p = (const DWORD *)p + 1; /* x */
 600     p = (const DWORD *)p + 1; /* y */
 601     p = (const DWORD *)p + 1; /* cx */
 602     p = (const DWORD *)p + 1; /* cy */
 603
 604     /* Skip menu name */
 605     switch (*(const DWORD *)p)
 606     {
 607     case 0x0000:  p = (const DWORD *)p + 1; break;
 608     case 0xffff:  p = (const DWORD *)p + 2; break;
 609     default:      p = (LPCWSTR)p + strlenW( p ) + 1; break;
 610     }
 611
 612     /* Skip class name */
 613     switch (*(const DWORD *)p)
 614     {
 615     case 0x0000:  p = (const DWORD *)p + 1; break;
 616     case 0xffff:  p = (const DWORD *)p + 2; break;
 617     default:      p = (LPCWSTR)p + strlenW( p ) + 1; break;
 618     }
 619
 620     /* Skip window caption */
 621     p = (LPCWSTR)p + strlenW( p ) + 1;
 622
 623     /* Skip font info */
 624     if (style & DS_SETFONT)
 625     {
 626         p = (const DWORD *)p + 1;  /* pointSize */
 627         if (dialogEx)
 628         {
 629             p = (const DWORD *)p + 1; /* weight */
 630             p = (const DWORD *)p + 1; /* italic */
 631         }
 632         p = (LPCWSTR)p + strlenW( p ) + 1;  /* faceName */
 633     }
 634
 635     /* Skip dialog items */
 636     while (nbItems)
 637     {
 638         /* align on DWORD boundary */
 639         p = (LPCVOID)(((UINT_PTR)p + 3) & ~3);
 640
 641         if (dialogEx)
 642         {
 643             p = (const DWORD *)p + 1; /* helpID */
 644             p = (const DWORD *)p + 1; /* exStyle */
 645             p = (const DWORD *)p + 1; /* style */
 646         }
 647         else
 648         {
 649             p = (const DWORD *)p + 1; /* style */
 650             p = (const DWORD *)p + 1; /* exStyle */
 651         }
 652
 653         p = (const DWORD *)p + 1; /* x */
 654         p = (const DWORD *)p + 1; /* y */
 655         p = (const DWORD *)p + 1; /* cx */
 656         p = (const DWORD *)p + 1; /* cy */
 657
 658         if (dialogEx)
 659             p = (const DWORD *)p + 1; /* ID */
 660         else
 661             p = (const DWORD *)p + 1; /* ID */
 662
 663         /* Skip class name */
 664         switch (*(const DWORD *)p)
 665         {
 666         case 0x0000:  p = (const DWORD *)p + 1; break;
 667         case 0xffff:  p = (const DWORD *)p + 2; break;
 668         default:      p = (LPCWSTR)p + strlenW( p ) + 1; break;
 669         }
 670
 671         /* Skip window name */
 672         switch (*(const DWORD *)p)
 673         {
 674         case 0x0000:  p = (const DWORD *)p + 1; break;
 675         case 0xffff:  p = (const DWORD *)p + 2; break;
 676         default:      p = (LPCWSTR)p + strlenW( p ) + 1; break;
 677         }
 678
 679         /* Skip data */
 680         data = get_word(&p);
 681         p = (const BYTE *)p + data;
 682
 683         /* Next item */
 684         nbItems--;
 685     }
 686
 687     return (WORD)((LPCSTR)p - (LPCSTR)dialog32);
 688 }
 689
 690
 691 /**********************************************************************
 692  *          ConvertMenu32To16   (KERNEL.616)
 693  */
 694 VOID WINAPI ConvertMenu32To16( LPCVOID menu32, DWORD size, LPVOID menu16 )
 695 {
 696     WORD version, headersize, flags, level = 1;
 697
 698     version = get_word( &menu32 );
 699     headersize = get_word( &menu32 );
 700     put_word( &menu16, version );
 701     put_word( &menu16, headersize );
 702     if ( headersize )
 703     {
 704         memcpy( menu16, menu32, headersize );
 705         menu16 = (BYTE *)menu16 + headersize;
 706         menu32 = (const BYTE *)menu32 + headersize;
 707     }
 708
 709     while ( level )
 710         if ( version == 0 )  /* standard */
 711         {
 712             flags = get_word( &menu32 );
 713             put_word( &menu16, flags );
 714             if ( !(flags & MF_POPUP) )
 715                 put_word( &menu16, get_word( &menu32 ) );  /* ID */
 716             else
 717                 level++;
 718
 719             WideCharToMultiByte( CP_ACP, 0, menu32, -1, menu16, 0x7fffffff, NULL, NULL );
 720             menu16 = (LPSTR)menu16 + strlen( menu16 ) + 1;
 721             menu32 = (LPCWSTR)menu32 + strlenW( menu32 ) + 1;
 722
 723             if ( flags & MF_END )
 724                 level--;
 725         }
 726         else  /* extended */
 727         {
 728             put_dword( &menu16, get_dword( &menu32 ) );  /* fType */
 729             put_dword( &menu16, get_dword( &menu32 ) );  /* fState */
 730             put_word( &menu16, get_dword( &menu32 ) );   /* ID */
 731             flags = get_word( &menu32 );
 732             put_byte(&menu16,flags);
 733
 734             WideCharToMultiByte( CP_ACP, 0, menu32, -1, menu16, 0x7fffffff, NULL, NULL );
 735             menu16 = (LPSTR)menu16 + strlen( menu16 ) + 1;
 736             menu32 = (LPCWSTR)menu32 + strlenW( menu32 ) + 1;
 737
 738             /* align on DWORD boundary (32-bit only) */
 739             menu32 = (LPCVOID)(((UINT_PTR)menu32 + 3) & ~3);
 740
 741             /* If popup, transfer helpid */
 742             if ( flags & 1)
 743             {
 744                 put_dword( &menu16, get_dword( &menu32 ) );
 745                 level++;
 746             }
 747
 748             if ( flags & MF_END )
 749                 level--;
 750         }
 751 }
 752
 753
 754 /**********************************************************************
 755  *          GetMenu32Size   (KERNEL.617)
 756  */
 757 WORD WINAPI GetMenu32Size16( LPCVOID menu32 )
 758 {
 759     LPCVOID p = menu32;
 760     WORD version, headersize, flags, level = 1;
 761
 762     version = get_word(&p);
 763     headersize = get_word(&p);
 764     p = (const BYTE *)p + headersize;
 765
 766     while ( level )
 767         if ( version == 0 )  /* standard */
 768         {
 769             flags = get_word(&p);
 770             if ( !(flags & MF_POPUP) )
 771                 p = (const WORD *)p + 1;  /* ID */
 772             else
 773                 level++;
 774
 775             p = (LPCWSTR)p + strlenW( p ) + 1;
 776
 777             if ( flags & MF_END )
 778                 level--;
 779         }
 780         else  /* extended */
 781         {
 782             p = (const DWORD *)p + 1; /* fType */
 783             p = (const DWORD *)p + 1; /* fState */
 784             p = (const DWORD *)p + 1; /* ID */
 785             flags = get_word(&p);
 786
 787             p = (LPCWSTR)p + strlenW( p ) + 1;
 788
 789             /* align on DWORD boundary (32-bit only) */
 790             p = (LPCVOID)(((UINT_PTR)p + 3) & ~3);
 791
 792             /* If popup, skip helpid */
 793             if ( flags & 1)
 794             {
 795                 p = (const DWORD *)p + 1;
 796                 level++;
 797             }
 798
 799             if ( flags & MF_END )
 800                 level--;
 801         }
 802
 803     return (WORD)((LPCSTR)p - (LPCSTR)menu32);
 804 }
 805
 806
 807 /**********************************************************************
 808  *          ConvertAccelerator32To16
 809  */
 810 static void ConvertAccelerator32To16( LPCVOID acc32, DWORD size, LPVOID acc16 )
 811 {
 812     BYTE type;
 813
 814     do
 815     {
 816         /* Copy type */
 817         type = get_byte(&acc32);
 818         put_byte(&acc16, type);
 819         /* Skip padding */
 820         get_byte(&acc32);
 821         /* Copy event and IDval */
 822         put_word(&acc16, get_word(&acc32));
 823         put_word(&acc16, get_word(&acc32));
 824         /* Skip padding */
 825         get_word(&acc32);
 826
 827     } while ( !( type & 0x80 ) );
 828 }
 829
 830
 831 /**********************************************************************
 832  *          NE_LoadPEResource
 833  */
 834 static HGLOBAL16 NE_LoadPEResource( NE_MODULE *pModule, WORD type, LPCVOID bits, DWORD size )
 835 {
 836     HGLOBAL16 handle;
 837
 838     TRACE("module=%04x type=%04x\n", pModule->self, type );
 839
 840     handle = GlobalAlloc16( 0, size );
 841
 842     switch (type)
 843     {
 844     case RT_MENU:
 845         ConvertMenu32To16( bits, size, GlobalLock16( handle ) );
 846         break;
 847     case RT_DIALOG:
 848         ConvertDialog32To16( bits, size, GlobalLock16( handle ) );
 849         break;
 850     case RT_ACCELERATOR:
 851         ConvertAccelerator32To16( bits, size, GlobalLock16( handle ) );
 852         break;
 853     case RT_STRING:
 854         FIXME("not yet implemented!\n" );
 855         /* fall through */
 856     default:
 857         memcpy( GlobalLock16( handle ), bits, size );
 858         break;
 859     }
 860     return handle;
 861 }
 862
 863
 864 /**********************************************************************
 865  *          AllocResource    (KERNEL.66)
 866  */
 867 HGLOBAL16 WINAPI AllocResource16( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
 868 {
 869     NE_NAMEINFO *pNameInfo=NULL;
 870     WORD sizeShift;
 871     HGLOBAL16 ret;
 872
 873     NE_MODULE *pModule = NE_GetPtr( hModule );
 874     if (!pModule || !pModule->ne_rsrctab || !hRsrc) return 0;
 875
 876     TRACE("module=%04x res=%04x size=%d\n", hModule, hRsrc, size );
 877
 878     sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
 879     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 880     if (size < (DWORD)pNameInfo->length << sizeShift)
 881         size = (DWORD)pNameInfo->length << sizeShift;
 882     ret = GlobalAlloc16( GMEM_FIXED, size );
 883     if (ret) FarSetOwner16( ret, hModule );
 884     return ret;
 885 }
 886
 887
 888 /**********************************************************************
 889  *      DirectResAlloc    (KERNEL.168)
 890  *
 891  * Check Schulman, p. 232 for details
 892  */
 893 HGLOBAL16 WINAPI DirectResAlloc16( HINSTANCE16 hInstance, WORD wType,
 894                                  UINT16 wSize )
 895 {
 896     HGLOBAL16 ret;
 897     TRACE("(%04x,%04x,%04x)\n", hInstance, wType, wSize );
 898     if (!(hInstance = GetExePtr( hInstance ))) return 0;
 899     if(wType != 0x10)   /* 0x10 is the only observed value, passed from
 900                            CreateCursorIndirect. */
 901         TRACE("(wType=%x)\n", wType);
 902     ret = GlobalAlloc16( GMEM_MOVEABLE, wSize );
 903     if (ret) FarSetOwner16( ret, hInstance );
 904     return ret;
 905 }
 906
 907
 908 /**********************************************************************
 909  *          AccessResource (KERNEL.64)
 910  */
 911 INT16 WINAPI AccessResource16( HINSTANCE16 hModule, HRSRC16 hRsrc )
 912 {
 913     HFILE16 fd;
 914     NE_MODULE *pModule = NE_GetPtr( hModule );
 915
 916     if (!pModule || !pModule->ne_rsrctab || !hRsrc) return -1;
 917
 918     TRACE("module=%04x res=%04x\n", pModule->self, hRsrc );
 919
 920     if ((fd = _lopen16( NE_MODULE_NAME(pModule), OF_READ )) != HFILE_ERROR16)
 921     {
 922         WORD sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
 923         NE_NAMEINFO *pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
 924         _llseek16( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET );
 925     }
 926     return fd;
 927 }
 928
 929
 930 /**********************************************************************
 931  *          FindResource     (KERNEL.60)
 932  */
 933 HRSRC16 WINAPI FindResource16( HMODULE16 hModule, LPCSTR name, LPCSTR type )
 934 {
 935     NE_TYPEINFO *pTypeInfo;
 936     NE_NAMEINFO *pNameInfo;
 937     LPBYTE pResTab;
 938     NE_MODULE *pModule = get_module( hModule );
 939
 940     if (!pModule) return 0;
 941
 942     if (pModule->module32)
 943     {
 944         /* 32-bit PE module */
 945         HRSRC hRsrc32 = FindResourceA( pModule->module32, name, type );
 946         return MapHRsrc32To16( pModule, hRsrc32, HIWORD(type) ? 0 : LOWORD(type) );
 947     }
 948
 949     TRACE("module=%04x name=%s type=%s\n", pModule->self, debugstr_a(name), debugstr_a(type) );
 950
 951     if (!pModule->ne_rsrctab) return 0;
 952
 953     type = get_res_name( type );
 954     name = get_res_name( name );
 955
 956     if (HIWORD(type) || HIWORD(name))
 957     {
 958         DWORD id = NE_FindNameTableId( pModule, type, name );
 959         if (id)  /* found */
 960         {
 961             type = (LPCSTR)(ULONG_PTR)LOWORD(id);
 962             name = (LPCSTR)(ULONG_PTR)HIWORD(id);
 963         }
 964     }
 965     pResTab = (LPBYTE)pModule + pModule->ne_rsrctab;
 966     pTypeInfo = (NE_TYPEINFO *)( pResTab + 2 );
 967
 968     for (;;)
 969     {
 970         if (!(pTypeInfo = NE_FindTypeSection( pResTab, pTypeInfo, type ))) break;
 971         if ((pNameInfo = NE_FindResourceFromType( pResTab, pTypeInfo, name )))
 972         {
 973             TRACE("    Found id %p\n", name );
 974             return (HRSRC16)( (char *)pNameInfo - (char *)pModule );
 975         }
 976         pTypeInfo = next_typeinfo(pTypeInfo);
 977     }
 978     return 0;
 979 }
 980
 981
 982 /**********************************************************************
 983  *          LoadResource     (KERNEL.61)
 984  */
 985 HGLOBAL16 WINAPI LoadResource16( HMODULE16 hModule, HRSRC16 hRsrc )
 986 {
 987     NE_TYPEINFO *pTypeInfo;
 988     NE_NAMEINFO *pNameInfo = NULL;
 989     NE_MODULE *pModule = get_module( hModule );
 990     int d;
 991
 992     if (!hRsrc || !pModule) return 0;
 993
 994     if (pModule->module32)
 995     {
 996         /* load 32-bit resource and convert it */
 997         HRSRC hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
 998         WORD type     = MapHRsrc16ToType( pModule, hRsrc );
 999         HGLOBAL hMem  = LoadResource( pModule->module32, hRsrc32 );
1000         DWORD size    = SizeofResource( pModule->module32, hRsrc32 );
1001         if (!hMem) return 0;
1002         return NE_LoadPEResource( pModule, type, LockResource( hMem ), size );
1003     }
1004
1005     /* first, verify hRsrc (just an offset from pModule to the needed pNameInfo) */
1006
1007     d = pModule->ne_rsrctab + 2;
1008     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d);
1009     while( hRsrc > d )
1010     {
1011         if (pTypeInfo->type_id == 0) break; /* terminal entry */
1012         d += sizeof(NE_TYPEINFO) + pTypeInfo->count * sizeof(NE_NAMEINFO);
1013         if (hRsrc < d)
1014         {
1015             if( ((d - hRsrc)%sizeof(NE_NAMEINFO)) == 0 )
1016             {
1017                 pNameInfo = (NE_NAMEINFO *)((char *)pModule + hRsrc);
1018                 break;
1019             }
1020             else break; /* NE_NAMEINFO boundary mismatch */
1021         }
1022         pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d);
1023     }
1024
1025     if (pNameInfo)
1026     {
1027         if (pNameInfo->handle && !(GlobalFlags16(pNameInfo->handle) & GMEM_DISCARDED))
1028         {
1029             pNameInfo->usage++;
1030             TRACE("  Already loaded, new count=%d\n", pNameInfo->usage );
1031         }
1032         else
1033         {
1034             FARPROC16 resloader;
1035             memcpy_unaligned( &resloader, &pTypeInfo->resloader, sizeof(FARPROC16) );
1036             if (resloader && resloader != get_default_res_handler())
1037             {
1038                 WORD args[3];
1039                 DWORD ret;
1040
1041                 args[2] = pNameInfo->handle;
1042                 args[1] = pModule->self;
1043                 args[0] = hRsrc;
1044                 WOWCallback16Ex( (DWORD)resloader, WCB16_PASCAL, sizeof(args), args, &ret );
1045                 pNameInfo->handle = LOWORD(ret);
1046             }
1047             else
1048                 pNameInfo->handle = NE_DefResourceHandler( pNameInfo->handle, pModule->self, hRsrc );
1049
1050             if (pNameInfo->handle)
1051             {
1052                 pNameInfo->usage++;
1053                 pNameInfo->flags |= NE_SEGFLAGS_LOADED;
1054             }
1055         }
1056         return pNameInfo->handle;
1057     }
1058     return 0;
1059 }
1060
1061
1062 /**********************************************************************
1063  *          LockResource   (KERNEL.62)
1064  */
1065 SEGPTR WINAPI WIN16_LockResource16( HGLOBAL16 handle )
1066 {
1067     TRACE("(%04x)\n", handle );
1068     /* May need to reload the resource if discarded */
1069     return WOWGlobalLock16( handle );
1070 }
1071
1072
1073 /**********************************************************************
1074  *          LockResource16 (KERNEL32.@)
1075  */
1076 LPVOID WINAPI LockResource16( HGLOBAL16 handle )
1077 {
1078     return MapSL( WIN16_LockResource16(handle) );
1079 }
1080
1081
1082 /**********************************************************************
1083  *          SizeofResource   (KERNEL.65)
1084  */
1085 DWORD WINAPI SizeofResource16( HMODULE16 hModule, HRSRC16 hRsrc )
1086 {
1087     NE_MODULE *pModule = NE_GetPtr( hModule );
1088
1089     TRACE("(%x, %x)\n", hModule, hRsrc );
1090
1091     if (!hRsrc) return 0;
1092     if (!(pModule = get_module( hModule ))) return 0;
1093     if (pModule->ne_rsrctab)
1094     {
1095         WORD sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
1096         NE_NAMEINFO *pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
1097         return (DWORD)pNameInfo->length << sizeShift;
1098     }
1099     if (pModule->module32)
1100     {
1101         /* 32-bit PE module */
1102         return SizeofResource( pModule->module32, MapHRsrc16To32( pModule, hRsrc ) );
1103     }
1104     return 0;
1105 }
1106
1107
1108 typedef WORD (WINAPI *pDestroyIcon32Proc)( HGLOBAL16 handle, UINT16 flags );
1109
1110 /**********************************************************************
1111  *          FreeResource     (KERNEL.63)
1112  */
1113 BOOL16 WINAPI FreeResource16( HGLOBAL16 handle )
1114 {
1115     pDestroyIcon32Proc proc;
1116     HMODULE user;
1117     NE_MODULE *pModule = NE_GetPtr( FarGetOwner16( handle ) );
1118
1119     TRACE("(%04x)\n", handle );
1120
1121     /* Try NE resource first */
1122
1123     if (pModule && pModule->ne_rsrctab)
1124     {
1125         NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2);
1126         while (pTypeInfo->type_id)
1127         {
1128             WORD count;
1129             NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
1130             for (count = pTypeInfo->count; count > 0; count--)
1131             {
1132                 if (pNameInfo->handle == handle)
1133                 {
1134                     if (pNameInfo->usage > 0) pNameInfo->usage--;
1135                     if (pNameInfo->usage == 0)
1136                     {
1137                         GlobalFree16( pNameInfo->handle );
1138                         pNameInfo->handle = 0;
1139                         pNameInfo->flags &= ~NE_SEGFLAGS_LOADED;
1140                     }
1141                     return 0;
1142                 }
1143                 pNameInfo++;
1144             }
1145             pTypeInfo = (NE_TYPEINFO *)pNameInfo;
1146         }
1147     }
1148
1149     /* If this failed, call USER.DestroyIcon32; this will check
1150        whether it is a shared cursor/icon; if not it will call
1151        GlobalFree16() */
1152     user = GetModuleHandleA( "user32.dll" );
1153     if (user && (proc = (pDestroyIcon32Proc)GetProcAddress( user, "DestroyIcon32" )))
1154         return proc( handle, 1 /*CID_RESOURCE*/ );
1155     else
1156         return GlobalFree16( handle );
1157 }