Prefer FASTCALL/STDCALL in kernel mode code.
Make compiler check function signatures.
Tested under BOCHS 2.0.2 + FreeDOS + loadros.
svn path=/trunk/; revision=4714
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dib.c,v 1.2 2003/05/18 17:16:17 ea Exp $ */
+
/* Static data */
unsigned char notmask[2] = { 0x0f, 0xf0 };
unsigned char altnotmask[2] = { 0xf0, 0x0f };
unsigned char mask1Bpp[8] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
+
+/* EOF */
extern unsigned char altnotmask[2];
extern unsigned char mask1Bpp[8];
-VOID DIB_1BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
-ULONG DIB_1BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
-VOID DIB_1BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
-VOID DIB_1BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
+VOID DIB_1BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
+ULONG DIB_1BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
+VOID DIB_1BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
+VOID DIB_1BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
BOOLEAN DIB_1BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation);
-VOID DIB_4BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
-ULONG DIB_4BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
-VOID DIB_4BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
-VOID DIB_4BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
+VOID DIB_4BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
+ULONG DIB_4BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
+VOID DIB_4BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
+VOID DIB_4BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
BOOLEAN DIB_4BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation);
-VOID DIB_8BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
-ULONG DIB_8BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
-VOID DIB_8BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
-VOID DIB_8BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
+VOID DIB_8BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
+ULONG DIB_8BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
+VOID DIB_8BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
+VOID DIB_8BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
BOOLEAN DIB_8BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation);
-VOID DIB_16BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
-ULONG DIB_16BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
-VOID DIB_16BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
-VOID DIB_16BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
+VOID DIB_16BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
+ULONG DIB_16BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
+VOID DIB_16BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
+VOID DIB_16BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
BOOLEAN DIB_16BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation);
-VOID DIB_24BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
-ULONG DIB_24BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
-VOID DIB_24BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
-VOID DIB_24BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
+VOID DIB_24BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
+ULONG DIB_24BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
+VOID DIB_24BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
+VOID DIB_24BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
BOOLEAN DIB_24BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation);
-VOID DIB_32BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
-ULONG DIB_32BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
-VOID DIB_32BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
-VOID DIB_32BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
+VOID DIB_32BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c);
+ULONG DIB_32BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y);
+VOID DIB_32BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c);
+VOID DIB_32BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c);
BOOLEAN DIB_32BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dib16bpp.c,v 1.4 2003/05/18 17:16:17 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include "../eng/objects.h"
#include "dib.h"
-VOID DIB_16BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
+VOID
+DIB_16BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PWORD addr = (PWORD)byteaddr + x;
*addr = (WORD)c;
}
-ULONG DIB_16BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
+ULONG
+DIB_16BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PWORD addr = (PWORD)byteaddr + x;
return (ULONG)(*addr);
}
-VOID DIB_16BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
+VOID
+DIB_16BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PWORD addr = (PWORD)byteaddr + x1;
}
}
-VOID DIB_16BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
+VOID
+DIB_16BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y1 * SurfObj->lDelta;
PWORD addr = (PWORD)byteaddr + x;
}
}
-BOOLEAN DIB_16BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
+BOOLEAN
+DIB_16BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation)
return TRUE;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dib1bpp.c,v 1.6 2003/05/18 17:16:17 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include "../eng/objects.h"
#include "dib.h"
-VOID DIB_1BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
+VOID
+DIB_1BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
{
PBYTE addr = SurfObj->pvScan0;
}
}
-ULONG DIB_1BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
+ULONG
+DIB_1BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
{
PBYTE addr = SurfObj->pvScan0 + y * SurfObj->lDelta + (x >> 3);
return (*addr & mask1Bpp[x % 8] ? 1 : 0);
}
-VOID DIB_1BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
+VOID
+DIB_1BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
{
while(x1 < x2) {
DIB_1BPP_PutPixel(SurfObj, x1, y, c);
}
}
-VOID DIB_1BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
+VOID
+DIB_1BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
{
while(y1 < y2) {
DIB_1BPP_PutPixel(SurfObj, x, y1, c);
}
}
-BOOLEAN DIB_1BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
+BOOLEAN
+DIB_1BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation)
return TRUE;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dib24bpp.c,v 1.11 2003/05/18 17:16:17 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include "../eng/objects.h"
#include "dib.h"
-VOID DIB_24BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
+VOID
+DIB_24BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PRGBTRIPLE addr = (PRGBTRIPLE)byteaddr + x;
*(PULONG)(addr) = c;
}
-ULONG DIB_24BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
+ULONG
+DIB_24BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PRGBTRIPLE addr = (PRGBTRIPLE)byteaddr + x;
return *(PULONG)(addr) & 0x00ffffff;
}
-VOID DIB_24BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
+VOID
+DIB_24BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PRGBTRIPLE addr = (PRGBTRIPLE)byteaddr + x1;
}
}
-VOID DIB_24BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
+VOID
+DIB_24BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y1 * SurfObj->lDelta;
PRGBTRIPLE addr = (PRGBTRIPLE)byteaddr + x;
}
}
-BOOLEAN DIB_24BPP_BitBlt( SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
+BOOLEAN
+DIB_24BPP_BitBlt( SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation)
return TRUE;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dib32bpp.c,v 1.2 2003/05/18 17:16:17 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include "../eng/objects.h"
#include "dib.h"
-VOID DIB_32BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
+VOID
+DIB_32BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PDWORD addr = (PDWORD)byteaddr + x;
*addr = c;
}
-ULONG DIB_32BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
+ULONG
+DIB_32BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PDWORD addr = (PDWORD)byteaddr + x;
return (ULONG)(*addr);
}
-VOID DIB_32BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
+VOID
+DIB_32BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PDWORD addr = (PDWORD)byteaddr + x1;
}
}
-VOID DIB_32BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
+VOID
+DIB_32BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y1 * SurfObj->lDelta;
PDWORD addr = (PDWORD)byteaddr + x;
}
}
-BOOLEAN DIB_32BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
+BOOLEAN
+DIB_32BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation)
return TRUE;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dib4bpp.c,v 1.13 2003/05/18 17:16:17 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include "../eng/objects.h"
#include "dib.h"
-VOID DIB_4BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
+VOID
+DIB_4BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
{
PBYTE addr = SurfObj->pvScan0;
*addr = (*addr & notmask[x&1]) | (c << ((1-(x&1))<<2));
}
-ULONG DIB_4BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
+ULONG
+DIB_4BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
{
PBYTE addr = SurfObj->pvScan0;
return (addr[(x>>1) + y * SurfObj->lDelta] >> ((1-(x&1))<<2) ) & 0x0f;
}
-VOID DIB_4BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
+VOID
+DIB_4BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
{
PBYTE addr = SurfObj->pvScan0 + (x1>>1) + y * SurfObj->lDelta;
LONG cx = x1;
}
}
-VOID DIB_4BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
+VOID
+DIB_4BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
{
PBYTE addr = SurfObj->pvScan0;
int lDelta = SurfObj->lDelta;
}
}
-BOOLEAN DIB_4BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
+BOOLEAN
+DIB_4BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation)
return TRUE;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dib8bpp.c,v 1.2 2003/05/18 17:16:17 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include "../eng/objects.h"
#include "dib.h"
-VOID DIB_8BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
+VOID
+DIB_8BPP_PutPixel(PSURFOBJ SurfObj, LONG x, LONG y, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta + x;
*byteaddr = c;
}
-ULONG DIB_8BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
+ULONG
+DIB_8BPP_GetPixel(PSURFOBJ SurfObj, LONG x, LONG y)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta + x;
return (ULONG)(*byteaddr);
}
-VOID DIB_8BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
+VOID
+DIB_8BPP_HLine(PSURFOBJ SurfObj, LONG x1, LONG x2, LONG y, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y * SurfObj->lDelta;
PBYTE addr = byteaddr + x1;
}
}
-VOID DIB_8BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
+VOID
+DIB_8BPP_VLine(PSURFOBJ SurfObj, LONG x, LONG y1, LONG y2, ULONG c)
{
PBYTE byteaddr = SurfObj->pvScan0 + y1 * SurfObj->lDelta;
PBYTE addr = byteaddr + x;
}
}
-BOOLEAN DIB_8BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
+BOOLEAN
+DIB_8BPP_BitBlt(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
XLATEOBJ *ColorTranslation)
return TRUE;
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: bitblt.c,v 1.20 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI BitBlt Functions
#include <ddk/winddi.h>
#include <ddk/ntddk.h>
+#include <ddk/ntddmou.h>
#include <ntos/minmax.h>
#include "brush.h"
#include "clip.h"
#define NDEBUG
#include <win32k/debug1.h>
-BOOL EngIntersectRect(PRECTL prcDst, PRECTL prcSrc1, PRECTL prcSrc2)
+BOOL STDCALL EngIntersectRect(PRECTL prcDst, PRECTL prcSrc1, PRECTL prcSrc2)
{
static const RECTL rclEmpty = { 0, 0, 0, 0 };
return ret;
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: brush.c,v 1.7 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Driver Brush Functions
{
return(BrushObj->pvRbrush);
}
+/* EOF */
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: brush.h,v 1.3 2003/05/18 17:16:17 ea Exp $ */
typedef struct _BRUSHINST
{
// We need to removed ajC0-3 when color pattern code is complete!!!
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: clip.c,v 1.12 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Clipping Functions
#define NDEBUG
#include <win32k/debug1.h>
-VOID IntEngDeleteClipRegion(CLIPOBJ *ClipObj)
+VOID STDCALL IntEngDeleteClipRegion(CLIPOBJ *ClipObj)
{
HCLIP HClip = AccessHandleFromUserObject(ClipObj);
FreeGDIHandle(HClip);
}
-CLIPOBJ * IntEngCreateClipRegion( ULONG count, PRECTL pRect, RECTL rcBounds )
+CLIPOBJ STDCALL * IntEngCreateClipRegion( ULONG count, PRECTL pRect, RECTL rcBounds )
{
HCLIP hClip;
CLIPGDI* clipInt;
return ClipGDI->EnumPos < ClipGDI->EnumRects.c;
}
+/* EOF */
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
#ifndef __WIN32K_CLIP_H
#define __WIN32K_CLIP_H
typedef ULONG HCLIP;
-CLIPOBJ * IntEngCreateClipRegion( ULONG count, PRECTL pRect, RECTL rcBounds );
-VOID IntEngDeleteClipRegion(CLIPOBJ *ClipObj);
+CLIPOBJ STDCALL * IntEngCreateClipRegion( ULONG count, PRECTL pRect, RECTL rcBounds );
+VOID STDCALL IntEngDeleteClipRegion(CLIPOBJ *ClipObj);
#define ENUM_RECT_LIMIT 50
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: copybits.c,v 1.14 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI EngCopyBits Function
*/
#include <ddk/winddi.h>
+#include <ddk/ntddmou.h>
#include "objects.h"
#include "clip.h"
#include "../dib/dib.h"
return FALSE;
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: debug.c,v 1.4 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Driver Brush Functions
DbgPrint(DebugMessage, ap);
DbgPrint("\n");
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: device.c,v 1.7 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Driver Device Functions
return (Status);
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: handle.c,v 1.13 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Manage GDI Handles
static int LastHandle = MAX_GDI_HANDLES;
-ULONG CreateGDIHandle(ULONG InternalSize, ULONG UserSize)
+ULONG FASTCALL CreateGDIHandle(ULONG InternalSize, ULONG UserSize)
{
ULONG size;
PENGOBJ pObj;
return 0;
}
-VOID FreeGDIHandle(ULONG Handle)
+VOID FASTCALL FreeGDIHandle(ULONG Handle)
{
if( Handle == 0 || Handle >= MAX_GDI_HANDLES ){
DPRINT1("FreeGDIHandle: invalid handle!!!!\n");
GDIHandles[Handle].pEngObj = NULL;
}
-PVOID AccessInternalObject(ULONG Handle)
+PVOID FASTCALL AccessInternalObject(ULONG Handle)
{
PENGOBJ pEngObj;
return (PVOID)pEngObj;
}
-PVOID AccessUserObject(ULONG Handle)
+PVOID FASTCALL AccessUserObject(ULONG Handle)
{
PENGOBJ pEngObj;
return (PVOID)( (PCHAR)pEngObj + sizeof( ENGOBJ ) );
}
-ULONG AccessHandleFromUserObject(PVOID UserObject)
+ULONG FASTCALL AccessHandleFromUserObject(PVOID UserObject)
{
PENGOBJ pEngObj;
ULONG Handle;
return Handle;
}
-PVOID AccessInternalObjectFromUserObject(PVOID UserObject)
+PVOID FASTCALL AccessInternalObjectFromUserObject(PVOID UserObject)
{
return AccessInternalObject( AccessHandleFromUserObject( UserObject ) );
}
-VOID InitEngHandleTable( void )
+VOID FASTCALL InitEngHandleTable( void )
{
ULONG i;
for( i=1; i < MAX_GDI_HANDLES; i++ ){
GDIHandles[ i ].pEngObj = NULL;
}
}
+/* EOF */
/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: handle.h,v 1.5 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Manage GDI Handle definitions
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: lineto.c,v 1.18 2003/05/18 17:16:17 ea Exp $ */
#include <ddk/winddi.h>
+#include <ddk/ntddmou.h>
#include <include/inteng.h>
#include <include/dib.h>
#include "objects.h"
return ret;
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: mem.c,v 1.8 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Driver Memory Management Functions
{
ZwFreeVirtualMemory (NtCurrentProcess(), &pv, 0, MEM_DECOMMIT);
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: misc.c,v 1.2 2003/05/18 17:16:17 ea Exp $ */
#include <ddk/winddi.h>
#include <include/dib.h>
#include <include/object.h>
}
return Result;
-}
\ No newline at end of file
+}
+/* EOF */
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: misc.h,v 1.2 2003/05/18 17:16:17 ea Exp $ */
#ifndef __ENG_MISC_H
#define __ENG_MISC_H
/*
- * ReactOS kernel
- * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: mouse.c,v 1.22 2003/03/28 15:27:47 gvg Exp $
+/* $Id: mouse.c,v 1.23 2003/05/18 17:16:17 ea Exp $
*
* PROJECT: ReactOS kernel
* PURPOSE: Mouse
#include "include/msgqueue.h"
#include "include/object.h"
#include "include/winsta.h"
+#include <include/mouse.h>
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
-INT
+INT STDCALL
MouseSafetyOnDrawStart(PSURFOBJ SurfObj, PSURFGDI SurfGDI, LONG HazardX1,
LONG HazardY1, LONG HazardX2, LONG HazardY2)
/*
return(TRUE);
}
-INT
+INT FASTCALL
MouseSafetyOnDrawEnd(PSURFOBJ SurfObj, PSURFGDI SurfGDI)
/*
* FUNCTION: Notify the mouse driver that drawing has finished on a surface.
return(TRUE);
}
-VOID
+VOID FASTCALL
MouseGDICallBack(PMOUSE_INPUT_DATA Data, ULONG InputCount)
/*
* FUNCTION: Call by the mouse driver when input events occur.
}
}
-VOID
+VOID FASTCALL
EnableMouse(HDC hDisplayDC)
{
PDC dc;
MouseEnabled = FALSE;
}
}
-
+/* EOF */
/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: objects.h,v 1.15 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Internal Objects
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: paint.c,v 1.14 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Driver Paint Functions
*/
#include <ddk/winddi.h>
+#include <ddk/ntddmou.h>
#include <include/object.h>
#include <include/paint.h>
#include <include/surface.h>
//#define NDEBUG
#include <win32k/debug1.h>
-BOOL FillSolid(SURFOBJ *Surface, PRECTL pRect, ULONG iColor)
+BOOL STDCALL FillSolid(SURFOBJ *Surface, PRECTL pRect, ULONG iColor)
{
LONG y;
ULONG LineWidth;
return TRUE;
}
-BOOL EngPaintRgn(SURFOBJ *Surface, CLIPOBJ *ClipRegion, ULONG iColor, MIX Mix,
+BOOL STDCALL
+EngPaintRgn(SURFOBJ *Surface, CLIPOBJ *ClipRegion, ULONG iColor, MIX Mix,
BRUSHINST *BrushInst, POINTL *BrushPoint)
{
RECT_ENUM RectEnum;
return EngPaint( Surface, ClipRegion, Brush, BrushOrigin, Mix );
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: palette.c,v 1.15 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Palette Functions
return Colors;
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: surface.c,v 1.19 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Driver Surace Functions
#define NDEBUG
#include <win32k/debug1.h>
-INT BitsPerFormat(ULONG Format)
+INT FASTCALL BitsPerFormat(ULONG Format)
{
switch(Format)
{
}
}
-ULONG BitmapFormat(WORD Bits, DWORD Compression)
+ULONG FASTCALL BitmapFormat(WORD Bits, DWORD Compression)
{
switch(Compression)
{
return FALSE;
}
-VOID InitializeFuncs(SURFGDI *SurfGDI, ULONG BitmapFormat)
+#define SURF_METHOD(c,n) DIB_##c##_##n
+#define SET_SURFGDI(c)\
+ SurfGDI->DIB_PutPixel=SURF_METHOD(c,PutPixel);\
+ SurfGDI->DIB_HLine=SURF_METHOD(c,HLine);\
+ SurfGDI->DIB_VLine=SURF_METHOD(c,VLine);\
+ SurfGDI->DIB_BitBlt=SURF_METHOD(c,BitBlt);
+
+VOID FASTCALL InitializeFuncs(SURFGDI *SurfGDI, ULONG BitmapFormat)
{
SurfGDI->BitBlt = NULL;
SurfGDI->CopyBits = NULL;
switch(BitmapFormat)
{
- case BMF_1BPP:
- SurfGDI->DIB_PutPixel = DIB_1BPP_PutPixel;
- SurfGDI->DIB_HLine = DIB_1BPP_HLine;
- SurfGDI->DIB_VLine = DIB_1BPP_VLine;
- SurfGDI->DIB_BitBlt = DIB_1BPP_BitBlt;
- break;
-
- case BMF_4BPP:
- SurfGDI->DIB_PutPixel = DIB_4BPP_PutPixel;
- SurfGDI->DIB_HLine = DIB_4BPP_HLine;
- SurfGDI->DIB_VLine = DIB_4BPP_VLine;
- SurfGDI->DIB_BitBlt = DIB_4BPP_BitBlt;
- break;
-
- case BMF_8BPP:
- SurfGDI->DIB_PutPixel = DIB_8BPP_PutPixel;
- SurfGDI->DIB_HLine = DIB_8BPP_HLine;
- SurfGDI->DIB_VLine = DIB_8BPP_VLine;
- SurfGDI->DIB_BitBlt = DIB_8BPP_BitBlt;
- break;
-
- case BMF_16BPP:
- SurfGDI->DIB_PutPixel = DIB_16BPP_PutPixel;
- SurfGDI->DIB_HLine = DIB_16BPP_HLine;
- SurfGDI->DIB_VLine = DIB_16BPP_VLine;
- SurfGDI->DIB_BitBlt = DIB_16BPP_BitBlt;
- break;
-
- case BMF_24BPP:
- SurfGDI->DIB_PutPixel = DIB_24BPP_PutPixel;
- SurfGDI->DIB_HLine = DIB_24BPP_HLine;
- SurfGDI->DIB_VLine = DIB_24BPP_VLine;
- SurfGDI->DIB_BitBlt = DIB_24BPP_BitBlt;
- break;
-
- case BMF_32BPP:
- SurfGDI->DIB_PutPixel = DIB_32BPP_PutPixel;
- SurfGDI->DIB_HLine = DIB_32BPP_HLine;
- SurfGDI->DIB_VLine = DIB_32BPP_VLine;
- SurfGDI->DIB_BitBlt = DIB_32BPP_BitBlt;
- break;
-
+ case BMF_1BPP: SET_SURFGDI(1BPP) break;
+ case BMF_4BPP: SET_SURFGDI(4BPP) break;
+ case BMF_8BPP: SET_SURFGDI(8BPP) break;
+ case BMF_16BPP: SET_SURFGDI(16BPP) break;
+ case BMF_24BPP: SET_SURFGDI(24BPP) break;
+ case BMF_32BPP: SET_SURFGDI(32BPP) break;
case BMF_4RLE:
case BMF_8RLE:
/* Not supported yet, fall through to unrecognized case */
return NewSurface;
}
-PFN DriverFunction(DRVENABLEDATA *DED, ULONG DriverFunc)
+PFN FASTCALL DriverFunction(DRVENABLEDATA *DED, ULONG DriverFunc)
{
ULONG i;
{
// FIXME: Call GDI_UnlockObject
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: transblt.c,v 1.9 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI TransparentBlt Function
#include <ddk/winddi.h>
#include <ddk/ntddk.h>
+#include <ddk/ntddmou.h>
#include <ntos/minmax.h>
#include <include/dib.h>
#include <include/object.h>
return TRUE;
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: xlate.c,v 1.19 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: GDI Color Translation Functions
ULONG CCMLastSourceColor = 0, CCMLastColorMatch = 0;
-ULONG RGBtoULONG(BYTE Red, BYTE Green, BYTE Blue)
+ULONG STDCALL RGBtoULONG(BYTE Red, BYTE Green, BYTE Blue)
{
return ((Red & 0xff) << 16) | ((Green & 0xff) << 8) | (Blue & 0xff);
}
-ULONG BGRtoULONG(BYTE Blue, BYTE Green, BYTE Red)
+ULONG STDCALL BGRtoULONG(BYTE Blue, BYTE Green, BYTE Red)
{
return ((Blue & 0xff) << 16) | ((Green & 0xff) << 8) | (Red & 0xff);
}
-static ULONG ShiftAndMask(XLATEGDI *XlateGDI, ULONG Color)
+static ULONG FASTCALL ShiftAndMask(XLATEGDI *XlateGDI, ULONG Color)
{
ULONG TranslatedColor;
// then we should cache more than one value. Same with the source.
// Takes indexed palette and a
-ULONG ClosestColorMatch(XLATEGDI *XlateGDI, ULONG SourceColor, ULONG *DestColors,
+ULONG STDCALL
+ClosestColorMatch(XLATEGDI *XlateGDI, ULONG SourceColor, ULONG *DestColors,
ULONG NumColors)
{
PVIDEO_CLUTDATA cSourceColor;
return idx;
}
-VOID IndexedToIndexedTranslationTable(XLATEGDI *XlateGDI, ULONG *TranslationTable,
+VOID STDCALL
+IndexedToIndexedTranslationTable(XLATEGDI *XlateGDI, ULONG *TranslationTable,
PALGDI *PalDest, PALGDI *PalSource)
{
ULONG i;
}
}
-static VOID BitMasksFromPal(USHORT PalType, PPALGDI Palette,
+static VOID STDCALL
+BitMasksFromPal(USHORT PalType, PPALGDI Palette,
PULONG RedMask, PULONG BlueMask, PULONG GreenMask)
{
switch(PalType)
* Calculate the number of bits Mask must be shift to the left to get a
* 1 in the most significant bit position
*/
-static INT CalculateShift(ULONG Mask)
+static INT FASTCALL CalculateShift(ULONG Mask)
{
INT Shift = 0;
ULONG LeftmostBit = 1 << (8 * sizeof(ULONG) - 1);
return Shift;
}
-XLATEOBJ *IntEngCreateXlate(USHORT DestPalType, USHORT SourcePalType,
+XLATEOBJ * STDCALL IntEngCreateXlate(USHORT DestPalType, USHORT SourcePalType,
HPALETTE PaletteDest, HPALETTE PaletteSource)
{
// FIXME: Add support for BGR conversions
return XlateObj;
}
-VOID EngDeleteXlate(XLATEOBJ *XlateObj)
+VOID FASTCALL EngDeleteXlate(XLATEOBJ *XlateObj)
{
HPALETTE HXlate = (HPALETTE)AccessHandleFromUserObject(XlateObj);
XLATEGDI *XlateGDI = (XLATEGDI*)AccessInternalObject((ULONG)HXlate);
return i;
}
+/* EOF */
LIST_ENTRY ListEntry;
} WNDCLASS_OBJECT, *PWNDCLASS_OBJECT;
-NTSTATUS
+NTSTATUS FASTCALL
InitClassImpl(VOID);
-NTSTATUS
+NTSTATUS FASTCALL
CleanupClassImpl(VOID);
-NTSTATUS
+NTSTATUS STDCALL
ClassReferenceClassByName(PW32PROCESS Process,
PWNDCLASS_OBJECT *Class,
LPWSTR ClassName);
-NTSTATUS
+NTSTATUS FASTCALL
ClassReferenceClassByAtom(PWNDCLASS_OBJECT *Class,
RTL_ATOM ClassAtom);
-NTSTATUS
+NTSTATUS FASTCALL
ClassReferenceClassByNameOrAtom(PWNDCLASS_OBJECT *Class,
LPWSTR ClassNameOrAtom);
-PWNDCLASS_OBJECT
+PWNDCLASS_OBJECT FASTCALL
W32kCreateClass(LPWNDCLASSEX lpwcx,
BOOL bUnicodeClass);
struct _WINDOW_OBJECT;
-ULONG
+ULONG FASTCALL
W32kGetClassLong(struct _WINDOW_OBJECT* WindowObject, ULONG Offset);
#endif /* __WIN32K_CLASS_H */
--- /dev/null
+const PALETTEENTRY* FASTCALL COLOR_GetSystemPaletteTemplate (VOID);
+COLORREF STDCALL COLOR_LookupNearestColor (PALETTEENTRY* palPalEntry, INT size, COLORREF color);
+INT STDCALL COLOR_PaletteLookupExactIndex (PALETTEENTRY* palPalEntry, INT size, COLORREF col);
+INT STDCALL COLOR_PaletteLookupPixel(PALETTEENTRY *palPalEntry, INT size, PXLATEOBJ XlateObj, COLORREF col, BOOL skipReserved);
+
#ifndef __WIN32K_COPYBITS_H
#define __WIN32K_COPYBITS_H
-BOOLEAN CopyBitsCopy(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
+BOOLEAN STDCALL CopyBitsCopy(SURFOBJ *DestSurf, SURFOBJ *SourceSurf,
SURFGDI *DestGDI, SURFGDI *SourceGDI,
PRECTL DestRect, POINTL *SourcePoint,
ULONG Delta, XLATEOBJ *ColorTranslation);
#define DCEOBJ_LockDCE(hDCE) ((PDCE)GDIOBJ_LockObj((HGDIOBJ)hDCE, GO_DCE_MAGIC))
#define DCEOBJ_UnlockDCE(hDCE) GDIOBJ_UnlockObj((HGDIOBJ)hDCE, GO_DCE_MAGIC)
-PDCE DCE_AllocDCE(HWND hWnd, DCE_TYPE type);
-PDCE DCE_FreeDCE(PDCE dce);
-VOID DCE_FreeWindowDCE(HWND);
-INT DCE_ExcludeRgn(HDC, HWND, HRGN);
-BOOL DCE_InvalidateDCE(HWND, const PRECTL);
-BOOL DCE_InternalDelete(PDCE dce);
+PDCE FASTCALL DCE_AllocDCE(HWND hWnd, DCE_TYPE type); // ???
+PDCE FASTCALL DceAllocDCE(HWND hWnd, DCE_TYPE Type);
+PDCE FASTCALL DCE_FreeDCE(PDCE dce);
+VOID FASTCALL DCE_FreeWindowDCE(HWND);
+HRGN STDCALL DceGetVisRgn(HWND hWnd, ULONG Flags, HWND hWndChild, ULONG CFlags);
+INT FASTCALL DCE_ExcludeRgn(HDC, HWND, HRGN);
+BOOL FASTCALL DCE_InvalidateDCE(HWND, const PRECTL);
+BOOL FASTCALL DCE_InternalDelete(PDCE dce);
#endif
#ifndef __WIN32K_DIB_H
#define __WIN32K_DIB_H
-int DIB_GetDIBWidthBytes(int width, int depth);
+#include <win32k/dc.h>
+INT FASTCALL DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse);
+HBITMAP STDCALL DIB_CreateDIBSection (PDC dc, PBITMAPINFO bmi, UINT usage, LPVOID *bits, HANDLE section, DWORD offset, DWORD ovr_pitch);
+INT STDCALL DIB_GetBitmapInfo (const BITMAPINFOHEADER *header, PDWORD width, PINT height, PWORD bpp, PWORD compr);
+INT STDCALL DIB_GetDIBImageBytes (INT width, INT height, INT depth);
+INT FASTCALL DIB_GetDIBWidthBytes (INT width, INT depth);
+RGBQUAD * FASTCALL DIB_MapPaletteColors (PDC dc, LPBITMAPINFO lpbmi);
+
+PPALETTEENTRY STDCALL DIBColorTableToPaletteEntries(PPALETTEENTRY palEntries, const RGBQUAD *DIBColorTable, ULONG ColorCount);
+HPALETTE FASTCALL BuildDIBPalette (PBITMAPINFO bmi, PINT paletteType);
+
#endif /* __WIN32K_DIB_H */
#ifndef __WIN32K_ENG_H
#define __WIN32K_ENG_H
-BOOL EngIntersectRect(PRECTL prcDst, PRECTL prcSrc1, PRECTL prcSrc2);
+BOOL STDCALL EngIntersectRect (PRECTL prcDst, PRECTL prcSrc1, PRECTL prcSrc2);
+VOID FASTCALL EngDeleteXlate (XLATEOBJ *XlateObj);
#endif /* __WIN32K_ENG_H */
#ifndef __WIN32K_ERROR_H
#define __WIN32K_ERROR_H
-VOID
+VOID FASTCALL
SetLastNtError(
NTSTATUS Status);
-VOID
+VOID FASTCALL
SetLastWin32Error(
DWORD Status);
#include <windows.h>
#include <ddk/ntddk.h>
-VOID
+VOID FASTCALL
W32kGuiCheck(VOID);
-VOID
+VOID FASTCALL
W32kGraphicsCheck(BOOL Create);
#endif /* __WIN32K_GUICHECK_H */
#ifndef __WIN32K_MOUSE_H
#define __WIN32K_MOUSE_H
-NTSTATUS
+NTSTATUS FASTCALL
InitInputImpl(VOID);
#endif /* __WIN32K_MOUSE_H */
/* Definitions of IntEngXxx functions */
-extern BOOL STDCALL IntEngLineTo(SURFOBJ *Surface,
+BOOL STDCALL IntEngLineTo(SURFOBJ *Surface,
CLIPOBJ *Clip,
BRUSHOBJ *Brush,
LONG x1,
POINTL *BrushOrigin,
ROP4 rop4);
-XLATEOBJ *IntEngCreateXlate(USHORT DestPalType,
+XLATEOBJ * STDCALL IntEngCreateXlate(USHORT DestPalType,
USHORT SourcePalType,
HPALETTE PaletteDest,
HPALETTE PaletteSource);
-extern BOOL STDCALL IntEngPolyline(SURFOBJ *DestSurf,
+BOOL STDCALL IntEngPolyline(SURFOBJ *DestSurf,
CLIPOBJ *Clip,
BRUSHOBJ *Brush,
CONST LPPOINT pt,
LONG dCount,
MIX mix);
+CLIPOBJ STDCALL * IntEngCreateClipRegion(ULONG count,
+ PRECTL pRect,
+ RECTL rcBounds);
#endif
#ifndef __WIN32K_MOUSE_H
#define __WIN32K_MOUSE_H
-INT MouseSafetyOnDrawStart(PSURFOBJ SurfObj, PSURFGDI SurfGDI, LONG HazardX1, LONG HazardY1, LONG HazardX2, LONG HazardY2);
-INT MouseSafetyOnDrawEnd(PSURFOBJ SurfObj, PSURFGDI SurfGDI);
-VOID EnableMouse(HDC hDisplayDC);
+#include "../eng/misc.h"
+//#include <ddk/ntddmou.h>
+
+INT STDCALL MouseSafetyOnDrawStart(PSURFOBJ SurfObj, PSURFGDI SurfGDI, LONG HazardX1, LONG HazardY1, LONG HazardX2, LONG HazardY2);
+INT FASTCALL MouseSafetyOnDrawEnd(PSURFOBJ SurfObj, PSURFGDI SurfGDI);
+VOID FASTCALL EnableMouse(HDC hDisplayDC);
+VOID FASTCALL MouseGDICallBack(PMOUSE_INPUT_DATA Data, ULONG InputCount);
+
#endif /* __WIN32K_MOUSE_H */
HWND CaptureWindow;
} USER_MESSAGE_QUEUE, *PUSER_MESSAGE_QUEUE;
-VOID
+VOID FASTCALL
MsqSendMessage(PUSER_MESSAGE_QUEUE MessageQueue,
PUSER_SENT_MESSAGE Message);
-VOID
+VOID FASTCALL
MsqInitializeMessage(PUSER_MESSAGE Message,
LPMSG Msg);
-PUSER_MESSAGE
+PUSER_MESSAGE FASTCALL
MsqCreateMessage(LPMSG Msg);
-VOID
+VOID FASTCALL
MsqDestroyMessage(PUSER_MESSAGE Message);
-VOID
+VOID FASTCALL
MsqPostMessage(PUSER_MESSAGE_QUEUE MessageQueue,
PUSER_MESSAGE Message);
-BOOLEAN
+BOOLEAN STDCALL
MsqFindMessage(IN PUSER_MESSAGE_QUEUE MessageQueue,
IN BOOLEAN Hardware,
IN BOOLEAN Remove,
IN UINT MsgFilterLow,
IN UINT MsgFilterHigh,
OUT PUSER_MESSAGE* Message);
-VOID
+VOID FASTCALL
MsqInitializeMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue);
-VOID
+VOID FASTCALL
MsqFreeMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue);
-PUSER_MESSAGE_QUEUE
+PUSER_MESSAGE_QUEUE FASTCALL
MsqCreateMessageQueue(VOID);
-VOID
+VOID FASTCALL
MsqDestroyMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue);
-PUSER_MESSAGE_QUEUE
+PUSER_MESSAGE_QUEUE FASTCALL
MsqGetHardwareMessageQueue(VOID);
-NTSTATUS
+NTSTATUS FASTCALL
MsqWaitForNewMessage(PUSER_MESSAGE_QUEUE MessageQueue);
-NTSTATUS
+NTSTATUS FASTCALL
MsqInitializeImpl(VOID);
-BOOLEAN
+BOOLEAN FASTCALL
MsqDispatchOneSentMessage(PUSER_MESSAGE_QUEUE MessageQueue);
-NTSTATUS
+NTSTATUS FASTCALL
MsqWaitForNewMessages(PUSER_MESSAGE_QUEUE MessageQueue);
-VOID
+VOID FASTCALL
MsqSendNotifyMessage(PUSER_MESSAGE_QUEUE MessageQueue,
PUSER_SENT_MESSAGE_NOTIFY NotifyMessage);
-VOID
+VOID FASTCALL
MsqIncPaintCountQueue(PUSER_MESSAGE_QUEUE Queue);
-VOID
+VOID FASTCALL
MsqDecPaintCountQueue(PUSER_MESSAGE_QUEUE Queue);
LRESULT STDCALL
W32kSendMessage(HWND hWnd,
WPARAM wParam,
LPARAM lParam,
BOOL KernelMessage);
-VOID
+VOID STDCALL
MsqPostKeyboardMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
-VOID
+VOID FASTCALL
MsqInsertSystemMessage(MSG* Msg);
#define MAKE_LONG(x, y) ((((y) & 0xFFFF) << 16) | ((x) & 0xFFFF))
#define __WIN32K_OBJECT_H
#include <windows.h>
+#include <win32k/gdiobj.h>
+#include <win32k/bitmaps.h>
+#include <win32k/pen.h>
typedef enum {
otUnknown = 0,
} USER_HANDLE_TABLE, *PUSER_HANDLE_TABLE;
-ULONG
+ULONG FASTCALL
ObmGetReferenceCount(
PVOID ObjectBody);
-ULONG
+ULONG FASTCALL
ObmGetHandleCount(
PVOID ObjectBody);
-VOID
+VOID FASTCALL
ObmReferenceObject(
PVOID ObjectBody);
-VOID
+VOID FASTCALL
ObmDereferenceObject(
PVOID ObjectBody);
-NTSTATUS
+NTSTATUS FASTCALL
ObmReferenceObjectByPointer(
PVOID ObjectBody,
USER_OBJECT_TYPE ObjectType);
-PVOID
+PVOID FASTCALL
ObmCreateObject(
PUSER_HANDLE_TABLE HandleTable,
PHANDLE Handle,
USER_OBJECT_TYPE ObjectType,
ULONG ObjectSize);
-NTSTATUS
+NTSTATUS FASTCALL
ObmCreateHandle(
PUSER_HANDLE_TABLE HandleTable,
PVOID ObjectBody,
PHANDLE HandleReturn);
-NTSTATUS
+NTSTATUS FASTCALL
ObmReferenceObjectByHandle(
PUSER_HANDLE_TABLE HandleTable,
HANDLE Handle,
USER_OBJECT_TYPE ObjectType,
PVOID* Object);
-NTSTATUS
+NTSTATUS FASTCALL
ObmCloseHandle(
PUSER_HANDLE_TABLE HandleTable,
HANDLE Handle);
-VOID
+VOID FASTCALL
ObmInitializeHandleTable(
PUSER_HANDLE_TABLE HandleTable);
-VOID
+VOID FASTCALL
ObmFreeHandleTable(
PUSER_HANDLE_TABLE HandleTable);
-PUSER_HANDLE_TABLE
+PUSER_HANDLE_TABLE FASTCALL
ObmCreateHandleTable(VOID);
-VOID
-ObmDestroyHandleTable(
- PUSER_HANDLE_TABLE HandleTable);
+VOID FASTCALL ObmDestroyHandleTable (PUSER_HANDLE_TABLE HandleTable);
+
+ULONG FASTCALL CreateGDIHandle (ULONG InternalSize, ULONG UserSize);
+VOID FASTCALL FreeGDIHandle (ULONG Handle);
+
+PVOID FASTCALL AccessUserObject (ULONG Handle);
+PVOID FASTCALL AccessInternalObject (ULONG Handle);
+
+PVOID FASTCALL AccessInternalObjectFromUserObject (PVOID UserObject);
+ULONG FASTCALL AccessHandleFromUserObject (PVOID UserObject);
+
+VOID FASTCALL InitEngHandleTable (VOID);
+VOID FASTCALL InitGdiObjectHandleTable (VOID);
+
+VOID FASTCALL CreateStockObjects (VOID);
-ULONG CreateGDIHandle(ULONG InternalSize, ULONG UserSize);
-VOID FreeGDIHandle(ULONG Handle);
+VOID FASTCALL GDIOBJ_MarkObjectGlobal (HGDIOBJ ObjectHandle);
+BOOL FASTCALL GDIOBJ_LockMultipleObj (PGDIMULTILOCK pList, INT nObj);
-PVOID AccessUserObject(ULONG Handle);
-PVOID AccessInternalObject(ULONG Handle);
+PPOINT FASTCALL GDI_Bezier (const POINT *Points, INT count, PINT nPtsOut);
-PVOID AccessInternalObjectFromUserObject(PVOID UserObject);
-ULONG AccessHandleFromUserObject(PVOID UserObject);
+/* objects/objconv.c */
-VOID InitEngHandleTable( void );
+PBRUSHOBJ FASTCALL PenToBrushObj (PDC dc, PENOBJ *pen);
+HBITMAP FASTCALL BitmapToSurf (PBITMAPOBJ BitmapObj);
#endif /* __WIN32K_OBJECT_H */
#ifndef __WIN32K_PAINT_H
#define __WIN32K_PAINT_H
-BOOL FillSolid(SURFOBJ *Surface, PRECTL Dimensions, ULONG iColor);
+BOOL STDCALL FillSolid (PSURFOBJ Surface, PRECTL Dimensions, ULONG iColor);
+BOOL STDCALL FillPolygon_ALTERNATE (PSURFOBJ SurfObj, PBRUSHOBJ BrushObj, MIX RopMode, CONST PPOINT Points, INT Count, RECTL BoundRect, INT OrigX, INT OrigY);
+BOOL STDCALL FillPolygon_WINDING (PSURFOBJ SurfObj, PBRUSHOBJ BrushObj, MIX RopMode, CONST PPOINT Points, INT Count, RECTL BoundRect, INT OrigX, INT OrigY);
#endif /* __WIN32K_DIB_H */
HWND STDCALL
PaintingFindWinToRepaint(HWND hWnd, PW32THREAD Thread);
BOOL STDCALL
+PaintRedrawWindow(HWND hWnd, const RECT* UpdateRect, HRGN UpdateRgn,
+ ULONG Flags, ULONG ExFlags);
+BOOL STDCALL
PaintHaveToDelayNCPaint(PWINDOW_OBJECT Window, ULONG Flags);
HRGN STDCALL
PaintUpdateNCRegion(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags);
static int PALETTE_Graymax = 0;
static int palette_size;
+HPALETTE FASTCALL PALETTE_Init (VOID);
+VOID FASTCALL PALETTE_ValidateFlags (PALETTEENTRY* lpPalE, INT size);
+INT STDCALL PALETTE_SetMapping(PPALOBJ palPtr, UINT uStart, UINT uNum, BOOL mapOnly);
+INT FASTCALL PALETTE_ToPhysical (PDC dc, COLORREF color);
+
+PPALETTEENTRY FASTCALL ReturnSystemPalette (VOID);
+
#endif /* __WIN32K_PALETTE_H */
--- /dev/null
+BOOL STDCALL PATH_Arc (HDC hdc, INT x1, INT y1, INT x2, INT y2, INT xStart, INT yStart, INT xEnd, INT yEnd);
+BOOL FASTCALL PATH_AssignGdiPath (GdiPath *pPathDest, const GdiPath *pPathSrc);
+VOID FASTCALL PATH_DestroyGdiPath (GdiPath *pPath);
+BOOL STDCALL PATH_Ellipse (HDC hdc, INT x1, INT y1, INT x2, INT y2);
+VOID STDCALL PATH_EmptyPath (GdiPath *pPath);
+VOID FASTCALL PATH_InitGdiPath (GdiPath *pPath);
+BOOL STDCALL PATH_LineTo (HDC hdc, INT x, INT y);
+BOOL FASTCALL PATH_MoveTo (HDC hdc);
+BOOL STDCALL PATH_PolyBezier (HDC hdc, const POINT *pts, DWORD cbPoints);
+BOOL STDCALL PATH_PolyBezierTo (HDC hdc, const POINT *pts, DWORD cbPoints);
+BOOL STDCALL PATH_Polygon (HDC hdc, const POINT *pts, DWORD cbPoints);
+BOOL STDCALL PATH_Polyline (HDC hdc, const POINT *pts, DWORD cbPoints);
+BOOL STDCALL PATH_PolylineTo (HDC hdc, const POINT *pts, DWORD cbPoints);
+BOOL STDCALL PATH_PolyPolygon ( HDC hdc, const POINT* pts, const INT* counts, UINT polygons);
+BOOL STDCALL PATH_PolyPolyline( HDC hdc, const POINT* pts, const DWORD* counts, DWORD polylines);
+BOOL STDCALL PATH_Rectangle (HDC hdc, INT x1, INT y1, INT x2, INT y2);
+BOOL STDCALL PATH_PathToRegion (const GdiPath *pPath, INT nPolyFillMode, HRGN *pHrgn);
+#ifdef _WIN32K_PATH_INTERNAL
+BOOL STDCALL PATH_AddEntry (GdiPath *pPath, const POINT *pPoint, BYTE flags);
+BOOL STDCALL PATH_AddFlatBezier (GdiPath *pPath, POINT *pt, BOOL closed);
+BOOL STDCALL PATH_DoArcPart (GdiPath *pPath, FLOAT_POINT corners[], double angleStart, double angleEnd, BOOL addMoveTo);
+BOOL FASTCALL PATH_FlattenPath (GdiPath *pPath);
+BOOL FASTCALL PATH_GetPathFromHDC (HDC hdc, GdiPath **ppPath);
+VOID STDCALL PATH_NormalizePoint (FLOAT_POINT corners[], const FLOAT_POINT *pPoint, double *pX, double *pY);
+BOOL STDCALL PATH_PathToRegion(const GdiPath *pPath, INT nPolyFillMode, HRGN *pHrgn);
+BOOL STDCALL PATH_ReserveEntries (GdiPath *pPath, INT numEntries);
+VOID STDCALL PATH_ScaleNormalizedPoint (FLOAT_POINT corners[], double x, double y, POINT *pPoint);
+#endif
W32kIsEmptyRect(PRECT Rect);
BOOL STDCALL
W32kIntersectRect(PRECT Dest, const RECT* Src1, const RECT* Src2);
-BOOL
+BOOL STDCALL
W32kOffsetRect(LPRECT Rect, INT x, INT y);
--- /dev/null
+DWORD FASTCALL SCROLL_CreateScrollBar(PWINDOW_OBJECT Window, LONG idObject);
+DWORD STDCALL SCROLL_GetScrollBarInfo(PWINDOW_OBJECT Window, LONG idObject, PSCROLLBARINFO psbi);
#ifndef __WIN32K_SURFACE_H
#define __WIN32K_SURFACE_H
-INT BitsPerFormat(ULONG Format);
+INT FASTCALL BitsPerFormat (ULONG Format);
+ULONG FASTCALL BitmapFormat (WORD Bits, DWORD Compression);
#endif /* __WIN32K_SURFACE_H */
--- /dev/null
+BOOL FASTCALL InitFontSupport(VOID);
--- /dev/null
+#ifndef _SUBSYS_WIN32K_INCLUDE_TIMER_H
+#define _SUBSYS_WIN32K_INCLUDE_TIMER_H
+
+NTSTATUS FASTCALL InitTimerImpl(VOID);
+
+#endif /* ndef _SUBSYS_WIN32K_INCLUDE_TIMER_H */
ATOM Atom;
} PROPERTY, *PPROPERTY;
-VOID
+VOID FASTCALL
WinPosSetupInternalPos(VOID);
typedef struct _WINDOW_OBJECT
#define WINDOWOBJECT_NEED_INTERNALPAINT (0x00000010)
#define WINDOWOBJECT_RESTOREMAX (0x00000020)
-NTSTATUS
-InitWindowImpl(VOID);
-NTSTATUS
-CleanupWindowImpl(VOID);
-VOID
-W32kGetClientRect(PWINDOW_OBJECT WindowObject, PRECT Rect);
-PWINDOW_OBJECT
-W32kGetWindowObject(HWND hWnd);
-VOID
-W32kReleaseWindowObject(PWINDOW_OBJECT Window);
-HWND STDCALL
-W32kCreateDesktopWindow(PWINSTATION_OBJECT WindowStation,
+NTSTATUS FASTCALL InitWindowImpl (VOID);
+NTSTATUS FASTCALL CleanupWindowImpl (VOID);
+VOID FASTCALL W32kGetClientRect (PWINDOW_OBJECT WindowObject, PRECT Rect);
+PWINDOW_OBJECT FASTCALL W32kGetWindowObject (HWND hWnd);
+VOID FASTCALL W32kReleaseWindowObject (PWINDOW_OBJECT Window);
+HWND STDCALL W32kCreateDesktopWindow (PWINSTATION_OBJECT WindowStation,
PWNDCLASS_OBJECT DesktopClass,
ULONG Width, ULONG Height);
-BOOL
-W32kIsDesktopWindow(HWND hWnd);
-HWND
-W32kGetActiveWindow(VOID);
-BOOL
-W32kIsWindowVisible(HWND Wnd);
-BOOL
-W32kIsChildWindow(HWND Parent, HWND Child);
-HWND W32kGetDesktopWindow();
+BOOL FASTCALL W32kIsDesktopWindow (HWND hWnd);
+HWND FASTCALL W32kGetActiveWindow (VOID);
+BOOL FASTCALL W32kIsWindowVisible (HWND Wnd);
+BOOL FASTCALL W32kIsChildWindow (HWND Parent, HWND Child);
+HWND FASTCALL W32kGetDesktopWindow (VOID);
+HWND FASTCALL W32kGetFocusWindow (VOID);
+VOID FASTCALL W32kSetFocusWindow (HWND hWnd);
#endif /* __WIN32K_WINDOW_H */
#define SWP_NOCLIENTMOVE 0x0800
#define SWP_NOCLIENTSIZE 0x1000
-LRESULT
+LRESULT STDCALL
WinPosGetNonClientSize(HWND Wnd, RECT* WindowRect, RECT* ClientRect);
-UINT
+UINT STDCALL
WinPosGetMinMaxInfo(PWINDOW_OBJECT Window, POINT* MaxSize, POINT* MaxPos,
POINT* MinTrack, POINT* MaxTrack);
-UINT
+UINT STDCALL
WinPosMinMaximize(PWINDOW_OBJECT WindowObject, UINT ShowFlag, RECT* NewPos);
-BOOLEAN
+BOOLEAN STDCALL
WinPosSetWindowPos(HWND Wnd, HWND WndInsertAfter, INT x, INT y, INT cx,
INT cy, UINT flags);
-BOOLEAN
+BOOLEAN FASTCALL
WinPosShowWindow(HWND Wnd, INT Cmd);
-USHORT
+USHORT STDCALL
WinPosWindowFromPoint(PWINDOW_OBJECT ScopeWin, POINT WinPoint,
PWINDOW_OBJECT* Window);
((IoGetCurrentProcess()->Win32WindowStation) = (PVOID)(WinSta))
-NTSTATUS
+NTSTATUS FASTCALL
InitWindowStationImpl(VOID);
-NTSTATUS
+NTSTATUS FASTCALL
CleanupWindowStationImpl(VOID);
-NTSTATUS
+NTSTATUS STDCALL
ValidateWindowStationHandle(HWINSTA WindowStation,
KPROCESSOR_MODE AccessMode,
ACCESS_MASK DesiredAccess,
PWINSTATION_OBJECT *Object);
-NTSTATUS
+NTSTATUS STDCALL
ValidateDesktopHandle(HDESK Desktop,
KPROCESSOR_MODE AccessMode,
ACCESS_MASK DesiredAccess,
PDESKTOP_OBJECT *Object);
LRESULT CALLBACK
W32kDesktopWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
-PDESKTOP_OBJECT
+PDESKTOP_OBJECT FASTCALL
W32kGetActiveDesktop(VOID);
-VOID
+VOID FASTCALL
W32kInitializeDesktopGraphics(VOID);
-VOID
+VOID FASTCALL
W32kEndDesktopGraphics(VOID);
-HDC
+HDC FASTCALL
W32kGetScreenDC(VOID);
#endif /* __WIN32K_WINSTA_H */
-/* $Id: loader.c,v 1.9 2002/09/08 10:23:50 chorns Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: loader.c,v 1.10 2003/05/18 17:16:17 ea Exp $
*
*/
-/* $Id: dllmain.c,v 1.34 2003/04/02 23:18:48 gdalsnes Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dllmain.c,v 1.35 2003/05/18 17:16:17 ea Exp $
*
* Entry Point for win32k.sys
*/
#include <include/winsta.h>
#include <include/class.h>
#include <include/window.h>
+#include <include/object.h>
+#include <include/input.h>
+#include <include/timer.h>
+#include <include/text.h>
#define NDEBUG
#include <win32k/debug1.h>
-/* $Id: svctabm.c,v 1.3 2002/09/08 10:23:51 chorns Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: svctabm.c,v 1.4 2003/05/18 17:16:17 ea Exp $
*
* Entry Point for win32k.sys
*/
-# $Id: makefile,v 1.61 2003/04/02 23:19:28 gdalsnes Exp $
+# $Id: makefile,v 1.62 2003/05/18 17:16:17 ea Exp $
PATH_TO_TOP = ../..
CFLAGS_DBG :=
endif
-TARGET_CFLAGS = $(CFLAGS_DBG) -I$(PATH_TO_TOP)/ntoskrnl/include -I$(FREETYPE_DIR)/include -DUNICODE -Wall
+TARGET_CFLAGS =\
+ $(CFLAGS_DBG) \
+ -I$(PATH_TO_TOP)/ntoskrnl/include \
+ -I$(FREETYPE_DIR)/include \
+ -DUNICODE \
+ -Wall
-TARGET_LFLAGS = $(PATH_TO_TOP)/dk/nkm/lib/freetype.a
+TARGET_LFLAGS =\
+ $(PATH_TO_TOP)/dk/nkm/lib/freetype.a \
+ --disable-stdcall-fixup
ENG_OBJECTS= eng/debug.o eng/mem.o eng/brush.o eng/bitblt.o eng/clip.o \
eng/copybits.o eng/device.o eng/handle.o eng/lineto.o eng/paint.o \
-/* $Id: driver.c,v 1.24 2003/03/11 00:21:41 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: driver.c,v 1.25 2003/05/18 17:16:17 ea Exp $
*
* GDI Driver support routines
* (mostly swiped from Wine)
static PGRAPHICS_DRIVER DriverList;
static PGRAPHICS_DRIVER GenericDriver = 0;
-BOOL DRIVER_RegisterDriver(LPCWSTR Name, PGD_ENABLEDRIVER EnableDriver)
+BOOL DRIVER_RegisterDriver(LPCWSTR Name, PGD_ENABLEDRIVER EnableDriver)
{
PGRAPHICS_DRIVER Driver = ExAllocatePoolWithTag(NonPagedPool, sizeof(*Driver), DRIVER_TAG);
DPRINT( "DRIVER_RegisterDriver( Name: %S )\n", Name );
return (PGD_ENABLEDRIVER)GdiDriverInfo.EntryPoint;
}
-BOOL DRIVER_BuildDDIFunctions(PDRVENABLEDATA DED,
+BOOL DRIVER_BuildDDIFunctions(PDRVENABLEDATA DED,
PDRIVER_FUNCTIONS DF)
{
int i;
}
-BOOL DRIVER_UnregisterDriver(LPCWSTR Name)
+BOOL DRIVER_UnregisterDriver(LPCWSTR Name)
{
PGRAPHICS_DRIVER Driver = NULL;
}
}
-INT DRIVER_ReferenceDriver (LPCWSTR Name)
+INT DRIVER_ReferenceDriver (LPCWSTR Name)
{
GRAPHICS_DRIVER *Driver = DriverList;
return ++GenericDriver->ReferenceCount;
}
-INT DRIVER_UnreferenceDriver (LPCWSTR Name)
+INT DRIVER_UnreferenceDriver (LPCWSTR Name)
{
GRAPHICS_DRIVER *Driver = DriverList;
assert( GenericDriver != 0 );
return --GenericDriver->ReferenceCount;
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: error.c,v 1.5 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Errors
#include <include/error.h>
-VOID
+VOID FASTCALL
SetLastNtError(NTSTATUS Status)
{
SetLastWin32Error(RtlNtStatusToDosError(Status));
}
-VOID
+VOID FASTCALL
SetLastWin32Error(DWORD Status)
{
PTEB Teb = NtCurrentTeb();
-/* $Id: object.c,v 1.5 2002/06/26 18:38:24 hbirr Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: object.c,v 1.6 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-PVOID
+PVOID FASTCALL
HEADER_TO_BODY(PUSER_OBJECT_HEADER ObjectHeader)
{
return (((PUSER_OBJECT_HEADER)ObjectHeader) + 1);
}
-PUSER_OBJECT_HEADER
+PUSER_OBJECT_HEADER FASTCALL
BODY_TO_HEADER(PVOID ObjectBody)
{
return (((PUSER_OBJECT_HEADER)ObjectBody) - 1);
}
-VOID STATIC
+VOID STATIC FASTCALL
ObmpLockHandleTable(PUSER_HANDLE_TABLE HandleTable)
{
ExAcquireFastMutex(&HandleTable->ListLock);
}
-VOID STATIC
+VOID STATIC FASTCALL
ObmpUnlockHandleTable(PUSER_HANDLE_TABLE HandleTable)
{
ExReleaseFastMutex(&HandleTable->ListLock);
}
-VOID
+VOID FASTCALL
ObmpPerformRetentionChecks(PUSER_OBJECT_HEADER ObjectHeader)
{
if (ObjectHeader->RefCount < 0)
}
}
-PUSER_HANDLE
+PUSER_HANDLE FASTCALL
ObmpGetObjectByHandle(PUSER_HANDLE_TABLE HandleTable,
HANDLE Handle)
/*
return &(Block->Handles[Index % HANDLE_BLOCK_ENTRIES]);
}
-VOID
+VOID FASTCALL
ObmpCloseAllHandles(PUSER_HANDLE_TABLE HandleTable)
{
PLIST_ENTRY CurrentEntry;
ObmpUnlockHandleTable(HandleTable);
}
-VOID
+VOID FASTCALL
ObmpDeleteHandleTable(PUSER_HANDLE_TABLE HandleTable)
{
PUSER_HANDLE_BLOCK Current;
}
}
-PVOID
+PVOID FASTCALL
ObmpDeleteHandle(PUSER_HANDLE_TABLE HandleTable,
HANDLE Handle)
{
return ObjectBody;
}
-NTSTATUS
+NTSTATUS FASTCALL
ObmpInitializeObject(PUSER_HANDLE_TABLE HandleTable,
PUSER_OBJECT_HEADER ObjectHeader,
PHANDLE Handle,
}
-ULONG
+ULONG FASTCALL
ObmGetReferenceCount(PVOID ObjectBody)
{
PUSER_OBJECT_HEADER ObjectHeader = BODY_TO_HEADER(ObjectBody);
return ObjectHeader->RefCount;
}
-ULONG
+ULONG FASTCALL
ObmGetHandleCount(PVOID ObjectBody)
{
PUSER_OBJECT_HEADER ObjectHeader = BODY_TO_HEADER(ObjectBody);
return ObjectHeader->HandleCount;
}
-VOID
+VOID FASTCALL
ObmReferenceObject(PVOID ObjectBody)
/*
* FUNCTION: Increments a given object's reference count and performs
ObmpPerformRetentionChecks(ObjectHeader);
}
-VOID
+VOID FASTCALL
ObmDereferenceObject(PVOID ObjectBody)
/*
* FUNCTION: Decrements a given object's reference count and performs
ObmpPerformRetentionChecks(ObjectHeader);
}
-NTSTATUS
+NTSTATUS FASTCALL
ObmReferenceObjectByPointer(PVOID ObjectBody,
USER_OBJECT_TYPE ObjectType)
/*
return STATUS_SUCCESS;
}
-PVOID
+PVOID FASTCALL
ObmCreateObject(PUSER_HANDLE_TABLE HandleTable,
PHANDLE Handle,
USER_OBJECT_TYPE ObjectType,
return ObjectBody;
}
-NTSTATUS
+NTSTATUS FASTCALL
ObmCreateHandle(PUSER_HANDLE_TABLE HandleTable,
PVOID ObjectBody,
PHANDLE HandleReturn)
return STATUS_SUCCESS;
}
-NTSTATUS
+NTSTATUS FASTCALL
ObmReferenceObjectByHandle(PUSER_HANDLE_TABLE HandleTable,
HANDLE Handle,
USER_OBJECT_TYPE ObjectType,
return STATUS_SUCCESS;
}
-NTSTATUS
+NTSTATUS FASTCALL
ObmCloseHandle(PUSER_HANDLE_TABLE HandleTable,
HANDLE Handle)
{
return STATUS_SUCCESS;
}
-VOID
+VOID FASTCALL
ObmInitializeHandleTable(PUSER_HANDLE_TABLE HandleTable)
{
InitializeListHead(&HandleTable->ListHead);
ExInitializeFastMutex(&HandleTable->ListLock);
}
-VOID
+VOID FASTCALL
ObmFreeHandleTable(PUSER_HANDLE_TABLE HandleTable)
{
ObmpDeleteHandleTable(HandleTable);
}
-PUSER_HANDLE_TABLE
+PUSER_HANDLE_TABLE FASTCALL
ObmCreateHandleTable(VOID)
{
PUSER_HANDLE_TABLE HandleTable;
return HandleTable;
}
-VOID
+VOID FASTCALL
ObmDestroyHandleTable(PUSER_HANDLE_TABLE HandleTable)
{
ObmFreeHandleTable(HandleTable);
-/* $Id: callback.c,v 1.8 2003/05/17 14:30:28 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: callback.c,v 1.9 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <include/class.h>
#include <include/error.h>
#include <include/winsta.h>
+#include <include/window.h>
#include <include/msgqueue.h>
#include <user32/callback.h>
#include <include/callback.h>
-/* $Id: class.c,v 1.15 2003/05/03 14:12:14 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: class.c,v 1.16 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-NTSTATUS
+NTSTATUS FASTCALL
InitClassImpl(VOID)
{
return(STATUS_SUCCESS);
}
-NTSTATUS
+NTSTATUS FASTCALL
CleanupClassImpl(VOID)
{
return(STATUS_SUCCESS);
}
-NTSTATUS
+NTSTATUS STDCALL
ClassReferenceClassByName(PW32PROCESS Process,
PWNDCLASS_OBJECT* Class,
LPWSTR ClassName)
return(STATUS_NOT_FOUND);
}
-NTSTATUS
+NTSTATUS FASTCALL
ClassReferenceClassByAtom(PWNDCLASS_OBJECT *Class,
RTL_ATOM ClassAtom)
{
return(Status);
}
-NTSTATUS
+NTSTATUS FASTCALL
ClassReferenceClassByNameOrAtom(PWNDCLASS_OBJECT *Class,
LPWSTR ClassNameOrAtom)
{
return(0);
}
-PWNDCLASS_OBJECT
+PWNDCLASS_OBJECT FASTCALL
W32kCreateClass(LPWNDCLASSEX lpwcx,
BOOL bUnicodeClass)
{
return(Atom);
}
-ULONG
+ULONG FASTCALL
W32kGetClassLong(PWINDOW_OBJECT WindowObject, ULONG Offset)
{
LONG Ret;
- /* $Id: guicheck.c,v 1.10 2003/03/06 23:57:03 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: guicheck.c,v 1.11 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-VOID
+VOID FASTCALL
W32kGraphicsCheck(BOOL Create)
{
if (Create)
}
-VOID
+VOID FASTCALL
W32kGuiCheck(VOID)
{
if (PsGetWin32Process() == NULL)
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: hook.c,v 1.2 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Window hooks
-/* $Id: input.c,v 1.5 2003/03/09 18:44:59 jfilby Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: input.c,v 1.6 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <include/winsta.h>
#include <include/msgqueue.h>
#include <ddk/ntddmou.h>
+#include <include/mouse.h>
#define NDEBUG
#include <debug.h>
static KEVENT InputThreadsStart;
static BOOLEAN InputThreadsRunning = FALSE;
-VOID MouseGDICallBack(PMOUSE_INPUT_DATA Data, ULONG InputCount);
-
/* FUNCTIONS *****************************************************************/
NTSTATUS STDCALL STATIC
return(STATUS_SUCCESS);
}
-NTSTATUS
+NTSTATUS FASTCALL
InitInputImpl(VOID)
{
NTSTATUS Status;
return(STATUS_SUCCESS);
}
-NTSTATUS
+NTSTATUS FASTCALL
CleanupInputImp(VOID)
{
return(STATUS_SUCCESS);
-/* $Id: keyboard.c,v 1.2 2002/10/31 00:03:31 dwelch Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: keyboard.c,v 1.3 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
int cchBuff,
UINT wFlags)
{
+ return(0);
}
BOOL STDCALL
}
return(FALSE);
}
+/* EOF */
-/* $Id: message.c,v 1.17 2003/05/18 06:47:19 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: message.c,v 1.18 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-NTSTATUS
+NTSTATUS FASTCALL
W32kInitMessageImpl(VOID)
{
return(STATUS_SUCCESS);
}
-NTSTATUS
+NTSTATUS FASTCALL
W32kCleanupMessageImpl(VOID)
{
return(STATUS_SUCCESS);
-/* $Id: metric.c,v 1.6 2003/03/13 20:02:36 rcampbell Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: metric.c,v 1.7 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
-/* $Id: msgqueue.c,v 1.7 2002/11/01 11:29:58 dwelch Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: msgqueue.c,v 1.8 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-VOID
+VOID FASTCALL
MsqIncPaintCountQueue(PUSER_MESSAGE_QUEUE Queue)
{
ExAcquireFastMutex(&Queue->Lock);
ExReleaseFastMutex(&Queue->Lock);
}
-VOID
+VOID FASTCALL
MsqDecPaintCountQueue(PUSER_MESSAGE_QUEUE Queue)
{
ExAcquireFastMutex(&Queue->Lock);
}
-NTSTATUS
+NTSTATUS FASTCALL
MsqInitializeImpl(VOID)
{
/*CurrentFocusMessageQueue = NULL;*/
return(STATUS_SUCCESS);
}
-VOID
+VOID FASTCALL
MsqInsertSystemMessage(MSG* Msg)
{
KIRQL OldIrql;
KeSetEvent(&HardwareMessageEvent, IO_NO_INCREMENT, FALSE);
}
-BOOL STATIC
+BOOL STATIC STDCALL
MsqTranslateMouseMessage(HWND hWnd, UINT FilterLow, UINT FilterHigh,
PUSER_MESSAGE Message, BOOL Remove,
PWINDOW_OBJECT ScopeWin, PUSHORT HitTest,
return(TRUE);
}
-BOOL
+BOOL STDCALL
MsqPeekHardwareMessage(PUSER_MESSAGE_QUEUE MessageQueue, HWND hWnd,
UINT FilterLow, UINT FilterHigh, BOOL Remove,
PUSER_MESSAGE* Message)
return(FALSE);
}
-VOID
+VOID STDCALL
MsqPostKeyboardMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
#if 0
#endif
}
-VOID
+VOID FASTCALL
MsqInitializeMessage(PUSER_MESSAGE Message,
LPMSG Msg)
{
RtlMoveMemory(&Message->Msg, Msg, sizeof(MSG));
}
-PUSER_MESSAGE
+PUSER_MESSAGE FASTCALL
MsqCreateMessage(LPMSG Msg)
{
PUSER_MESSAGE Message;
return Message;
}
-VOID
+VOID FASTCALL
MsqDestroyMessage(PUSER_MESSAGE Message)
{
ExFreePool(Message);
}
-VOID
+VOID FASTCALL
MsqDispatchSentNotifyMessages(PUSER_MESSAGE_QUEUE MessageQueue)
{
PLIST_ENTRY ListEntry;
}
}
-BOOLEAN
+BOOLEAN FASTCALL
MsqPeekSentMessages(PUSER_MESSAGE_QUEUE MessageQueue)
{
return(!IsListEmpty(&MessageQueue->SentMessagesListHead));
}
-BOOLEAN
+BOOLEAN FASTCALL
MsqDispatchOneSentMessage(PUSER_MESSAGE_QUEUE MessageQueue)
{
PUSER_SENT_MESSAGE Message;
return(TRUE);
}
-VOID
+VOID FASTCALL
MsqSendNotifyMessage(PUSER_MESSAGE_QUEUE MessageQueue,
PUSER_SENT_MESSAGE_NOTIFY NotifyMessage)
{
ExReleaseFastMutex(&MessageQueue->Lock);
}
-VOID
+VOID FASTCALL
MsqSendMessage(PUSER_MESSAGE_QUEUE MessageQueue,
PUSER_SENT_MESSAGE Message)
{
ExReleaseFastMutex(&MessageQueue->Lock);
}
-VOID
+VOID FASTCALL
MsqPostMessage(PUSER_MESSAGE_QUEUE MessageQueue, PUSER_MESSAGE Message)
{
ExAcquireFastMutex(&MessageQueue->Lock);
ExReleaseFastMutex(&MessageQueue->Lock);
}
-BOOLEAN
+BOOLEAN STDCALL
MsqFindMessage(IN PUSER_MESSAGE_QUEUE MessageQueue,
IN BOOLEAN Hardware,
IN BOOLEAN Remove,
return(FALSE);
}
-NTSTATUS
+NTSTATUS FASTCALL
MsqWaitForNewMessages(PUSER_MESSAGE_QUEUE MessageQueue)
{
PVOID WaitObjects[2] = {&MessageQueue->NewMessages, &HardwareMessageEvent};
NULL));
}
-VOID
+VOID FASTCALL
MsqInitializeMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue)
{
InitializeListHead(&MessageQueue->PostedMessagesListHead);
MessageQueue->FocusWindow = NULL;
}
-VOID
+VOID FASTCALL
MsqFreeMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue)
{
PLIST_ENTRY CurrentEntry;
}
}
-PUSER_MESSAGE_QUEUE
+PUSER_MESSAGE_QUEUE FASTCALL
MsqCreateMessageQueue(VOID)
{
PUSER_MESSAGE_QUEUE MessageQueue;
return MessageQueue;
}
-VOID
+VOID FASTCALL
MsqDestroyMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue)
{
MsqFreeMessageQueue(MessageQueue);
-/* $Id: painting.c,v 1.12 2003/03/27 02:25:14 rcampbell Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: painting.c,v 1.13 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-HRGN STATIC
+HRGN STATIC STDCALL
PaintDoPaint(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags, ULONG ExFlags)
{
HDC hDC;
return(hRgn);
}
-VOID STATIC
+VOID STATIC FASTCALL
PaintUpdateInternalPaint(PWINDOW_OBJECT Window, ULONG Flags)
{
if (Flags & RDW_INTERNALPAINT)
}
}
-VOID STATIC
+VOID STATIC FASTCALL
PaintValidateParent(PWINDOW_OBJECT Child)
{
HWND DesktopHandle = W32kGetDesktopWindow();
W32kReleaseWindowObject(Desktop);
}
-VOID STATIC
+VOID STATIC STDCALL
PaintUpdateRgns(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags,
BOOL First)
{
PaintUpdateInternalPaint(Window, Flags);
}
-BOOL
+BOOL STDCALL
PaintRedrawWindow(HWND hWnd, const RECT* UpdateRect, HRGN UpdateRgn,
ULONG Flags, ULONG ExFlags)
{
WINBOOL bErase)
{
HRGN hRGN;
- hRGN = W32kCreateRectRgnIndirect(lpRect);
+ hRGN = W32kCreateRectRgnIndirect((PRECT)lpRect);
return NtUserInvalidateRgn(hWnd, hRGN, bErase);
}
W32kSendMessage(hWnd, WM_PAINT, 0, 0, FALSE);
return(TRUE);
}
-
+/* EOF */
-/* $Id: prop.c,v 1.1 2002/09/04 18:09:31 dwelch Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: prop.c,v 1.2 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-PPROPERTY
+PPROPERTY FASTCALL
W32kGetProp(PWINDOW_OBJECT WindowObject, ATOM Atom)
{
PLIST_ENTRY ListEntry;
W32kReleaseWindowObject(WindowObject);
return(TRUE);
}
+/* EOF */
-/* $Id: scrollbar.c,v 1.4 2003/01/24 22:42:15 jfilby Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: scrollbar.c,v 1.5 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <include/winsta.h>
#include <include/winpos.h>
#include <include/rect.h>
+#include <include/scroll.h>
//#define NDEBUG
#include <debug.h>
* 'thumbSize' returns the size of the thumb, and 'thumbPos' returns the position of the thumb relative to the left or to
* the top. Return TRUE if the scrollbar is vertical, FALSE if horizontal.
*/
-static BOOL
+static BOOL STDCALL
SCROLL_GetScrollBarRect (PWINDOW_OBJECT Window, INT nBar, PRECT lprect)
{
SCROLLBARINFO info;
return vertical;
}
-DWORD SCROLL_CreateScrollBar(PWINDOW_OBJECT Window, LONG idObject)
+DWORD FASTCALL SCROLL_CreateScrollBar(PWINDOW_OBJECT Window, LONG idObject)
{
PSCROLLBARINFO psbi;
LRESULT Result;
return 0;
}
-DWORD SCROLL_GetScrollBarInfo(PWINDOW_OBJECT Window, LONG idObject, PSCROLLBARINFO psbi)
+DWORD STDCALL SCROLL_GetScrollBarInfo(PWINDOW_OBJECT Window, LONG idObject, PSCROLLBARINFO psbi)
{
switch(idObject)
{
-/*
+/* $Id: stubs.c,v 1.10 2003/05/18 17:16:17 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native User stubs
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: timer.c,v 1.2 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
static NTSTATUS STDCALL
-TimerThreadMain()
+TimerThreadMain(VOID)
{
NTSTATUS Status;
LARGE_INTEGER CurrentTime;
-NTSTATUS
-InitTimerImpl()
+NTSTATUS FASTCALL
+InitTimerImpl(VOID)
{
NTSTATUS Status;
return Status;
}
-
-
-
-
-
+/* EOF */
-/* $Id: userobj.c,v 1.1 2001/07/06 00:05:05 rex Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: userobj.c,v 1.2 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
static LIST_ENTRY UserObjectList;
-PUSER_OBJECT USEROBJ_AllocObject (WORD size, WORD magic)
+PUSER_OBJECT FASTCALL USEROBJ_AllocObject (WORD size, WORD magic)
{
PUSER_OBJECT_HEADER newObject;
return UserObjectHeaderToBody (newObject);
}
-BOOL USEROBJ_FreeObject (PUSER_OBJECT object, WORD magic)
+BOOL FASTCALL USEROBJ_FreeObject (PUSER_OBJECT object, WORD magic)
{
PUSER_OBJECT_HEADER objectHeader;
return TRUE;
}
-HUSEROBJ USEROBJ_PtrToHandle (PUSER_OBJECT object, WORD magic)
+HUSEROBJ FASTCALL USEROBJ_PtrToHandle (PUSER_OBJECT object, WORD magic)
{
PUSER_OBJECT_HEADER objectHeader;
return UserObjectHeaderToHandle(objectHeader);
}
-PUSER_OBJECT USEROBJ_HandleToPtr (HUSEROBJ handle, WORD magic)
+PUSER_OBJECT FASTCALL USEROBJ_HandleToPtr (HUSEROBJ handle, WORD magic)
{
PUSER_OBJECT_HEADER objectHeader;
return UserObjectHeaderToBody (objectHeader);
}
-BOOL USEROBJ_LockObject (HUSEROBJ objectHandle)
+BOOL FASTCALL USEROBJ_LockObject (HUSEROBJ objectHandle)
{
PUSER_OBJECT_HEADER objectHeader;
return TRUE;
}
-BOOL USEROBJ_UnlockObject (HUSEROBJ objectHandle)
+BOOL FASTCALL USEROBJ_UnlockObject (HUSEROBJ objectHandle)
{
PUSER_OBJECT_HEADER objectHeader;
return TRUE;
}
-
-
+/* EOF */
-/* $Id: windc.c,v 1.10 2003/05/04 15:41:40 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: windc.c,v 1.11 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
-VOID STATIC
+VOID STATIC FASTCALL
DceOffsetVisRgn(HDC hDC, HRGN hVisRgn)
{
DC *dc = DC_HandleToPtr(hDC);
DC_ReleasePtr(hDC);
}
-BOOL STATIC
+BOOL STATIC STDCALL
DceGetVisRect(PWINDOW_OBJECT Window, BOOL ClientArea, RECT* Rect)
{
if (ClientArea)
return(FALSE);
}
-BOOL
+BOOL STDCALL
DceAddClipRects(PWINDOW_OBJECT Parent, PWINDOW_OBJECT End,
HRGN ClipRgn, PRECT Rect, INT XOffset, INT YOffset)
{
return(FALSE);
}
-HRGN
+HRGN STDCALL
DceGetVisRgn(HWND hWnd, ULONG Flags, HWND hWndChild, ULONG CFlags)
{
PWINDOW_OBJECT Window;
return NtUserGetDCEx(hWnd, NULL, NULL == hWnd ? DCX_CACHE | DCX_WINDOW : DCX_USESTYLE);
}
-DCE* DceAllocDCE(HWND hWnd, DCE_TYPE Type)
+DCE * FASTCALL DceAllocDCE(HWND hWnd, DCE_TYPE Type)
{
HDCE DceHandle;
DCE* Dce;
return(Dce);
}
-VOID STATIC
+VOID STATIC STDCALL
DceSetDrawable(PWINDOW_OBJECT WindowObject, HDC hDC, ULONG Flags,
BOOL SetClipOrigin)
{
return(Dce->hDC);
}
-BOOL
+BOOL FASTCALL
DCE_InternalDelete(PDCE Dce)
{
PDCE PrevInList;
-/* $Id: window.c,v 1.44 2003/05/17 14:30:28 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: window.c,v 1.45 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <include/callback.h>
#include <include/msgqueue.h>
#include <include/rect.h>
+#include <include/dce.h>
+#include <include/paint.h>
+#include <include/painting.h>
+#include <include/scroll.h>
#define NDEBUG
#include <win32k/debug1.h>
}
}
-VOID
+VOID FASTCALL
W32kSetFocusWindow(HWND hWnd)
{
}
-BOOL
+BOOL FASTCALL
W32kIsChildWindow(HWND Parent, HWND Child)
{
PWINDOW_OBJECT BaseWindow = W32kGetWindowObject(Child);
return(FALSE);
}
-BOOL
+BOOL FASTCALL
W32kIsWindowVisible(HWND Wnd)
{
PWINDOW_OBJECT BaseWindow = W32kGetWindowObject(Wnd);
return(Result);
}
-BOOL
+BOOL FASTCALL
W32kIsDesktopWindow(HWND hWnd)
{
PWINDOW_OBJECT WindowObject;
return(IsDesktop);
}
-HWND W32kGetDesktopWindow()
+HWND FASTCALL W32kGetDesktopWindow(VOID)
{
return W32kGetActiveDesktop()->DesktopWindow;
}
-HWND W32kGetParentWindow(HWND hWnd)
+HWND FASTCALL W32kGetParentWindow(HWND hWnd)
{
return W32kGetWindowObject(hWnd)->ParentHandle;
}
-PWINDOW_OBJECT
+PWINDOW_OBJECT FASTCALL
W32kGetWindowObject(HWND hWnd)
{
PWINDOW_OBJECT WindowObject;
return(WindowObject);
}
-VOID
+VOID FASTCALL
W32kReleaseWindowObject(PWINDOW_OBJECT Window)
{
ObmDereferenceObject(Window);
*
* \note Does not check the validity of the parameters
*/
-VOID
+VOID FASTCALL
W32kGetClientRect(PWINDOW_OBJECT WindowObject, PRECT Rect)
{
ASSERT( WindowObject );
return(TRUE);
}
-HWND
+HWND FASTCALL
W32kGetActiveWindow(VOID)
{
PUSER_MESSAGE_QUEUE Queue;
}
}
-HWND
+HWND FASTCALL
W32kGetFocusWindow(VOID)
{
PUSER_MESSAGE_QUEUE Queue;
}
-WNDPROC
+WNDPROC FASTCALL
W32kGetWindowProc(HWND Wnd)
{
PWINDOW_OBJECT WindowObject;
return(WndProc);
}
-NTSTATUS
+NTSTATUS FASTCALL
InitWindowImpl(VOID)
{
InitializeListHead(&RegisteredMessageListHead);
return(STATUS_SUCCESS);
}
-NTSTATUS
+NTSTATUS FASTCALL
CleanupWindowImpl(VOID)
{
return(STATUS_SUCCESS);
ExReleaseFastMutexUnsafe (&PsGetWin32Process()->WindowListLock);
ObmDereferenceObject (classObject);
+#endif
return (HWND)0;
-#endif
}
DWORD STDCALL
DWORD STDCALL
NtUserGetWindowDC(HWND hWnd)
{
- return NtUserGetDCEx( hWnd, 0, DCX_USESTYLE | DCX_WINDOW );
+ return (DWORD) NtUserGetDCEx( hWnd, 0, DCX_USESTYLE | DCX_WINDOW );
}
DWORD STDCALL
if (NULL != lprcUpdate)
{
- Status = MmCopyFromCaller(&SafeUpdateRect, lprcUpdate, sizeof(RECT));
+ Status = MmCopyFromCaller(&SafeUpdateRect, (PRECT) lprcUpdate, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
return Status;
-/* $Id: winpos.c,v 1.9 2003/05/18 07:51:41 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: winpos.c,v 1.10 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <include/rect.h>
#include <include/callback.h>
#include <include/painting.h>
+#include <include/dce.h>
#define NDEBUG
#include <debug.h>
#define SWP_EX_PAINTSELF 0x0002
-ATOM AtomInternalPos = NULL;
+ATOM AtomInternalPos = (ATOM) NULL;
/* FUNCTIONS *****************************************************************/
(((Style) & WS_THICKFRAME) && \
!((Style) & (WS_DLGFRAME | WS_BORDER)) == WS_DLGFRAME)
-VOID
+VOID FASTCALL
WinPosSetupInternalPos(VOID)
{
AtomInternalPos = NtAddAtom(L"SysIP", (ATOM*)(PULONG)&AtomInternalPos);
return(TRUE);
}
-BOOL
+BOOL FASTCALL
WinPosActivateOtherWindow(PWINDOW_OBJECT Window)
{
+ return FALSE;
}
-POINT STATIC
+POINT STATIC FASTCALL
WinPosFindIconPos(HWND hWnd, POINT Pos)
{
+ POINT point;
+ //FIXME
+ return point;
}
-HWND STATIC
+HWND STATIC FASTCALL
WinPosCreateIconTitle(PWINDOW_OBJECT WindowObject)
{
return(NULL);
}
-BOOL STATIC
+BOOL STATIC FASTCALL
WinPosShowIconTitle(PWINDOW_OBJECT WindowObject, BOOL Show)
{
PINTERNALPOS InternalPos = NtUserGetProp(WindowObject->Self,
return(FALSE);
}
-PINTERNALPOS STATIC
+PINTERNALPOS STATIC STDCALL
WinPosInitInternalPos(PWINDOW_OBJECT WindowObject, POINT pt, PRECT RestoreRect)
{
PINTERNALPOS InternalPos = NtUserGetProp(WindowObject->Self,
return(InternalPos);
}
-UINT
+UINT STDCALL
WinPosMinMaximize(PWINDOW_OBJECT WindowObject, UINT ShowFlag, RECT* NewPos)
{
POINT Size;
return(SwpFlags);
}
-UINT
+UINT STDCALL
WinPosGetMinMaxInfo(PWINDOW_OBJECT Window, POINT* MaxSize, POINT* MaxPos,
POINT* MinTrack, POINT* MaxTrack)
{
if (MaxPos) *MaxPos = MinMax.ptMaxPosition;
if (MinTrack) *MinTrack = MinMax.ptMinTrackSize;
if (MaxTrack) *MaxTrack = MinMax.ptMaxTrackSize;
+
+ return 0; //FIXME: what does it return?
}
-BOOL STATIC
+BOOL STATIC FASTCALL
WinPosChangeActiveWindow(HWND Wnd, BOOL MouseMsg)
{
+ return FALSE;
}
-LONG STATIC
+LONG STATIC STDCALL
WinPosDoNCCALCSize(PWINDOW_OBJECT Window, PWINDOWPOS WinPos,
RECT* WindowRect, RECT* ClientRect)
{
+ return 0; //FIXME
}
-BOOL
+BOOL STDCALL
WinPosDoWinPosChanging(PWINDOW_OBJECT WindowObject,
PWINDOWPOS WinPos,
PRECT WindowRect,
return(TRUE);
}
-BOOLEAN
+BOOLEAN STDCALL
WinPosSetWindowPos(HWND Wnd, HWND WndInsertAfter, INT x, INT y, INT cx,
INT cy, UINT flags)
{
{
Window->Style |= WS_VISIBLE;
flags |= SWP_EX_PAINTSELF;
- VisRgn = 1;
+ VisRgn = (HRGN) 1;
}
else
{
if (flags & SWP_EX_PAINTSELF)
{
PaintRedrawWindow(Window->Self, NULL,
- (VisRgn == 1) ? 0 : VisRgn,
+ (VisRgn == (HRGN) 1) ? 0 : VisRgn,
RDW_ERASE | RDW_FRAME | RDW_INVALIDATE |
RDW_ALLCHILDREN,
RDW_EX_XYWINDOW | RDW_EX_USEHRGN);
else
{
PaintRedrawWindow(Window->Self, NULL,
- (VisRgn == 1) ? 0 : VisRgn,
+ (VisRgn == (HRGN) 1) ? 0 : VisRgn,
RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN,
RDW_EX_USEHRGN);
}
return(TRUE);
}
-LRESULT
+LRESULT STDCALL
WinPosGetNonClientSize(HWND Wnd, RECT* WindowRect, RECT* ClientRect)
{
*ClientRect = *WindowRect;
return(W32kSendNCCALCSIZEMessage(Wnd, FALSE, ClientRect, NULL));
}
-BOOLEAN
+BOOLEAN FASTCALL
WinPosShowWindow(HWND Wnd, INT Cmd)
{
BOOLEAN WasVisible;
return(WasVisible);
}
-BOOL STATIC
+BOOL STATIC FASTCALL
WinPosPtInWindow(PWINDOW_OBJECT Window, POINT Point)
{
return(Point.x >= Window->WindowRect.left &&
Point.y < Window->WindowRect.bottom);
}
-USHORT STATIC
+USHORT STATIC STDCALL
WinPosSearchChildren(PWINDOW_OBJECT ScopeWin, POINT Point,
PWINDOW_OBJECT* Window)
{
return(0);
}
-USHORT
+USHORT STDCALL
WinPosWindowFromPoint(PWINDOW_OBJECT ScopeWin, POINT WinPoint,
PWINDOW_OBJECT* Window)
{
return(HitTest);
}
+/* EOF */
-/* $Id: winsta.c,v 1.12 2003/03/06 23:57:03 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: winsta.c,v 1.13 2003/05/18 17:16:17 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* INCLUDES ******************************************************************/
#include <ddk/ntddk.h>
+#include <ddk/ntddmou.h>
#include <win32k/win32k.h>
#include <include/winsta.h>
#include <include/object.h>
#include <napi/win32.h>
#include <include/class.h>
#include <include/window.h>
+#include <include/error.h>
+#include <include/mouse.h>
#define NDEBUG
#include <debug.h>
/* FUNCTIONS *****************************************************************/
-PDESKTOP_OBJECT
+PDESKTOP_OBJECT FASTCALL
W32kGetActiveDesktop(VOID)
{
return(InputDesktop);
}
-NTSTATUS
+NTSTATUS FASTCALL
InitWindowStationImpl(VOID)
{
OBJECT_ATTRIBUTES ObjectAttributes;
return(STATUS_SUCCESS);
}
-NTSTATUS
+NTSTATUS FASTCALL
CleanupWindowStationImpl(VOID)
{
return STATUS_SUCCESS;
}
-NTSTATUS
+NTSTATUS STDCALL
ValidateWindowStationHandle(HWINSTA WindowStation,
KPROCESSOR_MODE AccessMode,
ACCESS_MASK DesiredAccess,
return Status;
}
-NTSTATUS
+NTSTATUS STDCALL
ValidateDesktopHandle(HDESK Desktop,
KPROCESSOR_MODE AccessMode,
ACCESS_MASK DesiredAccess,
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING WindowStationName;
- PWINSTATION_OBJECT WinStaObject;
+ //PWINSTATION_OBJECT WinStaObject;
WCHAR NameBuffer[MAX_PATH];
NTSTATUS Status;
HWINSTA WinSta;
return(TRUE);
}
-VOID
+VOID FASTCALL
W32kInitializeDesktopGraphics(VOID)
{
ScreenDeviceContext = W32kCreateDC(L"DISPLAY", NULL, NULL, NULL);
NtUserAcquireOrReleaseInputOwnership(FALSE);
}
-VOID
+VOID FASTCALL
W32kEndDesktopGraphics(VOID)
{
NtUserAcquireOrReleaseInputOwnership(TRUE);
}
}
-HDC
+HDC FASTCALL
W32kGetScreenDC(VOID)
{
return(ScreenDeviceContext);
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: bezier.c,v 1.3 2003/05/18 17:16:17 ea Exp $ */
#include <windows.h>
#include <ddk/ntddk.h>
+#include <math.h>
/******************************************************************
*
* level is the recursion depth
* returns true if the recusion can be terminated
*/
-static BOOL BezierCheck( int level, POINT *Points)
+static BOOL FASTCALL BezierCheck( int level, POINT *Points)
{
INT dx, dy;
/* Helper for GDI_Bezier.
* Just handles one Bezier, so Points should point to four POINTs
*/
-static void GDI_InternalBezier( POINT *Points, POINT **PtsOut, INT *dwOut,
+static void STDCALL GDI_InternalBezier( POINT *Points, POINT **PtsOut, INT *dwOut,
INT *nPtsOut, INT level )
{
if(*nPtsOut == *dwOut) {
* alternative would be to call the function twice, once to determine the size
* and a second time to do the work - I decided this was too much of a pain].
*/
-POINT *GDI_Bezier( const POINT *Points, INT count, INT *nPtsOut )
+POINT * FASTCALL GDI_Bezier( const POINT *Points, INT count, INT *nPtsOut )
{
POINT *out;
INT Bezier, dwOut = BEZIER_INITBUFSIZE, i;
return out;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: bitmaps.c,v 1.27 2003/05/18 17:16:17 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
//#include <win32k/debug.h>
#include "../eng/handle.h"
#include <include/inteng.h>
+#include <include/eng.h>
+#include <include/surface.h>
#define NDEBUG
#include <win32k/debug1.h>
return hBitmap;
}
-BOOL Bitmap_InternalDelete( PBITMAPOBJ pBmp )
+BOOL FASTCALL Bitmap_InternalDelete( PBITMAPOBJ pBmp )
{
ASSERT( pBmp );
if( pBmp->bitmap.bmBits )
/* Internal Functions */
-INT
+INT FASTCALL
BITMAPOBJ_GetWidthBytes (INT bmWidth, INT bpp)
{
switch(bpp)
return -1;
}
-HBITMAP BITMAPOBJ_CopyBitmap(HBITMAP hBitmap)
+HBITMAP FASTCALL BITMAPOBJ_CopyBitmap(HBITMAP hBitmap)
{
PBITMAPOBJ bmp;
HBITMAP res;
return res;
}
-INT BITMAP_GetObject(BITMAPOBJ * bmp, INT count, LPVOID buffer)
+INT STDCALL BITMAP_GetObject(BITMAPOBJ * bmp, INT count, LPVOID buffer)
{
if(bmp->dib)
{
return count;
}
}
+/* EOF */
-/* $Id: brush.c,v 1.19 2003/02/25 23:08:54 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: brush.c,v 1.20 2003/05/18 17:16:17 ea Exp $
*/
{
UNIMPLEMENTED;
}
+/* EOF */
-
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: cliprgn.c,v 1.15 2003/05/18 17:16:17 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#define NDEBUG
#include <win32k/debug1.h>
-VOID
+VOID FASTCALL
CLIPPING_UpdateGCRegion(DC* Dc)
{
if (Dc->w.hGCClipRgn == NULL)
}
-
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: color.c,v 1.17 2003/05/18 17:16:17 ea Exp $ */
+
// FIXME: Use PXLATEOBJ logicalToSystem instead of int *mapping
#undef WIN32_LEAN_AND_MEAN
#include <win32k/pen.h>
#include "../eng/handle.h"
#include <include/inteng.h>
+#include <include/color.h>
+#include <include/palette.h>
#define NDEBUG
#include <win32k/debug1.h>
{ 0xff, 0xff, 0xff, PC_SYS_USED } // last 10
};
-ULONG W32kGetSysColor(int nIndex)
+ULONG FASTCALL W32kGetSysColor(int nIndex)
{
PALETTEENTRY *p = COLOR_sysPalTemplate + (nIndex * sizeof(PALETTEENTRY));
return RGB(p->peRed, p->peGreen, p->peBlue);
return(W32kCreateSolidBrush(Col));
}
-//forward declarations
-COLORREF COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF color );
-const PALETTEENTRY* COLOR_GetSystemPaletteTemplate(void)
+const PALETTEENTRY* FASTCALL COLOR_GetSystemPaletteTemplate(void)
{
return (const PALETTEENTRY*)&COLOR_sysPalTemplate;
}
return 0x666;
}
-int COLOR_PaletteLookupPixel(PALETTEENTRY *palPalEntry, int size,
+INT STDCALL COLOR_PaletteLookupPixel(PALETTEENTRY *palPalEntry, INT size,
PXLATEOBJ XlateObj, COLORREF col, BOOL skipReserved)
{
int i, best = 0, diff = 0x7fffffff;
return (XlateObj->pulXlate) ? XlateObj->pulXlate[best] : best;
}
-COLORREF COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF color )
+COLORREF STDCALL COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF color )
{
unsigned char spec_type = color >> 24;
int i;
return (0x00ffffff & *(COLORREF*)(COLOR_sysPal + COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL, color, FALSE)));
}
-int COLOR_PaletteLookupExactIndex( PALETTEENTRY* palPalEntry, int size,
+int STDCALL COLOR_PaletteLookupExactIndex( PALETTEENTRY* palPalEntry, int size,
COLORREF col )
{
int i;
}
return -1;
}
+/* EOF */
-/* $Id: coord.c,v 1.10 2003/03/18 08:34:37 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: coord.c,v 1.11 2003/05/18 17:16:18 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
return TRUE;
}
-VOID STATIC
+VOID STATIC FASTCALL
CoordDPtoLP(PDC Dc, LPPOINT Point)
{
FLOAT x, y;
return TRUE;
}
-
+/* EOF */
-/* $Id: dc.c,v 1.59 2003/05/04 15:41:40 gvg Exp $
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dc.c,v 1.60 2003/05/18 17:16:18 ea Exp $
*
* DC.C - Device context functions
*
#include <win32k/text.h>
#include "../eng/handle.h"
#include <include/inteng.h>
+#include <include/eng.h>
#define NDEBUG
#include <win32k/debug1.h>
// --------------------------------------------------------- File Statics
-static void W32kSetDCState16(HDC hDC, HDC hDCSave);
+static VOID FASTCALL W32kSetDCState16(HDC hDC, HDC hDCSave);
// ----------------------------------------------------- Public Functions
return oldColor;
}
-static void W32kSetDCState16(HDC hDC, HDC hDCSave)
+STATIC VOID FASTCALL W32kSetDCState16(HDC hDC, HDC hDCSave)
{
PDC dc, dcs;
// ---------------------------------------------------- Private Interface
-HDC DC_AllocDC(LPCWSTR Driver)
+HDC FASTCALL DC_AllocDC(LPCWSTR Driver)
{
PDC NewDC;
HDC hDC;
return hDC;
}
-HDC DC_FindOpenDC(LPCWSTR Driver)
+HDC FASTCALL DC_FindOpenDC(LPCWSTR Driver)
{
return NULL;
}
/*!
* Initialize some common fields in the Device Context structure.
*/
-void DC_InitDC(HDC DCHandle)
+VOID FASTCALL DC_InitDC(HDC DCHandle)
{
// W32kRealizeDefaultPalette(DCHandle);
}
-void DC_FreeDC(HDC DCToFree)
+VOID FASTCALL DC_FreeDC(HDC DCToFree)
{
if (!GDIOBJ_FreeObj(DCToFree, GO_DC_MAGIC, GDIOBJFLAG_DEFAULT))
{
}
}
-BOOL DC_InternalDeleteDC( PDC DCToDelete )
+BOOL FASTCALL DC_InternalDeleteDC( PDC DCToDelete )
{
if( DCToDelete->DriverName )
ExFreePool(DCToDelete->DriverName);
return TRUE;
}
-HDC DC_GetNextDC (PDC pDC)
+HDC FASTCALL DC_GetNextDC (PDC pDC)
{
return pDC->hNext;
}
-void DC_SetNextDC (PDC pDC, HDC hNextDC)
+VOID FASTCALL DC_SetNextDC (PDC pDC, HDC hNextDC)
{
pDC->hNext = hNextDC;
}
-void
+VOID FASTCALL
DC_UpdateXforms(PDC dc)
{
XFORM xformWnd2Vport;
dc->w.vport2WorldValid = DC_InvertXform(&dc->w.xformWorld2Vport, &dc->w.xformVport2World);
}
-BOOL
+BOOL FASTCALL
DC_InvertXform(const XFORM *xformSrc,
XFORM *xformDest)
{
return TRUE;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: dib.c,v 1.22 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include <ntos/minmax.h>
#include <include/error.h>
#include <include/inteng.h>
+#include <include/eng.h>
+#include <include/dib.h>
#include <internal/safe.h>
+#include <include/surface.h>
#define NDEBUG
#include <win32k/debug1.h>
return hbitmap;
}
-HBITMAP DIB_CreateDIBSection(
+HBITMAP STDCALL
+DIB_CreateDIBSection(
PDC dc, BITMAPINFO *bmi, UINT usage,
LPVOID *bits, HANDLE section,
DWORD offset, DWORD ovr_pitch)
* http://www.microsoft.com/msdn/sdk/platforms/doc/sdk/win32/struc/src/str01.htm
* 11/16/1999 (RJJ) lifted from wine
*/
-int DIB_GetDIBWidthBytes(int width, int depth)
+INT FASTCALL DIB_GetDIBWidthBytes (INT width, INT depth)
{
int words;
* 11/16/1999 (RJJ) lifted from wine
*/
-int DIB_GetDIBImageBytes (int width, int height, int depth)
+INT STDCALL DIB_GetDIBImageBytes (INT width, INT height, INT depth)
{
return DIB_GetDIBWidthBytes( width, depth ) * (height < 0 ? -height : height);
}
* 11/16/1999 (RJJ) lifted from wine
*/
-int DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse)
+INT FASTCALL DIB_BitmapInfoSize (const BITMAPINFO * info, WORD coloruse)
{
int colors;
}
}
-int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, DWORD *width,
- int *height, WORD *bpp, WORD *compr )
+INT STDCALL DIB_GetBitmapInfo (const BITMAPINFOHEADER *header,
+ PDWORD width,
+ PINT height,
+ PWORD bpp,
+ PWORD compr)
{
if (header->biSize == sizeof(BITMAPINFOHEADER))
{
// Converts a Device Independent Bitmap (DIB) to a Device Dependant Bitmap (DDB)
// The specified Device Context (DC) defines what the DIB should be converted to
-PBITMAPOBJ DIBtoDDB(HGLOBAL hPackedDIB, HDC hdc) // FIXME: This should be removed. All references to this function should
+PBITMAPOBJ FASTCALL DIBtoDDB(HGLOBAL hPackedDIB, HDC hdc) // FIXME: This should be removed. All references to this function should
// change to W32kSetDIBits
{
HBITMAP hBmp = 0;
return pBmp;
}
-RGBQUAD *DIB_MapPaletteColors(PDC dc, LPBITMAPINFO lpbmi)
+RGBQUAD * FASTCALL DIB_MapPaletteColors(PDC dc, LPBITMAPINFO lpbmi)
{
RGBQUAD *lpRGB;
int nNumColors,i;
return lpRGB;
}
-PALETTEENTRY *DIBColorTableToPaletteEntries(PALETTEENTRY *palEntries, const RGBQUAD *DIBColorTable, ULONG ColorCount)
+PPALETTEENTRY STDCALL
+DIBColorTableToPaletteEntries(PPALETTEENTRY palEntries, const RGBQUAD *DIBColorTable, ULONG ColorCount)
{
ULONG i;
}
}
-HPALETTE BuildDIBPalette(BITMAPINFO *bmi, PINT paletteType)
+HPALETTE FASTCALL BuildDIBPalette (PBITMAPINFO bmi, PINT paletteType)
{
BYTE bits;
ULONG ColorCount;
return hPal;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: fillshap.c,v 1.18 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <win32k/pen.h>
#include <include/object.h>
#include <include/inteng.h>
+#include <include/path.h>
+#include <include/paint.h>
#define NDEBUG
#include <win32k/debug1.h>
UNIMPLEMENTED;
}
+#if 0
+
//ALTERNATE Selects alternate mode (fills the area between odd-numbered and even-numbered
//polygon sides on each scan line).
//When the fill mode is ALTERNATE, GDI fills the area between odd-numbered and
RECTL BoundRect,
int OrigX,
int OrigY);
+#endif
//This implementation is blatantly ripped off from W32kRectangle
BOOL
{
UNIMPLEMENTED;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
/*
* GDIOBJ.C - GDI object manipulation routines
*
- * $Id: gdiobj.c,v 1.23 2003/03/28 16:20:51 gvg Exp $
+ * $Id: gdiobj.c,v 1.24 2003/05/18 17:16:18 ea Exp $
*
*/
#include <windows.h>
#include <ddk/ntddk.h>
#include <include/dce.h>
+#include <include/object.h>
#include <win32k/gdiobj.h>
#include <win32k/brush.h>
#include <win32k/pen.h>
#include <win32k/dc.h>
#include <win32k/bitmaps.h>
#include <win32k/region.h>
+#include <include/palette.h>
#define NDEBUG
#include <win32k/debug1.h>
* Allocate GDI object table.
* \param Size - number of entries in the object table.
*/
-static PGDI_HANDLE_TABLE
+static PGDI_HANDLE_TABLE FASTCALL
GDIOBJ_iAllocHandleTable (WORD Size)
{
PGDI_HANDLE_TABLE handleTable;
/*!
* Returns the entry into the handle table by index.
*/
-static PGDI_HANDLE_ENTRY
+static PGDI_HANDLE_ENTRY FASTCALL
GDIOBJ_iGetHandleEntryForIndex (WORD TableIndex)
{
//DPRINT("GDIOBJ_iGetHandleEntryForIndex: TableIndex: %d,\n handle: %x, ptr: %x\n", TableIndex, HandleTable->Handles [TableIndex], &(HandleTable->Handles [TableIndex]) );
* Finds next free entry in the GDI handle table.
* \return index into the table is successful, zero otherwise.
*/
-static WORD
+static WORD FASTCALL
GDIOBJ_iGetNextOpenHandleIndex (void)
{
WORD tableIndex;
*
* \note Use GDIOBJ_Lock() to obtain pointer to the new object.
*/
-HGDIOBJ GDIOBJ_AllocObj(WORD Size, WORD Magic)
+HGDIOBJ FASTCALL GDIOBJ_AllocObj(WORD Size, WORD Magic)
{
PGDIOBJHDR newObject;
PGDI_HANDLE_ENTRY handleEntry;
* \note You should only use GDIOBJFLAG_IGNOREPID if you are cleaning up after the process that terminated.
* \note This function deferres object deletion if it is still in use.
*/
-BOOL GDIOBJ_FreeObj(HGDIOBJ hObj, WORD Magic, DWORD Flag)
+BOOL STDCALL GDIOBJ_FreeObj(HGDIOBJ hObj, WORD Magic, DWORD Flag)
{
PGDIOBJHDR objectHeader;
PGDI_HANDLE_ENTRY handleEntry;
*
* \todo Don't allow to lock the objects twice! Synchronization!
*/
-PGDIOBJ GDIOBJ_LockObj( HGDIOBJ hObj, WORD Magic )
+PGDIOBJ FASTCALL GDIOBJ_LockObj( HGDIOBJ hObj, WORD Magic )
{
PGDI_HANDLE_ENTRY handleEntry = GDIOBJ_iGetHandleEntryForIndex ((WORD) hObj & 0xffff);
PGDIOBJHDR objectHeader;
*
* \note this function uses an O(n^2) algoritm because we shouldn't need to call it with more than 3 or 4 objects.
*/
-BOOL GDIOBJ_LockMultipleObj( PGDIMULTILOCK pList, INT nObj )
+BOOL FASTCALL GDIOBJ_LockMultipleObj( PGDIMULTILOCK pList, INT nObj )
{
INT i, j;
ASSERT( pList );
*
* \todo Change synchronization algorithm.
*/
-BOOL GDIOBJ_UnlockObj( HGDIOBJ hObj, WORD Magic )
+BOOL FASTCALL GDIOBJ_UnlockObj( HGDIOBJ hObj, WORD Magic )
{
PGDI_HANDLE_ENTRY handleEntry = GDIOBJ_iGetHandleEntryForIndex ((WORD) hObj & 0xffff);
PGDIOBJHDR objectHeader;
*
* \note this function uses O(n^2) algoritm because we shouldn't need to call it with more than 3 or 4 objects.
*/
-BOOL GDIOBJ_UnlockMultipleObj( PGDIMULTILOCK pList, INT nObj )
+BOOL FASTCALL GDIOBJ_UnlockMultipleObj( PGDIMULTILOCK pList, INT nObj )
{
INT i, j;
ASSERT( pList );
*
* \note Only stock objects should be marked global.
*/
-VOID GDIOBJ_MarkObjectGlobal(HGDIOBJ ObjectHandle)
+VOID FASTCALL GDIOBJ_MarkObjectGlobal(HGDIOBJ ObjectHandle)
{
PGDI_HANDLE_ENTRY handleEntry;
* \param ObjectHandle - handle of the object.
* \return GDI Magic value.
*/
-WORD GDIOBJ_GetHandleMagic (HGDIOBJ ObjectHandle)
+WORD FASTCALL GDIOBJ_GetHandleMagic (HGDIOBJ ObjectHandle)
{
PGDI_HANDLE_ENTRY handleEntry;
/*!
* Initialization of the GDI object engine.
*/
-VOID
-InitGdiObjectHandleTable (void)
+VOID FASTCALL
+InitGdiObjectHandleTable (VOID)
{
DPRINT ("InitGdiObjectHandleTable\n");
ExInitializeFastMutex (&HandleTableMutex);
/*!
* Creates a bunch of stock objects: brushes, pens, fonts.
*/
-VOID CreateStockObjects(void)
+VOID FASTCALL CreateStockObjects(void)
{
// Create GDI Stock Objects from the logical structures we've defined
}
}
+/* EOF */
-
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: icm.c,v 1.6 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
UNIMPLEMENTED;
}
-
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: line.c,v 1.16 2003/05/18 17:16:18 ea Exp $ */
+
// Some code from the WINE project source (www.winehq.com)
#undef WIN32_LEAN_AND_MEAN
#include <win32k/pen.h>
#include <win32k/region.h>
#include <include/inteng.h>
+#include <include/object.h>
+#include <include/path.h>
#define NDEBUG
#include <win32k/debug1.h>
DC_ReleasePtr( hDC );
return nOldDirection;
}
+/* EOF */
-
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: metafile.c,v 1.8 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
UNIMPLEMENTED;
}
-
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: objconv.c,v 1.9 2003/05/18 17:16:18 ea Exp $ */
+
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <ddk/ntddk.h>
#include <win32k/gdiobj.h>
#include <win32k/pen.h>
#include "../eng/objects.h"
+#include <include/object.h>
+#include <include/surface.h>
#define NDEBUG
#include <win32k/debug1.h>
-PBRUSHOBJ PenToBrushObj(PDC dc, PENOBJ *pen)
+PBRUSHOBJ FASTCALL PenToBrushObj(PDC dc, PENOBJ *pen)
{
BRUSHOBJ *BrushObj;
XLATEOBJ *RGBtoVGA16;
return BrushObj;
}
-HBITMAP BitmapToSurf(PBITMAPOBJ BitmapObj)
+HBITMAP FASTCALL BitmapToSurf(PBITMAPOBJ BitmapObj)
{
HBITMAP BitmapHandle;
return BitmapHandle;
}
+/* EOF */
-
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: paint.c,v 1.9 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
DPRINT("stub");
return DCB_DISABLE; /* bounding rectangle always empty */
}
-
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: palette.c,v 1.8 2003/05/18 17:16:18 ea Exp $ */
+
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <win32k/debug.h>
#include <win32k/bitmaps.h>
#include <win32k/color.h>
#include <debug.h>
-#include "../include/palette.h"
+#include <include/palette.h>
+#include <include/object.h>
+#include <include/color.h>
static int PALETTE_firstFree = 0;
static unsigned char PALETTE_freeList[256];
int COLOR_gapFilled;
int COLOR_max;
-PALETTEENTRY *ReturnSystemPalette(void)
+PPALETTEENTRY FASTCALL ReturnSystemPalette (VOID)
{
return COLOR_sysPal;
}
// Create the system palette
-HPALETTE PALETTE_Init(void)
+HPALETTE FASTCALL PALETTE_Init(VOID)
{
int i;
HPALETTE hpalette;
return hpalette;
}
-static void PALETTE_FormatSystemPalette(void)
+static void FASTCALL PALETTE_FormatSystemPalette(void)
{
// Build free list so we'd have an easy way to find
// out if there are any available colorcells.
}
/* Ported from WINE 20020804 (graphics\x11drv\palette.c) */
-static int SysPaletteLookupPixel( COLORREF col, BOOL skipReserved )
+static int FASTCALL SysPaletteLookupPixel( COLORREF col, BOOL skipReserved )
{
int i, best = 0, diff = 0x7fffffff;
int r,g,b;
return index;
}
-void PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, int size)
+VOID FASTCALL PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, INT size)
{
int i = 0;
for( ; i<size ; i++ )
// Set the color-mapping table for selected palette.
// Return number of entries which mapping has changed.
-int PALETTE_SetMapping(PPALOBJ palPtr, UINT uStart, UINT uNum, BOOL mapOnly)
+INT STDCALL PALETTE_SetMapping(PPALOBJ palPtr, UINT uStart, UINT uNum, BOOL mapOnly)
{
char flag;
int prevMapping = (palPtr->mapping) ? 1 : 0;
/* Return the physical color closest to 'color'. */
/* Ported from WINE 20020804 (graphics\x11drv\palette.c) */
-int PALETTE_ToPhysical( PDC dc, COLORREF color )
+INT FASTCALL PALETTE_ToPhysical (PDC dc, COLORREF color)
{
WORD index = 0;
HPALETTE hPal = (dc)? dc->w.hPalette: W32kGetStockObject(DEFAULT_PALETTE);
// GDI_ReleaseObj( hPal );
return index;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: path.c,v 1.10 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <ddk/ntddk.h>
#include <win32k/float.h>
#include <win32k/coord.h>
#include <win32k/line.h>
+#define _WIN32K_PATH_INTERNAL
+#include <include/object.h>
+#include <include/path.h>
#include <math.h>
#include <float.h>
#define GROW_FACTOR_DENOM 1 /* Denominator of grow factor */
-static BOOL PATH_PathToRegion(const GdiPath *pPath, INT nPolyFillMode,
- HRGN *pHrgn);
-static void PATH_EmptyPath(GdiPath *pPath);
-static BOOL PATH_AddEntry(GdiPath *pPath, const POINT *pPoint,
- BYTE flags);
-static BOOL PATH_ReserveEntries(GdiPath *pPath, INT numEntries);
-static BOOL PATH_GetPathFromHDC(HDC hdc, GdiPath **ppPath);
-static BOOL PATH_DoArcPart(GdiPath *pPath, FLOAT_POINT corners[],
- double angleStart, double angleEnd, BOOL addMoveTo);
-static void PATH_ScaleNormalizedPoint(FLOAT_POINT corners[], double x,
- double y, POINT *pPoint);
-static void PATH_NormalizePoint(FLOAT_POINT corners[], const FLOAT_POINT
- *pPoint, double *pX, double *pY);
BOOL
STDCALL
*
* Initializes the GdiPath structure.
*/
-void PATH_InitGdiPath(GdiPath *pPath)
+VOID FASTCALL PATH_InitGdiPath(GdiPath *pPath)
{
assert(pPath!=NULL);
*
* Destroys a GdiPath structure (frees the memory in the arrays).
*/
-void PATH_DestroyGdiPath(GdiPath *pPath)
+VOID FASTCALL PATH_DestroyGdiPath(GdiPath *pPath)
{
assert(pPath!=NULL);
* not a copy constructor).
* Returns TRUE if successful, else FALSE.
*/
-BOOL PATH_AssignGdiPath(GdiPath *pPathDest, const GdiPath *pPathSrc)
+BOOL FASTCALL PATH_AssignGdiPath(GdiPath *pPathDest, const GdiPath *pPathSrc)
{
assert(pPathDest!=NULL && pPathSrc!=NULL);
* open path. This starts a new stroke. Returns TRUE if successful, else
* FALSE.
*/
-BOOL PATH_MoveTo(HDC hdc)
+BOOL FASTCALL PATH_MoveTo(HDC hdc)
{
GdiPath *pPath;
* a PT_MOVETO entry, if this is the first LineTo in a stroke).
* Returns TRUE if successful, else FALSE.
*/
-BOOL PATH_LineTo(HDC hdc, INT x, INT y)
+BOOL STDCALL PATH_LineTo(HDC hdc, INT x, INT y)
{
GdiPath *pPath;
POINT point, pointCurPos;
* Should be called when a call to Rectangle is performed on a DC that has
* an open path. Returns TRUE if successful, else FALSE.
*/
-BOOL PATH_Rectangle(HDC hdc, INT x1, INT y1, INT x2, INT y2)
+BOOL STDCALL PATH_Rectangle(HDC hdc, INT x1, INT y1, INT x2, INT y2)
{
GdiPath *pPath;
POINT corners[2], pointTemp;
* an open path. This adds four Bezier splines representing the ellipse
* to the path. Returns TRUE if successful, else FALSE.
*/
-BOOL PATH_Ellipse(HDC hdc, INT x1, INT y1, INT x2, INT y2)
+BOOL STDCALL PATH_Ellipse(HDC hdc, INT x1, INT y1, INT x2, INT y2)
{
/* TODO: This should probably be revised to call PATH_AngleArc */
/* (once it exists) */
* an open path. This adds up to five Bezier splines representing the arc
* to the path. Returns TRUE if successful, else FALSE.
*/
-BOOL PATH_Arc(HDC hdc, INT x1, INT y1, INT x2, INT y2,
+BOOL STDCALL PATH_Arc(HDC hdc, INT x1, INT y1, INT x2, INT y2,
INT xStart, INT yStart, INT xEnd, INT yEnd)
{
GdiPath *pPath;
return TRUE;
}
-BOOL PATH_PolyBezierTo(HDC hdc, const POINT *pts, DWORD cbPoints)
+BOOL STDCALL PATH_PolyBezierTo(HDC hdc, const POINT *pts, DWORD cbPoints)
{
GdiPath *pPath;
POINT pt;
return TRUE;
}
-BOOL PATH_PolyBezier(HDC hdc, const POINT *pts, DWORD cbPoints)
+BOOL STDCALL PATH_PolyBezier(HDC hdc, const POINT *pts, DWORD cbPoints)
{
GdiPath *pPath;
POINT pt;
return TRUE;
}
-BOOL PATH_Polyline(HDC hdc, const POINT *pts, DWORD cbPoints)
+BOOL STDCALL PATH_Polyline(HDC hdc, const POINT *pts, DWORD cbPoints)
{
GdiPath *pPath;
POINT pt;
return TRUE;
}
-BOOL PATH_PolylineTo(HDC hdc, const POINT *pts, DWORD cbPoints)
+BOOL STDCALL PATH_PolylineTo(HDC hdc, const POINT *pts, DWORD cbPoints)
{
GdiPath *pPath;
POINT pt;
}
-BOOL PATH_Polygon(HDC hdc, const POINT *pts, DWORD cbPoints)
+BOOL STDCALL PATH_Polygon(HDC hdc, const POINT *pts, DWORD cbPoints)
{
GdiPath *pPath;
POINT pt;
return TRUE;
}
-BOOL PATH_PolyPolygon( HDC hdc, const POINT* pts, const INT* counts,
+BOOL STDCALL PATH_PolyPolygon( HDC hdc, const POINT* pts, const INT* counts,
UINT polygons )
{
GdiPath *pPath;
return TRUE;
}
-BOOL PATH_PolyPolyline( HDC hdc, const POINT* pts, const DWORD* counts,
+BOOL STDCALL PATH_PolyPolyline( HDC hdc, const POINT* pts, const DWORD* counts,
DWORD polylines )
{
GdiPath *pPath;
/* PATH_AddFlatBezier
*
*/
-static BOOL PATH_AddFlatBezier(GdiPath *pPath, POINT *pt, BOOL closed)
+BOOL STDCALL PATH_AddFlatBezier(GdiPath *pPath, POINT *pt, BOOL closed)
{
POINT *pts;
INT no, i;
* Replaces Beziers with line segments
*
*/
-static BOOL PATH_FlattenPath(GdiPath *pPath)
+BOOL FASTCALL PATH_FlattenPath(GdiPath *pPath)
{
GdiPath newPath;
INT srcpt;
* error occurs, SetLastError is called with the appropriate value and
* FALSE is returned.
*/
-static BOOL PATH_PathToRegion(const GdiPath *pPath, INT nPolyFillMode,
+BOOL STDCALL PATH_PathToRegion(const GdiPath *pPath, INT nPolyFillMode,
HRGN *pHrgn)
{
int numStrokes, iStroke, i;
*
* Removes all entries from the path and sets the path state to PATH_Null.
*/
-static void PATH_EmptyPath(GdiPath *pPath)
+VOID STDCALL PATH_EmptyPath(GdiPath *pPath)
{
assert(pPath!=NULL);
* or PT_BEZIERTO, optionally ORed with PT_CLOSEFIGURE. Returns TRUE if
* successful, FALSE otherwise (e.g. if not enough memory was available).
*/
-BOOL PATH_AddEntry(GdiPath *pPath, const POINT *pPoint, BYTE flags)
+BOOL STDCALL PATH_AddEntry(GdiPath *pPath, const POINT *pPoint, BYTE flags)
{
assert(pPath!=NULL);
* been allocated; allocates larger arrays and copies the existing entries
* to those arrays, if necessary. Returns TRUE if successful, else FALSE.
*/
-static BOOL PATH_ReserveEntries(GdiPath *pPath, INT numEntries)
+BOOL STDCALL PATH_ReserveEntries(GdiPath *pPath, INT numEntries)
{
INT numEntriesToAllocate;
POINT *pPointsNew;
* Retrieves a pointer to the GdiPath structure contained in an HDC and
* places it in *ppPath. TRUE is returned if successful, FALSE otherwise.
*/
-static BOOL PATH_GetPathFromHDC(HDC hdc, GdiPath **ppPath)
+BOOL FASTCALL PATH_GetPathFromHDC(HDC hdc, GdiPath **ppPath)
{
DC *pDC;
* point is added to the path; otherwise, it is assumed that the current
* position is equal to the first control point.
*/
-static BOOL PATH_DoArcPart(GdiPath *pPath, FLOAT_POINT corners[],
+BOOL STDCALL PATH_DoArcPart(GdiPath *pPath, FLOAT_POINT corners[],
double angleStart, double angleEnd, BOOL addMoveTo)
{
double halfAngle, a;
* coordinates (-1.0, -1.0) correspond to corners[0], the coordinates
* (1.0, 1.0) correspond to corners[1].
*/
-static void PATH_ScaleNormalizedPoint(FLOAT_POINT corners[], double x,
+VOID STDCALL PATH_ScaleNormalizedPoint(FLOAT_POINT corners[], double x,
double y, POINT *pPoint)
{
pPoint->x=GDI_ROUND( (double)corners[0].x + (double)(corners[1].x-corners[0].x)*0.5*(x+1.0) );
* Normalizes a point with respect to the box whose corners are passed in
* corners. The normalized coordinates are stored in *pX and *pY.
*/
-static void PATH_NormalizePoint(FLOAT_POINT corners[],
+VOID STDCALL PATH_NormalizePoint(FLOAT_POINT corners[],
const FLOAT_POINT *pPoint,
double *pX, double *pY)
{
*pX=(double)(pPoint->x-corners[0].x)/(double)(corners[1].x-corners[0].x) * 2.0 - 1.0;
*pY=(double)(pPoint->y-corners[0].y)/(double)(corners[1].y-corners[0].y) * 2.0 - 1.0;
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: pen.c,v 1.10 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <ddk/ntddk.h>
{
UNIMPLEMENTED;
}
+/* EOF */
/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: polyfill.c,v 1.3 2003/05/18 17:16:18 ea Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Various Polygon Filling routines for Polygon()
#include <win32k/dc.h>
#include <win32k/pen.h>
#include <include/object.h>
+#include <include/paint.h>
#define NDEBUG
#include <win32k/debug1.h>
/*
** Hide memory clean up.
*/
-static void POLYGONFILL_DestroyEdge(PPFILL_EDGE pEdge)
+static void FASTCALL POLYGONFILL_DestroyEdge(PPFILL_EDGE pEdge)
{
if (0 != pEdge)
EngFreeMem(pEdge);
/*
** Clean up a list.
*/
-static void POLYGONFILL_DestroyEdgeList(PFILL_EDGE_LIST list)
+static void FASTCALL POLYGONFILL_DestroyEdgeList(PFILL_EDGE_LIST list)
{
PPFILL_EDGE pThis = 0;
PPFILL_EDGE pNext = 0;
/*
** This makes and initiaizes an Edge struct for a line between two points.
*/
-static PPFILL_EDGE POLYGONFILL_MakeEdge(POINT From, POINT To)
+static PPFILL_EDGE FASTCALL POLYGONFILL_MakeEdge(POINT From, POINT To)
{
PPFILL_EDGE rc = (PPFILL_EDGE)EngAllocMem(FL_ZERO_MEMORY, sizeof(PFILL_EDGE), PFILL_EDGE_ALLOC_TAG);
** Zero element1 = element2
** Positive integer element1 > element2
*/
-static INT PFILL_EDGE_Compare(PPFILL_EDGE Edge1, PPFILL_EDGE Edge2)
+static INT FASTCALL PFILL_EDGE_Compare(PPFILL_EDGE Edge1, PPFILL_EDGE Edge2)
{
//DPRINT("In PFILL_EDGE_Compare()\n");
if (Edge1->MinY == Edge2->MinY)
/*
** Insert an edge into a list keeping the list in order.
*/
-static void POLYGONFILL_ListInsert(PFILL_EDGE_LIST *list, PPFILL_EDGE NewEdge)
+static void FASTCALL POLYGONFILL_ListInsert(PFILL_EDGE_LIST *list, PPFILL_EDGE NewEdge)
{
PPFILL_EDGE pThis;
if (0 != list && 0 != NewEdge)
/*
** Create a list of edges for a list of points.
*/
-static PFILL_EDGE_LIST POLYGONFILL_MakeEdgeList(PPOINT Points, int Count)
+static PFILL_EDGE_LIST FASTCALL POLYGONFILL_MakeEdgeList(PPOINT Points, int Count)
{
int CurPt = 0;
int SeqNum = 0;
** for scanline Scanline.
**TODO: Get rid of this floating point arithmetic
*/
-static void POLYGONFILL_UpdateScanline(PPFILL_EDGE pEdge, int Scanline)
+static void FASTCALL POLYGONFILL_UpdateScanline(PPFILL_EDGE pEdge, int Scanline)
{
int Coord = 0;
**
** Note: once an edge is no longer active, it is deleted.
*/
-static void POLYGONFILL_AECInsertInOrder(PFILL_EDGE_LIST *list, PPFILL_EDGE pEdge)
+static void FASTCALL POLYGONFILL_AECInsertInOrder(PFILL_EDGE_LIST *list, PPFILL_EDGE pEdge)
{
BOOL Done = FALSE;
PPFILL_EDGE pThis = 0;
** This routine reorders the Active Edge collection (list) after all
** the now inactive edges have been removed.
*/
-static void POLYGONFILL_AECReorder(PFILL_EDGE_LIST *AEC)
+static void FASTCALL POLYGONFILL_AECReorder(PFILL_EDGE_LIST *AEC)
{
PPFILL_EDGE pThis = 0;
PPFILL_EDGE pPrev = 0;
/*
** This method updates the Active edge collection for the scanline Scanline.
*/
-static void POLYGONFILL_UpdateActiveEdges(int Scanline, PFILL_EDGE_LIST *GEC, PFILL_EDGE_LIST *AEC)
+static void STDCALL POLYGONFILL_UpdateActiveEdges(int Scanline, PFILL_EDGE_LIST *GEC, PFILL_EDGE_LIST *AEC)
{
PPFILL_EDGE pThis = 0;
PPFILL_EDGE pAECLast = 0;
** This method fills the portion of the polygon that intersects with the scanline
** Scanline.
*/
-static void POLYGONFILL_FillScanLine(int ScanLine, PFILL_EDGE_LIST ActiveEdges, SURFOBJ *SurfObj, PBRUSHOBJ BrushObj, MIX RopMode, int OrigX, int OrigY)
+static void STDCALL POLYGONFILL_FillScanLine(int ScanLine, PFILL_EDGE_LIST ActiveEdges, SURFOBJ *SurfObj, PBRUSHOBJ BrushObj, MIX RopMode, int OrigX, int OrigY)
{
BOOL OnOdd = TRUE;
RECTL BoundRect;
//When the fill mode is ALTERNATE, GDI fills the area between odd-numbered and
//even-numbered polygon sides on each scan line. That is, GDI fills the area between the
//first and second side, between the third and fourth side, and so on.
-BOOL FillPolygon_ALTERNATE(SURFOBJ *SurfObj, PBRUSHOBJ BrushObj, MIX RopMode, CONST PPOINT Points, int Count, RECTL BoundRect, int OrigX, int OrigY)
+BOOL STDCALL FillPolygon_ALTERNATE(SURFOBJ *SurfObj, PBRUSHOBJ BrushObj, MIX RopMode, CONST PPOINT Points, int Count, RECTL BoundRect, int OrigX, int OrigY)
{
PFILL_EDGE_LIST list = 0;
PFILL_EDGE_LIST ActiveEdges = 0;
//When the fill mode is WINDING, GDI fills any region that has a nonzero winding value.
//This value is defined as the number of times a pen used to draw the polygon would go around the region.
//The direction of each edge of the polygon is important.
-BOOL FillPolygon_WINDING(SURFOBJ *SurfObj, PBRUSHOBJ BrushObj,MIX RopMode, CONST PPOINT Points, int Count, RECTL BoundRect, int OrigX, int OrigY)
+BOOL STDCALL FillPolygon_WINDING(SURFOBJ *SurfObj, PBRUSHOBJ BrushObj,MIX RopMode, CONST PPOINT Points, int Count, RECTL BoundRect, int OrigX, int OrigY)
{
DPRINT("FillPolygon_WINDING\n");
return FALSE;
-}
\ No newline at end of file
+}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: print.c,v 1.9 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <ddk/ntddk.h>
{
UNIMPLEMENTED;
}
-
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: rect.c,v 1.4 2003/05/18 17:16:18 ea Exp $ */
#include <windows.h>
#include <ddk/ntddk.h>
#include <win32k/region.h>
/* FUNCTIONS *****************************************************************/
-BOOL
+BOOL STDCALL
W32kOffsetRect(LPRECT Rect, INT x, INT y)
{
Rect->left += x;
Dest->bottom = min(Src1->bottom, Src2->bottom);
return(TRUE);
}
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: region.c,v 1.23 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <ddk/ntddk.h>
#include <win32k/cliprgn.h>
#include <win32k/brush.h>
#include <include/rect.h>
+#include <include/object.h>
+#include <include/inteng.h>
#define NDEBUG
struct _POINTBLOCK *next;
} POINTBLOCK;
-static BOOL REGION_CopyRegion(PROSRGNDATA dst, PROSRGNDATA src)
+static BOOL FASTCALL REGION_CopyRegion(PROSRGNDATA dst, PROSRGNDATA src)
{
if(dst != src) // don't want to copy to itself
{
return TRUE;
}
-static void REGION_SetExtents (ROSRGNDATA *pReg)
+static void FASTCALL REGION_SetExtents (ROSRGNDATA *pReg)
{
RECT *pRect, *pRectEnd, *pExtents;
/***********************************************************************
* REGION_CropAndOffsetRegion
*/
-static BOOL REGION_CropAndOffsetRegion(const PPOINT off, const PRECT rect, PROSRGNDATA rgnSrc, PROSRGNDATA rgnDst)
+static BOOL STDCALL REGION_CropAndOffsetRegion(const PPOINT off, const PRECT rect, PROSRGNDATA rgnSrc, PROSRGNDATA rgnDst)
{
if(!rect) // just copy and offset
{
*
* \return hDst if success, 0 otherwise.
*/
-HRGN REGION_CropRgn(HRGN hDst, HRGN hSrc, const PRECT lpRect, PPOINT lpPt)
+HRGN STDCALL REGION_CropRgn(HRGN hDst, HRGN hSrc, const PRECT lpRect, PPOINT lpPt)
{
PROSRGNDATA objSrc, rgnDst;
HRGN hNewDst, hRet = NULL;
Lock[0].hObj = hNewDst;
}
- GDIOBJ_LockMultipleObj( &Lock, 2 );
+ GDIOBJ_LockMultipleObj( Lock, 2 );
rgnDst = Lock[0].pObj;
objSrc = Lock[1].pObj;
}
}
}
- GDIOBJ_UnlockMultipleObj( &Lock, 2 );
+ GDIOBJ_UnlockMultipleObj( Lock, 2 );
return hRet;
}
* - pReg->numRects will be decreased.
*
*/
-static INT REGION_Coalesce (
+static INT STDCALL REGION_Coalesce (
PROSRGNDATA pReg, /* Region to coalesce */
INT prevStart, /* Index of start of previous band */
INT curStart /* Index of start of current band */
* to reduce the number of rectangles in the region.
*
*/
-static void REGION_RegionOp(
+static void STDCALL REGION_RegionOp(
ROSRGNDATA *newReg, /* Place to store result */
ROSRGNDATA *reg1, /* First region in operation */
ROSRGNDATA *reg2, /* 2nd region in operation */
* Rectangles may be added to the region.
*
*/
-static void REGION_IntersectO(ROSRGNDATA *pReg, RECT *r1, RECT *r1End,
+static void STDCALL REGION_IntersectO(ROSRGNDATA *pReg, RECT *r1, RECT *r1End,
RECT *r2, RECT *r2End, INT top, INT bottom)
{
*/
if (left < right)
{
- MEMCHECK(pReg, pNextRect, pReg->Buffer);
+ MEMCHECK(pReg, *(LPRECT*)pNextRect, *(LPRECT*)pReg->Buffer);
pNextRect->left = left;
pNextRect->top = top;
pNextRect->right = right;
/***********************************************************************
* REGION_IntersectRegion
*/
-static void REGION_IntersectRegion(ROSRGNDATA *newReg, ROSRGNDATA *reg1,
+static void STDCALL REGION_IntersectRegion(ROSRGNDATA *newReg, ROSRGNDATA *reg1,
ROSRGNDATA *reg2)
{
/* check for trivial reject */
* with the rectangles we're passed.
*
*/
-static void REGION_UnionNonO (ROSRGNDATA *pReg, RECT *r, RECT *rEnd,
+static void STDCALL REGION_UnionNonO (ROSRGNDATA *pReg, RECT *r, RECT *rEnd,
INT top, INT bottom)
{
RECT *pNextRect;
while (r != rEnd)
{
- MEMCHECK(pReg, pNextRect, pReg->Buffer);
+ MEMCHECK(pReg, *(LPRECT*)pNextRect, *(LPRECT*)pReg->Buffer);
pNextRect->left = r->left;
pNextRect->top = top;
pNextRect->right = r->right;
* be changed.
*
*/
-static void REGION_UnionO (ROSRGNDATA *pReg, RECT *r1, RECT *r1End,
+static void STDCALL REGION_UnionO (ROSRGNDATA *pReg, RECT *r1, RECT *r1End,
RECT *r2, RECT *r2End, INT top, INT bottom)
{
RECT *pNextRect;
/***********************************************************************
* REGION_UnionRegion
*/
-static void REGION_UnionRegion(ROSRGNDATA *newReg, ROSRGNDATA *reg1,
+static void STDCALL REGION_UnionRegion(ROSRGNDATA *newReg, ROSRGNDATA *reg1,
ROSRGNDATA *reg2)
{
/* checks all the simple cases */
* pReg may be affected.
*
*/
-static void REGION_SubtractNonO1 (ROSRGNDATA *pReg, RECT *r, RECT *rEnd,
+static void STDCALL REGION_SubtractNonO1 (ROSRGNDATA *pReg, RECT *r, RECT *rEnd,
INT top, INT bottom)
{
RECT *pNextRect;
* pReg may have rectangles added to it.
*
*/
-static void REGION_SubtractO (ROSRGNDATA *pReg, RECT *r1, RECT *r1End,
+static void STDCALL REGION_SubtractO (ROSRGNDATA *pReg, RECT *r1, RECT *r1End,
RECT *r2, RECT *r2End, INT top, INT bottom)
{
RECT *pNextRect;
* regD is overwritten.
*
*/
-static void REGION_SubtractRegion(ROSRGNDATA *regD, ROSRGNDATA *regM,
+static void STDCALL REGION_SubtractRegion(ROSRGNDATA *regD, ROSRGNDATA *regM,
ROSRGNDATA *regS )
{
/* check for trivial reject */
/***********************************************************************
* REGION_XorRegion
*/
-static void REGION_XorRegion(ROSRGNDATA *dr, ROSRGNDATA *sra,
+static void STDCALL REGION_XorRegion(ROSRGNDATA *dr, ROSRGNDATA *sra,
ROSRGNDATA *srb)
{
HRGN htra, htrb;
/*!
* Adds a rectangle to a REGION
*/
-static void REGION_UnionRectWithRegion(const RECT *rect, ROSRGNDATA *rgn)
+static void FASTCALL REGION_UnionRectWithRegion(const RECT *rect, ROSRGNDATA *rgn)
{
ROSRGNDATA region;
}
-BOOL REGION_LPTODP(HDC hdc, HRGN hDest, HRGN hSrc)
+BOOL STDCALL REGION_LPTODP(HDC hdc, HRGN hDest, HRGN hSrc)
{
RECT *pCurRect, *pEndRect;
PROSRGNDATA srcObj = NULL;
return ret;
}
-HRGN RGNDATA_AllocRgn(INT n)
+HRGN FASTCALL RGNDATA_AllocRgn(INT n)
{
HRGN hReg;
PROSRGNDATA pReg;
return NULL;
}
-BOOL RGNDATA_InternalDelete( PROSRGNDATA pRgn )
+BOOL FASTCALL RGNDATA_InternalDelete( PROSRGNDATA pRgn )
{
ASSERT(pRgn);
if(pRgn->Buffer)
W32kPaintRgn(HDC hDC,
HRGN hRgn)
{
- RECT box;
- HRGN tmpVisRgn, prevVisRgn;
+ //RECT box;
+ HRGN tmpVisRgn; //, prevVisRgn;
DC *dc = DC_HandleToPtr(hDC);
PROSRGNDATA visrgn;
CLIPOBJ* ClipRegion;
ASSERT(pBrush);
BrushOrigin.x = dc->w.brushOrgX;
BrushOrigin.y = dc->w.brushOrgY;
- SurfObj = (SURFOBJ*)AccessUserObject(dc->Surface);
+ SurfObj = (SURFOBJ*)AccessUserObject((ULONG)dc->Surface);
bRet = IntEngPaint(SurfObj,
ClipRegion,
pBrush,
&BrushOrigin,
- 0xFFFF);//don't know what to put here
+ 0xFFFF);//FIXME:don't know what to put here
RGNDATA_UnlockRgn( tmpVisRgn );
PRECT pRect;
PROSRGNDATA pRgn;
- if( !NT_SUCCESS( MmCopyFromCaller( pRect, unsafeRect, sizeof( RECT ) ) ) )
+ if( !NT_SUCCESS( MmCopyFromCaller( pRect, (PRECT)unsafeRect, sizeof( RECT ) ) ) )
return NULL;
if( !(pRgn = RGNDATA_LockRgn( hDest ) ) )
RGNDATA_UnlockRgn( hrgn );
return size + sizeof(RGNDATAHEADER);
}
-
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: text.c,v 1.32 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include "../eng/handle.h"
#include <include/inteng.h>
+#include <include/text.h>
+#include <include/eng.h>
#define NDEBUG
#include <win32k/debug1.h>
FONTTABLE FontTable[256];
INT FontsLoaded = 0;
-BOOL InitFontSupport()
+BOOL FASTCALL InitFontSupport(VOID)
{
ULONG error;
UINT File;
return TRUE;
}
-static NTSTATUS
+static NTSTATUS STDCALL
GetFontObjectsFromTextObj(PTEXTOBJ TextObj, HFONT *FontHandle, PFONTOBJ *FontObj, PFONTGDI *FontGDI)
{
NTSTATUS Status = STATUS_SUCCESS;
return 1;
}
-NTSTATUS
+NTSTATUS FASTCALL
TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont)
{
PTEXTOBJ TextObj;
UNIMPLEMENTED;
}
-NTSTATUS
+NTSTATUS FASTCALL
TextIntRealizeFont(HFONT FontHandle)
{
UINT i;
return Status;
}
+
+/* EOF */
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: wingl.c,v 1.6 2003/05/18 17:16:18 ea Exp $ */
#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
UNIMPLEMENTED;
}
-
+/* EOF */