Changeset 4573 for trunk/src


Ignore:
Timestamp:
Nov 9, 2000, 7:15:23 PM (25 years ago)
Author:
sandervl
Message:

Icon api rewrite + small fixes

Location:
trunk/src/user32
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/dc.cpp

    r4558 r4573  
    1 /* $Id: dc.cpp,v 1.76 2000-11-05 18:49:07 sandervl Exp $ */
     1/* $Id: dc.cpp,v 1.77 2000-11-09 18:15:17 sandervl Exp $ */
    22
    33/*
    … …  
    741741   WinShowTrackRect(wnd->getOS2WindowHandle(), FALSE);
    742742
    743    //testestest
    744    if(hwnd == 0x68000019) {
    745         lpps->fErase = 1;
    746    }
    747743   if(wnd->needsEraseBkgnd() && lComplexity != RGN_NULL) {
    748744        wnd->setEraseBkgnd(FALSE);

  • trunk/src/user32/dib.cpp

    r2804 r4573  
    1 /* $Id: dib.cpp,v 1.5 2000-02-16 14:34:16 sandervl Exp $ */
     1/* $Id: dib.cpp,v 1.6 2000-11-09 18:15:18 sandervl Exp $ */
    22
    33/*
    … …  
    2020#include <stdlib.h>
    2121#include <misc.h>
     22#include "dib.h"
    2223
    2324#define DBG_LOCALLOG    DBG_dib
    … …  
    208209
    209210}
     211
     212/***********************************************************************
     213 *           BITMAP_GetWidthBytes
     214 *
     215 * Return number of bytes taken by a scanline of 16-bit aligned Windows DDB
     216 * data.
     217 */
     218int BITMAP_GetWidthBytes( INT bmWidth, INT bpp )
     219{
     220    switch(bpp)
     221    {
     222    case 1:
     223        return 2 * ((bmWidth+15) >> 4);
     224
     225    case 24:
     226        bmWidth *= 3; /* fall through */
     227    case 8:
     228        return bmWidth + (bmWidth & 1);
     229
     230    case 32:
     231        return bmWidth * 4;
     232
     233    case 16:
     234    case 15:
     235        return bmWidth * 2;
     236
     237    case 4:
     238        return 2 * ((bmWidth+3) >> 2);
     239
     240    default:
     241        dprintf(("BITMAP_GetWidthBytes: Unknown depth %d, please report.\n", bpp ));
     242    }
     243    return -1;
     244}

  • trunk/src/user32/dib.h

    r2469 r4573  
    1 /* $Id: dib.h,v 1.3 2000-01-18 20:08:09 sandervl Exp $ */
     1/* $Id: dib.h,v 1.4 2000-11-09 18:15:18 sandervl Exp $ */
    22
    33/*
    … …  
    2525                              int *height, WORD *bpp, WORD *compr );
    2626void DIB_FixColorsToLoadflags(BITMAPINFO * bmi, UINT loadflags, BYTE pix);
     27int  BITMAP_GetWidthBytes( INT width, INT depth );
    2728
    2829#endif

  • trunk/src/user32/loadres.cpp

    r4558 r4573  
    1 /* $Id: loadres.cpp,v 1.32 2000-11-05 18:49:07 sandervl Exp $ */
     1/* $Id: loadres.cpp,v 1.33 2000-11-09 18:15:18 sandervl Exp $ */
    22
    33/*
    … …  
    107107//******************************************************************************
    108108//******************************************************************************
    109 HICON LoadIconA(HINSTANCE hinst, LPCSTR lpszIcon, DWORD cxDesired,
    110                 DWORD cyDesired, DWORD fuLoad)
    111 {
    112  HICON          hIcon;
    113  HANDLE         hMapping = 0;
    114  char          *ptr = NULL;
    115  HRSRC          hRes;
    116  LPSTR          restype = RT_ICONA;
    117 
    118     dprintf(("USER32: LoadIconA %x %x (%d,%d) %x", hinst, lpszIcon, cxDesired, cyDesired, fuLoad));
    119 
    120     if(fuLoad & LR_LOADFROMFILE)
    121     {
    122         hMapping = VIRTUAL_MapFileA( lpszIcon, (LPVOID *)&ptr, TRUE);
    123         if(hMapping == INVALID_HANDLE_VALUE)
    124                 return 0;
    125         hIcon = OSLibWinCreatePointer(ptr);
    126         CloseHandle(hMapping);   
     109HICON WIN32API LoadIconA(HINSTANCE hinst, LPCSTR lpszIcon)
     110{
     111    if(HIWORD(lpszIcon)) {
     112         dprintf(("LoadIconA %x %s", hinst, lpszIcon));
     113    }
     114    else dprintf(("LoadIconA %x %x", hinst, lpszIcon));
     115    return LoadImageA(hinst, lpszIcon, IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE);
     116}
     117//******************************************************************************
     118//******************************************************************************
     119HICON WIN32API LoadIconW(HINSTANCE hinst, LPCWSTR lpszIcon)
     120{
     121    dprintf(("LoadIconA %x %x", hinst, lpszIcon));
     122    return LoadImageW(hinst, lpszIcon, IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE);
     123}
     124//******************************************************************************
     125//******************************************************************************
     126HCURSOR LoadCursorW(HINSTANCE hinst, LPCWSTR lpszCursor, DWORD cxDesired,
     127                    DWORD cyDesired, DWORD fuLoad)
     128{
     129 HCURSOR    hCursor;
     130 HANDLE     hMapping = 0;
     131 char      *ptr = NULL;
     132 HRSRC      hRes;
     133 LPSTR      restype = RT_CURSORA;
     134 LPVOID     lpOS2Resdata = NULL;
     135
     136    if(fuLoad & LR_LOADFROMFILE)
     137    {
     138        hMapping = VIRTUAL_MapFileW( lpszCursor, (LPVOID *)&ptr, TRUE);
     139        if(hMapping == INVALID_HANDLE_VALUE)
     140            return 0;
     141
     142        lpOS2Resdata = ConvertCursorToOS2(ptr);
     143        hCursor = OSLibWinCreatePointer(lpOS2Resdata, cxDesired, cyDesired);
     144        FreeOS2Resource(lpOS2Resdata);
     145
     146        UnmapViewOfFile(ptr);
     147        CloseHandle(hMapping);
    127148    }
    128149    else
    129150    {
    130         if(!hinst)
    131         {
    132                 hRes = FindResourceA(hInstanceUser32,lpszIcon,RT_ICONA);
    133                 if(!hRes)  {
    134                         hRes = FindResourceA(hInstanceUser32,lpszIcon,RT_GROUP_ICONA);
    135                         restype = RT_GROUP_ICONA;
    136                 }
    137                 if(hRes)
    138                 {
    139                         hIcon = OSLibWinCreateIcon(ConvertResourceToOS2(hInstanceUser32, restype, hRes));
    140                 }
    141                 else    hIcon = OSLibWinQuerySysIcon((ULONG)lpszIcon,GetSystemMetrics(SM_CXICON),GetSystemMetrics(SM_CYICON));
    142         }
    143         else
    144         { //not a system icon
    145                 hRes = FindResourceA(hinst,lpszIcon,RT_ICONA);
    146                 if(!hRes)  {
    147                         hRes = FindResourceA(hinst,lpszIcon,RT_GROUP_ICONA);
    148                         restype = RT_GROUP_ICONA;
    149                 }
    150                 if(hRes) {
    151                         hIcon = OSLibWinCreateIcon(ConvertResourceToOS2(hinst, restype, hRes));
    152                 }
    153                 else    hIcon = 0;
    154         }
    155     }
    156     dprintf(("LoadIconA (%X) returned %x\n", hinst, hIcon));
    157 
    158     return(hIcon);
    159 }
    160 //******************************************************************************
    161 //******************************************************************************
    162 HICON LoadIconW(HINSTANCE hinst, LPCWSTR lpszIcon, DWORD cxDesired,
    163                 DWORD cyDesired, DWORD fuLoad)
    164 {
    165  HICON          hIcon;
    166  HANDLE         hMapping = 0;
    167  char          *ptr = NULL;
    168  HRSRC          hRes;
    169  LPSTR          restype = RT_ICONA;
    170 
    171     if(fuLoad & LR_LOADFROMFILE)
    172     {
    173         hMapping = VIRTUAL_MapFileW( lpszIcon, (LPVOID *)&ptr, TRUE);
    174         if(hMapping == INVALID_HANDLE_VALUE)
    175                 return 0;
    176         hIcon = OSLibWinCreatePointer(ptr);
    177         CloseHandle(hMapping);   
    178     }
    179     else
    180     {
    181         if (!hinst)
    182         {
    183                 hRes = FindResourceW(hInstanceUser32,lpszIcon,RT_ICONW);
    184                 if(!hRes)  {
    185                         hRes = FindResourceW(hInstanceUser32,lpszIcon,RT_GROUP_ICONW);
    186                         restype = RT_GROUP_ICONA;
    187                 }
    188                 if(hRes)
    189                 {
    190                         hIcon = OSLibWinCreateIcon(ConvertResourceToOS2(hInstanceUser32, restype, hRes));
    191                 }
    192                 else    hIcon = OSLibWinQuerySysIcon((ULONG)lpszIcon,GetSystemMetrics(SM_CXICON),GetSystemMetrics(SM_CYICON));
    193         }
    194         else
    195         {//not a system icon
    196                 hRes = FindResourceW(hinst,lpszIcon,RT_ICONW);
    197                 if(!hRes)  {
    198                         hRes = FindResourceW(hinst,lpszIcon,RT_GROUP_ICONW);
    199                         restype = RT_GROUP_ICONA;
    200                 }
    201                 if(hRes) {
    202                         hIcon = OSLibWinCreateIcon(ConvertResourceToOS2(hinst, restype, hRes));
    203                 }
    204                 else    hIcon = 0;
    205         }
    206     }
    207     dprintf(("LoadIconW (%X) returned %x\n", hinst, hIcon));
    208 
    209     return(hIcon);
    210 }
    211 //******************************************************************************
    212 //******************************************************************************
    213 HICON WIN32API LoadIconA(HINSTANCE hinst, LPCSTR lpszIcon)
    214 {
    215     return LoadIconA(hinst, lpszIcon, 0, 0, 0);
    216 }
    217 //******************************************************************************
    218 //******************************************************************************
    219 HICON WIN32API LoadIconW(HINSTANCE hinst, LPCWSTR lpszIcon)
    220 {
    221     return LoadIconW(hinst, lpszIcon, 0, 0, 0);
    222 }
    223 //******************************************************************************
    224 //******************************************************************************
    225 HCURSOR LoadCursorA(HINSTANCE hinst, LPCSTR lpszCursor, DWORD cxDesired,
    226                     DWORD cyDesired, DWORD fuLoad)
    227 {
    228  HCURSOR        hCursor;
    229  HANDLE         hMapping = 0;
    230  char          *ptr = NULL;
    231  HRSRC          hRes;
    232  LPSTR          restype = RT_CURSORA;
    233 
    234     if(fuLoad & LR_LOADFROMFILE)
    235     {
    236         hMapping = VIRTUAL_MapFileA( lpszCursor, (LPVOID *)&ptr, TRUE);
    237         if(hMapping == INVALID_HANDLE_VALUE)
    238                 return 0;
    239         hCursor = OSLibWinCreatePointer(ptr);
    240         CloseHandle(hMapping);   
    241     }
    242     else
    243     {
    244         if(!hinst)
    245         {
    246                 hRes = FindResourceA(hInstanceUser32,lpszCursor,RT_CURSORA);
    247                 if(!hRes)  {
    248                         hRes = FindResourceA(hInstanceUser32,lpszCursor,RT_GROUP_CURSORA);
    249                         restype = RT_GROUP_CURSORA;
    250                 }
    251                 if(hRes)
    252                 {
    253                         hCursor = OSLibWinCreatePointer(ConvertResourceToOS2(hInstanceUser32, restype, hRes));
    254                 }
    255                 else    hCursor = OSLibWinQuerySysPointer((ULONG)lpszCursor,GetSystemMetrics(SM_CXCURSOR),GetSystemMetrics(SM_CYCURSOR));
    256         }
    257         else
    258         { //not a system icon
    259                 hRes = FindResourceA(hinst,lpszCursor,RT_CURSORA);
    260                 if(!hRes)  {
    261                         hRes = FindResourceA(hinst,lpszCursor,RT_GROUP_CURSORA);
    262                         restype = RT_GROUP_CURSORA;
    263                 }
    264                 if(hRes) {
    265                         hCursor = OSLibWinCreatePointer(ConvertResourceToOS2(hinst, restype, hRes));
    266                 }
    267                 else    hCursor = 0;
    268         }
    269     }
    270     if(HIWORD(lpszCursor)) {
    271          dprintf(("LoadCursorA %s from %x returned %x\n", lpszCursor, hinst, hCursor));
    272     }
    273     else dprintf(("LoadCursorA %x from %x returned %x\n", lpszCursor, hinst, hCursor));
     151        if(!hinst)
     152        {
     153            hRes = FindResourceW(hInstanceUser32,lpszCursor,RT_CURSORW);
     154            if(!hRes)  {
     155                hRes = FindResourceW(hInstanceUser32,lpszCursor,RT_GROUP_CURSORW);
     156                restype = RT_GROUP_CURSORA;
     157            }
     158            if(hRes)
     159            {
     160                 lpOS2Resdata = ConvertResourceToOS2(hInstanceUser32, restype, hRes);
     161                 hCursor = OSLibWinCreatePointer(lpOS2Resdata, cxDesired, cyDesired);
     162                 FreeOS2Resource(lpOS2Resdata);
     163            }
     164            else hCursor = OSLibWinQuerySysPointer((ULONG)lpszCursor, cxDesired, cyDesired);
     165        }
     166        else
     167        { //not a system icon
     168            hRes = FindResourceW(hinst,lpszCursor,RT_CURSORW);
     169            if(!hRes)  {
     170                hRes = FindResourceW(hinst,lpszCursor,RT_GROUP_CURSORW);
     171                restype = RT_GROUP_CURSORA;
     172            }
     173            if(hRes) {
     174                 lpOS2Resdata = ConvertResourceToOS2(hinst, restype, hRes);
     175                 hCursor = OSLibWinCreatePointer(lpOS2Resdata, cxDesired, cyDesired);
     176                 FreeOS2Resource(lpOS2Resdata);
     177            }
     178            else hCursor = 0;
     179        }
     180    }
     181    dprintf(("LoadCursorA %x from %x returned %x\n", lpszCursor, hinst, hCursor));
    274182
    275183    return(hCursor);
    … …  
    277185//******************************************************************************
    278186//******************************************************************************
    279 HCURSOR LoadCursorW(HINSTANCE hinst, LPCWSTR lpszCursor, DWORD cxDesired,
    280                     DWORD cyDesired, DWORD fuLoad)
    281 {
    282  HCURSOR        hCursor;
    283  HANDLE         hMapping = 0;
    284  char          *ptr = NULL;
    285  HRSRC          hRes;
    286  LPSTR          restype = RT_CURSORA;
    287 
    288     if(fuLoad & LR_LOADFROMFILE)
    289     {
    290         hMapping = VIRTUAL_MapFileW( lpszCursor, (LPVOID *)&ptr, TRUE);
    291         if(hMapping == INVALID_HANDLE_VALUE)
    292                 return 0;
    293         hCursor = OSLibWinCreatePointer(ptr);
    294         CloseHandle(hMapping);   
    295     }
    296     else
    297     {
    298         if(!hinst)
    299         {
    300                 hRes = FindResourceW(hInstanceUser32,lpszCursor,RT_CURSORW);
    301                 if(!hRes)  {
    302                         hRes = FindResourceW(hInstanceUser32,lpszCursor,RT_GROUP_CURSORW);
    303                         restype = RT_GROUP_CURSORA;
    304                 }
    305                 if(hRes)
    306                 {
    307                         hCursor = OSLibWinCreatePointer(ConvertResourceToOS2(hInstanceUser32, restype, hRes));
    308                 }
    309                 else    hCursor = OSLibWinQuerySysPointer((ULONG)lpszCursor,GetSystemMetrics(SM_CXCURSOR),GetSystemMetrics(SM_CYCURSOR));
    310         }
    311         else
    312         { //not a system icon
    313                 hRes = FindResourceW(hinst,lpszCursor,RT_CURSORW);
    314                 if(!hRes)  {
    315                         hRes = FindResourceW(hinst,lpszCursor,RT_GROUP_CURSORW);
    316                         restype = RT_GROUP_CURSORA;
    317                 }
    318                 if(hRes) {
    319                         hCursor = OSLibWinCreatePointer(ConvertResourceToOS2(hinst, restype, hRes));
    320                 }
    321                 else    hCursor = 0;
    322         }
    323     }
    324     dprintf(("LoadCursorW (%X) returned %x\n", hinst, hCursor));
    325 
    326     return(hCursor);
    327 }
    328 //******************************************************************************
    329 //******************************************************************************
    330187HCURSOR WIN32API LoadCursorA(HINSTANCE hinst, LPCSTR lpszCursor)
    331188{
    332     return LoadCursorA(hinst, lpszCursor, 0, 0, 0);
     189    return LoadImageA(hinst, lpszCursor, IMAGE_CURSOR, 0, 0,
     190                      LR_SHARED | LR_DEFAULTSIZE );
    333191}
    334192//******************************************************************************
    … …  
    336194HCURSOR WIN32API LoadCursorW(HINSTANCE hinst, LPCWSTR lpszCursor)
    337195{
    338     return LoadCursorW(hinst, lpszCursor, 0, 0, 0);
    339 }
    340 //******************************************************************************
    341 //******************************************************************************
    342 BOOL IsSystemBitmap(ULONG id)
    343 {
    344    switch(id)
    345    {
    346         case OBM_UPARROW:
    347         case OBM_DNARROW:
    348         case OBM_RGARROW:
    349         case OBM_LFARROW:
    350         case OBM_RESTORE:
    351         case OBM_RESTORED:
    352         case OBM_UPARROWD:
    353         case OBM_DNARROWD:
    354         case OBM_RGARROWD:
    355         case OBM_LFARROWD:
    356         case OBM_OLD_UPARROW:
    357         case OBM_OLD_DNARROW:
    358         case OBM_OLD_RGARROW:
    359         case OBM_OLD_LFARROW:
    360         case OBM_CHECK:
    361         case OBM_RADIOCHECK:
    362         case OBM_CHECKBOXES:
    363         case OBM_BTNCORNERS:
    364         case OBM_COMBO:
    365         case OBM_REDUCE:
    366         case OBM_REDUCED:
    367         case OBM_ZOOM:
    368         case OBM_ZOOMD:
    369         case OBM_SIZE:
    370         case OBM_CLOSE:
    371         case OBM_MNARROW:
    372         case OBM_UPARROWI:
    373         case OBM_DNARROWI:
    374         case OBM_RGARROWI:
    375         case OBM_LFARROWI:
    376         case OBM_CLOSED:
    377         case OBM_OLD_CLOSE:
    378         case OBM_BTSIZE:
    379         case OBM_OLD_REDUCE:
    380         case OBM_OLD_ZOOM:
    381         case OBM_OLD_RESTORE:
    382         case OBM_CONTEXTHELP:
    383         case OBM_CONTEXTHELPD:
    384         case OBM_TRTYPE:
    385                 return TRUE;
    386 
    387         default:
    388                 return FALSE;
    389    }
    390 }
    391 //******************************************************************************
    392 //NOTE: LR_CREATEDIBSECTION flag doesn't work (crash in GDI32)!
    393 //******************************************************************************
    394 HANDLE LoadBitmapA(HINSTANCE hinst, LPCSTR lpszName, int cxDesired, int cyDesired,
     196    return LoadImageW(hinst, lpszCursor, IMAGE_CURSOR, 0, 0,
     197                      LR_SHARED | LR_DEFAULTSIZE );
     198}
     199/***********************************************************************
     200*            LoadCursorFromFileW    (USER32.361)
     201*/
     202HCURSOR WIN32API LoadCursorFromFileW (LPCWSTR name)
     203{
     204    return LoadImageW(0, name, IMAGE_CURSOR, 0, 0,
     205                      LR_LOADFROMFILE | LR_DEFAULTSIZE );
     206}
     207/***********************************************************************
     208*            LoadCursorFromFileA    (USER32.360)
     209*/
     210HCURSOR WIN32API LoadCursorFromFileA (LPCSTR name)
     211{
     212    return LoadImageA(0, name, IMAGE_CURSOR, 0, 0,
     213                      LR_LOADFROMFILE | LR_DEFAULTSIZE );
     214}
     215//******************************************************************************
     216//NOTE: LR_CREATEDIBSECTION flag doesn't work (crash in GDI32)! (still??)
     217//******************************************************************************
     218HANDLE LoadBitmapW(HINSTANCE hinst, LPCWSTR lpszName, int cxDesired, int cyDesired,
    395219                   UINT fuLoad)
    396220{
    … …  
    404228    int size;
    405229
    406     if (!(fuLoad & LR_LOADFROMFILE)) {
    407       if (!(hRsrc = FindResourceA( hinst, lpszName, RT_BITMAPA ))) return 0;
    408       if (!(handle = LoadResource( hinst, hRsrc ))) return 0;
    409 
    410       if ((info = (BITMAPINFO *)LockResource( handle )) == NULL) return 0;
     230    if (!(fuLoad & LR_LOADFROMFILE))
     231    {
     232        handle = 0;
     233        if(!hinst)
     234        {
     235            hRsrc = FindResourceW( hInstanceUser32, lpszName, RT_BITMAPW );
     236            if(hRsrc) {
     237                handle = LoadResource( hInstanceUser32, hRsrc );
     238            }
     239        }
     240        if(handle == 0)
     241        {
     242            if (!(hRsrc = FindResourceW( hinst, lpszName, RT_BITMAPW ))) return 0;
     243            if (!(handle = LoadResource( hinst, hRsrc ))) return 0;
     244        }
     245
     246        if ((info = (BITMAPINFO *)LockResource( handle )) == NULL) return 0;
    411247    }
    412248    else
    413249    {
    414         hMapping = VIRTUAL_MapFileA( lpszName, (LPVOID *)&ptr, TRUE);
     250        hMapping = VIRTUAL_MapFileW( lpszName, (LPVOID *)&ptr, TRUE);
    415251        if (hMapping == INVALID_HANDLE_VALUE) {
    416                 //TODO: last err set to ERROR_OPEN_FAILED if file not found; correct??
    417                 dprintf(("LoadBitmapA: failed to load file %s (lasterr=%x)", lpszName, GetLastError()));
    418                 return 0;
    419         }
     252            //TODO: last err set to ERROR_OPEN_FAILED if file not found; correct??
     253            dprintf(("LoadBitmapW: failed to load file %x (lasterr=%x)", lpszName, GetLastError()));
     254            return 0;
     255        }
    420256        info = (BITMAPINFO *)(ptr + sizeof(BITMAPFILEHEADER));
    421257    }
    … …  
    482318                hbitmap = CreateDIBitmap(hdc, &fix_info->bmiHeader, CBM_INIT,
    483319                                         bits, fix_info, DIB_RGB_COLORS );
    484                 if(hbitmap == 0) {
    485                         dprintf(("LoadBitmapA: CreateDIBitmap failed!!"));
    486                 }
     320        if(hbitmap == 0) {
     321            dprintf(("LoadBitmapW: CreateDIBitmap failed!!"));
     322        }
    487323//        }
    488324        }
    … …  
    492328      GlobalFree(hFix);
    493329    }
    494     if (fuLoad & LR_LOADFROMFILE) CloseHandle( hMapping );
     330    if(fuLoad & LR_LOADFROMFILE) {
     331        UnmapViewOfFile(ptr);
     332        CloseHandle(hMapping);
     333    }
    495334    return hbitmap;
    496335}
    497336//******************************************************************************
     337//TODO: scale bitmap
     338//******************************************************************************
     339HANDLE CopyBitmap(HANDLE hBitmap, DWORD desiredx, DWORD desiredy)
     340{
     341    HBITMAP res = 0;
     342    BITMAP bm;
     343
     344    if(GetObjectA(hBitmap, sizeof(BITMAP), &bm) == FALSE) {
     345        dprintf(("CopyBitmap: GetObject failed!!"));
     346        return 0;
     347    }
     348
     349    bm.bmBits = NULL;
     350    res = CreateBitmapIndirect(&bm);
     351
     352    if(res)
     353    {
     354        char *buf = (char *)HeapAlloc( GetProcessHeap(), 0, bm.bmWidthBytes *
     355                                       bm.bmHeight );
     356        GetBitmapBits (hBitmap, bm.bmWidthBytes * bm.bmHeight, buf);
     357        SetBitmapBits (res, bm.bmWidthBytes * bm.bmHeight, buf);
     358        HeapFree( GetProcessHeap(), 0, buf );
     359    }
     360    return res;
     361}
     362//******************************************************************************
    498363//TODO: No support for RT_NEWBITMAP
    499364//******************************************************************************
    … …  
    502367 HBITMAP hBitmap = 0;
    503368
    504   if (!hinst)
    505   {
    506     if(IsSystemBitmap((ULONG)lpszBitmap))
    507     {
    508          hBitmap =  LoadBitmapA(hInstanceUser32, lpszBitmap, 0, 0, 0);
    509     }
    510   }
    511   if(!hBitmap)
    512         hBitmap = LoadBitmapA(hinst, lpszBitmap, 0, 0, 0);
     369  hBitmap = LoadImageA(hinst, lpszBitmap, IMAGE_BITMAP, 0, 0, 0);
    513370
    514371  if(HIWORD(lpszBitmap)) {
    515         dprintf(("LoadBitmapA %x %s returned %08xh\n", hinst, lpszBitmap, hBitmap));
     372        dprintf(("LoadBitmapA %x %s returned %08xh\n", hinst, lpszBitmap, hBitmap));
    516373  }
    517374  else  dprintf(("LoadBitmapA %x %x returned %08xh\n", hinst, lpszBitmap, hBitmap));
    … …  
    526383 HBITMAP hBitmap = 0;
    527384
    528   if(HIWORD(lpszBitmap) != 0)
    529     lpszBitmap = (LPWSTR)UnicodeToAsciiString((LPWSTR)lpszBitmap);
    530 
    531   hBitmap = LoadBitmapA((hinst == 0) ? hInstanceUser32:hinst, (LPSTR)lpszBitmap, 0, 0, 0);
    532 
    533   if(HIWORD(lpszBitmap) != 0)
    534     FreeAsciiString((LPSTR)lpszBitmap);
     385  hBitmap = LoadBitmapW((hinst == 0) ? hInstanceUser32:hinst, lpszBitmap, 0, 0, 0);
    535386
    536387  if(HIWORD(lpszBitmap)) {
    537         dprintf(("LoadBitmapW %x %s returned %08xh\n", hinst, lpszBitmap, hBitmap));
     388        dprintf(("LoadBitmapW %x %s returned %08xh\n", hinst, lpszBitmap, hBitmap));
    538389  }
    539390  else  dprintf(("LoadBitmapW %x %x returned %08xh\n", hinst, lpszBitmap, hBitmap));
    … …  
    542393}
    543394//******************************************************************************
    544 //TODO: Far from complete, but works for loading resources from exe
    545 //fuLoad flag ignored
    546395//******************************************************************************
    547396HANDLE WIN32API LoadImageA(HINSTANCE hinst, LPCSTR lpszName, UINT uType,
    548397                           int cxDesired, int cyDesired, UINT fuLoad)
    549398{
     399 HANDLE res = 0;
     400 LPCWSTR u_name;
     401
     402  if(HIWORD(lpszName)) {
     403        dprintf(("LoadImageA %x %s %d (%d,%d)\n", hinst, lpszName, uType, cxDesired, cyDesired));
     404  }
     405  else  dprintf(("LoadImageA %x %x %d (%d,%d)\n", hinst, lpszName, uType, cxDesired, cyDesired));
     406
     407  if (HIWORD(lpszName)) {
     408        u_name = HEAP_strdupAtoW(GetProcessHeap(), 0, lpszName);
     409  }
     410  else  u_name=(LPWSTR)lpszName;
     411
     412  res = LoadImageW(hinst, u_name, uType, cxDesired, cyDesired, fuLoad);
     413
     414  if (HIWORD(lpszName))
     415        HeapFree(GetProcessHeap(), 0, (LPVOID)u_name);
     416
     417  return res;
     418}
     419//******************************************************************************
     420//******************************************************************************
     421HANDLE WIN32API LoadImageW(HINSTANCE hinst, LPCWSTR lpszName, UINT uType,
     422                           int cxDesired, int cyDesired, UINT fuLoad)
     423{
    550424 HANDLE hRet = 0;
    551425
    552   if(HIWORD(lpszName)) {
    553         dprintf(("LoadImageA NOT COMPLETE %x %s %d (%d,%d)\n", hinst, lpszName, uType, cxDesired, cyDesired));
    554   }
    555   else  dprintf(("LoadImageA NOT COMPLETE %x %x %d (%d,%d)\n", hinst, lpszName, uType, cxDesired, cyDesired));
    556 
    557   if(fuLoad & LR_DEFAULTSIZE) {
    558         if (uType == IMAGE_ICON) {
    559             if (!cxDesired) cxDesired = GetSystemMetrics(SM_CXICON);
    560             if (!cyDesired) cyDesired = GetSystemMetrics(SM_CYICON);
    561         }
    562         else if (uType == IMAGE_CURSOR) {
    563             if (!cxDesired) cxDesired = GetSystemMetrics(SM_CXCURSOR);
    564             if (!cyDesired) cyDesired = GetSystemMetrics(SM_CYCURSOR);
    565         }
    566   }
    567   if (fuLoad & LR_LOADFROMFILE) fuLoad &= ~LR_SHARED;
    568 
    569   switch(uType) {
    570         case IMAGE_BITMAP:
    571                 hRet = (HANDLE)LoadBitmapA(hinst, lpszName, cxDesired, cyDesired, fuLoad);
    572                 break;
    573         case IMAGE_CURSOR:
    574                 hRet = (HANDLE)LoadCursorA(hinst, lpszName, cxDesired, cyDesired, fuLoad);
    575                 break;
    576         case IMAGE_ICON:
    577                 hRet = (HANDLE)LoadIconA(hinst, lpszName, cxDesired, cyDesired, fuLoad);
    578                 break;
    579         default:
    580                 dprintf(("LoadImageA: unsupported type %d!!", uType));
    581                 return 0;
    582   }
    583   dprintf(("LoadImageA returned %x\n", (int)hRet));
    584 
    585   return(hRet);
    586 }
    587 //******************************************************************************
    588 //******************************************************************************
    589 HANDLE WIN32API LoadImageW(HINSTANCE hinst, LPCWSTR lpszName, UINT uType,
    590                               int cxDesired, int cyDesired, UINT fuLoad)
    591 {
    592  HANDLE hRet = 0;
    593 
    594   dprintf(("LoadImageW NOT COMPLETE (%d,%d)\n", cxDesired, cyDesired));
     426  dprintf(("LoadImageW %x %x %d (%d,%d)\n", hinst, lpszName, uType, cxDesired, cyDesired));
    595427
    596428  if (fuLoad & LR_DEFAULTSIZE) {
    … …  
    606438  if (fuLoad & LR_LOADFROMFILE) fuLoad &= ~LR_SHARED;
    607439
    608   switch(uType) {
     440  switch (uType)
     441  {
    609442        case IMAGE_BITMAP:
    610                 hRet = (HANDLE)LoadBitmapW(hinst, lpszName);
    611                 break;
     443        {
     444            hRet = (HANDLE)LoadBitmapW(hinst, lpszName, cxDesired, cyDesired, fuLoad);
     445            break;
     446        }
     447        case IMAGE_ICON:
     448        {
     449            HDC hdc = GetDC(0);
     450            UINT palEnts = GetSystemPaletteEntries(hdc, 0, 0, NULL);
     451            if (palEnts == 0)
     452                palEnts = 256;
     453            ReleaseDC(0, hdc);
     454
     455            hRet = CURSORICON_Load(hinst, lpszName, cxDesired, cyDesired,  palEnts, FALSE, fuLoad);
     456            break;
     457        }
     458
    612459        case IMAGE_CURSOR:
    613                 hRet = (HANDLE)LoadCursorW(hinst, lpszName, cxDesired, cyDesired, fuLoad);
    614                 break;
    615         case IMAGE_ICON:
    616                 hRet = (HANDLE)LoadIconW(hinst, lpszName, cxDesired, cyDesired, fuLoad);
    617                 break;
     460            hRet = (HANDLE)LoadCursorW(hinst, lpszName, cxDesired, cyDesired, fuLoad);
     461            break;
     462//            return CURSORICON_Load(hinst, name, desiredx, desiredy, 1, TRUE, loadflags);
     463
    618464        default:
    619465                dprintf(("LoadImageW: unsupported type %d!!", uType));
    … …  
    642488 *
    643489 */
    644 HICON WINAPI CopyImage( HANDLE hnd, UINT type, INT desiredx,
    645                              INT desiredy, UINT flags )
     490HICON WINAPI CopyImage(HANDLE hnd, UINT type, INT desiredx,
     491                       INT desiredy, UINT flags )
    646492{
    647493    dprintf(("CopyImage %x %d (%d,%d) %x", hnd, type, desiredx, desiredy, flags));
    648494    switch (type)
    649495    {
    650 //      case IMAGE_BITMAP:
    651 //              return BITMAP_CopyBitmap(hnd);
     496        case IMAGE_BITMAP:
     497                return CopyBitmap(hnd, desiredx, desiredy);
    652498        case IMAGE_ICON:
    653                 return CopyIcon(hnd);
     499                return (HANDLE)CURSORICON_ExtCopy(hnd, type, desiredx, desiredy, flags);
    654500        case IMAGE_CURSOR:
    655                 return CopyCursor(hnd);
     501        /* Should call CURSORICON_ExtCopy but more testing
     502         * needs to be done before we change this
     503         */
     504                return O32_CopyCursor(hnd);
    656505//              return CopyCursorIcon(hnd,type, desiredx, desiredy, flags);
    657506        default:

  • trunk/src/user32/oslibres.cpp

    r3101 r4573  
    1 /* $Id: oslibres.cpp,v 1.10 2000-03-13 13:10:47 sandervl Exp $ */
     1/* $Id: oslibres.cpp,v 1.11 2000-11-09 18:15:18 sandervl Exp $ */
    22/*
    33 * Window API wrappers for OS/2
    … …  
    2424#include "pmwindow.h"
    2525
    26 #define DBG_LOCALLOG    DBG_oslibres
     26#define DBG_LOCALLOG    DBG_oslibres
    2727#include "dbglocal.h"
    2828
    … …  
    4646}
    4747//******************************************************************************
    48 //******************************************************************************
    49 HANDLE OSLibWinCreateIcon(PVOID iconbitmap)
     48//TODO: change search method for icon array (cxDesired, cyDesired)
     49//TODO: PM rescales the icon internally!!! ($W(#*&$(*%&)
     50//******************************************************************************
     51HANDLE OSLibWinCreateIcon(PVOID iconbitmap, ULONG cxDesired, ULONG cyDesired)
    5052{
    5153 POINTERINFO pointerInfo = {0};
    … …  
    102104    hps = WinGetScreenPS(HWND_DESKTOP);
    103105
    104     hbmColor = GpiCreateBitmap(hps, &bfhColor->bmp2, CBM_INIT,
    105                                (char *)bafh + bfhColor->offBits,
    106                                (BITMAPINFO2 *)&bfhColor->bmp2);
     106    //Resize icon bitmap if requested size is different
     107    if(cxDesired != bfhColor->bmp2.cx|| cyDesired != bfhColor->bmp2.cy)
     108    {
     109        BITMAPINFOHEADER2 infohdr = bfhColor->bmp2;
     110
     111        infohdr.cx = cxDesired;
     112        infohdr.cy = cyDesired;
     113        hbmColor = GpiCreateBitmap(hps, &infohdr, CBM_INIT,
     114                                   (char *)bafh + bfhColor->offBits,
     115                                   (BITMAPINFO2 *)&bfhColor->bmp2);
     116    }
     117    else {
     118        hbmColor = GpiCreateBitmap(hps, &bfhColor->bmp2, CBM_INIT,
     119                                   (char *)bafh + bfhColor->offBits,
     120                                   (BITMAPINFO2 *)&bfhColor->bmp2);
     121    }
    107122    if(hbmColor == GPI_ERROR) {
    108123        dprintf(("OSLibWinCreateIcon: GpiCreateBitmap failed!"));
    … …  
    110125        return 0;
    111126    }
    112     hbmMask = GpiCreateBitmap(hps, &bfhBW->bmp2, CBM_INIT,
    113                               (char *)bafh + bfhBW->offBits,
    114                               (BITMAPINFO2 *)&bfhBW->bmp2);
     127    //Resize icon mask if requested size is different
     128    if(cxDesired != bfhBW->bmp2.cx|| cyDesired*2 != bfhBW->bmp2.cy)
     129    {
     130        BITMAPINFOHEADER2 infohdr = bfhBW->bmp2;
     131
     132        infohdr.cx = cxDesired;
     133        infohdr.cy = cyDesired;
     134        hbmMask = GpiCreateBitmap(hps, &infohdr, CBM_INIT,
     135                                  (char *)bafh + bfhBW->offBits,
     136                                  (BITMAPINFO2 *)&bfhBW->bmp2);
     137    }
     138    else {
     139        hbmMask = GpiCreateBitmap(hps, &bfhBW->bmp2, CBM_INIT,
     140                                  (char *)bafh + bfhBW->offBits,
     141                                  (BITMAPINFO2 *)&bfhBW->bmp2);
     142    }
    115143    if(hbmMask == GPI_ERROR) {
    116144        dprintf(("OSLibWinCreateIcon: GpiCreateBitmap hbmMask failed!"));
    … …  
    132160    GpiDeleteBitmap(hbmColor);
    133161    WinReleasePS(hps);
     162
    134163    return hIcon;
    135164}
    136165//******************************************************************************
    137 //******************************************************************************
    138 HANDLE OSLibWinCreatePointer(PVOID cursorbitmap)
     166//TODO: change cursor size if required!! (cxDesired, cyDesired)
     167//******************************************************************************
     168HANDLE OSLibWinCreatePointer(PVOID cursorbitmap, ULONG cxDesired, ULONG cyDesired)
    139169{
    140170 POINTERINFO pointerInfo = {0};

  • trunk/src/user32/oslibres.h

    r2469 r4573  
    1 /* $Id: oslibres.h,v 1.4 2000-01-18 20:08:12 sandervl Exp $ */
     1/* $Id: oslibres.h,v 1.5 2000-11-09 18:15:18 sandervl Exp $ */
    22/*
    33 * Window GUI resource wrapper functions for OS/2
    … …  
    1818
    1919HANDLE  OSLibWinSetAccelTable(HWND hwnd, HANDLE hAccel, PVOID acceltemplate);
    20 HANDLE  OSLibWinCreateIcon(PVOID iconbitmap);
    21 HANDLE  OSLibWinCreatePointer(PVOID cursorbitmap);
     20HANDLE  OSLibWinCreateIcon(PVOID iconbitmap, ULONG cxDesired, ULONG cyDesired);
     21HANDLE  OSLibWinCreatePointer(PVOID cursorbitmap, ULONG cxDesired, ULONG cyDesired);
    2222HANDLE  OSLibWinQuerySysPointer(ULONG type,INT w,INT h);
    2323HANDLE  OSLibWinQuerySysIcon(ULONG type,INT w,INT h);

  • trunk/src/user32/user32.cpp

    r4554 r4573  
    1 /* $Id: user32.cpp,v 1.86 2000-11-05 13:39:50 sandervl Exp $ */
     1/* $Id: user32.cpp,v 1.87 2000-11-09 18:15:18 sandervl Exp $ */
    22
    33/*
    … …  
    368368    } else return FALSE;
    369369}
    370 /*****************************************************************************
    371  * Name      : HCURSOR WIN32API LoadCursorFromFileA
    372  * Purpose   : The LoadCursorFromFile function creates a cursor based on data
    373  *             contained in a file. The file is specified by its name or by a
    374  *             system cursor identifier. The function returns a handle to the
    375  *             newly created cursor. Files containing cursor data may be in
    376  *             either cursor (.CUR) or animated cursor (.ANI) format.
    377  * Parameters: LPCTSTR  lpFileName pointer to cursor file, or system cursor id
    378  * Variables :
    379  * Result    : If the function is successful, the return value is a handle to
    380  *               the new cursor.
    381  *             If the function fails, the return value is NULL. To get extended
    382  *               error information, call GetLastError. GetLastError may return
    383  *               the following
    384  * Remark    :
    385  * Status    : UNTESTED STUB
    386  *
    387  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    388  *****************************************************************************/
    389 HCURSOR WIN32API LoadCursorFromFileA(LPCTSTR lpFileName)
    390 {
    391   if (!HIWORD(lpFileName))
    392   {
    393     return LoadCursorA(NULL,lpFileName);
    394   }
    395   else
    396   {
    397     dprintf(("USER32:LoadCursorFromFileA (%s) not implemented.\n",
    398            lpFileName));
    399 
    400     return (NULL);
    401   }
    402 }
    403 /*****************************************************************************
    404  * Name      : HCURSOR WIN32API LoadCursorFromFileW
    405  * Purpose   : The LoadCursorFromFile function creates a cursor based on data
    406  *             contained in a file. The file is specified by its name or by a
    407  *             system cursor identifier. The function returns a handle to the
    408  *             newly created cursor. Files containing cursor data may be in
    409  *             either cursor (.CUR) or animated cursor (.ANI) format.
    410  * Parameters: LPCTSTR  lpFileName pointer to cursor file, or system cursor id
    411  * Variables :
    412  * Result    : If the function is successful, the return value is a handle to
    413  *               the new cursor.
    414  *             If the function fails, the return value is NULL. To get extended
    415  *               error information, call GetLastError. GetLastError may return
    416  *               the following
    417  * Remark    :
    418  * Status    : UNTESTED STUB
    419  *
    420  * Author    : Patrick Haller [Thu, 1998/02/26 11:55]
    421  *****************************************************************************/
    422 HCURSOR WIN32API LoadCursorFromFileW(LPCWSTR lpFileName)
    423 {
    424   if (!HIWORD(lpFileName))
    425   {
    426     return LoadCursorW(NULL,lpFileName);
    427   } else
    428   {
    429     dprintf(("USER32:LoadCursorFromFileW (%s) not implemented.\n",
    430            lpFileName));
    431 
    432     return (NULL);
    433   }
    434 }
    435370//******************************************************************************
    436371//******************************************************************************

  • trunk/src/user32/user32rsrc.orc

    r4494 r4573  
    1 /* $Id: user32rsrc.orc,v 1.3 2000-10-17 17:11:08 sandervl Exp $ */
     1/* $Id: user32rsrc.orc,v 1.4 2000-11-09 18:15:21 sandervl Exp $ */
    22/* converted from WINE */
    33
    … …  
    827827#define OIC_HDISK           32524
    828828#define OIC_NETWORK         32525
     829
     830OIC_SAMPLE    ICON LOADONCALL DISCARDABLE "bmp\oic_sample.ico"
     831OIC_HAND      ICON LOADONCALL DISCARDABLE "bmp\oic_hand_95.ico"
     832
     833OIC_QUES      ICON LOADONCALL DISCARDABLE "bmp\oic_ques_95.ico"
     834//OIC_BANG      ICON LOADONCALL DISCARDABLE "bmp\oic_bang_95.ico"
     835
     836/* folder */
     837OIC_BANG       ICON
     838{'
     83900 00 01 00 02 00 20 20 00 00 00 00 00 00 a8 08
     84000 00 26 00 00 00 10 10 00 00 00 00 00 00 68 05
     84100 00 ce 08 00 00 28 00 00 00 20 00 00 00 40 00
     84200 00 01 00 08 00 00 00 00 00 80 04 00 00 00 00
     84300 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     84400 00 00 00 80 00 00 80 00 00 00 80 80 00 80 00
     84500 00 80 00 80 00 80 80 00 00 c0 c0 c0 00 c0 dc
     846c0 00 f0 ca a6 00 04 04 04 00 08 08 08 00 0c 0c
     8470c 00 11 11 11 00 16 16 16 00 1c 1c 1c 00 22 22
     84822 00 29 29 29 00 55 55 55 00 4d 4d 4d 00 42 42
     84942 00 39 39 39 00 80 7c ff 00 50 50 ff 00 93 00
     850d6 00 ff ec cc 00 c6 d6 ef 00 d6 e7 e7 00 90 a9
     851ad 00 00 00 33 00 00 00 66 00 00 00 99 00 00 00
     852cc 00 00 33 00 00 00 33 33 00 00 33 66 00 00 33
     85399 00 00 33 cc 00 00 33 ff 00 00 66 00 00 00 66
     85433 00 00 66 66 00 00 66 99 00 00 66 cc 00 00 66
     855ff 00 00 99 00 00 00 99 33 00 00 99 66 00 00 99
     85699 00 00 99 cc 00 00 99 ff 00 00 cc 00 00 00 cc
     85733 00 00 cc 66 00 00 cc 99 00 00 cc cc 00 00 cc
     858ff 00 00 ff 66 00 00 ff 99 00 00 ff cc 00 33 00
     85900 00 33 00 33 00 33 00 66 00 33 00 99 00 33 00
     860cc 00 33 00 ff 00 33 33 00 00 33 33 33 00 33 33
     86166 00 33 33 99 00 33 33 cc 00 33 33 ff 00 33 66
     86200 00 33 66 33 00 33 66 66 00 33 66 99 00 33 66
     863cc 00 33 66 ff 00 33 99 00 00 33 99 33 00 33 99
     86466 00 33 99 99 00 33 99 cc 00 33 99 ff 00 33 cc
     86500 00 33 cc 33 00 33 cc 66 00 33 cc 99 00 33 cc
     866cc 00 33 cc ff 00 33 ff 33 00 33 ff 66 00 33 ff
     86799 00 33 ff cc 00 33 ff ff 00 66 00 00 00 66 00
     86833 00 66 00 66 00 66 00 99 00 66 00 cc 00 66 00
     869ff 00 66 33 00 00 66 33 33 00 66 33 66 00 66 33
     87099 00 66 33 cc 00 66 33 ff 00 66 66 00 00 66 66
     87133 00 66 66 66 00 66 66 99 00 66 66 cc 00 66 99
     87200 00 66 99 33 00 66 99 66 00 66 99 99 00 66 99
     873cc 00 66 99 ff 00 66 cc 00 00 66 cc 33 00 66 cc
     87499 00 66 cc cc 00 66 cc ff 00 66 ff 00 00 66 ff
     87533 00 66 ff 99 00 66 ff cc 00 cc 00 ff 00 ff 00
     876cc 00 99 99 00 00 99 33 99 00 99 00 99 00 99 00
     877cc 00 99 00 00 00 99 33 33 00 99 00 66 00 99 33
     878cc 00 99 00 ff 00 99 66 00 00 99 66 33 00 99 33
     87966 00 99 66 99 00 99 66 cc 00 99 33 ff 00 99 99
     88033 00 99 99 66 00 99 99 99 00 99 99 cc 00 99 99
     881ff 00 99 cc 00 00 99 cc 33 00 66 cc 66 00 99 cc
     88299 00 99 cc cc 00 99 cc ff 00 99 ff 00 00 99 ff
     88333 00 99 cc 66 00 99 ff 99 00 99 ff cc 00 99 ff
     884ff 00 cc 00 00 00 99 00 33 00 cc 00 66 00 cc 00
     88599 00 cc 00 cc 00 99 33 00 00 cc 33 33 00 cc 33
     88666 00 cc 33 99 00 cc 33 cc 00 cc 33 ff 00 cc 66
     88700 00 cc 66 33 00 99 66 66 00 cc 66 99 00 cc 66
     888cc 00 99 66 ff 00 cc 99 00 00 cc 99 33 00 cc 99
     88966 00 cc 99 99 00 cc 99 cc 00 cc 99 ff 00 cc cc
     89000 00 cc cc 33 00 cc cc 66 00 cc cc 99 00 cc cc
     891cc 00 cc cc ff 00 cc ff 00 00 cc ff 33 00 99 ff
     89266 00 cc ff 99 00 cc ff cc 00 cc ff ff 00 cc 00
     89333 00 ff 00 66 00 ff 00 99 00 cc 33 00 00 ff 33
     89433 00 ff 33 66 00 ff 33 99 00 ff 33 cc 00 ff 33
     895ff 00 ff 66 00 00 ff 66 33 00 cc 66 66 00 ff 66
     89699 00 ff 66 cc 00 cc 66 ff 00 ff 99 00 00 ff 99
     89733 00 ff 99 66 00 ff 99 99 00 ff 99 cc 00 ff 99
     898ff 00 ff cc 00 00 ff cc 33 00 ff cc 66 00 ff cc
     89999 00 ff cc cc 00 ff cc ff 00 ff ff 33 00 cc ff
     90066 00 ff ff 99 00 ff ff cc 00 66 66 ff 00 66 ff
     90166 00 66 ff ff 00 ff 66 66 00 ff 66 ff 00 ff ff
     90266 00 21 00 a5 00 5f 5f 5f 00 77 77 77 00 86 86
     90386 00 96 96 96 00 cb cb cb 00 b2 b2 b2 00 d7 d7
     904d7 00 dd dd dd 00 e3 e3 e3 00 ea ea ea 00 f1 f1
     905f1 00 f8 f8 f8 00 f0 fb ff 00 a4 a0 a0 00 80 80
     90680 00 00 00 ff 00 00 ff 00 00 00 ff ff 00 ff 00
     90700 00 ff 00 ff 00 ff ff 00 00 ff ff ff 00 00 00
     90800 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     90900 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     91000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     91100 00 6d 92 00 86 00 00 00 00 00 00 00 00 00 00
     91200 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     91392 6d d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     91400 00 00 00 00 00 00 00 00 00 00 00 00 00 92 6d
     915d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     91600 00 00 00 00 00 00 00 00 00 00 00 6d 92 d6 d6
     917d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     91800 00 00 00 00 00 00 00 00 00 6d 92 d6 d6 dd d6
     919d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     92000 00 00 00 00 00 00 00 92 6d d6 dd d6 d6 d6 d6
     921d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     92200 00 00 00 00 00 92 6d dd d6 d6 d6 d6 d6 d6 d6
     923d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     92400 00 00 00 6d 92 dd d6 d6 dd dd d6 d6 dd d6 d6
     925d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     92600 00 6d 92 dd dd dd dd dd d6 dd d6 d6 d6 d6 d6
     927d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     92892 6d dd dd dd d6 dd d6 dd dd d6 dd dd d6 d6 d6
     929d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     930dd dd dd dd dd dd d6 dd dd d6 dd d6 dd d6 d6 d6
     931d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     932dd dd dd dd dd dd dd dd dd dd dd dd d6 dd d6 dd
     933d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     934dd dd dd dd dd dd dd d6 dd dd d6 d6 dd d6 d6 d6
     935d6 d6 d6 d6 00 86 00 00 00 00 00 00 00 00 00 00
     936dd dd dd dd dd dd dd dd dd d6 dd dd d6 dd dd dd
     937d6 d6 d6 d6 00 d6 00 00 00 00 00 00 00 00 00 00
     938dd dd dd dd dd dd dd dd dd dd dd dd dd d6 d6 dd
     939d6 dd d6 d6 00 d6 00 00 00 00 00 00 00 00 00 00
     940dd dd dd dd dd dd dd dd dd dd d6 d6 dd dd dd dd
     941d6 d6 d6 d6 00 d6 00 00 00 00 00 00 00 00 00 00
     942dd dd dd dd dd dd dd dd d6 dd dd dd dd dd d6 dd
     943d6 d6 00 00 d6 d6 00 00 00 00 00 00 00 00 00 00
     944dd dd dd dd dd dd dd dd dd dd dd d6 dd dd dd d6
     94500 00 d6 d6 d6 d6 00 00 00 00 00 00 00 00 00 00
     946dd dd dd dd dd dd dd dd dd dd dd dd dd d6 00 00
     947d6 d6 d6 d6 00 00 00 00 00 00 00 00 00 00 00 00
     948dd dd dd dd dd dd dd dd dd dd dd dd 00 00 d6 d6
     949d6 d6 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     950dd dd dd dd dd dd dd dd dd dd 00 00 d6 d6 d6 d6
     95100 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     952dd dd dd dd dd dd dd dd 00 00 d6 d6 d6 d6 00 00
     95300 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     954dd dd dd dd dd dd 00 00 d6 d6 d6 d6 00 00 00 00
     95500 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     956dd dd dd dd 00 00 d6 d6 d6 d6 d6 00 00 00 00 00
     95700 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     958dd dd 00 00 d6 d6 d6 d6 d6 d6 d6 00 00 00 00 00
     95900 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     96000 00 d6 d6 d6 d6 d6 d6 d6 d6 00 00 00 00 00 00
     96100 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     96200 00 d6 d6 d6 d6 d6 d6 d6 d6 00 00 00 00 00 00
     96300 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     96400 00 00 d6 d6 d6 d6 d6 00 00 00 00 00 00 00 00
     96500 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     96600 00 00 d6 d6 00 00 00 00 00 00 00 00 00 00 00
     96700 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     96800 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     96900 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     97000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     97100 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ff
     972f0 ff ff ff c0 7f ff ff 00 3f ff fc 00 1f ff f0
     97300 0f ff c0 00 03 ff 00 00 01 fc 00 00 00 f0 00
     97400 01 c0 00 00 07 80 00 00 0f 80 00 00 3f 80 00
     97500 7f 80 00 00 7f 80 00 00 7f 80 00 00 7f 80 00
     97600 7f 80 00 00 7f 80 00 00 7f 80 00 00 ff 80 00
     97703 ff 80 00 0f ff 80 00 3f ff 80 00 ff ff 80 03
     978ff ff 80 03 ff ff 80 03 ff ff e0 07 ff ff e0 07
     979ff ff f0 1f ff ff f8 ff ff ff ff ff ff ff 28 00
     98000 00 10 00 00 00 20 00 00 00 01 00 08 00 00 00
     98100 00 40 01 00 00 00 00 00 00 00 00 00 00 00 00
     98200 00 00 00 00 00 00 00 00 00 00 00 80 00 00 80
     98300 00 00 80 80 00 80 00 00 00 80 00 80 00 80 80
     98400 00 c0 c0 c0 00 c0 dc c0 00 f0 ca a6 00 04 04
     98504 00 08 08 08 00 0c 0c 0c 00 11 11 11 00 16 16
     98616 00 1c 1c 1c 00 22 22 22 00 29 29 29 00 55 55
     98755 00 4d 4d 4d 00 42 42 42 00 39 39 39 00 80 7c
     988ff 00 50 50 ff 00 93 00 d6 00 ff ec cc 00 c6 d6
     989ef 00 d6 e7 e7 00 90 a9 ad 00 00 00 33 00 00 00
     99066 00 00 00 99 00 00 00 cc 00 00 33 00 00 00 33
     99133 00 00 33 66 00 00 33 99 00 00 33 cc 00 00 33
     992ff 00 00 66 00 00 00 66 33 00 00 66 66 00 00 66
     99399 00 00 66 cc 00 00 66 ff 00 00 99 00 00 00 99
     99433 00 00 99 66 00 00 99 99 00 00 99 cc 00 00 99
     995ff 00 00 cc 00 00 00 cc 33 00 00 cc 66 00 00 cc
     99699 00 00 cc cc 00 00 cc ff 00 00 ff 66 00 00 ff
     99799 00 00 ff cc 00 33 00 00 00 33 00 33 00 33 00
     99866 00 33 00 99 00 33 00 cc 00 33 00 ff 00 33 33
     99900 00 33 33 33 00 33 33 66 00 33 33 99 00 33 33
     1000cc 00 33 33 ff 00 33 66 00 00 33 66 33 00 33 66
     100166 00 33 66 99 00 33 66 cc 00 33 66 ff 00 33 99
     100200 00 33 99 33 00 33 99 66 00 33 99 99 00 33 99
     1003cc 00 33 99 ff 00 33 cc 00 00 33 cc 33 00 33 cc
     100466 00 33 cc 99 00 33 cc cc 00 33 cc ff 00 33 ff
     100533 00 33 ff 66 00 33 ff 99 00 33 ff cc 00 33 ff
     1006ff 00 66 00 00 00 66 00 33 00 66 00 66 00 66 00
     100799 00 66 00 cc 00 66 00 ff 00 66 33 00 00 66 33
     100833 00 66 33 66 00 66 33 99 00 66 33 cc 00 66 33
     1009ff 00 66 66 00 00 66 66 33 00 66 66 66 00 66 66
     101099 00 66 66 cc 00 66 99 00 00 66 99 33 00 66 99
     101166 00 66 99 99 00 66 99 cc 00 66 99 ff 00 66 cc
     101200 00 66 cc 33 00 66 cc 99 00 66 cc cc 00 66 cc
     1013ff 00 66 ff 00 00 66 ff 33 00 66 ff 99 00 66 ff
     1014cc 00 cc 00 ff 00 ff 00 cc 00 99 99 00 00 99 33
     101599 00 99 00 99 00 99 00 cc 00 99 00 00 00 99 33
     101633 00 99 00 66 00 99 33 cc 00 99 00 ff 00 99 66
     101700 00 99 66 33 00 99 33 66 00 99 66 99 00 99 66
     1018cc 00 99 33 ff 00 99 99 33 00 99 99 66 00 99 99
     101999 00 99 99 cc 00 99 99 ff 00 99 cc 00 00 99 cc
     102033 00 66 cc 66 00 99 cc 99 00 99 cc cc 00 99 cc
     1021ff 00 99 ff 00 00 99 ff 33 00 99 cc 66 00 99 ff
     102299 00 99 ff cc 00 99 ff ff 00 cc 00 00 00 99 00
     102333 00 cc 00 66 00 cc 00 99 00 cc 00 cc 00 99 33
     102400 00 cc 33 33 00 cc 33 66 00 cc 33 99 00 cc 33
     1025cc 00 cc 33 ff 00 cc 66 00 00 cc 66 33 00 99 66
     102666 00 cc 66 99 00 cc 66 cc 00 99 66 ff 00 cc 99
     102700 00 cc 99 33 00 cc 99 66 00 cc 99 99 00 cc 99
     1028cc 00 cc 99 ff 00 cc cc 00 00 cc cc 33 00 cc cc
     102966 00 cc cc 99 00 cc cc cc 00 cc cc ff 00 cc ff
     103000 00 cc ff 33 00 99 ff 66 00 cc ff 99 00 cc ff
     1031cc 00 cc ff ff 00 cc 00 33 00 ff 00 66 00 ff 00
     103299 00 cc 33 00 00 ff 33 33 00 ff 33 66 00 ff 33
     103399 00 ff 33 cc 00 ff 33 ff 00 ff 66 00 00 ff 66
     103433 00 cc 66 66 00 ff 66 99 00 ff 66 cc 00 cc 66
     1035ff 00 ff 99 00 00 ff 99 33 00 ff 99 66 00 ff 99
     103699 00 ff 99 cc 00 ff 99 ff 00 ff cc 00 00 ff cc
     103733 00 ff cc 66 00 ff cc 99 00 ff cc cc 00 ff cc
     1038ff 00 ff ff 33 00 cc ff 66 00 ff ff 99 00 ff ff
     1039cc 00 66 66 ff 00 66 ff 66 00 66 ff ff 00 ff 66
     104066 00 ff 66 ff 00 ff ff 66 00 21 00 a5 00 5f 5f
     10415f 00 77 77 77 00 86 86 86 00 96 96 96 00 cb cb
     1042cb 00 b2 b2 b2 00 d7 d7 d7 00 dd dd dd 00 e3 e3
     1043e3 00 ea ea ea 00 f1 f1 f1 00 f8 f8 f8 00 f0 fb
     1044ff 00 a4 a0 a0 00 80 80 80 00 00 00 ff 00 00 ff
     104500 00 00 ff ff 00 ff 00 00 00 ff 00 ff 00 ff ff
     104600 00 ff ff ff 00 00 00 00 00 00 00 00 00 00 00
     104700 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     104800 00 00 00 00 00 00 00 92 6d 92 92 6d 92 92 6d
     104992 92 6d 92 6d 00 00 00 00 00 00 00 00 00 00 00
     105000 00 00 00 92 00 00 00 ff dd dd dd dd d6 d6 d6
     1051d6 d6 d6 00 92 00 00 00 ff dd dd dd dd dd dd d6
     1052d6 d6 d6 00 6d 00 00 00 ff dd dd dd dd dd dd dd
     1053d6 d6 d6 00 92 00 00 00 ff dd dd dd dd dd dd dd
     1054d6 d6 d6 00 92 00 00 00 ff dd dd dd dd dd dd dd
     1055d6 d6 d6 00 6d 00 00 00 ff dd dd dd dd dd dd dd
     1056dd dd d6 00 92 00 00 00 ff ff ff ff ff ff ff ff
     1057ff ff c3 00 00 00 00 00 d6 d6 d6 d6 d6 d6 d6 00
     105800 00 00 00 00 00 00 00 00 d6 d6 d6 d6 d6 00 00
     105900 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     106000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     106100 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
     106200 00 00 00 00 00 ff ff 00 00 ff ff 00 00 c0 01
     106300 00 80 01 00 00 80 01 00 00 80 01 00 00 80 01
     106400 00 80 01 00 00 80 01 00 00 80 01 00 00 80 03
     106500 00 80 03 00 00 c0 7f 00 00 e0 ff 00 00 ff ff
     106600 00 ff ff 00 00
     1067'}
     1068
     1069OIC_NOTE      ICON LOADONCALL DISCARDABLE "bmp\oic_note_95.ico"
     1070OIC_PORTRAIT  ICON LOADONCALL DISCARDABLE "bmp\oic_portrait.ico"
     1071OIC_LANDSCAPE ICON LOADONCALL DISCARDABLE "bmp\oic_landscape.ico"
     1072OIC_ODINICON  ICON LOADONCALL DISCARDABLE "bmp\oic_sample.ico"
     1073OIC_FOLDER    ICON LOADONCALL DISCARDABLE "bmp\oic_folder.ico"
     1074OIC_FOLDER2   ICON LOADONCALL DISCARDABLE "bmp\oic_folder2.ico"
     1075OIC_FLOPPY    ICON LOADONCALL DISCARDABLE "bmp\oic_floppy.ico"
     1076OIC_CDROM     ICON LOADONCALL DISCARDABLE "bmp\oic_cdrom.ico"
     1077OIC_HDISK     ICON LOADONCALL DISCARDABLE "bmp\oic_hdisk.ico"
     1078OIC_NETWORK   ICON LOADONCALL DISCARDABLE "bmp\oic_network.ico"
    8291079
    8301080/* Cursors */

  • trunk/src/user32/win32wmdichild.cpp

    r3625 r4573  
    1 /* $Id: win32wmdichild.cpp,v 1.24 2000-05-28 16:43:47 sandervl Exp $ */
     1/* $Id: win32wmdichild.cpp,v 1.25 2000-11-09 18:15:22 sandervl Exp $ */
    22/*
    33 * Win32 MDI Child Window Class for OS/2
    … …  
    522522        return;
    523523    }
    524     MapWindowPoints(client->getParent()->getWindowHandle(), client->getWindowHandle(), (LPPOINT)&rect, 2);
     524    //SvL: No mapping required as our client rectangle is in frame coordinates (not relative to parent!)
     525/////    MapWindowPoints(client->getParent()->getWindowHandle(), client->getWindowHandle(), (LPPOINT)&rect, 2);
    525526
    526527    AdjustWindowRectEx( &rect, getStyle(), 0, getExStyle());

  • trunk/src/user32/window.cpp

    r4551 r4573  
    1 /* $Id: window.cpp,v 1.82 2000-11-04 16:28:26 sandervl Exp $ */
     1/* $Id: window.cpp,v 1.83 2000-11-09 18:15:22 sandervl Exp $ */
    22/*
    33 * Win32 window apis for OS/2
    … …  
    266266    }
    267267
    268     dprintf(("USER32:  CreateMDIWindowA\n"));
    269268    cs.szClass        = lpszClassName;
    270269    cs.szTitle        = lpszWindowName;
    … …  
    276275    cs.style          = dwStyle;
    277276    cs.lParam         = lParam;
     277
     278    if(HIWORD(lpszClassName)) {
     279         dprintf(("CreateMDIWindowA: class %s parent %x (%d,%d) (%d,%d), %x %x lParam=%x", lpszClassName, hwndParent, x, y, nWidth, nHeight, dwStyle, lParam));
     280    }
     281    else dprintf(("CreateMDIWindowA: class %d parent %x (%d,%d) (%d,%d), %x %x lParam=%x", lpszClassName, hwndParent, x, y, nWidth, nHeight, dwStyle, lParam));
    278282
    279283    return window->SendMessageA(WM_MDICREATE, 0, (LPARAM)&cs);

  • trunk/src/user32/winicon.cpp

    r3209 r4573  
    1 /* $Id: winicon.cpp,v 1.10 2000-03-23 23:06:54 sandervl Exp $ */
     1/* $Id: winicon.cpp,v 1.11 2000-11-09 18:15:23 sandervl Exp $ */
    22/*
    33 * Win32 Icon Code for OS/2
    44 *
    55 *
    6  * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
    7  *
    8  * Parts based on Wine code (objects\bitmap.c, loader\resource.c, objects\cursoricon.c):
     6 * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl) (OS/2 Port)
     7 *
     8 * Based on Wine code (objects\bitmap.c, loader\resource.c, objects\cursoricon.c):
    99 *
    1010 * Copyright 1993 Alexandre Julliard
    … …  
    1919 */
    2020#include <os2win.h>
     21#include <stdio.h>
     22#include <string.h>
    2123#include <winicon.h>
    2224#include <win\cursoricon.h>
    23 
    24 #define DBG_LOCALLOG    DBG_winicon
     25#include "dib.h"
     26#include <heapstring.h>
     27#include <win\virtual.h>
     28#include "initterm.h"
     29
     30#define DBG_LOCALLOG    DBG_winicon
    2531#include "dbglocal.h"
    2632
     33static WORD ICON_HOTSPOT = 0x4242;
     34
     35static HGLOBAL CURSORICON_CreateFromResource( HINSTANCE hInstance, HGLOBAL hObj, LPBYTE bits,
     36                        UINT cbSize, BOOL bIcon, DWORD dwVersion,
     37                        INT width, INT height, UINT loadflags );
     38static HGLOBAL CURSORICON_Copy( HINSTANCE hInstance, HGLOBAL handle );
     39static CURSORICONDIRENTRY *CURSORICON_FindBestIcon( CURSORICONDIR *dir, int width,
     40                                                    int height, int colors );
     41static CURSORICONDIRENTRY *CURSORICON_FindBestCursor( CURSORICONDIR *dir,
     42                                                  int width, int height, int color);
     43BOOL CURSORICON_SimulateLoadingFromResourceW( LPWSTR filename, BOOL fCursor,
     44                                                CURSORICONDIR **res, LPBYTE **ptr);
     45
     46/***********************************************************************
     47 *           CreateIcon    (USER32.75)
     48 */
     49HICON WIN32API CreateIcon(HINSTANCE hInstance, INT nWidth,
     50                          INT nHeight, BYTE bPlanes, BYTE bBitsPixel,
     51                          LPCVOID lpANDbits, LPCVOID lpXORbits )
     52{
     53    CURSORICONINFO info;
     54
     55    dprintf(("USER32: CreateIcon (%d,%d), %d, %x, %x", nWidth, nHeight, bPlanes * bBitsPixel, lpXORbits, lpANDbits));
     56
     57    info.ptHotSpot.x = ICON_HOTSPOT;
     58    info.ptHotSpot.y = ICON_HOTSPOT;
     59    info.nWidth = nWidth;
     60    info.nHeight = nHeight;
     61    info.nWidthBytes = 0;
     62    info.bPlanes = bPlanes;
     63    info.bBitsPerPixel = bBitsPixel;
     64
     65    return CreateCursorIconIndirect(0, &info, lpANDbits, lpXORbits);
     66}
     67/**********************************************************************
     68 *          CreateIconFromResource          (USER32.76)
     69 */
     70HICON WIN32API CreateIconFromResource(LPBYTE bits, UINT cbSize,
     71                                      BOOL bIcon, DWORD dwVersion)
     72{
     73    return CreateIconFromResourceEx( bits, cbSize, bIcon, dwVersion, 0,0,0);
     74}
    2775//******************************************************************************
    2876//******************************************************************************
    29 HICON WIN32API CreateIcon( HINSTANCE arg1, INT arg2, INT arg3, BYTE arg4, BYTE arg5, LPCVOID arg6, LPCVOID arg7)
    30 {
    31     dprintf(("USER32:  CreateIcon\n"));
    32     return O32_CreateIcon(arg1, arg2, arg3, arg4, arg5, (const BYTE *)arg6, (const BYTE *)arg7);
    33 }
    34 //******************************************************************************
    35 //ASSERT dwVer == win31 (ok according to SDK docs)
    36 //******************************************************************************
    37 HICON WIN32API CreateIconFromResource(PBYTE presbits,  UINT dwResSize,
    38                                       BOOL  fIcon,     DWORD dwVer)
    39 {
    40  HICON hicon;
    41  DWORD OS2ResSize = 0;
    42  PBYTE OS2Icon    = ConvertWin32Icon(presbits, dwResSize, &OS2ResSize);
    43 
    44     hicon = O32_CreateIconFromResource(OS2Icon, OS2ResSize, fIcon, dwVer);
    45     dprintf(("USER32:  CreateIconFromResource returned %X (%X)\n", hicon, GetLastError()));
    46     if(OS2Icon)
    47         FreeIcon(OS2Icon);
    48 
    49     return(hicon);
    50 }
    51 //******************************************************************************
    52 //******************************************************************************
    53 HICON WIN32API CreateIconFromResourceEx(PBYTE presbits,  UINT dwResSize,
    54                                         BOOL  fIcon,     DWORD dwVer,
    55                                         int   cxDesired, int cyDesired,
    56                                         UINT  Flags)
    57 {
    58     dprintf(("USER32:  CreateIconFromResourceEx %X %d %d %X %d %d %X, not completely supported!\n", presbits, dwResSize, fIcon, dwVer, cxDesired, cyDesired, Flags));
    59     return CreateIconFromResource(presbits, dwResSize, fIcon, dwVer);
    60 }
    61 //******************************************************************************
    62 //******************************************************************************
    63 HICON WIN32API CreateIconIndirect(LPICONINFO pIcon)
    64 {
    65  HICON   hIcon;
    66  HDC     hdcSrc, hdcDst;
    67 
    68     dprintf(("USER32:  CreateIconIndirect\n"));
    69     if(pIcon->hbmMask && pIcon->hbmColor)
    70     {
    71         ICONINFO iconinfo;
    72         SIZE bmpsize;
    73 
    74         iconinfo = *pIcon;
    75         if(GetBitmapDimensionEx(pIcon->hbmColor, &bmpsize) == FALSE) {
    76                 return 0;
    77         }
    78         //if there's a color bitmap, the mask bitmap contains only the AND bits
    79         //Open32 calls WinCreatePointerIndirect which expects AND & XOR bits
    80         //To solve this we create a bitmap that's 2x height of the mask, copy
    81         //the AND bits and set the XOR bits to 0
    82         hdcSrc = CreateCompatibleDC(0);
    83         hdcDst = CreateCompatibleDC(0);
    84 
    85         iconinfo.hbmMask  = CreateCompatibleBitmap (hdcDst, bmpsize.cx, bmpsize.cy*2);
    86         SelectObject (hdcDst, iconinfo.hbmMask);
    87         SelectObject (hdcSrc, pIcon->hbmMask);
    88         BitBlt (hdcDst, 0, 0, bmpsize.cx, bmpsize.cy,
    89                 hdcSrc, 0, 0, SRCCOPY);
    90         PatBlt (hdcDst, bmpsize.cx, bmpsize.cy, bmpsize.cx, bmpsize.cy, BLACKNESS);
    91 
    92         hIcon = O32_CreateIconIndirect(&iconinfo);
    93 
    94         DeleteObject(iconinfo.hbmMask);
    95         DeleteDC(hdcSrc);
    96         DeleteDC(hdcDst);
    97 
    98         return hIcon;
    99     }
    100     hIcon = O32_CreateIconIndirect(pIcon);
    101     if(hIcon == 0) {
    102         dprintf(("CreateIconIndirect %d (%d,%d) %x %x failed with %x", pIcon->fIcon, pIcon->xHotspot, pIcon->yHotspot, pIcon->hbmMask, pIcon->hbmColor, GetLastError()));
    103     }
    104     return hIcon;
    105 }
    106 //******************************************************************************
    107 //******************************************************************************
    108 HICON CreateIconIndirect(LPICONINFO pIcon, BOOL bIsIcon, int desiredX, int desiredY, DWORD flags)
    109 {
    110  HICON   hIcon;
    111  HDC     hdcSrc, hdcDst;
    112  BITMAP  bmp;
    113 
    114     if(pIcon->hbmMask && pIcon->hbmColor)
    115     {
    116         ICONINFO iconinfo;
    117         HBITMAP hbmOldSrc, hbmOldDst;
    118 
    119         iconinfo = *pIcon;
    120         GetObjectA(pIcon->hbmColor, sizeof(BITMAP), (LPVOID)&bmp);
    121 
    122         //if there's a color bitmap, the mask bitmap contains only the AND bits
    123         //Open32 calls WinCreatePointerIndirect which expects AND & XOR bits
    124         //To solve this we create a bitmap that's 2x height of the mask, copy
    125         //the AND bits and set the XOR bits to 0
    126         hdcSrc = CreateCompatibleDC(0);
    127         hdcDst = CreateCompatibleDC(0);
    128 
    129         iconinfo.hbmMask  = CreateCompatibleBitmap (hdcDst, desiredX, desiredY*2);
    130         hbmOldDst = SelectObject (hdcDst, iconinfo.hbmMask);
    131         hbmOldSrc = SelectObject (hdcSrc, pIcon->hbmMask);
    132         if(desiredX != bmp.bmWidth || desiredY != bmp.bmHeight) {
    133                 StretchBlt(hdcDst, 0, 0, desiredX, desiredY, hdcSrc, 0, 0,
    134                            bmp.bmWidth, bmp.bmHeight, SRCCOPY);
    135         }
    136         else {
    137                 BitBlt (hdcDst, 0, 0, bmp.bmWidth, bmp.bmHeight,
    138                         hdcSrc, 0, 0, SRCCOPY);
    139         }
    140         PatBlt (hdcDst, desiredX, desiredY, desiredX, desiredY, BLACKNESS);
    141 
    142         if(desiredX != bmp.bmWidth || desiredY != bmp.bmHeight) {
    143                 iconinfo.hbmColor  = CreateCompatibleBitmap (hdcDst, desiredX, desiredY);
    144                 SelectObject (hdcDst, iconinfo.hbmColor);
    145                 SelectObject (hdcSrc, pIcon->hbmColor);
    146                 StretchBlt(hdcDst, 0, 0, desiredX, desiredY, hdcSrc, 0, 0,
    147                            bmp.bmWidth, bmp.bmHeight, SRCCOPY);
    148         }
    149 
    150         hIcon = O32_CreateIconIndirect(&iconinfo);
    151 
    152         DeleteObject(iconinfo.hbmMask);
    153         if(desiredX != bmp.bmWidth || desiredY != bmp.bmHeight) {
    154                 DeleteObject(iconinfo.hbmColor);
    155         }
    156         SelectObject (hdcDst, hbmOldDst);
    157         SelectObject (hdcSrc, hbmOldSrc);
    158         DeleteDC(hdcSrc);
    159         DeleteDC(hdcDst);
    160 
    161         return hIcon;
    162     }
    163     hIcon = O32_CreateIconIndirect(pIcon);
    164     if(hIcon == 0) {
    165         dprintf(("CreateIconIndirect %d (%d,%d) %x %x failed with %x", pIcon->fIcon, pIcon->xHotspot, pIcon->yHotspot, pIcon->hbmMask, pIcon->hbmColor, GetLastError()));
    166     }
    167     return hIcon;
     77HICON WIN32API CreateIconFromResourceEx(LPBYTE bits, UINT cbSize,
     78                                        BOOL bIcon, DWORD dwVersion,
     79                                        INT width, INT height,
     80                                        UINT cFlag )
     81{
     82    dprintf(("USER32:  CreateIconFromResourceEx %X %d %d %X %d %d %X,", bits, cbSize, bIcon, dwVersion, width, height, cFlag));
     83    return CURSORICON_CreateFromResource(0, 0, bits, cbSize, bIcon, dwVersion, width, height, cFlag );
     84}
     85/**********************************************************************
     86 *          CreateIconIndirect      (USER32.78)
     87 */
     88HICON WINAPI CreateIconIndirect(ICONINFO *iconinfo)
     89{
     90    BITMAP bmpXor,bmpAnd;
     91    HICON hObj;
     92    int sizeXor,sizeAnd;
     93
     94    dprintf(("USER32: CreateIconIndirect %x", iconinfo));
     95
     96    GetObjectA( iconinfo->hbmColor, sizeof(bmpXor), &bmpXor );
     97    GetObjectA( iconinfo->hbmMask, sizeof(bmpAnd), &bmpAnd );
     98
     99    sizeXor = bmpXor.bmHeight * bmpXor.bmWidthBytes;
     100    sizeAnd = bmpAnd.bmHeight * bmpAnd.bmWidthBytes;
     101
     102    hObj = GlobalAlloc( GMEM_MOVEABLE, sizeof(CURSORICONINFO) + sizeXor + sizeAnd );
     103    if (hObj)
     104    {
     105        CURSORICONINFO *info;
     106
     107        info = (CURSORICONINFO *)GlobalLock( hObj );
     108
     109        /* If we are creating an icon, the hotspot is unused */
     110        if (iconinfo->fIcon)
     111        {
     112            info->ptHotSpot.x   = ICON_HOTSPOT;
     113            info->ptHotSpot.y   = ICON_HOTSPOT;
     114        }
     115        else
     116        {
     117            info->ptHotSpot.x   = iconinfo->xHotspot;
     118            info->ptHotSpot.y   = iconinfo->yHotspot;
     119        }
     120
     121        info->nWidth        = bmpXor.bmWidth;
     122        info->nHeight       = bmpXor.bmHeight;
     123        info->nWidthBytes   = bmpXor.bmWidthBytes;
     124        info->bPlanes       = bmpXor.bmPlanes;
     125        info->bBitsPerPixel = bmpXor.bmBitsPixel;
     126
     127        /* Transfer the bitmap bits to the CURSORICONINFO structure */
     128        GetBitmapBits( iconinfo->hbmMask ,sizeAnd,(char*)(info + 1) );
     129        GetBitmapBits( iconinfo->hbmColor,sizeXor,(char*)(info + 1) +sizeAnd);
     130        GlobalUnlock(hObj);
     131    }
     132    else {
     133        dprintf(("ERROR: CreateIconIndirect GlobalAlloc failed!!"));
     134    }
     135    return hObj;
    168136}
    169137//******************************************************************************
    … …  
    172140{
    173141    dprintf(("USER32: DestroyIcon %x", hIcon));
    174     return O32_DestroyIcon(hIcon);
     142    return CURSORICON_Destroy( hIcon, 0 );
    175143}
    176144//******************************************************************************
    … …  
    179147{
    180148    dprintf(("USER32:  CopyIcon %x", hIcon));
    181     return O32_CopyIcon(hIcon);
    182 }
    183 //******************************************************************************
    184 //WARNING: MEMORY LEAK & DIRTY HACK TO WORK AROUND OPEN32 BUG
    185 //OS/2 icon masks must be twice the height of the color bitmap
    186 //In Windows, the mask only contains the AND data if there's a color bitmap
    187 //--->> We're allocating a bitmap to replace the mask bitmap, but DON'T DELETE it!
    188 //WARNING: DIRTY HACK TO WORK AROUND OPEN32 BUG
    189 //******************************************************************************
    190 BOOL WIN32API GetIconInfo( HICON hIcon, LPICONINFO pIconInfo)
    191 {
    192  BOOL rc;
    193  HBITMAP hbmMask, hbmOldSrc, hbmOldDst;
    194  BITMAP bmp;
    195 
    196     dprintf(("USER32: GetIconInfo %x", hIcon));
    197     rc = O32_GetIconInfo(hIcon, pIconInfo);
     149    return CURSORICON_Copy( 0, hIcon );
     150}
     151/**********************************************************************
     152 *          GetIconInfo     (USER32.242)
     153 */
     154BOOL WINAPI GetIconInfo(HICON hIcon, ICONINFO *iconinfo)
     155{
     156    CURSORICONINFO  *ciconinfo;
     157
     158    dprintf(("GetIconInfo %x %x", hIcon, iconinfo));
     159
     160    ciconinfo = (CURSORICONINFO *)GlobalLock((HGLOBAL)hIcon);
     161    if (!ciconinfo)
     162        return FALSE;
     163
     164    if((ciconinfo->ptHotSpot.x == ICON_HOTSPOT) &&
     165       (ciconinfo->ptHotSpot.y == ICON_HOTSPOT))
     166    {
     167        iconinfo->fIcon    = TRUE;
     168        iconinfo->xHotspot = ciconinfo->nWidth / 2;
     169        iconinfo->yHotspot = ciconinfo->nHeight / 2;
     170    }
     171    else
     172    {
     173        iconinfo->fIcon    = FALSE;
     174        iconinfo->xHotspot = ciconinfo->ptHotSpot.x;
     175        iconinfo->yHotspot = ciconinfo->ptHotSpot.y;
     176    }
     177
     178    //Create new bitmaps for the color and mask data; application is responsible
     179    //for deleteing them (according to docs & verified in NT4)
     180    if(ciconinfo->bBitsPerPixel > 1)
     181    {
     182        BITMAPINFO* pInfo;
     183        int colorsize = 0;
     184        int coloroff;
     185
     186        HDC hdc = CreateCompatibleDC(0);
     187
     188        if(ciconinfo->bBitsPerPixel <= 8) {
     189            colorsize = (1<<ciconinfo->bBitsPerPixel)*sizeof(RGBQUAD);
     190        }
     191        else {
     192            colorsize = 3*sizeof(DWORD); //color masks
     193        }
     194        pInfo = (BITMAPINFO *)malloc(ciconinfo->nHeight * ciconinfo->nWidthBytes + colorsize + sizeof(BITMAPINFO));
     195        memset(pInfo, 0, sizeof(BITMAPINFO)+colorsize);
     196
     197        pInfo->bmiHeader.biSize     = sizeof(BITMAPINFOHEADER);
     198        pInfo->bmiHeader.biWidth    = ciconinfo->nWidth;
     199        pInfo->bmiHeader.biHeight   = ciconinfo->nHeight,
     200        pInfo->bmiHeader.biPlanes   = ciconinfo->bPlanes;
     201        pInfo->bmiHeader.biBitCount = ciconinfo->bBitsPerPixel;
     202        pInfo->bmiHeader.biSizeImage= ciconinfo->nHeight * ciconinfo->nWidthBytes;
     203
     204        //offset in cursorinfo memory
     205        coloroff = ciconinfo->nHeight * BITMAP_GetWidthBytes (ciconinfo->nWidth, 1);
     206
     207        char *src  = (char *)(ciconinfo + 1) + coloroff;
     208        if(ciconinfo->bBitsPerPixel <= 8) {
     209            src += colorsize;       //no color masks in cursorinfo data for bpp > 8
     210        }
     211        if(ciconinfo->bBitsPerPixel <= 8) {
     212                memcpy(&pInfo->bmiColors[0], (char *)(ciconinfo + 1) + coloroff, colorsize);
     213        }
     214        //else TODO: color masks (curerntly unused in CreateDIBitmap)
     215
     216        iconinfo->hbmColor = CreateDIBitmap(hdc, &pInfo->bmiHeader, CBM_INIT, src, pInfo, DIB_RGB_COLORS);
     217
     218        free(pInfo);
     219        DeleteDC(hdc);
     220    }
     221    else {
     222        iconinfo->hbmColor = CreateBitmap ( ciconinfo->nWidth, ciconinfo->nHeight,
     223                                            ciconinfo->bPlanes, ciconinfo->bBitsPerPixel,
     224                                            (char *)(ciconinfo + 1)
     225                                            + ciconinfo->nHeight *
     226                                            BITMAP_GetWidthBytes (ciconinfo->nWidth, 1) );
     227    }
     228
     229    iconinfo->hbmMask = CreateBitmap ( ciconinfo->nWidth, ciconinfo->nHeight,
     230                                1, 1, (char *)(ciconinfo + 1));
     231
     232    GlobalUnlock(hIcon);
     233
     234    return TRUE;
     235}
     236/***********************************************************************
     237 *           CreateCursorIconIndirect    (USER.408)
     238 */
     239HGLOBAL WIN32API CreateCursorIconIndirect( HINSTANCE hInstance,
     240                                           CURSORICONINFO *info,
     241                                           LPCVOID lpANDbits,
     242                                           LPCVOID lpXORbits )
     243{
     244    HGLOBAL handle;
     245    char *ptr;
     246    int sizeAnd, sizeXor;
     247
     248    if (!lpXORbits || !lpANDbits || info->bPlanes != 1) return 0;
     249    info->nWidthBytes = BITMAP_GetWidthBytes(info->nWidth,info->bBitsPerPixel);
     250    sizeXor = info->nHeight * info->nWidthBytes;
     251    sizeAnd = info->nHeight * BITMAP_GetWidthBytes( info->nWidth, 1 );
     252    if (!(handle = GlobalAlloc( GMEM_MOVEABLE,
     253                                sizeof(CURSORICONINFO) + sizeXor + sizeAnd)))
     254        return 0;
     255    ptr = (char *)GlobalLock( handle );
     256    memcpy( ptr, info, sizeof(*info) );
     257    memcpy( ptr + sizeof(CURSORICONINFO), lpANDbits, sizeAnd );
     258    memcpy( ptr + sizeof(CURSORICONINFO) + sizeAnd, lpXORbits, sizeXor );
     259    GlobalUnlock( handle );
     260    return handle;
     261}
     262/**********************************************************************
     263 *          CURSORICON_Load
     264 *
     265 * Load a cursor or icon from resource or file.
     266 */
     267HGLOBAL CURSORICON_Load( HINSTANCE hInstance, LPCWSTR name,
     268                         INT width, INT height, INT colors,
     269                         BOOL fCursor, UINT loadflags )
     270{
     271    HANDLE handle = 0, h = 0;
     272    HANDLE hRsrc;
     273    CURSORICONDIR *dir;
     274    CURSORICONDIRENTRY *dirEntry;
     275    LPBYTE bits;
     276
     277    if ( loadflags & LR_LOADFROMFILE )    /* Load from file */
     278    {
     279        LPBYTE *ptr;
     280        if (!CURSORICON_SimulateLoadingFromResourceW((LPWSTR)name, fCursor, &dir, &ptr))
     281            return 0;
     282        if (fCursor)
     283            dirEntry = (CURSORICONDIRENTRY *)CURSORICON_FindBestCursor(dir, width, height, 1);
     284        else
     285            dirEntry = (CURSORICONDIRENTRY *)CURSORICON_FindBestIcon(dir, width, height, colors);
     286        bits = ptr[dirEntry->wResId-1];
     287        h = CURSORICON_CreateFromResource( 0, 0, bits, dirEntry->dwBytesInRes,
     288                                           !fCursor, 0x00030000, width, height, loadflags);
     289        HeapFree( GetProcessHeap(), 0, dir );
     290        HeapFree( GetProcessHeap(), 0, ptr );
     291    }
     292    else  /* Load from resource */
     293    {
     294        HANDLE hGroupRsrc;
     295        WORD wResId;
     296        DWORD dwBytesInRes;
     297        BOOL  bIsGroup = TRUE;
     298
     299        /* Get directory resource ID */
     300        if (!hInstance)
     301        {
     302            hRsrc = FindResourceW(hInstanceUser32, name, fCursor ? RT_CURSORW : RT_ICONW);
     303            if(!hRsrc) {
     304                hRsrc = FindResourceW(hInstanceUser32, name, fCursor ? RT_GROUP_CURSORW : RT_GROUP_ICONW);
     305            }
     306            else bIsGroup = FALSE;
     307
     308            if(!hRsrc)  return 0;
     309
     310            hInstance = hInstanceUser32;
     311        }
     312        else {
     313            hRsrc = FindResourceW(hInstance, name, fCursor ? RT_GROUP_CURSORW : RT_GROUP_ICONW);
     314            if(!hRsrc)  return 0;
     315        }
     316        hGroupRsrc = hRsrc;
     317
     318        if(bIsGroup) {
     319            /* Find the best entry in the directory */
     320
     321            if (!(handle = LoadResource( hInstance, hRsrc ))) return 0;
     322            if (!(dir = (CURSORICONDIR*)LockResource( handle ))) return 0;
     323
     324            if (fCursor)
     325                dirEntry = (CURSORICONDIRENTRY *)CURSORICON_FindBestCursor( dir,
     326                                                                  width, height, 1);
     327            else
     328                dirEntry = (CURSORICONDIRENTRY *)CURSORICON_FindBestIcon( dir,
     329                                                           width, height, colors );
     330            if (!dirEntry) return 0;
     331            wResId = dirEntry->wResId;
     332            dwBytesInRes = dirEntry->dwBytesInRes;
     333            FreeResource( handle );
     334
     335            /* Load the resource */
     336            if (!(hRsrc = FindResourceW(hInstance,MAKEINTRESOURCEW(wResId),
     337                                      fCursor ? RT_CURSORW : RT_ICONW ))) return 0;
     338        }
     339
     340        if (!(handle = LoadResource( hInstance, hRsrc ))) return 0;
     341        bits = (LPBYTE)LockResource( handle );
     342        h = CURSORICON_CreateFromResource( 0, 0, bits, dwBytesInRes,
     343                                           !fCursor, 0x00030000, width, height, loadflags);
     344        FreeResource( handle );
     345
     346    }
     347
     348    return h;
     349}
     350
     351/*********************************************************************
     352 * The main purpose of this function is to create fake resource directory
     353 * and fake resource entries. There are several reasons for this:
     354 *  -   CURSORICONDIR and CURSORICONFILEDIR differ in sizes and their
     355 *              fields
     356 *  There are some "bad" cursor files which do not have
     357 *      bColorCount initialized but instead one must read this info
     358 *      directly from corresponding DIB sections
     359 * Note: wResId is index to array of pointer returned in ptrs (origin is 1)
     360 */
     361BOOL CURSORICON_SimulateLoadingFromResourceW( LPWSTR filename, BOOL fCursor,
     362                                              CURSORICONDIR **res, LPBYTE **ptr)
     363{
     364    LPBYTE    _free;
     365    CURSORICONFILEDIR *bits;
     366    int        entries, size, i;
     367    HANDLE     hMapping = 0;
     368
     369    *res = NULL;
     370    *ptr = NULL;
     371
     372    hMapping = VIRTUAL_MapFileW( filename, (LPVOID *)&bits, TRUE);
     373    if(hMapping == INVALID_HANDLE_VALUE)
     374            return FALSE;
     375
     376    /* FIXME: test for inimated icons
     377     * hack to load the first icon from the *.ani file
     378     */
     379    if ( *(LPDWORD)bits==0x46464952 ) /* "RIFF" */
     380    {
     381        LPBYTE pos = (LPBYTE) bits;
     382        dprintf(("Animated icons not correctly implemented! %p \n", bits));
     383
     384        for (;;)
     385        {
     386            if (*(LPDWORD)pos==0x6e6f6369)      /* "icon" */
     387            {
     388                dprintf(("icon entry found! %p\n", bits));
     389                pos+=4;
     390                if ( !*(LPWORD) pos==0x2fe)       /* iconsize */
     391                {
     392                    goto fail;
     393                }
     394                bits=(CURSORICONFILEDIR*)(pos+4);
     395                dprintf(("icon size ok. offset=%p \n", bits));
     396                break;
     397            }
     398            pos+=2;
     399            if (pos>=(LPBYTE)bits+766) goto fail;
     400        }
     401    }
     402    if (!(entries = bits->idCount)) goto fail;
     403    size = sizeof(CURSORICONDIR) + sizeof(CURSORICONDIRENTRY) * (entries - 1);
     404    _free = (LPBYTE) size;
     405
     406    for (i=0; i < entries; i++)
     407      size += bits->idEntries[i].dwDIBSize + (fCursor ? sizeof(POINT16): 0);
     408
     409    if (!(*ptr = (LPBYTE *)HeapAlloc( GetProcessHeap(), 0,
     410                            entries * sizeof (CURSORICONDIRENTRY*)))) goto fail;
     411    if (!(*res = (CURSORICONDIR *)HeapAlloc( GetProcessHeap(), 0, size))) goto fail;
     412
     413    _free = (LPBYTE)(*res) + (int)_free;
     414    memcpy((*res), bits, 6);
     415    for (i=0; i<entries; i++)
     416    {
     417      ((LPBYTE*)(*ptr))[i] = _free;
     418      if (fCursor) {
     419        (*res)->idEntries[i].ResInfo.cursor.wWidth=bits->idEntries[i].bWidth;
     420        (*res)->idEntries[i].ResInfo.cursor.wHeight=bits->idEntries[i].bHeight;
     421        ((LPPOINT16)_free)->x=bits->idEntries[i].xHotspot;
     422        ((LPPOINT16)_free)->y=bits->idEntries[i].yHotspot;
     423        _free+=sizeof(POINT16);
     424      }
     425      else {
     426        (*res)->idEntries[i].ResInfo.icon.bWidth=bits->idEntries[i].bWidth;
     427        (*res)->idEntries[i].ResInfo.icon.bHeight=bits->idEntries[i].bHeight;
     428        (*res)->idEntries[i].ResInfo.icon.bColorCount = bits->idEntries[i].bColorCount;
     429      }
     430      (*res)->idEntries[i].wPlanes=1;
     431      (*res)->idEntries[i].wBitCount = ((LPBITMAPINFOHEADER)((LPBYTE)bits +
     432                                                   bits->idEntries[i].dwDIBOffset))->biBitCount;
     433      (*res)->idEntries[i].dwBytesInRes = bits->idEntries[i].dwDIBSize;
     434      (*res)->idEntries[i].wResId=i+1;
     435
     436      memcpy(_free,(LPBYTE)bits +bits->idEntries[i].dwDIBOffset,
     437             (*res)->idEntries[i].dwBytesInRes);
     438      _free += (*res)->idEntries[i].dwBytesInRes;
     439    }
     440    UnmapViewOfFile( bits );
     441    CloseHandle(hMapping);
     442    return TRUE;
     443
     444fail:
     445    if (*res) HeapFree( GetProcessHeap(), 0, *res );
     446    if (*ptr) HeapFree( GetProcessHeap(), 0, *ptr );
     447
     448    UnmapViewOfFile( bits );
     449    CloseHandle(hMapping);
     450    return FALSE;
     451}
     452
     453/**********************************************************************
     454 *      CURSORICON_CreateFromResource
     455 *
     456 * Create a cursor or icon from in-memory resource template.
     457 *
     458 * FIXME: Convert to mono when cFlag is LR_MONOCHROME. Do something
     459 *        with cbSize parameter as well.
     460 */
     461static HGLOBAL CURSORICON_CreateFromResource( HINSTANCE hInstance, HGLOBAL hObj, LPBYTE bits,
     462                        UINT cbSize, BOOL bIcon, DWORD dwVersion,
     463                        INT width, INT height, UINT loadflags )
     464{
     465    int sizeAnd, sizeXor;
     466    HBITMAP hAndBits = 0, hXorBits = 0; /* error condition for later */
     467    BITMAP bmpXor, bmpAnd;
     468    POINT16 hotspot;
     469    BITMAPINFO *bmi;
     470    HDC hdc = 0;
     471    BOOL DoStretch;
     472    INT size, colortablesize;
     473
     474    hotspot.x = ICON_HOTSPOT;
     475    hotspot.y = ICON_HOTSPOT;
     476
     477    if (dwVersion == 0x00020000)
     478    {
     479        dprintf(("CURSORICON_CreateFromResource 2.xx resources are not supported"));
     480        return 0;
     481    }
     482
     483    if (bIcon) {
     484        bmi = (BITMAPINFO *)bits;
     485    }
     486    else /* get the hotspot */
     487    {
     488        POINT16 *pt = (POINT16 *)bits;
     489        hotspot = *pt;
     490        bmi = (BITMAPINFO *)(pt + 1);
     491    }
     492    size = DIB_BitmapInfoSize(bmi, DIB_RGB_COLORS);
     493
     494    if (!width) width = bmi->bmiHeader.biWidth;
     495    if (!height) height = bmi->bmiHeader.biHeight/2;
     496
     497    DoStretch = (bmi->bmiHeader.biHeight/2 != height) || (bmi->bmiHeader.biWidth != width);
     498
     499    /* Check bitmap header */
     500    if ( (bmi->bmiHeader.biSize != sizeof(BITMAPCOREHEADER)) &&
     501     (bmi->bmiHeader.biSize != sizeof(BITMAPINFOHEADER)  ||
     502      bmi->bmiHeader.biCompression != BI_RGB) )
     503    {
     504        return 0;
     505    }
     506
     507    if( (hdc = GetDC( 0 )) )
     508    {
     509        BITMAPINFO* pInfo;
     510
     511        /* Make sure we have room for the monochrome bitmap later on.
     512         * Note that BITMAPINFOINFO and BITMAPCOREHEADER are the same
     513         * up to and including the biBitCount. In-memory icon resource
     514         * format is as follows:
     515         *
     516         *   BITMAPINFOHEADER   icHeader  // DIB header
     517         *   RGBQUAD         icColors[]   // Color table
     518         *   BYTE            icXOR[]      // DIB bits for XOR mask
     519         *   BYTE            icAND[]      // DIB bits for AND mask
     520         */
     521
     522        if ((pInfo = (BITMAPINFO *)HeapAlloc( GetProcessHeap(), 0,
     523                                              max(size, sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD)))))
     524        {
     525            memcpy( pInfo, bmi, size );
     526            pInfo->bmiHeader.biHeight /= 2;
     527
     528            /* Create the XOR bitmap */
     529            if (DoStretch)
     530            {
     531                if(bIcon)
     532                {
     533                    hXorBits = CreateCompatibleBitmap(hdc, width, height);
     534                }
     535                else
     536                {
     537                    hXorBits = CreateBitmap(width, height, 1, 1, NULL);
     538                }
     539                if(hXorBits)
     540                {
     541                    HBITMAP hOld;
     542                    HDC hMem = CreateCompatibleDC(hdc);
     543                    BOOL res;
     544
     545                    if (hMem) {
     546                        hOld = SelectObject(hMem, hXorBits);
     547                        res = StretchDIBits(hMem, 0, 0, width, height, 0, 0,
     548                                            bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight/2,
     549                                            (char*)bmi + size, pInfo, DIB_RGB_COLORS, SRCCOPY);
     550                        SelectObject(hMem, hOld);
     551                        DeleteDC(hMem);
     552                    }
     553                    else res = FALSE;
     554                    if (!res) {
     555                        DeleteObject(hXorBits);
     556                        hXorBits = 0;
     557                    }
     558                }
     559            }
     560            else
     561            {
     562                hXorBits = CreateDIBitmap(hdc, &pInfo->bmiHeader,
     563                                          CBM_INIT, (char*)bmi + size, pInfo, DIB_RGB_COLORS );
     564            }
     565            if( hXorBits )
     566            {
     567                char* xbits = (char *)bmi + size + DIB_GetDIBImageBytes(bmi->bmiHeader.biWidth,
     568                                                                        bmi->bmiHeader.biHeight,
     569                                                                        bmi->bmiHeader.biBitCount) / 2;
     570
     571                pInfo->bmiHeader.biBitCount = 1;
     572                if (pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
     573                {
     574                    RGBQUAD *rgb = pInfo->bmiColors;
     575
     576                    pInfo->bmiHeader.biClrUsed = pInfo->bmiHeader.biClrImportant = 2;
     577                    rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00;
     578                    rgb[1].rgbBlue = rgb[1].rgbGreen = rgb[1].rgbRed = 0xff;
     579                    rgb[0].rgbReserved = rgb[1].rgbReserved = 0;
     580                }
     581                else
     582                {
     583                    RGBTRIPLE *rgb = (RGBTRIPLE *)(((BITMAPCOREHEADER *)pInfo) + 1);
     584
     585                    rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00;
     586                    rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff;
     587                }
     588
     589                /* Create the AND bitmap */
     590                if (DoStretch)
     591                {
     592                    if ((hAndBits = CreateBitmap(width, height, 1, 1, NULL)))
     593                    {
     594                        HBITMAP hOld;
     595                        HDC hMem = CreateCompatibleDC(hdc);
     596                        BOOL res;
     597
     598                        if (hMem) {
     599                            hOld = SelectObject(hMem, hAndBits);
     600                            res = StretchDIBits(hMem, 0, 0, width, height, 0, 0,
     601                                                pInfo->bmiHeader.biWidth, pInfo->bmiHeader.biHeight,
     602                                                xbits, pInfo, DIB_RGB_COLORS, SRCCOPY);
     603                            SelectObject(hMem, hOld);
     604                            DeleteDC(hMem);
     605                        }
     606                        else res = FALSE;
     607                        if (!res) {
     608                            DeleteObject(hAndBits); hAndBits = 0;
     609                        }
     610                    }
     611                }
     612                else {
     613//SvL: Must use CreateBitmap here as CreateDIBitmap converts data to 8bpp (GetObjectA info -> 8 bpp)
    198614#if 1
    199     if(rc && pIconInfo->hbmColor)
    200     {
    201         HDC  hdcSrc, hdcDst;
    202         hdcSrc = CreateCompatibleDC(0);
    203         hdcDst = CreateCompatibleDC(0);
    204 
    205         GetObjectA(pIconInfo->hbmColor, sizeof(BITMAP), (LPVOID)&bmp);
    206 
    207         hbmMask = CreateCompatibleBitmap (hdcDst, bmp.bmWidth, bmp.bmHeight);
    208         hbmOldDst = SelectObject (hdcDst, hbmMask);
    209         hbmOldSrc = SelectObject (hdcSrc, pIconInfo->hbmMask);
    210         BitBlt (hdcDst, 0, 0, bmp.bmWidth, bmp.bmHeight,
    211                 hdcSrc, 0, 0, SRCCOPY);
    212 
    213         SelectObject(hdcDst, hbmOldDst);
    214         SelectObject(hdcSrc, hbmOldSrc);
    215         DeleteDC(hdcDst);
    216         DeleteDC(hdcSrc);
    217         DeleteObject(pIconInfo->hbmMask);
    218         pIconInfo->hbmMask = hbmMask;
    219     }
     615                    int linewidth = BITMAP_GetWidthBytes(width, 1);
     616
     617                    char *newpix = (char *)malloc(linewidth*height);
     618
     619                    newpix += ((height-1)*linewidth);
     620
     621                    for(int i=0;i<height;i++) {
     622                        memcpy(newpix, xbits, linewidth);
     623                        newpix -= linewidth;
     624                        xbits  += linewidth;
     625                    }
     626                    newpix += linewidth;
     627                    hAndBits = CreateBitmap(width, height, 1, 1, newpix);
     628
     629                    free(newpix);
     630
     631#else
     632                    hAndBits = CreateDIBitmap(hdc, &pInfo->bmiHeader,
     633                                              CBM_INIT, xbits, pInfo, DIB_RGB_COLORS );
    220634#endif
    221     return rc;
    222 }
     635                }
     636                if( !hAndBits )
     637                    DeleteObject( hXorBits );
     638             }
     639             HeapFree( GetProcessHeap(), 0, pInfo );
     640        }
     641        ReleaseDC( 0, hdc );
     642    }
     643
     644    if( !hXorBits || !hAndBits )
     645    {
     646        dprintf(("\tunable to create an icon bitmap.\n"));
     647        return 0;
     648    }
     649
     650    /* Now create the CURSORICONINFO structure */
     651    GetObjectA( hXorBits, sizeof(bmpXor), &bmpXor );
     652    GetObjectA( hAndBits, sizeof(bmpAnd), &bmpAnd );
     653    colortablesize = 0;
     654
     655    if(bmpXor.bmBitsPixel <= 8) {
     656         colortablesize = sizeof(RGBQUAD)*(1<<bmpXor.bmBitsPixel);
     657         sizeXor = bmpXor.bmHeight * bmpXor.bmWidthBytes + colortablesize;
     658    }
     659    else sizeXor = bmpXor.bmHeight * bmpXor.bmWidthBytes;
     660
     661    sizeAnd = bmpAnd.bmHeight * bmpAnd.bmWidthBytes;
     662
     663    if (hObj) hObj = GlobalReAlloc( hObj,
     664             sizeof(CURSORICONINFO) + sizeXor + sizeAnd, GMEM_MOVEABLE );
     665    if (!hObj) hObj = GlobalAlloc( GMEM_MOVEABLE,
     666             sizeof(CURSORICONINFO) + sizeXor + sizeAnd );
     667    if (hObj)
     668    {
     669        CURSORICONINFO *info;
     670
     671        info = (CURSORICONINFO *)GlobalLock( hObj );
     672        info->ptHotSpot.x   = hotspot.x;
     673        info->ptHotSpot.y   = hotspot.y;
     674        info->nWidth        = bmpXor.bmWidth;
     675        info->nHeight       = bmpXor.bmHeight;
     676        info->nWidthBytes   = bmpXor.bmWidthBytes;
     677        info->bPlanes       = bmpXor.bmPlanes;
     678        info->bBitsPerPixel = bmpXor.bmBitsPixel;
     679        info->hColorBmp     = hXorBits;
     680
     681        /* Transfer the bitmap bits to the CURSORICONINFO structure */
     682        GetBitmapBits( hAndBits, sizeAnd, (char *)(info + 1));
     683
     684        if(bmpXor.bmBitsPixel > 1)
     685        {
     686            BITMAPINFO* pInfo = (BITMAPINFO *)malloc(sizeof(BITMAPINFO)+colortablesize+3*sizeof(DWORD)); //+ extra space for > 8bpp images
     687            HBITMAP oldbmp;
     688
     689            hdc = CreateCompatibleDC(0);
     690
     691            pInfo->bmiHeader.biSize     = sizeof(BITMAPINFOHEADER);
     692            pInfo->bmiHeader.biPlanes   = info->bPlanes;
     693            pInfo->bmiHeader.biBitCount = info->bBitsPerPixel;
     694
     695            GetDIBits(hdc, hXorBits, 0, bmpXor.bmHeight, (char *)(info + 1) + sizeAnd + colortablesize, pInfo, DIB_RGB_COLORS);
     696            if(colortablesize) {
     697                memcpy((char *)(info + 1) + sizeAnd, (char *)&pInfo->bmiHeader + pInfo->bmiHeader.biSize, colortablesize);
     698            }
     699
     700            DeleteDC(hdc);
     701            free(pInfo);
     702        }
     703        else {
     704            GetBitmapBits( hXorBits, sizeXor, (char *)(info + 1) + sizeAnd);
     705        }
     706        GlobalUnlock( hObj );
     707    }
     708
     709    DeleteObject( hAndBits );
     710    DeleteObject( hXorBits );
     711    return hObj;
     712}
     713
     714/**********************************************************************
     715 *      CURSORICON_Destroy   (USER.610)
     716 *
     717 * This routine is actually exported from Win95 USER under the name
     718 * DestroyIcon32 ...  The behaviour implemented here should mimic
     719 * the Win95 one exactly, especially the return values, which
     720 * depend on the setting of various flags.
     721 */
     722WORD WIN32API CURSORICON_Destroy( HGLOBAL handle, UINT flags )
     723{
     724    WORD retv;
     725
     726#if 0
     727    /* Check whether destroying active cursor */
     728
     729    if ( hActiveCursor == handle )
     730    {
     731        ERR_(cursor)("Destroying active cursor!\n" );
     732        SetCursor( 0 );
     733    }
     734    /* Try shared cursor/icon first */
     735
     736    if ( !(flags & CID_NONSHARED) )
     737    {
     738        INT count = CURSORICON_DelSharedIcon( handle );
     739
     740        if ( count != -1 )
     741            return (flags & CID_WIN32)? TRUE : (count == 0);
     742
     743        /* FIXME: OEM cursors/icons should be recognized */
     744    }
     745#endif
     746    /* Now assume non-shared cursor/icon */
     747
     748    retv = GlobalFree( handle );
     749    return (flags & CID_RESOURCE)? retv : TRUE;
     750}
     751
     752/***********************************************************************
     753 *           CURSORICON_Copy
     754 *
     755 * Make a copy of a cursor or icon.
     756 */
     757static HGLOBAL CURSORICON_Copy( HINSTANCE hInstance, HGLOBAL handle )
     758{
     759    char *ptrOld, *ptrNew;
     760    int size;
     761    HGLOBAL hNew;
     762
     763    if (!(ptrOld = (char *)GlobalLock( handle ))) return 0;
     764
     765    size = GlobalSize( handle );
     766    hNew = GlobalAlloc( GMEM_MOVEABLE, size );
     767    ptrNew = (char *)GlobalLock( hNew );
     768    memcpy( ptrNew, ptrOld, size );
     769    GlobalUnlock( handle );
     770    GlobalUnlock( hNew );
     771    return hNew;
     772}
     773
     774/*************************************************************************
     775 * CURSORICON_ExtCopy
     776 *
     777 * Copies an Image from the Cache if LR_COPYFROMRESOURCE is specified
     778 *
     779 * PARAMS
     780 *      Handle     [I] handle to an Image
     781 *      nType      [I] Type of Handle (IMAGE_CURSOR | IMAGE_ICON)
     782 *      iDesiredCX [I] The Desired width of the Image
     783 *      iDesiredCY [I] The desired height of the Image
     784 *      nFlags     [I] The flags from CopyImage
     785 *
     786 * RETURNS
     787 *     Success: The new handle of the Image
     788 *
     789 * NOTES
     790 *     LR_COPYDELETEORG and LR_MONOCHROME are currently not implemented.
     791 *     LR_MONOCHROME should be implemented by CURSORICON_CreateFromResource.
     792 *     LR_COPYFROMRESOURCE will only work if the Image is in the Cache.
     793 *
     794 *
     795 */
     796
     797HGLOBAL CURSORICON_ExtCopy(HGLOBAL Handle, UINT nType,
     798               INT iDesiredCX, INT iDesiredCY,
     799               UINT nFlags)
     800{
     801    HGLOBAL hNew=0;
     802
     803    if(Handle == 0)
     804    {
     805        return 0;
     806    }
     807
     808    hNew = CURSORICON_Copy(0, Handle);
     809    return hNew;
     810}
     811
    223812/**********************************************************************
    224813 *          CURSORICON_FindBestIcon
    … …  
    329918}
    330919/**********************************************************************
    331  *          LookupIconIdFromDirectoryEx16       (USER.364)
     920 *          LookupIconIdFromDirectoryEx       (USER.364)
    332921 *
    333922 * FIXME: exact parameter sizes
    … …  
    373962           bIcon ? GetSystemMetrics(SM_CYICON) : GetSystemMetrics(SM_CYCURSOR), bIcon ? 0 : LR_MONOCHROME );
    374963}
    375 /*************************************************************************
    376  * CURSORICON_ExtCopy
    377  *
    378  * Copies an Image from the Cache if LR_COPYFROMRESOURCE is specified
    379  *
    380  * PARAMS
    381  *      Handle     [I] handle to an Image
    382  *      nType      [I] Type of Handle (IMAGE_CURSOR | IMAGE_ICON)
    383  *      iDesiredCX [I] The Desired width of the Image
    384  *      iDesiredCY [I] The desired height of the Image
    385  *      nFlags     [I] The flags from CopyImage
    386  *
    387  * RETURNS
    388  *     Success: The new handle of the Image
    389  *
    390  * NOTES
    391  *     LR_COPYDELETEORG and LR_MONOCHROME are currently not implemented.
    392  *     LR_MONOCHROME should be implemented by CURSORICON_CreateFromResource.
    393  *     LR_COPYFROMRESOURCE will only work if the Image is in the Cache.
    394  *
    395  *
    396  * TODO: LR_COPYFROMRESOURCE doesn't work. Uses supplied icon instead
    397  *
    398  */
    399 HGLOBAL CopyCursorIcon(HGLOBAL Handle, UINT nType,
    400                        INT iDesiredCX, INT iDesiredCY,
    401                        UINT nFlags)
    402 {
    403     HGLOBAL hNew=0;
    404     BOOL bIsIcon = (nType == IMAGE_ICON);
    405 
    406     if(Handle == 0)
    407     {
    408         return 0;
    409     }
    410 
    411     /* Best Fit or Monochrome */
    412     if(!bIsIcon || (nFlags & LR_COPYFROMRESOURCE
    413         && (iDesiredCX > 0 || iDesiredCY > 0))
    414         || nFlags & LR_MONOCHROME)
    415     {
    416             LPBYTE pBits;
    417             HANDLE hMem;
    418             HRSRC hRsrc;
    419             DWORD dwBytesInRes;
    420             WORD wResId;
    421             CURSORICONDIR *pDir;
    422             CURSORICONDIRENTRY *pDirEntry;
    423 
    424             /* Completing iDesiredCX CY for Monochrome Bitmaps if needed
    425             */
    426             if(((nFlags & LR_MONOCHROME) && !(nFlags & LR_COPYFROMRESOURCE))
    427                 || (iDesiredCX == 0 && iDesiredCY == 0))
    428             {
    429                 iDesiredCY = GetSystemMetrics(bIsIcon ?
    430                     SM_CYICON : SM_CYCURSOR);
    431                 iDesiredCX = GetSystemMetrics(bIsIcon ?
    432                     SM_CXICON : SM_CXCURSOR);
    433             }
    434 
    435             /* Create a New Icon with the proper dimension
    436             */
    437             ICONINFO iconinfo;
    438 
    439             GetIconInfo(Handle, &iconinfo);
    440             hNew = CreateIconIndirect(&iconinfo, bIsIcon, iDesiredCX, iDesiredCY, nFlags);
    441     }
    442     else
    443     {
    444         if(bIsIcon) {
    445                 return CopyIcon(Handle);
    446         }
    447         else    return CopyCursor(Handle);
    448     }
    449     return hNew;
    450 }
    451964//******************************************************************************
    452965//******************************************************************************
Note: See TracChangeset for help on using the changeset viewer.