graphics/enhmetafiledrv/objects.c

   1 /*
   2  * Enhanced MetaFile objects
   3  *
   4  * Copyright 1999 Huw D M Davies
   5  */
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10
  11 #include "bitmap.h"
  12 #include "enhmetafiledrv.h"
  13 #include "debugtools.h"
  14
  15 DEFAULT_DEBUG_CHANNEL(enhmetafile);
  16
  17 /***********************************************************************
  18  *           EMFDRV_BITMAP_SelectObject
  19  */
  20 static HBITMAP EMFDRV_BITMAP_SelectObject( DC * dc, HBITMAP hbitmap )
  21 {
  22     return 0;
  23 }
  24
  25
  26 /***********************************************************************
  27  *           EMFDRV_CreateBrushIndirect
  28  */
  29 DWORD EMFDRV_CreateBrushIndirect( DC *dc, HBRUSH hBrush )
  30 {
  31     DWORD index = 0;
  32     LOGBRUSH logbrush;
  33
  34     if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return 0;
  35
  36     switch (logbrush.lbStyle) {
  37     case BS_SOLID:
  38     case BS_HATCHED:
  39     case BS_NULL:
  40       {
  41         EMRCREATEBRUSHINDIRECT emr;
  42         emr.emr.iType = EMR_CREATEBRUSHINDIRECT;
  43         emr.emr.nSize = sizeof(emr);
  44         emr.ihBrush = index = EMFDRV_AddHandleDC( dc );
  45         emr.lb = logbrush;
  46
  47         if(!EMFDRV_WriteRecord( dc, &emr.emr ))
  48             index = 0;
  49       }
  50       break;
  51     case BS_DIBPATTERN:
  52       {
  53         EMRCREATEDIBPATTERNBRUSHPT *emr;
  54         DWORD bmSize, biSize, size;
  55         BITMAPINFO *info = GlobalLock16(logbrush.lbHatch);
  56
  57         if (info->bmiHeader.biCompression)
  58             bmSize = info->bmiHeader.biSizeImage;
  59         else
  60             bmSize = DIB_GetDIBImageBytes(info->bmiHeader.biWidth,
  61                                           info->bmiHeader.biHeight,
  62                                           info->bmiHeader.biBitCount);
  63         biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush.lbColor));
  64         size = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize + bmSize;
  65         emr = HeapAlloc( GetProcessHeap(), 0, size );
  66         if(!emr) break;
  67         emr->emr.iType = EMR_CREATEDIBPATTERNBRUSHPT;
  68         emr->emr.nSize = size;
  69         emr->ihBrush = index = EMFDRV_AddHandleDC( dc );
  70         emr->iUsage = LOWORD(logbrush.lbColor);
  71         emr->offBmi = sizeof(EMRCREATEDIBPATTERNBRUSHPT);
  72         emr->cbBmi = biSize;
  73         emr->offBits = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize;
  74         memcpy((char *)emr + sizeof(EMRCREATEDIBPATTERNBRUSHPT), info,
  75                biSize + bmSize );
  76
  77         if(!EMFDRV_WriteRecord( dc, &emr->emr ))
  78             index = 0;
  79         HeapFree( GetProcessHeap(), 0, emr );
  80         GlobalUnlock16(logbrush.lbHatch);
  81       }
  82       break;
  83
  84     case BS_PATTERN:
  85         FIXME("Unsupported style %x\n",
  86               logbrush.lbStyle);
  87         break;
  88     default:
  89         FIXME("Unknown style %x\n", logbrush.lbStyle);
  90         break;
  91     }
  92     return index;
  93 }
  94
  95
  96 /***********************************************************************
  97  *           EMFDRV_BRUSH_SelectObject
  98  */
  99 static HBRUSH EMFDRV_BRUSH_SelectObject(DC *dc, HBRUSH hBrush )
 100 {
 101     EMRSELECTOBJECT emr;
 102     DWORD index;
 103     HBRUSH hOldBrush;
 104     int i;
 105
 106     /* If the object is a stock brush object, do not need to create it.
 107      * See definitions in  wingdi.h for range of stock brushes.
 108      * We do however have to handle setting the higher order bit to
 109      * designate that this is a stock object.
 110      */
 111     for (i = WHITE_BRUSH; i <= NULL_BRUSH; i++)
 112     {
 113         if (hBrush == GetStockObject(i))
 114         {
 115             index = i | 0x80000000;
 116             goto found;
 117         }
 118     }
 119     if (!(index = EMFDRV_CreateBrushIndirect(dc, hBrush ))) return 0;
 120
 121  found:
 122     emr.emr.iType = EMR_SELECTOBJECT;
 123     emr.emr.nSize = sizeof(emr);
 124     emr.ihObject = index;
 125     if(!EMFDRV_WriteRecord( dc, &emr.emr ))
 126         return FALSE;
 127
 128     hOldBrush = dc->hBrush;
 129     dc->hBrush = hBrush;
 130     return hOldBrush;
 131 }
 132
 133
 134 /******************************************************************
 135  *         EMFDRV_CreateFontIndirect
 136  */
 137 static BOOL EMFDRV_CreateFontIndirect(DC *dc, HFONT hFont )
 138 {
 139     DWORD index = 0;
 140     EMREXTCREATEFONTINDIRECTW emr;
 141     int i;
 142
 143     if (!GetObjectW( hFont, sizeof(emr.elfw.elfLogFont), &emr.elfw.elfLogFont )) return 0;
 144
 145     emr.emr.iType = EMR_EXTCREATEFONTINDIRECTW;
 146     emr.emr.nSize = (sizeof(emr) + 3) / 4 * 4;
 147     emr.ihFont = index = EMFDRV_AddHandleDC( dc );
 148     emr.elfw.elfFullName[0] = '\0';
 149     emr.elfw.elfStyle[0]    = '\0';
 150     emr.elfw.elfVersion     = 0;
 151     emr.elfw.elfStyleSize   = 0;
 152     emr.elfw.elfMatch       = 0;
 153     emr.elfw.elfReserved    = 0;
 154     for(i = 0; i < ELF_VENDOR_SIZE; i++)
 155         emr.elfw.elfVendorId[i] = 0;
 156     emr.elfw.elfCulture                 = PAN_CULTURE_LATIN;
 157     emr.elfw.elfPanose.bFamilyType      = PAN_NO_FIT;
 158     emr.elfw.elfPanose.bSerifStyle      = PAN_NO_FIT;
 159     emr.elfw.elfPanose.bWeight          = PAN_NO_FIT;
 160     emr.elfw.elfPanose.bProportion      = PAN_NO_FIT;
 161     emr.elfw.elfPanose.bContrast        = PAN_NO_FIT;
 162     emr.elfw.elfPanose.bStrokeVariation = PAN_NO_FIT;
 163     emr.elfw.elfPanose.bArmStyle        = PAN_NO_FIT;
 164     emr.elfw.elfPanose.bLetterform      = PAN_NO_FIT;
 165     emr.elfw.elfPanose.bMidline         = PAN_NO_FIT;
 166     emr.elfw.elfPanose.bXHeight         = PAN_NO_FIT;
 167
 168     if(!EMFDRV_WriteRecord( dc, &emr.emr ))
 169         index = 0;
 170     return index;
 171 }
 172
 173
 174 /***********************************************************************
 175  *           EMFDRV_FONT_SelectObject
 176  */
 177 static HFONT EMFDRV_FONT_SelectObject( DC * dc, HFONT hFont )
 178 {
 179     EMRSELECTOBJECT emr;
 180     DWORD index;
 181     int i;
 182
 183     /* If the object is a stock font object, do not need to create it.
 184      * See definitions in  wingdi.h for range of stock fonts.
 185      * We do however have to handle setting the higher order bit to
 186      * designate that this is a stock object.
 187      */
 188
 189     for (i = OEM_FIXED_FONT; i <= DEFAULT_GUI_FONT; i++)
 190     {
 191         if (i != DEFAULT_PALETTE && hFont == GetStockObject(i))
 192         {
 193             index = i | 0x80000000;
 194             goto found;
 195         }
 196     }
 197     if (!(index = EMFDRV_CreateFontIndirect(dc, hFont ))) return GDI_ERROR;
 198  found:
 199     emr.emr.iType = EMR_SELECTOBJECT;
 200     emr.emr.nSize = sizeof(emr);
 201     emr.ihObject = index;
 202     if(!EMFDRV_WriteRecord( dc, &emr.emr ))
 203         return GDI_ERROR;
 204
 205     return FALSE;
 206 }
 207
 208
 209
 210 /******************************************************************
 211  *         EMFDRV_CreatePenIndirect
 212  */
 213 static HPEN EMFDRV_CreatePenIndirect(DC *dc, HPEN hPen )
 214 {
 215     EMRCREATEPEN emr;
 216     DWORD index = 0;
 217
 218     if (!GetObjectA( hPen, sizeof(emr.lopn), &emr.lopn )) return 0;
 219
 220     emr.emr.iType = EMR_CREATEPEN;
 221     emr.emr.nSize = sizeof(emr);
 222     emr.ihPen = index = EMFDRV_AddHandleDC( dc );
 223
 224     if(!EMFDRV_WriteRecord( dc, &emr.emr ))
 225         index = 0;
 226     return index;
 227 }
 228
 229 /******************************************************************
 230  *         EMFDRV_PEN_SelectObject
 231  */
 232 static HPEN EMFDRV_PEN_SelectObject(DC *dc, HPEN hPen )
 233 {
 234     EMRSELECTOBJECT emr;
 235     DWORD index;
 236     HPEN hOldPen;
 237     int i;
 238
 239     /* If the object is a stock pen object, do not need to create it.
 240      * See definitions in  wingdi.h for range of stock pens.
 241      * We do however have to handle setting the higher order bit to
 242      * designate that this is a stock object.
 243      */
 244
 245     for (i = WHITE_PEN; i <= NULL_PEN; i++)
 246     {
 247         if (hPen == GetStockObject(i))
 248         {
 249             index = i | 0x80000000;
 250             goto found;
 251         }
 252     }
 253     if (!(index = EMFDRV_CreatePenIndirect(dc, hPen ))) return 0;
 254  found:
 255     emr.emr.iType = EMR_SELECTOBJECT;
 256     emr.emr.nSize = sizeof(emr);
 257     emr.ihObject = index;
 258     if(!EMFDRV_WriteRecord( dc, &emr.emr ))
 259         return FALSE;
 260
 261     hOldPen = dc->hPen;
 262     dc->hPen = hPen;
 263     return hOldPen;
 264 }
 265
 266
 267 /***********************************************************************
 268  *           EMFDRV_SelectObject
 269  */
 270 HGDIOBJ EMFDRV_SelectObject( DC *dc, HGDIOBJ handle )
 271 {
 272     GDIOBJHDR * ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
 273     HGDIOBJ ret = 0;
 274
 275     if (!ptr) return 0;
 276     TRACE("hdc=%04x %04x\n", dc->hSelf, handle );
 277
 278     switch(GDIMAGIC(ptr->wMagic))
 279     {
 280       case PEN_MAGIC:
 281           ret = EMFDRV_PEN_SelectObject( dc, handle );
 282           break;
 283       case BRUSH_MAGIC:
 284           ret = EMFDRV_BRUSH_SelectObject( dc, handle );
 285           break;
 286       case FONT_MAGIC:
 287           ret = EMFDRV_FONT_SelectObject( dc, handle );
 288           break;
 289       case BITMAP_MAGIC:
 290           ret = EMFDRV_BITMAP_SelectObject( dc, handle );
 291           break;
 292     }
 293     GDI_ReleaseObj( handle );
 294     return ret;
 295 }
 296
 297