dlls/wineps/brush.c

   1 /*
   2  *      PostScript brush handling
   3  *
   4  * Copyright 1998  Huw D M Davies
   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 "psdrv.h"
  22 #include "wine/debug.h"
  23 #include "winbase.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  26
  27 /***********************************************************************
  28  *           SelectBrush   (WINEPS.@)
  29  */
  30 HBRUSH PSDRV_SelectBrush( PSDRV_PDEVICE *physDev, HBRUSH hbrush )
  31 {
  32     LOGBRUSH logbrush;
  33
  34     if (!GetObjectA( hbrush, sizeof(logbrush), &logbrush )) return 0;
  35
  36     TRACE("hbrush = %p\n", hbrush);
  37
  38     switch(logbrush.lbStyle) {
  39
  40     case BS_SOLID:
  41         PSDRV_CreateColor(physDev, &physDev->brush.color, logbrush.lbColor);
  42         break;
  43
  44     case BS_NULL:
  45         break;
  46
  47     case BS_HATCHED:
  48         PSDRV_CreateColor(physDev, &physDev->brush.color, logbrush.lbColor);
  49         break;
  50
  51     case BS_PATTERN:
  52     case BS_DIBPATTERN:
  53         break;
  54
  55     default:
  56         FIXME("Unrecognized brush style %d\n", logbrush.lbStyle);
  57         break;
  58     }
  59
  60     physDev->brush.set = FALSE;
  61     return hbrush;
  62 }
  63
  64
  65 /**********************************************************************
  66  *
  67  *      PSDRV_SetBrush
  68  *
  69  */
  70 static BOOL PSDRV_SetBrush(PSDRV_PDEVICE *physDev)
  71 {
  72     LOGBRUSH logbrush;
  73     BOOL ret = TRUE;
  74
  75     if (!GetObjectA( GetCurrentObject(physDev->hdc,OBJ_BRUSH), sizeof(logbrush), &logbrush ))
  76     {
  77         ERR("Can't get BRUSHOBJ\n");
  78         return FALSE;
  79     }
  80
  81     switch (logbrush.lbStyle) {
  82     case BS_SOLID:
  83     case BS_HATCHED:
  84         PSDRV_WriteSetColor(physDev, &physDev->brush.color);
  85         break;
  86
  87     case BS_NULL:
  88         break;
  89
  90     default:
  91         ret = FALSE;
  92         break;
  93
  94     }
  95     physDev->brush.set = TRUE;
  96     return TRUE;
  97 }
  98
  99
 100 /**********************************************************************
 101  *
 102  *      PSDRV_Fill
 103  *
 104  */
 105 static BOOL PSDRV_Fill(PSDRV_PDEVICE *physDev, BOOL EO)
 106 {
 107     if(!EO)
 108         return PSDRV_WriteFill(physDev);
 109     else
 110         return PSDRV_WriteEOFill(physDev);
 111 }
 112
 113
 114 /**********************************************************************
 115  *
 116  *      PSDRV_Clip
 117  *
 118  */
 119 static BOOL PSDRV_Clip(PSDRV_PDEVICE *physDev, BOOL EO)
 120 {
 121     if(!EO)
 122         return PSDRV_WriteClip(physDev);
 123     else
 124         return PSDRV_WriteEOClip(physDev);
 125 }
 126
 127 /**********************************************************************
 128  *
 129  *      PSDRV_Brush
 130  *
 131  */
 132 BOOL PSDRV_Brush(PSDRV_PDEVICE *physDev, BOOL EO)
 133 {
 134     LOGBRUSH logbrush;
 135     BOOL ret = TRUE;
 136
 137     if (!GetObjectA( GetCurrentObject(physDev->hdc,OBJ_BRUSH), sizeof(logbrush), &logbrush ))
 138     {
 139         ERR("Can't get BRUSHOBJ\n");
 140         return FALSE;
 141     }
 142
 143     switch (logbrush.lbStyle) {
 144     case BS_SOLID:
 145         PSDRV_SetBrush(physDev);
 146         PSDRV_WriteGSave(physDev);
 147         PSDRV_Fill(physDev, EO);
 148         PSDRV_WriteGRestore(physDev);
 149         break;
 150
 151     case BS_HATCHED:
 152         PSDRV_SetBrush(physDev);
 153
 154         switch(logbrush.lbHatch) {
 155         case HS_VERTICAL:
 156         case HS_CROSS:
 157             PSDRV_WriteGSave(physDev);
 158             PSDRV_Clip(physDev, EO);
 159             PSDRV_WriteHatch(physDev);
 160             PSDRV_WriteStroke(physDev);
 161             PSDRV_WriteGRestore(physDev);
 162             if(logbrush.lbHatch == HS_VERTICAL)
 163                 break;
 164             /* else fallthrough for HS_CROSS */
 165
 166         case HS_HORIZONTAL:
 167             PSDRV_WriteGSave(physDev);
 168             PSDRV_Clip(physDev, EO);
 169             PSDRV_WriteRotate(physDev, 90.0);
 170             PSDRV_WriteHatch(physDev);
 171             PSDRV_WriteStroke(physDev);
 172             PSDRV_WriteGRestore(physDev);
 173             break;
 174
 175         case HS_FDIAGONAL:
 176         case HS_DIAGCROSS:
 177             PSDRV_WriteGSave(physDev);
 178             PSDRV_Clip(physDev, EO);
 179             PSDRV_WriteRotate(physDev, -45.0);
 180             PSDRV_WriteHatch(physDev);
 181             PSDRV_WriteStroke(physDev);
 182             PSDRV_WriteGRestore(physDev);
 183             if(logbrush.lbHatch == HS_FDIAGONAL)
 184                 break;
 185             /* else fallthrough for HS_DIAGCROSS */
 186
 187         case HS_BDIAGONAL:
 188             PSDRV_WriteGSave(physDev);
 189             PSDRV_Clip(physDev, EO);
 190             PSDRV_WriteRotate(physDev, 45.0);
 191             PSDRV_WriteHatch(physDev);
 192             PSDRV_WriteStroke(physDev);
 193             PSDRV_WriteGRestore(physDev);
 194             break;
 195
 196         default:
 197             ERR("Unknown hatch style\n");
 198             ret = FALSE;
 199             break;
 200         }
 201         break;
 202
 203     case BS_NULL:
 204         break;
 205
 206     case BS_PATTERN:
 207         {
 208             BITMAP bm;
 209             BYTE *bits;
 210             GetObjectA( (HBITMAP)logbrush.lbHatch, sizeof(BITMAP), &bm);
 211             TRACE("BS_PATTERN %dx%d %d bpp\n", bm.bmWidth, bm.bmHeight,
 212                   bm.bmBitsPixel);
 213             bits = HeapAlloc(PSDRV_Heap, 0, bm.bmWidthBytes * bm.bmHeight);
 214             GetBitmapBits( (HBITMAP)logbrush.lbHatch, bm.bmWidthBytes * bm.bmHeight, bits);
 215
 216             if(physDev->pi->ppd->LanguageLevel > 1) {
 217                 PSDRV_WriteGSave(physDev);
 218                 PSDRV_WritePatternDict(physDev, &bm, bits);
 219                 PSDRV_Fill(physDev, EO);
 220                 PSDRV_WriteGRestore(physDev);
 221             } else {
 222                 FIXME("Trying to set a pattern brush on a level 1 printer\n");
 223                 ret = FALSE;
 224             }
 225             HeapFree(PSDRV_Heap, 0, bits);
 226         }
 227         break;
 228
 229     case BS_DIBPATTERN:
 230         {
 231             BITMAPINFO *bmi = GlobalLock16(logbrush.lbHatch);
 232             UINT usage = logbrush.lbColor;
 233             TRACE("size %ldx%ldx%d\n", bmi->bmiHeader.biWidth,
 234                   bmi->bmiHeader.biHeight, bmi->bmiHeader.biBitCount);
 235             if(physDev->pi->ppd->LanguageLevel > 1) {
 236                 PSDRV_WriteGSave(physDev);
 237                 ret = PSDRV_WriteDIBPatternDict(physDev, bmi, usage);
 238                 PSDRV_Fill(physDev, EO);
 239                 PSDRV_WriteGRestore(physDev);
 240             } else {
 241                 FIXME("Trying to set a pattern brush on a level 1 printer\n");
 242                 ret = FALSE;
 243             }
 244             GlobalUnlock16(logbrush.lbHatch);
 245         }
 246         break;
 247
 248     default:
 249         ret = FALSE;
 250         break;
 251     }
 252     return ret;
 253 }