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