dlls/gdi/mfdrv/objects.c

   1 /*
   2  * GDI objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24
  25 #include "bitmap.h"
  26 #include "font.h"
  27 #include "wownt32.h"
  28 #include "mfdrv/metafiledrv.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(metafile);
  32
  33
  34 /***********************************************************************
  35  *           MFDRV_SelectBitmap
  36  */
  37 HBITMAP MFDRV_SelectBitmap( PHYSDEV dev, HBITMAP hbitmap )
  38 {
  39     return 0;
  40 }
  41
  42
  43 /******************************************************************
  44  *         MFDRV_CreateBrushIndirect
  45  */
  46
  47 INT16 MFDRV_CreateBrushIndirect(PHYSDEV dev, HBRUSH hBrush )
  48 {
  49     INT16 index = -1;
  50     DWORD size;
  51     METARECORD *mr;
  52     LOGBRUSH logbrush;
  53     METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
  54
  55     if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return -1;
  56
  57     switch(logbrush.lbStyle)
  58     {
  59     case BS_SOLID:
  60     case BS_NULL:
  61     case BS_HATCHED:
  62         {
  63             LOGBRUSH16 lb16;
  64
  65             lb16.lbStyle = logbrush.lbStyle;
  66             lb16.lbColor = logbrush.lbColor;
  67             lb16.lbHatch = logbrush.lbHatch;
  68             size = sizeof(METARECORD) + sizeof(LOGBRUSH16) - 2;
  69             mr = HeapAlloc( GetProcessHeap(), 0, size );
  70             mr->rdSize = size / 2;
  71             mr->rdFunction = META_CREATEBRUSHINDIRECT;
  72             memcpy( mr->rdParm, &lb16, sizeof(LOGBRUSH));
  73             break;
  74         }
  75     case BS_PATTERN:
  76         {
  77             BITMAP bm;
  78             BYTE *bits;
  79             BITMAPINFO *info;
  80             DWORD bmSize;
  81
  82             GetObjectA((HANDLE)logbrush.lbHatch, sizeof(bm), &bm);
  83             if(bm.bmBitsPixel != 1 || bm.bmPlanes != 1) {
  84                 FIXME("Trying to store a colour pattern brush\n");
  85                 goto done;
  86             }
  87
  88             bmSize = DIB_GetDIBImageBytes(bm.bmWidth, bm.bmHeight, 1);
  89
  90             size = sizeof(METARECORD) + sizeof(WORD) + sizeof(BITMAPINFO) +
  91               sizeof(RGBQUAD) + bmSize;
  92
  93             mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
  94             if(!mr) goto done;
  95             mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
  96             mr->rdSize = size / 2;
  97             mr->rdParm[0] = BS_PATTERN;
  98             mr->rdParm[1] = DIB_RGB_COLORS;
  99             info = (BITMAPINFO *)(mr->rdParm + 2);
 100
 101             info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 102             info->bmiHeader.biWidth = bm.bmWidth;
 103             info->bmiHeader.biHeight = bm.bmHeight;
 104             info->bmiHeader.biPlanes = 1;
 105             info->bmiHeader.biBitCount = 1;
 106             bits = ((BYTE *)info) + sizeof(BITMAPINFO) + sizeof(RGBQUAD);
 107
 108             GetDIBits(physDev->hdc, (HANDLE)logbrush.lbHatch, 0, bm.bmHeight,
 109                       bits, info, DIB_RGB_COLORS);
 110             *(DWORD *)info->bmiColors = 0;
 111             *(DWORD *)(info->bmiColors + 1) = 0xffffff;
 112             break;
 113         }
 114
 115     case BS_DIBPATTERN:
 116         {
 117               BITMAPINFO *info;
 118               DWORD bmSize, biSize;
 119
 120               info = GlobalLock16((HGLOBAL16)logbrush.lbHatch);
 121               if (info->bmiHeader.biCompression)
 122                   bmSize = info->bmiHeader.biSizeImage;
 123               else
 124                   bmSize = DIB_GetDIBImageBytes(info->bmiHeader.biWidth,
 125                                                 info->bmiHeader.biHeight,
 126                                                 info->bmiHeader.biBitCount);
 127               biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush.lbColor));
 128               size = sizeof(METARECORD) + biSize + bmSize + 2;
 129               mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 130               if(!mr) goto done;
 131               mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 132               mr->rdSize = size / 2;
 133               *(mr->rdParm) = logbrush.lbStyle;
 134               *(mr->rdParm + 1) = LOWORD(logbrush.lbColor);
 135               memcpy(mr->rdParm + 2, info, biSize + bmSize);
 136               break;
 137         }
 138         default:
 139             FIXME("Unkonwn brush style %x\n", logbrush.lbStyle);
 140             return -1;
 141     }
 142     index = MFDRV_AddHandleDC( dev );
 143     if(!MFDRV_WriteRecord( dev, mr, mr->rdSize * 2))
 144         index = -1;
 145     HeapFree(GetProcessHeap(), 0, mr);
 146 done:
 147     return index;
 148 }
 149
 150
 151 /***********************************************************************
 152  *           MFDRV_SelectBrush
 153  */
 154 HBRUSH MFDRV_SelectBrush( PHYSDEV dev, HBRUSH hbrush )
 155 {
 156     INT16 index;
 157     METARECORD mr;
 158
 159     index = MFDRV_CreateBrushIndirect( dev, hbrush );
 160     if(index == -1) return 0;
 161
 162     mr.rdSize = sizeof(mr) / 2;
 163     mr.rdFunction = META_SELECTOBJECT;
 164     mr.rdParm[0] = index;
 165     return MFDRV_WriteRecord( dev, &mr, mr.rdSize * 2) ? hbrush : 0;
 166 }
 167
 168 /******************************************************************
 169  *         MFDRV_CreateFontIndirect
 170  */
 171
 172 static BOOL MFDRV_CreateFontIndirect(PHYSDEV dev, HFONT hFont, LOGFONT16 *logfont)
 173 {
 174     int index;
 175     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
 176     METARECORD *mr = (METARECORD *)&buffer;
 177
 178     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
 179     mr->rdFunction = META_CREATEFONTINDIRECT;
 180     memcpy(&(mr->rdParm), logfont, sizeof(LOGFONT16));
 181     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2))) return FALSE;
 182
 183     mr->rdSize = sizeof(METARECORD) / 2;
 184     mr->rdFunction = META_SELECTOBJECT;
 185
 186     if ((index = MFDRV_AddHandleDC( dev )) == -1) return FALSE;
 187     *(mr->rdParm) = index;
 188     return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 189 }
 190
 191
 192 /***********************************************************************
 193  *           MFDRV_SelectFont
 194  */
 195 HFONT MFDRV_SelectFont( PHYSDEV dev, HFONT hfont )
 196 {
 197     LOGFONT16 lf16;
 198
 199     if (!GetObject16( HFONT_16(hfont), sizeof(lf16), &lf16 )) return HGDI_ERROR;
 200     if (MFDRV_CreateFontIndirect(dev, hfont, &lf16)) return 0;
 201     return HGDI_ERROR;
 202 }
 203
 204 /******************************************************************
 205  *         MFDRV_CreatePenIndirect
 206  */
 207 static BOOL MFDRV_CreatePenIndirect(PHYSDEV dev, HPEN hPen, LOGPEN16 *logpen)
 208 {
 209     int index;
 210     char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
 211     METARECORD *mr = (METARECORD *)&buffer;
 212
 213     mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
 214     mr->rdFunction = META_CREATEPENINDIRECT;
 215     memcpy(&(mr->rdParm), logpen, sizeof(*logpen));
 216     if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2))) return FALSE;
 217
 218     mr->rdSize = sizeof(METARECORD) / 2;
 219     mr->rdFunction = META_SELECTOBJECT;
 220
 221     if ((index = MFDRV_AddHandleDC( dev )) == -1) return FALSE;
 222     *(mr->rdParm) = index;
 223     return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 224 }
 225
 226
 227 /***********************************************************************
 228  *           MFDRV_SelectPen
 229  */
 230 HPEN MFDRV_SelectPen( PHYSDEV dev, HPEN hpen )
 231 {
 232     LOGPEN16 logpen;
 233
 234     if (!GetObject16( HPEN_16(hpen), sizeof(logpen), &logpen )) return 0;
 235     if (MFDRV_CreatePenIndirect( dev, hpen, &logpen )) return hpen;
 236     return 0;
 237 }