graphics/metafiledrv/objects.c

   1 /*
   2  * GDI objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include "bitmap.h"
  10 #include "brush.h"
  11 #include "font.h"
  12 #include "metafiledrv.h"
  13 #include "pen.h"
  14 #include "debug.h"
  15 #include "heap.h"
  16
  17 DECLARE_DEBUG_CHANNEL(gdi)
  18 DECLARE_DEBUG_CHANNEL(metafile)
  19
  20 /***********************************************************************
  21  *           MFDRV_BITMAP_SelectObject
  22  */
  23 static HBITMAP16 MFDRV_BITMAP_SelectObject( DC * dc, HBITMAP16 hbitmap,
  24                                             BITMAPOBJ * bmp )
  25 {
  26     return 0;
  27 }
  28
  29
  30 /******************************************************************
  31  *         MFDRV_CreateBrushIndirect
  32  */
  33
  34 static BOOL MFDRV_CreateBrushIndirect(DC *dc, HBRUSH16 hBrush,
  35                                       LOGBRUSH16 *logbrush)
  36 {
  37     int index;
  38     char buffer[sizeof(METARECORD) - 2 + sizeof(*logbrush)];
  39     METARECORD *mr = (METARECORD *)&buffer;
  40
  41     mr->rdSize = (sizeof(METARECORD) + sizeof(*logbrush) - 2) / 2;
  42     mr->rdFunction = META_CREATEBRUSHINDIRECT;
  43     memcpy(&(mr->rdParm), logbrush, sizeof(*logbrush));
  44     if (!(MFDRV_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
  45
  46     mr->rdSize = sizeof(METARECORD) / 2;
  47     mr->rdFunction = META_SELECTOBJECT;
  48
  49     if ((index = MFDRV_AddHandleDC( dc )) == -1) return FALSE;
  50     *(mr->rdParm) = index;
  51     return MFDRV_WriteRecord( dc, mr, mr->rdSize * 2);
  52 }
  53
  54
  55 /******************************************************************
  56  *         MFDRV_CreatePatternBrush
  57  */
  58 static BOOL MFDRV_CreatePatternBrush(DC *dc, HBRUSH16 hBrush,
  59                                      LOGBRUSH16 *logbrush)
  60 {
  61     DWORD len, bmSize, biSize;
  62     METARECORD *mr;
  63     BITMAPINFO *info;
  64     int index;
  65     char buffer[sizeof(METARECORD)];
  66
  67     switch (logbrush->lbStyle)
  68     {
  69     case BS_PATTERN:
  70         {
  71             BITMAP bm;
  72             BYTE *bits;
  73
  74             GetObjectA(logbrush->lbHatch, sizeof(bm), &bm);
  75             if(bm.bmBitsPixel != 1 || bm.bmPlanes != 1) {
  76                 FIXME(metafile, "Trying to store a colour pattern brush\n");
  77                 return FALSE;
  78             }
  79
  80             bmSize = DIB_GetDIBImageBytes(bm.bmWidth, bm.bmHeight, 1);
  81
  82             len = sizeof(METARECORD) +  sizeof(WORD) + sizeof(BITMAPINFO) +
  83               sizeof(RGBQUAD) + bmSize;
  84
  85             mr = HeapAlloc(SystemHeap, HEAP_ZERO_MEMORY, len);
  86             if(!mr) return FALSE;
  87             mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
  88             mr->rdSize = len / 2;
  89             mr->rdParm[0] = BS_PATTERN;
  90             mr->rdParm[1] = DIB_RGB_COLORS;
  91             info = (BITMAPINFO *)(mr->rdParm + 2);
  92
  93             info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  94             info->bmiHeader.biWidth = bm.bmWidth;
  95             info->bmiHeader.biHeight = bm.bmHeight;
  96             info->bmiHeader.biPlanes = 1;
  97             info->bmiHeader.biBitCount = 1;
  98             bits = ((BYTE *)info) + sizeof(BITMAPINFO) + sizeof(RGBQUAD);
  99
 100             GetDIBits(dc->hSelf, logbrush->lbHatch, 0, bm.bmHeight, bits,
 101                       info, DIB_RGB_COLORS);
 102             *(DWORD *)info->bmiColors = 0;
 103             *(DWORD *)(info->bmiColors + 1) = 0xffffff;
 104             break;
 105         }
 106
 107     case BS_DIBPATTERN:
 108         info = (BITMAPINFO *)GlobalLock16((HGLOBAL16)logbrush->lbHatch);
 109         if (info->bmiHeader.biCompression)
 110             bmSize = info->bmiHeader.biSizeImage;
 111         else
 112             bmSize = DIB_GetDIBImageBytes(info->bmiHeader.biWidth,
 113                                           info->bmiHeader.biHeight,
 114                                           info->bmiHeader.biBitCount);
 115         biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush->lbColor));
 116         len = sizeof(METARECORD) + biSize + bmSize + 2;
 117         mr = HeapAlloc(SystemHeap, HEAP_ZERO_MEMORY, len);
 118         if(!mr) return FALSE;
 119         mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
 120         mr->rdSize = len / 2;
 121         *(mr->rdParm) = logbrush->lbStyle;
 122         *(mr->rdParm + 1) = LOWORD(logbrush->lbColor);
 123         memcpy(mr->rdParm + 2, info, biSize + bmSize);
 124         break;
 125     default:
 126         return FALSE;
 127     }
 128     if (!(MFDRV_WriteRecord(dc, mr, len)))
 129     {
 130         HeapFree(SystemHeap, 0, mr);
 131         return FALSE;
 132     }
 133
 134     HeapFree(SystemHeap, 0, mr);
 135
 136     mr = (METARECORD *)&buffer;
 137     mr->rdSize = sizeof(METARECORD) / 2;
 138     mr->rdFunction = META_SELECTOBJECT;
 139
 140     if ((index = MFDRV_AddHandleDC( dc )) == -1) return FALSE;
 141     *(mr->rdParm) = index;
 142     return MFDRV_WriteRecord( dc, mr, mr->rdSize * 2);
 143 }
 144
 145 /***********************************************************************
 146  *           MFDRV_BRUSH_SelectObject
 147  */
 148 static HBRUSH MFDRV_BRUSH_SelectObject( DC * dc, HBRUSH hbrush,
 149                                           BRUSHOBJ * brush )
 150 {
 151     LOGBRUSH16 logbrush = { brush->logbrush.lbStyle,
 152                             brush->logbrush.lbColor,
 153                             brush->logbrush.lbHatch };
 154     switch (brush->logbrush.lbStyle)
 155     {
 156     case BS_SOLID:
 157     case BS_HATCHED:
 158     case BS_HOLLOW:
 159         if (!MFDRV_CreateBrushIndirect( dc, hbrush, &logbrush )) return 0;
 160         break;
 161     case BS_PATTERN:
 162     case BS_DIBPATTERN:
 163         if (!MFDRV_CreatePatternBrush( dc, hbrush, &logbrush )) return 0;
 164         break;
 165     }
 166     return 1;  /* FIXME? */
 167 }
 168
 169 /******************************************************************
 170  *         MFDRV_CreateFontIndirect
 171  */
 172
 173 static BOOL MFDRV_CreateFontIndirect(DC *dc, HFONT16 hFont, LOGFONT16 *logfont)
 174 {
 175     int index;
 176     char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
 177     METARECORD *mr = (METARECORD *)&buffer;
 178
 179     mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
 180     mr->rdFunction = META_CREATEFONTINDIRECT;
 181     memcpy(&(mr->rdParm), logfont, sizeof(LOGFONT16));
 182     if (!(MFDRV_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
 183
 184     mr->rdSize = sizeof(METARECORD) / 2;
 185     mr->rdFunction = META_SELECTOBJECT;
 186
 187     if ((index = MFDRV_AddHandleDC( dc )) == -1) return FALSE;
 188     *(mr->rdParm) = index;
 189     return MFDRV_WriteRecord( dc, mr, mr->rdSize * 2);
 190 }
 191
 192
 193 /***********************************************************************
 194  *           MFDRV_FONT_SelectObject
 195  */
 196 static HFONT16 MFDRV_FONT_SelectObject( DC * dc, HFONT16 hfont,
 197                                         FONTOBJ * font )
 198 {
 199     HFONT16 prevHandle = dc->w.hFont;
 200     if (MFDRV_CreateFontIndirect(dc, hfont, &(font->logfont)))
 201         return prevHandle;
 202     return 0;
 203 }
 204
 205 /******************************************************************
 206  *         MFDRV_CreatePenIndirect
 207  */
 208 static BOOL MFDRV_CreatePenIndirect(DC *dc, HPEN16 hPen, LOGPEN16 *logpen)
 209 {
 210     int index;
 211     char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
 212     METARECORD *mr = (METARECORD *)&buffer;
 213
 214     mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
 215     mr->rdFunction = META_CREATEPENINDIRECT;
 216     memcpy(&(mr->rdParm), logpen, sizeof(*logpen));
 217     if (!(MFDRV_WriteRecord( dc, mr, mr->rdSize * 2))) return FALSE;
 218
 219     mr->rdSize = sizeof(METARECORD) / 2;
 220     mr->rdFunction = META_SELECTOBJECT;
 221
 222     if ((index = MFDRV_AddHandleDC( dc )) == -1) return FALSE;
 223     *(mr->rdParm) = index;
 224     return MFDRV_WriteRecord( dc, mr, mr->rdSize * 2);
 225 }
 226
 227
 228 /***********************************************************************
 229  *           MFDRV_PEN_SelectObject
 230  */
 231 static HPEN MFDRV_PEN_SelectObject( DC * dc, HPEN hpen, PENOBJ * pen )
 232 {
 233     HPEN prevHandle = dc->w.hPen;
 234     LOGPEN16 logpen = { pen->logpen.lopnStyle,
 235                         { pen->logpen.lopnWidth.x, pen->logpen.lopnWidth.y },
 236                         pen->logpen.lopnColor };
 237     if (MFDRV_CreatePenIndirect( dc, hpen, &logpen )) return prevHandle;
 238     return 0;
 239 }
 240
 241
 242 /***********************************************************************
 243  *           MFDRV_SelectObject
 244  */
 245 HGDIOBJ MFDRV_SelectObject( DC *dc, HGDIOBJ handle )
 246 {
 247     GDIOBJHDR * ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
 248     HGDIOBJ ret = 0;
 249
 250     if (!ptr) return 0;
 251     TRACE(gdi, "hdc=%04x %04x\n", dc->hSelf, handle );
 252
 253     switch(ptr->wMagic)
 254     {
 255       case PEN_MAGIC:
 256           ret = MFDRV_PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
 257           break;
 258       case BRUSH_MAGIC:
 259           ret = MFDRV_BRUSH_SelectObject( dc, handle, (BRUSHOBJ *)ptr );
 260           break;
 261       case BITMAP_MAGIC:
 262           ret = MFDRV_BITMAP_SelectObject( dc, handle, (BITMAPOBJ *)ptr );
 263           break;
 264       case FONT_MAGIC:
 265           ret = MFDRV_FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
 266           break;
 267       case REGION_MAGIC:
 268           ret = (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
 269           break;
 270     }
 271     GDI_HEAP_UNLOCK( handle );
 272     return ret;
 273 }
 274
 275