windows/graphics.c

   1 /*
   2  * X-specific shortcuts to speed up WM code.
   3  * No coordinate transformations except origin translation.
   4  *
   5  * Copyright 1993, 1994 Alexandre Julliard
   6  */
   7
   8 #include <assert.h>
   9 #include <stdlib.h>
  10 #include "ts_xlib.h"
  11 #include "ts_xutil.h"
  12 #include <X11/Intrinsic.h>
  13 #include "graphics.h"
  14 #include "color.h"
  15 #include "bitmap.h"
  16 #include "gdi.h"
  17 #include "dc.h"
  18
  19 #define MAX_DRAWLINES 8
  20
  21
  22 /**********************************************************************
  23  *          GRAPH_DrawLines
  24  *
  25  * Draw multiple unconnected lines (limited by MAX_DRAWLINES).
  26  */
  27 BOOL32 GRAPH_DrawLines( HDC32 hdc, LPPOINT32 pXY, INT32 N, HPEN32 hPen )
  28 {
  29     BOOL32      bRet = FALSE;
  30     DC*         dc;
  31
  32     assert( N <= MAX_DRAWLINES );
  33     if( (dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )) )
  34     {
  35         HPEN32  hPrevPen  = 0;
  36
  37         if( hPen ) hPrevPen = SelectObject32( hdc, hPen );
  38         if( DC_SetupGCForPen( dc ) )
  39         {
  40             XSegment    l[MAX_DRAWLINES];
  41             INT32       i, j;
  42
  43             for( i = 0; i < N; i++ )
  44             {
  45                  j = 2 * i;
  46                  l[i].x1 = pXY[j].x + dc->w.DCOrgX;
  47                  l[i].x2 = pXY[j + 1].x + dc->w.DCOrgX;
  48                  l[i].y1 = pXY[j].y + dc->w.DCOrgY;
  49                  l[i].y2 = pXY[j + 1].y + dc->w.DCOrgY;
  50             }
  51             TSXDrawSegments( display, dc->u.x.drawable, dc->u.x.gc, l, N );
  52             bRet = TRUE;
  53         }
  54         if( hPrevPen ) SelectObject32( hdc, hPrevPen );
  55         GDI_HEAP_UNLOCK( hdc );
  56     }
  57     return bRet;
  58 }
  59
  60 /**********************************************************************
  61  *
  62  *          GRAPH_DrawBitmap
  63  *
  64  * Short-cut function to blit a bitmap into a device.
  65  * Faster than CreateCompatibleDC() + SelectBitmap() + BitBlt() + DeleteDC().
  66  */
  67 BOOL32 GRAPH_DrawBitmap( HDC32 hdc, HBITMAP32 hbitmap,
  68                          INT32 xdest, INT32 ydest, INT32 xsrc, INT32 ysrc,
  69                          INT32 width, INT32 height, BOOL32 bMono )
  70 {
  71     BITMAPOBJ *bmp;
  72     DC *dc;
  73     BOOL32 ret = TRUE;
  74     X11DRV_PHYSBITMAP *pbitmap;
  75
  76     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE;
  77     if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
  78     {
  79         GDI_HEAP_UNLOCK( hdc );
  80         return FALSE;
  81     }
  82
  83     /* HACK for now */
  84     if(!bmp->DDBitmap)
  85         X11DRV_CreateBitmap( hbitmap );
  86     pbitmap = bmp->DDBitmap->physBitmap;
  87
  88     xdest += dc->w.DCOrgX; ydest += dc->w.DCOrgY;
  89
  90     TSXSetFunction( display, dc->u.x.gc, GXcopy );
  91     if (bmp->bitmap.bmBitsPixel == 1)
  92     {
  93         TSXSetForeground( display, dc->u.x.gc, dc->u.x.backgroundPixel );
  94         TSXSetBackground( display, dc->u.x.gc, dc->u.x.textPixel );
  95         TSXCopyPlane( display, pbitmap->pixmap, dc->u.x.drawable, dc->u.x.gc,
  96                     xsrc, ysrc, width, height, xdest, ydest, 1 );
  97     }
  98     else if (bmp->bitmap.bmBitsPixel == dc->w.bitsPerPixel)
  99     {
 100         if( bMono )
 101         {
 102             INT32       plane;
 103
 104             if( COLOR_GetMonoPlane(&plane) )
 105             {
 106                 TSXSetForeground(display, dc->u.x.gc, dc->u.x.backgroundPixel);
 107                 TSXSetBackground(display, dc->u.x.gc, dc->u.x.textPixel);
 108             }
 109             else
 110             {
 111                 TSXSetForeground(display, dc->u.x.gc, dc->u.x.textPixel);
 112                 TSXSetBackground(display, dc->u.x.gc, dc->u.x.backgroundPixel);
 113             }
 114             TSXCopyPlane( display, pbitmap->pixmap, dc->u.x.drawable, dc->u.x.gc,
 115                         xsrc, ysrc, width, height, xdest, ydest, plane );
 116         }
 117         else
 118         {
 119             TSXCopyArea( display, pbitmap->pixmap, dc->u.x.drawable,
 120                        dc->u.x.gc, xsrc, ysrc, width, height, xdest, ydest );
 121         }
 122     }
 123     else
 124     {
 125       ret = FALSE;
 126     }
 127
 128     GDI_HEAP_UNLOCK( hdc );
 129     GDI_HEAP_UNLOCK( hbitmap );
 130     return ret;
 131 }
 132
 133
 134 /**********************************************************************
 135  *          GRAPH_DrawReliefRect
 136  *
 137  * Used in the standard control code for button edge drawing.
 138  */
 139 void GRAPH_DrawReliefRect( HDC32 hdc, const RECT32 *rect, INT32 highlight_size,
 140                            INT32 shadow_size, BOOL32 pressed )
 141 {
 142     if(pressed)
 143         GRAPH_DrawGenericReliefRect(hdc, rect, highlight_size, shadow_size,
 144                                     GetSysColorBrush32(COLOR_BTNSHADOW),
 145                                     GetSysColorBrush32(COLOR_BTNHIGHLIGHT));
 146     else
 147         GRAPH_DrawGenericReliefRect(hdc, rect, highlight_size, shadow_size,
 148                                     GetSysColorBrush32(COLOR_BTNHIGHLIGHT),
 149                                     GetSysColorBrush32(COLOR_BTNSHADOW));
 150
 151     return;
 152 }
 153
 154
 155 /******************************************************************************
 156  *             GRAPH_DrawGenericReliefRect
 157  *
 158  *   Creates a rectangle with the specified highlight and shadow colors.
 159  *   Adapted from DrawReliefRect (which is somewhat misnamed).
 160  */
 161 void  GRAPH_DrawGenericReliefRect(
 162     HDC32  hdc,
 163     const  RECT32 *rect,
 164     INT32  highlight_size,
 165     INT32  shadow_size,
 166     HBRUSH32  highlight,
 167     HBRUSH32  shadow )
 168 {
 169     DC*         dc;
 170     HBRUSH32    hPrevBrush;
 171     INT32       w, h;
 172     RECT32      r = *rect;
 173
 174     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return;
 175
 176     OffsetRect32( &r, dc->w.DCOrgX, dc->w.DCOrgY);
 177     h = rect->bottom - rect->top;  w = rect->right - rect->left;
 178
 179     hPrevBrush = SelectObject32(hdc, highlight);
 180
 181     if ( DC_SetupGCForBrush( dc ) )
 182     {
 183          INT32  i;
 184
 185          TSXSetFunction( display, dc->u.x.gc, GXcopy );
 186          for (i = 0; i < highlight_size; i++)
 187          {
 188               TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 189                                         r.left + i, r.top, 1, h - i );
 190               TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 191                                         r.left, r.top + i, w - i, 1 );
 192          }
 193     }
 194
 195     SelectObject32( hdc, shadow );
 196     if ( DC_SetupGCForBrush( dc ) )
 197     {
 198          INT32  i;
 199
 200          TSXSetFunction( display, dc->u.x.gc, GXcopy );
 201          for (i = 0; i < shadow_size; i++)
 202          {
 203               TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 204                               r.right - i - 1, r.top + i, 1, h - i );
 205               TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 206                               r.left + i, r.bottom - i - 1, w - i, 1 );
 207          }
 208     }
 209
 210     SelectObject32( hdc, hPrevBrush );
 211     GDI_HEAP_UNLOCK( hdc );
 212 }
 213
 214
 215
 216 /**********************************************************************
 217  *          GRAPH_DrawRectangle
 218  */
 219 void GRAPH_DrawRectangle( HDC32 hdc, INT32 x, INT32 y,
 220                                      INT32 w, INT32 h, HPEN32 hPen )
 221 {
 222     DC* dc;
 223
 224     if( (dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )) )
 225     {
 226         HPEN32  hPrevPen  = 0;
 227
 228         if( hPen ) hPrevPen = SelectObject32( hdc, hPen );
 229         if( DC_SetupGCForPen( dc ) )
 230             TSXDrawRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 231                             x + dc->w.DCOrgX, y + dc->w.DCOrgY, w - 1, h - 1);
 232         if( hPrevPen ) SelectObject32( hdc, hPrevPen );
 233         GDI_HEAP_UNLOCK( hdc );
 234     }
 235 }
 236
 237 /**********************************************************************
 238  *          GRAPH_SelectClipMask
 239  */
 240 BOOL32 GRAPH_SelectClipMask( HDC32 hdc, HBITMAP32 hMonoBitmap, INT32 x, INT32 y)
 241 {
 242     BITMAPOBJ *bmp = NULL;
 243     DC *dc;
 244     X11DRV_PHYSBITMAP *pbitmap = NULL;
 245
 246     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE;
 247     if ( hMonoBitmap )
 248     {
 249        if ( !(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hMonoBitmap, BITMAP_MAGIC))
 250            || bmp->bitmap.bmBitsPixel != 1 )
 251        {
 252            GDI_HEAP_UNLOCK( hdc );
 253            return FALSE;
 254        }
 255
 256        /* HACK for now */
 257        if(!bmp->DDBitmap)
 258            X11DRV_CreateBitmap( hMonoBitmap );
 259        pbitmap = bmp->DDBitmap->physBitmap;
 260        TSXSetClipOrigin( display, dc->u.x.gc, dc->w.DCOrgX + x, dc->w.DCOrgY + y);
 261     }
 262
 263     TSXSetClipMask( display, dc->u.x.gc, (bmp) ? pbitmap->pixmap : None );
 264
 265     GDI_HEAP_UNLOCK( hdc );
 266     GDI_HEAP_UNLOCK( hMonoBitmap );
 267     return TRUE;
 268 }
 269