*/
#include <win32k.h>
-#include "math.h"
+#define _USE_MATH_DEFINES
+#include <math.h>
#define NDEBUG
#include <debug.h>
pPath = PATH_LockPath( hPath );
if (!pPath) return FALSE;
PATH_DestroyGdiPath( pPath );
- PATH_UnlockPath( pPath );
- PATH_FreeExtPathByHandle(hPath);
+ GDIOBJ_vDeleteObject(&pPath->BaseObject);
return TRUE;
}
if( pPath->state != PATH_Closed )
{
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
return FALSE;
}
pNumPointsInStroke = ExAllocatePoolWithTag(PagedPool, sizeof(ULONG) * numStrokes, TAG_PATH);
if(!pNumPointsInStroke)
{
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
nPolyFillMode);
if(hrgn==(HRGN)0)
{
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
if(!pLinePts)
{
DPRINT1("Can't allocate pool!\n");
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto end;
}
nLinePts = 0;
if(pPath->state == PATH_Open)
{
PATH_UnlockPath( pPath );
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
return FALSE;
}
PATH_FlattenPath(pPath);
- size = IntGdiGetObject( pdcattr->hpen, 0, NULL);
+ size = GreGetObject( pdcattr->hpen, 0, NULL);
if (!size)
{
PATH_UnlockPath( pPath );
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
return FALSE;
}
elp = ExAllocatePoolWithTag(PagedPool, size, TAG_PATH);
- (VOID) IntGdiGetObject( pdcattr->hpen, size, elp);
+ GreGetObject(pdcattr->hpen, size, elp);
- obj_type = GDIOBJ_GetObjectType(pdcattr->hpen);
+ obj_type = GDI_HANDLE_GET_TYPE(pdcattr->hpen);
if(obj_type == GDI_OBJECT_TYPE_PEN)
{
penStyle = ((LOGPEN*)elp)->lopnStyle;
}
else
{
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
ExFreePoolWithTag(elp, TAG_PATH);
PATH_UnlockPath( pPath );
return FALSE;
if(obj_type == GDI_OBJECT_TYPE_EXTPEN && penType == PS_COSMETIC)
{
PATH_UnlockPath( pPath );
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
return FALSE;
}
PATH_DestroyGdiPath(pDownPath);
ExFreePoolWithTag(pDownPath, TAG_PATH);
}
- ExFreePoolWithTag(pStrokes, TAG_PATH);
+ if (pStrokes) ExFreePoolWithTag(pStrokes, TAG_PATH);
pNewPath->state = PATH_Closed;
if (!(ret = PATH_AssignGdiPath(pPath, pNewPath)))
DPRINT1("Assign path failed\n");
PATH_DestroyGdiPath(pNewPath);
ExFreePoolWithTag(pNewPath, TAG_PATH);
+ PATH_UnlockPath(pPath);
return ret;
}
if ( !TextObj ) return FALSE;
FontGetObject( TextObj, sizeof(lf), &lf);
+ TEXTOBJ_UnlockText(TextObj);
if (lf.lfEscapement != 0)
{
sinEsc = 0;
}
- IntGdiGetDCOrg(dc, &org);
+ org = dc->ptlDCOrig;
for (idx = 0; idx < count; idx++)
{
PDC dc = DC_LockDc ( hDC );
if ( !dc )
{
- SetLastWin32Error(ERROR_INVALID_HANDLE);
+ EngSetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
pPath = PATH_LockPath(dc->dclevel.hPath);
+ if (!pPath)
{
DC_UnlockDc(dc);
return FALSE;
PATH_EmptyPath(pPath);
PATH_UnlockPath(pPath);
+ dc->dclevel.flPath &= ~DCPATH_ACTIVE;
+
DC_UnlockDc ( dc );
return TRUE;
}
dc = DC_LockDc ( hDC );
if ( !dc )
{
- SetLastWin32Error(ERROR_INVALID_HANDLE);
+ EngSetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
if ( dc->dclevel.hPath )
{
- DPRINT1("BeginPath 1 0x%x\n", dc->dclevel.hPath);
+ DPRINT("BeginPath 1 0x%x\n", dc->dclevel.hPath);
if ( !(dc->dclevel.flPath & DCPATH_SAVE) )
{ // Remove previous handle.
if (!PATH_Delete(dc->dclevel.hPath))
pPath = PATH_AllocPathWithHandle();
if (!pPath)
{
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
dc->dclevel.flPath |= DCPATH_ACTIVE; // Set active ASAP!
dc->dclevel.hPath = pPath->BaseObject.hHmgr;
- DPRINT1("BeginPath 2 h 0x%x p 0x%x\n", dc->dclevel.hPath, pPath);
+ DPRINT("BeginPath 2 h 0x%x p 0x%x\n", dc->dclevel.hPath, pPath);
// Path handles are shared. Also due to recursion with in the same thread.
- GDIOBJ_UnlockObjByPtr((POBJ)pPath); // Unlock
+ GDIOBJ_vUnlockObject((POBJ)pPath); // Unlock
pPath = PATH_LockPath(dc->dclevel.hPath); // Share Lock.
/* Make sure that path is empty */
pDc = DC_LockDc(hDC);
if (!pDc)
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pPath = PATH_LockPath( pDc->dclevel.hPath );
else
{
// FIXME: check if lasterror is set correctly
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
}
PATH_UnlockPath( pPath );
if ( !dc )
{
- SetLastWin32Error(ERROR_INVALID_HANDLE);
+ EngSetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
if ( (pPath->state != PATH_Open) || !(dc->dclevel.flPath & DCPATH_ACTIVE) )
{
DPRINT1("EndPath ERROR! 0x%x\n", dc->dclevel.hPath);
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
ret = FALSE;
}
/* Set flag to indicate that path is finished */
else
{
- DPRINT1("EndPath 0x%x\n", dc->dclevel.hPath);
+ DPRINT("EndPath 0x%x\n", dc->dclevel.hPath);
pPath->state = PATH_Closed;
dc->dclevel.flPath &= ~DCPATH_ACTIVE;
}
BOOL ret = FALSE;
PPATH pPath;
PDC_ATTR pdcattr;
- PDC dc = DC_LockDc ( hDC );
+ PDC dc;
- if ( !dc )
+ dc = DC_LockDc(hDC);
+ if (!dc)
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
+
pPath = PATH_LockPath( dc->dclevel.hPath );
if (!pPath)
{
pDc = DC_LockDc(hDC);
if (!pDc)
{
- SetLastWin32Error(ERROR_INVALID_HANDLE);
+ EngSetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
if (!(pDc = DC_LockDc(hdc)))
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!dc)
{
DPRINT1("Can't lock dc!\n");
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return -1;
}
if (pPath->state != PATH_Closed)
{
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
goto done;
}
}
else if(nSize<pPath->numEntriesUsed)
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
else
pDc = DC_LockDc(hDC);
if (!pDc)
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
if (pPath->state!=PATH_Closed)
{
//FIXME: check that setlasterror is being called correctly
- SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
+ EngSetLastError(ERROR_CAN_NOT_COMPLETE);
}
else
{
if (!(pDc = DC_LockDc(hdc)))
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (!(pDc = DC_LockDc(hDC)))
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pPath = PATH_LockPath( pDc->dclevel.hPath );
if (!(pDc = DC_LockDc(hDC)))
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pPath = PATH_LockPath( pDc->dclevel.hPath );
PDC pdc = DC_LockDc ( hDC );
if ( !pdc )
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
Ret = PATH_WidenPath(pdc);