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
  75     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE;
  76     if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
  77     {
  78         GDI_HEAP_UNLOCK( hdc );
  79         return FALSE;
  80     }
  81
  82     xdest += dc->w.DCOrgX; ydest += dc->w.DCOrgY;
  83
  84     TSXSetFunction( display, dc->u.x.gc, GXcopy );
  85     if (bmp->bitmap.bmBitsPixel == 1)
  86     {
  87         TSXSetForeground( display, dc->u.x.gc, dc->u.x.backgroundPixel );
  88         TSXSetBackground( display, dc->u.x.gc, dc->u.x.textPixel );
  89         TSXCopyPlane( display, bmp->pixmap, dc->u.x.drawable, dc->u.x.gc,
  90                     xsrc, ysrc, width, height, xdest, ydest, 1 );
  91     }
  92     else if (bmp->bitmap.bmBitsPixel == dc->w.bitsPerPixel)
  93     {
  94         if( bMono )
  95         {
  96             INT32       plane;
  97
  98             if( COLOR_GetMonoPlane(&plane) )
  99             {
 100                 TSXSetForeground(display, dc->u.x.gc, dc->u.x.backgroundPixel);
 101                 TSXSetBackground(display, dc->u.x.gc, dc->u.x.textPixel);
 102             }
 103             else
 104             {
 105                 TSXSetForeground(display, dc->u.x.gc, dc->u.x.textPixel);
 106                 TSXSetBackground(display, dc->u.x.gc, dc->u.x.backgroundPixel);
 107             }
 108             TSXCopyPlane( display, bmp->pixmap, dc->u.x.drawable, dc->u.x.gc,
 109                         xsrc, ysrc, width, height, xdest, ydest, plane );
 110         }
 111         else
 112         {
 113             TSXCopyArea( display, bmp->pixmap, dc->u.x.drawable,
 114                        dc->u.x.gc, xsrc, ysrc, width, height, xdest, ydest );
 115         }
 116     }
 117     else
 118     {
 119       ret = FALSE;
 120     }
 121
 122     GDI_HEAP_UNLOCK( hdc );
 123     GDI_HEAP_UNLOCK( hbitmap );
 124     return ret;
 125 }
 126
 127
 128 /**********************************************************************
 129  *          GRAPH_DrawReliefRect
 130  *
 131  * Used in the standard control code for button edge drawing.
 132  */
 133 void GRAPH_DrawReliefRect( HDC32 hdc, const RECT32 *rect, INT32 highlight_size,
 134                            INT32 shadow_size, BOOL32 pressed )
 135 {
 136     if(pressed)
 137         GRAPH_DrawGenericReliefRect(hdc, rect, highlight_size, shadow_size,
 138                                     GetSysColorBrush32(COLOR_BTNSHADOW),
 139                                     GetSysColorBrush32(COLOR_BTNHIGHLIGHT));
 140     else
 141         GRAPH_DrawGenericReliefRect(hdc, rect, highlight_size, shadow_size,
 142                                     GetSysColorBrush32(COLOR_BTNHIGHLIGHT),
 143                                     GetSysColorBrush32(COLOR_BTNSHADOW));
 144
 145     return;
 146 }
 147
 148
 149 /******************************************************************************
 150  *             GRAPH_DrawGenericReliefRect
 151  *
 152  *   Creates a rectangle with the specified highlight and shadow colors.
 153  *   Adapted from DrawReliefRect (which is somewhat misnamed).
 154  */
 155 void  GRAPH_DrawGenericReliefRect(
 156     HDC32  hdc,
 157     const  RECT32 *rect,
 158     INT32  highlight_size,
 159     INT32  shadow_size,
 160     HBRUSH32  highlight,
 161     HBRUSH32  shadow )
 162 {
 163     DC*         dc;
 164     HBRUSH32    hPrevBrush;
 165     INT32       w, h;
 166     RECT32      r = *rect;
 167
 168     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return;
 169
 170     OffsetRect32( &r, dc->w.DCOrgX, dc->w.DCOrgY);
 171     h = rect->bottom - rect->top;  w = rect->right - rect->left;
 172
 173     hPrevBrush = SelectObject32(hdc, highlight);
 174
 175     if ( DC_SetupGCForBrush( dc ) )
 176     {
 177          INT32  i;
 178
 179          TSXSetFunction( display, dc->u.x.gc, GXcopy );
 180          for (i = 0; i < highlight_size; i++)
 181          {
 182               TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 183                                         r.left + i, r.top, 1, h - i );
 184               TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 185                                         r.left, r.top + i, w - i, 1 );
 186          }
 187     }
 188
 189     SelectObject32( hdc, shadow );
 190     if ( DC_SetupGCForBrush( dc ) )
 191     {
 192          INT32  i;
 193
 194          TSXSetFunction( display, dc->u.x.gc, GXcopy );
 195          for (i = 0; i < shadow_size; i++)
 196          {
 197               TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 198                               r.right - i - 1, r.top + i, 1, h - i );
 199               TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 200                               r.left + i, r.bottom - i - 1, w - i, 1 );
 201          }
 202     }
 203
 204     SelectObject32( hdc, hPrevBrush );
 205     GDI_HEAP_UNLOCK( hdc );
 206 }
 207
 208
 209
 210 /**********************************************************************
 211  *          GRAPH_DrawRectangle
 212  */
 213 void GRAPH_DrawRectangle( HDC32 hdc, INT32 x, INT32 y,
 214                                      INT32 w, INT32 h, HPEN32 hPen )
 215 {
 216     DC* dc;
 217
 218     if( (dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC )) )
 219     {
 220         HPEN32  hPrevPen  = 0;
 221
 222         if( hPen ) hPrevPen = SelectObject32( hdc, hPen );
 223         if( DC_SetupGCForPen( dc ) )
 224             TSXDrawRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 225                             x + dc->w.DCOrgX, y + dc->w.DCOrgY, w - 1, h - 1);
 226         if( hPrevPen ) SelectObject32( hdc, hPrevPen );
 227         GDI_HEAP_UNLOCK( hdc );
 228     }
 229 }
 230
 231 /**********************************************************************
 232  *          GRAPH_SelectClipMask
 233  */
 234 BOOL32 GRAPH_SelectClipMask( HDC32 hdc, HBITMAP32 hMonoBitmap, INT32 x, INT32 y)
 235 {
 236     BITMAPOBJ *bmp = NULL;
 237     DC *dc;
 238
 239     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE;
 240     if ( hMonoBitmap )
 241     {
 242        if ( !(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hMonoBitmap, BITMAP_MAGIC))
 243            || bmp->bitmap.bmBitsPixel != 1 )
 244        {
 245            GDI_HEAP_UNLOCK( hdc );
 246            return FALSE;
 247        }
 248        TSXSetClipOrigin( display, dc->u.x.gc, dc->w.DCOrgX + x, dc->w.DCOrgY + y);
 249     }
 250
 251     TSXSetClipMask( display, dc->u.x.gc, (bmp) ? bmp->pixmap : None );
 252
 253     GDI_HEAP_UNLOCK( hdc );
 254     GDI_HEAP_UNLOCK( hMonoBitmap );
 255     return TRUE;
 256 }
 257