reactos/subsystems/win32/win32k/objects/dcutil.c

   1
   2 #include <w32k.h>
   3
   4 #define NDEBUG
   5 #include <debug.h>
   6
   7 /*
   8  * DC device-independent Get/SetXXX functions
   9  * (RJJ) swiped from WINE
  10  */
  11
  12 #define DC_GET_VAL( func_type, func_name, dc_field ) \
  13 func_type APIENTRY  func_name( HDC hdc ) \
  14 {                                   \
  15   func_type  ft;                    \
  16   PDC  dc = DC_LockDc( hdc );       \
  17   PDC_ATTR Dc_Attr;                 \
  18   if (!dc)                          \
  19   {                                 \
  20     SetLastWin32Error(ERROR_INVALID_HANDLE); \
  21     return 0;                       \
  22   }                                 \
  23   Dc_Attr = dc->pDc_Attr;           \
  24   if (!Dc_Attr) Dc_Attr = &dc->Dc_Attr; \
  25   ft = Dc_Attr->dc_field;           \
  26   DC_UnlockDc(dc);                  \
  27   return ft;                        \
  28 }
  29
  30 /* DC_GET_VAL_EX is used to define functions returning a POINT or a SIZE. It is
  31  * important that the function has the right signature, for the implementation
  32  * we can do whatever we want.
  33  */
  34 #define DC_GET_VAL_EX( FuncName, ret_x, ret_y, type, ax, ay ) \
  35 VOID FASTCALL Int##FuncName ( PDC dc, LP##type pt) \
  36 { \
  37   PDC_ATTR Dc_Attr; \
  38   ASSERT(dc); \
  39   ASSERT(pt); \
  40   Dc_Attr = dc->pDc_Attr; \
  41   if (!Dc_Attr) Dc_Attr = &dc->Dc_Attr; \
  42   pt->ax = Dc_Attr->ret_x; \
  43   pt->ay = Dc_Attr->ret_y; \
  44 }
  45
  46 #if 0
  47 BOOL APIENTRY NtGdi##FuncName ( HDC hdc, LP##type pt ) \
  48 { \
  49   NTSTATUS Status = STATUS_SUCCESS; \
  50   type Safept; \
  51   PDC dc; \
  52   if(!pt) \
  53   { \
  54     SetLastWin32Error(ERROR_INVALID_PARAMETER); \
  55     return FALSE; \
  56   } \
  57   if(!(dc = DC_LockDc(hdc))) \
  58   { \
  59     SetLastWin32Error(ERROR_INVALID_HANDLE); \
  60     return FALSE; \
  61   } \
  62   Int##FuncName( dc, &Safept); \
  63   DC_UnlockDc(dc); \
  64   _SEH2_TRY \
  65   { \
  66     ProbeForWrite(pt, \
  67                   sizeof( type ), \
  68                   1); \
  69     *pt = Safept; \
  70   } \
  71   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) \
  72   { \
  73     Status = _SEH2_GetExceptionCode(); \
  74   } \
  75   _SEH2_END; \
  76   if(!NT_SUCCESS(Status)) \
  77   { \
  78     SetLastNtError(Status); \
  79     return FALSE; \
  80   } \
  81   return TRUE; \
  82 }
  83 #endif
  84
  85 #define DC_SET_MODE( func_name, dc_field, min_val, max_val ) \
  86 INT APIENTRY  func_name( HDC hdc, INT mode ) \
  87 {                                           \
  88   INT  prevMode;                            \
  89   PDC  dc;                                  \
  90   PDC_ATTR Dc_Attr;                         \
  91   if ((mode < min_val) || (mode > max_val)) \
  92   { \
  93     SetLastWin32Error(ERROR_INVALID_PARAMETER); \
  94     return 0;                               \
  95   } \
  96   dc = DC_LockDc ( hdc );              \
  97   if ( !dc )                                \
  98   { \
  99     SetLastWin32Error(ERROR_INVALID_HANDLE); \
 100     return 0;                               \
 101   } \
 102   Dc_Attr = dc->pDc_Attr;           \
 103   if (!Dc_Attr) Dc_Attr = &dc->Dc_Attr; \
 104   prevMode = Dc_Attr->dc_field;             \
 105   Dc_Attr->dc_field = mode;                 \
 106   DC_UnlockDc ( dc );                    \
 107   return prevMode;                          \
 108 }
 109
 110
 111 static
 112 VOID
 113 CopytoUserDcAttr(PDC dc, PDC_ATTR Dc_Attr)
 114 {
 115   NTSTATUS Status = STATUS_SUCCESS;
 116   dc->Dc_Attr.mxWorldToDevice = dc->DcLevel.mxWorldToDevice;
 117   dc->Dc_Attr.mxDeviceToWorld = dc->DcLevel.mxDeviceToWorld;
 118   dc->Dc_Attr.mxWorldToPage = dc->DcLevel.mxWorldToPage;
 119
 120   _SEH2_TRY
 121   {
 122       ProbeForWrite( Dc_Attr,
 123              sizeof(DC_ATTR),
 124                            1);
 125       RtlCopyMemory( Dc_Attr,
 126                 &dc->Dc_Attr,
 127              sizeof(DC_ATTR));
 128   }
 129   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 130   {
 131      Status = _SEH2_GetExceptionCode();
 132   }
 133   _SEH2_END;
 134 }
 135
 136
 137 BOOL
 138 FASTCALL
 139 DCU_SyncDcAttrtoUser(PDC dc)
 140 {
 141   PDC_ATTR Dc_Attr = dc->pDc_Attr;
 142
 143   if (Dc_Attr == ((PDC_ATTR)&dc->Dc_Attr)) return TRUE; // No need to copy self.
 144
 145   if (!Dc_Attr) return FALSE;
 146   else
 147     CopytoUserDcAttr( dc, Dc_Attr);
 148   return TRUE;
 149 }
 150
 151 BOOL
 152 FASTCALL
 153 DCU_SynchDcAttrtoUser(HDC hDC)
 154 {
 155   BOOL Ret;
 156   PDC pDC = DC_LockDc ( hDC );
 157   if (!pDC) return FALSE;
 158   Ret = DCU_SyncDcAttrtoUser(pDC);
 159   DC_UnlockDc( pDC );
 160   return Ret;
 161 }
 162
 163
 164 DC_GET_VAL( INT, IntGdiGetMapMode, iMapMode )
 165 DC_GET_VAL( INT, IntGdiGetPolyFillMode, jFillMode )
 166 DC_GET_VAL( COLORREF, IntGdiGetBkColor, crBackgroundClr )
 167 DC_GET_VAL( INT, IntGdiGetBkMode, jBkMode )
 168 DC_GET_VAL( INT, IntGdiGetROP2, jROP2 )
 169 DC_GET_VAL( INT, IntGdiGetStretchBltMode, jStretchBltMode )
 170 DC_GET_VAL( UINT, IntGdiGetTextAlign, lTextAlign )
 171 DC_GET_VAL( COLORREF, IntGdiGetTextColor, crForegroundClr )
 172
 173 DC_GET_VAL_EX( GetViewportOrgEx, ptlViewportOrg.x, ptlViewportOrg.y, POINT, x, y )
 174 DC_GET_VAL_EX( GetWindowExtEx, szlWindowExt.cx, szlWindowExt.cy, SIZE, cx, cy )
 175 DC_GET_VAL_EX( GetWindowOrgEx, ptlWindowOrg.x, ptlWindowOrg.y, POINT, x, y )
 176
 177 DC_SET_MODE( IntGdiSetPolyFillMode, jFillMode, ALTERNATE, WINDING )
 178 DC_SET_MODE( IntGdiSetROP2, jROP2, R2_BLACK, R2_WHITE )
 179 DC_SET_MODE( IntGdiSetStretchBltMode, jStretchBltMode, BLACKONWHITE, HALFTONE )
 180
 181
 182
 183 COLORREF FASTCALL
 184 IntGdiSetBkColor(HDC hDC, COLORREF color)
 185 {
 186   COLORREF oldColor;
 187   PDC dc;
 188   PDC_ATTR Dc_Attr;
 189   HBRUSH hBrush;
 190
 191   if (!(dc = DC_LockDc(hDC)))
 192   {
 193     SetLastWin32Error(ERROR_INVALID_HANDLE);
 194     return CLR_INVALID;
 195   }
 196   Dc_Attr = dc->pDc_Attr;
 197   if (!Dc_Attr) Dc_Attr = &dc->Dc_Attr;
 198   oldColor = Dc_Attr->crBackgroundClr;
 199   Dc_Attr->crBackgroundClr = color;
 200   Dc_Attr->ulBackgroundClr = (ULONG)color;
 201   Dc_Attr->ulDirty_ &= ~(DIRTY_BACKGROUND|DIRTY_LINE|DIRTY_FILL); // Clear Flag if set.
 202   hBrush = Dc_Attr->hbrush;
 203   DC_UnlockDc(dc);
 204   NtGdiSelectBrush(hDC, hBrush);
 205   return oldColor;
 206 }
 207
 208 INT FASTCALL
 209 IntGdiSetBkMode(HDC hDC, INT Mode)
 210 {
 211   COLORREF oldMode;
 212   PDC dc;
 213   PDC_ATTR Dc_Attr;
 214
 215   if (!(dc = DC_LockDc(hDC)))
 216   {
 217     SetLastWin32Error(ERROR_INVALID_HANDLE);
 218     return CLR_INVALID;
 219   }
 220   Dc_Attr = dc->pDc_Attr;
 221   if (!Dc_Attr) Dc_Attr = &dc->Dc_Attr;
 222   oldMode = Dc_Attr->lBkMode;
 223   Dc_Attr->jBkMode = Mode;
 224   Dc_Attr->lBkMode = Mode;
 225   DC_UnlockDc(dc);
 226   return oldMode;
 227 }
 228
 229 UINT
 230 FASTCALL
 231 IntGdiSetTextAlign(HDC  hDC,
 232                        UINT  Mode)
 233 {
 234   UINT prevAlign;
 235   DC *dc;
 236   PDC_ATTR Dc_Attr;
 237
 238   dc = DC_LockDc(hDC);
 239   if (!dc)
 240     {
 241       SetLastWin32Error(ERROR_INVALID_HANDLE);
 242       return GDI_ERROR;
 243     }
 244   Dc_Attr = dc->pDc_Attr;
 245   if(!Dc_Attr) Dc_Attr = &dc->Dc_Attr;
 246   prevAlign = Dc_Attr->lTextAlign;
 247   Dc_Attr->lTextAlign = Mode;
 248   DC_UnlockDc( dc );
 249   return  prevAlign;
 250 }
 251
 252 COLORREF
 253 FASTCALL
 254 IntGdiSetTextColor(HDC hDC,
 255                  COLORREF color)
 256 {
 257   COLORREF  oldColor;
 258   PDC  dc = DC_LockDc(hDC);
 259   PDC_ATTR Dc_Attr;
 260   HBRUSH hBrush;
 261
 262   if (!dc)
 263   {
 264     SetLastWin32Error(ERROR_INVALID_HANDLE);
 265     return CLR_INVALID;
 266   }
 267   Dc_Attr = dc->pDc_Attr;
 268   if(!Dc_Attr) Dc_Attr = &dc->Dc_Attr;
 269
 270   oldColor = Dc_Attr->crForegroundClr;
 271   Dc_Attr->crForegroundClr = color;
 272   hBrush = Dc_Attr->hbrush;
 273   Dc_Attr->ulDirty_ &= ~(DIRTY_TEXT|DIRTY_LINE|DIRTY_FILL);
 274   DC_UnlockDc( dc );
 275   NtGdiSelectBrush(hDC, hBrush);
 276   return  oldColor;
 277 }
 278
 279 VOID
 280 FASTCALL
 281 DCU_SetDcUndeletable(HDC  hDC)
 282 {
 283   PDC dc = DC_LockDc(hDC);
 284   if (!dc)
 285     {
 286       SetLastWin32Error(ERROR_INVALID_HANDLE);
 287       return;
 288     }
 289
 290   dc->fs |= DC_FLAG_PERMANENT;
 291   DC_UnlockDc( dc );
 292   return;
 293 }