dlls/wing.dll16/wing.c

   1 /*
   2  * WinG support
   3  *
   4  * Copyright (C) Robert Pouliot <krynos@clic.net>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "wownt32.h"
  29 #include "wine/wingdi16.h"
  30 #include "wine/list.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(wing);
  34
  35 struct dib_segptr_bits
  36 {
  37     struct list entry;
  38     HBITMAP   bmp;
  39     WORD      sel;
  40     WORD      count;
  41 };
  42
  43 static struct list dib_segptr_list = LIST_INIT( dib_segptr_list );
  44
  45 /* remove saved bits for bitmaps that no longer exist */
  46 static void cleanup_segptr_bits(void)
  47 {
  48     unsigned int i;
  49     struct dib_segptr_bits *bits, *next;
  50
  51     LIST_FOR_EACH_ENTRY_SAFE( bits, next, &dib_segptr_list, struct dib_segptr_bits, entry )
  52     {
  53         if (GetObjectType( bits->bmp ) == OBJ_BITMAP) continue;
  54         for (i = 0; i < bits->count; i++) FreeSelector16( bits->sel + (i << __AHSHIFT) );
  55         list_remove( &bits->entry );
  56         HeapFree( GetProcessHeap(), 0, bits );
  57     }
  58 }
  59
  60 static SEGPTR alloc_segptr_bits( HBITMAP bmp, void *bits32 )
  61 {
  62     DIBSECTION dib;
  63     unsigned int i, size;
  64     struct dib_segptr_bits *bits;
  65
  66     cleanup_segptr_bits();
  67
  68     if (!(bits = HeapAlloc( GetProcessHeap(), 0, sizeof(*bits) ))) return 0;
  69
  70     GetObjectW( bmp, sizeof(dib), &dib );
  71     size = dib.dsBm.bmHeight * dib.dsBm.bmWidthBytes;
  72
  73     /* calculate number of sel's needed for size with 64K steps */
  74     bits->bmp   = bmp;
  75     bits->count = (size + 0xffff) / 0x10000;
  76     bits->sel   = AllocSelectorArray16( bits->count );
  77
  78     for (i = 0; i < bits->count; i++)
  79     {
  80         SetSelectorBase(bits->sel + (i << __AHSHIFT), (DWORD)bits32 + i * 0x10000);
  81         SetSelectorLimit16(bits->sel + (i << __AHSHIFT), size - 1); /* yep, limit is correct */
  82         size -= 0x10000;
  83     }
  84     list_add_head( &dib_segptr_list, &bits->entry );
  85     return MAKESEGPTR( bits->sel, 0 );
  86 }
  87
  88 /*************************************************************************
  89  * WING {WING}
  90  *
  91  * The Windows Game dll provides a number of functions designed to allow
  92  * programmers to bypass Gdi and write directly to video memory. The intention
  93  * was to bolster the use of Windows as a gaming platform and remove the
  94  * need for Dos based games using 32 bit Dos extenders.
  95  *
  96  * This initial approach could not compete with the performance of Dos games
  97  * (such as Doom and Warcraft) at the time, and so this dll was eventually
  98  * superseded by DirectX. It should not be used by new applications, and is
  99  * provided only for compatibility with older Windows programs.
 100  */
 101
 102 typedef enum WING_DITHER_TYPE
 103 {
 104   WING_DISPERSED_4x4, WING_DISPERSED_8x8, WING_CLUSTERED_4x4
 105 } WING_DITHER_TYPE;
 106
 107 /***********************************************************************
 108  *          WinGCreateDC        (WING.1001)
 109  *
 110  * Create a new WinG device context.
 111  *
 112  * PARAMS
 113  *  None.
 114  *
 115  * RETURNS
 116  *  Success: A handle to the created device context.
 117  *  Failure: A NULL handle.
 118  */
 119 HDC16 WINAPI WinGCreateDC16(void)
 120 {
 121     TRACE("(void)\n");
 122     return HDC_16( CreateCompatibleDC( 0 ));
 123 }
 124
 125 /***********************************************************************
 126  *  WinGRecommendDIBFormat    (WING.1002)
 127  *
 128  * Get the recommended format of bitmaps for the current display.
 129  *
 130  * PARAMS
 131  *  bmpi [O] Destination for format information
 132  *
 133  * RETURNS
 134  *  Success: TRUE. bmpi is filled with the best (fastest) bitmap format
 135  *  Failure: FALSE, if bmpi is NULL.
 136  */
 137 BOOL16 WINAPI WinGRecommendDIBFormat16(BITMAPINFO *bmpi)
 138 {
 139     TRACE("(%p)\n", bmpi);
 140
 141     if (!bmpi)
 142         return FALSE;
 143
 144     bmpi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 145     bmpi->bmiHeader.biWidth = 320;
 146     bmpi->bmiHeader.biHeight = -1;
 147     bmpi->bmiHeader.biPlanes = 1;
 148     bmpi->bmiHeader.biBitCount = 8;
 149     bmpi->bmiHeader.biCompression = BI_RGB;
 150     bmpi->bmiHeader.biSizeImage = 0;
 151     bmpi->bmiHeader.biXPelsPerMeter = 0;
 152     bmpi->bmiHeader.biYPelsPerMeter = 0;
 153     bmpi->bmiHeader.biClrUsed = 0;
 154     bmpi->bmiHeader.biClrImportant = 0;
 155
 156     return TRUE;
 157 }
 158
 159 /***********************************************************************
 160  *        WinGCreateBitmap    (WING.1003)
 161  *
 162  * Create a new WinG bitmap.
 163  *
 164  * PARAMS
 165  *  hdc  [I] WinG device context
 166  *  bmpi [I] Information about the bitmap
 167  *  bits [I] Location of the bitmap image data
 168  *
 169  * RETURNS
 170  *  Success: A handle to the created bitmap.
 171  *  Failure: A NULL handle.
 172  */
 173 HBITMAP16 WINAPI WinGCreateBitmap16(HDC16 hdc, BITMAPINFO *bmpi, SEGPTR *bits)
 174 {
 175     LPVOID bits32;
 176     HBITMAP hbitmap;
 177
 178     TRACE("(%d,%p,%p): create %dx%dx%d bitmap\n", hdc, bmpi, bits,
 179           bmpi->bmiHeader.biWidth, bmpi->bmiHeader.biHeight, bmpi->bmiHeader.biPlanes);
 180
 181     hbitmap = CreateDIBSection( HDC_32(hdc), bmpi, BI_RGB, &bits32, 0, 0 );
 182     if (hbitmap)
 183     {
 184         SEGPTR segptr = alloc_segptr_bits( hbitmap, bits32 );
 185         if (bits) *bits = segptr;
 186     }
 187     return HBITMAP_16(hbitmap);
 188 }
 189
 190 /***********************************************************************
 191  *  WinGGetDIBPointer   (WING.1004)
 192  */
 193 SEGPTR WINAPI WinGGetDIBPointer16(HBITMAP16 hWinGBitmap, BITMAPINFO* bmpi)
 194 {
 195     struct dib_segptr_bits *bits;
 196
 197     if (bmpi) FIXME( "%04x %p: setting BITMAPINFO not supported\n", hWinGBitmap, bmpi );
 198
 199     LIST_FOR_EACH_ENTRY( bits, &dib_segptr_list, struct dib_segptr_bits, entry )
 200         if (HBITMAP_16(bits->bmp) == hWinGBitmap) return MAKESEGPTR( bits->sel, 0 );
 201
 202     return 0;
 203 }
 204
 205 /***********************************************************************
 206  *  WinGSetDIBColorTable   (WING.1006)
 207  *
 208  * Set all or part of the color table for a WinG device context.
 209  *
 210  * PARAMS
 211  *  hdc    [I] WinG device context
 212  *  start  [I] Start color
 213  *  num    [I] Number of entries to set
 214  *  colors [I] Array of color data
 215  *
 216  * RETURNS
 217  *  The number of entries set.
 218  */
 219 UINT16 WINAPI WinGSetDIBColorTable16(HDC16 hdc, UINT16 start, UINT16 num, RGBQUAD *colors)
 220 {
 221     TRACE("(%d,%d,%d,%p)\n", hdc, start, num, colors);
 222     return SetDIBColorTable( HDC_32(hdc), start, num, colors );
 223 }
 224
 225 /***********************************************************************
 226  *  WinGGetDIBColorTable   (WING.1005)
 227  *
 228  * Get all or part of the color table for a WinG device context.
 229  *
 230  * PARAMS
 231  *  hdc    [I] WinG device context
 232  *  start  [I] Start color
 233  *  num    [I] Number of entries to set
 234  *  colors [O] Destination for the array of color data
 235  *
 236  * RETURNS
 237  *  The number of entries retrieved.
 238  */
 239 UINT16 WINAPI WinGGetDIBColorTable16(HDC16 hdc, UINT16 start, UINT16 num, RGBQUAD *colors)
 240 {
 241     TRACE("(%d,%d,%d,%p)\n", hdc, start, num, colors);
 242     return GetDIBColorTable( HDC_32(hdc), start, num, colors );
 243 }
 244
 245 /***********************************************************************
 246  *  WinGCreateHalfTonePalette   (WING.1007)
 247  *
 248  * Create a half tone palette.
 249  *
 250  * PARAMS
 251  *  None.
 252  *
 253  * RETURNS
 254  *  Success: A handle to the created palette.
 255  *  Failure: A NULL handle.
 256  */
 257 HPALETTE16 WINAPI WinGCreateHalfTonePalette16(void)
 258 {
 259     HDC hdc = CreateCompatibleDC(0);
 260     HPALETTE16 ret = HPALETTE_16( CreateHalftonePalette( hdc ));
 261     TRACE("(void)\n");
 262     DeleteDC( hdc );
 263     return ret;
 264 }
 265
 266 /***********************************************************************
 267  *  WinGCreateHalfToneBrush   (WING.1008)
 268  *
 269  * Create a half tone brush for a WinG device context.
 270  *
 271  * PARAMS
 272  *  winDC [I] WinG device context
 273  *  col   [I] Color
 274  *  type  [I] Desired dithering type.
 275  *
 276  * RETURNS
 277  *  Success: A handle to the created brush.
 278  *  Failure: A NULL handle.
 279  */
 280 HBRUSH16 WINAPI WinGCreateHalfToneBrush16(HDC16 winDC, COLORREF col,
 281                                             WING_DITHER_TYPE type)
 282 {
 283     TRACE("(%d,%d,%d)\n", winDC, col, type);
 284     return HBRUSH_16( CreateSolidBrush( col ));
 285 }
 286
 287 /***********************************************************************
 288  *  WinGStretchBlt   (WING.1009)
 289  *
 290  * See StretchBlt16.
 291  */
 292 BOOL16 WINAPI WinGStretchBlt16(HDC16 destDC, INT16 xDest, INT16 yDest,
 293                                INT16 widDest, INT16 heiDest,
 294                                HDC16 srcDC, INT16 xSrc, INT16 ySrc,
 295                                INT16 widSrc, INT16 heiSrc)
 296 {
 297     BOOL retval;
 298     TRACE("(%d,%d,...)\n", destDC, srcDC);
 299     SetStretchBltMode( HDC_32(destDC), COLORONCOLOR );
 300     retval = StretchBlt( HDC_32(destDC), xDest, yDest, widDest, heiDest,
 301                          HDC_32(srcDC), xSrc, ySrc, widSrc, heiSrc, SRCCOPY );
 302     SetStretchBltMode( HDC_32(destDC), BLACKONWHITE );
 303     return retval;
 304 }
 305
 306 /***********************************************************************
 307  *  WinGBitBlt   (WING.1010)
 308  *
 309  * See BitBlt16.
 310  */
 311 BOOL16 WINAPI WinGBitBlt16(HDC16 destDC, INT16 xDest, INT16 yDest,
 312                            INT16 widDest, INT16 heiDest, HDC16 srcDC,
 313                            INT16 xSrc, INT16 ySrc)
 314 {
 315     TRACE("(%d,%d,...)\n", destDC, srcDC);
 316     return BitBlt( HDC_32(destDC), xDest, yDest, widDest, heiDest, HDC_32(srcDC), xSrc, ySrc, SRCCOPY );
 317 }